{ "nbformat": 4, "nbformat_minor": 5, "metadata": { "accelerator": "GPU", "colab": { "gpuType": "T4", "provenance": [] }, "kernelspec": { "display_name": "Python 3", "language": "python", "name": "python3" }, "language_info": { "name": "python", "version": "3.11" } }, "cells": [ { "cell_type": "markdown", "id": "10-setup-hdr", "metadata": { "id": "10-setup-hdr" }, "source": [ "# 1.0 \u2014 Setup & Imports\n", "\n", "Mount Google Drive when running in Colab, import all dependencies, fix random seeds,\n", "declare project paths, and set global training hyperparameters." ] }, { "cell_type": "markdown", "id": "11-imports-hdr", "metadata": { "id": "11-imports-hdr" }, "source": [ "## 1.1 \u2014 Library Imports & Environment\n", "\n", "Standard-library \u2192 third-party \u2192 deep-learning imports, then Colab Drive mount and\n", "global random-seed fixation so experiments are reproducible." ] }, { "cell_type": "code", "execution_count": 1, "id": "11-imports-code", "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "11-imports-code", "executionInfo": { "status": "ok", "timestamp": 1779943323570, "user_tz": -330, "elapsed": 34681, "user": { "displayName": "Big Story", "userId": "07276682490797804347" } }, "outputId": "551804e5-3f1e-4172-ca63-759665ef6b8f" }, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "Mounted at /content/drive\n" ] } ], "source": [ "import os\n", "import sys\n", "import io\n", "import json\n", "import math\n", "import gc\n", "import random\n", "import shutil\n", "import time\n", "import glob\n", "from pathlib import Path\n", "\n", "# \u2500\u2500 Colab: mount Drive if running inside Google Colab \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", "if 'google.colab' in sys.modules:\n", " try:\n", " from google.colab import drive\n", " drive.mount(\"/content/drive\", force_remount=False)\n", " IN_COLAB = True\n", " except Exception as e:\n", " print(f\"Colab drive note: {e}\")\n", " IN_COLAB = False\n", "else:\n", " IN_COLAB = False\n", "\n", "# \u2500\u2500 Third-party \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", "import numpy as np\n", "import pandas as pd\n", "import seaborn as sns\n", "import matplotlib.pyplot as plt\n", "from matplotlib import gridspec\n", "from openpyxl import Workbook, load_workbook\n", "from openpyxl.drawing.image import Image as XLImage\n", "from openpyxl.utils.dataframe import dataframe_to_rows\n", "from sklearn.model_selection import train_test_split\n", "from sklearn.metrics import confusion_matrix, accuracy_score, cohen_kappa_score, classification_report\n", "\n", "# \u2500\u2500 TensorFlow / Keras \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", "import tensorflow as tf\n", "import tensorflow_probability as tfp\n", "from tensorflow import keras\n", "from tensorflow.keras import backend as K, Sequential, layers, activations, optimizers\n", "from tensorflow.keras.layers import (\n", " Input, Add, Multiply, Reshape, Dense, Activation, BatchNormalization,\n", " Flatten, Dropout, concatenate, Lambda,\n", ")\n", "from tensorflow.keras.layers import (\n", " Conv2D, AveragePooling2D, MaxPooling2D, GlobalAveragePooling2D,\n", " GlobalAvgPool2D, DepthwiseConv2D, SeparableConv2D, MaxPool2D, UpSampling2D,\n", ")\n", "from tensorflow.keras.layers import (\n", " Conv2DTranspose, add, multiply, LayerNormalization,\n", ")\n", "from tensorflow.python.util.tf_export import keras_export\n", "from tensorflow.python.ops import array_ops\n", "from tensorflow.python.keras.utils import control_flow_util\n", "from tensorflow.keras.callbacks import ModelCheckpoint\n", "from tensorflow.keras.models import load_model, Model\n", "from tensorflow.keras.utils import plot_model\n", "from keras.regularizers import l2\n", "\n", "# \u2500\u2500 Global styling & reproducibility seeds \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", "sns.set()\n", "np.random.seed(1337)\n", "random.seed(1337)\n", "tf.random.set_seed(1337)\n" ] }, { "cell_type": "markdown", "id": "12-paths-hdr", "metadata": { "id": "12-paths-hdr" }, "source": [ "## 1.2 \u2014 Project Paths & Training Hyperparameters\n", "\n", "Resolve the project root on Drive, create output directories, and define all\n", "training constants (patch size, epoch count, batch size, dropout, image dimensions)." ] }, { "cell_type": "code", "execution_count": 2, "id": "12-paths-code", "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "12-paths-code", "executionInfo": { "status": "ok", "timestamp": 1779943324178, "user_tz": -330, "elapsed": 604, "user": { "displayName": "Big Story", "userId": "07276682490797804347" } }, "outputId": "9a431333-b737-4032-901f-2b81633a424c" }, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "Project root: /content/drive/My Drive/Classification\n", "Data file: /content/drive/My Drive/Classification/data/data.csv\n", "Training workbook: /content/drive/My Drive/Classification/multicp/models/model_training_multihead_results.xlsx\n" ] } ], "source": [ "IN_KAGGLE = Path('/kaggle').exists()\n", "IN_COLAB = 'google.colab' in sys.modules\n", "\n", "if IN_KAGGLE:\n", " PROJECT_ROOT = Path('/kaggle/working/Classification')\n", " SAVED_MODEL_DIR = PROJECT_ROOT / 'multicp' / 'models'\n", " TRAINING_RESULTS_DIR = SAVED_MODEL_DIR / 'training_results'\n", "elif IN_COLAB:\n", " PROJECT_ROOT = Path('/content/drive/My Drive/Classification')\n", " SAVED_MODEL_DIR = PROJECT_ROOT / 'multicp' / 'models'\n", " TRAINING_RESULTS_DIR = SAVED_MODEL_DIR / 'training_results'\n", "else:\n", " PROJECT_ROOT = Path('.')\n", " SAVED_MODEL_DIR = Path('multicp/models')\n", " TRAINING_RESULTS_DIR = SAVED_MODEL_DIR / 'training_results'\n", "\n", "SAVED_MODEL_DIR.mkdir(parents=True, exist_ok=True)\n", "TRAINING_RESULTS_DIR.mkdir(parents=True, exist_ok=True)\n", "TRAINING_WORKBOOK = SAVED_MODEL_DIR / 'model_training_multihead_results.xlsx'\n", "MODEL_REGISTRY_PATH = SAVED_MODEL_DIR / 'model_registry_multihead.json'\n", "\n", "_data_matches = (\n", " glob.glob('/kaggle/input/**/k001.csv', recursive=True)\n", " or glob.glob('/kaggle/input/**/data.csv', recursive=True)\n", " or glob.glob('Classification/data/data.csv')\n", " or glob.glob('../data/data.csv')\n", " or glob.glob('../../Classification/data/data.csv')\n", " or glob.glob('/content/drive/My Drive/Classification/data/data.csv')\n", " or glob.glob('data.csv')\n", ")\n", "_ref_matches = (\n", " glob.glob('/kaggle/input/**/k002.csv', recursive=True)\n", " or glob.glob('/kaggle/input/**/ref.csv', recursive=True)\n", " or glob.glob('Classification/data/ref.csv')\n", " or glob.glob('../data/ref.csv')\n", " or glob.glob('../../Classification/data/ref.csv')\n", " or glob.glob('/content/drive/My Drive/Classification/data/ref.csv')\n", " or glob.glob('ref.csv')\n", ")\n", "\n", "DATA_FILE = Path(_data_matches[0]) if _data_matches else Path('data.csv')\n", "LABEL_FILE = Path(_ref_matches[0]) if _ref_matches else Path('ref.csv')\n", "\n", "# \u2500\u2500 Global training hyperparameters \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", "Data_to_use = '6_bands'\n", "use_pearson_corr = False\n", "P_S = 9 # patch size (pixels)\n", "Targeted_accuracy = 0.985\n", "Min_trainable_epoch = 20\n", "train_percent = 75\n", "epoch = 100\n", "BATCH_SIZE = 128\n", "dropout_rate = 0.25\n", "shifts = int(1 / dropout_rate) # number of staged-dropout shifts = 4\n", "H, W, B = 330, 307, 6 # image height, width, spectral bands\n", "\n", "# \u2500\u2500 Legacy string path (used by some save helpers) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", "folder_path = str(TRAINING_RESULTS_DIR) + os.sep\n", "os.makedirs(os.path.join(folder_path, 'Results'), exist_ok=True)\n", "os.makedirs(os.path.join(folder_path, 'Trained models'), exist_ok=True)\n", "\n", "print('Project root: ', PROJECT_ROOT)\n", "print('Data file: ', DATA_FILE)\n", "print('Label file: ', LABEL_FILE)\n", "print('Training workbook:', TRAINING_WORKBOOK)\n" ] }, { "cell_type": "markdown", "id": "20-data-hdr", "metadata": { "id": "20-data-hdr" }, "source": [ "# 2.0 \u2014 Data Loading & Patch Preparation\n", "\n", "Load multispectral data and reference labels, per-band min-max normalise the image,\n", "extract labeled spatial patches, visualise class balance, and produce the\n", "stratified train/test split." ] }, { "cell_type": "markdown", "id": "21-load-hdr", "metadata": { "id": "21-load-hdr" }, "source": [ "## 2.1 \u2014 Load & Normalise\n", "\n", "Read data (H\u00d7W\u00d7B) and labels (H\u00d7W) from CSV.\n", "Each spectral band is independently normalised to [0, 1]." ] }, { "cell_type": "code", "execution_count": 3, "id": "21-load-code", "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "21-load-code", "executionInfo": { "status": "ok", "timestamp": 1779943325065, "user_tz": -330, "elapsed": 885, "user": { "displayName": "Big Story", "userId": "07276682490797804347" } }, "outputId": "433b04f2-1593-49a7-9bcc-f9aae27aac36" }, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "shape of x: (330, 307, 6)\n", "shape of y: (330, 307)\n" ] } ], "source": [ "x = pd.read_csv(DATA_FILE).to_numpy(dtype=np.float32).reshape(H, W, B)\n", "y = pd.read_csv(LABEL_FILE).to_numpy(dtype=np.int32).reshape(H, W)\n", "\n", "# Per-band min-max normalisation; epsilon guard prevents divide-by-zero\n", "for band_idx in range(B): # renamed b \u2192 band_idx (single-letter variable)\n", " band = x[:, :, band_idx]\n", " denom = max(float(np.max(band) - np.min(band)), 1e-8)\n", " x[:, :, band_idx] = (band - np.min(band)) / denom\n", "\n", "print('shape of x:', x.shape)\n", "print('shape of y:', y.shape)" ] }, { "cell_type": "markdown", "id": "22-patch-hdr", "metadata": { "id": "22-patch-hdr" }, "source": [ "## 2.2 \u2014 Patch Extraction\n", "\n", "Edge-pad the image by `(P_S - 1) / 2` pixels, then slide over every labeled pixel\n", "to collect `P_S \u00d7 P_S \u00d7 B` patches. Background pixels (label == 0) are skipped." ] }, { "cell_type": "code", "execution_count": 4, "id": "22-patch-code", "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "22-patch-code", "executionInfo": { "status": "ok", "timestamp": 1779943325176, "user_tz": -330, "elapsed": 94, "user": { "displayName": "Big Story", "userId": "07276682490797804347" } }, "outputId": "1dc52cc7-9cae-4e03-8089-ba98faecd2d6" }, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "shape of padded_x: (338, 315, 6)\n", "17.0161% of data is labeled with 7 classes\n" ] } ], "source": [ "y_shape = y.shape[0] * y.shape[1]\n", "pad_width = int((P_S - 1) / 2)\n", "padded_x = np.pad(x, [(pad_width, pad_width), (pad_width, pad_width), (0, 0)], 'edge')\n", "\n", "X, Y = [], []\n", "for row_idx in range(H): # renamed a \u2192 row_idx (single-letter variable)\n", " for col_idx in range(W): # renamed b \u2192 col_idx (single-letter variable)\n", " if y[row_idx][col_idx] != 0:\n", " patch = padded_x[row_idx:row_idx + P_S, col_idx:col_idx + P_S, :]\n", " X.append(patch)\n", " Y.append(y[row_idx][col_idx] - 1) # zero-index labels\n", "\n", "X = np.array(X, dtype=np.float32)\n", "Y = np.array(Y, dtype=np.int32)\n", "num_classes = len(np.unique(y)) - 1 # exclude background class 0\n", "\n", "print('shape of padded_x:', padded_x.shape)\n", "print(f'{len(Y) * 100 / y_shape:.4f}% of data is labeled with {num_classes} classes')" ] }, { "cell_type": "markdown", "id": "23-split-hdr", "metadata": { "id": "23-split-hdr" }, "source": [ "## 2.3 \u2014 Class Distribution & Train/Test Split\n", "\n", "Display a bar chart of per-class pixel counts, then create a stratified split\n", "keeping `train_percent`% for training." ] }, { "cell_type": "code", "execution_count": 5, "id": "23-split-code", "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 567 }, "id": "23-split-code", "executionInfo": { "status": "ok", "timestamp": 1779943325550, "user_tz": -330, "elapsed": 371, "user": { "displayName": "Big Story", "userId": "07276682490797804347" } }, "outputId": "4d2a8fec-b120-4218-b7dd-a1e358f98467" }, "outputs": [ { "output_type": "display_data", "data": { "text/plain": [ "
" ], "image/png": "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\n" }, "metadata": {} }, { "output_type": "stream", "name": "stdout", "text": [ "x_train: (12929, 9, 9, 6)\n", "x_test: (4310, 9, 9, 6)\n", "y_train: (12929,)\n", "y_test: (4310,)\n" ] } ], "source": [ "# Approximate RGB visualisation (middle three bands)\n", "Approximate_rgb_img = x[:, :, [B // 2 - 1, B // 2, B // 2 + 1]] * 255\n", "\n", "class_labels, value_counts = np.unique(y.reshape(-1, 1), return_counts=True)\n", "plt.figure(figsize=(15, 5))\n", "plt.bar(class_labels[1:] - 1, value_counts[1:])\n", "plt.xticks(class_labels, rotation=0)\n", "plt.xlabel('classes')\n", "plt.ylabel('Number of pixels')\n", "plt.title('Distribution Plot')\n", "plt.show()\n", "\n", "x_train, x_test, y_train, y_test = train_test_split(\n", " X, Y, train_size=(train_percent / 100), stratify=Y, random_state=10\n", ")\n", "print(\n", " f'x_train: {x_train.shape}\\n'\n", " f'x_test: {x_test.shape}\\n'\n", " f'y_train: {y_train.shape}\\n'\n", " f'y_test: {y_test.shape}'\n", ")" ] }, { "cell_type": "markdown", "id": "30-shared-hdr", "metadata": { "id": "30-shared-hdr" }, "source": [ "# 3.0 \u2014 Shared Metrics, Layers, and Callbacks\n", "\n", "Define visualisation helpers, classification metric reporting, the Pearson-correlation\n", "attention layer, a staged-dropout layer, and the custom training callback used by all\n", "three models." ] }, { "cell_type": "markdown", "id": "31-viz-hdr", "metadata": { "id": "31-viz-hdr" }, "source": [ "## 3.1 \u2014 Visualisation & Metric Helpers\n", "\n", "`plot_accuracy_loss_curve` overlays accuracy and loss on dual axes.\n", "`performance_meausures` (name preserved as-is for backward compatibility) renders a\n", "4-panel figure: classification report, confusion matrix, score summary, and parameter\n", "count \u2014 and now correctly returns the figure for downstream export." ] }, { "cell_type": "code", "execution_count": 6, "id": "31-viz-code", "metadata": { "id": "31-viz-code", "executionInfo": { "status": "ok", "timestamp": 1779943325552, "user_tz": -330, "elapsed": 6, "user": { "displayName": "Big Story", "userId": "07276682490797804347" } } }, "outputs": [], "source": [ "def plot_accuracy_loss_curve(history, use_pearson_corr=None, folder_path=None):\n", " \"\"\"Plot and optionally save training accuracy and loss curves.\"\"\"\n", " train_loss = history.history['loss']\n", " val_loss = history.history['val_loss']\n", " train_accuracy = history.history['accuracy']\n", " val_accuracy = history.history['val_accuracy']\n", "\n", " fig = plt.figure(figsize=(24, 8))\n", " ax = plt.subplot(1, 1, 1)\n", " ax2 = ax.twinx()\n", "\n", " ax.plot(train_accuracy, color='blue', marker='o', linewidth=1.5, markersize=2, label='train_accuracy')\n", " ax.plot(val_accuracy, color='green', marker='o', linewidth=1.5, markersize=2, label='val_accuracy')\n", " ax.grid()\n", " ax.legend()\n", " plt.xlabel('no. of epoches')\n", " plt.ylabel('accuracy')\n", "\n", " ax2.plot(train_loss, color='black', marker='o', linewidth=1.5, markersize=2, label='train_loss')\n", " ax2.plot(val_loss, color='red', marker='o', linewidth=1.5, markersize=2, label='val_loss')\n", " ax2.grid()\n", " ax2.legend()\n", " plt.xlabel('no. of epoches')\n", " plt.ylabel('loss')\n", " plt.title('accuracy and loss plot for model performance')\n", " plt.show()\n", "\n", " if folder_path:\n", " results_dir = os.path.join(folder_path, \"Results\")\n", " os.makedirs(results_dir, exist_ok=True)\n", " prefix = \"Pearson_Corr \" if use_pearson_corr else \"\"\n", " path = os.path.join(results_dir, f\"{prefix}{train_percent}% ps_{P_S} accuracy_loss.png\")\n", " fig.savefig(path)\n", "\n", "\n", "def performance_meausures(y_test, y_pred, tt, *parameters_summary, folder_path=None):\n", " \"\"\"Compute and visualize classification metrics; returns the figure for export.\n", "\n", " NOTE: function name has a typo ('meausures') \u2014 preserved for backward compatibility.\n", " \"\"\"\n", " Total_params, Trainable_params, Non_trainable_params = parameters_summary\n", " accuracy = accuracy_score(y_test, y_pred)\n", " kappa = cohen_kappa_score(y_test, y_pred)\n", " cm = confusion_matrix(y_test, y_pred).astype('int32')\n", " cr = classification_report(y_test, y_pred, output_dict=True)\n", " df_cr = pd.DataFrame(cr).T\n", " df_score = pd.DataFrame({\n", " 'accuracy score: ': [accuracy],\n", " 'Cohen_Kappa score: ': [kappa],\n", " \"Training Time: \": [tt],\n", " }).T\n", " df_summary = pd.DataFrame({\n", " 'Total_params: ': [Total_params],\n", " 'Trainable_params: ': [Trainable_params],\n", " 'Non_trainable_params: ': [Non_trainable_params],\n", " }).T\n", "\n", " spec = gridspec.GridSpec(\n", " ncols=2, nrows=2, width_ratios=[1, 3],\n", " wspace=0.5, hspace=0.5, height_ratios=[7, 1],\n", " )\n", " fig = plt.figure(figsize=(24, 10))\n", "\n", " ax1 = fig.add_subplot(spec[0])\n", " ax1.set_title('classification report')\n", " sns.heatmap(df_cr, cmap='Blues', cbar=False, annot=True, fmt=' .5g', ax=ax1)\n", "\n", " ax2 = fig.add_subplot(spec[1])\n", " ax2.set_title('confusion matrix')\n", " ax2.set_xlabel('predicted class')\n", " ax2.set_ylabel('actual class')\n", " sns.heatmap(cm, cmap='Blues', cbar=False, annot=True, fmt=' .5g', ax=ax2)\n", "\n", " ax3 = fig.add_subplot(spec[2])\n", " sns.heatmap(df_score, cmap='Blues', cbar=False, annot=True, fmt=' .5g', ax=ax3)\n", " ax3.set_xticks([])\n", "\n", " ax4 = fig.add_subplot(spec[3])\n", " sns.heatmap(df_summary, cmap=\"Blues\", cbar=False, annot=True, fmt=' .10g', ax=ax4)\n", " ax4.set_xticks([])\n", "\n", " if folder_path:\n", " path = folder_path + \"Results/\" + str(train_percent) + \"% ps_\" + str(P_S) + \" Performance Measure.png\"\n", " fig.savefig(path)\n", "\n", " return fig # FIX: was missing; run_training used plt.gcf() as a workaround" ] }, { "cell_type": "markdown", "id": "32-layers-hdr", "metadata": { "id": "32-layers-hdr" }, "source": [ "## 3.2 \u2014 Custom Keras Layers\n", "\n", "`Pearson_correlation_masked` computes a spatial Pearson-correlation attention mask\n", "relative to the central pixel. `Dropout_Train` implements deterministic channel-shift\n", "dropout, cycling through channel groups across training shifts rather than random zeroing." ] }, { "cell_type": "code", "execution_count": 7, "id": "32-layers-code", "metadata": { "id": "32-layers-code", "executionInfo": { "status": "ok", "timestamp": 1779943325553, "user_tz": -330, "elapsed": 3, "user": { "displayName": "Big Story", "userId": "07276682490797804347" } } }, "outputs": [], "source": [ "class Pearson_correlation_masked(layers.Layer):\n", " \"\"\"Apply a Pearson-correlation attention mask to image patches.\"\"\"\n", "\n", " def __init__(self, P_S=9, **kwargs):\n", " \"\"\"Initialize with patch size P_S.\"\"\"\n", " super(Pearson_correlation_masked, self).__init__(**kwargs)\n", " self.P_S = P_S\n", "\n", " def call(self, inputs):\n", " \"\"\"Compute per-pixel Pearson correlation with the central patch pixel and apply as attention.\"\"\"\n", " loc = self.P_S // 2\n", " channels = inputs.shape[-1]\n", "\n", " # Mean of each pixel's spectral vector across channels\n", " x_mean = tf.repeat(tf.math.reduce_mean(inputs, axis=-1, keepdims=True), repeats=channels, axis=-1)\n", "\n", " # Central pixel, tiled to match spatial extent\n", " y = tf.repeat(\n", " tf.repeat(inputs[:, loc:loc+1, loc:loc+1, :], repeats=self.P_S, axis=-2),\n", " repeats=self.P_S, axis=-3,\n", " )\n", " y_mean = tf.repeat(tf.math.reduce_mean(y, axis=-1, keepdims=True), repeats=channels, axis=-1)\n", "\n", " a = tf.math.subtract(inputs, x_mean)\n", " b = tf.math.subtract(y, y_mean)\n", " ab = tf.math.multiply(a, b)\n", "\n", " num = tf.math.reduce_sum(ab, axis=-1, keepdims=True)\n", " a_sq = tf.math.reduce_sum(tf.math.multiply(a, a), axis=-1, keepdims=True)\n", " b_sq = tf.math.reduce_sum(tf.math.multiply(b, b), axis=-1, keepdims=True)\n", " deno = tf.math.sqrt(tf.math.multiply(a_sq, b_sq))\n", " corr = tf.math.divide(num, deno)\n", "\n", " # Threshold at mean correlation; apply mask\n", " thresh = tf.math.reduce_mean(corr)\n", " mask = tf.cast(corr > thresh, corr.dtype)\n", " masked_corr = tf.math.multiply(mask, corr)\n", " attention_wts = tf.repeat(masked_corr, repeats=channels, axis=-1)\n", "\n", " return multiply([inputs, attention_wts])\n", "\n", " def get_config(self):\n", " \"\"\"Return serializable Keras configuration.\"\"\"\n", " config = super(Pearson_correlation_masked, self).get_config()\n", " config.update({\"P_S\": self.P_S})\n", " return config\n", "\n", "\n", "@keras_export('keras.layers.Dropout')\n", "class Dropout_Train(layers.Layer):\n", " \"\"\"Deterministic channel-shift dropout applied during training only.\n", "\n", " Instead of random zeroing, successive shifts zero out a different contiguous\n", " slice of channels, ensuring every channel is trained without being dropped.\n", " \"\"\"\n", "\n", " def __init__(self, rate, shift=1, noise_shape=None, seed=None, **kwargs):\n", " \"\"\"Initialize with dropout rate and current shift index.\"\"\"\n", " super(Dropout_Train, self).__init__(**kwargs)\n", " if isinstance(rate, (int, float)) and not 0 <= rate <= 1:\n", " raise ValueError(f\"Invalid value {rate} received for `rate`, expected a value between 0 and 1.\")\n", " if not isinstance(shift, int):\n", " raise TypeError(f\"Invalid dtype {type(shift)} found for `shift`. It must be an integer\")\n", " if shift * rate > 1.0:\n", " raise ValueError(\n", " f\"Invalid value {shift} received for `shift`, \"\n", " f\"expected an integer value less than or equal to {int(1 / rate)}\"\n", " )\n", " self.rate = rate\n", " self.shift = shift\n", " self.noise_shape = noise_shape\n", " self.seed = seed\n", " self.supports_masking = True\n", "\n", " def _get_noise_shape(self, inputs):\n", " \"\"\"Resolve the concrete dropout noise shape from symbolic noise_shape.\"\"\"\n", " if self.noise_shape is None:\n", " return None\n", " concrete_inputs_shape = array_ops.shape(inputs)\n", " noise_shape = []\n", " for i, value in enumerate(self.noise_shape):\n", " noise_shape.append(concrete_inputs_shape[i] if value is None else value)\n", " return tf.convert_to_tensor(noise_shape)\n", "\n", " def call(self, inputs, training=None):\n", " \"\"\"Apply channel-shift dropout when training; identity otherwise.\"\"\"\n", " if self.rate == 0:\n", " return tf.identity(inputs)\n", " if training is None:\n", " training = K.learning_phase()\n", "\n", " def dropped_inputs():\n", " \"\"\"Build and apply the binary channel mask for this shift.\"\"\"\n", " input_shape = inputs.shape\n", " range_0 = int(self.rate * (self.shift - 1) * input_shape[-1])\n", " range_1 = (\n", " int(self.rate * self.shift * input_shape[-1])\n", " if self.shift * self.rate < 1.0\n", " else None\n", " )\n", " multiplier = np.ones(input_shape[-1])\n", " multiplier[range_0:range_1] = 0.0\n", " multiplier = tf.constant(multiplier)\n", " return Multiply()([inputs, multiplier])\n", "\n", " return control_flow_util.smart_cond(training, dropped_inputs, lambda: array_ops.identity(inputs))\n", "\n", " def compute_output_shape(self, input_shape):\n", " \"\"\"Output shape is unchanged from input shape.\"\"\"\n", " return input_shape\n", "\n", " def get_config(self):\n", " \"\"\"Return serializable Keras configuration.\"\"\"\n", " config = super(Dropout_Train, self).get_config()\n", " config.update({\n", " \"rate\": self.rate,\n", " \"shift\": self.shift,\n", " \"noise_shape\": self.noise_shape,\n", " \"seed\": self.seed,\n", " \"supports_masking\": self.supports_masking,\n", " })\n", " return config" ] }, { "cell_type": "markdown", "id": "33-callbacks-hdr", "metadata": { "id": "33-callbacks-hdr" }, "source": [ "## 3.3 \u2014 Model Modifier & Training Callback\n", "\n", "`modified_model` rebuilds a Keras model, replacing layers whose name contains\n", "`layer_name` with a new layer instance (used to advance the dropout shift stage).\n", "`Custom_callbacks` orchestrates staged training: it triggers `modified_model` each\n", "time the validation accuracy threshold is met, cycling through all dropout shifts\n", "before finalising and saving the best weights." ] }, { "cell_type": "code", "execution_count": 8, "id": "33-callbacks-code", "metadata": { "id": "33-callbacks-code", "executionInfo": { "status": "ok", "timestamp": 1779943325565, "user_tz": -330, "elapsed": 10, "user": { "displayName": "Big Story", "userId": "07276682490797804347" } } }, "outputs": [], "source": [ "def modified_model(model, layer_name, rate, new_layer, shift, **kwargs):\n", " \"\"\"Rebuild `model`, replacing layers matching `layer_name` with `new_layer`.\n", "\n", " layer_name: substring to match in layer names (case-insensitive)\n", " shift: int \u2192 Dropout_Train shift index; str \u2192 standard Dropout (e.g. 'Final')\n", " \"\"\"\n", " name = kwargs.get(\"name\", None)\n", " x = model.layers[0].output\n", " modification = False\n", " z = 0\n", "\n", " for lyr in model.layers[1:]:\n", " if (layer_name in lyr.name or layer_name in lyr.name.upper()) and isinstance(shift, int):\n", " x = new_layer(rate=rate, shift=shift, name=f\"{layer_name}_{shift}_{z}\")(x)\n", " modification = True\n", " z += 1\n", " elif (layer_name in lyr.name or layer_name in lyr.name.upper()) and isinstance(shift, str):\n", " x = new_layer(rate=rate, name=f\"{layer_name}_{shift}_{z}\")(x)\n", " modification = True\n", " z += 1\n", " else:\n", " x = lyr(x)\n", "\n", " if not modification:\n", " print(\"___________________________________Model has not been modified___________________________________\")\n", " return Model(inputs=model.layers[0].input, outputs=x, name=name)\n", "\n", "\n", "class Custom_callbacks(tf.keras.callbacks.Callback):\n", " \"\"\"Manage staged dropout-shift training and best-weight restoration.\n", "\n", " Advances the dropout shift whenever val_accuracy >= accuracy_score AND\n", " at least min_epochs epochs have been completed in the current shift.\n", " After all shifts, saves the model with the best observed val_accuracy.\n", " \"\"\"\n", "\n", " def __init__(self, filepath, epochs, rate, new_layer=Dropout_Train,\n", " layer_name=\"DROPOUT\", accuracy_score=0.99, min_epochs=50):\n", " \"\"\"Configure staged training parameters.\"\"\"\n", " super(Custom_callbacks, self).__init__()\n", " self.filepath = filepath\n", " self.epochs = epochs\n", " self.new_layer = new_layer\n", " self.rate = rate\n", " self.best = 0.0\n", " self.epoch_num = 1\n", " self.layer_name = layer_name\n", " self.min_epochs = min_epochs # minimum epochs per shift before advancing\n", " self.accuracy_score = accuracy_score if accuracy_score <= 1.0 else accuracy_score / 100.0\n", "\n", " def on_train_begin(self, logs=None):\n", " \"\"\"Initialise shift counter and apply the first shift to the model.\"\"\"\n", " print(self.epochs)\n", " self.shift = 1\n", " self.epoch_completed = 0\n", " print(f\"Model will be trained in {int(1 / self.rate)} shifts\")\n", " print(\"Starting training with 1st shift \\n\")\n", " self.model = modified_model(self.model, self.layer_name, self.rate, self.new_layer, self.shift)\n", "\n", " def on_train_end(self, logs=None):\n", " \"\"\"Verify all shifts completed, restore best weights, and save the model.\"\"\"\n", " if self.shift <= int(1 / self.rate):\n", " raise NotImplementedError(\n", " f\"model has not trained fully in the available no. of epochs\\n\"\n", " f\" only {self.shift - 1} shifts completed out of {int(1 / self.rate)}\"\n", " )\n", " print(\"Model training completition \", \"\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\" * self.shift, (self.rate * (self.shift - 1)) * 100, \"%\")\n", " print(f\"Model has been fully trained in {int(1 / self.rate)} shifts\")\n", " self.model.set_weights(self.best_weights)\n", " print(f\"\\nSaving best model to {self.filepath}\")\n", " self.model.save(self.filepath)\n", "\n", " def on_epoch_end(self, epoch, logs=None):\n", " \"\"\"Advance the shift or record best weights depending on current training state.\"\"\"\n", " self.epoch_completed += 1\n", " self.epoch_num += 1\n", " total_shifts = int(1 / self.rate)\n", " acc = logs.get(\"val_accuracy\", 0.0)\n", " threshold_met = (acc >= self.accuracy_score) and (self.epoch_completed >= self.min_epochs)\n", "\n", " if threshold_met and self.shift < total_shifts:\n", " # Advance to the next dropout shift\n", " print(\"\\nTargeted accuracy has been achieved\")\n", " print(\"Model training completition \", \"\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\" * self.shift, (self.rate * self.shift) * 100, \"%\")\n", " self.shift += 1\n", " suffix = \"nd\" if self.shift == 2 else \"th\"\n", " print(f\"Modifying the model for {self.shift}{suffix} shift\")\n", " self.model = modified_model(self.model, self.layer_name, self.rate, self.new_layer, self.shift)\n", " self.epoch_completed = 0\n", "\n", " elif threshold_met and self.shift == total_shifts:\n", " # All shifts done \u2014 switch to standard Dropout for the final phase\n", " print(\"\\nModel training completition \", \"\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\" * self.shift, (self.rate * self.shift) * 100, \"%\")\n", " print(\"All shifting has been completed\\n\")\n", " print(\"\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588===============> Now redefining the model to standard model <===============\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\")\n", " self.model = modified_model(self.model, self.layer_name, self.rate, self.new_layer, \"Final\", name=\"AlexNet\")\n", " self.shift += 1\n", " self.epoch_completed = 0\n", "\n", " else:\n", " print(\", need more training\")\n", " # Record best weights in the final (post-shift) stage\n", " if self.shift >= total_shifts:\n", " current = logs.get(\"val_accuracy\")\n", " if not np.less(current, self.best) and (self.epoch_num >= self.epochs - 10):\n", " print(f\"val_accuracy improved from {self.best:.4f} to {current:.4f}\")\n", " self.best = current\n", " self.best_weights = self.model.get_weights()\n", "\n", " def get_config(self):\n", " \"\"\"Return serializable Keras configuration.\"\"\"\n", " config = super(Custom_callbacks, self).get_config()\n", " config.update({\n", " \"filepath\": self.filepath,\n", " \"epochs\": self.epochs,\n", " \"new_layer\": self.new_layer,\n", " \"rate\": self.rate,\n", " \"best\": self.best,\n", " \"epoch_num\": self.epoch_num,\n", " \"layer_name\": self.layer_name,\n", " \"min_epochs\": self.min_epochs,\n", " \"accuracy_score\": self.accuracy_score,\n", " })\n", " return config" ] }, { "cell_type": "markdown", "id": "40-alex-hdr", "metadata": { "id": "40-alex-hdr" }, "source": [ "# 4.0 \u2014 AlexNet Multi-Head Model\n", "\n", "A five-block convolutional backbone (AlexNet-style) followed by three dense layers,\n", "each guarded by a `Dropout` layer named `TRAIN_DROPOUT_*` (targeted by `Custom_callbacks`).\n", "The backbone fans out to `K_HEADS = 7` independent softmax output heads." ] }, { "cell_type": "code", "execution_count": 9, "id": "40-alex-code", "metadata": { "id": "40-alex-code", "executionInfo": { "status": "ok", "timestamp": 1779943325567, "user_tz": -330, "elapsed": 1, "user": { "displayName": "Big Story", "userId": "07276682490797804347" } } }, "outputs": [], "source": [ "def AlexNet(input_shape, num_classes=13, use_pearson_corr=False, dropout_rate=0.5):\n", " \"\"\"Build the multi-head AlexNet-style convolutional classifier.\"\"\"\n", " K_HEADS = 7 # number of independent output heads\n", "\n", " x_input = Input(input_shape)\n", " X = Pearson_correlation_masked(P_S)(x_input) if use_pearson_corr else x_input\n", "\n", " # \u2500\u2500 Convolutional backbone \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", " X = Conv2D(filters=96, kernel_size=(3, 3), activation='relu', strides=(1, 1), padding='same')(X)\n", " X = Conv2D(filters=256, kernel_size=(3, 3), activation='relu', strides=(1, 1), padding='same')(X)\n", " X = Conv2D(filters=384, kernel_size=(3, 3), activation='relu', strides=(1, 1), padding='same')(X)\n", " X = Conv2D(filters=384, kernel_size=(3, 3), activation='relu', strides=(1, 1), padding='same')(X)\n", " X = Conv2D(filters=256, kernel_size=(3, 3), activation='relu', strides=(1, 1), padding='same')(X)\n", " X = MaxPooling2D(pool_size=(2, 2), strides=(2, 2), padding='same')(X)\n", "\n", " # \u2500\u2500 Dense head \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", " X = Flatten()(X)\n", " X = Dense(4096, activation='relu')(X)\n", " X = Dropout(dropout_rate, name=\"TRAIN_DROPOUT_1\")(X)\n", " X = Dense(1024, activation='relu')(X)\n", " X = Dropout(dropout_rate, name=\"TRAIN_DROPOUT_2\")(X)\n", " X = Dense(256, activation='relu')(X)\n", " X = Dropout(dropout_rate, name=\"TRAIN_DROPOUT_3\")(X)\n", " X = Dense(32, activation='relu')(X)\n", "\n", " # \u2500\u2500 Multi-head outputs \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", " output_heads = [\n", " Dense(num_classes, activation='softmax', dtype='float32', name=f'head_{i+1}')(X)\n", " for i in range(K_HEADS)\n", " ]\n", " return Model(inputs=x_input, outputs=output_heads, name=\"MultiHead_AlexNet\")" ] }, { "cell_type": "markdown", "id": "50-gfnet-hdr", "metadata": { "id": "50-gfnet-hdr" }, "source": [ "# 5.0 \u2014 GFNet Multi-Head Model\n", "\n", "GFNet replaces self-attention with a learned global filter in the frequency domain\n", "(2-D real FFT \u2192 element-wise complex multiply \u2192 inverse FFT). This section defines\n", "all supporting layer classes and the multi-head GFNet builder." ] }, { "cell_type": "markdown", "id": "51-gfnet-layers-hdr", "metadata": { "id": "51-gfnet-layers-hdr" }, "source": [ "## 5.1 \u2014 GFNet Layer Classes\n", "\n", "`GF_MLP`, `GF_DropPath`, `GF_Expand_Dims`, `GF_Patches`, `GF_PatchEncoder`,\n", "`GF_GlobalFilter`, and `GF_Block` form the GFNet primitive vocabulary.\n", "\n", "> **Fixes applied:** `GF_Expand_Dims.config` and `GF_GlobalFilter.config` were\n", "> incorrectly named (missing `get_` prefix); both renamed to `get_config` so Keras\n", "> serialisation works correctly." ] }, { "cell_type": "code", "execution_count": 10, "id": "51-gfnet-layers-code", "metadata": { "id": "51-gfnet-layers-code", "executionInfo": { "status": "ok", "timestamp": 1779943325658, "user_tz": -330, "elapsed": 82, "user": { "displayName": "Big Story", "userId": "07276682490797804347" } } }, "outputs": [], "source": [ "class GF_MLP(layers.Layer):\n", " \"\"\"Feed-forward MLP block used by the GFNet architecture.\"\"\"\n", "\n", " def __init__(self, in_features, out_features, drop=0.0, **kwargs):\n", " \"\"\"Initialize with in/out feature dims and dropout rate.\"\"\"\n", " super(GF_MLP, self).__init__(**kwargs)\n", " self.in_features = in_features\n", " self.out_features = out_features\n", " self.drop = drop\n", " self.mlp_1 = Dense(in_features, activation=activations.gelu, use_bias=False)\n", " self.drop_1 = Dropout(drop)\n", " self.mlp_2 = Dense(out_features, activation=activations.gelu, use_bias=False)\n", " self.drop_2 = Dropout(drop)\n", "\n", " def call(self, x):\n", " \"\"\"Forward pass: two GELU dense layers with dropout.\"\"\"\n", " x = self.drop_1(self.mlp_1(x))\n", " x = self.drop_2(self.mlp_2(x))\n", " return x\n", "\n", " def get_config(self):\n", " \"\"\"Return serializable Keras configuration.\"\"\"\n", " config = super(GF_MLP, self).get_config()\n", " config.update({\"in_features\": self.in_features, \"out_features\": self.out_features, \"drop\": self.drop})\n", " return config\n", "\n", "\n", "class GF_DropPath(layers.Layer):\n", " \"\"\"Stochastic depth (DropPath) regularization for residual paths.\"\"\"\n", "\n", " def __init__(self, drop_prob=0.0, training=False, **kwargs):\n", " \"\"\"Initialize with drop probability.\"\"\"\n", " super(GF_DropPath, self).__init__(**kwargs)\n", " self.drop_prob = drop_prob\n", " self.training = training\n", "\n", " def call(self, x, **kwargs):\n", " \"\"\"Apply stochastic depth; identity when drop_prob==0 or not training.\"\"\"\n", " if self.drop_prob == 0. or not self.training:\n", " return x\n", " keep_prob = 1 - self.drop_prob\n", " shape = (x.shape[0],) + (1,) * (x.ndim - 1)\n", " random_tensor = keep_prob + tf.random.uniform(shape, dtype=x.dtype)\n", " random_tensor.floor_() # binarize\n", " return tf.divide(x, keep_prob) * random_tensor\n", "\n", " def get_config(self):\n", " \"\"\"Return serializable Keras configuration.\"\"\"\n", " config = super(GF_DropPath, self).get_config()\n", " config.update({\"drop_prob\": self.drop_prob, \"training\": self.training})\n", " return config\n", "\n", "\n", "class GF_Expand_Dims(layers.Layer):\n", " \"\"\"Expand tensor dimensions along `ndim` for GFNet compatibility.\"\"\"\n", "\n", " def __init__(self, ndim, **kwargs):\n", " \"\"\"Initialize with axis index to expand.\"\"\"\n", " super(GF_Expand_Dims, self).__init__(**kwargs)\n", " self.ndim = ndim\n", "\n", " def call(self, x):\n", " \"\"\"Insert a dimension at axis `ndim`.\"\"\"\n", " return tf.expand_dims(x, axis=self.ndim)\n", "\n", " def get_config(self, **kwargs): # FIX: was incorrectly named `config`; corrected to `get_config`\n", " \"\"\"Return serializable Keras configuration.\"\"\"\n", " config = super(GF_Expand_Dims, self).get_config()\n", " config.update({\"ndim\": self.ndim})\n", " return config\n", "\n", "\n", "class GF_Patches(layers.Layer):\n", " \"\"\"Extract image patches for the GFNet backbone.\n", "\n", " Supports two methods:\n", " - 'conv': strided Conv2D projection (shape \u2192 [B, N, hidden_dim])\n", " - 'extract': tf.image.extract_patches (shape \u2192 [B, N, patch_dim])\n", " \"\"\"\n", "\n", " def __init__(self, patch_size=3, hidden_dim=256, patch_method='extract', **kwargs):\n", " \"\"\"Initialize patch extractor with size, projection dim, and method.\"\"\"\n", " super(GF_Patches, self).__init__(**kwargs)\n", " self.patch_size = patch_size\n", " self.hidden_dim = hidden_dim\n", " self.patch_method = patch_method.lower()\n", "\n", " def call(self, images):\n", " \"\"\"Extract patches via Conv2D or tf.image.extract_patches.\"\"\"\n", " if self.patch_method == \"conv\":\n", " x = Conv2D(self.hidden_dim, self.patch_size, self.patch_size)(images)\n", " patches = Reshape([-1, x.shape[-1]])(x)\n", " return patches\n", " else:\n", " batch_size = tf.shape(images)[0]\n", " patches = tf.image.extract_patches(\n", " images=images,\n", " sizes=[1, self.patch_size, self.patch_size, 1],\n", " strides=[1, self.patch_size, self.patch_size, 1],\n", " rates=[1, 1, 1, 1],\n", " padding=\"VALID\",\n", " )\n", " patch_dims = patches.shape[-1]\n", " return tf.reshape(patches, [batch_size, -1, patch_dims])\n", "\n", " def get_config(self):\n", " \"\"\"Return serializable Keras configuration.\"\"\"\n", " config = super(GF_Patches, self).get_config()\n", " config.update({\"patch_size\": self.patch_size, \"hidden_dim\": self.hidden_dim, \"patch_method\": self.patch_method})\n", " return config\n", "\n", "\n", "class GF_PatchEncoder(layers.Layer):\n", " \"\"\"Project GFNet patches to `projection_dim` and add positional embeddings.\"\"\"\n", "\n", " def __init__(self, num_patches, projection_dim, **kwargs):\n", " \"\"\"Initialize with patch count and projection dimensionality.\"\"\"\n", " super(GF_PatchEncoder, self).__init__(**kwargs)\n", " self.num_patches = num_patches\n", " self.projection_dim = projection_dim\n", " self.projection = layers.Dense(units=projection_dim)\n", " self.position_embedding = layers.Embedding(input_dim=num_patches, output_dim=projection_dim)\n", "\n", " def call(self, patch, **kwargs):\n", " \"\"\"Project patches and add sinusoidal-free learned positional embeddings.\"\"\"\n", " positions = tf.range(start=0, limit=self.num_patches, delta=1)\n", " return self.projection(patch) + self.position_embedding(positions)\n", "\n", " def get_config(self, **kwargs):\n", " \"\"\"Return serializable Keras configuration.\"\"\"\n", " config = super(GF_PatchEncoder, self).get_config()\n", " config.update({\"num_patches\": self.num_patches, \"projection_dim\": self.projection_dim})\n", " return config\n", "\n", "\n", "class GF_GlobalFilter(layers.Layer):\n", " \"\"\"Apply the Global Filter operation: FFT \u2192 learned complex multiply \u2192 IFFT.\"\"\"\n", "\n", " def __init__(self, patch_size, dim, **kwargs):\n", " \"\"\"Initialize with spatial patch size and feature dimensionality.\"\"\"\n", " super(GF_GlobalFilter, self).__init__(**kwargs)\n", " self.patch_size = patch_size\n", " self.dim = dim\n", "\n", " def build(self, input_shape):\n", " \"\"\"Create the learnable complex weight tensor.\"\"\"\n", " w_init = tf.random_uniform_initializer()\n", " self.complex_weight = self.add_weight(\n", " name=\"complex_weight\",\n", " shape=(self.patch_size, self.patch_size, input_shape[-1] // 2 + 1, 2),\n", " initializer=w_init,\n", " trainable=True,\n", " )\n", " super().build(input_shape)\n", "\n", " def call(self, x, **kwargs):\n", " \"\"\"Apply real-valued 2-D FFT filtering with learned complex weights.\"\"\"\n", " B, N, C = x.shape\n", " a = b = int(math.sqrt(N))\n", " x = tf.reshape(x, [-1, a, b, C])\n", " x = tf.signal.rfft2d(x)\n", " weight = tf.dtypes.complex(self.complex_weight[:, :, :, 0], self.complex_weight[:, :, :, -1])\n", " x = x * weight\n", " x = tf.signal.irfft2d(x)\n", " return tf.reshape(x, [-1, N, C])\n", "\n", " def get_config(self, **kwargs): # FIX: was incorrectly named `config`; corrected to `get_config`\n", " \"\"\"Return serializable Keras configuration.\"\"\"\n", " config = super(GF_GlobalFilter, self).get_config()\n", " config.update({\"patch_size\": self.patch_size, \"dim\": self.dim})\n", " return config\n", "\n", "\n", "class GF_Block(tf.keras.layers.Layer):\n", " \"\"\"One GFNet block: LayerNorm \u2192 GlobalFilter \u2192 DropPath residual \u2192 LayerNorm \u2192 MLP \u2192 DropPath residual.\"\"\"\n", "\n", " def __init__(self, patch_size=3, dim=512, mlp_ratio=4.0, drop=0.0, drop_path=0.0, **kwargs):\n", " \"\"\"Initialize GFNet block with filter and MLP hyperparameters.\"\"\"\n", " super(GF_Block, self).__init__(**kwargs)\n", " self.patch_size = patch_size\n", " self.dim = dim\n", " self.mlp_ratio = mlp_ratio\n", " self.drop = drop\n", " self.drop_path_rate = drop_path\n", "\n", " self.norm1 = tf.keras.layers.LayerNormalization(axis=-1)\n", " self.filter = GF_GlobalFilter(patch_size, dim)\n", " self.drop_path = GF_DropPath(drop_path)\n", " self.norm2 = tf.keras.layers.LayerNormalization(axis=-1)\n", " mlp_hidden_dim = int(dim * mlp_ratio)\n", " self.mlp = GF_MLP(in_features=mlp_hidden_dim, out_features=dim, drop=drop)\n", "\n", " def call(self, x):\n", " \"\"\"Single residual block: filter branch + MLP branch.\"\"\"\n", " x = x + self.drop_path(self.mlp(self.norm2(self.filter(self.norm1(x)))))\n", " return x\n", "\n", " def get_config(self):\n", " \"\"\"Return serializable Keras configuration.\"\"\"\n", " config = super(GF_Block, self).get_config()\n", " config.update({\n", " \"patch_size\": self.patch_size,\n", " \"dim\": self.dim,\n", " \"mlp_ratio\": self.mlp_ratio,\n", " \"drop\": self.drop,\n", " \"drop_path\": self.drop_path_rate,\n", " })\n", " return config" ] }, { "cell_type": "markdown", "id": "52-gfnet-builder-hdr", "metadata": { "id": "52-gfnet-builder-hdr" }, "source": [ "## 5.2 \u2014 GFNet Model Builder\n", "\n", "Assembles patch extraction, encoder, `GlobalFilter_layers` GFNet blocks, pooling,\n", "and `K_HEADS = 7` softmax output heads." ] }, { "cell_type": "code", "execution_count": 11, "id": "52-gfnet-builder-code", "metadata": { "id": "52-gfnet-builder-code", "executionInfo": { "status": "ok", "timestamp": 1779943325676, "user_tz": -330, "elapsed": 2, "user": { "displayName": "Big Story", "userId": "07276682490797804347" } } }, "outputs": [], "source": [ "def GFNet(input_shape=(P_S, P_S, B),\n", " use_pearson_corr=False,\n", " patch_size=3,\n", " num_classes=16,\n", " hidden_dim=512,\n", " GlobalFilter_layers=12,\n", " mlp_ratio=4,\n", " num_patches=9,\n", " dropout_rate=0.0,\n", " drop_path_rate=0.0):\n", " \"\"\"Build the multi-head GFNet classifier.\"\"\"\n", " K_HEADS = 7 # number of independent output heads\n", "\n", " x_input = Input(shape=input_shape)\n", " x = Pearson_correlation_masked(P_S)(x_input) if use_pearson_corr else x_input\n", "\n", " # \u2500\u2500 Patch extraction and encoding \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", " x = GF_Patches(patch_size)(x)\n", " x = GF_PatchEncoder(num_patches, hidden_dim)(x)\n", " x = Dropout(dropout_rate, name=\"TRAIN_DROPOUT_1\")(x)\n", "\n", " # \u2500\u2500 Stacked Global Filter blocks \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", " for _ in range(GlobalFilter_layers):\n", " x = GF_Block(\n", " patch_size=patch_size,\n", " dim=hidden_dim,\n", " mlp_ratio=mlp_ratio,\n", " drop=dropout_rate,\n", " drop_path=drop_path_rate,\n", " )(x)\n", "\n", " # \u2500\u2500 Pooling and normalisation \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", " x = Dropout(dropout_rate, name=\"TRAIN_DROPOUT_2\")(x)\n", " x = LayerNormalization()(x)\n", " x = GF_Expand_Dims(ndim=2)(x)\n", " x = GlobalAveragePooling2D()(x)\n", " x = Flatten()(x)\n", " x = Dropout(dropout_rate, name=\"TRAIN_DROPOUT_3\")(x)\n", "\n", " # \u2500\u2500 Multi-head outputs \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", " output_heads = [\n", " Dense(num_classes, activation=\"softmax\", dtype=\"float32\", name=f\"head_{i+1}\")(x)\n", " for i in range(K_HEADS)\n", " ]\n", " return keras.Model(inputs=x_input, outputs=output_heads, name=\"MultiHead_GFNet\")" ] }, { "cell_type": "markdown", "id": "60-vit-hdr", "metadata": { "id": "60-vit-hdr" }, "source": [ "# 6.0 \u2014 Vision Transformer Multi-Head Model\n", "\n", "A compact ViT with learnable CLS token, positional embeddings, and a symmetric\n", "U-Net-style skip-connection transformer stack (`ViT_TransFormer_Block`).\n", "Optional spatial-attention preprocessing modules are also defined here." ] }, { "cell_type": "markdown", "id": "61-vit-layers-hdr", "metadata": { "id": "61-vit-layers-hdr" }, "source": [ "## 6.1 \u2014 ViT Layer Classes\n", "\n", "`ViT_SpatialAttention`, `ViT_SpatialAttention1`, `MLP` (functional),\n", "`ViT_Patches`, `ViT_PatchEncoder` (with CLS token), `ViT_Weighted_add`,\n", "`ViT_TransFormer`, `ViT_TransFormer_Block` (symmetric skips), and\n", "`ViT_Class_Token_Norm`." ] }, { "cell_type": "code", "execution_count": 12, "id": "61-vit-layers-code", "metadata": { "id": "61-vit-layers-code", "executionInfo": { "status": "ok", "timestamp": 1779943325692, "user_tz": -330, "elapsed": 15, "user": { "displayName": "Big Story", "userId": "07276682490797804347" } } }, "outputs": [], "source": [ "class ViT_SpatialAttention(layers.Layer):\n", " \"\"\"Four-conv spatial attention gate producing a sigmoid attention map.\"\"\"\n", "\n", " def __init__(self, k_size=3, **kwargs):\n", " \"\"\"Initialize with convolution kernel size.\"\"\"\n", " super().__init__(**kwargs)\n", " self.k_size = k_size\n", " self.norm = layers.BatchNormalization()\n", " self.conv1 = layers.Conv2D(1, kernel_size=(k_size, k_size), padding=\"same\")\n", " self.conv2 = layers.Conv2D(1, kernel_size=(k_size, k_size), padding=\"same\")\n", " self.conv3 = layers.Conv2D(1, kernel_size=(k_size, k_size), padding=\"same\")\n", " self.conv4 = layers.Conv2D(1, kernel_size=(k_size, k_size), padding=\"same\")\n", " self.act_relu = layers.Activation(\"relu\")\n", " self.act_sigmoid = layers.Activation(\"sigmoid\")\n", "\n", " def call(self, inputs):\n", " \"\"\"Pass through four convolutions with ReLU; final sigmoid gate.\"\"\"\n", " x = self.conv1(inputs)\n", " x = self.norm(x)\n", " x = self.conv2(x)\n", " x = self.act_relu(x)\n", " x = self.conv3(x)\n", " x = self.act_relu(x)\n", " x = self.conv4(x)\n", " return self.act_sigmoid(x)\n", "\n", " def get_config(self):\n", " \"\"\"Return serializable Keras configuration.\"\"\"\n", " config = super().get_config()\n", " config.update({\"k_size\": self.k_size})\n", " return config\n", "\n", "\n", "class ViT_SpatialAttention1(layers.Layer):\n", " \"\"\"Encoder-decoder spatial attention gate with Conv2D + Conv2DTranspose.\"\"\"\n", "\n", " def __init__(self, input_shape, **kwargs):\n", " \"\"\"Initialize with expected input spatial shape for shape correction.\"\"\"\n", " super().__init__(**kwargs)\n", " self.input_shape_val = input_shape\n", " self.filters = input_shape[-1]\n", " self.k_size = input_shape[1]\n", "\n", " self.norm = layers.BatchNormalization()\n", " self.conv1 = layers.Conv2D(self.filters, kernel_size=3, padding=\"same\", kernel_initializer=\"he_normal\")\n", " self.conv2 = layers.Conv2D(self.filters, kernel_size=3, strides=2, padding=\"same\")\n", " self.conv3 = layers.Conv2D(self.filters, kernel_size=3, strides=2, padding=\"same\")\n", " self.convt1 = layers.Conv2DTranspose(self.filters, kernel_size=3, strides=2, padding=\"same\")\n", " self.convt2 = layers.Conv2DTranspose(self.filters, kernel_size=3, strides=2, padding=\"same\")\n", " self.relu = layers.ReLU()\n", " self.sigmoid = layers.Activation(\"sigmoid\")\n", "\n", " def call(self, inputs):\n", " \"\"\"Encoder\u2013decoder path with shape correction and sigmoid gate.\"\"\"\n", " x = self.relu(self.norm(self.conv1(inputs)))\n", " x = self.relu(self.conv2(x))\n", " x = self.relu(self.conv3(x))\n", " x = self.relu(self.convt1(x))\n", " x = self.relu(self.convt2(x))\n", " # Shape correction if stride misalignment occurs\n", " if x.shape[1] != self.input_shape_val[1] or x.shape[2] != self.input_shape_val[2]:\n", " k_size = x.shape[1] - self.k_size + 1\n", " x = layers.Conv2D(self.filters, kernel_size=k_size, strides=1, padding=\"valid\")(x)\n", " return self.sigmoid(x)\n", "\n", " def get_config(self):\n", " \"\"\"Return serializable Keras configuration.\"\"\"\n", " config = super().get_config()\n", " config.update({\"input_shape\": self.input_shape_val, \"filters\": self.filters, \"k_size\": self.k_size})\n", " return config\n", "\n", "\n", "def MLP(x, hidden_units, dropout_rate):\n", " \"\"\"Feedforward network used inside Transformer blocks.\n", "\n", " hidden_units: list of Dense layer sizes (e.g. [mlp_dim, embed_dim])\n", " dropout_rate: dropout applied after each Dense layer\n", " \"\"\"\n", " for units in hidden_units:\n", " x = layers.Dense(units, activation=tf.keras.activations.gelu)(x)\n", " x = layers.Dropout(dropout_rate)(x)\n", " return x\n", "\n", "\n", "class ViT_Patches(layers.Layer):\n", " \"\"\"Extract non-overlapping patches and project to `embed_dim`.\"\"\"\n", "\n", " def __init__(self, patch_size, embed_dim=768, **kwargs):\n", " \"\"\"Initialize with patch size and embedding dimension.\"\"\"\n", " super(ViT_Patches, self).__init__(**kwargs)\n", " self.patch_size = patch_size\n", " self.embed_dim = embed_dim\n", "\n", " def build(self, input_shape):\n", " \"\"\"Build the linear projection layer.\"\"\"\n", " self.projection = layers.Dense(self.embed_dim)\n", "\n", " def call(self, images):\n", " \"\"\"Extract patches via tf.image.extract_patches and project them.\"\"\"\n", " batch_size = tf.shape(images)[0]\n", " patches = tf.image.extract_patches(\n", " images=images,\n", " sizes=[1, self.patch_size, self.patch_size, 1],\n", " strides=[1, self.patch_size, self.patch_size, 1],\n", " rates=[1, 1, 1, 1],\n", " padding=\"VALID\",\n", " )\n", " patch_dims = patches.shape[-1] # = patch_size * patch_size * C\n", " patches = tf.reshape(patches, [batch_size, -1, patch_dims])\n", " return self.projection(patches) # project raw patches \u2192 embed_dim\n", "\n", " def get_config(self):\n", " \"\"\"Return serializable Keras configuration.\"\"\"\n", " config = super(ViT_Patches, self).get_config()\n", " config.update({\"patch_size\": self.patch_size, \"embed_dim\": self.embed_dim})\n", " return config\n", "\n", "\n", "class ViT_PatchEncoder(layers.Layer):\n", " \"\"\"Prepend a learnable CLS token and add positional embeddings to ViT patches.\"\"\"\n", "\n", " def __init__(self, num_patches, projection_dim, **kwargs):\n", " \"\"\"Initialize with patch count and projection dimensionality.\"\"\"\n", " super(ViT_PatchEncoder, self).__init__(**kwargs)\n", " self.num_patches = num_patches\n", " self.projection_dim = projection_dim\n", " self.projection = layers.Dense(units=projection_dim)\n", " self.position_embedding = layers.Embedding(input_dim=num_patches + 1, output_dim=projection_dim)\n", " # Learnable CLS token initialised to zeros\n", " self.cls_token = self.add_weight(\n", " name=\"cls_token\",\n", " shape=(1, 1, projection_dim),\n", " initializer=tf.zeros_initializer(),\n", " trainable=True,\n", " )\n", "\n", " def call(self, patch, **kwargs):\n", " \"\"\"Prepend CLS token, project patches, and add positional embeddings.\"\"\"\n", " batch_size = tf.shape(patch)[0]\n", " patch_proj = self.projection(patch) # [B, N, D]\n", " cls_tokens = tf.repeat(self.cls_token, repeats=batch_size, axis=0) # [B, 1, D]\n", " x = tf.concat([cls_tokens, patch_proj], axis=1) # [B, N+1, D]\n", " positions = tf.range(start=0, limit=self.num_patches + 1, delta=1)\n", " return x + self.position_embedding(positions)\n", "\n", " def get_config(self):\n", " \"\"\"Return serializable Keras configuration.\"\"\"\n", " config = super(ViT_PatchEncoder, self).get_config()\n", " config.update({\"num_patches\": self.num_patches, \"projection_dim\": self.projection_dim})\n", " return config\n", "\n", "\n", "class ViT_Weighted_add(layers.Layer):\n", " \"\"\"Combine two tensors with a single learned scalar weight `w`: w*x + (1-w)*y.\"\"\"\n", "\n", " def __init__(self, name, **kwargs):\n", " \"\"\"Initialize with a unique identifier for the weight.\"\"\"\n", " super(ViT_Weighted_add, self).__init__(**kwargs)\n", " self.wt_name = name\n", "\n", " def build(self, input_shape):\n", " \"\"\"Create the scalar blend weight.\"\"\"\n", " self.w = self.add_weight(\n", " name=\"weighted_add_\" + str(self.wt_name),\n", " shape=(1,),\n", " initializer=tf.random_normal_initializer(),\n", " trainable=True,\n", " )\n", "\n", " def call(self, input_1, input_2):\n", " \"\"\"Weighted residual blend.\"\"\"\n", " return input_1 * self.w + input_2 * (1.0 - self.w)\n", "\n", " def get_config(self):\n", " \"\"\"Return serializable Keras configuration.\"\"\"\n", " config = super(ViT_Weighted_add, self).get_config()\n", " config.update({\"wt_name\": self.wt_name})\n", " return config\n", "\n", "\n", "class ViT_TransFormer(layers.Layer):\n", " \"\"\"Single transformer block: Multi-Head Attention + FFN, both with learned-weight residuals.\"\"\"\n", "\n", " def __init__(self, layer_num, num_heads, projection_dim, dropout=0.1, **kwargs):\n", " \"\"\"Initialize block with layer index, head count, projection dim, and dropout.\"\"\"\n", " super(ViT_TransFormer, self).__init__(**kwargs)\n", " self.layer_num = layer_num\n", " self.num_heads = num_heads\n", " self.projection_dim = projection_dim\n", " self.dropout = dropout\n", "\n", " def build(self, input_shape):\n", " \"\"\"Build sub-layers (deferred so `layer_num` is in scope for naming).\"\"\"\n", " self.norm1 = layers.LayerNormalization(epsilon=1e-6, name=f\"ln1_{self.layer_num}\")\n", " self.norm2 = layers.LayerNormalization(epsilon=1e-6, name=f\"ln2_{self.layer_num}\")\n", " self.add1 = ViT_Weighted_add(f\"transformer_1_{self.layer_num}\")\n", " self.add2 = ViT_Weighted_add(f\"transformer_2_{self.layer_num}\")\n", " self.mha = layers.MultiHeadAttention(\n", " num_heads=self.num_heads,\n", " key_dim=self.projection_dim,\n", " dropout=self.dropout,\n", " name=f\"mha_{self.layer_num}\",\n", " )\n", " self.dense1 = layers.Dense(self.projection_dim * 2, activation=tf.keras.activations.gelu)\n", " self.drop1 = layers.Dropout(self.dropout)\n", " self.dense2 = layers.Dense(self.projection_dim, activation=tf.keras.activations.gelu)\n", " self.drop2 = layers.Dropout(self.dropout)\n", "\n", " def call(self, inputs, training=None):\n", " \"\"\"MHA residual block then FFN residual block.\"\"\"\n", " # Multi-Head Attention\n", " x1 = self.norm1(inputs)\n", " x1 = self.mha(x1, x1, training=training)\n", " x1 = self.add1(x1, inputs)\n", " # Feed-Forward Network\n", " x2 = self.norm2(x1)\n", " x2 = self.drop1(self.dense1(x2), training=training)\n", " x2 = self.drop2(self.dense2(x2), training=training)\n", " return self.add2(x2, x1)\n", "\n", " def get_config(self):\n", " \"\"\"Return serializable Keras configuration.\"\"\"\n", " config = super(ViT_TransFormer, self).get_config()\n", " config.update({\n", " \"layer_num\": self.layer_num, \"num_heads\": self.num_heads,\n", " \"projection_dim\": self.projection_dim, \"dropout\": self.dropout,\n", " })\n", " return config\n", "\n", "\n", "class ViT_TransFormer_Block(layers.Layer):\n", " \"\"\"Stack of `num_layers` transformer blocks with symmetric U-Net-style skip connections.\"\"\"\n", "\n", " def __init__(self, num_layers, num_heads, projection_dim, dropout=0.1, **kwargs):\n", " \"\"\"Initialize block stack with depth, head count, projection dim, and dropout.\"\"\"\n", " super(ViT_TransFormer_Block, self).__init__(**kwargs)\n", " self.num_layers = num_layers\n", " self.num_heads = num_heads\n", " self.projection_dim = projection_dim\n", " self.dropout = dropout\n", "\n", " def build(self, input_shape):\n", " \"\"\"Build the list of TransFormer sub-layers.\"\"\"\n", " self.Blocks = [\n", " ViT_TransFormer(i, self.num_heads, self.projection_dim, self.dropout)\n", " for i in range(self.num_layers)\n", " ]\n", "\n", " def call(self, inputs, training=None):\n", " \"\"\"Forward + symmetric skip connections (mirror like U-Net).\"\"\"\n", " block_list = []\n", " x = inputs\n", " for i in range(self.num_layers):\n", " x = self.Blocks[i](x, training=training)\n", " if i <= self.num_layers // 2:\n", " block_list.append(x)\n", " else:\n", " x = layers.Add()([x, block_list[self.num_layers - i - 1]])\n", " return x\n", "\n", " def get_config(self):\n", " \"\"\"Return serializable Keras configuration.\"\"\"\n", " config = super(ViT_TransFormer_Block, self).get_config()\n", " config.update({\n", " \"num_layers\": self.num_layers, \"num_heads\": self.num_heads,\n", " \"projection_dim\": self.projection_dim, \"dropout\": self.dropout,\n", " })\n", " return config\n", "\n", "\n", "class ViT_Class_Token_Norm(layers.Layer):\n", " \"\"\"Apply LayerNormalization and return only the CLS token (index 0).\"\"\"\n", "\n", " def __init__(self, eps=1e-6, **kwargs):\n", " \"\"\"Initialize with LayerNorm epsilon.\"\"\"\n", " super(ViT_Class_Token_Norm, self).__init__(**kwargs)\n", " self.eps = eps\n", " self.norm = layers.LayerNormalization(epsilon=self.eps)\n", "\n", " def call(self, inputs):\n", " \"\"\"Normalize sequence and extract CLS token \u2192 shape (B, D).\"\"\"\n", " x = self.norm(inputs)\n", " return x[:, 0, :] # CLS token\n", "\n", " def get_config(self):\n", " \"\"\"Return serializable Keras configuration.\"\"\"\n", " config = super(ViT_Class_Token_Norm, self).get_config()\n", " config.update({\"eps\": self.eps})\n", " return config" ] }, { "cell_type": "markdown", "id": "62-vit-builder-hdr", "metadata": { "id": "62-vit-builder-hdr" }, "source": [ "## 6.2 \u2014 ViT Model Builder\n", "\n", "`create_vit_classifier` assembles the full pipeline. Three representation strategies\n", "are supported via the `method` argument: `with_cls_tkn` (CLS token), `with_gap`\n", "(global average pooling), and `without_gap` (flattened normalization).\n", "\n", "> **Note:** `projection_dim`, `num_heads`, `transformer_layers`, and `dropout` are\n", "> referenced as free variables from the enclosing scope. The authoritative values are\n", "> set in Section 7.0 (Training Configuration) below; the defaults here serve as\n", "> documentation / fallbacks if Section 7.0 is not run first." ] }, { "cell_type": "code", "execution_count": 13, "id": "62-vit-builder-code", "metadata": { "id": "62-vit-builder-code", "executionInfo": { "status": "ok", "timestamp": 1779943325715, "user_tz": -330, "elapsed": 10, "user": { "displayName": "Big Story", "userId": "07276682490797804347" } } }, "outputs": [], "source": [ "# Default ViT hyperparameters \u2014 overridden by Section 7.0\n", "projection_dim = 256\n", "num_heads = 4\n", "transformer_layers = 12\n", "dropout = 0.1 # dropout inside Transformer blocks\n", "\n", "\n", "def create_vit_classifier(input_shape=(P_S, P_S, B),\n", " num_classes=7,\n", " use_pearson_corr=False,\n", " dropout_rate=0.25,\n", " method=\"with_gap\",\n", " k_heads: int = 1):\n", " \"\"\"Build a Vision Transformer classifier with optional multi-head outputs.\n", "\n", " k_heads == 1: returns a single logits tensor (shape [B, num_classes]).\n", " k_heads > 1: returns a list of k_heads tensors [ (B, num_classes), ... ].\n", " method: 'with_cls_tkn' | 'with_gap' | 'without_gap'\n", " \"\"\"\n", " inputs = layers.Input(shape=input_shape)\n", " x0 = Pearson_correlation_masked(P_S)(inputs) if use_pearson_corr else inputs\n", "\n", " # \u2500\u2500 Patch creation & encoding \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", " patches = ViT_Patches(patch_size, embed_dim=projection_dim)(x0)\n", " encoded_patches = ViT_PatchEncoder(num_patches, projection_dim)(patches)\n", "\n", " # \u2500\u2500 Transformer stack \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", " encoded_patches = ViT_TransFormer_Block(transformer_layers, num_heads, projection_dim, dropout)(encoded_patches)\n", " encoded_patches = layers.Dropout(dropout_rate, name=\"TRAIN_DROPOUT_1\")(encoded_patches)\n", "\n", " # \u2500\u2500 Representation strategy \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", " if method == \"with_cls_tkn\":\n", " representation = ViT_Class_Token_Norm(eps=1e-6)(encoded_patches)\n", " elif method == \"without_gap\":\n", " representation = layers.LayerNormalization(epsilon=1e-6)(encoded_patches)\n", " representation = layers.Flatten()(representation)\n", " elif method == \"with_gap\":\n", " representation = layers.LayerNormalization(epsilon=1e-6)(encoded_patches)\n", " representation = tf.reduce_mean(representation, axis=1) # [B, D]\n", " else:\n", " raise ValueError(f\"Unknown method: {method}\")\n", "\n", " # \u2500\u2500 Classification MLP \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", " x = layers.Dense(512, activation=tf.keras.activations.gelu)(representation)\n", " x = layers.Dropout(dropout_rate, name=\"TRAIN_DROPOUT_3\")(x)\n", " x = layers.Dense(256, activation=tf.keras.activations.gelu)(x)\n", " x = layers.Dense(128, activation=tf.keras.activations.gelu)(x)\n", " x = layers.Dropout(dropout_rate, name=\"TRAIN_DROPOUT_5\")(x)\n", " x = layers.Dense(64, activation=tf.keras.activations.gelu)(x)\n", " features = layers.Dropout(dropout_rate, name=\"TRAIN_DROPOUT_6\")(x)\n", "\n", " # \u2500\u2500 Multi-head outputs \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", " output_heads = [\n", " layers.Dense(num_classes, activation=\"softmax\", dtype=\"float32\", name=f\"head_{i+1}\")(features)\n", " for i in range(max(1, k_heads))\n", " ]\n", "\n", " outputs = output_heads[0] if k_heads == 1 else output_heads\n", " return keras.Model(inputs=inputs, outputs=outputs)" ] }, { "cell_type": "markdown", "id": "70-config-hdr", "metadata": { "id": "70-config-hdr" }, "source": [ "# 7.0 \u2014 Training Configuration\n", "\n", "Authoritative architecture hyperparameters (overriding any defaults set above),\n", "the `CUSTOM_OBJECTS` dict required for model deserialisation, and `MODEL_SPECS` \u2014\n", "a registry mapping each model name to its builder, optimiser, LR schedule, and\n", "output paths." ] }, { "cell_type": "code", "execution_count": 14, "id": "70-config-code", "metadata": { "id": "70-config-code", "executionInfo": { "status": "ok", "timestamp": 1779943325750, "user_tz": -330, "elapsed": 34, "user": { "displayName": "Big Story", "userId": "07276682490797804347" } } }, "outputs": [], "source": [ "# \u2500\u2500 Architecture hyperparameters (authoritative values) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", "# NOTE: projection_dim, num_heads, transformer_layers, dropout were also set in\n", "# Section 6.2 as defaults; the values here take precedence at call time.\n", "patch_size = 3\n", "hidden_dim = 512\n", "GlobalFilter_layers = 12\n", "mlp_ratio = 4\n", "num_patches = 9\n", "projection_dim = 256\n", "num_heads = 4\n", "transformer_layers = 12\n", "dropout = 0.1\n", "\n", "# \u2500\u2500 Custom-object registry for model deserialisation \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", "CUSTOM_OBJECTS = {\n", " 'Pearson_correlation_masked': Pearson_correlation_masked,\n", " 'Dropout_Train': Dropout_Train,\n", " 'GF_Patches': GF_Patches,\n", " 'GF_PatchEncoder': GF_PatchEncoder,\n", " 'GF_GlobalFilter': GF_GlobalFilter,\n", " 'GF_Block': GF_Block,\n", " 'GF_Expand_Dims': GF_Expand_Dims,\n", " 'GF_MLP': GF_MLP,\n", " 'GF_DropPath': GF_DropPath,\n", " 'ViT_Patches': ViT_Patches,\n", " 'ViT_PatchEncoder': ViT_PatchEncoder,\n", " 'ViT_SpatialAttention': ViT_SpatialAttention,\n", " 'ViT_SpatialAttention1': ViT_SpatialAttention1,\n", " 'ViT_Weighted_add': ViT_Weighted_add,\n", " 'ViT_TransFormer': ViT_TransFormer,\n", " 'ViT_TransFormer_Block': ViT_TransFormer_Block,\n", " 'ViT_Class_Token_Norm': ViT_Class_Token_Norm,\n", "}\n", "\n", "# \u2500\u2500 Per-model training specifications \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", "MODEL_SPECS = {\n", " 'AlexNet_CNN_MultiHead': {\n", " 'builder': lambda: AlexNet(input_shape=(P_S, P_S, B), num_classes=num_classes,\n", " use_pearson_corr=use_pearson_corr, dropout_rate=dropout_rate),\n", " 'optimizer': lambda: optimizers.Adagrad(0.01),\n", " 'lr_schedule': 'alexnet',\n", " 'model_file': SAVED_MODEL_DIR / 'AlexNet_CNN_MultiHead_best.keras',\n", " 'final_file': SAVED_MODEL_DIR / 'AlexNet_CNN_MultiHead_final.keras',\n", " },\n", " 'GFNet_MultiHead': {\n", " 'builder': lambda: GFNet((P_S, P_S, B), use_pearson_corr, patch_size, num_classes,\n", " hidden_dim, GlobalFilter_layers, mlp_ratio, num_patches, dropout_rate, 0.0),\n", " 'optimizer': lambda: tf.keras.optimizers.Adam(learning_rate=0.000003),\n", " 'lr_schedule': 'gfnet',\n", " 'model_file': SAVED_MODEL_DIR / 'GFNet_MultiHead_best.keras',\n", " 'final_file': SAVED_MODEL_DIR / 'GFNet_MultiHead_final.keras',\n", " },\n", " 'ViT_UNet_MultiHead': {\n", " 'builder': lambda: create_vit_classifier(input_shape=(P_S, P_S, B), num_classes=num_classes,\n", " use_pearson_corr=use_pearson_corr, dropout_rate=dropout_rate,\n", " method='with_cls_tkn', k_heads=7),\n", " 'optimizer': lambda: optimizers.Adam(3e-6),\n", " 'lr_schedule': 'vit',\n", " 'model_file': SAVED_MODEL_DIR / 'ViT_UNet_MultiHead_best.keras',\n", " 'final_file': SAVED_MODEL_DIR / 'ViT_UNet_MultiHead_final.keras',\n", " },\n", "}" ] }, { "cell_type": "markdown", "id": "80-helpers-hdr", "metadata": { "id": "80-helpers-hdr" }, "source": [ "# 8.0 \u2014 Training and Export Helpers\n", "\n", "Utility functions for workbook management, learning-rate scheduling, multi-head\n", "prediction aggregation, performance metrics export, and the reusable training runner." ] }, { "cell_type": "markdown", "id": "81-excel-hdr", "metadata": { "id": "81-excel-hdr" }, "source": [ "## 8.1 \u2014 Excel Export Utilities\n", "\n", "`ensure_workbook` creates or opens the results workbook.\n", "`autosize_columns` adjusts column widths.\n", "`fig_to_buffer` serialises Matplotlib figures to PNG buffers for embedding.\n", "`export_training_sheet` writes summary rows, classification reports, confusion matrices,\n", "and three figures into a dedicated worksheet." ] }, { "cell_type": "code", "execution_count": 15, "id": "81-excel-code", "metadata": { "id": "81-excel-code", "executionInfo": { "status": "ok", "timestamp": 1779943325751, "user_tz": -330, "elapsed": 4, "user": { "displayName": "Big Story", "userId": "07276682490797804347" } } }, "outputs": [], "source": [ "def ensure_workbook(path):\n", " \"\"\"Create a new workbook with a Summary sheet, or load an existing one.\"\"\"\n", " if path.exists():\n", " return load_workbook(path)\n", " wb = Workbook()\n", " ws = wb.active\n", " ws.title = 'Summary'\n", " wb.save(path)\n", " return wb\n", "\n", "\n", "def autosize_columns(ws):\n", " \"\"\"Resize each worksheet column to fit its widest cell value (max 40 chars).\"\"\"\n", " for col in ws.columns:\n", " values = [len(str(cell.value)) for cell in col if cell.value is not None]\n", " if values:\n", " ws.column_dimensions[col[0].column_letter].width = min(max(values) + 2, 40)\n", "\n", "\n", "def fig_to_buffer(fig):\n", " \"\"\"Serialise a Matplotlib figure to an in-memory PNG BytesIO buffer.\"\"\"\n", " buf = io.BytesIO()\n", " fig.savefig(buf, format='png', bbox_inches='tight', dpi=200)\n", " buf.seek(0)\n", " return buf\n", "\n", "\n", "def export_training_sheet(wb, model_name, summary_row, report_df, cm, figs):\n", " \"\"\"Write metrics, classification report, confusion matrix, and figures to a new Excel sheet.\"\"\"\n", " ws = wb.create_sheet(title=model_name[:31])\n", "\n", " # Summary key-value rows\n", " for idx, (key, value) in enumerate(summary_row.items(), start=1):\n", " ws.cell(row=idx, column=1, value=key)\n", " ws.cell(row=idx, column=2, value=value)\n", "\n", " row0 = len(summary_row) + 3\n", "\n", " # Classification report table\n", " for r_idx, row in enumerate(dataframe_to_rows(report_df.reset_index(), index=False, header=True), start=row0):\n", " for c_idx, val in enumerate(row, start=1):\n", " ws.cell(row=r_idx, column=c_idx, value=val)\n", "\n", " # Confusion matrix (offset to column 10)\n", " for r_idx, row in enumerate(dataframe_to_rows(pd.DataFrame(cm), index=False, header=False), start=row0):\n", " for c_idx, val in enumerate(row, start=10):\n", " ws.cell(row=r_idx, column=c_idx, value=int(val))\n", "\n", " # Embedded figures: curve, performance, LR schedule\n", " for anchor, fig in [('L2', figs[0]), ('L30', figs[1]), ('L58', figs[2])]:\n", " img = XLImage(fig_to_buffer(fig))\n", " img.anchor = anchor\n", " ws.add_image(img)\n", "\n", " autosize_columns(ws)" ] }, { "cell_type": "markdown", "id": "82-lr-hdr", "metadata": { "id": "82-lr-hdr" }, "source": [ "## 8.2 \u2014 Learning Rate Scheduling\n", "\n", "`build_lr_callback` builds a cosine-annealing `LearningRateScheduler` and plots the\n", "schedule. The AlexNet and GFNet variants use a **three-stage** multi-step cosine\n", "decay; the ViT variant uses a single-stage cosine decay.\n", "\n", "> **DRY refactor:** the identical multi-step cosine decay logic that was duplicated\n", "> in the AlexNet and GFNet branches has been extracted into `_multistep_cosine_lrfn`.\n", "> `LR_START` (which was assigned but never read in both branches) has been removed." ] }, { "cell_type": "code", "execution_count": 16, "id": "82-lr-code", "metadata": { "id": "82-lr-code", "executionInfo": { "status": "ok", "timestamp": 1779943325751, "user_tz": -330, "elapsed": 2, "user": { "displayName": "Big Story", "userId": "07276682490797804347" } } }, "outputs": [], "source": [ "def _multistep_cosine_lrfn(e, steps, lr_max, lr_min):\n", " \"\"\"Cosine-decay LR for a three-stage schedule.\n", "\n", " # DRY: consolidated repeated cosine decay logic from alexnet and gfnet branches\n", " stages: [0, steps[0]) \u2192 stage 1, [steps[0], steps[0]+steps[1]) \u2192 stage 2, else \u2192 stage 3\n", " \"\"\"\n", " if e < steps[0]:\n", " epoch2, epochs2 = e, steps[0]\n", " elif e < steps[0] + steps[1]:\n", " epoch2, epochs2 = e - steps[0], steps[1]\n", " else:\n", " epoch2, epochs2 = e - steps[0] - steps[1], steps[2]\n", " phase = math.pi * epoch2 / (epochs2 - 1)\n", " return (lr_max - lr_min) * 0.5 * (1.0 + math.cos(phase)) + lr_min\n", "\n", "\n", "def build_lr_callback(kind):\n", " \"\"\"Build a LearningRateScheduler and return (callback, figure).\"\"\"\n", " if kind == 'alexnet':\n", " LR_MAX, LR_MIN = 0.02, 0.005\n", " STEPS = [epoch, epoch * 2, epoch * 3]\n", " lrfn = lambda e: _multistep_cosine_lrfn(e, STEPS, LR_MAX, LR_MIN) # DRY\n", "\n", " elif kind == 'gfnet':\n", " LR_MAX, LR_MIN = 6e-4, 1e-7\n", " STEPS = [epoch, epoch * 2, epoch * 3]\n", " lrfn = lambda e: _multistep_cosine_lrfn(e, STEPS, LR_MAX, LR_MIN) # DRY\n", "\n", " else: # 'vit' and any other schedule: single-stage cosine decay\n", " LR_MAX, LR_MIN = 6e-4, 1e-7\n", " def lrfn(e):\n", " \"\"\"Single-stage cosine-decay LR schedule.\"\"\"\n", " phase = math.pi * e / (epoch - 1)\n", " return (LR_MAX - LR_MIN) * 0.5 * (1.0 + math.cos(phase)) + LR_MIN\n", "\n", " rng = list(range(epoch))\n", " lr_y = [lrfn(x) for x in rng]\n", " fig = plt.figure(figsize=(10, 4))\n", " plt.plot(rng, lr_y, '-o')\n", " plt.xlabel('Epoch', size=14)\n", " plt.ylabel('Learning Rate', size=14)\n", " plt.title(f'Learning rate schedule: {kind}')\n", " plt.show()\n", " return tf.keras.callbacks.LearningRateScheduler(lrfn, verbose=True), fig" ] }, { "cell_type": "markdown", "id": "83-pred-hdr", "metadata": { "id": "83-pred-hdr" }, "source": [ "## 8.3 \u2014 Prediction & Metric Helpers\n", "\n", "`predict_multihead` averages probability distributions across all K heads and returns\n", "argmax class predictions. `parameter_summary` counts total / trainable / non-trainable\n", "parameters. `history_figure` plots head-1 accuracy and overall loss curves." ] }, { "cell_type": "code", "execution_count": 17, "id": "83-pred-code", "metadata": { "id": "83-pred-code", "executionInfo": { "status": "ok", "timestamp": 1779943325751, "user_tz": -330, "elapsed": 1, "user": { "displayName": "Big Story", "userId": "07276682490797804347" } } }, "outputs": [], "source": [ "def predict_multihead(model, x_data):\n", " \"\"\"Average multi-head probabilities and return (argmax labels, averaged probs).\"\"\"\n", " y_pred_list = model.predict(x_data, verbose=0)\n", " y_pred_stacked = np.stack(y_pred_list, axis=0)\n", " y_pred_avg_probs = np.mean(y_pred_stacked, axis=0)\n", " y_pred_argmax = np.argmax(y_pred_avg_probs, axis=1)\n", " return y_pred_argmax.reshape(-1, 1), y_pred_avg_probs\n", "\n", "\n", "def parameter_summary(model):\n", " \"\"\"Return (total, trainable, non_trainable) parameter counts for a Keras model.\"\"\"\n", " trainable = int(np.sum([np.prod(v.shape) for v in model.trainable_weights]))\n", " non_trainable = int(np.sum([np.prod(v.shape) for v in model.non_trainable_weights]))\n", " return int(trainable + non_trainable), trainable, non_trainable\n", "\n", "\n", "def history_figure(history, model_name):\n", " \"\"\"Plot head-1 train/val accuracy and overall train/val loss; return the figure.\"\"\"\n", " fig = plt.figure(figsize=(24, 8))\n", " ax = plt.subplot(1, 1, 1)\n", " ax2 = ax.twinx()\n", "\n", " ax.plot(history.history.get('head_1_accuracy', []), color='blue', marker='o', linewidth=1.5, markersize=2, label='train_head_1_accuracy')\n", " ax.plot(history.history.get('val_head_1_accuracy', []), color='green', marker='o', linewidth=1.5, markersize=2, label='val_head_1_accuracy')\n", " ax.grid()\n", " ax.legend()\n", "\n", " ax2.plot(history.history.get('loss', []), color='black', marker='o', linewidth=1.5, markersize=2, label='train_loss')\n", " ax2.plot(history.history.get('val_loss', []), color='red', marker='o', linewidth=1.5, markersize=2, label='val_loss')\n", " ax2.legend()\n", "\n", " plt.title(f'accuracy and loss plot for {model_name}')\n", " plt.show()\n", " return fig" ] }, { "cell_type": "markdown", "id": "84-runner-hdr", "metadata": { "id": "84-runner-hdr" }, "source": [ "## 8.4 \u2014 Training Runner\n", "\n", "`run_training` orchestrates the full cycle for a single model: build \u2192 compile \u2192\n", "fit \u2192 reload best checkpoint \u2192 evaluate \u2192 export to Excel. Returns a summary dict\n", "for the master summary sheet." ] }, { "cell_type": "code", "execution_count": 18, "id": "84-runner-code", "metadata": { "id": "84-runner-code", "executionInfo": { "status": "ok", "timestamp": 1779943325758, "user_tz": -330, "elapsed": 7, "user": { "displayName": "Big Story", "userId": "07276682490797804347" } } }, "outputs": [], "source": [ "def run_training(model_name, spec, workbook):\n", " \"\"\"Train, evaluate, save, and export results for one configured model.\"\"\"\n", " tf.keras.backend.clear_session()\n", " gc.collect()\n", "\n", " model = spec['builder']()\n", " lr_callback, lr_fig = build_lr_callback(spec['lr_schedule'])\n", " checkpoint = ModelCheckpoint(\n", " spec['model_file'],\n", " monitor='val_head_1_accuracy',\n", " verbose=1,\n", " save_best_only=True,\n", " save_weights_only=False,\n", " mode='max',\n", " )\n", " model.compile(\n", " optimizer=spec['optimizer'](),\n", " loss=['sparse_categorical_crossentropy'] * 7,\n", " metrics=['accuracy'] * 7,\n", " )\n", "\n", " start_time = time.time()\n", " history = model.fit(\n", " x_train, [y_train] * 7,\n", " validation_data=(x_test, [y_test] * 7),\n", " validation_freq=1,\n", " batch_size=BATCH_SIZE,\n", " callbacks=[checkpoint, lr_callback],\n", " shuffle=False,\n", " epochs=epoch,\n", " )\n", " tt = time.time() - start_time\n", "\n", " # Reload best checkpoint and copy to final path\n", " reloaded = load_model(spec['model_file'], custom_objects=CUSTOM_OBJECTS, safe_mode=False)\n", " shutil.copy2(spec['model_file'], spec['final_file'])\n", "\n", " # Evaluate\n", " y_pred, _ = predict_multihead(reloaded, x_test)\n", " total_params, trainable_params, non_trainable_params = parameter_summary(reloaded)\n", " accuracy = float(accuracy_score(y_test, y_pred))\n", " kappa = float(cohen_kappa_score(y_test, y_pred))\n", " cm = confusion_matrix(y_test, y_pred)\n", " report_df = pd.DataFrame(classification_report(y_test, y_pred, output_dict=True)).T\n", "\n", " # Generate figures (performance_meausures now returns fig directly)\n", " curve_fig = history_figure(history, model_name)\n", " perf_fig = performance_meausures(\n", " y_test, y_pred, tt,\n", " total_params, trainable_params, non_trainable_params,\n", " folder_path=folder_path,\n", " )\n", "\n", " summary_row = {\n", " 'model_name': model_name,\n", " 'best_model_path': str(spec['model_file']),\n", " 'final_model_path': str(spec['final_file']),\n", " 'test_accuracy': accuracy,\n", " 'cohen_kappa': kappa,\n", " 'training_time_sec': float(tt),\n", " 'total_params': total_params,\n", " 'trainable_params': trainable_params,\n", " 'non_trainable_params': non_trainable_params,\n", " }\n", " export_training_sheet(workbook, model_name, summary_row, report_df, cm, [curve_fig, perf_fig, lr_fig])\n", " return summary_row" ] }, { "cell_type": "markdown", "id": "90-main-hdr", "metadata": { "id": "90-main-hdr" }, "source": [ "# 9.0 \u2014 Main Training Execution\n", "\n", "Iterate over `MODEL_SPECS`, run each model through `run_training`, populate the\n", "Summary worksheet, and persist the workbook and model registry JSON." ] }, { "cell_type": "code", "execution_count": 19, "id": "90-main-code", "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 1000 }, "id": "90-main-code", "executionInfo": { "status": "ok", "timestamp": 1779948803409, "user_tz": -330, "elapsed": 5477651, "user": { "displayName": "Big Story", "userId": "07276682490797804347" } }, "outputId": "5b5ab36f-7511-494e-bbdc-6b1ad2f2a53a" }, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "\n", "============================== Training AlexNet_CNN_MultiHead ==============================\n" ] }, { "output_type": "display_data", "data": { "text/plain": [ "
" ], "image/png": "iVBORw0KGgoAAAANSUhEUgAAA2wAAAGTCAYAAABUN5G0AAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAc71JREFUeJzt3XlclNX+B/DPDMgSMMAomSguoCwKCO6Ikbmk2KrmlSxFMeUWmmm2mC169aZxs5uiqaD+UlMxM69dU9yv5pKZuGQqIrigFpoDMwOyzjy/P7wz12EGGB62B/i8X69eNmee88yZ8evol3O+58gEQRBAREREREREkiOv7wEQERERERGRZUzYiIiIiIiIJIoJGxERERERkUQxYSMiIiIiIpIoJmxEREREREQSxYSNiIiIiIhIopiwERERERERSRQTNiIiIiIiIoliwkZERERERCRRTNiIiKhSAwYMwHvvvVffw2iUTpw4AT8/P6SkpNT6ayUkJMDPz09U3++++w5+fn64efNmDY9KHKmNh4iotjBhIyKqI4Z/YP7666/1PZQmpaCgAAkJCThx4kR9D4WauOzsbCQkJODixYv1PRQiakCYsBERUaVSUlIwb968+h6GKAUFBVi6dCl+/vnn+h4KNXF37tzB0qVLmbARUZXY1vcAiIiobpWWlkKv18POzs7qPlW5traJGT8REVFDxRk2IiKJyc7OxqxZs9C3b18EBgbi6aefxrfffmtyTXFxMRYvXowRI0age/fuCAkJwZgxY/DTTz+ZXHfz5k34+flh9erV+OqrrzBo0CAEBQUhIyPDWM90/fp1vPfee+jRowe6d++OWbNmoaCgwOQ+ZWvYDMs7T506hQULFqBPnz4ICQlBXFwcVCqVSV+9Xo+EhAT069cPXbt2xdixY3HlyhWr6uIqGr81n8HNmzcRFhYGAFi6dCn8/Pzg5+eHhIQE4zUZGRl444030KtXLwQFBWHEiBHYv3+/Fb9TwA8//IARI0YgNDQU3bp1w7PPPou1a9eaXKPRaPDJJ59gwIABCAwMREREBN555x2Ln9Py5csRERGBoKAgREdH4/r162avefbsWUycOBHdu3dH165d8corr+DUqVNm1/3yyy8YOXIkgoKCMGjQICQnJ5f7+X733Xdmz5X9nMpz6NAhjBkzBiEhIQgNDcXkyZORnp5uck1JSQkyMjJw586dSu936dIlvPfeexg4cCCCgoIQHh6OWbNmIScnp9K+1ozn+PHj8Pf3x+LFi036/fvf/4afnx82btxobPPz88Pf/vY37Nu3D88884zxz+Phw4fNXreyP7cnTpzAiy++CACYNWuWMRYtffZERA/jDBsRkYT8+eef+Mtf/gKZTIaXX34ZSqUShw8fxuzZs5GXl4fx48cDAPLy8rBlyxY888wzGDVqFPLz8/Htt9/i1VdfxZYtWxAQEGBy3++++w5FRUX4y1/+Ajs7O7i6uhqfe/PNN9GmTRvMmDEDFy5cwJYtW6BUKvH2229XOt758+dDoVBgypQpuHXrFtauXYu//e1v+OKLL4zXLFq0CKtWrcKTTz6Jxx9/HJcuXcLEiRNRVFRk9ediafzWfAZKpRJz5szBnDlzMHjwYAwePBgAjBtvpKen46WXXkLLli0xadIkPPLII9i1axfi4uKQkJBgvN6So0ePYsaMGQgLC8PMmTMBAJmZmUhNTUV0dDQAID8/Hy+//DIyMjIwcuRIdO7cGTk5OThw4ACys7OhVCqN90tKSoJMJkNMTAzy8vKwatUqzJw5E1u2bDFec/z4cUyaNAmBgYGYMmUKZDIZvvvuO0RHR2Pjxo0IDg4GAKSlpWHixIlQKpWYOnUqSktLkZCQgObNm1v9mVvjX//6F9577z3069cPM2fOREFBATZt2oQxY8Zg27ZtaNOmDYAHycywYcMwfPhwLFy4sMJ7Hjt2DFlZWRgxYgQ8PDyQnp6Ob775BleuXME333wDmUxWrfGEhYVhzJgxSExMxKBBg9ClSxfcuXMH8+fPR9++ffHSSy+Z3PPUqVPYs2cPxowZAycnJ6xfvx5vvPEGDh48CHd3dwDW/bn18fHBG2+8gSVLlmD06NHo3r07AKBbt27V+S0goqZAICKiOrF161bB19dXOHfuXLnXvP/++0J4eLigUqlM2qdPny50795dKCgoEARBEEpLS4WioiKTa9RqtdC3b19h1qxZxrasrCzB19dX6Natm3Dv3j2T65csWSL4+vqaXC8IghAXFyf06tXLpO3JJ58U3n33XbP3Mn78eEGv1xvbP/nkEyEgIEDQaDSCIAjC3bt3hc6dOwuvv/66yf0SEhIEX19fk3taUtH4rf0M7t27J/j6+gpLliwxu390dLTwzDPPmNxHr9cLo0ePFp566qkKxzZ//nyhW7duQmlpabnXLF68WPD19RX27Nlj9pzhc/vpp58EX19fITIy0mQca9euFXx9fYW0tDTj9U899ZQQExNj8pkXFBQIAwYMECZMmGBse/3114WgoCDh1q1bxrYrV64IAQEBgq+vr7HN8Plu3brVbHxlPzPD73lWVpYgCIKQl5cn9OjRQ/jggw9M+t29e1fo3r27SbvhdSr7/Ta8n7J27Ngh+Pr6CidPnqyR8dy/f18YPHiw8PTTTwtFRUXC5MmThW7dupl8XobPoEuXLsL169eNbRcvXhR8fX2F9evXG9us/XN77ty5cj9vIqLycEkkEZFECIKAPXv2YMCAARAEASqVyvhfv379oNVq8dtvvwEAbGxsjDVcer0eubm5KC0tRWBgIC5cuGB276eeespkNudhUVFRJo979OiB3Nxc5OXlVTpmw6zCw311Oh1u3boF4MGMUGlpKcaMGWPS75VXXqn03pWNv6qfQVm5ubn46aefEBkZiby8PONnnZOTg379+uHatWvIzs4ut79CoUBBQQGOHj1a7jV79uyBv7+/xZm6sjNFI0aMMKnL69GjBwAgKysLAHDx4kVcu3YNzz77LHJycozjvX//PsLCwnDy5Eno9XrodDocOXIEgwYNgqenp/F+Pj4+6NevX6Wfi7WOHTsGjUaDp59+2iRW5XI5unbtarIrZ5s2bZCWllbp7BoAODg4GP+/qKgIKpUKXbt2BQBj/Fd3PI6OjliwYAEyMjLw8ssv4z//+Q9mzZpl8nkZ9O3bF23btjU+9vf3h7Ozs/H3pSp/bomIxOCSSCIiiVCpVNBoNNi8eTM2b95c7jUG27Ztw5o1a3D16lWUlJQY2w3L0B5mqc2g7D9SFQoFAECtVsPZ2bnCMZfXV6PRAABu374NACb/4AUANzc3k2WZlSlv/FX5DMq6ceMGBEHA4sWLzeqZDO7du4eWLVtafG7MmDHYtWsXJk2ahJYtWyI8PByRkZGIiIgweY2nnnqq0rEAlX+W165dAwC8++675d5Dq9WiuLgYhYWFaNeundnzHTp0wKFDh6waT2UM4zEs/yyrstgpT25uLpYuXYqdO3fi3r17Js9ptdoaG0/37t3x0ksvYcOGDejXr5+xvqysVq1ambW5uroaf1+q+ueWiKiqmLAREUmEXq8HADz33HMYPny4xWsMtVfbt2/He++9h0GDBmHixIlo3rw5bGxssHLlSuNP/h/28KxFWXK55cUWgiBUOubq9K0KS+Ov6mdQluHzjomJweOPP27xmrKJ5sOaN2+Of/3rXzhy5AgOHz6Mw4cP47vvvsMLL7yATz/91Mp39j+VfZaGX9955x2zGkWDRx55BMXFxVa/Znn1YDqdrtK+hvHEx8fDw8PD7HkbGxurx/GwN998E6dPn8bEiRMREBCARx55BHq9Hq+++mqFcVXV8RQXFxuPesjKykJBQQEcHR2tfh+G16vKn1siIjGYsBERSYRSqYSTkxP0ej369u1b4bW7d++Gl5cXli5davKP7iVLltT2MKvEMGt048YNeHl5GdtzcnKgVqurdW9rP4PykhLDeJo1a1bp510eOzs7DBgwAAMGDIBer8ecOXOwefNmvP7662jXrh3atm1rtmOiWIbxOjs7VzhepVIJBwcHiztMXr161eSxYZbTMFtkYJgZtWY8zZs3F/35laVWq3H8+HFMnToVU6ZMMbYbZs9qcjxLlixBRkYG3n33XXz22WdYtGgRPvjggyqPuSp/bivaMIWIqDysYSMikggbGxsMGTIEu3fvxuXLl82ef3hZleGn/g/POJw9exZnzpyp9XFWRVhYGGxtbbFp0yaT9g0bNlT73tZ+BoZZk7JJSfPmzdGrVy9s3rzZ4nbzlS1jK7vNvFwuN86kGGa5nnrqKVy6dAl79+4161/VWcjAwEC0bdsWa9asQX5+frnjtbGxQb9+/bBv3z6TxCsjIwNHjhwx6ePs7Ax3d3f88ssvJu0Pb21fnscffxzOzs5YuXKlyXLUsuMBrN/Wv7zZrLJHJVR3PGfPnsWaNWsQHR2NmJgYTJw4EV9//bWow9Wr8ue2vFgkIqoIZ9iIiOrY1q1b8eOPP5q1jxs3Dm+99RZOnDiBv/zlLxg1ahQ6duwItVqN3377DcePHzf+g7J///7Ys2cP4uLi0L9/f9y8eRPJycno2LEj7t+/X9dvqVwtWrTAuHHjsGbNGvz1r3/F448/jrS0NBw+fBju7u7VmnGw9jNwcHBAx44dsWvXLrRv3x5ubm7o1KkTfH198fHHH2PMmDF49tln8Ze//AVeXl74888/cebMGfzxxx/4/vvvy339Dz74AGq1Gn369EHLli1x+/ZtfP311wgICICPjw8AYOLEidi9ezemTZuGkSNHokuXLlCr1Thw4ADmzp0Lf39/q9+vXC7H/PnzMWnSJDzzzDMYMWIEWrZsiezsbJw4cQLOzs5YsWIFAGDq1Kn48ccf8fLLL+Oll16CTqfD119/jY4dOyItLc3kvqNGjUJiYiJmz56NwMBA/PLLL2YzcZY4Oztjzpw5eOeddzBixAgMGzYMSqUSt2/fxqFDh9CtWzd89NFHAKzf1t/Z2Rk9e/bEqlWrUFJSgpYtW+Lo0aO4efNmjY2nqKgI7777Ltq1a4fp06cbP6+DBw9i1qxZ+Pe//41HHnmk0td7mLV/btu2bQuFQoHk5GQ4OTnhkUceQXBwsMnsMxFRWUzYiIjqWNnZJoMRI0bgsccew5YtW7Bs2TLs3bsXmzZtgpubGzp27Gg868tw7Z9//onNmzfjyJEj6NixI/7xj38gJSVF1CxBbZo5cyYcHBywZcsWHD9+HCEhIVi9ejXGjBljsitiVVXlM5g/fz7mzZuHBQsWoKSkBFOmTIGvry86duyIrVu3YunSpdi2bRtyc3OhVCrRuXNnxMXFVfj6zz33HL755hts3LgRGo0GHh4eiIyMxNSpU431aE5OTtiwYQMSEhKwd+9ebNu2Dc2bN0dYWFi5m5lUpHfv3ti8eTO+/PJLfP3117h//z48PDwQHByM0aNHG6/z9/fH6tWrsWDBAixZsgSPPfYYpk6dirt375olbIbDznfv3o1du3YhIiICq1atMh44XpFnn30Wjz76KBITE7F69WoUFxejZcuW6NGjB0aMGFHl9wc8OLdv3rx52LhxIwRBQHh4OJKSksqtM6zqeD7//HPcuHEDycnJsLe3B/BgaevChQsxevRoxMfHY86cOVUac4sWLaz6c9usWTMsXLgQn3/+OebMmYPS0lIsWLCACRsRVUgm1HRlOBERUSU0Gg169uyJN998E6+99lp9D4eIiEiyWMNGRES1qrCw0KzNUJPUq1evuh4OERFRg8IlkUREVKt27tyJbdu2ISIiAo888ghSU1OxY8cO9OvXD927d6/v4REREUkaEzYiIqpVfn5+sLGxwapVq5Cfn4/mzZtj3LhxePPNN+t7aERERJLHGjYiIiIiIiKJYg0bERERERGRRDFhIyIiIiIikigmbERERERERBLFTUfqkCAI0OulUTIol8skMxZqWBg7JAbjhsRg3JBYjB0Soy7jRi6XQSaTWXUtE7Y6pNcLUKny63sYsLWVw93dCRrNfZSW6ut7ONSAMHZIDMYNicG4IbEYOyRGXceNUukEGxvrEjYuiSQiIiIiIpIoJmxEREREREQSxYSNiIiIiIhIopiwERERERERSRQTNiIiIiIiIoliwkZERERERCRRkkzYMjIyMGHCBISEhCA8PBzx8fEoLi6utJ8gCEhMTET//v0RHByM0aNH48yZMybXHDt2DNOnT8eAAQPQtWtXDBs2DKtWrUJJSYnZ/Q4cOIDnnnsOQUFBGDJkCLZu3VpTb5GIiIiIiKhSkkvY1Go1oqOjUVJSgoSEBEyfPh3ffPMNFi5cWGnfpKQkLFmyBOPHj8fKlSvh4eGBmJgYZGVlGa9JTk5Gfn4+3njjDSQmJuKFF15AQkICPvroI5N7/fLLL5gyZQpCQkKQlJSEyMhIzJ49GykpKTX+nuuSXi/g4jUVDqXexMVrKrPDAfV6AZeu5+CnC3/g0vUcHjpJRERERFSPZIIgSOpf5CtXrsSKFStw8OBBuLm5AQA2b96MuXPn4uDBg2jZsqXFfkVFRejbty9efvllzJgxAwBQXFyMoUOHIiIiAnPmzAEAqFQqKJVKk74rVqzAF198gWPHjhmfmzhxIvLz85GcnGy87q233sLFixexc+dOUe9Np9PX68HZp9LuYOO+dORoi4xt7i72GDOoE7r7PVrp83q9gMtZucjNL4Kbkz18vdwglz848E/sc9SwGA6VzMnJ52GkZDXGDYnBuCGxGDskRl3HzYODs62bO7Ot5bFU2eHDhxEWFmZM1gAgMjISH3/8MY4ePYoRI0ZY7Jeamoq8vDxERkYa2+zs7DB48GDs3bvX2FY2WQOAgIAACIKAu3fvQqlUori4GCdOnMDMmTNNrhs2bBh27NiBmzdvok2bNtV8p3XrVNodLNt23qw9R1uEZdvOY2gvL6T8nFXh8ycu3rGYzAEoN9Gr6LnKkkAiIiIioqZOcglbZmYmRo4cadKmUCjg4eGBzMzMCvsBgLe3t0m7j48P1q5di8LCQjg4OFjsm5qaCjs7O2MSduPGDZSUlFi8l+G1GlLCptcL2LgvvcJrdp80T9YeVlEyZ4k1z1WUBDKZIyIiIiKSYMKm0WigUCjM2l1dXaFWqyvsZ2dnB3t7e5N2hUIBQRCgVqstJmzXrl3DunXrEBUVBScnJwAwvk7ZcRgeVzSOytja1n3Z4MVrKpOkyJL6WBhbURIYGdYOJ87/AdVD41a62OPlIX7o6f8gmUu7kYPcvGK4OdvBr607k7k6YJi6t3YKnwhg3JA4jBsSi7FDYkg5biSXsNWlvLw8TJ06FW3atMH06dNr/fXkchnc3Z1q/XXKKrmaU+evWV27jl83a1Npi5Dw7TmM6O+DQ6dv4Z660Phcc1cHTH4hCH2DPaHTC7iQeQ8qTSGUCgd09m4OGyZzNUqhcKzvIVADxLghMRg3JBZjh8SQYtxILmFTKBTQarVm7Wq1Gq6urhX2Ky4uRlFRkcksm0ajgUwmM+tbXFyMuLg4qNVqbN68GY888ojxOcO1Zceh0WhMnq8qvV6ARnNfVN/qaCaT1L4y1fbdfzLM2u6pC7Fg7clKZ+YAcHauGmxs5FAoHKHRFECnYyE3WYdxQ2Iwbkgsxg6JUddxo1A4NtxNR7y9vc1q1bRaLe7evWtWU1a2HwBcvXoV/v7+xvbMzEx4enqaLIfU6/WYOXMmfvvtN2zYsAGtWrUyuVfbtm3RrFkzZGZm4vHHHze518OvJUZ97Fbk4+kKdxf7CpdFymT1syyyplU0Mxc3PBAAN0GpCTqdnjtvUZUxbkgMxg2JxdghMaQYN5JL2CIiIrBixQqTWraUlBTI5XKEh4eX269bt25wdnbGrl27jAlbSUkJ9uzZg4iICJNrDUcErF69Gn5+fmb3srOzQ+/evbF7925ER0cb23fu3AkfH58GteEI8GAp5phBncrdBAQAhvS0vEtkY7J21yXkFZaatVu7CQoRERERUV2TXFWdYfOPuLg4HDlyBFu3bkV8fDyioqJMzmCLjo7G4MGDjY/t7e0RGxuLNWvWYO3atTh+/Djeeust5ObmYuLEicbrVqxYgeTkZIwdOxZ2dnY4c+aM8b+8vDzjda+99hrOnDmDOXPm4MSJE1iyZAl27NiBqVOn1s0HUcO6+z2KuOGBcHcx3ZRF6WKPuOGB+MuATuU+P7SXV10OtdZYStYelvJzltkspCGZO5V2h4eKExEREVGdk9zB2QCQkZGBefPm4fTp03BycsLzzz+P6dOnw87OznjN2LFjcevWLRw4cMDYJggCEhMTsXHjRqhUKgQEBGDWrFkIDQ016ffzzz9bfN1169ahd+/exsf79+/HF198gatXr8LT0xOTJ0/Giy++KPp91ffB2cCD+q2M22qUCDI0kwnw8XQ1WfJX3pJAS4dqK13s8VI5Z61V9lyvgEcb1Iyes4MtmjWzafJLKXkYKYnBuCExGDckFmOHxJDywdmSTNgaKykkbID4gKwoKRHzXHlJYENL5prSUkr+JUhiMG5IDMYNicXYITGYsBGAhp+w1YbGnszFDQ9EaCePRjP7JqXYoYaDcUNiMG5ILMYOiSHlhE1ym45Q0yKXy+Dfzt2svbvfo+UmOj6tXUUlc04OtsivpI6tpq3ddanCXSmJiIiIiCrChI0kqyaTOUM9XUU7ZdaGvMJSoEySaNjIpLHNvhERERFRzeOSyDrEJZF1o6J6OikttaxsIxMpauyxQ7WDcUNiMG5ILMYOicElkUR1qLyZOaDqs3PuznYoLtXXylJKzr4RERERUWWYsFGTU9WllqfT79b5UkrWvhERERERIMGDs4nqkyGZ69P5Mfi3c4dcLqvw0PHaOlQ8r7CUh3gTEREREWfYiKwhpaWUnH0jIiIiajqYsBFZSSpLKVn7RkRERNR0MGEjqgGWkjnDUkrOvhERERGRWEzYiGqR1Gbfuvs9WuGxB0REREQkLUzYiGqZVGbfNu1Lh14AkvdzBo6IiIiooWDCRlRP6nr2TaUtwvJ/md+37AwcEREREUkHt/UnqkdVOUbA3dkOTg619zOWTfvSUVqq53EBRERERBLCGTYiCaqPQ7xV2iK8tewotAUlxjYulyQiIiKqX5xhI5Ko+ph9ezhZA0wP6yYiIiKiuscZNqIGpj5m3zbtS0dXnxZIv5mLkqs5aCYT4OPpyt0liYiIiGoZEzaiBqgqO08qXewxemBHJO+/YtJeFVwuSURERFQ/mLARNSLlzb7J5TLIZbJqzcCVt1wybnhgua9JRERERNUjEwSB28DVEZ1OD5Uqv76HAVtbOdzdnZCTk4/SUn19D4fq0Km0O2YzcC6OzcySsapwdrBFs2Y2PNuNysXvHBKDcUNiMXZIjLqOG6XSCTY21m0nwhk2oibE0gxcx9aueHflcdHLJfMKS4EyB33zbDciIiKimsFdIomamLK7T9rayjFmUKdaeS2e7UZERERUPZxhI6JyNyyp7nJJblZCREREVD1M2IgIQO0slwQq3qyESRsRERFRxbgkkoiMuFySiIiISFokOcOWkZGB+fPn4/Tp03BycsLzzz+PN998E3Z2dhX2EwQBSUlJ2LhxI1QqFQICAjBr1iyEhIQYr1GpVPjyyy9x9uxZXLx4Ec2aNcPp06fN7qXT6bBmzRps3boVv//+O1q0aIGnnnoKU6ZMgZOTU02/ZSLJKm+5pLuzHYpL9cgvs+GItbhckoiIiKhykkvY1Go1oqOj0b59eyQkJCA7OxsLFy5EYWEhPvroowr7JiUlYcmSJZg5cyb8/PywYcMGxMTEYPv27fDy8gIAZGdnY+fOnQgODkZgYCDS0tIs3mv58uVYvnw5pk2bhuDgYKSnp+Pzzz/HnTt3sGjRohp/30RSZlgumXFbjRJBhmYyAT6erjidfrfWznZj0kZEREQkwYQtOTkZ+fn5WLp0Kdzc3AA8mO2aO3cuYmNj0bJlS4v9ioqKsHLlSsTExGD8+PEAgO7du2Po0KFYvXo15syZAwDw8/PDsWPHAAAJCQnlJmw7duzAs88+i8mTJwMA+vTpg5ycHCQlJaG0tBS2tpL76IhqlVwuQ0B7pckZJbW1Wcmmfeno6tMCV26peRg3ERERNWmSyzoOHz6MsLAwY7IGAJGRkfj4449x9OhRjBgxwmK/1NRU5OXlITIy0thmZ2eHwYMHY+/evcY2udy6sr3S0lI4OzubtLm4uIDnjBOZqo3NSrhckoiIiOgByW06kpmZCW9vb5M2hUIBDw8PZGZmVtgPgFlfHx8f3L59G4WFhVUax6hRo/D999/j+PHjyM/Px7lz57B+/XpERUVxdo2ojNrYrKS85ZKn0u5U675EREREDYnkMg+NRgOFQmHW7urqCrVaXWE/Ozs72Nvbm7QrFAoIggC1Wg0HBwerxxEbG4vi4mJMmDDBOKv23HPP4f3337f6HpbY2tZ/jmxjIzf5lchaVYmd3l0eg9xGjg2706B6eLnkI82gvV+N5ZL709Hd71Gk38xFbl4x3Jzt4NfWncslJYzfOSQG44bEYuyQGFKOG8klbFLx9ddfY926dZg1axY6d+6M9PR0LF68GPPmzcPHH38s6p5yuQzu7tLZYVKhcKzvIVADZW3sPBXWAQN7t8eFzHtQaQqhVDjAr70Skz/Zi3vqqs16G6g0RXgz4Qg0+cXGtuauDpj8QhD6BnuKuifVDX7nkBiMGxKLsUNiSDFuJJewKRQKaLVas3a1Wg1XV9cK+xUXF6OoqMhklk2j0UAmk1XYt6ycnBx8+umneOeddzB27FgAQM+ePeHs7Iy3334b48aNQ4cOHarwrh7Q6wVoNPer3K+m2djIoVA4QqMpgE6nr+/hUAMiNnbaNHdEm+YPvgDztQUYM9gXCd+eEz2Oh5M1ALinLsSCtScx9cVg9PRnjZvU8DuHxGDckFiMHRKjruNGoXC0ejZPcgmbt7e3Wa2aVqvF3bt3zerTyvYDgKtXr8Lf39/YnpmZCU9Pzyoth8zKykJxcTECAgJM2jt37gwAuHHjhqiEDQBKS6XzxaHT6SU1Hmo4qhs7oR1b1Mrukht2p6Grd3MAMNkEhTtMSgO/c0gMxg2JxdghMaQYN5JL2CIiIrBixQqTWraUlBTI5XKEh4eX269bt25wdnbGrl27jAlbSUkJ9uzZg4iIiCqNwdPzwbKq3377DT169DC2nz//4LypNm3aVOl+RGSutnaX3HHsGg6dvW16yDd3mCQiIqIGSnIJW1RUFNavX4+4uDjExsYiOzsb8fHxiIqKMjmDLTo6Grdv3zZu2W9vb4/Y2FgkJCRAqVTC19cXmzZtQm5uLiZOnGjyGikpKQCAK1euQKfTGR8HBQWhdevWaNGiBQYNGoTFixdDp9Ohc+fOuHLlChISEtC3b1/4+PjU0adB1LgZdpd82JhBnap1GPe/jlw1a+OB3ERERNRQyQQJHiyWkZGBefPm4fTp03BycsLzzz+P6dOnw87OznjN2LFjcevWLRw4cMDYJggCEhMTsXHjRqhUKgQEBGDWrFkIDQ01ub+fn5/F112wYIHxnLe8vDwsW7YM+/btQ3Z2Njw8PPDkk09i6tSpVaqHe5hOp4dKlS+qb02ytZWbHH5MZK26ip1TaXdqfLkkAChd7BH/Wl8uj6xj/M4hMRg3JBZjh8So67hRKp2srmGTZMLWWDFho4auLmNHrxdqdLmkwczRIZDLZaxvq0P8ziExGDckFmOHxJBywia5JZFEREDtLJcEgOXbzyO/sNT4mPVtREREJGXSOxmOiKgc3f0eRdzwQLi72Ju0K13s8UK/9lbd4+FkDfhffduptDs1NUwiIiKiGsMZNiJqUCztLunr5QYAOHT2d9FLJjftS0dXnxa4ckvN5ZJEREQkGUzYiKjBsbRcEqjekkmVtghvLTtqsrEJl0sSERFRfeOSSCJqNMpbMunkYN3PpsruQsnlkkRERFTfOMNGRI2KpSWTekHAZ8lnRN+TyyWJiIiovjBhI6JGp+ySSb1egLuLvej6Ni6XJCIiovrCJZFE1OjJ5TKMGdSpWvfgckkiIiKqD0zYiKhJKK++zcWxWbXuu2lfOvR6oVr3ICIiIioPl0QSUZNhqb6tY2tXvLvyeLWWS166ngO5XMb6NiIiIqpxTNiIqEmxdCRAdY4DAIDl28+bHMjN+jYiIiKqKVwSSURNXnWXSz6crAGsbyMiIqKawxk2IiLUznLJTfvSEdrJg8sjiYiISDQmbERE/1XTyyVZ30ZERETVxYSNiKgChuWSG/elm8y0OTnYmi2FtIT1bURERFQdTNiIiCphabmkXhDwWfKZSvuWV98WNzyQSRsRERFVigkbEZEVyi6X1OsFuLvYV6u+ratPC1y5peZySSIiIioXEzYiIhHkclm169veWnYU2oISYxuXSxIREVFZ3NafiEik8o4DcHKw7mdhDydrAI8DICIiInOcYSMiqobq1LeVh8cBEBERkQETNiKiaqrp+jYeB0BEREQGTNiIiGpYdevbAB4HQERERA+who2IqBaUV9/m4tjMqv7lHQfA+jYiIqKmhTNsRES1xFJ9W8fWrnh35fFqHQfA+jYiIqKmQ5IzbBkZGZgwYQJCQkIQHh6O+Ph4FBcXV9pPEAQkJiaif//+CA4OxujRo3HmzBmTa1QqFebPn49Ro0YhMDAQoaGh5d6vqKgIixcvxoABAxAYGIj+/fvj008/re7bI6ImxFDf1qfzY/Bv5w5bWznGDOok+n6G+rZL13Pw04U/cOl6DvR6oQZHTERERFIiuRk2tVqN6OhotG/fHgkJCcjOzsbChQtRWFiIjz76qMK+SUlJWLJkCWbOnAk/Pz9s2LABMTEx2L59O7y8vAAA2dnZ2LlzJ4KDgxEYGIi0tDSL99Lr9Xj99deRlZWFKVOmoE2bNrh9+zauXr1a4++ZiJoWw3LJjfvSTWbanBxszZZCWsL6NiIioqZDcglbcnIy8vPzsXTpUri5uQEAdDod5s6di9jYWLRs2dJiv6KiIqxcuRIxMTEYP348AKB79+4YOnQoVq9ejTlz5gAA/Pz8cOzYMQBAQkJCuQnb1q1bcfbsWezcuROPPsp/BBFRzarOcQDl1bfFDQ9k0kZERNTISG5J5OHDhxEWFmZM1gAgMjISer0eR48eLbdfamoq8vLyEBkZaWyzs7PD4MGDcfjwYWObXG7dW96yZQuGDh3KZI2Iak3Z5ZL+bd3NNimpik370rk8koiIqJGRXMKWmZkJb29vkzaFQgEPDw9kZmZW2A+AWV8fHx/cvn0bhYWFVo+hpKQEFy5cgKenJ9555x2EhIQgNDQU06ZNw927d6vwboiIrGc4DkAslbYIl7NyodcLrHEjIiJqJKq9JPLKlSvIzMzE/fv38cILL1R7QBqNBgqFwqzd1dUVarW6wn52dnawtzf96bRCoYAgCFCr1XBwcLBqDLm5uSgpKUFSUhJ69uyJpUuXQqVS4R//+AemTp2K5OTkqr2ph9ja1n+ObGMjN/mVyFqMndrXu8tjkNvIsWF3GlQP17c52iK/oPL6trMZf2LVjgsmfZUu9nh5iB96+tfPigHGDYnBuCGxGDskhpTjRnTCdu7cOXz44Ye4fPmysc2QsJ08eRKvvvoqPv/8cwwcOLDag6xrer0eAODk5ISlS5fCzs4OANCiRQtMmDABx48fR1hYWJXvK5fL4O7uVKNjrQ6FwrG+h0ANFGOndj0V1gEDe7fHhcx7UGkKoVQ4QCcI+HDFsUr77v45y6xNpS1CwrfnMCu6J/oGe9bGkK3CuCExGDckFmOHxJBi3IhK2NLT0xEdHQ25XI7x48cjMzPTpE6sR48ecHd3R0pKSpUTNoVCAa1Wa9auVqvh6upaYb/i4mIUFRWZzLJpNBrIZLIK+1q6l0wmQ7du3YzJGgD06tULNjY2uHLliqiETa8XoNHcr3K/mmZjI4dC4QiNpgA6nb6+h0MNCGOnbrVp7og2zR/8xaHXC1C62JvMnFXVym3n4NdaUednuDFuSAzGDYnF2CEx6jpuFApHq2fzRCVsCQkJAIDvvvsO7dq1w9KlS00SNplMhpCQEPz6669Vvre3t7dZrZpWq8Xdu3fN6tPK9gOAq1evwt/f39iemZkJT09Pq5dDAoCjoyNat25d7vNFReL/wVRaKp0vDp1OL6nxUMPB2KkfLw3qhGXbzovur9IU4XzGPcjlMuPOlL5ebnWWwDFuSAzGDYnF2CExpBg3ohZp/vzzzxgyZAjatWtX7jWtWrUStUFHREQEjh07Bo1GY2xLSUmBXC5HeHh4uf26desGZ2dn7Nq1y9hWUlKCPXv2ICIiosrjePLJJ5GammqSnP3000/Q6XTo0qVLle9HRFRdhvPbyu4kqXSxx+Aebay6x/Lt5xG/6TQSv7+A+E2n8fbyYziVdqc2hktEREQ1QNQMW35+PpRKZYXXFBUVGWvBqiIqKgrr169HXFwcYmNjkZ2djfj4eERFRZmcwRYdHY3bt29j7969AAB7e3vExsYiISEBSqUSvr6+2LRpE3JzczFx4kST10hJSQHwYMMUnU5nfBwUFGScWZs4cSK2b9+O119/HePGjYNKpcKiRYvQvXt39OnTp8rvi4ioJlg6v83Xyw2Xs3Kx95eblfbnGW5EREQNi6iErVWrViabjVhy4cIFeHl5Vfnerq6uWLt2LebNm4e4uDg4OTnhxRdfxPTp002u0+v10Ol0Jm2TJk2CIAhYs2YNVCoVAgICsHr1arNxTJs2zeLjBQsWYMSIEcb3uG7dOnzyySeYOnUqHB0dMXDgQLz33nuQyeq2/oOI6GGG89se5uvlBncXe+SIrHHbtC8doZ086ry+jYiIiComKmHr378/1q9fj2PHjqFv375mz+/cuRNnzpzB66+/LmpQPj4++Oqrryq8Zv369WZtMpkMsbGxiI2NrbBvWlqaVeMICAiw+DpERFJjOMNNbI2bSluES9dz6q2+jYiIiCwTlbD99a9/xe7duzF58mS88MIL+PPPPwEAGzZswJkzZ/DDDz+gdevWmDBhQo0OloiIymeocdu4L91kps3JwdZsKaQly7efN7nO3cUeYwZ14lJJIiKieiQTBEEQ0zErKwtvv/02zpw5Y/Zc165dsWjRIrRpY10RfFOh0+mhUuXX9zBgayuHu7sTcnLyJbcLDkkbY6dh0OsFkxo3vSDgs+Qzou9X3fo2xg2JwbghsRg7JEZdx41S6VS72/oDgJeXF5KTk3Hx4kWcOXMGarUazs7OCA4ORnBwsNjbEhFRNZWtcdPrBda3ERERNVCiEzaDgIAABAQE1MRYiIioFrC+jYiIqOESdQ7bwIEDsW7dugqv2bBhAwYOHChqUEREVLPKO8PNycG6n9vx/DYiIqL6IWqG7datWyYHW1ui0Whw+/ZtUYMiIqKaZ+kMN2vr23h+GxERUf2o9pLI8mi1WtjZ2dXW7YmISATWtxERETUsVidsJ0+eNHl869YtszYA0Ol0+OOPP/Dvf/8b7du3r/YAiYio9rC+jYiISNqs3tbf398fMpl1fwELggCZTIYFCxbghRdeqM74GhVu608NHWOn8TqVdkf0+W1lryt7fhvjhsRg3JBYjB0So1Fs6x8XFweZTAZBELBs2TL07NkTvXv3NrtOLpfD1dUVffr0gY+Pj/WjJiKiesP6NiIiImmyOmGbOnWq8f9//vlnjBw5krNnRESNSG3VtxEREZF4orb1X79+PZM1IqJGzlDfJpZKW4TLWbk1NyAiIqImSFTCRkRETUN1z29T5RXi4jUVDqXexMVrKuj1VpVNExER0X+J3tb/999/x/Lly3Hs2DHcuXMHJSUlZtfIZDJcuHChWgMkIqL6VZ36ts37rkBb8L+/H8puSEJEREQVE5WwZWVlYdSoUdBoNOjYsSOKi4vh6ekJe3t7ZGVlobS0FP7+/nBxcanp8RIRUT0QW9/2cLIGcEMSIiKiqhK1JHLp0qXIy8vDV199he+//x4AMGLECOzatQsHDhzAgAEDUFBQgCVLltToYImISBqqW9+2aV86l0cSERFZQVTCduzYMURERKBXr15mzz366KP44osvAAD//Oc/qzU4IiKSrvLq21wcm1Xa13Dg9qXrOfjpwh+4dD2HCRwREZEFopZE5uTkwNvb+383sbVFQUGB8bGdnR369u2Lffv2VX+EREQkWZbq23K0RUjaUXn98vLt5ys8cJuIiIhEzrC5u7ubJGhubm64deuWyTU2NjbQarXVGx0REUmeob6tT+fH4N/O3WzGrTzlHbh9Ku1ObQyTiIioQRKVsLVv3x43btwwPg4ODsaRI0eQlZUFAFCpVNi9eze8vLxqZpRERNRg+Hq5WZ20WcL6NiIiov8RlbA9/vjjOHHiBDQaDQAgOjoa+fn5eO655zBy5EgMGTIEf/75J8aOHVujgyUiIumriQO3Wd9GRET0gEwQhCr/LZiXl4eMjAz4+PjA2dkZALBr1y4sXboUWVlZ8PT0xNixY/Hyyy/X+IAbMp1OD5Uqv76HAVtbOdzdnZCTk4/SUn19D4caEMYOVcWptDvYuC/dZOt/Jwdbs6WQlpS9jvVtTQ+/b0gsxg6JUddxo1Q6wcbGurkzUQkbicOEjRo6xg5VlV4vIOO2GiWCDM1kAkpK9VYduF0ent/WdPD7hsRi7JAYUk7YRC2JtIZer8d3331XW7cnIqIGQC6XIaC9Ek90a4OA9kr4t7V+UxJLWN9GRERNTa0kbN9//z0iIyMxe/ZsUf0zMjIwYcIEhISEIDw8HPHx8SguLq60nyAISExMRP/+/REcHIzRo0fjzJkzJteoVCrMnz8fo0aNQmBgIEJDQyu97/nz5xEQEGDVtUREVL6aqG+7nJVbcwMiIiKSuColbDk5OVi6dCn++te/YsqUKfjqq69QWFhofH7//v14+umn8e677+LGjRsYPHhwlQekVqsRHR2NkpISJCQkYPr06fjmm2+wcOHCSvsmJSVhyZIlGD9+PFauXAkPDw/ExMQYd68EgOzsbOzcuRPNmzdHYGBgpfcUBAHz5s2DUqms8nshIiJz5R247eRg3dGgqrxCbkhCRERNhtUHZ//5558YNWoU/vjjDxjK3vbv34+9e/fiq6++wgcffIDvv/8eADBo0CDExcXB39+/ygNKTk5Gfn4+li5dCjc3NwCATqfD3LlzERsbi5YtW1rsV1RUhJUrVyImJgbjx48HAHTv3h1Dhw7F6tWrMWfOHACAn58fjh07BgBISEhAWlpahePZunUrcnJyMHLkSKxfv77K74eIiMxZOnBbLwhW1bcl77uCvIIS42NuSEJERI2Z1TNsK1aswO+//46IiAh88cUX+OKLL9CvXz+kpqZi/Pjx2L59O3r06IFt27YhISFBVLIGAIcPH0ZYWJgxWQOAyMhI6PV6HD16tNx+qampyMvLQ2RkpLHNzs4OgwcPxuHDh41tcrn1k4oajQaLFi3CrFmz0KxZs6q9ESIiqlDZA7etrW97OFkDeOA2ERE1blZnLz/++CM6duyIlStXYujQoRg6dCgSExPh7e2N1NRUvPDCC1i/fr3oRM0gMzMT3t7eJm0KhQIeHh7IzMyssB8As74+Pj64ffu2ydJNa33xxRfo0qULnnzyySr3JSKiqqlufRs3JCEiosbI6iWRf/zxB0aNGmXSJpPJEBYWhszMTEyZMqVGBqTRaKBQKMzaXV1doVarK+xnZ2cHe3vTn84qFAoIggC1Wg0HBwerx3Hx4kV8++232LZtm/WDt4Ktba1tzGk1wxai1m4lSmTA2CExqhI3vbs8BrmNHBt2p0H10PltLo80g/Z+SQU9H2xIknFbDb+27ki7kYPcvGK4OdvBr6075HJZ9d4E1Tl+35BYjB0SQ8pxY3XCVlRUZLJM0cDQ1qZNm5oaU70TBAFz587FmDFj4OPjU2P3lctlcHd3qrH7VZdC4VjfQ6AGirFDYlgbN0+FdcDA3u1xIfMeVJpCKBUO+FNdgM83plba97fruUj89wXcU/9vVUVzVwdMfiEIfYM9RY+d6g+/b0gsxg6JIcW4sTphqysKhQJardasXa1Ww9XVtcJ+xcXFKCoqMpll02g0kMlkFfYta+fOncjMzMSiRYug0WgAPEhYDfezt7c3m8mzhl4vQKO5X+V+Nc3GRg6FwhEaTQF0Oh4oSdZj7JAYYuOmTXNHtGn+4C9OrbbAqj7f/2i+dP6euhAL1p7E1BeD0dOfG5M0FPy+IbEYOyRGXceNQuFo9WxelRK21NRUJCUlmbSdOnUKALBq1Srj7pEPmzRpUlVeAt7e3ma1alqtFnfv3jWrTyvbDwCuXr1qUkeXmZkJT0/PKi2HzMzMhFqtxoABA8ye69mzJyZNmoSZM2dafb+H1cXJ6dbS6fSSGg81HIwdEqM6cePj6Qp3F3vkPLRMsqo27E5DV+/mXB7ZwPD7hsRi7JAYUoybKiVsx44dM26JX9Znn31m1iaTyaqcsEVERGDFihUmtWwpKSmQy+UIDw8vt1+3bt3g7OyMXbt2GRO2kpIS7NmzBxEREVUaw/Dhw9GrVy+Ttm3btmHnzp1ISkqCpyeX1RAR1SXDhiTLtp0XfQ+VtgiXrudALpcZjxLw9XJjAkdERJJmdcK2YMGC2hyHUVRUFNavX4+4uDjExsYiOzsb8fHxiIqKMjmDLTo6Grdv38bevXsBAPb29oiNjUVCQgKUSiV8fX2xadMm5ObmYuLEiSavkZKSAgC4cuUKdDqd8XFQUBBat26NNm3amNXk/fzzz7CxsUHv3r1r8+0TEVE5DAdub9yXbjLTpnSxR3c/D+z95Wal91i+/TzyC0uNj3mGGxERSZ3VCdvw4cNrcxxGrq6uWLt2LebNm4e4uDg4OTnhxRdfxPTp002u0+v10Ol0Jm2TJk2CIAhYs2YNVCoVAgICsHr1anh5eZlcN23aNIuPFyxYgBEjRtTCuyIioppg6cBtXy83XM7KtSphezhZA/53hlvc8EAmbUREJEkywVLhGdUKnU4PlSq/vocBW1s53N2dkJOTL7k1uiRtjB0Soy7iRq8X8PbyY6Jr3JQu9oh/rS+XR0oIv29ILMYOiVHXcaNUOlm96Yj0DhogIiKqouoeuq3SFuFyVm7NDYiIiKiGMGEjIqJGwVDj5u5ieuyKk4N1q/9VeYW4dD0HP134A5eu50Cv5wIUIiKqf5I7h42IiEgsSzVuekHAZ8lnKu27ed8VaAtKjI+5IQkREUkBEzYiImpU5HIZ/Nu5Gx/r9YJVZ7g9nKwB3JCEiIikgUsiiYioUatufdumfelcHklERPWGCRsRETV65dW3uTg2q7Sv4cBt1rcREVF94JJIIiJqEizVt+Voi5C040KlfXngNhER1RdRCdu4ceMqvUYul8PZ2RkdOnTAoEGD0LVrVzEvRUREVGPK1rddup5jVT8euE1ERPVFVML2888/AwBkMhksnbtdtn3VqlUYMWIE/v73v4scJhERUc3z9XKzakOS8mzal47QTh48cJuIiGqNqBq2c+fO4cknn4SPjw8WLVqEgwcP4ty5czh48CAWLVqEjh07YsCAATh06BDWrFmDzp0747vvvsPGjRtrevxERESi8cBtIiKSOlEJ25IlS3D58mV88803ePrpp9GqVSvY2dmhVatWePrpp7F582akpaVh/fr16Nu3L/7v//4PSqUS3333XU2Pn4iIqFp44DYREUmZqCWRO3bsQGRkJB555BGLzz/yyCN46qmn8MMPP2DmzJlQKBR4/PHHsXv37moNloiIqDbwwG0iIpIqUQmbSqVCSUlJhdeUlpbi3r17xsceHh7Q6/ViXo6IiKjW8cBtIiKSIlFLItu2bYuUlBTk5FjeXSsnJwe7du1C27ZtjW137tyBq6uruFESERHVMR64TUREUiAqYXvllVfw559/YsSIEVi3bh3Onz+P33//HefPn8e6deswYsQI3Lt3D6+88goAQK/X46effkJQUFCNDp6IiKg28cBtIiKqb6KWREZFRSE7OxuJiYlYsGCByXOCIEAul2Py5MmIiooCAOTm5iImJgahoaHVHzEREVEd4oHbRERUn2SCpYPUrHTt2jXs2LEDaWlpyMvLg7OzM/z8/PD000+jQ4cONTnORkGn00Olyq/vYcDWVg53dyfk5OSjtJR1hWQ9xg6J0Rjj5tL1HMRvOi26P+vbKtcY44bqBmOHxKjruFEqnWBjY91iR1EzbAbt27fHlClTqnMLIiKiBocHbhMRUV0RVcNGRETUlNXEgdusbyMiImtUa4bt3Llz+PXXX6HRaKDT6cyel8lkiIuLq85LEBERSZJhQ5KN+9JNZtqcHGxN6tbKw/o2IiKyhqiELTc3F3FxcUhNTUVFJXBM2IiIqDGrzoHbZZM6nt9GRESWiErYFi5ciFOnTqFXr14YPnw4HnvsMdjY2NT02IiIiCRP7IHb5WF9GxERPUxUwnbw4EEEBwdj7dq1kMn4FwoREZGBob5t2bbzovqrtEW4nJVrkgQSEVHTJWrTkaKiIvTo0YPJGhERkQXlHbjt5GDdz0lVeYXckISIiACInGHz9/fHrVu3anosREREjUZ16ts277sCbUGJ8TE3JCEiarpEzbBNmTIFBw4cwJkzZ2p4OA9kZGRgwoQJCAkJQXh4OOLj41FcXFxpP0EQkJiYiP79+yM4OBijR482G6NKpcL8+fMxatQoBAYGIjQ01Ow+Op0OSUlJePnll9G7d2/06tULY8eOxS+//FJTb5GIiJoAQ31bn86Pwb+dO/zbupvNulnycLIG/G9DklNpd2prqEREJFGiZtj+/PNP9O/fH6+88gqeffZZdOnSBc7OzhavfeGFF6p0b7VajejoaLRv3x4JCQnIzs7GwoULUVhYiI8++qjCvklJSViyZAlmzpwJPz8/bNiwATExMdi+fTu8vLwAANnZ2di5cyeCg4MRGBiItLQ0s/sUFhYiMTERw4cPx6RJkyCXy/HNN99g3LhxWL16NcLCwqr0noiIiIDq17dxQxIioqZHJlS0L385/P39IZPJTLb0L1vPJggCZDIZLl68WKV7r1y5EitWrMDBgwfh5uYGANi8eTPmzp2LgwcPomXLlhb7FRUVoW/fvnj55ZcxY8YMAEBxcTGGDh2KiIgIzJkzBwCg1+shlz+YWExISMCaNWtw+vRpk3vpdDrk5eXB1dXVpO2ZZ55Bu3btsGLFiiq9p//dQw+VKl9U35pkayuHu7sTcnLyUVqqr+/hUAPC2CExGDfmTqXdMTu/zcWxmdnMmiXvvBQKXy83k6WWvl5ujS6JY9yQWIwdEqOu40apdIKNjXWLHUXNsC1YsEBMN6scPnwYYWFhxmQNACIjI/Hxxx/j6NGjGDFihMV+qampyMvLQ2RkpLHNzs4OgwcPxt69e41thmStIjY2NibJmqHNz88PN27cqOI7IiIiMmWpvi1HW4SkHRcq7Xs6/S6SdlwwSfZY40ZE1HiJStiGDx9e0+MwyszMxMiRI03aFAoFPDw8kJmZWWE/APD29jZp9/Hxwdq1a1FYWAgHBwfR4yotLcXZs2fRvXt30fcgIiIyKHt+26XrOVb12/vLTbM2HrpNRNR4iUrYapNGo4FCoTBrd3V1hVqtrrCfnZ0d7O1Ni7kVCgUEQYBara5WwrZq1SpkZ2dj/Pjxou8BPJhurW+G6Vdrp2GJDBg7JAbjxjqdOyihdLGHSuSB2wCwaX86ega0bBTLIxk3JBZjh8SQctxILmGToqNHjyIhIQGvv/46AgMDRd9HLpfB3d2pBkdWPQqFY30PgRooxg6JwbipXOyIYCxYe1J0f5WmCLdzChHUsUUNjqp+MW5ILMYOiSHFuLEqYfP394dcLscPP/yADh06GDcdqYxMJsOFC5Wvx3+YQqGAVqs1a1er1WZ1ZWX7FRcXo6ioyGSWTaPRQCaTVdi3Ir/99humTp2KZ555BlOmTBF1DwO9XoBGc79a96gJNjZyKBSO0GgKoNOxGJesx9ghMRg31gvwcsXUF4OxYXeayUybUmGPnv6PYvfPWZXe4/rtXGi1BcjNK4absx382ro3yBk3xg2JxdghMeo6bhQKx5rddKRnz54AAEdHR5PHtcHb29usVk2r1eLu3btm9Wll+wHA1atX4e/vb2zPzMyEp6enqOWQ169fx6RJkxAaGor58+dXub8lUtqtSKfTS2o81HAwdkgMxo11Qju2QFfv5ma7QF7OyrUqYdu453KjOnSbcUNiMXZIDCnGjVUJ2/r16yt8XJMiIiKwYsUKk1q2lJQUyOVyhIeHl9uvW7ducHZ2xq5du4wJW0lJCfbs2YOIiIgqj+POnTuIiYlBq1atsGTJEjRr1kzcGyIiIqqishuSAICvlxvcXexNdoe0pLxDt7khCRFRwyS5GraoqCisX78ecXFxiI2NRXZ2NuLj4xEVFWVyBlt0dDRu375t3LLf3t4esbGxSEhIgFKphK+vLzZt2oTc3FxMnDjR5DVSUlIAAFeuXIFOpzM+DgoKQuvWrVFYWIhJkyYhJycHs2fPRnp6urGvnZ0dOnfuXNsfAxERkQkeuk1E1DRJLmFzdXXF2rVrMW/ePMTFxcHJyQkvvvgipk+fbnKdXq+HTqczaZs0aRIEQcCaNWugUqkQEBCA1atXw8vLy+S6adOmWXy8YMECjBgxAn/++ScuXboEAHjttddMrm3dujUOHDhQI++ViIioKrr7PYq44YGiDt1WaYtw6XoO5HJZoz5wm4iosZEJgiCI6ahSqbB161b8+uuv0Gq1ZskT8GDTkbVr11Z7kI2FTqeHSpVf38Oo85PcqfFg7JAYjJuap9cLog7ddnKwRX5hqfGxlOvbGDckFmOHxKjruFEqnWp205GyLl26hOjoaGg0GlSU71mzkyQRERFVjdhDtx9O1gDWtxERNQSiErZPP/0UarUar732Gl588UU89thjsLGxqemxERERkRWs3ZCkPKxvIyKSLlFHeZ85cwaDBg3CtGnT0Lp1ayZrRERE9ciwIYlYKm0RLmfl1tyAiIioxohK2Jo1a2a2kQcRERHVH8OGJO4u9ibtTg7WLaZR5RXi0vUc/HThD1y6ngO9XlSJOxER1TBRSyJ79uyJ8+fFbStMREREtaO736MI7eRhsiGJXhDwWfKZSvtu3nelUR24TUTUWIiaYXv33XeRnp6O1atX1/R4iIiIqBoMG5L06fwY/Nu5w7+tu9msmyXlHbh9Ku1ObQ2ViIisIGqGbfny5ejUqRM+++wzJCcnIyAgAE5OTmbXyWQyfPLJJ9UeJBEREYnDA7eJiBo2UQnbtm3bjP+flZWFrKwsi9cxYSMiIqp/PHCbiKjhEpWw7d+/v6bHQURERLXIUn2btQduL99+vsEcuE1E1NiISthOnjyJ5s2b4/HHH6/p8RAREVEt4YHbREQNj6hNR2bPno0ff/yxpsdCREREdchw4LZYm/alc/t/IqJaJiph8/DwgE6nq+mxEBERUR2qiQO3L13P4fltRES1SNSSyAEDBuDo0aMoLi6GnZ1dTY+JiIiI6kh5G5I4OdiaLYW0hPVtRES1SyYIQpV/FKbVahEdHY0WLVrg7bffRqdO4n8615TodHqoVPn1PQzY2srh7u6EnJx8lJbq63s41IAwdkgMxk3DoNcLog7cLk9169sYNyQWY4fEqOu4USqdYGNj3WJHUTNsL7zwAoqLi3Hx4kX8+OOPsLe3h1KphExmusWvTCbDvn37xLwEERER1aGyG5Lo9QLcXexNZt2qgue3ERHVDFE1bIIgoFmzZmjVqhVatWoFpVJpbH/4P72eP9UgIiJqiGqivu1yVm7NDYiIqIkSNcN24MCBmh4HERERSUx169tUeYW4dD2HB24TEVWDqISNiIiImgZLB25bW9+WvO8K8gpKjI+5IQkRUdUxYSMiIqIKia1vezhZA3jgNhGRGNVK2E6fPo1jx47hzp07KC4uNnteJpPhk08+qc5LEBERkcQY6tuWbTsvqj83JCEisp6ohK20tBQzZszA3r17IQgCZDIZHj4dwPCYCRsREVHjVF59m4tjM2jLzKyVZThwWy6Xsb6NiKgSohK2NWvWYM+ePRg5ciTGjBmDkSNHIjo6GsOGDcPJkyeRlJSEsLAwzJw5s6bHS0RERBJhqb4tR1uEpB0XKu3LA7eJiKwjalv/f//73+jUqRP+/ve/o0uXLgAAFxcXdO3aFa+++iq+/vpr/Oc//8GRI0dqdLBEREQkLYb6tj6dH4N/O3e4u9hb1a/sLpOG+rZTaXdqY5hERA2WqITtxo0b6N27t/GxTCZDaen/vng7deqEJ598Eps2bar+CImIiKjB8PVyszpps2TTvnTo9ULlFxIRNRGiErZmzZrBwcHB+PiRRx6BSqUyucbT0xPXr18XNaiMjAxMmDABISEhCA8PR3x8vMVNTcoSBAGJiYno378/goODMXr0aJw5c8bkGpVKhfnz52PUqFEIDAxEaGhoufc7cOAAnnvuOQQFBWHIkCHYunWrqPdDRETUVNTEgduXrufg4jUVDqXexMVrKiZwRNSkiUrYWrVqhd9//9342NvbGydPnjTZeOTs2bNwdXWt8r3VajWio6NRUlKChIQETJ8+Hd988w0WLlxYad+kpCQsWbIE48ePx8qVK+Hh4YGYmBhkZWUZr8nOzsbOnTvRvHlzBAYGlnuvX375BVOmTEFISAiSkpIQGRmJ2bNnIyUlpcrviYiIqCkxbEhSdqbNycG60vnl289jwdep+GzDKSz4OhVvLz/GpZJE1GSJ2nSkZ8+e2L9/v3EnyGHDhuHTTz9FbGwsnnjiCZw6dQqnTp3CyJEjq3zv5ORk5OfnY+nSpXBzcwMA6HQ6zJ07F7GxsWjZsqXFfkVFRVi5ciViYmIwfvx4AED37t0xdOhQrF69GnPmzAEA+Pn54dixYwCAhIQEpKWlWbzf8uXLERwcjL/97W8AgD59+iArKwtLlizB0KFDq/y+iIiImpLqHLhdXn0bz28joqZI1AzbyJEj0b9/f2RnZwMAXnnlFfTv3x+HDx/GvHnzsHPnTgQFBeGtt96q8r0PHz6MsLAwY7IGAJGRkdDr9Th69Gi5/VJTU5GXl4fIyEhjm52dHQYPHozDhw8b2+Tyyt9ycXExTpw4YZaYDRs2DBkZGbh582YV3hEREVHTVHZDEv+21m9KYgnr24ioKRI1w9alSxfMnTvX+LhZs2ZYsWIFfv31V2RlZcHT0xPBwcFWJUdlZWZmms3MKRQKeHh4IDMzs8J+wIPlmQ/z8fHB2rVrUVhYaFJ3V5EbN26gpKTE4r0Mr9WmTRur7kVEREQPVPfAbZW2CJezcuHr5WYyc8cz3IioMROVsJUnKCgIQUFB1bqHRqOBQqEwa3d1dYVara6wn52dHeztTX9yp1AoIAgC1Gq11Qmb4XXKjsPwuKJxVMbWVtSkZo2ysZGb/EpkLcYOicG4oYf17vIY5DZybNidBtVDB247Odoiv6C0gp4PnM34E6t2XDDpq3Sxx8tD/NDTn8slid85JI6U46ZaCVtxcTGOHz+OzMxM3L9/H3FxcQAe1JPl5eXB3d1d1CxbYyWXy+Du7lTfwzBSKBzrewjUQDF2SAzGDRk8FdYBA3u3x4XMe1BpCqFUOEAnCPhwxbFK++7+OcusTaUtQsK35zAruif6BnvWxpCpAeJ3DokhxbgRnbDt378fH330EVQqlXHzEUPClpaWhtGjRyM+Ph7PPvtsle6rUCig1WrN2tVqdYW7TioUChQXF6OoqMhklk2j0UAmk1Vpx0rDtWXHodFoTJ6vKr1egEZzX1TfmmRjI4dC4QiNpgA6nb6+h0MNCGOHxGDcUHnaNHdEm+YP/nGk1wtQutibzJxV1cpt5+DXWsHlkU0cv3NIjLqOG4XC0erZPFEJ26lTpzBt2jR4eHhg9uzZOHPmDH744Qfj88HBwWjbti327NlT5YTN29vbrFZNq9Xi7t27ZjVlZfsBwNWrV+Hv729sz8zMhKenp9XLIQGgbdu2aNasGTIzM/H444+b3Ovh1xKjtFQ6Xxw6nV5S46GGg7FDYjBuqDIvVaO+DQBUmiKcz7gHuVzG+jbidw6JIsW4EZWwffnll3BxccHWrVuhVCqRm5trdk1gYCDOnTtX5XtHRERgxYoVJrVsKSkpkMvlCA8PL7dft27d4OzsjF27dhkTtpKSEuzZswcRERFVGoOdnR169+6N3bt3Izo62ti+c+dO+Pj4cMMRIiKiWmA4v23jvnTklKlR6+7ngb2/VL5L8/Lt502OBXB3sceYQZ14HAARNViiErZz585hyJAhUCqV5V7TqlUrHDhwoMr3joqKwvr16xEXF4fY2FhkZ2cjPj4eUVFRJmewRUdH4/bt29i7dy8AwN7eHrGxsUhISIBSqYSvry82bdqE3NxcTJw40eQ1DIdfX7lyBTqdzvg4KCgIrVu3BgC89tprGDduHObMmYPIyEicOHECO3bswD//+c8qvyciIiKyjuH8tozbapQIMjSTCfDxdMXlrFyrEjae4UZEjY2ohK24uBjOzs4VXmOoHasqV1dXrF27FvPmzUNcXBycnJzw4osvYvr06SbX6fV66HQ6k7ZJkyZBEASsWbMGKpUKAQEBWL16Nby8vEyumzZtmsXHCxYswIgRIwAAPXr0QEJCAr744gt8++238PT0xPz5803OeSMiIqKaJ5fLENBeCXd3J+Tk5KO0VA9fLze4u9ibzLxVxaZ96Qjt5MHlkUTU4IhK2Ly8vPDrr79WeM2ZM2dE13r5+Pjgq6++qvCa9evXm7XJZDLExsYiNja2wr5paWlWjWPgwIEYOHCgVdcSERFR7amJM9wuXc9hfRsRNTii9tx/6qmnkJqaiq1bt1p8fvXq1UhPT8ewYcOqNTgiIiIiA0ONm7uL6ZmrTg7W/fx5+fbziN90GonfX0D8ptN4e/kxnEq7UxtDJSKqMTJBEISqdsrPz8fo0aORkZGBPn36oLi4GKmpqZgwYQLOnDmD06dPIyAgAMnJybCzs6uNcTdIOp0eKlV+fQ8DtrZyk2UmRNZi7JAYjBsSo6K40esFXM7KNc6U6QUBnyWfEf1arG9rXPidQ2LUddwolU61u62/k5MTNmzYgL/97W9ISUkx1pKtWbMGMpkMkZGR+Pjjj5msERERUY2Ty2Xwb+dufKzXC6xvI6JGS/TB2a6urli0aBE++OAD/Prrr1Cr1XB2dkZQUBBatGhRk2MkIiIiKhfr24ioMROdsBm4u7tbPOcsMTERR44cwbp166r7EkREREQVKu8MNycHW7Ot/i3h+W1EJFXVTtjKc/XqVZw8ebK2bk9ERERkwnCGm5j6Np7fRkRSVWsJGxEREVFdY30bETU2orb1JyIiImoIDPVtYhnq2y5dz8FPF/7Apes50OurvME2EZFonGEjIiKiRo31bUTUkDFhIyIiokaP9W1E1FAxYSMiIqImgfVtRNQQWZ2wTZo0qUo3vnz5cpUHQ0RERFRXeH4bETUEVidsP/74Y5VvLpPxC4uIiIiki/VtRCR1Vids+/fvr81xEBEREdUL1rcRkZRZnbC1bt26NsdBREREVG9Y30ZEUsVz2IiIiIjK4PltRCQV3CWSiIiIyALWtxGRFDBhIyIiIioH69uIqL4xYSMiIiKqAOvbiKg+sYaNiIiIqApY30ZEdYkzbERERERVxPo2IqorTNiIiIiIRGB9GxHVBSZsRERERCLVVn0bAJNE0NfLjTVvRE0UEzYiIiKiGmKob1u27byo/iptEXYcu4ZDZ2+bJH1cMknUdEly05GMjAxMmDABISEhCA8PR3x8PIqLiyvtJwgCEhMT0b9/fwQHB2P06NE4c+aM2XXZ2dmYOnUqQkND0atXL8yePRt5eXkm1+h0OiQlJWHo0KHo2rUrBg4ciE8//RT5+fk19TaJiIioETLUt7m72Ju0OzlY93Pyfx25ajZDZ1gyeSrtTo2Nk4gaBsnNsKnVakRHR6N9+/ZISEhAdnY2Fi5ciMLCQnz00UcV9k1KSsKSJUswc+ZM+Pn5YcOGDYiJicH27dvh5eUFACgpKcGrr74KAFi0aBEKCwvx6aef4q233sLKlSuN91q+fDmWL1+OadOmITg4GOnp6fj8889x584dLFq0qPY+ACIiImrwqlPfVhEeCUDU9EguYUtOTkZ+fj6WLl0KNzc3AA9mu+bOnYvY2Fi0bNnSYr+ioiKsXLkSMTExGD9+PACge/fuGDp0KFavXo05c+YAAHbv3o309HTs3LkT3t7eAACFQoGJEyfi3LlzCA4OBgDs2LEDzz77LCZPngwA6NOnD3JycpCUlITS0lLY2kruoyMiIiIJqen6NuB/RwLI5TLWtxE1EZJbEnn48GGEhYUZkzUAiIyMhF6vx9GjR8vtl5qairy8PERGRhrb7OzsMHjwYBw+fNjk/n5+fsZkDQDCw8Ph5uaGQ4cOGdtKS0vh7Oxs8houLi4QBJ6TQkRERFVX3fPbDJZvP4/4TaeR+P0FxG86jbeXH+NSSaJGTHIJW2ZmpkkyBTyYAfPw8EBmZmaF/QCY9fXx8cHt27dRWFhY7v1lMhk6dOhgcv9Ro0bh+++/x/Hjx5Gfn49z585h/fr1iIqK4uwaERERiVJefZvSxR4v9Gtv1T3KOxKASRtR4yS5zEOj0UChUJi1u7q6Qq1WV9jPzs4O9vamX4AKhQKCIECtVsPBwQEajQYuLi6V3j82NhbFxcWYMGGCcVbtueeew/vvvy/2rQEAbG3rP0e2sZGb/EpkLcYOicG4ITEac9z07vIYega0RNqNHOTmFcPN2Q5+bR8snTx89neoxB4JsD8dPQNaNvnlkY05dqj2SDluJJewScXXX3+NdevWYdasWejcuTPS09OxePFizJs3Dx9//LGoe8rlMri7O9XwSMVTKBzrewjUQDF2SAzGDYnRmOOmb3Nns7bYEcFYsPakqPupNEW4ea8AcrkMKk0hlAoHdPZuDpsmmsA15tih2iPFuJFcwqZQKKDVas3a1Wo1XF1dK+xXXFyMoqIik1k2jUYDmUxm7KtQKMy28Dfcv1WrVgCAnJwcfPrpp3jnnXcwduxYAEDPnj3h7OyMt99+G+PGjUOHDh2q/N70egEazf0q96tpNjZyKBSO0GgKoNPp63s41IAwdkgMxg2J0VTjJsDLFVNfDMaG3WkmM21OjrbILyitoOcDC9b+bLJkUulij5eH+KGnf9M5v62pxg5VT13HjULhaPVsnuQSNm9vb7NaNa1Wi7t375rVnpXtBwBXr16Fv7+/sT0zMxOenp5wcHAwXnf58mWTvoIg4OrVqwgPDwcAZGVlobi4GAEBASbXde7cGQBw48YNUQkbAJSWSueLQ6fTS2o81HAwdkgMxg2J0RTjJrRjC3T1bi7qSICy9W0qbRESvj2HuOGBTe7Q7aYYO1R9UowbyS3SjIiIwLFjx6DRaIxtKSkpkMvlxoTKkm7dusHZ2Rm7du0ytpWUlGDPnj2IiIgwuf+lS5dw7do1Y9vx48eRm5uLJ554AgDg6ekJAPjtt99MXuP8+fMAgDZt2oh/g0RERESVMBwJ0KfzY/Bv5w7/tu5mG5VUxaZ96Sgt1ePS9Rz8dOEPXLqeA72eO18TNQSSm2GLiorC+vXrERcXh9jYWGRnZyM+Ph5RUVEmZ7BFR0fj9u3b2Lt3LwDA3t4esbGxSEhIgFKphK+vLzZt2oTc3FxMnDjR2G/IkCFYuXIlpk6dihkzZqCgoADx8fHo37+/8Qy2Fi1aYNCgQVi8eDF0Oh06d+6MK1euICEhAX379oWPj0/dfihERETUpBmOBFi27byo/iptEd5adhTaghJjm7uLPcYM6tTkZt6IGhqZIMGDxTIyMjBv3jycPn0aTk5OeP755zF9+nTY2dkZrxk7dixu3bqFAwcOGNsEQUBiYiI2btwIlUqFgIAAzJo1C6GhoSb3z87Oxvz583HkyBHY2tpi8ODBeP/9903OXcvLy8OyZcuwb98+ZGdnw8PDA08++SSmTp1aYS1dRXQ6PVSqfFF9a5KtrRzu7k7IycmX3JQvSRtjh8Rg3JAYjBvLTqXdwcZ96SaHbzs52JothayKxrZckrFDYtR13CiVTlbXsEkyYWusmLBRQ8fYITEYNyQG46Z8er0gqr6tPEoXeyyMDcOVW2rjPX293Brs8QCMHRJDygmb5JZEEhEREVH5DPVtBnq9AHcXe5NZt6rgckkiaZPcpiNEREREZD1DfVt1PJysAUCOtgjLtp3HqbQ71bovEVUfEzYiIiKiBq6736OIGx5otpOki2Ozat2Xu0sS1T8uiSQiIiJqBLr7PYrQTh4m9W0dW7vi3ZXHuVySqAHjDBsRERFRI1H2/DZbWzmXSxI1cEzYiIiIiBqx2lwuyeWRRLWPSyKJiIiIGrnaWi556XoO5HJZozgOgEiqmLARERERNQFljwMAgDGDOmHZtvOi77l8+3mTQ7tZ30ZU87gkkoiIiKiJqu5yyYeTNYD1bUS1gTNsRERERE1YbSyX3LQvHV19WuDKLTWXSxJVExM2IiIioiauppdL8jgAoprDJZFEREREZKa85ZJODtb9vL+i4wD0eoGHcRNZiTNsRERERGSRpeWSekHAZ8lnRN9z7a5L2Lgv3WS5JWffiMrHhI2IiIiIylV2uaReL8DdxV50fVteYSlQzmYlccMDmbQRlcElkURERERkNblchjGDOtXKvQ2HcXPJJNH/cIaNiIiIiKrEUN9Wdmmji2Mzs9q1qlBpi7Dj2DUcOnubSyaJ/osJGxERERFVWW0cBwAA/zpy1ayNSyapKeOSSCIiIiISxVDf1qfzY/Bv5w5bW3mtLZcEHiyZLC3Vc7kkNSmcYSMiIiKiGlPeckl3ZzsUl+qRX2bDkarg+W7UFDFhIyIiIqIaZWm5pK+XG06n3xV9GLdBeee7cbkkNVZcEklERERENa7sckm5XFbuYdxKF3u80K99tV7PsFzy4jUVDqXexMVrKi6XpEaBM2xEREREVGfKm30DgENnfxe9YQmXS1JjxRk2IiIiIqpTlmbfauJ8t/KWS55Ku8Oz3ajB4gwbEREREUlCbZ3vtnbXJfNNUDj7Rg0EEzYiIiIikozaON8tr7AUKLM75cOblVhaoimXy2ri7RBVmyQTtoyMDMyfPx+nT5+Gk5MTnn/+ebz55puws7OrsJ8gCEhKSsLGjRuhUqkQEBCAWbNmISQkxOS67OxszJ8/H0eOHEGzZs0wePBgzJo1C87OzibXFRUVYcWKFdi+fTvu3LmDFi1aIDIyEu+++25Nv2UiIiIi+i/DksmHjRnUqdo7TFrC2TeSOsnVsKnVakRHR6OkpAQJCQmYPn06vvnmGyxcuLDSvklJSViyZAnGjx+PlStXwsPDAzExMcjKyjJeU1JSgldffRXXrl3DokWLMGfOHBw5cgRvvfWWyb30ej1ef/11/PDDD5gyZQrWrFljVdJIRERERDWvvB0mXRybVeu+eYWlZjN3D9e+EdU3yc2wJScnIz8/H0uXLoWbmxsAQKfTYe7cuYiNjUXLli0t9isqKsLKlSsRExOD8ePHAwC6d++OoUOHYvXq1ZgzZw4AYPfu3UhPT8fOnTvh7e0NAFAoFJg4cSLOnTuH4OBgAMDWrVtx9uxZ7Ny5E48+yp+uEBEREdW32lguWZFN+9LR1acFrtxSc7kk1RvJzbAdPnwYYWFhxmQNACIjI6HX63H06NFy+6WmpiIvLw+RkZHGNjs7OwwePBiHDx82ub+fn58xWQOA8PBwuLm54dChQ8a2LVu2YOjQoUzWiIiIiCSk7A6Ttrbyau8uWR7DUQHxm04j8fsLiN90Gm8vP8aZN6pTkkvYMjMzTZIp4MEMmIeHBzIzMyvsB8Csr4+PD27fvo3CwsJy7y+TydChQwfjPUpKSnDhwgV4enrinXfeQUhICEJDQzFt2jTcvXu32u+RiIiIiGpOecsl3Z3t4ORQvQVlPCqA6pvklkRqNBooFAqzdldXV6jV6gr72dnZwd7e9A+qQqGAIAhQq9VwcHCARqOBi4tLhffPzc1FSUkJkpKS0LNnTyxduhQqlQr/+Mc/MHXqVCQnJ4t+f7a29Z8j29jITX4lshZjh8Rg3JAYjBuqqt5dHkPPgJZIv6VGUakAe1sZOrV2xanLd5Hw7bkaf721KeablShd7PHyED/09OcKrYZGyt85kkvYpECv1wMAnJycsHTpUuNGIy1atMCECRNw/PhxhIWFVfm+crkM7u5ONTrW6lAoHOt7CNRAMXZIDMYNicG4oapq3tx01++nwpzh7GSPxH/9invqwv9d5+qA4hIdtPfFne+WV1AKwPSoAJW2CAnfnsOs6J7oHdgKFzLvQaUphFLhgM7ezWHD2jfJk+J3juQSNoVCAa1Wa9auVqvh6upaYb/i4mIUFRWZzLJpNBrIZDJjX4VCgby8PIv3b9WqlfEamUyGbt26mewK2atXL9jY2ODKlSuiEja9XoBGc7/K/WqajY0cCoUjNJoC6HT6+h4ONSCMHRKDcUNiMG5ILEuxE+DlikVx4Ui7kYPcvGK4OdvBr617rc2+JXxzGiu+O8fZtwakrr9zFApHq2fzJJeweXt7m9WqabVa3L1716z2rGw/ALh69Sr8/f2N7ZmZmfD09ISDg4PxusuXL5v0FQQBV69eRXh4OADA0dERrVu3Lve1iorE70JUWiqdv3R0Or2kxkMNB2OHxGDckBiMGxLLUux0auNm/H+9XkBoxxaIGx5otrTRxbGZWe1aVVQ0+xY3PBDd/R6FXi/wsG4JkuJ3juQStoiICKxYscKkli0lJQVyudyYUFnSrVs3ODs7Y9euXcaEraSkBHv27EFERITJ/b///ntcu3YN7du3BwAcP34cubm5eOKJJ4zXPfnkk0hJSTGZsfvpp5+g0+nQpUuXmn7bRERERFQP6uOoAL0AJO8v/7BuJnP0MJkgCJLazkatVuPpp59Ghw4dEBsbi+zsbCxcuBDPPvssPvroI+N10dHRuH37Nvbu3WtsS0xMREJCAmbOnAlfX19s2rQJR44cwfbt2+Hl5QXgQRI3YsQIAMCMGTNQUFCA+Ph4+Pn5YeXKlcZ7/f7773juuecQHByMcePGQaVSYdGiRWjbti02bNgAmazqf2h0Oj1UqnyxH02NsbWVw93dCTk5+ZL7CQJJG2OHxGDckBiMGxKrpmLnVNodLNt2vgZHZp2hvbxw4uKdcpM5qh11/Z2jVDpZvSRScgkbAGRkZGDevHk4ffo0nJyc8Pzzz2P69Okm9WRjx47FrVu3cODAAWObIAhITEzExo0boVKpEBAQgFmzZiE0NNTk/tnZ2Zg/fz6OHDkCW1tbDB48GO+//z6cnU2LVC9evIhPPvkEZ8+ehaOjIwYOHIj33nvP4i6W1mDCRg0dY4fEYNyQGIwbEqsmY+dU2h2z5ZLuznYoLtUjv7C0gp61I254oNlsIGffagYTNgLAhI0aPsYOicG4ITEYNyRWTceOpeWJp9Pv1svsm7ODLZo1s+FSylog5YRNcjVsRERERERSIZfL4N/O3aTNcFB3Xc++5RWWAmXubTjIm0spGy8mbEREREREVWRps5L6nH1L+TnLrM2QzHEpZcPGhI2IiIiISISqzL4pXewxemBHJO+/Uiu7T1Zk7a5L5rOBXErZYDBhIyIiIiKqQeXNvsnlMshlsjqfgavOUkomc/WPCRsRERERUQ2zNPsGVDwD1yvgUYtLG2tTRUspq5PMMdGrOUzYiIiIiIjqUEUzcD6tXSVzlIDYZA5AhUswASZ0VcFt/esQt/Wnho6xQ2IwbkgMxg2J1RhiR0pHCdS0uOGBACpO6MTO3FVnxk/K2/ozYatDTNiooWPskBiMGxKDcUNiNebYsXSQd30tpRTL2cH2QU1dOcTO3Il9zjDjx4SNADBho4aPsUNiMG5IDMYNidXYY6e8mSJLyVx9LaVsSOKGB6K736OSTthYw0ZERERE1EBUtJmJlM6Fayg27UtHaCeP+h5GhaxL64iIiIiISNIMyVyfzo/Bv5075HKZcVdKdxd7k2uVLvYY2surnkYqHSptES5n5db3MCrEGTYiIiIiokasqrtSNrS6uOrKza/bg8yrigkbEREREVEjV9WllLWVzDk52Equps7Nyb7yi+oREzYiIiIioiasJpO5l8rZlfHh56RUU6d0efCepIwJGxERERERWSQmmQNQ4XNxwwMlswzzpUGdJH9gNxM2IiIiIiKqsvKSucqeq62ZOzHPGc5hkzImbEREREREVKdqY+ZO7HNSx4SNiIiIiIgkQ+zMndjnpI7nsBEREREREUkUEzYiIiIiIiKJYsJGREREREQkUUzYiIiIiIiIJIoJGxERERERkUQxYSMiIiIiIpIomSAIQn0PoqkQBAF6vTQ+bhsbOXQ6fX0Pgxogxg6JwbghMRg3JBZjh8Soy7iRy2WQyaw7B44JGxERERERkURxSSQREREREZFEMWEjIiIiIiKSKCZsREREREREEsWEjYiIiIiISKKYsBEREREREUkUEzYiIiIiIiKJYsJGREREREQkUUzYiIiIiIiIJIoJGxERERERkUQxYSMiIiIiIpIoJmxEREREREQSxYSNiIiIiIhIopiwERERERERSRQTtiYmIyMDEyZMQEhICMLDwxEfH4/i4uL6HhZJxK5du/Daa68hIiICISEheP755/Htt99CEAST67Zs2YIhQ4YgKCgIzz33HA4ePFhPIyYpys/PR0REBPz8/PDrr7+aPMfYIUu2bduGF154AUFBQejduzdeffVVFBYWGp8/cOAAnnvuOQQFBWHIkCHYunVrPY6WpGD//v0YNWoUQkND0a9fP0ybNg1ZWVlm1/E7p+m6fv06PvroIzz//PPo3LkznnnmGYvXWRMjWq0W77//Pnr16oXQ0FC88cYbuHPnTm2/BSMmbE2IWq1GdHQ0SkpKkJCQgOnTp+Obb77BwoUL63toJBFfffUVHB0d8d5772H58uWIiIjAhx9+iGXLlhmv+eGHH/Dhhx8iMjISSUlJCAkJwZQpU3DmzJn6GzhJypdffgmdTmfWztghS5YvX4558+Zh2LBhWL16Nf72t7+hTZs2xhj65ZdfMGXKFISEhCApKQmRkZGYPXs2UlJS6nnkVF9OnDiBKVOmoGPHjli2bBnef/99XLp0CTExMSaJPr9zmrb09HQcOnQI7dq1g4+Pj8VrrI2RN998E0ePHsWcOXPw2Wef4erVq5g0aRJKS0vr4J0AEKjJWLFihRASEiLk5OQY25KTk4WAgADhjz/+qL+BkWTcu3fPrO2DDz4QunXrJuh0OkEQBOGpp54SZsyYYXLN6NGjhVdffbVOxkjSduXKFSEkJETYtGmT4OvrK5w7d874HGOHysrIyBA6d+4s/Oc//yn3mpiYGGH06NEmbTNmzBAiIyNre3gkUR9++KEwYMAAQa/XG9uOHz8u+Pr6CidPnjS28TunaTP8u0UQBOHdd98Vnn76abNrrImR1NRUwdfXV/jxxx+NbRkZGYKfn5/www8/1MLIzXGGrQk5fPgwwsLC4ObmZmyLjIyEXq/H0aNH629gJBlKpdKsLSAgAHl5ebh//z6ysrJw7do1REZGmlwzbNgwHD9+nMtrCfPnz0dUVBQ6dOhg0s7YIUu+++47tGnTBk888YTF54uLi3HixAkMHTrUpH3YsGHIyMjAzZs362KYJDGlpaVwcnKCTCYztrm4uACAcQk/v3NILq84zbE2Rg4fPgyFQoHw8HDjNd7e3ggICMDhw4drfuAWMGFrQjIzM+Ht7W3SplAo4OHhgczMzHoaFUndqVOn0LJlSzg7OxvjpOw/xn18fFBSUmKxfoCajpSUFFy+fBlxcXFmzzF2yJKzZ8/C19cXX375JcLCwhAYGIioqCicPXsWAHDjxg2UlJSY/d1lWN7Ev7uaphEjRiAjIwMbNmyAVqtFVlYWPv/8c3Tu3BndunUDwO8cqpy1MZKZmYkOHTqY/IAAeJC01dV3EBO2JkSj0UChUJi1u7q6Qq1W18OISOp++eUX7Ny5EzExMQBgjJOycWR4zDhqugoKCrBw4UJMnz4dzs7OZs8zdsiSu3fv4siRI9i+fTs+/vhjLFu2DDKZDDExMbh37x7jhizq0aMHli5dikWLFqFHjx4YNGgQ7t27h6SkJNjY2ADgdw5VztoY0Wg0xhnch9Xlv5+ZsBGRRX/88QemT5+O3r17Y9y4cfU9HJK45cuXo3nz5hg5cmR9D4UaEEEQcP/+fSxevBhDhw7FE088geXLl0MQBHz99df1PTySqNTUVLzzzjv4y1/+grVr12Lx4sXQ6/WYPHmyyaYjRI0FE7YmRKFQQKvVmrWr1Wq4urrWw4hIqjQaDSZNmgQ3NzckJCQY14Eb4qRsHGk0GpPnqWm5desW1qxZgzfeeANarRYajQb3798HANy/fx/5+fmMHbJIoVDAzc0N/v7+xjY3Nzd07twZV65cYdyQRfPnz0efPn3w3nvvoU+fPhg6dCgSExNx4cIFbN++HQD/vqLKWRsjCoUCeXl5Zv3r8t/PTNiaEEtrbbVaLe7evWtWH0BNV2FhIWJjY6HVarFq1SqTZQCGOCkbR5mZmWjWrBm8vLzqdKwkDTdv3kRJSQkmT56Mnj17omfPnvjrX/8KABg3bhwmTJjA2CGLOnbsWO5zRUVFaNu2LZo1a2YxbgDw764mKiMjwyTJB4DHHnsM7u7uuHHjBgD+fUWVszZGvL29cfXqVbMzaa9evVpn30FM2JqQiIgIHDt2zPiTA+DBJgFyudxk5xtqukpLS/Hmm28iMzMTq1atQsuWLU2e9/LyQvv27c3OP9q5cyfCwsJgZ2dXl8MliQgICMC6detM/ps1axYAYO7cufj4448ZO2TRk08+idzcXFy8eNHYlpOTg99++w1dunSBnZ0devfujd27d5v027lzJ3x8fNCmTZu6HjJJgKenJy5cuGDSduvWLeTk5KB169YA+PcVVc7aGImIiIBarcbx48eN11y9ehUXLlxAREREnYzVtk5ehSQhKioK69evR1xcHGJjY5GdnY34+HhERUWZ/cOcmqa5c+fi4MGDeO+995CXl2dycGTnzp1hZ2eHqVOnYubMmWjbti169+6NnTt34ty5c6w3acIUCgV69+5t8bkuXbqgS5cuAMDYITODBg1CUFAQ3njjDUyfPh329vZITEyEnZ0dxowZAwB47bXXMG7cOMyZMweRkZE4ceIEduzYgX/+85/1PHqqL1FRUfjkk08wf/58DBgwALm5ucY62oe3aOd3TtNWUFCAQ4cOAXiQ0Ofl5RmTs169ekGpVFoVI6GhoejXrx/ef/99vPvuu7C3t8c///lP+Pn54amnnqqT9yITys7vUaOWkZGBefPm4fTp03BycsLzzz+P6dOn8ydNBAAYMGAAbt26ZfG5/fv3G3+avWXLFiQlJeH27dvo0KEDZsyYgSeffLIuh0oSd+LECYwbNw7ffvstgoKCjO2MHSpLpVJhwYIFOHjwIEpKStCjRw/MmjXLZLnk/v378cUXX+Dq1avw9PTE5MmT8eKLL9bjqKk+CYKA5ORkbNq0CVlZWXByckJISAimT59uPPLBgN85TdfNmzcxcOBAi8+tW7fO+INGa2JEq9ViwYIF2Lt3L0pLS9GvXz988MEHdTbhwYSNiIiIiIhIoljDRkREREREJFFM2IiIiIiIiCSKCRsREREREZFEMWEjIiIiIiKSKCZsREREREREEsWEjYiIiIiISKKYsBEREREREUkUEzYiIqIGbMCAARgwYEB9D4OIiGqJbX0PgIiIqL7dvHkTAwcOrPCa1q1b48CBA3U0IiIiogeYsBEREf1X27Zt8dxzz1l8zsXFpY5HQ0RExISNiIjIqG3btpg6dWp9D4OIiMiINWxERERV5Ofnh7Fjx+KPP/7AjBkz0Lt3b3Tt2hVRUVE4duyYxT4qlQp///vfMWDAAAQGBiIsLAzTpk3D5cuXLV5fXFyMr776CiNHjkRoaChCQ0MxbNgwLFiwAGq12uz6/Px8zJ8/H/369UNgYCCeffZZpKSk1Oj7JiKiuicTBEGo70EQERHVJ0MNW79+/bB69epKr/fz84Ofnx+0Wi3c3d3Rt29fqFQq7Nq1C0VFRViyZAkGDRpkvF6lUmH06NG4ceMGevXqhZCQENy8eRO7d++GnZ0dVq1ahR49ehivLywsxIQJE5Camor27dvj8ccfR7NmzXD9+nUcO3YMmzZtQkBAAIAHm46UlJSgdevWUKvV6Nu3LwoKCrBz504UFhZi1apV6NevX81/aEREVCe4JJKIiOi/bty4gYSEBIvPde3aFREREcbHaWlpeOaZZ/DZZ59BJpMBAMaNG4cXX3wRH374Ifr16wcHBwcAwD/+8Q/cuHEDsbGxmDFjhvEehw4dwuTJk/H+++8jJSUFcvmDhS+LFy9Gamoqnn/+eSxYsAA2NjbGPlqt1nidwZ07dxAUFIR169bBzs4OAPDss89i/Pjx+L//+z8mbEREDRgTNiIiov+6ceMGli5davG5cePGmSRsNjY2mDFjhjFZAwB/f388//zz+Pbbb3Ho0CEMGTIExcXF+OGHH+Dm5obXXnvN5J5PPPEEwsPDcfToUaSmpqJHjx4oLS3F5s2b4eLigtmzZ5ska0D5m5/MmjXLmKwBQFhYGFq3bo3z589X+XMgIiLpYA0bERHRf/Xr1w9paWkW/5s9e7bJta1atULr1q3N7mFY2njhwgUAQGZmJoqKihAcHAxHR0ez63v37g0AuHjxovH6/Px8BAUFwdXV1apxKxQKeHl5mbW3bNkSGo3GqnsQEZE0MWEjIiISoUWLFhbbmzdvDgDIy8sz+bW86z08PEyu02q1AB4kW9Yqb9bN1tYWer3e6vsQEZH0MGEjIiIS4c8//7TYfu/ePQCAs7Ozya/lXW9oN1ynUCgAANnZ2TU3WCIiarCYsBEREYnw+++/49atW2btv/zyCwCgc+fOAABvb2/Y29vj119/RUFBgdn1J06cAADjro8dOnSAs7Mzfv31V4vb9xMRUdPChI2IiEgEnU6Hzz//HA+fjnPp0iVs374dSqUSTzzxBADAzs4OTz/9NHJycrBy5UqTexw+fBhHjhxBu3bt0K1bNwAPljGOHj0aWq0Wf//736HT6Uz6aLVa5Ofn1/K7IyIiqeAukURERP9V0bb+ADB58mTY29sDeHAWW2pqKkaOHGlyDptOp8O8efOMW/oDwNtvv42TJ09i+fLlOH36NLp27Ypbt24hJSUFjo6O+OSTT0y26p82bRrOnj2L7du34+zZs3j88cdhZ2eHmzdv4scff8TGjRuNM3JERNS4MWEjIiL6r4q29QeA6OhoY8Lm6uqKxMREfPrpp9iyZQsKCgrQuXNnTJ06FeHh4Sb9lEolvvnmG3z55Zc4cOAATp06BWdnZwwcOBBTpkyBr6+vyfX29vb4v//7P3z99df4/vvvsWXLFsjlcnh6eiIqKsri7pRERNQ4yYSH13IQERFRpfz8/NCrVy+sX7++vodCRESNHGvYiIiIiIiIJIoJGxERERERkUQxYSMiIiIiIpIo1rARERERERFJFGfYiIiIiIiIJIoJGxERERERkUQxYSMiIiIiIpIoJmxEREREREQSxYSNiIiIiIhIopiwERERERERSRQTNiIiIiIiIoliwkZERERERCRRTNiIiIiIiIgk6v8BKlWvxPcSK9MAAAAASUVORK5CYII=\n" }, "metadata": {} }, { "output_type": "stream", "name": "stdout", "text": [ "\n", "Epoch 1: LearningRateScheduler setting learning rate to 0.02.\n", "Epoch 1/100\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 130ms/step - head_1_accuracy: 0.4073 - head_1_loss: 1.6977 - head_2_accuracy: 0.3398 - head_2_loss: 1.7464 - head_3_accuracy: 0.4029 - head_3_loss: 1.7110 - head_4_accuracy: 0.4062 - head_4_loss: 1.7422 - head_5_accuracy: 0.4046 - head_5_loss: 1.7099 - head_6_accuracy: 0.3698 - head_6_loss: 1.7147 - head_7_accuracy: 0.3773 - head_7_loss: 1.6937 - loss: 12.0167\n", "Epoch 1: val_head_1_accuracy improved from None to 0.55012, saving model to /content/drive/My Drive/Classification/multicp/models/AlexNet_CNN_MultiHead_best.keras\n", "\n", "Epoch 1: finished saving model to /content/drive/My Drive/Classification/multicp/models/AlexNet_CNN_MultiHead_best.keras\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m42s\u001b[0m 226ms/step - head_1_accuracy: 0.4492 - head_1_loss: 1.5317 - head_2_accuracy: 0.4142 - head_2_loss: 1.5573 - head_3_accuracy: 0.4403 - head_3_loss: 1.5308 - head_4_accuracy: 0.4416 - head_4_loss: 1.5590 - head_5_accuracy: 0.4372 - head_5_loss: 1.5392 - head_6_accuracy: 0.4163 - head_6_loss: 1.5443 - head_7_accuracy: 0.4257 - head_7_loss: 1.5338 - loss: 10.8948 - val_head_1_accuracy: 0.5501 - val_head_1_loss: 2.0560 - val_head_2_accuracy: 0.4921 - val_head_2_loss: 1.8468 - val_head_3_accuracy: 0.5483 - val_head_3_loss: 1.8366 - val_head_4_accuracy: 0.5515 - val_head_4_loss: 1.9912 - val_head_5_accuracy: 0.5009 - val_head_5_loss: 1.8426 - val_head_6_accuracy: 0.5429 - val_head_6_loss: 1.9569 - val_head_7_accuracy: 0.5230 - val_head_7_loss: 1.9485 - val_loss: 13.4867 - learning_rate: 0.0200\n", "\n", "Epoch 2: LearningRateScheduler setting learning rate to 0.019996224067873887.\n", "Epoch 2/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 57ms/step - head_1_accuracy: 0.4702 - head_1_loss: 1.5369 - head_2_accuracy: 0.4546 - head_2_loss: 1.4889 - head_3_accuracy: 0.4577 - head_3_loss: 1.4957 - head_4_accuracy: 0.4626 - head_4_loss: 1.4993 - head_5_accuracy: 0.4558 - head_5_loss: 1.4985 - head_6_accuracy: 0.4463 - head_6_loss: 1.5187 - head_7_accuracy: 0.4570 - head_7_loss: 1.5007 - loss: 10.5387\n", "Epoch 2: val_head_1_accuracy improved from 0.55012 to 0.59165, saving model to /content/drive/My Drive/Classification/multicp/models/AlexNet_CNN_MultiHead_best.keras\n", "\n", "Epoch 2: finished saving model to /content/drive/My Drive/Classification/multicp/models/AlexNet_CNN_MultiHead_best.keras\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m8s\u001b[0m 79ms/step - head_1_accuracy: 0.5091 - head_1_loss: 1.3260 - head_2_accuracy: 0.4949 - head_2_loss: 1.3195 - head_3_accuracy: 0.5014 - head_3_loss: 1.3153 - head_4_accuracy: 0.5048 - head_4_loss: 1.3194 - head_5_accuracy: 0.4999 - head_5_loss: 1.3226 - head_6_accuracy: 0.4895 - head_6_loss: 1.3286 - head_7_accuracy: 0.4986 - head_7_loss: 1.3295 - loss: 9.3514 - val_head_1_accuracy: 0.5916 - val_head_1_loss: 1.0544 - val_head_2_accuracy: 0.5782 - val_head_2_loss: 1.0898 - val_head_3_accuracy: 0.5893 - val_head_3_loss: 1.0576 - val_head_4_accuracy: 0.5930 - val_head_4_loss: 1.0553 - val_head_5_accuracy: 0.5831 - val_head_5_loss: 1.0748 - val_head_6_accuracy: 0.5910 - val_head_6_loss: 1.0841 - val_head_7_accuracy: 0.5814 - val_head_7_loss: 1.0698 - val_loss: 7.4880 - learning_rate: 0.0200\n", "\n", "Epoch 3: LearningRateScheduler setting learning rate to 0.019984900073539133.\n", "Epoch 3/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 55ms/step - head_1_accuracy: 0.5864 - head_1_loss: 1.0436 - head_2_accuracy: 0.5746 - head_2_loss: 1.0667 - head_3_accuracy: 0.5874 - head_3_loss: 1.0402 - head_4_accuracy: 0.5934 - head_4_loss: 1.0378 - head_5_accuracy: 0.5776 - head_5_loss: 1.0551 - head_6_accuracy: 0.5808 - head_6_loss: 1.0478 - head_7_accuracy: 0.5831 - head_7_loss: 1.0515 - loss: 7.3428\n", "Epoch 3: val_head_1_accuracy improved from 0.59165 to 0.62993, saving model to /content/drive/My Drive/Classification/multicp/models/AlexNet_CNN_MultiHead_best.keras\n", "\n", "Epoch 3: finished saving model to /content/drive/My Drive/Classification/multicp/models/AlexNet_CNN_MultiHead_best.keras\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m9s\u001b[0m 84ms/step - head_1_accuracy: 0.5929 - head_1_loss: 0.9965 - head_2_accuracy: 0.5896 - head_2_loss: 1.0107 - head_3_accuracy: 0.5949 - head_3_loss: 0.9919 - head_4_accuracy: 0.5986 - head_4_loss: 0.9897 - head_5_accuracy: 0.5933 - head_5_loss: 0.9999 - head_6_accuracy: 0.5929 - head_6_loss: 0.9938 - head_7_accuracy: 0.5912 - head_7_loss: 0.9993 - loss: 7.0502 - val_head_1_accuracy: 0.6299 - val_head_1_loss: 0.9195 - val_head_2_accuracy: 0.6309 - val_head_2_loss: 0.9240 - val_head_3_accuracy: 0.6494 - val_head_3_loss: 0.9045 - val_head_4_accuracy: 0.6503 - val_head_4_loss: 0.9013 - val_head_5_accuracy: 0.6327 - val_head_5_loss: 0.9096 - val_head_6_accuracy: 0.6441 - val_head_6_loss: 0.9076 - val_head_7_accuracy: 0.6404 - val_head_7_loss: 0.9074 - val_loss: 6.3786 - learning_rate: 0.0200\n", "\n", "Epoch 4: LearningRateScheduler setting learning rate to 0.019966039419298132.\n", "Epoch 4/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 56ms/step - head_1_accuracy: 0.6152 - head_1_loss: 0.9295 - head_2_accuracy: 0.6214 - head_2_loss: 0.9368 - head_3_accuracy: 0.6156 - head_3_loss: 0.9265 - head_4_accuracy: 0.6250 - head_4_loss: 0.9263 - head_5_accuracy: 0.6273 - head_5_loss: 0.9263 - head_6_accuracy: 0.6303 - head_6_loss: 0.9230 - head_7_accuracy: 0.6158 - head_7_loss: 0.9320 - loss: 6.5004\n", "Epoch 4: val_head_1_accuracy improved from 0.62993 to 0.64896, saving model to /content/drive/My Drive/Classification/multicp/models/AlexNet_CNN_MultiHead_best.keras\n", "\n", "Epoch 4: finished saving model to /content/drive/My Drive/Classification/multicp/models/AlexNet_CNN_MultiHead_best.keras\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m8s\u001b[0m 79ms/step - head_1_accuracy: 0.6179 - head_1_loss: 0.9089 - head_2_accuracy: 0.6294 - head_2_loss: 0.9113 - head_3_accuracy: 0.6237 - head_3_loss: 0.9029 - head_4_accuracy: 0.6308 - head_4_loss: 0.9026 - head_5_accuracy: 0.6339 - head_5_loss: 0.9000 - head_6_accuracy: 0.6364 - head_6_loss: 0.8988 - head_7_accuracy: 0.6205 - head_7_loss: 0.9071 - loss: 6.3938 - val_head_1_accuracy: 0.6490 - val_head_1_loss: 0.8822 - val_head_2_accuracy: 0.6680 - val_head_2_loss: 0.8753 - val_head_3_accuracy: 0.6608 - val_head_3_loss: 0.8666 - val_head_4_accuracy: 0.6550 - val_head_4_loss: 0.8661 - val_head_5_accuracy: 0.6559 - val_head_5_loss: 0.8619 - val_head_6_accuracy: 0.6524 - val_head_6_loss: 0.8638 - val_head_7_accuracy: 0.6599 - val_head_7_loss: 0.8679 - val_loss: 6.0892 - learning_rate: 0.0200\n", "\n", "Epoch 5: LearningRateScheduler setting learning rate to 0.019939661096230965.\n", "Epoch 5/100\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 58ms/step - head_1_accuracy: 0.6489 - head_1_loss: 0.8735 - head_2_accuracy: 0.6502 - head_2_loss: 0.8694 - head_3_accuracy: 0.6479 - head_3_loss: 0.8629 - head_4_accuracy: 0.6507 - head_4_loss: 0.8648 - head_5_accuracy: 0.6559 - head_5_loss: 0.8621 - head_6_accuracy: 0.6558 - head_6_loss: 0.8605 - head_7_accuracy: 0.6404 - head_7_loss: 0.8689 - loss: 6.0627\n", "Epoch 5: val_head_1_accuracy improved from 0.64896 to 0.68190, saving model to /content/drive/My Drive/Classification/multicp/models/AlexNet_CNN_MultiHead_best.keras\n", "\n", "Epoch 5: finished saving model to /content/drive/My Drive/Classification/multicp/models/AlexNet_CNN_MultiHead_best.keras\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 95ms/step - head_1_accuracy: 0.6547 - head_1_loss: 0.8462 - head_2_accuracy: 0.6547 - head_2_loss: 0.8439 - head_3_accuracy: 0.6552 - head_3_loss: 0.8374 - head_4_accuracy: 0.6575 - head_4_loss: 0.8392 - head_5_accuracy: 0.6590 - head_5_loss: 0.8357 - head_6_accuracy: 0.6602 - head_6_loss: 0.8338 - head_7_accuracy: 0.6467 - head_7_loss: 0.8416 - loss: 5.9355 - val_head_1_accuracy: 0.6819 - val_head_1_loss: 0.7988 - val_head_2_accuracy: 0.6872 - val_head_2_loss: 0.7927 - val_head_3_accuracy: 0.6868 - val_head_3_loss: 0.7862 - val_head_4_accuracy: 0.6794 - val_head_4_loss: 0.7907 - val_head_5_accuracy: 0.6889 - val_head_5_loss: 0.7823 - val_head_6_accuracy: 0.6865 - val_head_6_loss: 0.7817 - val_head_7_accuracy: 0.6821 - val_head_7_loss: 0.7858 - val_loss: 5.5231 - learning_rate: 0.0199\n", "\n", "Epoch 6: LearningRateScheduler setting learning rate to 0.019905791665072958.\n", "Epoch 6/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 57ms/step - head_1_accuracy: 0.6695 - head_1_loss: 0.8256 - head_2_accuracy: 0.6685 - head_2_loss: 0.8187 - head_3_accuracy: 0.6700 - head_3_loss: 0.8170 - head_4_accuracy: 0.6676 - head_4_loss: 0.8198 - head_5_accuracy: 0.6744 - head_5_loss: 0.8192 - head_6_accuracy: 0.6708 - head_6_loss: 0.8175 - head_7_accuracy: 0.6667 - head_7_loss: 0.8210 - loss: 5.7388\n", "Epoch 6: val_head_1_accuracy improved from 0.68190 to 0.68422, saving model to /content/drive/My Drive/Classification/multicp/models/AlexNet_CNN_MultiHead_best.keras\n", "\n", "Epoch 6: finished saving model to /content/drive/My Drive/Classification/multicp/models/AlexNet_CNN_MultiHead_best.keras\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m9s\u001b[0m 79ms/step - head_1_accuracy: 0.6748 - head_1_loss: 0.8004 - head_2_accuracy: 0.6731 - head_2_loss: 0.7926 - head_3_accuracy: 0.6765 - head_3_loss: 0.7890 - head_4_accuracy: 0.6780 - head_4_loss: 0.7927 - head_5_accuracy: 0.6783 - head_5_loss: 0.7928 - head_6_accuracy: 0.6756 - head_6_loss: 0.7906 - head_7_accuracy: 0.6729 - head_7_loss: 0.7934 - loss: 5.6060 - val_head_1_accuracy: 0.6842 - val_head_1_loss: 0.8172 - val_head_2_accuracy: 0.6638 - val_head_2_loss: 0.8170 - val_head_3_accuracy: 0.6921 - val_head_3_loss: 0.8064 - val_head_4_accuracy: 0.6889 - val_head_4_loss: 0.8119 - val_head_5_accuracy: 0.6810 - val_head_5_loss: 0.8113 - val_head_6_accuracy: 0.6691 - val_head_6_loss: 0.8136 - val_head_7_accuracy: 0.6673 - val_head_7_loss: 0.8072 - val_loss: 5.6885 - learning_rate: 0.0199\n", "\n", "Epoch 7: LearningRateScheduler setting learning rate to 0.019864465229470298.\n", "Epoch 7/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 59ms/step - head_1_accuracy: 0.6885 - head_1_loss: 0.7757 - head_2_accuracy: 0.6884 - head_2_loss: 0.7697 - head_3_accuracy: 0.6937 - head_3_loss: 0.7655 - head_4_accuracy: 0.6947 - head_4_loss: 0.7683 - head_5_accuracy: 0.6930 - head_5_loss: 0.7683 - head_6_accuracy: 0.6887 - head_6_loss: 0.7702 - head_7_accuracy: 0.6932 - head_7_loss: 0.7693 - loss: 5.3870\n", "Epoch 7: val_head_1_accuracy improved from 0.68422 to 0.70302, saving model to /content/drive/My Drive/Classification/multicp/models/AlexNet_CNN_MultiHead_best.keras\n", "\n", "Epoch 7: finished saving model to /content/drive/My Drive/Classification/multicp/models/AlexNet_CNN_MultiHead_best.keras\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m8s\u001b[0m 82ms/step - head_1_accuracy: 0.7018 - head_1_loss: 0.7362 - head_2_accuracy: 0.7019 - head_2_loss: 0.7319 - head_3_accuracy: 0.7065 - head_3_loss: 0.7246 - head_4_accuracy: 0.7086 - head_4_loss: 0.7264 - head_5_accuracy: 0.7061 - head_5_loss: 0.7275 - head_6_accuracy: 0.7039 - head_6_loss: 0.7311 - head_7_accuracy: 0.7044 - head_7_loss: 0.7290 - loss: 5.1569 - val_head_1_accuracy: 0.7030 - val_head_1_loss: 0.7898 - val_head_2_accuracy: 0.7067 - val_head_2_loss: 0.7848 - val_head_3_accuracy: 0.7116 - val_head_3_loss: 0.7846 - val_head_4_accuracy: 0.7121 - val_head_4_loss: 0.7765 - val_head_5_accuracy: 0.7019 - val_head_5_loss: 0.8102 - val_head_6_accuracy: 0.7039 - val_head_6_loss: 0.7942 - val_head_7_accuracy: 0.7028 - val_head_7_loss: 0.8086 - val_loss: 5.5486 - learning_rate: 0.0199\n", "\n", "Epoch 8: LearningRateScheduler setting learning rate to 0.019815723401640555.\n", "Epoch 8/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 57ms/step - head_1_accuracy: 0.7153 - head_1_loss: 0.7095 - head_2_accuracy: 0.7171 - head_2_loss: 0.7064 - head_3_accuracy: 0.7139 - head_3_loss: 0.6985 - head_4_accuracy: 0.7149 - head_4_loss: 0.7000 - head_5_accuracy: 0.7146 - head_5_loss: 0.7085 - head_6_accuracy: 0.7142 - head_6_loss: 0.7130 - head_7_accuracy: 0.7189 - head_7_loss: 0.7058 - loss: 4.9417\n", "Epoch 8: val_head_1_accuracy improved from 0.70302 to 0.77842, saving model to /content/drive/My Drive/Classification/multicp/models/AlexNet_CNN_MultiHead_best.keras\n", "\n", "Epoch 8: finished saving model to /content/drive/My Drive/Classification/multicp/models/AlexNet_CNN_MultiHead_best.keras\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m9s\u001b[0m 86ms/step - head_1_accuracy: 0.7191 - head_1_loss: 0.6944 - head_2_accuracy: 0.7236 - head_2_loss: 0.6904 - head_3_accuracy: 0.7219 - head_3_loss: 0.6839 - head_4_accuracy: 0.7223 - head_4_loss: 0.6849 - head_5_accuracy: 0.7186 - head_5_loss: 0.6927 - head_6_accuracy: 0.7187 - head_6_loss: 0.6965 - head_7_accuracy: 0.7212 - head_7_loss: 0.6902 - loss: 4.8804 - val_head_1_accuracy: 0.7784 - val_head_1_loss: 0.5626 - val_head_2_accuracy: 0.7807 - val_head_2_loss: 0.5521 - val_head_3_accuracy: 0.7914 - val_head_3_loss: 0.5373 - val_head_4_accuracy: 0.7791 - val_head_4_loss: 0.5485 - val_head_5_accuracy: 0.7782 - val_head_5_loss: 0.5523 - val_head_6_accuracy: 0.7733 - val_head_6_loss: 0.5615 - val_head_7_accuracy: 0.7847 - val_head_7_loss: 0.5494 - val_loss: 3.8647 - learning_rate: 0.0198\n", "\n", "Epoch 9: LearningRateScheduler setting learning rate to 0.019759615260472672.\n", "Epoch 9/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 59ms/step - head_1_accuracy: 0.7531 - head_1_loss: 0.6068 - head_2_accuracy: 0.7565 - head_2_loss: 0.6020 - head_3_accuracy: 0.7650 - head_3_loss: 0.5927 - head_4_accuracy: 0.7580 - head_4_loss: 0.6005 - head_5_accuracy: 0.7607 - head_5_loss: 0.6012 - head_6_accuracy: 0.7538 - head_6_loss: 0.6126 - head_7_accuracy: 0.7630 - head_7_loss: 0.5977 - loss: 4.2136\n", "Epoch 9: val_head_1_accuracy improved from 0.77842 to 0.82529, saving model to /content/drive/My Drive/Classification/multicp/models/AlexNet_CNN_MultiHead_best.keras\n", "\n", "Epoch 9: finished saving model to /content/drive/My Drive/Classification/multicp/models/AlexNet_CNN_MultiHead_best.keras\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m8s\u001b[0m 82ms/step - head_1_accuracy: 0.7739 - head_1_loss: 0.5697 - head_2_accuracy: 0.7739 - head_2_loss: 0.5677 - head_3_accuracy: 0.7805 - head_3_loss: 0.5588 - head_4_accuracy: 0.7762 - head_4_loss: 0.5649 - head_5_accuracy: 0.7738 - head_5_loss: 0.5678 - head_6_accuracy: 0.7666 - head_6_loss: 0.5794 - head_7_accuracy: 0.7804 - head_7_loss: 0.5632 - loss: 4.0104 - val_head_1_accuracy: 0.8253 - val_head_1_loss: 0.4736 - val_head_2_accuracy: 0.8142 - val_head_2_loss: 0.4813 - val_head_3_accuracy: 0.8132 - val_head_3_loss: 0.4709 - val_head_4_accuracy: 0.8155 - val_head_4_loss: 0.4722 - val_head_5_accuracy: 0.8148 - val_head_5_loss: 0.4818 - val_head_6_accuracy: 0.8220 - val_head_6_loss: 0.4809 - val_head_7_accuracy: 0.8302 - val_head_7_loss: 0.4728 - val_loss: 3.3330 - learning_rate: 0.0198\n", "\n", "Epoch 10: LearningRateScheduler setting learning rate to 0.01969619730210873.\n", "Epoch 10/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 58ms/step - head_1_accuracy: 0.6384 - head_1_loss: 1.0640 - head_2_accuracy: 0.6520 - head_2_loss: 1.0481 - head_3_accuracy: 0.6473 - head_3_loss: 1.0261 - head_4_accuracy: 0.6428 - head_4_loss: 1.0322 - head_5_accuracy: 0.6226 - head_5_loss: 1.0927 - head_6_accuracy: 0.6299 - head_6_loss: 1.0753 - head_7_accuracy: 0.6340 - head_7_loss: 1.0639 - loss: 7.4023\n", "Epoch 10: val_head_1_accuracy did not improve from 0.82529\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 72ms/step - head_1_accuracy: 0.6305 - head_1_loss: 1.0348 - head_2_accuracy: 0.6379 - head_2_loss: 1.0185 - head_3_accuracy: 0.6362 - head_3_loss: 1.0121 - head_4_accuracy: 0.6337 - head_4_loss: 1.0110 - head_5_accuracy: 0.6119 - head_5_loss: 1.0547 - head_6_accuracy: 0.6227 - head_6_loss: 1.0442 - head_7_accuracy: 0.6244 - head_7_loss: 1.0325 - loss: 7.2785 - val_head_1_accuracy: 0.7285 - val_head_1_loss: 0.7452 - val_head_2_accuracy: 0.7283 - val_head_2_loss: 0.7476 - val_head_3_accuracy: 0.7209 - val_head_3_loss: 0.7636 - val_head_4_accuracy: 0.7267 - val_head_4_loss: 0.7504 - val_head_5_accuracy: 0.7223 - val_head_5_loss: 0.7571 - val_head_6_accuracy: 0.7079 - val_head_6_loss: 0.7701 - val_head_7_accuracy: 0.7262 - val_head_7_loss: 0.7568 - val_loss: 5.2927 - learning_rate: 0.0197\n", "\n", "Epoch 11: LearningRateScheduler setting learning rate to 0.01962553338305709.\n", "Epoch 11/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 60ms/step - head_1_accuracy: 0.7461 - head_1_loss: 0.6616 - head_2_accuracy: 0.7461 - head_2_loss: 0.6589 - head_3_accuracy: 0.7461 - head_3_loss: 0.6552 - head_4_accuracy: 0.7440 - head_4_loss: 0.6588 - head_5_accuracy: 0.7433 - head_5_loss: 0.6675 - head_6_accuracy: 0.7399 - head_6_loss: 0.6685 - head_7_accuracy: 0.7472 - head_7_loss: 0.6585 - loss: 4.6288\n", "Epoch 11: val_head_1_accuracy did not improve from 0.82529\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 68ms/step - head_1_accuracy: 0.7590 - head_1_loss: 0.6136 - head_2_accuracy: 0.7601 - head_2_loss: 0.6088 - head_3_accuracy: 0.7611 - head_3_loss: 0.6064 - head_4_accuracy: 0.7570 - head_4_loss: 0.6099 - head_5_accuracy: 0.7567 - head_5_loss: 0.6174 - head_6_accuracy: 0.7547 - head_6_loss: 0.6197 - head_7_accuracy: 0.7610 - head_7_loss: 0.6087 - loss: 4.3264 - val_head_1_accuracy: 0.7095 - val_head_1_loss: 0.6876 - val_head_2_accuracy: 0.7114 - val_head_2_loss: 0.7063 - val_head_3_accuracy: 0.7130 - val_head_3_loss: 0.6942 - val_head_4_accuracy: 0.7188 - val_head_4_loss: 0.6709 - val_head_5_accuracy: 0.7081 - val_head_5_loss: 0.6978 - val_head_6_accuracy: 0.7053 - val_head_6_loss: 0.6954 - val_head_7_accuracy: 0.7202 - val_head_7_loss: 0.6827 - val_loss: 4.8340 - learning_rate: 0.0196\n", "\n", "Epoch 12: LearningRateScheduler setting learning rate to 0.019547694655894312.\n", "Epoch 12/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 60ms/step - head_1_accuracy: 0.7784 - head_1_loss: 0.5564 - head_2_accuracy: 0.7779 - head_2_loss: 0.5629 - head_3_accuracy: 0.7806 - head_3_loss: 0.5580 - head_4_accuracy: 0.7825 - head_4_loss: 0.5560 - head_5_accuracy: 0.7787 - head_5_loss: 0.5627 - head_6_accuracy: 0.7824 - head_6_loss: 0.5606 - head_7_accuracy: 0.7808 - head_7_loss: 0.5591 - loss: 3.9156\n", "Epoch 12: val_head_1_accuracy improved from 0.82529 to 0.83364, saving model to /content/drive/My Drive/Classification/multicp/models/AlexNet_CNN_MultiHead_best.keras\n", "\n", "Epoch 12: finished saving model to /content/drive/My Drive/Classification/multicp/models/AlexNet_CNN_MultiHead_best.keras\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m9s\u001b[0m 86ms/step - head_1_accuracy: 0.8068 - head_1_loss: 0.4902 - head_2_accuracy: 0.8042 - head_2_loss: 0.4930 - head_3_accuracy: 0.8091 - head_3_loss: 0.4889 - head_4_accuracy: 0.8088 - head_4_loss: 0.4900 - head_5_accuracy: 0.8081 - head_5_loss: 0.4941 - head_6_accuracy: 0.8066 - head_6_loss: 0.4954 - head_7_accuracy: 0.8069 - head_7_loss: 0.4920 - loss: 3.4775 - val_head_1_accuracy: 0.8336 - val_head_1_loss: 0.4553 - val_head_2_accuracy: 0.8385 - val_head_2_loss: 0.4452 - val_head_3_accuracy: 0.8378 - val_head_3_loss: 0.4408 - val_head_4_accuracy: 0.8346 - val_head_4_loss: 0.4606 - val_head_5_accuracy: 0.8360 - val_head_5_loss: 0.4522 - val_head_6_accuracy: 0.8320 - val_head_6_loss: 0.4473 - val_head_7_accuracy: 0.8327 - val_head_7_loss: 0.4575 - val_loss: 3.1581 - learning_rate: 0.0195\n", "\n", "Epoch 13: LearningRateScheduler setting learning rate to 0.019462759497620545.\n", "Epoch 13/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 61ms/step - head_1_accuracy: 0.8256 - head_1_loss: 0.4647 - head_2_accuracy: 0.8241 - head_2_loss: 0.4682 - head_3_accuracy: 0.8256 - head_3_loss: 0.4647 - head_4_accuracy: 0.8284 - head_4_loss: 0.4605 - head_5_accuracy: 0.8255 - head_5_loss: 0.4673 - head_6_accuracy: 0.8261 - head_6_loss: 0.4697 - head_7_accuracy: 0.8266 - head_7_loss: 0.4636 - loss: 3.2588\n", "Epoch 13: val_head_1_accuracy improved from 0.83364 to 0.88933, saving model to /content/drive/My Drive/Classification/multicp/models/AlexNet_CNN_MultiHead_best.keras\n", "\n", "Epoch 13: finished saving model to /content/drive/My Drive/Classification/multicp/models/AlexNet_CNN_MultiHead_best.keras\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m9s\u001b[0m 87ms/step - head_1_accuracy: 0.8518 - head_1_loss: 0.3995 - head_2_accuracy: 0.8514 - head_2_loss: 0.3990 - head_3_accuracy: 0.8520 - head_3_loss: 0.3984 - head_4_accuracy: 0.8536 - head_4_loss: 0.3974 - head_5_accuracy: 0.8505 - head_5_loss: 0.4018 - head_6_accuracy: 0.8510 - head_6_loss: 0.4024 - head_7_accuracy: 0.8516 - head_7_loss: 0.3986 - loss: 2.8246 - val_head_1_accuracy: 0.8893 - val_head_1_loss: 0.3036 - val_head_2_accuracy: 0.8821 - val_head_2_loss: 0.3189 - val_head_3_accuracy: 0.8845 - val_head_3_loss: 0.3066 - val_head_4_accuracy: 0.8896 - val_head_4_loss: 0.2969 - val_head_5_accuracy: 0.8898 - val_head_5_loss: 0.3103 - val_head_6_accuracy: 0.8893 - val_head_6_loss: 0.3039 - val_head_7_accuracy: 0.8916 - val_head_7_loss: 0.2992 - val_loss: 2.1392 - learning_rate: 0.0195\n", "\n", "Epoch 14: LearningRateScheduler setting learning rate to 0.01937081343074052.\n", "Epoch 14/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 61ms/step - head_1_accuracy: 0.8787 - head_1_loss: 0.3235 - head_2_accuracy: 0.8755 - head_2_loss: 0.3287 - head_3_accuracy: 0.8785 - head_3_loss: 0.3247 - head_4_accuracy: 0.8763 - head_4_loss: 0.3254 - head_5_accuracy: 0.8774 - head_5_loss: 0.3271 - head_6_accuracy: 0.8794 - head_6_loss: 0.3245 - head_7_accuracy: 0.8751 - head_7_loss: 0.3252 - loss: 2.2792\n", "Epoch 14: val_head_1_accuracy improved from 0.88933 to 0.89629, saving model to /content/drive/My Drive/Classification/multicp/models/AlexNet_CNN_MultiHead_best.keras\n", "\n", "Epoch 14: finished saving model to /content/drive/My Drive/Classification/multicp/models/AlexNet_CNN_MultiHead_best.keras\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m9s\u001b[0m 84ms/step - head_1_accuracy: 0.8865 - head_1_loss: 0.2999 - head_2_accuracy: 0.8855 - head_2_loss: 0.3032 - head_3_accuracy: 0.8868 - head_3_loss: 0.2998 - head_4_accuracy: 0.8872 - head_4_loss: 0.3000 - head_5_accuracy: 0.8858 - head_5_loss: 0.3015 - head_6_accuracy: 0.8878 - head_6_loss: 0.3020 - head_7_accuracy: 0.8856 - head_7_loss: 0.3004 - loss: 2.1274 - val_head_1_accuracy: 0.8963 - val_head_1_loss: 0.3004 - val_head_2_accuracy: 0.8940 - val_head_2_loss: 0.3020 - val_head_3_accuracy: 0.8970 - val_head_3_loss: 0.2976 - val_head_4_accuracy: 0.8984 - val_head_4_loss: 0.2788 - val_head_5_accuracy: 0.8970 - val_head_5_loss: 0.2962 - val_head_6_accuracy: 0.8942 - val_head_6_loss: 0.2893 - val_head_7_accuracy: 0.8986 - val_head_7_loss: 0.2790 - val_loss: 2.0412 - learning_rate: 0.0194\n", "\n", "Epoch 15: LearningRateScheduler setting learning rate to 0.01927194903714966.\n", "Epoch 15/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 59ms/step - head_1_accuracy: 0.8925 - head_1_loss: 0.3040 - head_2_accuracy: 0.8891 - head_2_loss: 0.3060 - head_3_accuracy: 0.8909 - head_3_loss: 0.3066 - head_4_accuracy: 0.8906 - head_4_loss: 0.3043 - head_5_accuracy: 0.8890 - head_5_loss: 0.3042 - head_6_accuracy: 0.8915 - head_6_loss: 0.3042 - head_7_accuracy: 0.8913 - head_7_loss: 0.3032 - loss: 2.1326\n", "Epoch 15: val_head_1_accuracy improved from 0.89629 to 0.91369, saving model to /content/drive/My Drive/Classification/multicp/models/AlexNet_CNN_MultiHead_best.keras\n", "\n", "Epoch 15: finished saving model to /content/drive/My Drive/Classification/multicp/models/AlexNet_CNN_MultiHead_best.keras\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m9s\u001b[0m 86ms/step - head_1_accuracy: 0.9029 - head_1_loss: 0.2701 - head_2_accuracy: 0.9021 - head_2_loss: 0.2716 - head_3_accuracy: 0.9024 - head_3_loss: 0.2715 - head_4_accuracy: 0.9026 - head_4_loss: 0.2708 - head_5_accuracy: 0.9013 - head_5_loss: 0.2697 - head_6_accuracy: 0.9031 - head_6_loss: 0.2698 - head_7_accuracy: 0.9031 - head_7_loss: 0.2694 - loss: 1.9115 - val_head_1_accuracy: 0.9137 - val_head_1_loss: 0.2371 - val_head_2_accuracy: 0.9137 - val_head_2_loss: 0.2360 - val_head_3_accuracy: 0.9130 - val_head_3_loss: 0.2368 - val_head_4_accuracy: 0.9151 - val_head_4_loss: 0.2253 - val_head_5_accuracy: 0.9132 - val_head_5_loss: 0.2357 - val_head_6_accuracy: 0.9135 - val_head_6_loss: 0.2340 - val_head_7_accuracy: 0.9213 - val_head_7_loss: 0.2192 - val_loss: 1.6227 - learning_rate: 0.0193\n", "\n", "Epoch 16: LearningRateScheduler setting learning rate to 0.019166265864911925.\n", "Epoch 16/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 61ms/step - head_1_accuracy: 0.9132 - head_1_loss: 0.2403 - head_2_accuracy: 0.9108 - head_2_loss: 0.2459 - head_3_accuracy: 0.9125 - head_3_loss: 0.2430 - head_4_accuracy: 0.9105 - head_4_loss: 0.2453 - head_5_accuracy: 0.9136 - head_5_loss: 0.2447 - head_6_accuracy: 0.9118 - head_6_loss: 0.2440 - head_7_accuracy: 0.9124 - head_7_loss: 0.2421 - loss: 1.7051\n", "Epoch 16: val_head_1_accuracy improved from 0.91369 to 0.95661, saving model to /content/drive/My Drive/Classification/multicp/models/AlexNet_CNN_MultiHead_best.keras\n", "\n", "Epoch 16: finished saving model to /content/drive/My Drive/Classification/multicp/models/AlexNet_CNN_MultiHead_best.keras\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m9s\u001b[0m 84ms/step - head_1_accuracy: 0.9227 - head_1_loss: 0.2117 - head_2_accuracy: 0.9215 - head_2_loss: 0.2147 - head_3_accuracy: 0.9220 - head_3_loss: 0.2129 - head_4_accuracy: 0.9206 - head_4_loss: 0.2156 - head_5_accuracy: 0.9234 - head_5_loss: 0.2137 - head_6_accuracy: 0.9217 - head_6_loss: 0.2135 - head_7_accuracy: 0.9216 - head_7_loss: 0.2135 - loss: 1.5103 - val_head_1_accuracy: 0.9566 - val_head_1_loss: 0.1292 - val_head_2_accuracy: 0.9559 - val_head_2_loss: 0.1299 - val_head_3_accuracy: 0.9545 - val_head_3_loss: 0.1326 - val_head_4_accuracy: 0.9557 - val_head_4_loss: 0.1294 - val_head_5_accuracy: 0.9552 - val_head_5_loss: 0.1328 - val_head_6_accuracy: 0.9541 - val_head_6_loss: 0.1316 - val_head_7_accuracy: 0.9578 - val_head_7_loss: 0.1271 - val_loss: 0.9125 - learning_rate: 0.0192\n", "\n", "Epoch 17: LearningRateScheduler setting learning rate to 0.019053870328023387.\n", "Epoch 17/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 60ms/step - head_1_accuracy: 0.9436 - head_1_loss: 0.1639 - head_2_accuracy: 0.9440 - head_2_loss: 0.1639 - head_3_accuracy: 0.9423 - head_3_loss: 0.1633 - head_4_accuracy: 0.9432 - head_4_loss: 0.1666 - head_5_accuracy: 0.9428 - head_5_loss: 0.1640 - head_6_accuracy: 0.9441 - head_6_loss: 0.1674 - head_7_accuracy: 0.9432 - head_7_loss: 0.1616 - loss: 1.1508\n", "Epoch 17: val_head_1_accuracy did not improve from 0.95661\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 70ms/step - head_1_accuracy: 0.9468 - head_1_loss: 0.1503 - head_2_accuracy: 0.9473 - head_2_loss: 0.1497 - head_3_accuracy: 0.9463 - head_3_loss: 0.1502 - head_4_accuracy: 0.9469 - head_4_loss: 0.1516 - head_5_accuracy: 0.9472 - head_5_loss: 0.1492 - head_6_accuracy: 0.9468 - head_6_loss: 0.1508 - head_7_accuracy: 0.9474 - head_7_loss: 0.1487 - loss: 1.0608 - val_head_1_accuracy: 0.9457 - val_head_1_loss: 0.1665 - val_head_2_accuracy: 0.9436 - val_head_2_loss: 0.1768 - val_head_3_accuracy: 0.9436 - val_head_3_loss: 0.1671 - val_head_4_accuracy: 0.9427 - val_head_4_loss: 0.1650 - val_head_5_accuracy: 0.9415 - val_head_5_loss: 0.1679 - val_head_6_accuracy: 0.9448 - val_head_6_loss: 0.1688 - val_head_7_accuracy: 0.9476 - val_head_7_loss: 0.1571 - val_loss: 1.1688 - learning_rate: 0.0191\n", "\n", "Epoch 18: LearningRateScheduler setting learning rate to 0.018934875599262328.\n", "Epoch 18/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 61ms/step - head_1_accuracy: 0.9360 - head_1_loss: 0.1780 - head_2_accuracy: 0.9356 - head_2_loss: 0.1824 - head_3_accuracy: 0.9354 - head_3_loss: 0.1803 - head_4_accuracy: 0.9355 - head_4_loss: 0.1795 - head_5_accuracy: 0.9348 - head_5_loss: 0.1806 - head_6_accuracy: 0.9361 - head_6_loss: 0.1805 - head_7_accuracy: 0.9329 - head_7_loss: 0.1817 - loss: 1.2630\n", "Epoch 18: val_head_1_accuracy improved from 0.95661 to 0.97355, saving model to /content/drive/My Drive/Classification/multicp/models/AlexNet_CNN_MultiHead_best.keras\n", "\n", "Epoch 18: finished saving model to /content/drive/My Drive/Classification/multicp/models/AlexNet_CNN_MultiHead_best.keras\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m9s\u001b[0m 85ms/step - head_1_accuracy: 0.9571 - head_1_loss: 0.1228 - head_2_accuracy: 0.9575 - head_2_loss: 0.1242 - head_3_accuracy: 0.9570 - head_3_loss: 0.1225 - head_4_accuracy: 0.9565 - head_4_loss: 0.1232 - head_5_accuracy: 0.9561 - head_5_loss: 0.1241 - head_6_accuracy: 0.9569 - head_6_loss: 0.1227 - head_7_accuracy: 0.9551 - head_7_loss: 0.1240 - loss: 0.8719 - val_head_1_accuracy: 0.9735 - val_head_1_loss: 0.0736 - val_head_2_accuracy: 0.9735 - val_head_2_loss: 0.0752 - val_head_3_accuracy: 0.9724 - val_head_3_loss: 0.0762 - val_head_4_accuracy: 0.9731 - val_head_4_loss: 0.0747 - val_head_5_accuracy: 0.9729 - val_head_5_loss: 0.0769 - val_head_6_accuracy: 0.9738 - val_head_6_loss: 0.0739 - val_head_7_accuracy: 0.9735 - val_head_7_loss: 0.0740 - val_loss: 0.5230 - learning_rate: 0.0189\n", "\n", "Epoch 19: LearningRateScheduler setting learning rate to 0.01880940149623386.\n", "Epoch 19/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 62ms/step - head_1_accuracy: 0.9747 - head_1_loss: 0.0805 - head_2_accuracy: 0.9734 - head_2_loss: 0.0801 - head_3_accuracy: 0.9749 - head_3_loss: 0.0806 - head_4_accuracy: 0.9742 - head_4_loss: 0.0802 - head_5_accuracy: 0.9752 - head_5_loss: 0.0797 - head_6_accuracy: 0.9739 - head_6_loss: 0.0814 - head_7_accuracy: 0.9743 - head_7_loss: 0.0797 - loss: 0.5621\n", "Epoch 19: val_head_1_accuracy did not improve from 0.97355\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m8s\u001b[0m 75ms/step - head_1_accuracy: 0.9773 - head_1_loss: 0.0679 - head_2_accuracy: 0.9766 - head_2_loss: 0.0676 - head_3_accuracy: 0.9777 - head_3_loss: 0.0674 - head_4_accuracy: 0.9770 - head_4_loss: 0.0685 - head_5_accuracy: 0.9776 - head_5_loss: 0.0673 - head_6_accuracy: 0.9767 - head_6_loss: 0.0681 - head_7_accuracy: 0.9773 - head_7_loss: 0.0680 - loss: 0.4795 - val_head_1_accuracy: 0.8784 - val_head_1_loss: 0.6843 - val_head_2_accuracy: 0.8780 - val_head_2_loss: 0.6870 - val_head_3_accuracy: 0.8759 - val_head_3_loss: 0.6819 - val_head_4_accuracy: 0.8810 - val_head_4_loss: 0.6502 - val_head_5_accuracy: 0.8768 - val_head_5_loss: 0.6750 - val_head_6_accuracy: 0.8782 - val_head_6_loss: 0.6540 - val_head_7_accuracy: 0.8810 - val_head_7_loss: 0.6222 - val_loss: 4.6555 - learning_rate: 0.0188\n", "\n", "Epoch 20: LearningRateScheduler setting learning rate to 0.018677574360723745.\n", "Epoch 20/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 61ms/step - head_1_accuracy: 0.6173 - head_1_loss: 1.8939 - head_2_accuracy: 0.6268 - head_2_loss: 2.0384 - head_3_accuracy: 0.6305 - head_3_loss: 1.9174 - head_4_accuracy: 0.6201 - head_4_loss: 2.0121 - head_5_accuracy: 0.6260 - head_5_loss: 2.1435 - head_6_accuracy: 0.6335 - head_6_loss: 2.0220 - head_7_accuracy: 0.6292 - head_7_loss: 2.0960 - loss: 14.1232\n", "Epoch 20: val_head_1_accuracy did not improve from 0.97355\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 71ms/step - head_1_accuracy: 0.7252 - head_1_loss: 0.9565 - head_2_accuracy: 0.7318 - head_2_loss: 0.9941 - head_3_accuracy: 0.7378 - head_3_loss: 0.9558 - head_4_accuracy: 0.7223 - head_4_loss: 0.9939 - head_5_accuracy: 0.7303 - head_5_loss: 1.0349 - head_6_accuracy: 0.7371 - head_6_loss: 0.9869 - head_7_accuracy: 0.7332 - head_7_loss: 1.0099 - loss: 7.0001 - val_head_1_accuracy: 0.8452 - val_head_1_loss: 0.4479 - val_head_2_accuracy: 0.8487 - val_head_2_loss: 0.4303 - val_head_3_accuracy: 0.8490 - val_head_3_loss: 0.4259 - val_head_4_accuracy: 0.8422 - val_head_4_loss: 0.4425 - val_head_5_accuracy: 0.8501 - val_head_5_loss: 0.4416 - val_head_6_accuracy: 0.8466 - val_head_6_loss: 0.4372 - val_head_7_accuracy: 0.8466 - val_head_7_loss: 0.4306 - val_loss: 3.0460 - learning_rate: 0.0187\n", "\n", "Epoch 21: LearningRateScheduler setting learning rate to 0.01853952693148294.\n", "Epoch 21/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 62ms/step - head_1_accuracy: 0.8708 - head_1_loss: 0.3457 - head_2_accuracy: 0.8717 - head_2_loss: 0.3476 - head_3_accuracy: 0.8721 - head_3_loss: 0.3465 - head_4_accuracy: 0.8715 - head_4_loss: 0.3486 - head_5_accuracy: 0.8708 - head_5_loss: 0.3521 - head_6_accuracy: 0.8699 - head_6_loss: 0.3468 - head_7_accuracy: 0.8729 - head_7_loss: 0.3461 - loss: 2.4333\n", "Epoch 21: val_head_1_accuracy did not improve from 0.97355\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 72ms/step - head_1_accuracy: 0.8827 - head_1_loss: 0.3142 - head_2_accuracy: 0.8840 - head_2_loss: 0.3145 - head_3_accuracy: 0.8833 - head_3_loss: 0.3154 - head_4_accuracy: 0.8834 - head_4_loss: 0.3172 - head_5_accuracy: 0.8830 - head_5_loss: 0.3189 - head_6_accuracy: 0.8818 - head_6_loss: 0.3153 - head_7_accuracy: 0.8839 - head_7_loss: 0.3159 - loss: 2.2332 - val_head_1_accuracy: 0.9123 - val_head_1_loss: 0.2472 - val_head_2_accuracy: 0.9114 - val_head_2_loss: 0.2466 - val_head_3_accuracy: 0.9104 - val_head_3_loss: 0.2449 - val_head_4_accuracy: 0.9132 - val_head_4_loss: 0.2426 - val_head_5_accuracy: 0.9111 - val_head_5_loss: 0.2528 - val_head_6_accuracy: 0.9162 - val_head_6_loss: 0.2472 - val_head_7_accuracy: 0.9128 - val_head_7_loss: 0.2459 - val_loss: 1.7234 - learning_rate: 0.0185\n", "\n", "Epoch 22: LearningRateScheduler setting learning rate to 0.018395398210570905.\n", "Epoch 22/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 61ms/step - head_1_accuracy: 0.9185 - head_1_loss: 0.2222 - head_2_accuracy: 0.9176 - head_2_loss: 0.2274 - head_3_accuracy: 0.9172 - head_3_loss: 0.2249 - head_4_accuracy: 0.9178 - head_4_loss: 0.2263 - head_5_accuracy: 0.9163 - head_5_loss: 0.2286 - head_6_accuracy: 0.9172 - head_6_loss: 0.2264 - head_7_accuracy: 0.9187 - head_7_loss: 0.2270 - loss: 1.5826\n", "Epoch 22: val_head_1_accuracy did not improve from 0.97355\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 69ms/step - head_1_accuracy: 0.9199 - head_1_loss: 0.2156 - head_2_accuracy: 0.9198 - head_2_loss: 0.2192 - head_3_accuracy: 0.9196 - head_3_loss: 0.2179 - head_4_accuracy: 0.9204 - head_4_loss: 0.2183 - head_5_accuracy: 0.9196 - head_5_loss: 0.2214 - head_6_accuracy: 0.9196 - head_6_loss: 0.2187 - head_7_accuracy: 0.9212 - head_7_loss: 0.2186 - loss: 1.5448 - val_head_1_accuracy: 0.9058 - val_head_1_loss: 0.2799 - val_head_2_accuracy: 0.9084 - val_head_2_loss: 0.2803 - val_head_3_accuracy: 0.9084 - val_head_3_loss: 0.2853 - val_head_4_accuracy: 0.9097 - val_head_4_loss: 0.2818 - val_head_5_accuracy: 0.9074 - val_head_5_loss: 0.2875 - val_head_6_accuracy: 0.9086 - val_head_6_loss: 0.2764 - val_head_7_accuracy: 0.9102 - val_head_7_loss: 0.2752 - val_loss: 1.9565 - learning_rate: 0.0184\n", "\n", "Epoch 23: LearningRateScheduler setting learning rate to 0.018245333323392336.\n", "Epoch 23/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 61ms/step - head_1_accuracy: 0.9343 - head_1_loss: 0.1795 - head_2_accuracy: 0.9325 - head_2_loss: 0.1803 - head_3_accuracy: 0.9344 - head_3_loss: 0.1805 - head_4_accuracy: 0.9339 - head_4_loss: 0.1830 - head_5_accuracy: 0.9336 - head_5_loss: 0.1807 - head_6_accuracy: 0.9355 - head_6_loss: 0.1814 - head_7_accuracy: 0.9350 - head_7_loss: 0.1824 - loss: 1.2679\n", "Epoch 23: val_head_1_accuracy did not improve from 0.97355\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 70ms/step - head_1_accuracy: 0.9363 - head_1_loss: 0.1711 - head_2_accuracy: 0.9356 - head_2_loss: 0.1708 - head_3_accuracy: 0.9353 - head_3_loss: 0.1724 - head_4_accuracy: 0.9359 - head_4_loss: 0.1730 - head_5_accuracy: 0.9351 - head_5_loss: 0.1741 - head_6_accuracy: 0.9374 - head_6_loss: 0.1721 - head_7_accuracy: 0.9366 - head_7_loss: 0.1730 - loss: 1.2184 - val_head_1_accuracy: 0.9490 - val_head_1_loss: 0.1290 - val_head_2_accuracy: 0.9494 - val_head_2_loss: 0.1269 - val_head_3_accuracy: 0.9485 - val_head_3_loss: 0.1320 - val_head_4_accuracy: 0.9515 - val_head_4_loss: 0.1262 - val_head_5_accuracy: 0.9499 - val_head_5_loss: 0.1313 - val_head_6_accuracy: 0.9527 - val_head_6_loss: 0.1297 - val_head_7_accuracy: 0.9538 - val_head_7_loss: 0.1265 - val_loss: 0.8988 - learning_rate: 0.0182\n", "\n", "Epoch 24: LearningRateScheduler setting learning rate to 0.01808948337256816.\n", "Epoch 24/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 61ms/step - head_1_accuracy: 0.9604 - head_1_loss: 0.1098 - head_2_accuracy: 0.9594 - head_2_loss: 0.1088 - head_3_accuracy: 0.9603 - head_3_loss: 0.1096 - head_4_accuracy: 0.9595 - head_4_loss: 0.1099 - head_5_accuracy: 0.9589 - head_5_loss: 0.1133 - head_6_accuracy: 0.9602 - head_6_loss: 0.1096 - head_7_accuracy: 0.9600 - head_7_loss: 0.1097 - loss: 0.7706\n", "Epoch 24: val_head_1_accuracy did not improve from 0.97355\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 70ms/step - head_1_accuracy: 0.9592 - head_1_loss: 0.1079 - head_2_accuracy: 0.9585 - head_2_loss: 0.1074 - head_3_accuracy: 0.9594 - head_3_loss: 0.1079 - head_4_accuracy: 0.9591 - head_4_loss: 0.1078 - head_5_accuracy: 0.9582 - head_5_loss: 0.1105 - head_6_accuracy: 0.9594 - head_6_loss: 0.1080 - head_7_accuracy: 0.9588 - head_7_loss: 0.1078 - loss: 0.7647 - val_head_1_accuracy: 0.9622 - val_head_1_loss: 0.1034 - val_head_2_accuracy: 0.9633 - val_head_2_loss: 0.1017 - val_head_3_accuracy: 0.9619 - val_head_3_loss: 0.1032 - val_head_4_accuracy: 0.9650 - val_head_4_loss: 0.1010 - val_head_5_accuracy: 0.9617 - val_head_5_loss: 0.1037 - val_head_6_accuracy: 0.9629 - val_head_6_loss: 0.1014 - val_head_7_accuracy: 0.9643 - val_head_7_loss: 0.1006 - val_loss: 0.7122 - learning_rate: 0.0181\n", "\n", "Epoch 25: LearningRateScheduler setting learning rate to 0.017928005285788026.\n", "Epoch 25/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 61ms/step - head_1_accuracy: 0.9678 - head_1_loss: 0.0918 - head_2_accuracy: 0.9664 - head_2_loss: 0.0923 - head_3_accuracy: 0.9669 - head_3_loss: 0.0916 - head_4_accuracy: 0.9671 - head_4_loss: 0.0927 - head_5_accuracy: 0.9650 - head_5_loss: 0.0927 - head_6_accuracy: 0.9671 - head_6_loss: 0.0924 - head_7_accuracy: 0.9669 - head_7_loss: 0.0915 - loss: 0.6451\n", "Epoch 25: val_head_1_accuracy did not improve from 0.97355\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 71ms/step - head_1_accuracy: 0.9694 - head_1_loss: 0.0836 - head_2_accuracy: 0.9692 - head_2_loss: 0.0847 - head_3_accuracy: 0.9693 - head_3_loss: 0.0841 - head_4_accuracy: 0.9692 - head_4_loss: 0.0844 - head_5_accuracy: 0.9688 - head_5_loss: 0.0846 - head_6_accuracy: 0.9690 - head_6_loss: 0.0846 - head_7_accuracy: 0.9693 - head_7_loss: 0.0840 - loss: 0.5958 - val_head_1_accuracy: 0.9487 - val_head_1_loss: 0.1669 - val_head_2_accuracy: 0.9499 - val_head_2_loss: 0.1677 - val_head_3_accuracy: 0.9510 - val_head_3_loss: 0.1627 - val_head_4_accuracy: 0.9490 - val_head_4_loss: 0.1692 - val_head_5_accuracy: 0.9510 - val_head_5_loss: 0.1622 - val_head_6_accuracy: 0.9478 - val_head_6_loss: 0.1636 - val_head_7_accuracy: 0.9503 - val_head_7_loss: 0.1608 - val_loss: 1.1441 - learning_rate: 0.0179\n", "\n", "Epoch 26: LearningRateScheduler setting learning rate to 0.01776106165779741.\n", "Epoch 26/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 62ms/step - head_1_accuracy: 0.9768 - head_1_loss: 0.0659 - head_2_accuracy: 0.9755 - head_2_loss: 0.0668 - head_3_accuracy: 0.9764 - head_3_loss: 0.0666 - head_4_accuracy: 0.9763 - head_4_loss: 0.0672 - head_5_accuracy: 0.9775 - head_5_loss: 0.0671 - head_6_accuracy: 0.9765 - head_6_loss: 0.0680 - head_7_accuracy: 0.9757 - head_7_loss: 0.0679 - loss: 0.4695\n", "Epoch 26: val_head_1_accuracy did not improve from 0.97355\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 70ms/step - head_1_accuracy: 0.9784 - head_1_loss: 0.0615 - head_2_accuracy: 0.9783 - head_2_loss: 0.0613 - head_3_accuracy: 0.9781 - head_3_loss: 0.0619 - head_4_accuracy: 0.9787 - head_4_loss: 0.0623 - head_5_accuracy: 0.9789 - head_5_loss: 0.0624 - head_6_accuracy: 0.9782 - head_6_loss: 0.0632 - head_7_accuracy: 0.9782 - head_7_loss: 0.0626 - loss: 0.4394 - val_head_1_accuracy: 0.9608 - val_head_1_loss: 0.1117 - val_head_2_accuracy: 0.9608 - val_head_2_loss: 0.1100 - val_head_3_accuracy: 0.9615 - val_head_3_loss: 0.1119 - val_head_4_accuracy: 0.9622 - val_head_4_loss: 0.1132 - val_head_5_accuracy: 0.9601 - val_head_5_loss: 0.1127 - val_head_6_accuracy: 0.9619 - val_head_6_loss: 0.1151 - val_head_7_accuracy: 0.9601 - val_head_7_loss: 0.1135 - val_loss: 0.7824 - learning_rate: 0.0178\n", "\n", "Epoch 27: LearningRateScheduler setting learning rate to 0.017588820586678492.\n", "Epoch 27/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 61ms/step - head_1_accuracy: 0.9805 - head_1_loss: 0.0556 - head_2_accuracy: 0.9807 - head_2_loss: 0.0566 - head_3_accuracy: 0.9809 - head_3_loss: 0.0547 - head_4_accuracy: 0.9802 - head_4_loss: 0.0556 - head_5_accuracy: 0.9807 - head_5_loss: 0.0561 - head_6_accuracy: 0.9815 - head_6_loss: 0.0552 - head_7_accuracy: 0.9806 - head_7_loss: 0.0557 - loss: 0.3894\n", "Epoch 27: val_head_1_accuracy did not improve from 0.97355\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 71ms/step - head_1_accuracy: 0.9803 - head_1_loss: 0.0564 - head_2_accuracy: 0.9804 - head_2_loss: 0.0572 - head_3_accuracy: 0.9805 - head_3_loss: 0.0561 - head_4_accuracy: 0.9799 - head_4_loss: 0.0568 - head_5_accuracy: 0.9804 - head_5_loss: 0.0566 - head_6_accuracy: 0.9809 - head_6_loss: 0.0566 - head_7_accuracy: 0.9807 - head_7_loss: 0.0562 - loss: 0.3997 - val_head_1_accuracy: 0.8872 - val_head_1_loss: 0.7081 - val_head_2_accuracy: 0.8942 - val_head_2_loss: 0.6117 - val_head_3_accuracy: 0.8898 - val_head_3_loss: 0.6710 - val_head_4_accuracy: 0.8933 - val_head_4_loss: 0.6231 - val_head_5_accuracy: 0.8921 - val_head_5_loss: 0.6601 - val_head_6_accuracy: 0.8893 - val_head_6_loss: 0.6918 - val_head_7_accuracy: 0.8930 - val_head_7_loss: 0.5941 - val_loss: 4.5431 - learning_rate: 0.0176\n", "\n", "Epoch 28: LearningRateScheduler setting learning rate to 0.01741145550458964.\n", "Epoch 28/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 62ms/step - head_1_accuracy: 0.9513 - head_1_loss: 0.1889 - head_2_accuracy: 0.9510 - head_2_loss: 0.1834 - head_3_accuracy: 0.9508 - head_3_loss: 0.1845 - head_4_accuracy: 0.9505 - head_4_loss: 0.1845 - head_5_accuracy: 0.9504 - head_5_loss: 0.1912 - head_6_accuracy: 0.9484 - head_6_loss: 0.1904 - head_7_accuracy: 0.9511 - head_7_loss: 0.1859 - loss: 1.3087\n", "Epoch 28: val_head_1_accuracy improved from 0.97355 to 0.98121, saving model to /content/drive/My Drive/Classification/multicp/models/AlexNet_CNN_MultiHead_best.keras\n", "\n", "Epoch 28: finished saving model to /content/drive/My Drive/Classification/multicp/models/AlexNet_CNN_MultiHead_best.keras\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m9s\u001b[0m 85ms/step - head_1_accuracy: 0.9780 - head_1_loss: 0.0774 - head_2_accuracy: 0.9780 - head_2_loss: 0.0760 - head_3_accuracy: 0.9784 - head_3_loss: 0.0764 - head_4_accuracy: 0.9783 - head_4_loss: 0.0768 - head_5_accuracy: 0.9780 - head_5_loss: 0.0780 - head_6_accuracy: 0.9771 - head_6_loss: 0.0779 - head_7_accuracy: 0.9780 - head_7_loss: 0.0769 - loss: 0.5447 - val_head_1_accuracy: 0.9812 - val_head_1_loss: 0.0556 - val_head_2_accuracy: 0.9805 - val_head_2_loss: 0.0543 - val_head_3_accuracy: 0.9800 - val_head_3_loss: 0.0563 - val_head_4_accuracy: 0.9807 - val_head_4_loss: 0.0551 - val_head_5_accuracy: 0.9784 - val_head_5_loss: 0.0553 - val_head_6_accuracy: 0.9800 - val_head_6_loss: 0.0587 - val_head_7_accuracy: 0.9794 - val_head_7_loss: 0.0569 - val_loss: 0.3904 - learning_rate: 0.0174\n", "\n", "Epoch 29: LearningRateScheduler setting learning rate to 0.017229145003133918.\n", "Epoch 29/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 62ms/step - head_1_accuracy: 0.9877 - head_1_loss: 0.0390 - head_2_accuracy: 0.9870 - head_2_loss: 0.0382 - head_3_accuracy: 0.9869 - head_3_loss: 0.0391 - head_4_accuracy: 0.9870 - head_4_loss: 0.0382 - head_5_accuracy: 0.9872 - head_5_loss: 0.0382 - head_6_accuracy: 0.9879 - head_6_loss: 0.0392 - head_7_accuracy: 0.9873 - head_7_loss: 0.0381 - loss: 0.2699\n", "Epoch 29: val_head_1_accuracy improved from 0.98121 to 0.98701, saving model to /content/drive/My Drive/Classification/multicp/models/AlexNet_CNN_MultiHead_best.keras\n", "\n", "Epoch 29: finished saving model to /content/drive/My Drive/Classification/multicp/models/AlexNet_CNN_MultiHead_best.keras\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m9s\u001b[0m 90ms/step - head_1_accuracy: 0.9902 - head_1_loss: 0.0310 - head_2_accuracy: 0.9900 - head_2_loss: 0.0306 - head_3_accuracy: 0.9899 - head_3_loss: 0.0309 - head_4_accuracy: 0.9900 - head_4_loss: 0.0312 - head_5_accuracy: 0.9900 - head_5_loss: 0.0312 - head_6_accuracy: 0.9903 - head_6_loss: 0.0319 - head_7_accuracy: 0.9899 - head_7_loss: 0.0306 - loss: 0.2197 - val_head_1_accuracy: 0.9870 - val_head_1_loss: 0.0435 - val_head_2_accuracy: 0.9865 - val_head_2_loss: 0.0423 - val_head_3_accuracy: 0.9865 - val_head_3_loss: 0.0443 - val_head_4_accuracy: 0.9872 - val_head_4_loss: 0.0429 - val_head_5_accuracy: 0.9865 - val_head_5_loss: 0.0446 - val_head_6_accuracy: 0.9872 - val_head_6_loss: 0.0446 - val_head_7_accuracy: 0.9858 - val_head_7_loss: 0.0448 - val_loss: 0.3058 - learning_rate: 0.0172\n", "\n", "Epoch 30: LearningRateScheduler setting learning rate to 0.0170420726535325.\n", "Epoch 30/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 61ms/step - head_1_accuracy: 0.9910 - head_1_loss: 0.0283 - head_2_accuracy: 0.9910 - head_2_loss: 0.0281 - head_3_accuracy: 0.9913 - head_3_loss: 0.0280 - head_4_accuracy: 0.9918 - head_4_loss: 0.0282 - head_5_accuracy: 0.9916 - head_5_loss: 0.0280 - head_6_accuracy: 0.9914 - head_6_loss: 0.0283 - head_7_accuracy: 0.9913 - head_7_loss: 0.0278 - loss: 0.1968\n", "Epoch 30: val_head_1_accuracy did not improve from 0.98701\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 70ms/step - head_1_accuracy: 0.9918 - head_1_loss: 0.0259 - head_2_accuracy: 0.9919 - head_2_loss: 0.0263 - head_3_accuracy: 0.9918 - head_3_loss: 0.0259 - head_4_accuracy: 0.9921 - head_4_loss: 0.0263 - head_5_accuracy: 0.9921 - head_5_loss: 0.0261 - head_6_accuracy: 0.9922 - head_6_loss: 0.0260 - head_7_accuracy: 0.9917 - head_7_loss: 0.0262 - loss: 0.1846 - val_head_1_accuracy: 0.9847 - val_head_1_loss: 0.0530 - val_head_2_accuracy: 0.9842 - val_head_2_loss: 0.0530 - val_head_3_accuracy: 0.9840 - val_head_3_loss: 0.0556 - val_head_4_accuracy: 0.9840 - val_head_4_loss: 0.0547 - val_head_5_accuracy: 0.9840 - val_head_5_loss: 0.0542 - val_head_6_accuracy: 0.9838 - val_head_6_loss: 0.0573 - val_head_7_accuracy: 0.9840 - val_head_7_loss: 0.0570 - val_loss: 0.3844 - learning_rate: 0.0170\n", "\n", "Epoch 31: LearningRateScheduler setting learning rate to 0.016850426821783986.\n", "Epoch 31/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 66ms/step - head_1_accuracy: 0.9922 - head_1_loss: 0.0244 - head_2_accuracy: 0.9931 - head_2_loss: 0.0244 - head_3_accuracy: 0.9928 - head_3_loss: 0.0257 - head_4_accuracy: 0.9934 - head_4_loss: 0.0249 - head_5_accuracy: 0.9930 - head_5_loss: 0.0253 - head_6_accuracy: 0.9928 - head_6_loss: 0.0252 - head_7_accuracy: 0.9927 - head_7_loss: 0.0247 - loss: 0.1748\n", "Epoch 31: val_head_1_accuracy did not improve from 0.98701\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m8s\u001b[0m 80ms/step - head_1_accuracy: 0.9946 - head_1_loss: 0.0188 - head_2_accuracy: 0.9949 - head_2_loss: 0.0188 - head_3_accuracy: 0.9950 - head_3_loss: 0.0197 - head_4_accuracy: 0.9949 - head_4_loss: 0.0197 - head_5_accuracy: 0.9952 - head_5_loss: 0.0192 - head_6_accuracy: 0.9950 - head_6_loss: 0.0198 - head_7_accuracy: 0.9950 - head_7_loss: 0.0189 - loss: 0.1361 - val_head_1_accuracy: 0.9712 - val_head_1_loss: 0.0947 - val_head_2_accuracy: 0.9710 - val_head_2_loss: 0.1006 - val_head_3_accuracy: 0.9705 - val_head_3_loss: 0.0988 - val_head_4_accuracy: 0.9710 - val_head_4_loss: 0.1072 - val_head_5_accuracy: 0.9708 - val_head_5_loss: 0.0968 - val_head_6_accuracy: 0.9710 - val_head_6_loss: 0.1091 - val_head_7_accuracy: 0.9703 - val_head_7_loss: 0.1134 - val_loss: 0.7137 - learning_rate: 0.0169\n", "\n", "Epoch 32: LearningRateScheduler setting learning rate to 0.01665440047899583.\n", "Epoch 32/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 67ms/step - head_1_accuracy: 0.9885 - head_1_loss: 0.0351 - head_2_accuracy: 0.9891 - head_2_loss: 0.0355 - head_3_accuracy: 0.9889 - head_3_loss: 0.0347 - head_4_accuracy: 0.9889 - head_4_loss: 0.0363 - head_5_accuracy: 0.9888 - head_5_loss: 0.0354 - head_6_accuracy: 0.9891 - head_6_loss: 0.0353 - head_7_accuracy: 0.9894 - head_7_loss: 0.0344 - loss: 0.2467\n", "Epoch 32: val_head_1_accuracy improved from 0.98701 to 0.98933, saving model to /content/drive/My Drive/Classification/multicp/models/AlexNet_CNN_MultiHead_best.keras\n", "\n", "Epoch 32: finished saving model to /content/drive/My Drive/Classification/multicp/models/AlexNet_CNN_MultiHead_best.keras\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m9s\u001b[0m 92ms/step - head_1_accuracy: 0.9868 - head_1_loss: 0.0426 - head_2_accuracy: 0.9869 - head_2_loss: 0.0430 - head_3_accuracy: 0.9872 - head_3_loss: 0.0424 - head_4_accuracy: 0.9872 - head_4_loss: 0.0438 - head_5_accuracy: 0.9869 - head_5_loss: 0.0425 - head_6_accuracy: 0.9873 - head_6_loss: 0.0430 - head_7_accuracy: 0.9875 - head_7_loss: 0.0419 - loss: 0.3023 - val_head_1_accuracy: 0.9893 - val_head_1_loss: 0.0321 - val_head_2_accuracy: 0.9898 - val_head_2_loss: 0.0319 - val_head_3_accuracy: 0.9889 - val_head_3_loss: 0.0331 - val_head_4_accuracy: 0.9896 - val_head_4_loss: 0.0329 - val_head_5_accuracy: 0.9905 - val_head_5_loss: 0.0326 - val_head_6_accuracy: 0.9891 - val_head_6_loss: 0.0333 - val_head_7_accuracy: 0.9900 - val_head_7_loss: 0.0341 - val_loss: 0.2304 - learning_rate: 0.0167\n", "\n", "Epoch 33: LearningRateScheduler setting learning rate to 0.016454191007078768.\n", "Epoch 33/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 63ms/step - head_1_accuracy: 0.9958 - head_1_loss: 0.0146 - head_2_accuracy: 0.9957 - head_2_loss: 0.0153 - head_3_accuracy: 0.9959 - head_3_loss: 0.0146 - head_4_accuracy: 0.9959 - head_4_loss: 0.0154 - head_5_accuracy: 0.9949 - head_5_loss: 0.0158 - head_6_accuracy: 0.9963 - head_6_loss: 0.0149 - head_7_accuracy: 0.9962 - head_7_loss: 0.0150 - loss: 0.1057\n", "Epoch 33: val_head_1_accuracy improved from 0.98933 to 0.99072, saving model to /content/drive/My Drive/Classification/multicp/models/AlexNet_CNN_MultiHead_best.keras\n", "\n", "Epoch 33: finished saving model to /content/drive/My Drive/Classification/multicp/models/AlexNet_CNN_MultiHead_best.keras\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m9s\u001b[0m 87ms/step - head_1_accuracy: 0.9970 - head_1_loss: 0.0120 - head_2_accuracy: 0.9971 - head_2_loss: 0.0125 - head_3_accuracy: 0.9971 - head_3_loss: 0.0119 - head_4_accuracy: 0.9970 - head_4_loss: 0.0127 - head_5_accuracy: 0.9967 - head_5_loss: 0.0127 - head_6_accuracy: 0.9971 - head_6_loss: 0.0120 - head_7_accuracy: 0.9972 - head_7_loss: 0.0122 - loss: 0.0868 - val_head_1_accuracy: 0.9907 - val_head_1_loss: 0.0284 - val_head_2_accuracy: 0.9903 - val_head_2_loss: 0.0277 - val_head_3_accuracy: 0.9910 - val_head_3_loss: 0.0285 - val_head_4_accuracy: 0.9912 - val_head_4_loss: 0.0282 - val_head_5_accuracy: 0.9907 - val_head_5_loss: 0.0275 - val_head_6_accuracy: 0.9900 - val_head_6_loss: 0.0301 - val_head_7_accuracy: 0.9905 - val_head_7_loss: 0.0293 - val_loss: 0.1984 - learning_rate: 0.0165\n", "\n", "Epoch 34: LearningRateScheduler setting learning rate to 0.01625.\n", "Epoch 34/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 61ms/step - head_1_accuracy: 0.9938 - head_1_loss: 0.0192 - head_2_accuracy: 0.9938 - head_2_loss: 0.0192 - head_3_accuracy: 0.9942 - head_3_loss: 0.0183 - head_4_accuracy: 0.9937 - head_4_loss: 0.0193 - head_5_accuracy: 0.9941 - head_5_loss: 0.0188 - head_6_accuracy: 0.9935 - head_6_loss: 0.0197 - head_7_accuracy: 0.9934 - head_7_loss: 0.0189 - loss: 0.1334\n", "Epoch 34: val_head_1_accuracy improved from 0.99072 to 0.99211, saving model to /content/drive/My Drive/Classification/multicp/models/AlexNet_CNN_MultiHead_best.keras\n", "\n", "Epoch 34: finished saving model to /content/drive/My Drive/Classification/multicp/models/AlexNet_CNN_MultiHead_best.keras\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m9s\u001b[0m 86ms/step - head_1_accuracy: 0.9941 - head_1_loss: 0.0191 - head_2_accuracy: 0.9942 - head_2_loss: 0.0191 - head_3_accuracy: 0.9941 - head_3_loss: 0.0185 - head_4_accuracy: 0.9942 - head_4_loss: 0.0189 - head_5_accuracy: 0.9946 - head_5_loss: 0.0188 - head_6_accuracy: 0.9940 - head_6_loss: 0.0195 - head_7_accuracy: 0.9941 - head_7_loss: 0.0186 - loss: 0.1338 - val_head_1_accuracy: 0.9921 - val_head_1_loss: 0.0287 - val_head_2_accuracy: 0.9933 - val_head_2_loss: 0.0276 - val_head_3_accuracy: 0.9926 - val_head_3_loss: 0.0297 - val_head_4_accuracy: 0.9921 - val_head_4_loss: 0.0275 - val_head_5_accuracy: 0.9926 - val_head_5_loss: 0.0289 - val_head_6_accuracy: 0.9923 - val_head_6_loss: 0.0307 - val_head_7_accuracy: 0.9935 - val_head_7_loss: 0.0329 - val_loss: 0.2024 - learning_rate: 0.0162\n", "\n", "Epoch 35: LearningRateScheduler setting learning rate to 0.01604203306079512.\n", "Epoch 35/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 63ms/step - head_1_accuracy: 0.9991 - head_1_loss: 0.0058 - head_2_accuracy: 0.9991 - head_2_loss: 0.0061 - head_3_accuracy: 0.9989 - head_3_loss: 0.0062 - head_4_accuracy: 0.9991 - head_4_loss: 0.0062 - head_5_accuracy: 0.9990 - head_5_loss: 0.0066 - head_6_accuracy: 0.9990 - head_6_loss: 0.0063 - head_7_accuracy: 0.9993 - head_7_loss: 0.0062 - loss: 0.0433\n", "Epoch 35: val_head_1_accuracy did not improve from 0.99211\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 73ms/step - head_1_accuracy: 0.9988 - head_1_loss: 0.0057 - head_2_accuracy: 0.9987 - head_2_loss: 0.0061 - head_3_accuracy: 0.9986 - head_3_loss: 0.0062 - head_4_accuracy: 0.9986 - head_4_loss: 0.0060 - head_5_accuracy: 0.9987 - head_5_loss: 0.0064 - head_6_accuracy: 0.9985 - head_6_loss: 0.0061 - head_7_accuracy: 0.9986 - head_7_loss: 0.0063 - loss: 0.0433 - val_head_1_accuracy: 0.9921 - val_head_1_loss: 0.0279 - val_head_2_accuracy: 0.9916 - val_head_2_loss: 0.0271 - val_head_3_accuracy: 0.9916 - val_head_3_loss: 0.0289 - val_head_4_accuracy: 0.9914 - val_head_4_loss: 0.0280 - val_head_5_accuracy: 0.9916 - val_head_5_loss: 0.0276 - val_head_6_accuracy: 0.9912 - val_head_6_loss: 0.0285 - val_head_7_accuracy: 0.9916 - val_head_7_loss: 0.0291 - val_loss: 0.1981 - learning_rate: 0.0160\n", "\n", "Epoch 36: LearningRateScheduler setting learning rate to 0.015830499594543305.\n", "Epoch 36/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 67ms/step - head_1_accuracy: 0.9989 - head_1_loss: 0.0052 - head_2_accuracy: 0.9987 - head_2_loss: 0.0059 - head_3_accuracy: 0.9988 - head_3_loss: 0.0057 - head_4_accuracy: 0.9983 - head_4_loss: 0.0062 - head_5_accuracy: 0.9986 - head_5_loss: 0.0059 - head_6_accuracy: 0.9986 - head_6_loss: 0.0054 - head_7_accuracy: 0.9983 - head_7_loss: 0.0058 - loss: 0.0402\n", "Epoch 36: val_head_1_accuracy did not improve from 0.99211\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m8s\u001b[0m 80ms/step - head_1_accuracy: 0.9990 - head_1_loss: 0.0042 - head_2_accuracy: 0.9988 - head_2_loss: 0.0047 - head_3_accuracy: 0.9988 - head_3_loss: 0.0045 - head_4_accuracy: 0.9987 - head_4_loss: 0.0048 - head_5_accuracy: 0.9987 - head_5_loss: 0.0049 - head_6_accuracy: 0.9992 - head_6_loss: 0.0042 - head_7_accuracy: 0.9990 - head_7_loss: 0.0044 - loss: 0.0321 - val_head_1_accuracy: 0.9863 - val_head_1_loss: 0.0417 - val_head_2_accuracy: 0.9868 - val_head_2_loss: 0.0423 - val_head_3_accuracy: 0.9875 - val_head_3_loss: 0.0402 - val_head_4_accuracy: 0.9865 - val_head_4_loss: 0.0426 - val_head_5_accuracy: 0.9865 - val_head_5_loss: 0.0413 - val_head_6_accuracy: 0.9861 - val_head_6_loss: 0.0442 - val_head_7_accuracy: 0.9868 - val_head_7_loss: 0.0443 - val_loss: 0.2942 - learning_rate: 0.0158\n", "\n", "Epoch 37: LearningRateScheduler setting learning rate to 0.01561561259751415.\n", "Epoch 37/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 68ms/step - head_1_accuracy: 0.9990 - head_1_loss: 0.0050 - head_2_accuracy: 0.9992 - head_2_loss: 0.0052 - head_3_accuracy: 0.9989 - head_3_loss: 0.0051 - head_4_accuracy: 0.9991 - head_4_loss: 0.0053 - head_5_accuracy: 0.9988 - head_5_loss: 0.0054 - head_6_accuracy: 0.9991 - head_6_loss: 0.0052 - head_7_accuracy: 0.9992 - head_7_loss: 0.0052 - loss: 0.0365\n", "Epoch 37: val_head_1_accuracy improved from 0.99211 to 0.99304, saving model to /content/drive/My Drive/Classification/multicp/models/AlexNet_CNN_MultiHead_best.keras\n", "\n", "Epoch 37: finished saving model to /content/drive/My Drive/Classification/multicp/models/AlexNet_CNN_MultiHead_best.keras\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m14s\u001b[0m 134ms/step - head_1_accuracy: 0.9992 - head_1_loss: 0.0044 - head_2_accuracy: 0.9994 - head_2_loss: 0.0045 - head_3_accuracy: 0.9991 - head_3_loss: 0.0047 - head_4_accuracy: 0.9992 - head_4_loss: 0.0047 - head_5_accuracy: 0.9991 - head_5_loss: 0.0046 - head_6_accuracy: 0.9991 - head_6_loss: 0.0045 - head_7_accuracy: 0.9992 - head_7_loss: 0.0046 - loss: 0.0324 - val_head_1_accuracy: 0.9930 - val_head_1_loss: 0.0226 - val_head_2_accuracy: 0.9937 - val_head_2_loss: 0.0221 - val_head_3_accuracy: 0.9930 - val_head_3_loss: 0.0224 - val_head_4_accuracy: 0.9935 - val_head_4_loss: 0.0217 - val_head_5_accuracy: 0.9930 - val_head_5_loss: 0.0237 - val_head_6_accuracy: 0.9930 - val_head_6_loss: 0.0239 - val_head_7_accuracy: 0.9933 - val_head_7_loss: 0.0243 - val_loss: 0.1606 - learning_rate: 0.0156\n", "\n", "Epoch 38: LearningRateScheduler setting learning rate to 0.015397588442698465.\n", "Epoch 38/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 63ms/step - head_1_accuracy: 0.9994 - head_1_loss: 0.0035 - head_2_accuracy: 0.9991 - head_2_loss: 0.0039 - head_3_accuracy: 0.9992 - head_3_loss: 0.0038 - head_4_accuracy: 0.9995 - head_4_loss: 0.0038 - head_5_accuracy: 0.9986 - head_5_loss: 0.0043 - head_6_accuracy: 0.9993 - head_6_loss: 0.0036 - head_7_accuracy: 0.9990 - head_7_loss: 0.0039 - loss: 0.0268\n", "Epoch 38: val_head_1_accuracy did not improve from 0.99304\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 72ms/step - head_1_accuracy: 0.9995 - head_1_loss: 0.0032 - head_2_accuracy: 0.9993 - head_2_loss: 0.0033 - head_3_accuracy: 0.9994 - head_3_loss: 0.0032 - head_4_accuracy: 0.9995 - head_4_loss: 0.0035 - head_5_accuracy: 0.9991 - head_5_loss: 0.0036 - head_6_accuracy: 0.9995 - head_6_loss: 0.0032 - head_7_accuracy: 0.9995 - head_7_loss: 0.0031 - loss: 0.0233 - val_head_1_accuracy: 0.9930 - val_head_1_loss: 0.0228 - val_head_2_accuracy: 0.9937 - val_head_2_loss: 0.0216 - val_head_3_accuracy: 0.9935 - val_head_3_loss: 0.0229 - val_head_4_accuracy: 0.9937 - val_head_4_loss: 0.0224 - val_head_5_accuracy: 0.9935 - val_head_5_loss: 0.0227 - val_head_6_accuracy: 0.9921 - val_head_6_loss: 0.0237 - val_head_7_accuracy: 0.9928 - val_head_7_loss: 0.0232 - val_loss: 0.1593 - learning_rate: 0.0154\n", "\n", "Epoch 39: LearningRateScheduler setting learning rate to 0.015176646661939037.\n", "Epoch 39/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 66ms/step - head_1_accuracy: 0.9995 - head_1_loss: 0.0026 - head_2_accuracy: 0.9996 - head_2_loss: 0.0029 - head_3_accuracy: 0.9994 - head_3_loss: 0.0029 - head_4_accuracy: 0.9995 - head_4_loss: 0.0030 - head_5_accuracy: 0.9996 - head_5_loss: 0.0027 - head_6_accuracy: 0.9996 - head_6_loss: 0.0028 - head_7_accuracy: 0.9993 - head_7_loss: 0.0027 - loss: 0.0196\n", "Epoch 39: val_head_1_accuracy did not improve from 0.99304\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m8s\u001b[0m 76ms/step - head_1_accuracy: 0.9993 - head_1_loss: 0.0030 - head_2_accuracy: 0.9993 - head_2_loss: 0.0033 - head_3_accuracy: 0.9992 - head_3_loss: 0.0034 - head_4_accuracy: 0.9994 - head_4_loss: 0.0037 - head_5_accuracy: 0.9994 - head_5_loss: 0.0031 - head_6_accuracy: 0.9993 - head_6_loss: 0.0032 - head_7_accuracy: 0.9991 - head_7_loss: 0.0032 - loss: 0.0230 - val_head_1_accuracy: 0.9926 - val_head_1_loss: 0.0233 - val_head_2_accuracy: 0.9928 - val_head_2_loss: 0.0223 - val_head_3_accuracy: 0.9928 - val_head_3_loss: 0.0235 - val_head_4_accuracy: 0.9928 - val_head_4_loss: 0.0231 - val_head_5_accuracy: 0.9933 - val_head_5_loss: 0.0231 - val_head_6_accuracy: 0.9926 - val_head_6_loss: 0.0238 - val_head_7_accuracy: 0.9935 - val_head_7_loss: 0.0232 - val_loss: 0.1624 - learning_rate: 0.0152\n", "\n", "Epoch 40: LearningRateScheduler setting learning rate to 0.014953009724880662.\n", "Epoch 40/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 69ms/step - head_1_accuracy: 0.9991 - head_1_loss: 0.0040 - head_2_accuracy: 0.9990 - head_2_loss: 0.0041 - head_3_accuracy: 0.9992 - head_3_loss: 0.0039 - head_4_accuracy: 0.9991 - head_4_loss: 0.0043 - head_5_accuracy: 0.9994 - head_5_loss: 0.0039 - head_6_accuracy: 0.9990 - head_6_loss: 0.0040 - head_7_accuracy: 0.9993 - head_7_loss: 0.0038 - loss: 0.0280\n", "Epoch 40: val_head_1_accuracy improved from 0.99304 to 0.99374, saving model to /content/drive/My Drive/Classification/multicp/models/AlexNet_CNN_MultiHead_best.keras\n", "\n", "Epoch 40: finished saving model to /content/drive/My Drive/Classification/multicp/models/AlexNet_CNN_MultiHead_best.keras\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 95ms/step - head_1_accuracy: 0.9990 - head_1_loss: 0.0042 - head_2_accuracy: 0.9990 - head_2_loss: 0.0043 - head_3_accuracy: 0.9992 - head_3_loss: 0.0041 - head_4_accuracy: 0.9991 - head_4_loss: 0.0045 - head_5_accuracy: 0.9992 - head_5_loss: 0.0042 - head_6_accuracy: 0.9990 - head_6_loss: 0.0041 - head_7_accuracy: 0.9992 - head_7_loss: 0.0042 - loss: 0.0299 - val_head_1_accuracy: 0.9937 - val_head_1_loss: 0.0218 - val_head_2_accuracy: 0.9935 - val_head_2_loss: 0.0211 - val_head_3_accuracy: 0.9937 - val_head_3_loss: 0.0221 - val_head_4_accuracy: 0.9933 - val_head_4_loss: 0.0217 - val_head_5_accuracy: 0.9930 - val_head_5_loss: 0.0226 - val_head_6_accuracy: 0.9937 - val_head_6_loss: 0.0223 - val_head_7_accuracy: 0.9933 - val_head_7_loss: 0.0227 - val_loss: 0.1554 - learning_rate: 0.0150\n", "\n", "Epoch 41: LearningRateScheduler setting learning rate to 0.014726902814962063.\n", "Epoch 41/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 61ms/step - head_1_accuracy: 0.9997 - head_1_loss: 0.0016 - head_2_accuracy: 1.0000 - head_2_loss: 0.0018 - head_3_accuracy: 0.9996 - head_3_loss: 0.0018 - head_4_accuracy: 0.9996 - head_4_loss: 0.0018 - head_5_accuracy: 0.9996 - head_5_loss: 0.0019 - head_6_accuracy: 0.9999 - head_6_loss: 0.0016 - head_7_accuracy: 0.9994 - head_7_loss: 0.0019 - loss: 0.0125\n", "Epoch 41: val_head_1_accuracy did not improve from 0.99374\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 70ms/step - head_1_accuracy: 0.9998 - head_1_loss: 0.0014 - head_2_accuracy: 1.0000 - head_2_loss: 0.0015 - head_3_accuracy: 0.9998 - head_3_loss: 0.0015 - head_4_accuracy: 0.9998 - head_4_loss: 0.0015 - head_5_accuracy: 0.9998 - head_5_loss: 0.0016 - head_6_accuracy: 0.9999 - head_6_loss: 0.0014 - head_7_accuracy: 0.9998 - head_7_loss: 0.0014 - loss: 0.0103 - val_head_1_accuracy: 0.9933 - val_head_1_loss: 0.0214 - val_head_2_accuracy: 0.9930 - val_head_2_loss: 0.0200 - val_head_3_accuracy: 0.9933 - val_head_3_loss: 0.0211 - val_head_4_accuracy: 0.9935 - val_head_4_loss: 0.0200 - val_head_5_accuracy: 0.9933 - val_head_5_loss: 0.0217 - val_head_6_accuracy: 0.9933 - val_head_6_loss: 0.0212 - val_head_7_accuracy: 0.9937 - val_head_7_loss: 0.0216 - val_loss: 0.1474 - learning_rate: 0.0147\n", "\n", "Epoch 42: LearningRateScheduler setting learning rate to 0.014498553602675261.\n", "Epoch 42/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 67ms/step - head_1_accuracy: 0.9974 - head_1_loss: 0.0106 - head_2_accuracy: 0.9972 - head_2_loss: 0.0100 - head_3_accuracy: 0.9976 - head_3_loss: 0.0099 - head_4_accuracy: 0.9975 - head_4_loss: 0.0105 - head_5_accuracy: 0.9977 - head_5_loss: 0.0099 - head_6_accuracy: 0.9975 - head_6_loss: 0.0107 - head_7_accuracy: 0.9976 - head_7_loss: 0.0104 - loss: 0.0720\n", "Epoch 42: val_head_1_accuracy did not improve from 0.99374\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m8s\u001b[0m 80ms/step - head_1_accuracy: 0.9976 - head_1_loss: 0.0094 - head_2_accuracy: 0.9975 - head_2_loss: 0.0089 - head_3_accuracy: 0.9976 - head_3_loss: 0.0088 - head_4_accuracy: 0.9976 - head_4_loss: 0.0094 - head_5_accuracy: 0.9978 - head_5_loss: 0.0089 - head_6_accuracy: 0.9976 - head_6_loss: 0.0096 - head_7_accuracy: 0.9978 - head_7_loss: 0.0093 - loss: 0.0650 - val_head_1_accuracy: 0.9935 - val_head_1_loss: 0.0222 - val_head_2_accuracy: 0.9935 - val_head_2_loss: 0.0207 - val_head_3_accuracy: 0.9935 - val_head_3_loss: 0.0220 - val_head_4_accuracy: 0.9937 - val_head_4_loss: 0.0208 - val_head_5_accuracy: 0.9933 - val_head_5_loss: 0.0225 - val_head_6_accuracy: 0.9933 - val_head_6_loss: 0.0226 - val_head_7_accuracy: 0.9940 - val_head_7_loss: 0.0222 - val_loss: 0.1544 - learning_rate: 0.0145\n", "\n", "Epoch 43: LearningRateScheduler setting learning rate to 0.014268192016320704.\n", "Epoch 43/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 66ms/step - head_1_accuracy: 0.9998 - head_1_loss: 0.0020 - head_2_accuracy: 0.9998 - head_2_loss: 0.0023 - head_3_accuracy: 0.9998 - head_3_loss: 0.0021 - head_4_accuracy: 0.9998 - head_4_loss: 0.0022 - head_5_accuracy: 0.9999 - head_5_loss: 0.0023 - head_6_accuracy: 0.9997 - head_6_loss: 0.0020 - head_7_accuracy: 0.9997 - head_7_loss: 0.0020 - loss: 0.0149\n", "Epoch 43: val_head_1_accuracy improved from 0.99374 to 0.99397, saving model to /content/drive/My Drive/Classification/multicp/models/AlexNet_CNN_MultiHead_best.keras\n", "\n", "Epoch 43: finished saving model to /content/drive/My Drive/Classification/multicp/models/AlexNet_CNN_MultiHead_best.keras\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m17s\u001b[0m 147ms/step - head_1_accuracy: 0.9997 - head_1_loss: 0.0017 - head_2_accuracy: 0.9998 - head_2_loss: 0.0020 - head_3_accuracy: 0.9998 - head_3_loss: 0.0019 - head_4_accuracy: 0.9998 - head_4_loss: 0.0019 - head_5_accuracy: 0.9998 - head_5_loss: 0.0018 - head_6_accuracy: 0.9997 - head_6_loss: 0.0018 - head_7_accuracy: 0.9997 - head_7_loss: 0.0018 - loss: 0.0131 - val_head_1_accuracy: 0.9940 - val_head_1_loss: 0.0186 - val_head_2_accuracy: 0.9942 - val_head_2_loss: 0.0175 - val_head_3_accuracy: 0.9947 - val_head_3_loss: 0.0186 - val_head_4_accuracy: 0.9942 - val_head_4_loss: 0.0174 - val_head_5_accuracy: 0.9937 - val_head_5_loss: 0.0194 - val_head_6_accuracy: 0.9940 - val_head_6_loss: 0.0194 - val_head_7_accuracy: 0.9940 - val_head_7_loss: 0.0197 - val_loss: 0.1317 - learning_rate: 0.0143\n", "\n", "Epoch 44: LearningRateScheduler setting learning rate to 0.01403605001048893.\n", "Epoch 44/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 61ms/step - head_1_accuracy: 0.9998 - head_1_loss: 0.0015 - head_2_accuracy: 0.9998 - head_2_loss: 0.0017 - head_3_accuracy: 1.0000 - head_3_loss: 0.0015 - head_4_accuracy: 0.9997 - head_4_loss: 0.0016 - head_5_accuracy: 0.9996 - head_5_loss: 0.0018 - head_6_accuracy: 0.9998 - head_6_loss: 0.0017 - head_7_accuracy: 0.9996 - head_7_loss: 0.0016 - loss: 0.0115\n", "Epoch 44: val_head_1_accuracy did not improve from 0.99397\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 70ms/step - head_1_accuracy: 0.9998 - head_1_loss: 0.0014 - head_2_accuracy: 0.9997 - head_2_loss: 0.0016 - head_3_accuracy: 1.0000 - head_3_loss: 0.0014 - head_4_accuracy: 0.9996 - head_4_loss: 0.0015 - head_5_accuracy: 0.9996 - head_5_loss: 0.0017 - head_6_accuracy: 0.9997 - head_6_loss: 0.0016 - head_7_accuracy: 0.9997 - head_7_loss: 0.0015 - loss: 0.0107 - val_head_1_accuracy: 0.9933 - val_head_1_loss: 0.0220 - val_head_2_accuracy: 0.9935 - val_head_2_loss: 0.0210 - val_head_3_accuracy: 0.9935 - val_head_3_loss: 0.0227 - val_head_4_accuracy: 0.9937 - val_head_4_loss: 0.0214 - val_head_5_accuracy: 0.9928 - val_head_5_loss: 0.0217 - val_head_6_accuracy: 0.9930 - val_head_6_loss: 0.0226 - val_head_7_accuracy: 0.9930 - val_head_7_loss: 0.0232 - val_loss: 0.1552 - learning_rate: 0.0140\n", "\n", "Epoch 45: LearningRateScheduler setting learning rate to 0.01380236133250198.\n", "Epoch 45/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 67ms/step - head_1_accuracy: 0.9998 - head_1_loss: 9.7781e-04 - head_2_accuracy: 1.0000 - head_2_loss: 9.9006e-04 - head_3_accuracy: 1.0000 - head_3_loss: 0.0010 - head_4_accuracy: 0.9998 - head_4_loss: 0.0011 - head_5_accuracy: 0.9999 - head_5_loss: 0.0011 - head_6_accuracy: 0.9998 - head_6_loss: 0.0011 - head_7_accuracy: 0.9999 - head_7_loss: 9.9251e-04 - loss: 0.0072\n", "Epoch 45: val_head_1_accuracy improved from 0.99397 to 0.99490, saving model to /content/drive/My Drive/Classification/multicp/models/AlexNet_CNN_MultiHead_best.keras\n", "\n", "Epoch 45: finished saving model to /content/drive/My Drive/Classification/multicp/models/AlexNet_CNN_MultiHead_best.keras\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m13s\u001b[0m 129ms/step - head_1_accuracy: 0.9999 - head_1_loss: 9.4987e-04 - head_2_accuracy: 1.0000 - head_2_loss: 0.0011 - head_3_accuracy: 1.0000 - head_3_loss: 0.0010 - head_4_accuracy: 0.9999 - head_4_loss: 0.0011 - head_5_accuracy: 0.9999 - head_5_loss: 0.0011 - head_6_accuracy: 0.9998 - head_6_loss: 0.0012 - head_7_accuracy: 0.9999 - head_7_loss: 0.0010 - loss: 0.0075 - val_head_1_accuracy: 0.9949 - val_head_1_loss: 0.0193 - val_head_2_accuracy: 0.9942 - val_head_2_loss: 0.0186 - val_head_3_accuracy: 0.9944 - val_head_3_loss: 0.0199 - val_head_4_accuracy: 0.9942 - val_head_4_loss: 0.0190 - val_head_5_accuracy: 0.9944 - val_head_5_loss: 0.0189 - val_head_6_accuracy: 0.9944 - val_head_6_loss: 0.0207 - val_head_7_accuracy: 0.9947 - val_head_7_loss: 0.0204 - val_loss: 0.1368 - learning_rate: 0.0138\n", "\n", "Epoch 46: LearningRateScheduler setting learning rate to 0.013567361287049638.\n", "Epoch 46/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 63ms/step - head_1_accuracy: 1.0000 - head_1_loss: 8.5158e-04 - head_2_accuracy: 1.0000 - head_2_loss: 7.9591e-04 - head_3_accuracy: 1.0000 - head_3_loss: 7.5028e-04 - head_4_accuracy: 1.0000 - head_4_loss: 7.8496e-04 - head_5_accuracy: 1.0000 - head_5_loss: 8.6854e-04 - head_6_accuracy: 1.0000 - head_6_loss: 7.3987e-04 - head_7_accuracy: 1.0000 - head_7_loss: 6.5860e-04 - loss: 0.0054\n", "Epoch 46: val_head_1_accuracy did not improve from 0.99490\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 73ms/step - head_1_accuracy: 1.0000 - head_1_loss: 8.5850e-04 - head_2_accuracy: 0.9999 - head_2_loss: 9.1675e-04 - head_3_accuracy: 0.9999 - head_3_loss: 8.5829e-04 - head_4_accuracy: 0.9999 - head_4_loss: 8.8396e-04 - head_5_accuracy: 0.9999 - head_5_loss: 9.0831e-04 - head_6_accuracy: 0.9999 - head_6_loss: 8.9375e-04 - head_7_accuracy: 0.9998 - head_7_loss: 8.2827e-04 - loss: 0.0062 - val_head_1_accuracy: 0.9937 - val_head_1_loss: 0.0211 - val_head_2_accuracy: 0.9942 - val_head_2_loss: 0.0203 - val_head_3_accuracy: 0.9937 - val_head_3_loss: 0.0220 - val_head_4_accuracy: 0.9937 - val_head_4_loss: 0.0203 - val_head_5_accuracy: 0.9937 - val_head_5_loss: 0.0209 - val_head_6_accuracy: 0.9937 - val_head_6_loss: 0.0227 - val_head_7_accuracy: 0.9940 - val_head_7_loss: 0.0232 - val_loss: 0.1499 - learning_rate: 0.0136\n", "\n", "Epoch 47: LearningRateScheduler setting learning rate to 0.013331286499257584.\n", "Epoch 47/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 67ms/step - head_1_accuracy: 0.9992 - head_1_loss: 0.0038 - head_2_accuracy: 0.9988 - head_2_loss: 0.0038 - head_3_accuracy: 0.9989 - head_3_loss: 0.0036 - head_4_accuracy: 0.9988 - head_4_loss: 0.0036 - head_5_accuracy: 0.9989 - head_5_loss: 0.0035 - head_6_accuracy: 0.9991 - head_6_loss: 0.0032 - head_7_accuracy: 0.9988 - head_7_loss: 0.0036 - loss: 0.0251\n", "Epoch 47: val_head_1_accuracy did not improve from 0.99490\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m8s\u001b[0m 77ms/step - head_1_accuracy: 0.9996 - head_1_loss: 0.0021 - head_2_accuracy: 0.9994 - head_2_loss: 0.0022 - head_3_accuracy: 0.9995 - head_3_loss: 0.0021 - head_4_accuracy: 0.9994 - head_4_loss: 0.0021 - head_5_accuracy: 0.9995 - head_5_loss: 0.0020 - head_6_accuracy: 0.9995 - head_6_loss: 0.0019 - head_7_accuracy: 0.9994 - head_7_loss: 0.0020 - loss: 0.0145 - val_head_1_accuracy: 0.9944 - val_head_1_loss: 0.0213 - val_head_2_accuracy: 0.9947 - val_head_2_loss: 0.0202 - val_head_3_accuracy: 0.9942 - val_head_3_loss: 0.0214 - val_head_4_accuracy: 0.9947 - val_head_4_loss: 0.0196 - val_head_5_accuracy: 0.9937 - val_head_5_loss: 0.0217 - val_head_6_accuracy: 0.9937 - val_head_6_loss: 0.0225 - val_head_7_accuracy: 0.9944 - val_head_7_loss: 0.0241 - val_loss: 0.1498 - learning_rate: 0.0133\n", "\n", "Epoch 48: LearningRateScheduler setting learning rate to 0.013094374676425914.\n", "Epoch 48/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 68ms/step - head_1_accuracy: 0.9984 - head_1_loss: 0.0035 - head_2_accuracy: 0.9986 - head_2_loss: 0.0038 - head_3_accuracy: 0.9983 - head_3_loss: 0.0040 - head_4_accuracy: 0.9989 - head_4_loss: 0.0032 - head_5_accuracy: 0.9991 - head_5_loss: 0.0036 - head_6_accuracy: 0.9984 - head_6_loss: 0.0040 - head_7_accuracy: 0.9989 - head_7_loss: 0.0034 - loss: 0.0255\n", "Epoch 48: val_head_1_accuracy did not improve from 0.99490\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m8s\u001b[0m 79ms/step - head_1_accuracy: 0.9988 - head_1_loss: 0.0034 - head_2_accuracy: 0.9988 - head_2_loss: 0.0038 - head_3_accuracy: 0.9984 - head_3_loss: 0.0038 - head_4_accuracy: 0.9989 - head_4_loss: 0.0033 - head_5_accuracy: 0.9990 - head_5_loss: 0.0036 - head_6_accuracy: 0.9986 - head_6_loss: 0.0035 - head_7_accuracy: 0.9989 - head_7_loss: 0.0035 - loss: 0.0252 - val_head_1_accuracy: 0.9944 - val_head_1_loss: 0.0201 - val_head_2_accuracy: 0.9949 - val_head_2_loss: 0.0190 - val_head_3_accuracy: 0.9942 - val_head_3_loss: 0.0210 - val_head_4_accuracy: 0.9937 - val_head_4_loss: 0.0207 - val_head_5_accuracy: 0.9954 - val_head_5_loss: 0.0189 - val_head_6_accuracy: 0.9937 - val_head_6_loss: 0.0217 - val_head_7_accuracy: 0.9951 - val_head_7_loss: 0.0209 - val_loss: 0.1415 - learning_rate: 0.0131\n", "\n", "Epoch 49: LearningRateScheduler setting learning rate to 0.01285686436867807.\n", "Epoch 49/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 62ms/step - head_1_accuracy: 0.9996 - head_1_loss: 0.0012 - head_2_accuracy: 0.9997 - head_2_loss: 0.0014 - head_3_accuracy: 0.9996 - head_3_loss: 0.0017 - head_4_accuracy: 0.9996 - head_4_loss: 0.0014 - head_5_accuracy: 0.9996 - head_5_loss: 0.0013 - head_6_accuracy: 0.9996 - head_6_loss: 0.0016 - head_7_accuracy: 0.9996 - head_7_loss: 0.0015 - loss: 0.0101\n", "Epoch 49: val_head_1_accuracy improved from 0.99490 to 0.99536, saving model to /content/drive/My Drive/Classification/multicp/models/AlexNet_CNN_MultiHead_best.keras\n", "\n", "Epoch 49: finished saving model to /content/drive/My Drive/Classification/multicp/models/AlexNet_CNN_MultiHead_best.keras\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m11s\u001b[0m 86ms/step - head_1_accuracy: 0.9997 - head_1_loss: 0.0014 - head_2_accuracy: 0.9998 - head_2_loss: 0.0014 - head_3_accuracy: 0.9996 - head_3_loss: 0.0016 - head_4_accuracy: 0.9998 - head_4_loss: 0.0015 - head_5_accuracy: 0.9996 - head_5_loss: 0.0015 - head_6_accuracy: 0.9998 - head_6_loss: 0.0015 - head_7_accuracy: 0.9997 - head_7_loss: 0.0016 - loss: 0.0105 - val_head_1_accuracy: 0.9954 - val_head_1_loss: 0.0184 - val_head_2_accuracy: 0.9958 - val_head_2_loss: 0.0175 - val_head_3_accuracy: 0.9954 - val_head_3_loss: 0.0191 - val_head_4_accuracy: 0.9949 - val_head_4_loss: 0.0183 - val_head_5_accuracy: 0.9958 - val_head_5_loss: 0.0177 - val_head_6_accuracy: 0.9956 - val_head_6_loss: 0.0198 - val_head_7_accuracy: 0.9956 - val_head_7_loss: 0.0197 - val_loss: 0.1301 - learning_rate: 0.0129\n", "\n", "Epoch 50: LearningRateScheduler setting learning rate to 0.012618994728761062.\n", "Epoch 50/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 64ms/step - head_1_accuracy: 0.9999 - head_1_loss: 0.0015 - head_2_accuracy: 0.9995 - head_2_loss: 0.0019 - head_3_accuracy: 0.9995 - head_3_loss: 0.0020 - head_4_accuracy: 0.9993 - head_4_loss: 0.0020 - head_5_accuracy: 0.9994 - head_5_loss: 0.0019 - head_6_accuracy: 0.9996 - head_6_loss: 0.0017 - head_7_accuracy: 0.9994 - head_7_loss: 0.0019 - loss: 0.0130\n", "Epoch 50: val_head_1_accuracy did not improve from 0.99536\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 73ms/step - head_1_accuracy: 0.9999 - head_1_loss: 0.0011 - head_2_accuracy: 0.9998 - head_2_loss: 0.0014 - head_3_accuracy: 0.9997 - head_3_loss: 0.0014 - head_4_accuracy: 0.9995 - head_4_loss: 0.0015 - head_5_accuracy: 0.9997 - head_5_loss: 0.0013 - head_6_accuracy: 0.9997 - head_6_loss: 0.0013 - head_7_accuracy: 0.9997 - head_7_loss: 0.0013 - loss: 0.0095 - val_head_1_accuracy: 0.9951 - val_head_1_loss: 0.0173 - val_head_2_accuracy: 0.9954 - val_head_2_loss: 0.0165 - val_head_3_accuracy: 0.9956 - val_head_3_loss: 0.0178 - val_head_4_accuracy: 0.9951 - val_head_4_loss: 0.0173 - val_head_5_accuracy: 0.9954 - val_head_5_loss: 0.0170 - val_head_6_accuracy: 0.9949 - val_head_6_loss: 0.0186 - val_head_7_accuracy: 0.9951 - val_head_7_loss: 0.0184 - val_loss: 0.1230 - learning_rate: 0.0126\n", "\n", "Epoch 51: LearningRateScheduler setting learning rate to 0.01238100527123894.\n", "Epoch 51/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 67ms/step - head_1_accuracy: 1.0000 - head_1_loss: 8.2859e-04 - head_2_accuracy: 1.0000 - head_2_loss: 9.0547e-04 - head_3_accuracy: 1.0000 - head_3_loss: 8.7808e-04 - head_4_accuracy: 1.0000 - head_4_loss: 7.4938e-04 - head_5_accuracy: 0.9999 - head_5_loss: 8.8353e-04 - head_6_accuracy: 1.0000 - head_6_loss: 8.3187e-04 - head_7_accuracy: 0.9998 - head_7_loss: 8.8576e-04 - loss: 0.0060\n", "Epoch 51: val_head_1_accuracy did not improve from 0.99536\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m8s\u001b[0m 78ms/step - head_1_accuracy: 1.0000 - head_1_loss: 6.2287e-04 - head_2_accuracy: 1.0000 - head_2_loss: 6.5022e-04 - head_3_accuracy: 1.0000 - head_3_loss: 6.8038e-04 - head_4_accuracy: 1.0000 - head_4_loss: 6.0053e-04 - head_5_accuracy: 0.9999 - head_5_loss: 6.8753e-04 - head_6_accuracy: 1.0000 - head_6_loss: 6.3085e-04 - head_7_accuracy: 0.9999 - head_7_loss: 7.0332e-04 - loss: 0.0046 - val_head_1_accuracy: 0.9949 - val_head_1_loss: 0.0192 - val_head_2_accuracy: 0.9956 - val_head_2_loss: 0.0183 - val_head_3_accuracy: 0.9951 - val_head_3_loss: 0.0194 - val_head_4_accuracy: 0.9947 - val_head_4_loss: 0.0188 - val_head_5_accuracy: 0.9949 - val_head_5_loss: 0.0187 - val_head_6_accuracy: 0.9949 - val_head_6_loss: 0.0203 - val_head_7_accuracy: 0.9947 - val_head_7_loss: 0.0201 - val_loss: 0.1345 - learning_rate: 0.0124\n", "\n", "Epoch 52: LearningRateScheduler setting learning rate to 0.012143135631321932.\n", "Epoch 52/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 64ms/step - head_1_accuracy: 0.9996 - head_1_loss: 0.0010 - head_2_accuracy: 0.9998 - head_2_loss: 0.0012 - head_3_accuracy: 0.9996 - head_3_loss: 0.0012 - head_4_accuracy: 0.9996 - head_4_loss: 0.0011 - head_5_accuracy: 0.9996 - head_5_loss: 9.8868e-04 - head_6_accuracy: 0.9996 - head_6_loss: 0.0013 - head_7_accuracy: 0.9998 - head_7_loss: 8.7088e-04 - loss: 0.0076\n", "Epoch 52: val_head_1_accuracy did not improve from 0.99536\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m10s\u001b[0m 74ms/step - head_1_accuracy: 0.9998 - head_1_loss: 7.2034e-04 - head_2_accuracy: 0.9999 - head_2_loss: 8.7168e-04 - head_3_accuracy: 0.9998 - head_3_loss: 8.0807e-04 - head_4_accuracy: 0.9998 - head_4_loss: 7.9023e-04 - head_5_accuracy: 0.9998 - head_5_loss: 7.7609e-04 - head_6_accuracy: 0.9998 - head_6_loss: 8.0942e-04 - head_7_accuracy: 0.9998 - head_7_loss: 6.9596e-04 - loss: 0.0055 - val_head_1_accuracy: 0.9951 - val_head_1_loss: 0.0204 - val_head_2_accuracy: 0.9954 - val_head_2_loss: 0.0197 - val_head_3_accuracy: 0.9951 - val_head_3_loss: 0.0209 - val_head_4_accuracy: 0.9942 - val_head_4_loss: 0.0203 - val_head_5_accuracy: 0.9951 - val_head_5_loss: 0.0201 - val_head_6_accuracy: 0.9942 - val_head_6_loss: 0.0214 - val_head_7_accuracy: 0.9949 - val_head_7_loss: 0.0218 - val_loss: 0.1445 - learning_rate: 0.0121\n", "\n", "Epoch 53: LearningRateScheduler setting learning rate to 0.011905625323574085.\n", "Epoch 53/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 62ms/step - head_1_accuracy: 0.9999 - head_1_loss: 6.9800e-04 - head_2_accuracy: 1.0000 - head_2_loss: 5.7028e-04 - head_3_accuracy: 0.9997 - head_3_loss: 0.0010 - head_4_accuracy: 1.0000 - head_4_loss: 6.2878e-04 - head_5_accuracy: 1.0000 - head_5_loss: 5.6148e-04 - head_6_accuracy: 0.9997 - head_6_loss: 9.2375e-04 - head_7_accuracy: 1.0000 - head_7_loss: 5.1043e-04 - loss: 0.0049\n", "Epoch 53: val_head_1_accuracy did not improve from 0.99536\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 72ms/step - head_1_accuracy: 0.9997 - head_1_loss: 0.0020 - head_2_accuracy: 0.9998 - head_2_loss: 0.0017 - head_3_accuracy: 0.9996 - head_3_loss: 0.0021 - head_4_accuracy: 0.9998 - head_4_loss: 0.0020 - head_5_accuracy: 0.9997 - head_5_loss: 0.0018 - head_6_accuracy: 0.9996 - head_6_loss: 0.0020 - head_7_accuracy: 0.9997 - head_7_loss: 0.0018 - loss: 0.0136 - val_head_1_accuracy: 0.9954 - val_head_1_loss: 0.0190 - val_head_2_accuracy: 0.9949 - val_head_2_loss: 0.0185 - val_head_3_accuracy: 0.9944 - val_head_3_loss: 0.0196 - val_head_4_accuracy: 0.9949 - val_head_4_loss: 0.0201 - val_head_5_accuracy: 0.9949 - val_head_5_loss: 0.0189 - val_head_6_accuracy: 0.9944 - val_head_6_loss: 0.0202 - val_head_7_accuracy: 0.9949 - val_head_7_loss: 0.0197 - val_loss: 0.1367 - learning_rate: 0.0119\n", "\n", "Epoch 54: LearningRateScheduler setting learning rate to 0.011668713500742417.\n", "Epoch 54/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 63ms/step - head_1_accuracy: 0.9998 - head_1_loss: 0.0018 - head_2_accuracy: 0.9995 - head_2_loss: 0.0021 - head_3_accuracy: 0.9995 - head_3_loss: 0.0023 - head_4_accuracy: 0.9996 - head_4_loss: 0.0020 - head_5_accuracy: 0.9996 - head_5_loss: 0.0017 - head_6_accuracy: 0.9996 - head_6_loss: 0.0022 - head_7_accuracy: 0.9996 - head_7_loss: 0.0017 - loss: 0.0139\n", "Epoch 54: val_head_1_accuracy did not improve from 0.99536\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 72ms/step - head_1_accuracy: 0.9998 - head_1_loss: 0.0014 - head_2_accuracy: 0.9997 - head_2_loss: 0.0016 - head_3_accuracy: 0.9997 - head_3_loss: 0.0017 - head_4_accuracy: 0.9996 - head_4_loss: 0.0016 - head_5_accuracy: 0.9998 - head_5_loss: 0.0014 - head_6_accuracy: 0.9996 - head_6_loss: 0.0017 - head_7_accuracy: 0.9998 - head_7_loss: 0.0013 - loss: 0.0108 - val_head_1_accuracy: 0.9940 - val_head_1_loss: 0.0210 - val_head_2_accuracy: 0.9944 - val_head_2_loss: 0.0202 - val_head_3_accuracy: 0.9942 - val_head_3_loss: 0.0215 - val_head_4_accuracy: 0.9940 - val_head_4_loss: 0.0218 - val_head_5_accuracy: 0.9940 - val_head_5_loss: 0.0204 - val_head_6_accuracy: 0.9940 - val_head_6_loss: 0.0219 - val_head_7_accuracy: 0.9947 - val_head_7_loss: 0.0210 - val_loss: 0.1470 - learning_rate: 0.0117\n", "\n", "Epoch 55: LearningRateScheduler setting learning rate to 0.011432638712950362.\n", "Epoch 55/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 62ms/step - head_1_accuracy: 0.9998 - head_1_loss: 9.1612e-04 - head_2_accuracy: 0.9997 - head_2_loss: 0.0011 - head_3_accuracy: 0.9998 - head_3_loss: 7.8156e-04 - head_4_accuracy: 0.9998 - head_4_loss: 0.0010 - head_5_accuracy: 0.9997 - head_5_loss: 9.6021e-04 - head_6_accuracy: 0.9998 - head_6_loss: 8.9806e-04 - head_7_accuracy: 1.0000 - head_7_loss: 7.9268e-04 - loss: 0.0065\n", "Epoch 55: val_head_1_accuracy did not improve from 0.99536\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 72ms/step - head_1_accuracy: 0.9999 - head_1_loss: 6.3985e-04 - head_2_accuracy: 0.9998 - head_2_loss: 8.3355e-04 - head_3_accuracy: 0.9999 - head_3_loss: 6.4594e-04 - head_4_accuracy: 0.9999 - head_4_loss: 7.0961e-04 - head_5_accuracy: 0.9998 - head_5_loss: 8.9425e-04 - head_6_accuracy: 0.9999 - head_6_loss: 6.8247e-04 - head_7_accuracy: 0.9999 - head_7_loss: 6.9060e-04 - loss: 0.0051 - val_head_1_accuracy: 0.9951 - val_head_1_loss: 0.0195 - val_head_2_accuracy: 0.9954 - val_head_2_loss: 0.0189 - val_head_3_accuracy: 0.9956 - val_head_3_loss: 0.0197 - val_head_4_accuracy: 0.9951 - val_head_4_loss: 0.0202 - val_head_5_accuracy: 0.9954 - val_head_5_loss: 0.0195 - val_head_6_accuracy: 0.9951 - val_head_6_loss: 0.0207 - val_head_7_accuracy: 0.9954 - val_head_7_loss: 0.0196 - val_loss: 0.1376 - learning_rate: 0.0114\n", "\n", "Epoch 56: LearningRateScheduler setting learning rate to 0.011197638667498021.\n", "Epoch 56/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 64ms/step - head_1_accuracy: 1.0000 - head_1_loss: 4.3674e-04 - head_2_accuracy: 1.0000 - head_2_loss: 4.5424e-04 - head_3_accuracy: 1.0000 - head_3_loss: 4.4237e-04 - head_4_accuracy: 1.0000 - head_4_loss: 4.3464e-04 - head_5_accuracy: 1.0000 - head_5_loss: 5.3497e-04 - head_6_accuracy: 1.0000 - head_6_loss: 4.5827e-04 - head_7_accuracy: 1.0000 - head_7_loss: 3.9817e-04 - loss: 0.0032\n", "Epoch 56: val_head_1_accuracy did not improve from 0.99536\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 73ms/step - head_1_accuracy: 1.0000 - head_1_loss: 4.6200e-04 - head_2_accuracy: 1.0000 - head_2_loss: 4.5225e-04 - head_3_accuracy: 1.0000 - head_3_loss: 4.4471e-04 - head_4_accuracy: 1.0000 - head_4_loss: 4.2684e-04 - head_5_accuracy: 1.0000 - head_5_loss: 4.8661e-04 - head_6_accuracy: 1.0000 - head_6_loss: 4.3523e-04 - head_7_accuracy: 1.0000 - head_7_loss: 4.0519e-04 - loss: 0.0031 - val_head_1_accuracy: 0.9947 - val_head_1_loss: 0.0199 - val_head_2_accuracy: 0.9949 - val_head_2_loss: 0.0190 - val_head_3_accuracy: 0.9951 - val_head_3_loss: 0.0204 - val_head_4_accuracy: 0.9944 - val_head_4_loss: 0.0208 - val_head_5_accuracy: 0.9947 - val_head_5_loss: 0.0196 - val_head_6_accuracy: 0.9949 - val_head_6_loss: 0.0209 - val_head_7_accuracy: 0.9944 - val_head_7_loss: 0.0202 - val_loss: 0.1413 - learning_rate: 0.0112\n", "\n", "Epoch 57: LearningRateScheduler setting learning rate to 0.010963949989511071.\n", "Epoch 57/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 61ms/step - head_1_accuracy: 1.0000 - head_1_loss: 3.6379e-04 - head_2_accuracy: 1.0000 - head_2_loss: 3.7303e-04 - head_3_accuracy: 1.0000 - head_3_loss: 3.6265e-04 - head_4_accuracy: 1.0000 - head_4_loss: 3.6613e-04 - head_5_accuracy: 1.0000 - head_5_loss: 4.1454e-04 - head_6_accuracy: 1.0000 - head_6_loss: 3.4505e-04 - head_7_accuracy: 1.0000 - head_7_loss: 3.0258e-04 - loss: 0.0025\n", "Epoch 57: val_head_1_accuracy did not improve from 0.99536\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 71ms/step - head_1_accuracy: 1.0000 - head_1_loss: 3.4873e-04 - head_2_accuracy: 1.0000 - head_2_loss: 3.4003e-04 - head_3_accuracy: 1.0000 - head_3_loss: 3.4012e-04 - head_4_accuracy: 1.0000 - head_4_loss: 3.3050e-04 - head_5_accuracy: 1.0000 - head_5_loss: 3.7292e-04 - head_6_accuracy: 0.9999 - head_6_loss: 3.8611e-04 - head_7_accuracy: 1.0000 - head_7_loss: 2.9755e-04 - loss: 0.0024 - val_head_1_accuracy: 0.9954 - val_head_1_loss: 0.0196 - val_head_2_accuracy: 0.9958 - val_head_2_loss: 0.0187 - val_head_3_accuracy: 0.9954 - val_head_3_loss: 0.0199 - val_head_4_accuracy: 0.9951 - val_head_4_loss: 0.0201 - val_head_5_accuracy: 0.9954 - val_head_5_loss: 0.0193 - val_head_6_accuracy: 0.9954 - val_head_6_loss: 0.0205 - val_head_7_accuracy: 0.9954 - val_head_7_loss: 0.0197 - val_loss: 0.1385 - learning_rate: 0.0110\n", "\n", "Epoch 58: LearningRateScheduler setting learning rate to 0.010731807983679297.\n", "Epoch 58/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 64ms/step - head_1_accuracy: 1.0000 - head_1_loss: 2.8327e-04 - head_2_accuracy: 1.0000 - head_2_loss: 3.2807e-04 - head_3_accuracy: 1.0000 - head_3_loss: 2.7269e-04 - head_4_accuracy: 1.0000 - head_4_loss: 3.3094e-04 - head_5_accuracy: 1.0000 - head_5_loss: 3.3403e-04 - head_6_accuracy: 1.0000 - head_6_loss: 2.6893e-04 - head_7_accuracy: 1.0000 - head_7_loss: 2.8600e-04 - loss: 0.0021\n", "Epoch 58: val_head_1_accuracy did not improve from 0.99536\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 73ms/step - head_1_accuracy: 1.0000 - head_1_loss: 3.2479e-04 - head_2_accuracy: 1.0000 - head_2_loss: 3.7763e-04 - head_3_accuracy: 1.0000 - head_3_loss: 3.2434e-04 - head_4_accuracy: 0.9999 - head_4_loss: 3.9203e-04 - head_5_accuracy: 0.9999 - head_5_loss: 4.0739e-04 - head_6_accuracy: 1.0000 - head_6_loss: 3.1060e-04 - head_7_accuracy: 0.9999 - head_7_loss: 3.4872e-04 - loss: 0.0025 - val_head_1_accuracy: 0.9951 - val_head_1_loss: 0.0196 - val_head_2_accuracy: 0.9956 - val_head_2_loss: 0.0188 - val_head_3_accuracy: 0.9954 - val_head_3_loss: 0.0199 - val_head_4_accuracy: 0.9949 - val_head_4_loss: 0.0198 - val_head_5_accuracy: 0.9956 - val_head_5_loss: 0.0195 - val_head_6_accuracy: 0.9951 - val_head_6_loss: 0.0203 - val_head_7_accuracy: 0.9956 - val_head_7_loss: 0.0201 - val_loss: 0.1383 - learning_rate: 0.0107\n", "\n", "Epoch 59: LearningRateScheduler setting learning rate to 0.010501446397324737.\n", "Epoch 59/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 61ms/step - head_1_accuracy: 1.0000 - head_1_loss: 2.1517e-04 - head_2_accuracy: 1.0000 - head_2_loss: 2.7361e-04 - head_3_accuracy: 1.0000 - head_3_loss: 1.9445e-04 - head_4_accuracy: 1.0000 - head_4_loss: 2.2528e-04 - head_5_accuracy: 1.0000 - head_5_loss: 2.0312e-04 - head_6_accuracy: 1.0000 - head_6_loss: 2.2494e-04 - head_7_accuracy: 1.0000 - head_7_loss: 1.6408e-04 - loss: 0.0015\n", "Epoch 59: val_head_1_accuracy did not improve from 0.99536\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 70ms/step - head_1_accuracy: 1.0000 - head_1_loss: 2.1378e-04 - head_2_accuracy: 0.9999 - head_2_loss: 3.7476e-04 - head_3_accuracy: 1.0000 - head_3_loss: 1.9658e-04 - head_4_accuracy: 0.9999 - head_4_loss: 2.7150e-04 - head_5_accuracy: 1.0000 - head_5_loss: 2.1182e-04 - head_6_accuracy: 1.0000 - head_6_loss: 2.3823e-04 - head_7_accuracy: 1.0000 - head_7_loss: 1.7976e-04 - loss: 0.0017 - val_head_1_accuracy: 0.9947 - val_head_1_loss: 0.0207 - val_head_2_accuracy: 0.9951 - val_head_2_loss: 0.0196 - val_head_3_accuracy: 0.9951 - val_head_3_loss: 0.0205 - val_head_4_accuracy: 0.9949 - val_head_4_loss: 0.0204 - val_head_5_accuracy: 0.9947 - val_head_5_loss: 0.0206 - val_head_6_accuracy: 0.9949 - val_head_6_loss: 0.0212 - val_head_7_accuracy: 0.9947 - val_head_7_loss: 0.0211 - val_loss: 0.1447 - learning_rate: 0.0105\n", "\n", "Epoch 60: LearningRateScheduler setting learning rate to 0.010273097185037938.\n", "Epoch 60/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 63ms/step - head_1_accuracy: 1.0000 - head_1_loss: 2.8678e-04 - head_2_accuracy: 1.0000 - head_2_loss: 3.2578e-04 - head_3_accuracy: 1.0000 - head_3_loss: 2.9145e-04 - head_4_accuracy: 1.0000 - head_4_loss: 2.4544e-04 - head_5_accuracy: 1.0000 - head_5_loss: 3.1815e-04 - head_6_accuracy: 1.0000 - head_6_loss: 2.4788e-04 - head_7_accuracy: 1.0000 - head_7_loss: 2.3804e-04 - loss: 0.0020\n", "Epoch 60: val_head_1_accuracy did not improve from 0.99536\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 72ms/step - head_1_accuracy: 1.0000 - head_1_loss: 2.4232e-04 - head_2_accuracy: 1.0000 - head_2_loss: 2.9060e-04 - head_3_accuracy: 1.0000 - head_3_loss: 2.5905e-04 - head_4_accuracy: 1.0000 - head_4_loss: 2.5168e-04 - head_5_accuracy: 1.0000 - head_5_loss: 2.9034e-04 - head_6_accuracy: 1.0000 - head_6_loss: 2.4071e-04 - head_7_accuracy: 1.0000 - head_7_loss: 2.1917e-04 - loss: 0.0018 - val_head_1_accuracy: 0.9944 - val_head_1_loss: 0.0203 - val_head_2_accuracy: 0.9947 - val_head_2_loss: 0.0193 - val_head_3_accuracy: 0.9951 - val_head_3_loss: 0.0200 - val_head_4_accuracy: 0.9947 - val_head_4_loss: 0.0199 - val_head_5_accuracy: 0.9947 - val_head_5_loss: 0.0204 - val_head_6_accuracy: 0.9947 - val_head_6_loss: 0.0208 - val_head_7_accuracy: 0.9944 - val_head_7_loss: 0.0209 - val_loss: 0.1418 - learning_rate: 0.0103\n", "\n", "Epoch 61: LearningRateScheduler setting learning rate to 0.01004699027511934.\n", "Epoch 61/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 61ms/step - head_1_accuracy: 1.0000 - head_1_loss: 2.0026e-04 - head_2_accuracy: 1.0000 - head_2_loss: 2.4540e-04 - head_3_accuracy: 1.0000 - head_3_loss: 2.2249e-04 - head_4_accuracy: 1.0000 - head_4_loss: 2.2922e-04 - head_5_accuracy: 1.0000 - head_5_loss: 2.4587e-04 - head_6_accuracy: 1.0000 - head_6_loss: 1.9057e-04 - head_7_accuracy: 1.0000 - head_7_loss: 2.0480e-04 - loss: 0.0015\n", "Epoch 61: val_head_1_accuracy did not improve from 0.99536\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 70ms/step - head_1_accuracy: 1.0000 - head_1_loss: 2.3543e-04 - head_2_accuracy: 1.0000 - head_2_loss: 2.7960e-04 - head_3_accuracy: 1.0000 - head_3_loss: 2.5240e-04 - head_4_accuracy: 1.0000 - head_4_loss: 2.5911e-04 - head_5_accuracy: 1.0000 - head_5_loss: 2.4864e-04 - head_6_accuracy: 1.0000 - head_6_loss: 1.9740e-04 - head_7_accuracy: 1.0000 - head_7_loss: 2.1412e-04 - loss: 0.0017 - val_head_1_accuracy: 0.9947 - val_head_1_loss: 0.0203 - val_head_2_accuracy: 0.9947 - val_head_2_loss: 0.0195 - val_head_3_accuracy: 0.9951 - val_head_3_loss: 0.0202 - val_head_4_accuracy: 0.9947 - val_head_4_loss: 0.0200 - val_head_5_accuracy: 0.9947 - val_head_5_loss: 0.0204 - val_head_6_accuracy: 0.9944 - val_head_6_loss: 0.0210 - val_head_7_accuracy: 0.9949 - val_head_7_loss: 0.0211 - val_loss: 0.1425 - learning_rate: 0.0100\n", "\n", "Epoch 62: LearningRateScheduler setting learning rate to 0.009823353338060961.\n", "Epoch 62/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 63ms/step - head_1_accuracy: 0.9999 - head_1_loss: 3.0861e-04 - head_2_accuracy: 0.9999 - head_2_loss: 3.8174e-04 - head_3_accuracy: 1.0000 - head_3_loss: 3.6071e-04 - head_4_accuracy: 0.9999 - head_4_loss: 4.3449e-04 - head_5_accuracy: 1.0000 - head_5_loss: 2.7131e-04 - head_6_accuracy: 1.0000 - head_6_loss: 2.6318e-04 - head_7_accuracy: 1.0000 - head_7_loss: 2.7868e-04 - loss: 0.0023\n", "Epoch 62: val_head_1_accuracy did not improve from 0.99536\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 72ms/step - head_1_accuracy: 0.9999 - head_1_loss: 3.1515e-04 - head_2_accuracy: 0.9999 - head_2_loss: 4.0879e-04 - head_3_accuracy: 0.9999 - head_3_loss: 3.9514e-04 - head_4_accuracy: 0.9999 - head_4_loss: 4.1357e-04 - head_5_accuracy: 1.0000 - head_5_loss: 2.8207e-04 - head_6_accuracy: 1.0000 - head_6_loss: 2.7349e-04 - head_7_accuracy: 1.0000 - head_7_loss: 2.7174e-04 - loss: 0.0024 - val_head_1_accuracy: 0.9947 - val_head_1_loss: 0.0204 - val_head_2_accuracy: 0.9949 - val_head_2_loss: 0.0194 - val_head_3_accuracy: 0.9951 - val_head_3_loss: 0.0201 - val_head_4_accuracy: 0.9947 - val_head_4_loss: 0.0204 - val_head_5_accuracy: 0.9951 - val_head_5_loss: 0.0205 - val_head_6_accuracy: 0.9949 - val_head_6_loss: 0.0209 - val_head_7_accuracy: 0.9951 - val_head_7_loss: 0.0203 - val_loss: 0.1425 - learning_rate: 0.0098\n", "\n", "Epoch 63: LearningRateScheduler setting learning rate to 0.009602411557301536.\n", "Epoch 63/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 61ms/step - head_1_accuracy: 1.0000 - head_1_loss: 2.4830e-04 - head_2_accuracy: 1.0000 - head_2_loss: 3.4221e-04 - head_3_accuracy: 1.0000 - head_3_loss: 2.9895e-04 - head_4_accuracy: 1.0000 - head_4_loss: 2.9324e-04 - head_5_accuracy: 1.0000 - head_5_loss: 3.3008e-04 - head_6_accuracy: 1.0000 - head_6_loss: 2.8435e-04 - head_7_accuracy: 1.0000 - head_7_loss: 2.4360e-04 - loss: 0.0020\n", "Epoch 63: val_head_1_accuracy did not improve from 0.99536\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 70ms/step - head_1_accuracy: 1.0000 - head_1_loss: 2.4420e-04 - head_2_accuracy: 1.0000 - head_2_loss: 3.1740e-04 - head_3_accuracy: 1.0000 - head_3_loss: 2.7681e-04 - head_4_accuracy: 1.0000 - head_4_loss: 2.9362e-04 - head_5_accuracy: 1.0000 - head_5_loss: 3.1720e-04 - head_6_accuracy: 1.0000 - head_6_loss: 2.9470e-04 - head_7_accuracy: 1.0000 - head_7_loss: 2.6860e-04 - loss: 0.0020 - val_head_1_accuracy: 0.9951 - val_head_1_loss: 0.0200 - val_head_2_accuracy: 0.9951 - val_head_2_loss: 0.0190 - val_head_3_accuracy: 0.9951 - val_head_3_loss: 0.0199 - val_head_4_accuracy: 0.9949 - val_head_4_loss: 0.0200 - val_head_5_accuracy: 0.9951 - val_head_5_loss: 0.0202 - val_head_6_accuracy: 0.9951 - val_head_6_loss: 0.0207 - val_head_7_accuracy: 0.9949 - val_head_7_loss: 0.0203 - val_loss: 0.1407 - learning_rate: 0.0096\n", "\n", "Epoch 64: LearningRateScheduler setting learning rate to 0.009384387402485851.\n", "Epoch 64/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 63ms/step - head_1_accuracy: 1.0000 - head_1_loss: 2.4370e-04 - head_2_accuracy: 1.0000 - head_2_loss: 2.8965e-04 - head_3_accuracy: 1.0000 - head_3_loss: 4.5087e-04 - head_4_accuracy: 1.0000 - head_4_loss: 2.7561e-04 - head_5_accuracy: 1.0000 - head_5_loss: 3.2304e-04 - head_6_accuracy: 1.0000 - head_6_loss: 2.2459e-04 - head_7_accuracy: 1.0000 - head_7_loss: 2.5654e-04 - loss: 0.0021\n", "Epoch 64: val_head_1_accuracy did not improve from 0.99536\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 72ms/step - head_1_accuracy: 1.0000 - head_1_loss: 2.6644e-04 - head_2_accuracy: 1.0000 - head_2_loss: 2.8171e-04 - head_3_accuracy: 0.9999 - head_3_loss: 6.2220e-04 - head_4_accuracy: 1.0000 - head_4_loss: 2.8312e-04 - head_5_accuracy: 1.0000 - head_5_loss: 3.3432e-04 - head_6_accuracy: 1.0000 - head_6_loss: 2.7417e-04 - head_7_accuracy: 1.0000 - head_7_loss: 2.8573e-04 - loss: 0.0024 - val_head_1_accuracy: 0.9947 - val_head_1_loss: 0.0205 - val_head_2_accuracy: 0.9951 - val_head_2_loss: 0.0198 - val_head_3_accuracy: 0.9951 - val_head_3_loss: 0.0213 - val_head_4_accuracy: 0.9944 - val_head_4_loss: 0.0204 - val_head_5_accuracy: 0.9949 - val_head_5_loss: 0.0206 - val_head_6_accuracy: 0.9944 - val_head_6_loss: 0.0218 - val_head_7_accuracy: 0.9947 - val_head_7_loss: 0.0225 - val_loss: 0.1460 - learning_rate: 0.0094\n", "\n", "Epoch 65: LearningRateScheduler setting learning rate to 0.009169500405456693.\n", "Epoch 65/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 61ms/step - head_1_accuracy: 0.9999 - head_1_loss: 6.1906e-04 - head_2_accuracy: 0.9999 - head_2_loss: 5.7374e-04 - head_3_accuracy: 0.9999 - head_3_loss: 4.3503e-04 - head_4_accuracy: 0.9999 - head_4_loss: 5.0394e-04 - head_5_accuracy: 0.9999 - head_5_loss: 5.0221e-04 - head_6_accuracy: 0.9999 - head_6_loss: 7.4597e-04 - head_7_accuracy: 0.9999 - head_7_loss: 3.8848e-04 - loss: 0.0038\n", "Epoch 65: val_head_1_accuracy did not improve from 0.99536\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 70ms/step - head_1_accuracy: 0.9998 - head_1_loss: 0.0011 - head_2_accuracy: 0.9998 - head_2_loss: 9.2492e-04 - head_3_accuracy: 0.9998 - head_3_loss: 6.5228e-04 - head_4_accuracy: 0.9998 - head_4_loss: 7.7168e-04 - head_5_accuracy: 0.9998 - head_5_loss: 7.8151e-04 - head_6_accuracy: 0.9998 - head_6_loss: 0.0013 - head_7_accuracy: 0.9998 - head_7_loss: 5.7813e-04 - loss: 0.0061 - val_head_1_accuracy: 0.9954 - val_head_1_loss: 0.0203 - val_head_2_accuracy: 0.9956 - val_head_2_loss: 0.0190 - val_head_3_accuracy: 0.9954 - val_head_3_loss: 0.0201 - val_head_4_accuracy: 0.9951 - val_head_4_loss: 0.0204 - val_head_5_accuracy: 0.9956 - val_head_5_loss: 0.0199 - val_head_6_accuracy: 0.9949 - val_head_6_loss: 0.0209 - val_head_7_accuracy: 0.9954 - val_head_7_loss: 0.0199 - val_loss: 0.1412 - learning_rate: 0.0092\n", "\n", "Epoch 66: LearningRateScheduler setting learning rate to 0.008957966939204882.\n", "Epoch 66/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 63ms/step - head_1_accuracy: 0.9999 - head_1_loss: 5.8736e-04 - head_2_accuracy: 0.9999 - head_2_loss: 5.4817e-04 - head_3_accuracy: 0.9999 - head_3_loss: 5.2671e-04 - head_4_accuracy: 0.9999 - head_4_loss: 6.1780e-04 - head_5_accuracy: 0.9999 - head_5_loss: 5.8053e-04 - head_6_accuracy: 0.9999 - head_6_loss: 5.6681e-04 - head_7_accuracy: 0.9999 - head_7_loss: 5.5946e-04 - loss: 0.0040\n", "Epoch 66: val_head_1_accuracy did not improve from 0.99536\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 73ms/step - head_1_accuracy: 0.9996 - head_1_loss: 0.0011 - head_2_accuracy: 0.9997 - head_2_loss: 9.4259e-04 - head_3_accuracy: 0.9998 - head_3_loss: 8.3638e-04 - head_4_accuracy: 0.9997 - head_4_loss: 8.8896e-04 - head_5_accuracy: 0.9997 - head_5_loss: 0.0010 - head_6_accuracy: 0.9997 - head_6_loss: 9.4549e-04 - head_7_accuracy: 0.9998 - head_7_loss: 8.9763e-04 - loss: 0.0067 - val_head_1_accuracy: 0.9951 - val_head_1_loss: 0.0206 - val_head_2_accuracy: 0.9956 - val_head_2_loss: 0.0193 - val_head_3_accuracy: 0.9954 - val_head_3_loss: 0.0202 - val_head_4_accuracy: 0.9951 - val_head_4_loss: 0.0207 - val_head_5_accuracy: 0.9949 - val_head_5_loss: 0.0203 - val_head_6_accuracy: 0.9951 - val_head_6_loss: 0.0212 - val_head_7_accuracy: 0.9954 - val_head_7_loss: 0.0204 - val_loss: 0.1436 - learning_rate: 0.0090\n", "\n", "Epoch 67: LearningRateScheduler setting learning rate to 0.00875.\n", "Epoch 67/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 61ms/step - head_1_accuracy: 1.0000 - head_1_loss: 3.7780e-04 - head_2_accuracy: 1.0000 - head_2_loss: 3.2829e-04 - head_3_accuracy: 1.0000 - head_3_loss: 3.4581e-04 - head_4_accuracy: 1.0000 - head_4_loss: 3.7431e-04 - head_5_accuracy: 1.0000 - head_5_loss: 3.9126e-04 - head_6_accuracy: 1.0000 - head_6_loss: 2.8666e-04 - head_7_accuracy: 1.0000 - head_7_loss: 3.3833e-04 - loss: 0.0024\n", "Epoch 67: val_head_1_accuracy did not improve from 0.99536\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 70ms/step - head_1_accuracy: 0.9998 - head_1_loss: 9.7231e-04 - head_2_accuracy: 0.9998 - head_2_loss: 0.0010 - head_3_accuracy: 0.9998 - head_3_loss: 8.6263e-04 - head_4_accuracy: 0.9998 - head_4_loss: 8.4416e-04 - head_5_accuracy: 0.9998 - head_5_loss: 8.4242e-04 - head_6_accuracy: 0.9998 - head_6_loss: 8.7171e-04 - head_7_accuracy: 0.9998 - head_7_loss: 8.3502e-04 - loss: 0.0063 - val_head_1_accuracy: 0.9949 - val_head_1_loss: 0.0199 - val_head_2_accuracy: 0.9949 - val_head_2_loss: 0.0186 - val_head_3_accuracy: 0.9949 - val_head_3_loss: 0.0195 - val_head_4_accuracy: 0.9954 - val_head_4_loss: 0.0192 - val_head_5_accuracy: 0.9947 - val_head_5_loss: 0.0198 - val_head_6_accuracy: 0.9951 - val_head_6_loss: 0.0207 - val_head_7_accuracy: 0.9944 - val_head_7_loss: 0.0206 - val_loss: 0.1384 - learning_rate: 0.0088\n", "\n", "Epoch 68: LearningRateScheduler setting learning rate to 0.008545808992921232.\n", "Epoch 68/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 63ms/step - head_1_accuracy: 0.9998 - head_1_loss: 3.6578e-04 - head_2_accuracy: 0.9998 - head_2_loss: 6.0775e-04 - head_3_accuracy: 0.9998 - head_3_loss: 3.3579e-04 - head_4_accuracy: 0.9998 - head_4_loss: 3.6366e-04 - head_5_accuracy: 1.0000 - head_5_loss: 3.5870e-04 - head_6_accuracy: 0.9998 - head_6_loss: 4.1927e-04 - head_7_accuracy: 1.0000 - head_7_loss: 3.0074e-04 - loss: 0.0028\n", "Epoch 68: val_head_1_accuracy did not improve from 0.99536\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 73ms/step - head_1_accuracy: 0.9999 - head_1_loss: 2.7666e-04 - head_2_accuracy: 0.9999 - head_2_loss: 4.3306e-04 - head_3_accuracy: 0.9999 - head_3_loss: 2.7996e-04 - head_4_accuracy: 0.9999 - head_4_loss: 2.9928e-04 - head_5_accuracy: 1.0000 - head_5_loss: 3.2688e-04 - head_6_accuracy: 0.9999 - head_6_loss: 3.0797e-04 - head_7_accuracy: 1.0000 - head_7_loss: 2.9780e-04 - loss: 0.0022 - val_head_1_accuracy: 0.9951 - val_head_1_loss: 0.0199 - val_head_2_accuracy: 0.9954 - val_head_2_loss: 0.0187 - val_head_3_accuracy: 0.9951 - val_head_3_loss: 0.0195 - val_head_4_accuracy: 0.9951 - val_head_4_loss: 0.0194 - val_head_5_accuracy: 0.9949 - val_head_5_loss: 0.0198 - val_head_6_accuracy: 0.9951 - val_head_6_loss: 0.0206 - val_head_7_accuracy: 0.9951 - val_head_7_loss: 0.0202 - val_loss: 0.1387 - learning_rate: 0.0085\n", "\n", "Epoch 69: LearningRateScheduler setting learning rate to 0.008345599521004173.\n", "Epoch 69/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 61ms/step - head_1_accuracy: 1.0000 - head_1_loss: 2.7142e-04 - head_2_accuracy: 1.0000 - head_2_loss: 3.3134e-04 - head_3_accuracy: 1.0000 - head_3_loss: 2.7575e-04 - head_4_accuracy: 1.0000 - head_4_loss: 2.6323e-04 - head_5_accuracy: 1.0000 - head_5_loss: 3.5296e-04 - head_6_accuracy: 1.0000 - head_6_loss: 2.5686e-04 - head_7_accuracy: 1.0000 - head_7_loss: 2.3822e-04 - loss: 0.0020\n", "Epoch 69: val_head_1_accuracy did not improve from 0.99536\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 70ms/step - head_1_accuracy: 1.0000 - head_1_loss: 2.5917e-04 - head_2_accuracy: 1.0000 - head_2_loss: 2.9097e-04 - head_3_accuracy: 1.0000 - head_3_loss: 2.7093e-04 - head_4_accuracy: 0.9999 - head_4_loss: 2.8957e-04 - head_5_accuracy: 1.0000 - head_5_loss: 3.2787e-04 - head_6_accuracy: 1.0000 - head_6_loss: 2.5472e-04 - head_7_accuracy: 0.9999 - head_7_loss: 2.5637e-04 - loss: 0.0020 - val_head_1_accuracy: 0.9954 - val_head_1_loss: 0.0190 - val_head_2_accuracy: 0.9954 - val_head_2_loss: 0.0179 - val_head_3_accuracy: 0.9954 - val_head_3_loss: 0.0187 - val_head_4_accuracy: 0.9951 - val_head_4_loss: 0.0186 - val_head_5_accuracy: 0.9949 - val_head_5_loss: 0.0190 - val_head_6_accuracy: 0.9949 - val_head_6_loss: 0.0195 - val_head_7_accuracy: 0.9949 - val_head_7_loss: 0.0193 - val_loss: 0.1329 - learning_rate: 0.0083\n", "\n", "Epoch 70: LearningRateScheduler setting learning rate to 0.008149573178216015.\n", "Epoch 70/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 63ms/step - head_1_accuracy: 1.0000 - head_1_loss: 3.3652e-04 - head_2_accuracy: 1.0000 - head_2_loss: 3.6608e-04 - head_3_accuracy: 1.0000 - head_3_loss: 3.1089e-04 - head_4_accuracy: 1.0000 - head_4_loss: 3.5687e-04 - head_5_accuracy: 1.0000 - head_5_loss: 3.1738e-04 - head_6_accuracy: 1.0000 - head_6_loss: 3.1660e-04 - head_7_accuracy: 1.0000 - head_7_loss: 2.5050e-04 - loss: 0.0023\n", "Epoch 70: val_head_1_accuracy improved from 0.99536 to 0.99559, saving model to /content/drive/My Drive/Classification/multicp/models/AlexNet_CNN_MultiHead_best.keras\n", "\n", "Epoch 70: finished saving model to /content/drive/My Drive/Classification/multicp/models/AlexNet_CNN_MultiHead_best.keras\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m9s\u001b[0m 88ms/step - head_1_accuracy: 0.9999 - head_1_loss: 4.4336e-04 - head_2_accuracy: 0.9999 - head_2_loss: 4.6836e-04 - head_3_accuracy: 0.9998 - head_3_loss: 4.8692e-04 - head_4_accuracy: 0.9999 - head_4_loss: 4.2506e-04 - head_5_accuracy: 0.9999 - head_5_loss: 4.0089e-04 - head_6_accuracy: 0.9999 - head_6_loss: 4.3584e-04 - head_7_accuracy: 0.9998 - head_7_loss: 4.1299e-04 - loss: 0.0031 - val_head_1_accuracy: 0.9956 - val_head_1_loss: 0.0201 - val_head_2_accuracy: 0.9961 - val_head_2_loss: 0.0189 - val_head_3_accuracy: 0.9954 - val_head_3_loss: 0.0196 - val_head_4_accuracy: 0.9954 - val_head_4_loss: 0.0198 - val_head_5_accuracy: 0.9954 - val_head_5_loss: 0.0199 - val_head_6_accuracy: 0.9956 - val_head_6_loss: 0.0207 - val_head_7_accuracy: 0.9956 - val_head_7_loss: 0.0197 - val_loss: 0.1388 - learning_rate: 0.0081\n", "\n", "Epoch 71: LearningRateScheduler setting learning rate to 0.0079579273464675.\n", "Epoch 71/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 61ms/step - head_1_accuracy: 1.0000 - head_1_loss: 2.9223e-04 - head_2_accuracy: 1.0000 - head_2_loss: 2.9116e-04 - head_3_accuracy: 1.0000 - head_3_loss: 4.4627e-04 - head_4_accuracy: 1.0000 - head_4_loss: 3.3195e-04 - head_5_accuracy: 0.9999 - head_5_loss: 4.6588e-04 - head_6_accuracy: 1.0000 - head_6_loss: 3.7133e-04 - head_7_accuracy: 1.0000 - head_7_loss: 3.4378e-04 - loss: 0.0025\n", "Epoch 71: val_head_1_accuracy did not improve from 0.99559\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 70ms/step - head_1_accuracy: 1.0000 - head_1_loss: 2.7941e-04 - head_2_accuracy: 1.0000 - head_2_loss: 3.0150e-04 - head_3_accuracy: 1.0000 - head_3_loss: 3.2472e-04 - head_4_accuracy: 1.0000 - head_4_loss: 2.9365e-04 - head_5_accuracy: 0.9999 - head_5_loss: 3.7220e-04 - head_6_accuracy: 0.9999 - head_6_loss: 3.4336e-04 - head_7_accuracy: 1.0000 - head_7_loss: 2.8748e-04 - loss: 0.0022 - val_head_1_accuracy: 0.9951 - val_head_1_loss: 0.0189 - val_head_2_accuracy: 0.9954 - val_head_2_loss: 0.0178 - val_head_3_accuracy: 0.9954 - val_head_3_loss: 0.0187 - val_head_4_accuracy: 0.9949 - val_head_4_loss: 0.0188 - val_head_5_accuracy: 0.9949 - val_head_5_loss: 0.0184 - val_head_6_accuracy: 0.9951 - val_head_6_loss: 0.0196 - val_head_7_accuracy: 0.9954 - val_head_7_loss: 0.0186 - val_loss: 0.1316 - learning_rate: 0.0080\n", "\n", "Epoch 72: LearningRateScheduler setting learning rate to 0.007770854996866082.\n", "Epoch 72/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 67ms/step - head_1_accuracy: 1.0000 - head_1_loss: 1.8953e-04 - head_2_accuracy: 1.0000 - head_2_loss: 2.7125e-04 - head_3_accuracy: 1.0000 - head_3_loss: 2.7889e-04 - head_4_accuracy: 1.0000 - head_4_loss: 2.4398e-04 - head_5_accuracy: 1.0000 - head_5_loss: 2.2580e-04 - head_6_accuracy: 1.0000 - head_6_loss: 2.3994e-04 - head_7_accuracy: 1.0000 - head_7_loss: 2.0752e-04 - loss: 0.0017\n", "Epoch 72: val_head_1_accuracy did not improve from 0.99559\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m8s\u001b[0m 82ms/step - head_1_accuracy: 1.0000 - head_1_loss: 1.9736e-04 - head_2_accuracy: 1.0000 - head_2_loss: 2.6530e-04 - head_3_accuracy: 1.0000 - head_3_loss: 2.5340e-04 - head_4_accuracy: 1.0000 - head_4_loss: 2.1922e-04 - head_5_accuracy: 1.0000 - head_5_loss: 2.2122e-04 - head_6_accuracy: 1.0000 - head_6_loss: 1.9715e-04 - head_7_accuracy: 1.0000 - head_7_loss: 1.9496e-04 - loss: 0.0016 - val_head_1_accuracy: 0.9951 - val_head_1_loss: 0.0190 - val_head_2_accuracy: 0.9956 - val_head_2_loss: 0.0179 - val_head_3_accuracy: 0.9951 - val_head_3_loss: 0.0187 - val_head_4_accuracy: 0.9954 - val_head_4_loss: 0.0186 - val_head_5_accuracy: 0.9949 - val_head_5_loss: 0.0187 - val_head_6_accuracy: 0.9954 - val_head_6_loss: 0.0197 - val_head_7_accuracy: 0.9956 - val_head_7_loss: 0.0190 - val_loss: 0.1319 - learning_rate: 0.0078\n", "\n", "Epoch 73: LearningRateScheduler setting learning rate to 0.007588544495410363.\n", "Epoch 73/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 67ms/step - head_1_accuracy: 1.0000 - head_1_loss: 2.2453e-04 - head_2_accuracy: 0.9999 - head_2_loss: 3.5094e-04 - head_3_accuracy: 1.0000 - head_3_loss: 2.8051e-04 - head_4_accuracy: 1.0000 - head_4_loss: 2.6876e-04 - head_5_accuracy: 1.0000 - head_5_loss: 4.2241e-04 - head_6_accuracy: 1.0000 - head_6_loss: 2.3701e-04 - head_7_accuracy: 0.9999 - head_7_loss: 4.5341e-04 - loss: 0.0022\n", "Epoch 73: val_head_1_accuracy did not improve from 0.99559\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m8s\u001b[0m 77ms/step - head_1_accuracy: 1.0000 - head_1_loss: 2.3691e-04 - head_2_accuracy: 0.9999 - head_2_loss: 3.4717e-04 - head_3_accuracy: 1.0000 - head_3_loss: 2.7844e-04 - head_4_accuracy: 1.0000 - head_4_loss: 2.6222e-04 - head_5_accuracy: 1.0000 - head_5_loss: 3.5355e-04 - head_6_accuracy: 1.0000 - head_6_loss: 2.2386e-04 - head_7_accuracy: 0.9999 - head_7_loss: 4.2526e-04 - loss: 0.0021 - val_head_1_accuracy: 0.9951 - val_head_1_loss: 0.0194 - val_head_2_accuracy: 0.9956 - val_head_2_loss: 0.0185 - val_head_3_accuracy: 0.9954 - val_head_3_loss: 0.0194 - val_head_4_accuracy: 0.9949 - val_head_4_loss: 0.0193 - val_head_5_accuracy: 0.9951 - val_head_5_loss: 0.0193 - val_head_6_accuracy: 0.9954 - val_head_6_loss: 0.0203 - val_head_7_accuracy: 0.9954 - val_head_7_loss: 0.0195 - val_loss: 0.1366 - learning_rate: 0.0076\n", "\n", "Epoch 74: LearningRateScheduler setting learning rate to 0.007411179413321509.\n", "Epoch 74/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 65ms/step - head_1_accuracy: 1.0000 - head_1_loss: 1.4808e-04 - head_2_accuracy: 1.0000 - head_2_loss: 2.0137e-04 - head_3_accuracy: 1.0000 - head_3_loss: 1.6504e-04 - head_4_accuracy: 1.0000 - head_4_loss: 1.8276e-04 - head_5_accuracy: 1.0000 - head_5_loss: 2.0744e-04 - head_6_accuracy: 1.0000 - head_6_loss: 1.5660e-04 - head_7_accuracy: 1.0000 - head_7_loss: 1.6231e-04 - loss: 0.0012\n", "Epoch 74: val_head_1_accuracy did not improve from 0.99559\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m8s\u001b[0m 76ms/step - head_1_accuracy: 1.0000 - head_1_loss: 1.4505e-04 - head_2_accuracy: 1.0000 - head_2_loss: 1.9454e-04 - head_3_accuracy: 1.0000 - head_3_loss: 1.6438e-04 - head_4_accuracy: 1.0000 - head_4_loss: 1.7823e-04 - head_5_accuracy: 1.0000 - head_5_loss: 2.1797e-04 - head_6_accuracy: 1.0000 - head_6_loss: 1.7833e-04 - head_7_accuracy: 1.0000 - head_7_loss: 1.7005e-04 - loss: 0.0013 - val_head_1_accuracy: 0.9949 - val_head_1_loss: 0.0199 - val_head_2_accuracy: 0.9956 - val_head_2_loss: 0.0189 - val_head_3_accuracy: 0.9954 - val_head_3_loss: 0.0198 - val_head_4_accuracy: 0.9949 - val_head_4_loss: 0.0197 - val_head_5_accuracy: 0.9951 - val_head_5_loss: 0.0197 - val_head_6_accuracy: 0.9954 - val_head_6_loss: 0.0208 - val_head_7_accuracy: 0.9954 - val_head_7_loss: 0.0199 - val_loss: 0.1393 - learning_rate: 0.0074\n", "\n", "Epoch 75: LearningRateScheduler setting learning rate to 0.0072389383422025895.\n", "Epoch 75/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 61ms/step - head_1_accuracy: 1.0000 - head_1_loss: 1.5984e-04 - head_2_accuracy: 1.0000 - head_2_loss: 2.0596e-04 - head_3_accuracy: 1.0000 - head_3_loss: 2.0998e-04 - head_4_accuracy: 1.0000 - head_4_loss: 1.7702e-04 - head_5_accuracy: 1.0000 - head_5_loss: 1.7261e-04 - head_6_accuracy: 1.0000 - head_6_loss: 2.3532e-04 - head_7_accuracy: 1.0000 - head_7_loss: 1.8480e-04 - loss: 0.0013\n", "Epoch 75: val_head_1_accuracy did not improve from 0.99559\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 70ms/step - head_1_accuracy: 1.0000 - head_1_loss: 1.5838e-04 - head_2_accuracy: 1.0000 - head_2_loss: 2.1008e-04 - head_3_accuracy: 1.0000 - head_3_loss: 1.9218e-04 - head_4_accuracy: 1.0000 - head_4_loss: 1.7642e-04 - head_5_accuracy: 1.0000 - head_5_loss: 1.7257e-04 - head_6_accuracy: 1.0000 - head_6_loss: 2.0794e-04 - head_7_accuracy: 1.0000 - head_7_loss: 1.9314e-04 - loss: 0.0013 - val_head_1_accuracy: 0.9951 - val_head_1_loss: 0.0201 - val_head_2_accuracy: 0.9956 - val_head_2_loss: 0.0192 - val_head_3_accuracy: 0.9951 - val_head_3_loss: 0.0200 - val_head_4_accuracy: 0.9954 - val_head_4_loss: 0.0199 - val_head_5_accuracy: 0.9954 - val_head_5_loss: 0.0199 - val_head_6_accuracy: 0.9954 - val_head_6_loss: 0.0210 - val_head_7_accuracy: 0.9954 - val_head_7_loss: 0.0202 - val_loss: 0.1411 - learning_rate: 0.0072\n", "\n", "Epoch 76: LearningRateScheduler setting learning rate to 0.007071994714211974.\n", "Epoch 76/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 63ms/step - head_1_accuracy: 1.0000 - head_1_loss: 2.2188e-04 - head_2_accuracy: 1.0000 - head_2_loss: 2.1686e-04 - head_3_accuracy: 1.0000 - head_3_loss: 1.7844e-04 - head_4_accuracy: 1.0000 - head_4_loss: 1.9648e-04 - head_5_accuracy: 1.0000 - head_5_loss: 2.0025e-04 - head_6_accuracy: 1.0000 - head_6_loss: 1.8963e-04 - head_7_accuracy: 1.0000 - head_7_loss: 1.6925e-04 - loss: 0.0014\n", "Epoch 76: val_head_1_accuracy did not improve from 0.99559\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m8s\u001b[0m 74ms/step - head_1_accuracy: 1.0000 - head_1_loss: 2.2532e-04 - head_2_accuracy: 1.0000 - head_2_loss: 2.1040e-04 - head_3_accuracy: 1.0000 - head_3_loss: 1.9247e-04 - head_4_accuracy: 1.0000 - head_4_loss: 2.2164e-04 - head_5_accuracy: 1.0000 - head_5_loss: 2.2182e-04 - head_6_accuracy: 1.0000 - head_6_loss: 1.8238e-04 - head_7_accuracy: 1.0000 - head_7_loss: 1.6634e-04 - loss: 0.0014 - val_head_1_accuracy: 0.9947 - val_head_1_loss: 0.0205 - val_head_2_accuracy: 0.9951 - val_head_2_loss: 0.0195 - val_head_3_accuracy: 0.9944 - val_head_3_loss: 0.0201 - val_head_4_accuracy: 0.9947 - val_head_4_loss: 0.0204 - val_head_5_accuracy: 0.9949 - val_head_5_loss: 0.0201 - val_head_6_accuracy: 0.9947 - val_head_6_loss: 0.0215 - val_head_7_accuracy: 0.9949 - val_head_7_loss: 0.0206 - val_loss: 0.1439 - learning_rate: 0.0071\n", "\n", "Epoch 77: LearningRateScheduler setting learning rate to 0.00691051662743184.\n", "Epoch 77/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 61ms/step - head_1_accuracy: 1.0000 - head_1_loss: 1.5033e-04 - head_2_accuracy: 1.0000 - head_2_loss: 1.8987e-04 - head_3_accuracy: 1.0000 - head_3_loss: 1.7512e-04 - head_4_accuracy: 1.0000 - head_4_loss: 1.9751e-04 - head_5_accuracy: 1.0000 - head_5_loss: 2.4560e-04 - head_6_accuracy: 1.0000 - head_6_loss: 1.6037e-04 - head_7_accuracy: 1.0000 - head_7_loss: 1.7711e-04 - loss: 0.0013\n", "Epoch 77: val_head_1_accuracy did not improve from 0.99559\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 70ms/step - head_1_accuracy: 1.0000 - head_1_loss: 1.4869e-04 - head_2_accuracy: 1.0000 - head_2_loss: 1.9820e-04 - head_3_accuracy: 1.0000 - head_3_loss: 1.6446e-04 - head_4_accuracy: 1.0000 - head_4_loss: 2.0965e-04 - head_5_accuracy: 1.0000 - head_5_loss: 2.1643e-04 - head_6_accuracy: 1.0000 - head_6_loss: 1.5745e-04 - head_7_accuracy: 1.0000 - head_7_loss: 1.7044e-04 - loss: 0.0013 - val_head_1_accuracy: 0.9949 - val_head_1_loss: 0.0200 - val_head_2_accuracy: 0.9951 - val_head_2_loss: 0.0190 - val_head_3_accuracy: 0.9951 - val_head_3_loss: 0.0197 - val_head_4_accuracy: 0.9947 - val_head_4_loss: 0.0200 - val_head_5_accuracy: 0.9947 - val_head_5_loss: 0.0197 - val_head_6_accuracy: 0.9947 - val_head_6_loss: 0.0211 - val_head_7_accuracy: 0.9949 - val_head_7_loss: 0.0200 - val_loss: 0.1400 - learning_rate: 0.0069\n", "\n", "Epoch 78: LearningRateScheduler setting learning rate to 0.006754666676607666.\n", "Epoch 78/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 63ms/step - head_1_accuracy: 1.0000 - head_1_loss: 1.5229e-04 - head_2_accuracy: 1.0000 - head_2_loss: 1.9896e-04 - head_3_accuracy: 1.0000 - head_3_loss: 1.7832e-04 - head_4_accuracy: 1.0000 - head_4_loss: 1.9825e-04 - head_5_accuracy: 1.0000 - head_5_loss: 2.1456e-04 - head_6_accuracy: 1.0000 - head_6_loss: 1.4788e-04 - head_7_accuracy: 1.0000 - head_7_loss: 1.5482e-04 - loss: 0.0012\n", "Epoch 78: val_head_1_accuracy did not improve from 0.99559\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m8s\u001b[0m 73ms/step - head_1_accuracy: 1.0000 - head_1_loss: 1.5719e-04 - head_2_accuracy: 1.0000 - head_2_loss: 2.1958e-04 - head_3_accuracy: 1.0000 - head_3_loss: 1.9605e-04 - head_4_accuracy: 1.0000 - head_4_loss: 1.9397e-04 - head_5_accuracy: 1.0000 - head_5_loss: 2.3847e-04 - head_6_accuracy: 1.0000 - head_6_loss: 1.5770e-04 - head_7_accuracy: 1.0000 - head_7_loss: 1.7358e-04 - loss: 0.0013 - val_head_1_accuracy: 0.9951 - val_head_1_loss: 0.0201 - val_head_2_accuracy: 0.9954 - val_head_2_loss: 0.0191 - val_head_3_accuracy: 0.9954 - val_head_3_loss: 0.0199 - val_head_4_accuracy: 0.9947 - val_head_4_loss: 0.0200 - val_head_5_accuracy: 0.9951 - val_head_5_loss: 0.0198 - val_head_6_accuracy: 0.9954 - val_head_6_loss: 0.0212 - val_head_7_accuracy: 0.9954 - val_head_7_loss: 0.0202 - val_loss: 0.1408 - learning_rate: 0.0068\n", "\n", "Epoch 79: LearningRateScheduler setting learning rate to 0.006604601789429095.\n", "Epoch 79/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 62ms/step - head_1_accuracy: 1.0000 - head_1_loss: 1.3292e-04 - head_2_accuracy: 1.0000 - head_2_loss: 1.7088e-04 - head_3_accuracy: 1.0000 - head_3_loss: 1.4738e-04 - head_4_accuracy: 1.0000 - head_4_loss: 1.5262e-04 - head_5_accuracy: 1.0000 - head_5_loss: 1.7913e-04 - head_6_accuracy: 1.0000 - head_6_loss: 1.3382e-04 - head_7_accuracy: 1.0000 - head_7_loss: 1.3378e-04 - loss: 0.0011\n", "Epoch 79: val_head_1_accuracy did not improve from 0.99559\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 71ms/step - head_1_accuracy: 1.0000 - head_1_loss: 1.4287e-04 - head_2_accuracy: 1.0000 - head_2_loss: 1.6091e-04 - head_3_accuracy: 1.0000 - head_3_loss: 1.5235e-04 - head_4_accuracy: 1.0000 - head_4_loss: 1.5122e-04 - head_5_accuracy: 1.0000 - head_5_loss: 1.7868e-04 - head_6_accuracy: 1.0000 - head_6_loss: 1.3923e-04 - head_7_accuracy: 1.0000 - head_7_loss: 1.3363e-04 - loss: 0.0011 - val_head_1_accuracy: 0.9954 - val_head_1_loss: 0.0199 - val_head_2_accuracy: 0.9954 - val_head_2_loss: 0.0190 - val_head_3_accuracy: 0.9951 - val_head_3_loss: 0.0198 - val_head_4_accuracy: 0.9949 - val_head_4_loss: 0.0197 - val_head_5_accuracy: 0.9951 - val_head_5_loss: 0.0197 - val_head_6_accuracy: 0.9954 - val_head_6_loss: 0.0210 - val_head_7_accuracy: 0.9954 - val_head_7_loss: 0.0201 - val_loss: 0.1398 - learning_rate: 0.0066\n", "\n", "Epoch 80: LearningRateScheduler setting learning rate to 0.0064604730685170605.\n", "Epoch 80/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 63ms/step - head_1_accuracy: 1.0000 - head_1_loss: 1.2524e-04 - head_2_accuracy: 1.0000 - head_2_loss: 1.6940e-04 - head_3_accuracy: 1.0000 - head_3_loss: 1.4374e-04 - head_4_accuracy: 1.0000 - head_4_loss: 1.5718e-04 - head_5_accuracy: 1.0000 - head_5_loss: 1.7651e-04 - head_6_accuracy: 1.0000 - head_6_loss: 1.2785e-04 - head_7_accuracy: 1.0000 - head_7_loss: 1.6009e-04 - loss: 0.0011\n", "Epoch 80: val_head_1_accuracy did not improve from 0.99559\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 73ms/step - head_1_accuracy: 1.0000 - head_1_loss: 1.1913e-04 - head_2_accuracy: 1.0000 - head_2_loss: 1.5326e-04 - head_3_accuracy: 1.0000 - head_3_loss: 1.3662e-04 - head_4_accuracy: 1.0000 - head_4_loss: 1.4969e-04 - head_5_accuracy: 1.0000 - head_5_loss: 1.5031e-04 - head_6_accuracy: 1.0000 - head_6_loss: 1.2052e-04 - head_7_accuracy: 1.0000 - head_7_loss: 1.4492e-04 - loss: 9.8403e-04 - val_head_1_accuracy: 0.9951 - val_head_1_loss: 0.0201 - val_head_2_accuracy: 0.9954 - val_head_2_loss: 0.0192 - val_head_3_accuracy: 0.9954 - val_head_3_loss: 0.0200 - val_head_4_accuracy: 0.9956 - val_head_4_loss: 0.0198 - val_head_5_accuracy: 0.9951 - val_head_5_loss: 0.0200 - val_head_6_accuracy: 0.9954 - val_head_6_loss: 0.0213 - val_head_7_accuracy: 0.9951 - val_head_7_loss: 0.0205 - val_loss: 0.1413 - learning_rate: 0.0065\n", "\n", "Epoch 81: LearningRateScheduler setting learning rate to 0.006322425639276255.\n", "Epoch 81/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 62ms/step - head_1_accuracy: 1.0000 - head_1_loss: 1.0862e-04 - head_2_accuracy: 1.0000 - head_2_loss: 1.5523e-04 - head_3_accuracy: 1.0000 - head_3_loss: 1.3319e-04 - head_4_accuracy: 1.0000 - head_4_loss: 1.2496e-04 - head_5_accuracy: 1.0000 - head_5_loss: 1.8206e-04 - head_6_accuracy: 1.0000 - head_6_loss: 1.2306e-04 - head_7_accuracy: 1.0000 - head_7_loss: 1.2085e-04 - loss: 9.4797e-04\n", "Epoch 81: val_head_1_accuracy did not improve from 0.99559\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 70ms/step - head_1_accuracy: 1.0000 - head_1_loss: 1.1229e-04 - head_2_accuracy: 1.0000 - head_2_loss: 1.5509e-04 - head_3_accuracy: 1.0000 - head_3_loss: 1.2477e-04 - head_4_accuracy: 1.0000 - head_4_loss: 1.2649e-04 - head_5_accuracy: 1.0000 - head_5_loss: 1.7441e-04 - head_6_accuracy: 1.0000 - head_6_loss: 1.1896e-04 - head_7_accuracy: 1.0000 - head_7_loss: 1.3776e-04 - loss: 9.5911e-04 - val_head_1_accuracy: 0.9949 - val_head_1_loss: 0.0204 - val_head_2_accuracy: 0.9954 - val_head_2_loss: 0.0193 - val_head_3_accuracy: 0.9954 - val_head_3_loss: 0.0202 - val_head_4_accuracy: 0.9951 - val_head_4_loss: 0.0201 - val_head_5_accuracy: 0.9951 - val_head_5_loss: 0.0201 - val_head_6_accuracy: 0.9951 - val_head_6_loss: 0.0215 - val_head_7_accuracy: 0.9949 - val_head_7_loss: 0.0206 - val_loss: 0.1426 - learning_rate: 0.0063\n", "\n", "Epoch 82: LearningRateScheduler setting learning rate to 0.006190598503766142.\n", "Epoch 82/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 62ms/step - head_1_accuracy: 1.0000 - head_1_loss: 1.5300e-04 - head_2_accuracy: 1.0000 - head_2_loss: 1.6106e-04 - head_3_accuracy: 1.0000 - head_3_loss: 1.4520e-04 - head_4_accuracy: 1.0000 - head_4_loss: 1.2594e-04 - head_5_accuracy: 1.0000 - head_5_loss: 1.4123e-04 - head_6_accuracy: 1.0000 - head_6_loss: 1.1368e-04 - head_7_accuracy: 1.0000 - head_7_loss: 1.4837e-04 - loss: 9.8848e-04\n", "Epoch 82: val_head_1_accuracy did not improve from 0.99559\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 73ms/step - head_1_accuracy: 1.0000 - head_1_loss: 1.4856e-04 - head_2_accuracy: 1.0000 - head_2_loss: 1.7871e-04 - head_3_accuracy: 1.0000 - head_3_loss: 1.6296e-04 - head_4_accuracy: 1.0000 - head_4_loss: 1.3993e-04 - head_5_accuracy: 1.0000 - head_5_loss: 1.5617e-04 - head_6_accuracy: 1.0000 - head_6_loss: 1.3758e-04 - head_7_accuracy: 1.0000 - head_7_loss: 1.5174e-04 - loss: 0.0011 - val_head_1_accuracy: 0.9954 - val_head_1_loss: 0.0208 - val_head_2_accuracy: 0.9951 - val_head_2_loss: 0.0198 - val_head_3_accuracy: 0.9954 - val_head_3_loss: 0.0206 - val_head_4_accuracy: 0.9951 - val_head_4_loss: 0.0205 - val_head_5_accuracy: 0.9951 - val_head_5_loss: 0.0205 - val_head_6_accuracy: 0.9954 - val_head_6_loss: 0.0218 - val_head_7_accuracy: 0.9954 - val_head_7_loss: 0.0210 - val_loss: 0.1454 - learning_rate: 0.0062\n", "\n", "Epoch 83: LearningRateScheduler setting learning rate to 0.006065124400737674.\n", "Epoch 83/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 62ms/step - head_1_accuracy: 1.0000 - head_1_loss: 1.3586e-04 - head_2_accuracy: 1.0000 - head_2_loss: 1.4131e-04 - head_3_accuracy: 1.0000 - head_3_loss: 1.3697e-04 - head_4_accuracy: 1.0000 - head_4_loss: 1.3793e-04 - head_5_accuracy: 1.0000 - head_5_loss: 1.6659e-04 - head_6_accuracy: 1.0000 - head_6_loss: 1.4750e-04 - head_7_accuracy: 1.0000 - head_7_loss: 1.1454e-04 - loss: 9.8069e-04\n", "Epoch 83: val_head_1_accuracy did not improve from 0.99559\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 71ms/step - head_1_accuracy: 1.0000 - head_1_loss: 1.4981e-04 - head_2_accuracy: 1.0000 - head_2_loss: 1.5534e-04 - head_3_accuracy: 1.0000 - head_3_loss: 1.8073e-04 - head_4_accuracy: 1.0000 - head_4_loss: 1.4948e-04 - head_5_accuracy: 1.0000 - head_5_loss: 1.6582e-04 - head_6_accuracy: 1.0000 - head_6_loss: 1.4162e-04 - head_7_accuracy: 1.0000 - head_7_loss: 1.3421e-04 - loss: 0.0011 - val_head_1_accuracy: 0.9951 - val_head_1_loss: 0.0206 - val_head_2_accuracy: 0.9951 - val_head_2_loss: 0.0197 - val_head_3_accuracy: 0.9961 - val_head_3_loss: 0.0205 - val_head_4_accuracy: 0.9949 - val_head_4_loss: 0.0204 - val_head_5_accuracy: 0.9949 - val_head_5_loss: 0.0205 - val_head_6_accuracy: 0.9951 - val_head_6_loss: 0.0216 - val_head_7_accuracy: 0.9954 - val_head_7_loss: 0.0209 - val_loss: 0.1444 - learning_rate: 0.0061\n", "\n", "Epoch 84: LearningRateScheduler setting learning rate to 0.005946129671976613.\n", "Epoch 84/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 62ms/step - head_1_accuracy: 1.0000 - head_1_loss: 1.3818e-04 - head_2_accuracy: 1.0000 - head_2_loss: 1.7920e-04 - head_3_accuracy: 1.0000 - head_3_loss: 1.8462e-04 - head_4_accuracy: 1.0000 - head_4_loss: 2.0285e-04 - head_5_accuracy: 1.0000 - head_5_loss: 3.0970e-04 - head_6_accuracy: 1.0000 - head_6_loss: 1.4479e-04 - head_7_accuracy: 1.0000 - head_7_loss: 1.3665e-04 - loss: 0.0013\n", "Epoch 84: val_head_1_accuracy did not improve from 0.99559\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 72ms/step - head_1_accuracy: 1.0000 - head_1_loss: 1.3237e-04 - head_2_accuracy: 1.0000 - head_2_loss: 2.1123e-04 - head_3_accuracy: 1.0000 - head_3_loss: 1.5796e-04 - head_4_accuracy: 1.0000 - head_4_loss: 1.5804e-04 - head_5_accuracy: 1.0000 - head_5_loss: 1.9435e-04 - head_6_accuracy: 1.0000 - head_6_loss: 1.3082e-04 - head_7_accuracy: 1.0000 - head_7_loss: 1.2027e-04 - loss: 0.0011 - val_head_1_accuracy: 0.9954 - val_head_1_loss: 0.0204 - val_head_2_accuracy: 0.9956 - val_head_2_loss: 0.0195 - val_head_3_accuracy: 0.9956 - val_head_3_loss: 0.0203 - val_head_4_accuracy: 0.9954 - val_head_4_loss: 0.0202 - val_head_5_accuracy: 0.9958 - val_head_5_loss: 0.0204 - val_head_6_accuracy: 0.9954 - val_head_6_loss: 0.0216 - val_head_7_accuracy: 0.9956 - val_head_7_loss: 0.0209 - val_loss: 0.1431 - learning_rate: 0.0059\n", "\n", "Epoch 85: LearningRateScheduler setting learning rate to 0.0058337341350880745.\n", "Epoch 85/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 62ms/step - head_1_accuracy: 1.0000 - head_1_loss: 1.0410e-04 - head_2_accuracy: 1.0000 - head_2_loss: 1.3122e-04 - head_3_accuracy: 1.0000 - head_3_loss: 1.3076e-04 - head_4_accuracy: 1.0000 - head_4_loss: 1.6277e-04 - head_5_accuracy: 1.0000 - head_5_loss: 1.4855e-04 - head_6_accuracy: 1.0000 - head_6_loss: 1.6184e-04 - head_7_accuracy: 1.0000 - head_7_loss: 1.2749e-04 - loss: 9.6673e-04\n", "Epoch 85: val_head_1_accuracy did not improve from 0.99559\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 71ms/step - head_1_accuracy: 1.0000 - head_1_loss: 1.1191e-04 - head_2_accuracy: 1.0000 - head_2_loss: 1.2707e-04 - head_3_accuracy: 1.0000 - head_3_loss: 1.5076e-04 - head_4_accuracy: 1.0000 - head_4_loss: 1.8656e-04 - head_5_accuracy: 1.0000 - head_5_loss: 1.6373e-04 - head_6_accuracy: 1.0000 - head_6_loss: 1.5897e-04 - head_7_accuracy: 1.0000 - head_7_loss: 1.4211e-04 - loss: 0.0011 - val_head_1_accuracy: 0.9949 - val_head_1_loss: 0.0207 - val_head_2_accuracy: 0.9954 - val_head_2_loss: 0.0197 - val_head_3_accuracy: 0.9954 - val_head_3_loss: 0.0206 - val_head_4_accuracy: 0.9951 - val_head_4_loss: 0.0205 - val_head_5_accuracy: 0.9951 - val_head_5_loss: 0.0205 - val_head_6_accuracy: 0.9951 - val_head_6_loss: 0.0218 - val_head_7_accuracy: 0.9951 - val_head_7_loss: 0.0211 - val_loss: 0.1451 - learning_rate: 0.0058\n", "\n", "Epoch 86: LearningRateScheduler setting learning rate to 0.005728050962850342.\n", "Epoch 86/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 62ms/step - head_1_accuracy: 1.0000 - head_1_loss: 1.7960e-04 - head_2_accuracy: 1.0000 - head_2_loss: 2.6289e-04 - head_3_accuracy: 0.9999 - head_3_loss: 2.6236e-04 - head_4_accuracy: 1.0000 - head_4_loss: 2.0821e-04 - head_5_accuracy: 0.9999 - head_5_loss: 2.2389e-04 - head_6_accuracy: 1.0000 - head_6_loss: 2.1519e-04 - head_7_accuracy: 1.0000 - head_7_loss: 1.8748e-04 - loss: 0.0015\n", "Epoch 86: val_head_1_accuracy did not improve from 0.99559\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m8s\u001b[0m 75ms/step - head_1_accuracy: 0.9999 - head_1_loss: 2.2483e-04 - head_2_accuracy: 1.0000 - head_2_loss: 2.3377e-04 - head_3_accuracy: 0.9999 - head_3_loss: 2.3639e-04 - head_4_accuracy: 1.0000 - head_4_loss: 2.2790e-04 - head_5_accuracy: 0.9998 - head_5_loss: 3.2432e-04 - head_6_accuracy: 0.9999 - head_6_loss: 2.6268e-04 - head_7_accuracy: 0.9999 - head_7_loss: 2.6655e-04 - loss: 0.0018 - val_head_1_accuracy: 0.9949 - val_head_1_loss: 0.0202 - val_head_2_accuracy: 0.9956 - val_head_2_loss: 0.0193 - val_head_3_accuracy: 0.9954 - val_head_3_loss: 0.0200 - val_head_4_accuracy: 0.9951 - val_head_4_loss: 0.0202 - val_head_5_accuracy: 0.9944 - val_head_5_loss: 0.0201 - val_head_6_accuracy: 0.9951 - val_head_6_loss: 0.0212 - val_head_7_accuracy: 0.9949 - val_head_7_loss: 0.0204 - val_loss: 0.1423 - learning_rate: 0.0057\n", "\n", "Epoch 87: LearningRateScheduler setting learning rate to 0.005629186569259479.\n", "Epoch 87/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 62ms/step - head_1_accuracy: 1.0000 - head_1_loss: 1.7526e-04 - head_2_accuracy: 1.0000 - head_2_loss: 2.0714e-04 - head_3_accuracy: 1.0000 - head_3_loss: 2.1644e-04 - head_4_accuracy: 1.0000 - head_4_loss: 2.1600e-04 - head_5_accuracy: 1.0000 - head_5_loss: 2.0069e-04 - head_6_accuracy: 1.0000 - head_6_loss: 2.1174e-04 - head_7_accuracy: 1.0000 - head_7_loss: 1.9478e-04 - loss: 0.0014\n", "Epoch 87: val_head_1_accuracy did not improve from 0.99559\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 71ms/step - head_1_accuracy: 1.0000 - head_1_loss: 1.6628e-04 - head_2_accuracy: 1.0000 - head_2_loss: 1.9300e-04 - head_3_accuracy: 1.0000 - head_3_loss: 1.9113e-04 - head_4_accuracy: 1.0000 - head_4_loss: 1.9805e-04 - head_5_accuracy: 1.0000 - head_5_loss: 1.9431e-04 - head_6_accuracy: 1.0000 - head_6_loss: 1.9041e-04 - head_7_accuracy: 1.0000 - head_7_loss: 1.8129e-04 - loss: 0.0013 - val_head_1_accuracy: 0.9944 - val_head_1_loss: 0.0201 - val_head_2_accuracy: 0.9947 - val_head_2_loss: 0.0192 - val_head_3_accuracy: 0.9947 - val_head_3_loss: 0.0199 - val_head_4_accuracy: 0.9949 - val_head_4_loss: 0.0202 - val_head_5_accuracy: 0.9949 - val_head_5_loss: 0.0200 - val_head_6_accuracy: 0.9954 - val_head_6_loss: 0.0210 - val_head_7_accuracy: 0.9951 - val_head_7_loss: 0.0203 - val_loss: 0.1413 - learning_rate: 0.0056\n", "\n", "Epoch 88: LearningRateScheduler setting learning rate to 0.005537240502379456.\n", "Epoch 88/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 62ms/step - head_1_accuracy: 1.0000 - head_1_loss: 1.1141e-04 - head_2_accuracy: 1.0000 - head_2_loss: 1.5042e-04 - head_3_accuracy: 1.0000 - head_3_loss: 1.5377e-04 - head_4_accuracy: 1.0000 - head_4_loss: 1.4934e-04 - head_5_accuracy: 1.0000 - head_5_loss: 1.1095e-04 - head_6_accuracy: 1.0000 - head_6_loss: 1.0308e-04 - head_7_accuracy: 1.0000 - head_7_loss: 1.0556e-04 - loss: 8.8453e-04\n", "Epoch 88: val_head_1_accuracy did not improve from 0.99559\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 73ms/step - head_1_accuracy: 1.0000 - head_1_loss: 1.0713e-04 - head_2_accuracy: 1.0000 - head_2_loss: 1.5897e-04 - head_3_accuracy: 1.0000 - head_3_loss: 1.3554e-04 - head_4_accuracy: 1.0000 - head_4_loss: 1.3765e-04 - head_5_accuracy: 1.0000 - head_5_loss: 1.1337e-04 - head_6_accuracy: 1.0000 - head_6_loss: 1.1244e-04 - head_7_accuracy: 1.0000 - head_7_loss: 1.1417e-04 - loss: 8.8790e-04 - val_head_1_accuracy: 0.9949 - val_head_1_loss: 0.0200 - val_head_2_accuracy: 0.9951 - val_head_2_loss: 0.0192 - val_head_3_accuracy: 0.9951 - val_head_3_loss: 0.0200 - val_head_4_accuracy: 0.9954 - val_head_4_loss: 0.0201 - val_head_5_accuracy: 0.9951 - val_head_5_loss: 0.0200 - val_head_6_accuracy: 0.9951 - val_head_6_loss: 0.0211 - val_head_7_accuracy: 0.9949 - val_head_7_loss: 0.0203 - val_loss: 0.1410 - learning_rate: 0.0055\n", "\n", "Epoch 89: LearningRateScheduler setting learning rate to 0.0054523053441056886.\n", "Epoch 89/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 62ms/step - head_1_accuracy: 1.0000 - head_1_loss: 1.1676e-04 - head_2_accuracy: 1.0000 - head_2_loss: 1.4268e-04 - head_3_accuracy: 1.0000 - head_3_loss: 1.1729e-04 - head_4_accuracy: 1.0000 - head_4_loss: 1.5048e-04 - head_5_accuracy: 1.0000 - head_5_loss: 1.3922e-04 - head_6_accuracy: 1.0000 - head_6_loss: 1.4425e-04 - head_7_accuracy: 1.0000 - head_7_loss: 1.2910e-04 - loss: 9.3978e-04\n", "Epoch 89: val_head_1_accuracy did not improve from 0.99559\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 71ms/step - head_1_accuracy: 1.0000 - head_1_loss: 1.6554e-04 - head_2_accuracy: 1.0000 - head_2_loss: 2.1927e-04 - head_3_accuracy: 0.9999 - head_3_loss: 2.0055e-04 - head_4_accuracy: 0.9999 - head_4_loss: 3.1041e-04 - head_5_accuracy: 1.0000 - head_5_loss: 2.1501e-04 - head_6_accuracy: 1.0000 - head_6_loss: 1.4266e-04 - head_7_accuracy: 0.9999 - head_7_loss: 2.5051e-04 - loss: 0.0015 - val_head_1_accuracy: 0.9949 - val_head_1_loss: 0.0208 - val_head_2_accuracy: 0.9951 - val_head_2_loss: 0.0197 - val_head_3_accuracy: 0.9947 - val_head_3_loss: 0.0209 - val_head_4_accuracy: 0.9949 - val_head_4_loss: 0.0205 - val_head_5_accuracy: 0.9949 - val_head_5_loss: 0.0206 - val_head_6_accuracy: 0.9947 - val_head_6_loss: 0.0218 - val_head_7_accuracy: 0.9947 - val_head_7_loss: 0.0211 - val_loss: 0.1462 - learning_rate: 0.0055\n", "\n", "Epoch 90: LearningRateScheduler setting learning rate to 0.00537446661694291.\n", "Epoch 90/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 62ms/step - head_1_accuracy: 1.0000 - head_1_loss: 2.0423e-04 - head_2_accuracy: 1.0000 - head_2_loss: 1.8522e-04 - head_3_accuracy: 1.0000 - head_3_loss: 2.1191e-04 - head_4_accuracy: 1.0000 - head_4_loss: 2.0418e-04 - head_5_accuracy: 1.0000 - head_5_loss: 1.4797e-04 - head_6_accuracy: 1.0000 - head_6_loss: 1.8052e-04 - head_7_accuracy: 1.0000 - head_7_loss: 1.7839e-04 - loss: 0.0013\n", "Epoch 90: val_head_1_accuracy did not improve from 0.99559\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 73ms/step - head_1_accuracy: 1.0000 - head_1_loss: 1.5830e-04 - head_2_accuracy: 1.0000 - head_2_loss: 1.7548e-04 - head_3_accuracy: 1.0000 - head_3_loss: 1.9664e-04 - head_4_accuracy: 1.0000 - head_4_loss: 1.7274e-04 - head_5_accuracy: 1.0000 - head_5_loss: 1.4177e-04 - head_6_accuracy: 1.0000 - head_6_loss: 1.5716e-04 - head_7_accuracy: 1.0000 - head_7_loss: 1.5483e-04 - loss: 0.0012 - val_head_1_accuracy: 0.9951 - val_head_1_loss: 0.0199 - val_head_2_accuracy: 0.9956 - val_head_2_loss: 0.0189 - val_head_3_accuracy: 0.9954 - val_head_3_loss: 0.0199 - val_head_4_accuracy: 0.9954 - val_head_4_loss: 0.0196 - val_head_5_accuracy: 0.9954 - val_head_5_loss: 0.0198 - val_head_6_accuracy: 0.9949 - val_head_6_loss: 0.0209 - val_head_7_accuracy: 0.9951 - val_head_7_loss: 0.0202 - val_loss: 0.1396 - learning_rate: 0.0054\n", "\n", "Epoch 91: LearningRateScheduler setting learning rate to 0.00530380269789127.\n", "Epoch 91/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 63ms/step - head_1_accuracy: 1.0000 - head_1_loss: 1.9377e-04 - head_2_accuracy: 1.0000 - head_2_loss: 1.7841e-04 - head_3_accuracy: 0.9999 - head_3_loss: 2.3296e-04 - head_4_accuracy: 0.9999 - head_4_loss: 3.0461e-04 - head_5_accuracy: 1.0000 - head_5_loss: 1.9111e-04 - head_6_accuracy: 1.0000 - head_6_loss: 1.8340e-04 - head_7_accuracy: 0.9999 - head_7_loss: 3.0052e-04 - loss: 0.0016\n", "Epoch 91: val_head_1_accuracy did not improve from 0.99559\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 72ms/step - head_1_accuracy: 1.0000 - head_1_loss: 1.8137e-04 - head_2_accuracy: 1.0000 - head_2_loss: 1.6527e-04 - head_3_accuracy: 0.9999 - head_3_loss: 2.1706e-04 - head_4_accuracy: 0.9999 - head_4_loss: 3.0893e-04 - head_5_accuracy: 1.0000 - head_5_loss: 1.8963e-04 - head_6_accuracy: 1.0000 - head_6_loss: 1.8124e-04 - head_7_accuracy: 0.9999 - head_7_loss: 3.1089e-04 - loss: 0.0016 - val_head_1_accuracy: 0.9949 - val_head_1_loss: 0.0200 - val_head_2_accuracy: 0.9951 - val_head_2_loss: 0.0189 - val_head_3_accuracy: 0.9954 - val_head_3_loss: 0.0199 - val_head_4_accuracy: 0.9954 - val_head_4_loss: 0.0196 - val_head_5_accuracy: 0.9954 - val_head_5_loss: 0.0197 - val_head_6_accuracy: 0.9949 - val_head_6_loss: 0.0210 - val_head_7_accuracy: 0.9954 - val_head_7_loss: 0.0202 - val_loss: 0.1396 - learning_rate: 0.0053\n", "\n", "Epoch 92: LearningRateScheduler setting learning rate to 0.005240384739527328.\n", "Epoch 92/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 62ms/step - head_1_accuracy: 1.0000 - head_1_loss: 1.7537e-04 - head_2_accuracy: 1.0000 - head_2_loss: 3.1673e-04 - head_3_accuracy: 1.0000 - head_3_loss: 1.9712e-04 - head_4_accuracy: 1.0000 - head_4_loss: 2.2236e-04 - head_5_accuracy: 1.0000 - head_5_loss: 2.1083e-04 - head_6_accuracy: 1.0000 - head_6_loss: 2.1356e-04 - head_7_accuracy: 1.0000 - head_7_loss: 1.9629e-04 - loss: 0.0015\n", "Epoch 92: val_head_1_accuracy did not improve from 0.99559\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 72ms/step - head_1_accuracy: 1.0000 - head_1_loss: 1.8567e-04 - head_2_accuracy: 0.9999 - head_2_loss: 3.3953e-04 - head_3_accuracy: 0.9999 - head_3_loss: 2.2879e-04 - head_4_accuracy: 0.9999 - head_4_loss: 2.5495e-04 - head_5_accuracy: 1.0000 - head_5_loss: 2.4221e-04 - head_6_accuracy: 0.9999 - head_6_loss: 2.3304e-04 - head_7_accuracy: 1.0000 - head_7_loss: 1.9622e-04 - loss: 0.0017 - val_head_1_accuracy: 0.9956 - val_head_1_loss: 0.0206 - val_head_2_accuracy: 0.9954 - val_head_2_loss: 0.0197 - val_head_3_accuracy: 0.9956 - val_head_3_loss: 0.0205 - val_head_4_accuracy: 0.9954 - val_head_4_loss: 0.0203 - val_head_5_accuracy: 0.9956 - val_head_5_loss: 0.0207 - val_head_6_accuracy: 0.9949 - val_head_6_loss: 0.0218 - val_head_7_accuracy: 0.9947 - val_head_7_loss: 0.0213 - val_loss: 0.1440 - learning_rate: 0.0052\n", "\n", "Epoch 93: LearningRateScheduler setting learning rate to 0.005184276598359447.\n", "Epoch 93/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 63ms/step - head_1_accuracy: 1.0000 - head_1_loss: 1.3933e-04 - head_2_accuracy: 1.0000 - head_2_loss: 1.5088e-04 - head_3_accuracy: 1.0000 - head_3_loss: 1.1598e-04 - head_4_accuracy: 1.0000 - head_4_loss: 1.2311e-04 - head_5_accuracy: 1.0000 - head_5_loss: 1.1275e-04 - head_6_accuracy: 1.0000 - head_6_loss: 1.1188e-04 - head_7_accuracy: 1.0000 - head_7_loss: 1.3504e-04 - loss: 8.8897e-04\n", "Epoch 93: val_head_1_accuracy did not improve from 0.99559\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 72ms/step - head_1_accuracy: 0.9999 - head_1_loss: 2.7069e-04 - head_2_accuracy: 0.9999 - head_2_loss: 2.8683e-04 - head_3_accuracy: 1.0000 - head_3_loss: 1.7076e-04 - head_4_accuracy: 0.9999 - head_4_loss: 2.8442e-04 - head_5_accuracy: 0.9999 - head_5_loss: 2.4165e-04 - head_6_accuracy: 0.9999 - head_6_loss: 1.7828e-04 - head_7_accuracy: 1.0000 - head_7_loss: 1.7080e-04 - loss: 0.0016 - val_head_1_accuracy: 0.9956 - val_head_1_loss: 0.0201 - val_head_2_accuracy: 0.9958 - val_head_2_loss: 0.0194 - val_head_3_accuracy: 0.9961 - val_head_3_loss: 0.0202 - val_head_4_accuracy: 0.9954 - val_head_4_loss: 0.0200 - val_head_5_accuracy: 0.9961 - val_head_5_loss: 0.0202 - val_head_6_accuracy: 0.9956 - val_head_6_loss: 0.0213 - val_head_7_accuracy: 0.9954 - val_head_7_loss: 0.0207 - val_loss: 0.1417 - learning_rate: 0.0052\n", "\n", "Epoch 94: LearningRateScheduler setting learning rate to 0.005135534770529701.\n", "Epoch 94/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 61ms/step - head_1_accuracy: 0.9998 - head_1_loss: 4.1724e-04 - head_2_accuracy: 0.9998 - head_2_loss: 5.4912e-04 - head_3_accuracy: 0.9998 - head_3_loss: 5.2061e-04 - head_4_accuracy: 0.9998 - head_4_loss: 5.4738e-04 - head_5_accuracy: 0.9999 - head_5_loss: 5.1721e-04 - head_6_accuracy: 0.9999 - head_6_loss: 4.4936e-04 - head_7_accuracy: 0.9999 - head_7_loss: 6.4484e-04 - loss: 0.0036\n", "Epoch 94: val_head_1_accuracy did not improve from 0.99559\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 72ms/step - head_1_accuracy: 0.9998 - head_1_loss: 4.1685e-04 - head_2_accuracy: 0.9998 - head_2_loss: 5.5734e-04 - head_3_accuracy: 0.9998 - head_3_loss: 5.1832e-04 - head_4_accuracy: 0.9998 - head_4_loss: 6.3744e-04 - head_5_accuracy: 0.9999 - head_5_loss: 4.6119e-04 - head_6_accuracy: 0.9999 - head_6_loss: 4.0951e-04 - head_7_accuracy: 0.9999 - head_7_loss: 5.3974e-04 - loss: 0.0036 - val_head_1_accuracy: 0.9956 - val_head_1_loss: 0.0184 - val_head_2_accuracy: 0.9958 - val_head_2_loss: 0.0176 - val_head_3_accuracy: 0.9963 - val_head_3_loss: 0.0184 - val_head_4_accuracy: 0.9956 - val_head_4_loss: 0.0182 - val_head_5_accuracy: 0.9958 - val_head_5_loss: 0.0186 - val_head_6_accuracy: 0.9956 - val_head_6_loss: 0.0196 - val_head_7_accuracy: 0.9958 - val_head_7_loss: 0.0190 - val_loss: 0.1306 - learning_rate: 0.0051\n", "\n", "Epoch 95: LearningRateScheduler setting learning rate to 0.005094208334927043.\n", "Epoch 95/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 63ms/step - head_1_accuracy: 1.0000 - head_1_loss: 1.2176e-04 - head_2_accuracy: 1.0000 - head_2_loss: 1.8041e-04 - head_3_accuracy: 1.0000 - head_3_loss: 1.8473e-04 - head_4_accuracy: 1.0000 - head_4_loss: 1.5648e-04 - head_5_accuracy: 1.0000 - head_5_loss: 1.6353e-04 - head_6_accuracy: 1.0000 - head_6_loss: 1.4704e-04 - head_7_accuracy: 1.0000 - head_7_loss: 1.6100e-04 - loss: 0.0011\n", "Epoch 95: val_head_1_accuracy improved from 0.99559 to 0.99582, saving model to /content/drive/My Drive/Classification/multicp/models/AlexNet_CNN_MultiHead_best.keras\n", "\n", "Epoch 95: finished saving model to /content/drive/My Drive/Classification/multicp/models/AlexNet_CNN_MultiHead_best.keras\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m9s\u001b[0m 87ms/step - head_1_accuracy: 1.0000 - head_1_loss: 1.2539e-04 - head_2_accuracy: 1.0000 - head_2_loss: 1.6604e-04 - head_3_accuracy: 1.0000 - head_3_loss: 2.1056e-04 - head_4_accuracy: 1.0000 - head_4_loss: 1.4899e-04 - head_5_accuracy: 1.0000 - head_5_loss: 1.6167e-04 - head_6_accuracy: 1.0000 - head_6_loss: 1.3230e-04 - head_7_accuracy: 1.0000 - head_7_loss: 2.1024e-04 - loss: 0.0012 - val_head_1_accuracy: 0.9958 - val_head_1_loss: 0.0186 - val_head_2_accuracy: 0.9956 - val_head_2_loss: 0.0179 - val_head_3_accuracy: 0.9956 - val_head_3_loss: 0.0186 - val_head_4_accuracy: 0.9949 - val_head_4_loss: 0.0186 - val_head_5_accuracy: 0.9956 - val_head_5_loss: 0.0188 - val_head_6_accuracy: 0.9951 - val_head_6_loss: 0.0198 - val_head_7_accuracy: 0.9954 - val_head_7_loss: 0.0192 - val_loss: 0.1321 - learning_rate: 0.0051\n", "\n", "Epoch 96: LearningRateScheduler setting learning rate to 0.0050603389037690355.\n", "Epoch 96/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 62ms/step - head_1_accuracy: 1.0000 - head_1_loss: 2.0060e-04 - head_2_accuracy: 1.0000 - head_2_loss: 1.9181e-04 - head_3_accuracy: 1.0000 - head_3_loss: 1.5145e-04 - head_4_accuracy: 1.0000 - head_4_loss: 2.0450e-04 - head_5_accuracy: 1.0000 - head_5_loss: 1.6815e-04 - head_6_accuracy: 1.0000 - head_6_loss: 1.9992e-04 - head_7_accuracy: 1.0000 - head_7_loss: 1.8242e-04 - loss: 0.0013\n", "Epoch 96: val_head_1_accuracy did not improve from 0.99582\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 72ms/step - head_1_accuracy: 1.0000 - head_1_loss: 1.6800e-04 - head_2_accuracy: 1.0000 - head_2_loss: 1.8798e-04 - head_3_accuracy: 1.0000 - head_3_loss: 1.5985e-04 - head_4_accuracy: 1.0000 - head_4_loss: 1.8675e-04 - head_5_accuracy: 1.0000 - head_5_loss: 1.8271e-04 - head_6_accuracy: 1.0000 - head_6_loss: 1.7763e-04 - head_7_accuracy: 1.0000 - head_7_loss: 1.8634e-04 - loss: 0.0013 - val_head_1_accuracy: 0.9956 - val_head_1_loss: 0.0187 - val_head_2_accuracy: 0.9956 - val_head_2_loss: 0.0180 - val_head_3_accuracy: 0.9958 - val_head_3_loss: 0.0186 - val_head_4_accuracy: 0.9956 - val_head_4_loss: 0.0185 - val_head_5_accuracy: 0.9958 - val_head_5_loss: 0.0189 - val_head_6_accuracy: 0.9954 - val_head_6_loss: 0.0197 - val_head_7_accuracy: 0.9958 - val_head_7_loss: 0.0192 - val_loss: 0.1320 - learning_rate: 0.0051\n", "\n", "Epoch 97: LearningRateScheduler setting learning rate to 0.005033960580701866.\n", "Epoch 97/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 67ms/step - head_1_accuracy: 0.9999 - head_1_loss: 1.9309e-04 - head_2_accuracy: 0.9999 - head_2_loss: 3.9751e-04 - head_3_accuracy: 0.9999 - head_3_loss: 1.9864e-04 - head_4_accuracy: 0.9999 - head_4_loss: 2.6667e-04 - head_5_accuracy: 0.9999 - head_5_loss: 2.7018e-04 - head_6_accuracy: 0.9999 - head_6_loss: 2.7776e-04 - head_7_accuracy: 0.9999 - head_7_loss: 2.1491e-04 - loss: 0.0018\n", "Epoch 97: val_head_1_accuracy did not improve from 0.99582\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m8s\u001b[0m 77ms/step - head_1_accuracy: 0.9999 - head_1_loss: 2.5246e-04 - head_2_accuracy: 0.9999 - head_2_loss: 5.0310e-04 - head_3_accuracy: 0.9999 - head_3_loss: 2.6404e-04 - head_4_accuracy: 0.9999 - head_4_loss: 3.2063e-04 - head_5_accuracy: 0.9999 - head_5_loss: 2.9643e-04 - head_6_accuracy: 0.9999 - head_6_loss: 3.9860e-04 - head_7_accuracy: 0.9999 - head_7_loss: 3.0124e-04 - loss: 0.0024 - val_head_1_accuracy: 0.9951 - val_head_1_loss: 0.0186 - val_head_2_accuracy: 0.9958 - val_head_2_loss: 0.0180 - val_head_3_accuracy: 0.9958 - val_head_3_loss: 0.0189 - val_head_4_accuracy: 0.9954 - val_head_4_loss: 0.0185 - val_head_5_accuracy: 0.9951 - val_head_5_loss: 0.0190 - val_head_6_accuracy: 0.9951 - val_head_6_loss: 0.0202 - val_head_7_accuracy: 0.9951 - val_head_7_loss: 0.0195 - val_loss: 0.1332 - learning_rate: 0.0050\n", "\n", "Epoch 98: LearningRateScheduler setting learning rate to 0.0050150999264608675.\n", "Epoch 98/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 68ms/step - head_1_accuracy: 0.9999 - head_1_loss: 1.9705e-04 - head_2_accuracy: 1.0000 - head_2_loss: 2.5427e-04 - head_3_accuracy: 1.0000 - head_3_loss: 1.8938e-04 - head_4_accuracy: 1.0000 - head_4_loss: 2.5706e-04 - head_5_accuracy: 1.0000 - head_5_loss: 2.0168e-04 - head_6_accuracy: 0.9999 - head_6_loss: 3.1551e-04 - head_7_accuracy: 1.0000 - head_7_loss: 2.0232e-04 - loss: 0.0016\n", "Epoch 98: val_head_1_accuracy did not improve from 0.99582\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m8s\u001b[0m 79ms/step - head_1_accuracy: 0.9998 - head_1_loss: 2.8457e-04 - head_2_accuracy: 0.9999 - head_2_loss: 3.2078e-04 - head_3_accuracy: 0.9999 - head_3_loss: 2.6678e-04 - head_4_accuracy: 0.9999 - head_4_loss: 2.9662e-04 - head_5_accuracy: 0.9999 - head_5_loss: 2.7428e-04 - head_6_accuracy: 0.9998 - head_6_loss: 4.8870e-04 - head_7_accuracy: 0.9999 - head_7_loss: 2.6268e-04 - loss: 0.0022 - val_head_1_accuracy: 0.9958 - val_head_1_loss: 0.0191 - val_head_2_accuracy: 0.9958 - val_head_2_loss: 0.0184 - val_head_3_accuracy: 0.9956 - val_head_3_loss: 0.0190 - val_head_4_accuracy: 0.9954 - val_head_4_loss: 0.0189 - val_head_5_accuracy: 0.9956 - val_head_5_loss: 0.0194 - val_head_6_accuracy: 0.9958 - val_head_6_loss: 0.0200 - val_head_7_accuracy: 0.9961 - val_head_7_loss: 0.0196 - val_loss: 0.1350 - learning_rate: 0.0050\n", "\n", "Epoch 99: LearningRateScheduler setting learning rate to 0.005003775932126112.\n", "Epoch 99/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 64ms/step - head_1_accuracy: 0.9999 - head_1_loss: 1.5844e-04 - head_2_accuracy: 1.0000 - head_2_loss: 1.7478e-04 - head_3_accuracy: 0.9999 - head_3_loss: 1.9366e-04 - head_4_accuracy: 1.0000 - head_4_loss: 1.1649e-04 - head_5_accuracy: 1.0000 - head_5_loss: 1.2609e-04 - head_6_accuracy: 1.0000 - head_6_loss: 1.5338e-04 - head_7_accuracy: 1.0000 - head_7_loss: 9.9749e-05 - loss: 0.0010\n", "Epoch 99: val_head_1_accuracy did not improve from 0.99582\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m8s\u001b[0m 74ms/step - head_1_accuracy: 0.9999 - head_1_loss: 1.8544e-04 - head_2_accuracy: 1.0000 - head_2_loss: 1.3531e-04 - head_3_accuracy: 0.9999 - head_3_loss: 2.0508e-04 - head_4_accuracy: 1.0000 - head_4_loss: 1.2683e-04 - head_5_accuracy: 1.0000 - head_5_loss: 1.2561e-04 - head_6_accuracy: 1.0000 - head_6_loss: 1.6341e-04 - head_7_accuracy: 1.0000 - head_7_loss: 1.0430e-04 - loss: 0.0011 - val_head_1_accuracy: 0.9958 - val_head_1_loss: 0.0192 - val_head_2_accuracy: 0.9958 - val_head_2_loss: 0.0186 - val_head_3_accuracy: 0.9958 - val_head_3_loss: 0.0192 - val_head_4_accuracy: 0.9958 - val_head_4_loss: 0.0190 - val_head_5_accuracy: 0.9958 - val_head_5_loss: 0.0196 - val_head_6_accuracy: 0.9956 - val_head_6_loss: 0.0201 - val_head_7_accuracy: 0.9958 - val_head_7_loss: 0.0198 - val_loss: 0.1361 - learning_rate: 0.0050\n", "\n", "Epoch 100: LearningRateScheduler setting learning rate to 0.005.\n", "Epoch 100/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 61ms/step - head_1_accuracy: 1.0000 - head_1_loss: 1.8176e-04 - head_2_accuracy: 1.0000 - head_2_loss: 1.8367e-04 - head_3_accuracy: 1.0000 - head_3_loss: 1.7703e-04 - head_4_accuracy: 1.0000 - head_4_loss: 2.8434e-04 - head_5_accuracy: 1.0000 - head_5_loss: 1.8323e-04 - head_6_accuracy: 1.0000 - head_6_loss: 1.7729e-04 - head_7_accuracy: 1.0000 - head_7_loss: 3.2539e-04 - loss: 0.0015\n", "Epoch 100: val_head_1_accuracy did not improve from 0.99582\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 72ms/step - head_1_accuracy: 1.0000 - head_1_loss: 1.5195e-04 - head_2_accuracy: 1.0000 - head_2_loss: 1.4326e-04 - head_3_accuracy: 1.0000 - head_3_loss: 1.4691e-04 - head_4_accuracy: 1.0000 - head_4_loss: 1.6255e-04 - head_5_accuracy: 1.0000 - head_5_loss: 1.4226e-04 - head_6_accuracy: 1.0000 - head_6_loss: 1.5474e-04 - head_7_accuracy: 1.0000 - head_7_loss: 1.5039e-04 - loss: 0.0011 - val_head_1_accuracy: 0.9958 - val_head_1_loss: 0.0192 - val_head_2_accuracy: 0.9961 - val_head_2_loss: 0.0186 - val_head_3_accuracy: 0.9956 - val_head_3_loss: 0.0193 - val_head_4_accuracy: 0.9954 - val_head_4_loss: 0.0190 - val_head_5_accuracy: 0.9958 - val_head_5_loss: 0.0195 - val_head_6_accuracy: 0.9958 - val_head_6_loss: 0.0202 - val_head_7_accuracy: 0.9958 - val_head_7_loss: 0.0198 - val_loss: 0.1363 - learning_rate: 0.0050\n" ] }, { "output_type": "display_data", "data": { "text/plain": [ "
" ], "image/png": "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\n" }, "metadata": {} }, { "output_type": "stream", "name": "stdout", "text": [ "\n", "============================== Training GFNet_MultiHead ==============================\n" ] }, { "output_type": "display_data", "data": { "text/plain": [ "
" ], "image/png": "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\n" }, "metadata": {} }, { "output_type": "display_data", "data": { "text/plain": [ "
" ], "image/png": "iVBORw0KGgoAAAANSUhEUgAAA3UAAAGTCAYAAACPjDuWAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAdR9JREFUeJzt3Xlc1HX+B/DXDKcBA4yZiuKFcqggnqgommmKlXcrWYpHyhq65bFbaqUlpbJrGugqXpuZR6mZraF4tRoelFdWphKDCrriMTAzIPd8f3/4m1mHGWD4MsAMvJ6PRw+a73w+3/nM9G70zed4SwRBEEBEREREREQ2SVrXAyAiIiIiIiLxmNQRERERERHZMCZ1RERERERENoxJHRERERERkQ1jUkdERERERGTDmNQRERERERHZMCZ1RERERERENoxJHRERERERkQ1jUkdERERERGTDmNQREVGtGjRoEN555526Hka9lJKSAj8/Pxw6dKjGXys+Ph5+fn6i+n799dfw8/NDZmamhUclXl5eHhYtWoTQ0FD4+fnho48+qushERGZjUkdEZEN0v2l+JdffqnroTQo+fn5iI+PR0pKSl0PhSwsISEB+/btwyuvvILY2FiMHDmyRl7nwoULiI+Ph1qtrpH7E1HDZF/XAyAioobl0KFDkEgkdT0MUfLz87FmzRrMmjULISEhdT0csqCzZ8+iS5cumDVrVo2+zsWLF7FmzRqMHj0aMpmsRl+LiBoOztQREZFoJSUlKCoqqlIfR0dHODg41NCIqkbM+Kl+evjwIZMsIrJZTOqIiOqxrKwsLFiwAH379kXnzp3xwgsvYM+ePQZtioqK8Omnn2LMmDHo3r07goODMWHCBJw9e9agXWZmJvz8/LB582Z89tlnGDx4MAIDA5GWlqbfX3Xz5k2888476NGjB7p3744FCxYgPz/f4D5l99TplpKeP38ey5YtQ+/evREcHIzo6GgolUqDvlqtFvHx8ejXrx+6dOmCiRMn4o8//jBrn15F4zfnM8jMzESfPn0AAGvWrIGfnx/8/PwQHx+vb5OWloa//OUv6NWrFwIDAzFmzBgcO3bMjP9SwHfffYcxY8aga9eu6NatG1566SVs3brVoI1arcbHH3+MQYMGoXPnzggLC8Pf/vY3k5/TunXrEBYWhsDAQERGRuLmzZtGr/nzzz9j2rRp6N69O7p06YLXXnsN58+fN2p37tw5jB07FoGBgRg8eDB27dpV7uf79ddfGz1X9nMqz4kTJzBhwgQEBweja9eumDFjBlJTUw3aFBcXIy0tDffu3av0fgBw8OBBDB8+HIGBgXjxxRdx5MgRvPPOOxg0aBCA/+1DzMzMxH/+8x/9f9fMzEz9c4mJiRb5POPj4xEbGwsAeO655wxei4ioOrj8koionnrw4AH+9Kc/QSKR4NVXX4VcLsfJkyexaNEi5ObmYvLkyQCA3Nxc7N69Gy+++CJefvll5OXlYc+ePXj99dexe/duBAQEGNz366+/RmFhIf70pz/B0dER7u7u+ufeeusttGzZEnPnzsWVK1ewe/duyOVy/PWvf610vDExMZDJZJg1axZu376NrVu34sMPP8Tq1av1bVauXIlNmzbh2WefRf/+/XH16lVMmzYNhYWFZn8upsZvzmcgl8uxZMkSLFmyBEOGDMGQIUMAQH9YSGpqKl555RU0bdoU06dPx1NPPYWDBw8iOjoa8fHx+vamnDp1CnPnzkWfPn0wf/58AIBCocCFCxcQGRkJ4PFBHq+++irS0tIwduxYdOzYEdnZ2Th+/DiysrIgl8v199u4cSMkEgmmTp2K3NxcbNq0CfPnz8fu3bv1bc6cOYPp06ejc+fOmDVrFiQSCb7++mtERkZix44dCAoKAgBcu3YN06ZNg1wux+zZs1FSUoL4+Hg0btzY7M/cHN988w3eeecd9OvXD/Pnz0d+fj527tyJCRMmYN++fWjZsiWAx7+oGD58OEaPHo3ly5dXeM///Oc/mDNnDnx9fTFv3jyoVCosWrQITZs21bfx8fFBbGwsli1bhmbNmmHKlCkAALlcjtu3b1v08xwyZAhu3LiBAwcOYMGCBfD09NS/FhFRtQhERGRz9u7dK/j6+gqXL18ut83ChQuF0NBQQalUGlyfM2eO0L17dyE/P18QBEEoKSkRCgsLDdqoVCqhb9++woIFC/TXMjIyBF9fX6Fbt27Cw4cPDdrHxcUJvr6+Bu0FQRCio6OFXr16GVx79tlnhbffftvovUyePFnQarX66x9//LEQEBAgqNVqQRAE4f79+0LHjh2FN954w+B+8fHxgq+vr8E9Talo/OZ+Bg8fPhR8fX2FuLg4o/tHRkYKL774osF9tFqtMH78eOH555+vcGwxMTFCt27dhJKSknLbfPrpp4Kvr69w+PBho+d0n9vZs2cFX19fITw83GAcW7duFXx9fYVr167p2z///PPC1KlTDT7z/Px8YdCgQcKUKVP019544w0hMDBQuH37tv7aH3/8IQQEBAi+vr76a7rPd+/evUbjK/uZ6f6bZ2RkCIIgCLm5uUKPHj2Ed99916Df/fv3he7duxtc171OZf+9BUEQXnzxRSEsLEzIzc3VX0tJSRF8fX2FZ5991qDts88+K8yYMcPgWk18nps2bTJ470RElsDll0RE9ZAgCDh8+DAGDRoEQRCgVCr1//Tr1w8ajQa//fYbAMDOzg6Ojo4AHi/by8nJQUlJCTp37owrV64Y3fv5558vd2YhIiLC4HGPHj2Qk5OD3NzcSsesm1V8sm9paal+tuTMmTMoKSnBhAkTDPq99tprld67svFX9TMoKycnB2fPnkV4eDhyc3P1n3V2djb69euHGzduICsrq9z+MpkM+fn5OHXqVLltDh8+DH9/f5MzfmUPnhkzZoz+/QCPP0sAyMjIAAD8/vvvuHHjBl566SVkZ2frx/vo0SP06dMHP/30E7RaLUpLS5GcnIzBgwfDy8tLfz8fHx/069ev0s/FXKdPn4ZarcYLL7xgEKtSqRRdunQxOG20ZcuWuHbtWqWzdFlZWbh+/TpGjRoFFxcX/fVevXrB19e3SuOz1OdJRFRTuPySiKgeUiqVUKvV+PLLL/Hll1+W20Zn37592LJlC9LT01FcXKy/rlvy9iRT13Se/Is/AP3BEyqVCq6urhWOuby+uqPf79y5AwBo1aqVQTsPDw+DJaCVKW/8VfkMyrp16xYEQcCnn36KTz/91GSbhw8fGiz7e9KECRNw8OBBTJ8+HU2bNkVoaCjCw8MRFhZm8BrPP/98pWMBKv8sb9y4AQB4++23y72HRqNBUVERCgoK0Lp1a6Pn27ZtixMnTpg1nsroxqNbalpWZbFjSnnxAgCtW7c2K1nXsdTnWZU4JSKqCiZ1RET1kG5WYMSIERg9erTJNrq9YPv378c777yDwYMHY9q0aWjcuDHs7OyQkJCgn4l4krOzc7mvK5WaXgAiCEKlY65O36owNf6qfgZl6T7vqVOnon///ibbmEoudBo3boxvvvkGycnJOHnyJE6ePImvv/4ao0aNwooVK8x8Z/9T2Wep+/m3v/3NaM+kzlNPPVWlk0HLK1NRWlpaaV/deGJjY9GkSROj5+3s7MweR02w1OdJRFRTmNQREdVDcrkcLi4u0Gq16Nu3b4Vtk5KS4O3tjTVr1hj8xTwuLq6mh1klutmSW7duwdvbW389OzsbKpWqWvc29zMoL3HRjcfBwaHSz7s8jo6OGDRoEAYNGgStVoslS5bgyy+/xBtvvIHWrVujVatWRidBiqUbr6ura4XjlcvlcHZ2NnnSY3p6usFj3SxU2aLauhkzc8bTuHFj0Z9fWU/GS1mm3k91mPt5AuXHEBFRdXBPHRFRPWRnZ4ehQ4ciKSkJ169fN3r+yaWXulmQJ2fEfv75Z1y6dKnGx1kVffr0gb29PXbu3Glwffv27dW+t7mfQaNGjQAYJy6NGzdGr1698OWXX5o8ar9syYGysrOzDR5LpVL9TKputuz555/H1atXceTIEaP+VZ3N7Ny5M1q1aoUtW7YgLy+v3PHa2dmhX79+OHr0qEFylpaWhuTkZIM+rq6u8PT0xLlz5wyu79ixo9Lx9O/fH66urkhISDBY+lp2PID5JQ2aNm0KX19ffPPNNwbv8ccffzT5/0R1mPt5Av+LIY1GY9ExEFHDxpk6IiIbtnfvXvzwww9G1ydNmoR58+YhJSUFf/rTn/Dyyy+jffv2UKlU+O2333DmzBn8+OOPAICBAwfi8OHDiI6OxsCBA5GZmYldu3ahffv2ePToUW2/pXI9/fTTmDRpErZs2YI///nP6N+/P65du4aTJ0/C09OzWjMg5n4Gzs7OaN++PQ4ePIg2bdrAw8MDHTp0gK+vLxYvXowJEybgpZdewp/+9Cd4e3vjwYMHuHTpEu7evYtvv/223Nd/9913oVKp0Lt3bzRt2hR37tzBF198gYCAAPj4+AAApk2bhqSkJLz55psYO3YsOnXqBJVKhePHj+ODDz6Av7+/2e9XKpUiJiYG06dPx4svvogxY8agadOmyMrKQkpKClxdXbF+/XoAwOzZs/HDDz/g1VdfxSuvvILS0lJ88cUXaN++Pa5du2Zw35dffhkbNmzAokWL0LlzZ5w7d85oRs8UV1dXLFmyBH/7298wZswYDB8+HHK5HHfu3MGJEyfQrVs3vP/++wCqVtJgzpw5eOONN/DKK69gzJgxUKvV2L59O3x9fU0mX2JV5fPs1KkTAGDVqlUYPnw4HBwc8Oyzz3J5JhFVC5M6IiIbVnbWSmfMmDFo1qwZdu/ejbVr1+LIkSPYuXMnPDw80L59e30tNF3bBw8e4Msvv0RycjLat2+Pv//97zh06JA+8bMW8+fPh7OzM3bv3o0zZ84gODgYmzdvxoQJEwxOJ6yqqnwGMTExWLp0KZYtW4bi4mLMmjULvr6+aN++Pfbu3Ys1a9Zg3759yMnJgVwuR8eOHREdHV3h648YMQJfffUVduzYAbVajSZNmiA8PByzZ8/W7+dycXHB9u3bER8fjyNHjmDfvn1o3Lgx+vTpU+4BLBUJCQnBl19+iX/+85/44osv8OjRIzRp0gRBQUEYP368vp2/vz82b96MZcuWIS4uDs2aNcPs2bNx//59o6ROVzA+KSkJBw8eRFhYGDZt2qQv2l6Rl156Cc888ww2bNiAzZs3o6ioCE2bNkWPHj0wZsyYKr8/4HGh+08++QTx8fFYuXIl2rRpg2XLluGbb76x2FJWHXM/z6CgILz55pvYtWsXfvjhB2i1Whw7doxJHRFVi0Sw9A50IiKiWqRWq9GzZ0+89dZbmDlzZl0Ph2zAyJEjIZfL8a9//auuh0JEZBHcU0dERDajoKDA6NrWrVsBPK4/RvSk4uJilJSUGFxLSUnB1atXGS9EVK9w+SUREdmMxMRE7Nu3D2FhYXjqqadw4cIFHDhwAP369UP37t3renhkZbKysjBlyhSMGDECzzzzDBQKBXbt2oUmTZogIiKirodHRGQxTOqIiMhm+Pn5wc7ODps2bUJeXh4aN26MSZMm4a233qrroZEVcnd3R6dOnbB7924olUo89dRTGDBgAObPnw9PT8+6Hh4RkcVwTx0REREREZEN4546IiIiIiIiG8akjoiIiIiIyIYxqSMiIiIiIrJhPCjFCgmCAK3WOrY6SqUSqxkL2Q7GDYnF2CExGDckBuOGxKrN2JFKJZBIJJW2Y1JnhbRaAUplXl0PA/b2Unh6ukCtfoSSEm1dD4dsBOOGxGLskBiMGxKDcUNi1XbsyOUusLOrPKnj8ksiIiIiIiIbxqSOiIiIiIjIhjGpIyIiIiIismFM6oiIiIiIiGwYkzoiIiIiIiIbxqSOiIiIiIjIhlllUpeWloYpU6YgODgYoaGhiI2NRVFRUaX9BEHAhg0bMHDgQAQFBWH8+PG4dOmSUbusrCzMnj0bXbt2Ra9evbBo0SLk5uYatTt+/DhGjBiBwMBADB06FHv37i13vNHR0ejZsyeCg4MxatQonDp1qsrvm4iIiIiIqKqsLqlTqVSIjIxEcXEx4uPjMWfOHHz11VdYvnx5pX03btyIuLg4TJ48GQkJCWjSpAmmTp2KjIwMfZvi4mK8/vrruHHjBlauXIklS5YgOTkZ8+bNM7jXuXPnMGvWLAQHB2Pjxo0IDw/HokWLcOjQIYN2qampGD9+PBwcHPD3v/8da9euxfDhw5Gfn2+ZD6SOaLUCfr+hxIkLmfj9htKgwKJWK+DqzWycvXIXV29ms3AnEREREVEdsrri47t27UJeXh7WrFkDDw8PAEBpaSk++OADREVFoWnTpib7FRYWIiEhAVOnTsXkyZMBAN27d8ewYcOwefNmLFmyBACQlJSE1NRUJCYmol27dgAAmUyGadOm4fLlywgKCgIArFu3DkFBQfjwww8BAL1790ZGRgbi4uIwbNgw/esuXrwY/fr1w+rVq/XXQkNDLfiJ1L7z1+5hx9FUZGsK9dc83ZwwYXAHACj3ue5+z0CrFXA9Iwc5eYXwcHGCr7cHpNLHBRMres6c54mIiIiIyJjVJXUnT55Enz599AkdAISHh2Px4sU4deoUxowZY7LfhQsXkJubi/DwcP01R0dHDBkyBEeOHDG4v5+fnz6hAx4nYR4eHjhx4gSCgoJQVFSElJQUzJ8/3+A1hg8fjgMHDiAzMxMtW7ZEWloazp8/jx07dljo3de989fuYe2+X42uZ2sKTV5/8rlhvbyR8vs9UclgRYlkZckiEREREVFDZnVJnUKhwNixYw2uyWQyNGnSBAqFosJ+AAySNQDw8fHB1q1bUVBQAGdnZygUCqM2EokEbdu21d/j1q1bKC4uNnkv3Wu1bNkSP//8MwDg0aNHGD16NK5du4ZnnnkGEydOxLRp00S8+7ql1QrYcTRVdP9DP2YYXTM3Gayob0XJIhM+IiIiImrorC6pU6vVkMlkRtfd3d2hUqkq7Ofo6AgnJyeD6zKZDIIgQKVSwdnZGWq1Gm5ubhXeX/ez7Dh0j3XPP3jwAAAwf/58TJ48GW+//TaSk5Px97//HS4uLoiIiDD3bRuxt6/97Y6/31AaJE61Jekn44TuSRUlfOF9WiPl17tQPjFuuZsTXh3qh57+jxO+a7eykZNbBA9XR/i18mTCV8Ps7KQGP4nMxdghMRg3JAbjhsSy1tixuqTOlmi1WgDAqFGjMHPmTACP997dvXsX69evF53USaUSeHq6WGyc5ipOz6711wQAoRrnrBw8c9PomlJTiPg9lzFmoA9OXLyNh6oC/XON3Z0xY1Qg+gZ5oVQr4IriIZTqAshlzujYrjHsmPBZjEzWqK6HQDaKsUNiMG5IDMYNiWVtsWN1SZ1MJoNGozG6rlKp4O7uXmG/oqIiFBYWGszWqdVqSCQSfV+ZTGayfIFKpULz5s0BQN+27DjUarXB87qZu969exu069OnD/79738jNzcXrq6uFb9hE7RaAWr1oyr3qy4HSf06xfLr/6QZXXuoKsCyrT9xhq8G2dlJIZM1glqdj9JSbV0Ph2wIY4fEYNyQGIwbEqu2Y0cma2TWrKDVJXXt2rUz2jun0Whw//59oz1uZfsBQHp6Ovz9/fXXFQoFvLy84OzsrG93/fp1g76CICA9PV1/amWrVq3g4OAAhUKB/v37G9zrydfq0KFDhe/FnNp65Skpqf0vGB8vd3i6OdXJEszaVtEMH/fwWUZpqbZO4phsH2OHxGDckBiMGxLL2mLHuhaDAggLC8Pp06f1s2IAcOjQIUil0gpLBXTr1g2urq44ePCg/lpxcTEOHz6MsLAwg/tfvXoVN27c0F87c+YMcnJyMGDAAACPT80MCQlBUlKSwWskJibCx8cHLVu2BAAEBwfDw8MDp0+fNmh3+vRpeHl5QS6XV/0DqENSqUR/UmVtklhZPnToxwyjxFa3h++r46n467rTiN15ERu+vYLYnRfx13Wncf7avToaLRERERE1dFaX1EVERMDFxQXR0dFITk7G3r17ERsbi4iICIMadZGRkRgyZIj+sZOTE6KiorBlyxZs3boVZ86cwbx585CTk2NwEuXQoUPRoUMHzJ49G99//z0SExOxcOFCDBw4UF+jDgBmzpyJS5cuYcmSJUhJSUFcXBwOHDiA2bNn69s4ODhg9uzZ2LFjB9asWYPTp09jxYoV+O677/DGG2/U8CdVM7r7PYPo0Z3h6WZ44IzczQnRozuX+9ywXt6iX3NoT/F9a1tFCd/5a/dYmJ2IiIiIap1EEKpzTEXNSEtLw9KlS3Hx4kW4uLhg5MiRmDNnDhwdHfVtJk6ciNu3b+P48eP6a4IgYMOGDdixYweUSiUCAgKwYMECdO3a1eD+WVlZiImJQXJyMuzt7TFkyBAsXLjQaP/bsWPHsHr1aqSnp8PLywszZszAuHHjjMa7bds2bN26FXfv3kWLFi3w+uuv4+WXXxb9/ktLtVAq80T3twStVkDaHRWKBQkcJAJ8vNwrLSJuqtac3M0Jr5RTp073XHl16uRuTugV8IzJ0y+tkauzPRwc7Mpdtgk0jALr9vZSeHq6IDs7z6qWJZD1Y+yQGIwbEoNxQ2LVduzI5S5m7amzyqSuobOGpA4QF7QVJS2VJTRVTRZtKeGLHt0ZQMUF2OsL/kFJYjF2SAzGDYnBuCGxmNSR2Ww5qasptp7wuTrbI7egpNzno0d3RtcOTerFLJ41xQ3ZFsYOicG4ITEYNySWtSZ1Vnf6JZEpUqkE/q09ja5393um3GTIp4W71SR8FSV0ALD14NUGMYtHRERERJbHpI5snq0nfMD/J31lEj/dASz1aRaPiIiIiCyPSR3Va/Uh4eMsHhERERFVhEkdNViWSvg8XR1RVKJFXiVLLMXiLB4RERERVYRJHZEJVU34Lqbex9p9v5Z7Pxdn+xpJ+jiLR0RERERWV3ycyNrpEr7eHZvBv7UnpFJJpUXbJ4f718hYcgtKWAydiIiIqIHjTB2RhVS0bBN4XLagNpduchaPiIiIqGFgUkdkQeUt2wTEL90Ui3vxiIiIiBoGJnVEtchU0qdbuslZPCIiIiISg0kdkRXgLB4RERERicWkjshKcBaPiIiIiMRgUkdk5axtFo+JHREREZF1YUkDIhtQlTIKnq6OcHGumd/X7DyaipISLcskEBEREVkRztQR2bDansVTagoxb+0paPKL9de4NJOIiIiobnGmjsjG1fYs3pMJHWBY7JyIiIiIah9n6ojqqdqexdt5NBVdfJ5GamYOitOz4SAR4OPlzlMziYiIiGoYkzqieqw2T9Tk0kwiIiKiusGkjqgBqqlZvPKWZupOzdRqBda/IyIiIrIwJnVEDVRVZvHcGjkYJWxVsfNoKrQCsOsY698RERERWZpEEASeR25lSku1UCrz6noYsLeXwtPTBdnZeSgp0db1cKgWlZ1Ra9/CHW8nnDFIyCyJ9e8I4HcOicO4ITEYNyRWbceOXO4CO7vKz7bk6ZdEZKTsiZr29lJMGNyhxl6P9e+IiIiIxOPySyIyS00tzQR4yAoRERFRdTCpIyKzmTpgxVJLMys7ZIWIiIiITOPySyKqEi7NJCIiIrIunKkjomorb2mm3M0J459rj13H/hA9k8elmUREREQVY1JHRBahW5qZdkeFYkECB4kAHy93SKUSSCWSGq1/R0RERNSQcfklEVmMVCpBQBs5BnRriYA2cn1hcd1Mnqebk0F7t0YO1Xo9Ls0kIiIi4kwdEdWSmjhkhUsziYiIiDhTR0S1qCYOWSlvaeb5a/eqdV8iIiIiW8GkjojqFJdmEhEREVUPl18SUZ3j0kwiIiIi8ThTR0RWgUsziYiIiMRhUkdEVotLM4mIiIgqZ5XLL9PS0hATE4OLFy/CxcUFI0eOxFtvvQVHR8cK+wmCgI0bN2LHjh1QKpUICAjAggULEBwcbNAuKysLMTExSE5OhoODA4YMGYIFCxbA1dXVoN3x48exevVqpKenw8vLCzNmzMDYsWMN2vj5+RmN4+mnn8apU6fEvXkiMsClmUREREQVs7qkTqVSITIyEm3atEF8fDyysrKwfPlyFBQU4P3336+w78aNGxEXF4f58+fDz88P27dvx9SpU7F//354e3sDAIqLi/H6668DAFauXImCggKsWLEC8+bNQ0JCgv5e586dw6xZszBu3DgsXLgQZ8+exaJFi+Di4oJhw4YZvO7EiRPx4osv6h87OFRvFoGIDOmWZj5pwuAOLGhOREREBCtM6nbt2oW8vDysWbMGHh4eAIDS0lJ88MEHiIqKQtOmTU32KywsREJCAqZOnYrJkycDALp3745hw4Zh8+bNWLJkCQAgKSkJqampSExMRLt27QAAMpkM06ZNw+XLlxEUFAQAWLduHYKCgvDhhx8CAHr37o2MjAzExcUZJXXNmzc3mg0kopqlW5q542iqwYydWyMHo4StKnYeTUXXDk30hdOJiIiIrJ3V7ak7efIk+vTpo0/oACA8PBxarbbCJY0XLlxAbm4uwsPD9dccHR0xZMgQnDx50uD+fn5++oQOAEJDQ+Hh4YETJ04AAIqKipCSkmKUvA0fPhxpaWnIzMys7tskIgvo7vcM/j6zL/72SlfMGNERf3ulK1ZGhxrtwasKpaYQV29mc78dERER2Qyrm6lTKBRG+9ZkMhmaNGkChUJRYT8ABskaAPj4+GDr1q0oKCiAs7MzFAqFURuJRIK2bdvq73Hr1i0UFxebvJfutVq2bKm/vmHDBnzyySdo1KgR+vXrh7/97W/w8vKq4jsnIjFqYmnmuv2/Iq+gRP+Y++2IiIjImlldUqdWqyGTyYyuu7u7Q6VSVdjP0dERTk6Gv6GXyWQQBAEqlQrOzs5Qq9Vwc3Or8P66n2XHoXv85DhGjRqFgQMH4umnn8b169exbt06TJgwAfv374e7u7uZ79qYvX3dT6La2UkNfhKZwxriJqRTM0jtpNiedA3KJ5dmPuUAzaPKl2Y+mdAB/9tvN3tcEHr6M7GrKdYQO2R7GDckBuOGxLLW2LG6pM7WrFixQv/vPXv2RPfu3TFmzBh89dVXmD59uqh7SqUSeHq6WGqI1SaTNarrIZANquu4eb5PWzwX0gZXFA+hVBdALnOGXxs5Znx8BA9VBaLuufNoKgb2bI1rN5T6e3Zs1xh23H9nUXUdO2SbGDckBuOGxLK22LG6pE4mk0Gj0RhdV6lUFc58yWQyFBUVobCw0GC2Tq1WQyKR6PvKZDLk5uaavH/z5s0BQN+27DjUarXB86b4+/ujbdu2+O2338ptUxmtVoBa/Uh0f0uxs5NCJmsEtTofpaXauh4O2Qhri5uWjRuhZePHX7x5mnxMGOKL+D2XRd3rQU4+Jn9wyGC2T+7mhFeH+nEGzwKsLXbINjBuSAzGDYlV27EjkzUya1bQ6pK6du3aGe2d02g0uH//vtEet7L9ACA9PR3+/v766wqFAl5eXnB2dta3u379ukFfQRCQnp6O0NBQAECrVq3g4OAAhUKB/v37G9zrydeqSSUl1vMFU1qqtarxkG2w1rjp2v5pk6dmujjbGy27NKXs8k2lphDxey6zFIIFWWvskHVj3JAYjBsSy9pix7oWgwIICwvD6dOn9bNiAHDo0CFIpVJ90mVKt27d4OrqioMHD+qvFRcX4/DhwwgLCzO4/9WrV3Hjxg39tTNnziAnJwcDBgwA8PjUzJCQECQlJRm8RmJiInx8fAwOSSnr999/R3p6OgIDA81+z0RUu0ydmjlzVOdq3XPn0VSUlGh5aiYRERHVOqubqYuIiMC2bdsQHR2NqKgoZGVlITY2FhEREQY16iIjI3Hnzh0cOXIEAODk5ISoqCjEx8dDLpfD19cXO3fuRE5ODqZNm6bvN3ToUCQkJGD27NmYO3cu8vPzERsbi4EDB+pr1AHAzJkzMWnSJCxZsgTh4eFISUnBgQMHsGrVKn2bzZs349atWwgJCYFcLkdqairWr1+PZs2a4eWXX66FT4uIxCp7aqZWK8DTzclg9q4qlJpCzFt7yqBGHk/NJCIiotogEQTB6n6VnJaWhqVLl+LixYtwcXHByJEjMWfOHDg6OurbTJw4Ebdv38bx48f11wRBwIYNG7Bjxw4olUoEBARgwYIF6Nq1q8H9s7KyEBMTg+TkZNjb22PIkCFYuHAhXF1dDdodO3YMq1evRnp6Ory8vDBjxgyMGzdO//zx48eRkJCA9PR05OXlwdPTE2FhYXjrrbfwzDPi/xJXWqqFUpknur+l2NtL4enpguzsPKuaXibrZstxc/7avWqVQigPl2aax5Zjh+oO44bEYNyQWLUdO3K5i1l76qwyqWvomNSRLbP1uDl/7Z7Rfju3Rg4GM3BVJXdzQuzMvpDylMwK2XrsUN1g3JAYjBsSy1qTOqtbfklEVJe6+z2Drh2a4HpGDnLyCuHh4oT2LdzxdsKZai3NvJ6RA19vD4P7+np7MNEjIiKiamNSR0RURtn9dgAwYXCHai3NvJh6HxsPXDFIDLnnjoiIiCzB6k6/JCKyRt39nkH06M7wdHMyuO7WyMGs/kfOZRrN9GVrCrF23684f+2excZJREREDQ9n6oiIzFQTSzOBx+UQunZowqWYREREJAqTOiKiKqiJpZlKTSGu3syGVCrhfjsiIiKqMiZ1RETVpFuaWfbUTLmbE7r7NcGRc5mV3mPd/l+RV1Cif8z9dkRERGQuJnVERBZgammm7rRLc5K6JxM64H/77VjjjoiIiCrDpI6IyEJMLc309faAp5uT6D13O4+moovP0/jjtopLM4mIiMgkJnVERDVIKpVUa8+dUlOIeWtPGRQ/59JMIiIiehJLGhAR1bDyyiG4OJv3e7UnEzqApRCIiIjIEGfqiIhqgak9d1pBwD92XRJ9T5ZCICIiIoBJHRFRrSm7506rFaq1346lEIiIiAhgUkdEVGequ98OYCkEIiIi4p46IqI6Vd5+O7dGDmb1L68UAvfbERERNRycqSMiqmOm9tu1b+GOtxPOVKsUAvfbERERNQxM6oiIrICpGnfVLYXA/XZEREQNA5M6IiIrpVuaueNoqsGMnYuzvdGyS1O4346IiKhhYFJHRGTFqlMKobz9dtGjOzOxIyIiqkeY1BERWTlLl0LgfjsiIqL6hadfEhHZGF0pBLF0++2u3szG2St3cfVmNrRawYIjJCIiotpU7Zm6P/74AwqFAo8ePcKoUaMsMCQiIqoM99sRERGRjuik7vLly3jvvfdw/fp1/TVdUvfTTz/h9ddfxyeffILnnnuu2oMkIiJj3G9HREREgMjll6mpqYiMjERmZiYmT56MsLAwg+d79OgBT09PHDp0yCKDJCIi03T77Xp3bAb/1p7wb+VpVMi8KnYeTeVSTCIiIhsjKqmLj48HAHz99dd4++23ERgYaPC8RCJBcHAwfvnll+qPkIiIzMb9dkRERA2PqOWXP/74I4YOHYrWrVuX26Z58+b44YcfRA+MiIjE4X47IiKihkVUUpeXlwe5XF5hm8LCQmi1WlGDIiKi6uF+OyIiooZDVFLXvHlzgwNSTLly5Qq8vb1FDYqIiKqP9e2IiIgaBlF76gYOHIhTp07h9OnTJp9PTEzEpUuXMHjw4GoNjoiILIf77YiIiOonUTN1f/7zn5GUlIQZM2Zg1KhRePDgAQBg+/btuHTpEr777ju0aNECU6ZMsehgiYioerjfjoiIqP6RCIIg6tesGRkZ+Otf/4pLly4ZPdelSxesXLkSLVu2rO74GqTSUi2Uyry6Hgbs7aXw9HRBdnYeSkq4P5LMw7ixDVqtIGq/XXkssd+OsUNiMG5IDMYNiVXbsSOXu8DOrvLFlaKLj3t7e2PXrl34/fffcenSJahUKri6uiIoKAhBQUFib0tERLWA++2IiIjqD9FJnU5AQAACAgIsMRYiIqojuv12a/f9Kqq/UlOI6xk58PX2MJgB9PX2YKJHRERUw0Qldc899xwiIyMxadKkctts374dW7ZswbFjx0QPjoiIak9199tdTL2PjQeuGPTlnjsiIqKaJyqpu337NtRqdYVt1Go17ty5I2pQRERUN6pT3+7IuUyja6xxR0REVPNElTQwh0ajgaOjo6i+aWlpmDJlCoKDgxEaGorY2FgUFRVV2k8QBGzYsAEDBw5EUFAQxo8fb/Igl6ysLMyePRtdu3ZFr169sGjRIuTm5hq1O378OEaMGIHAwEAMHToUe/furfD1P/roI/j5+eHDDz80+70SEVkb3X673h2bwb+1J/xbecLTzala99x5NJXlD4iIiGqI2TN1P/30k8Hj27dvG10DgNLSUty9exf//ve/0aZNmyoPSKVSITIyEm3atEF8fDyysrKwfPlyFBQU4P3336+w78aNGxEXF4f58+fDz88P27dvx9SpU7F//359IfTi4mK8/vrrAICVK1eioKAAK1aswLx585CQkKC/17lz5zBr1iyMGzcOCxcuxNmzZ7Fo0SK4uLhg2LBhRq997do17N27F66urlV+z0RE1qy6++2A/9W4k0ol3G9HRERkYWYndRMnToRE8vgPX4lEgm+++QbffPONybaCIEAikWDevHlVHtCuXbuQl5eHNWvWwMPDA8DjRPGDDz5AVFQUmjZtarJfYWEhEhISMHXqVEyePBkA0L17dwwbNgybN2/GkiVLAABJSUlITU1FYmIi2rVrBwCQyWSYNm0aLl++rD+5c926dQgKCtLPuvXu3RsZGRmIi4szmdQtXboUkydPLvczISKyZeXtt5O7OaG7XxOTSy/LYo07IiKimmF2UhcdHQ2JRAJBELB27Vr07NkTISEhRu2kUinc3d3Ru3dv+Pj4VHlAJ0+eRJ8+ffQJHQCEh4dj8eLFOHXqFMaMGWOy34ULF5Cbm4vw8HD9NUdHRwwZMgRHjhwxuL+fn58+oQOA0NBQeHh44MSJEwgKCkJRURFSUlIwf/58g9cYPnw4Dhw4gMzMTIMafN9++y0yMzOxceNGJnVEVG+Z2m+nO+3SnKSu7GEr3G9HRERkGWYndbNnz9b/+48//oixY8di1KhRFh+QQqHA2LFjDa7JZDI0adIECoWiwn4ADJI1APDx8cHWrVtRUFAAZ2dnKBQKozYSiQRt27bV3+PWrVsoLi42eS/da+mSutzcXMTGxmLhwoVo1KiRiHdMRGQ7yta3AwBfbw+L1LgjIiIicUSdfrlt2zZLj0NPrVZDJpMZXXd3d4dKpaqwn6OjI5ycDDfzy2QyCIIAlUoFZ2dnqNVquLm5VXh/3c+y49A9fnIca9asQevWrTF8+HAz36F57O1r7Awbs+mq15tTxZ5Ih3HTML021A/xey6L6qvUFCLtjgqdfZ4GwNihquF3DonBuCGxrDV2ql18vCFLTU3F9u3b8dVXX1n0vlKpBJ6eLha9Z3XIZJyBpKpj3DQsz/dpC1cXJ2z45hc8VBXor7s95QDNo+JK+xeWAjfv5UH5x0PIZc7o2K4x7HiIClUBv3NIDMYNiWVtsSM6qfvvf/+LdevW4fTp07h37x6Ki43/0JZIJLhy5UqV7iuTyaDRaIyuq1QquLu7V9ivqKgIhYWFBrN1arUaEolE31cmk5ksX6BSqdC8eXMA0LctOw5dbT7d88uXL8ewYcPQokUL/XNarRbFxcVQq9VwdXWFVFr1LF6rFaBWP6pyP0uzs5NCJmsEtTofpaXauh4O2QjGTcMV4O2OldGhuHYrGzm5RfBwdYRWAFZsv1Bp3437fzFI/uRuTnh1qB96+nOvHVWM3zkkBuOGxKrt2JHJGpk1KygqqcvIyMDLL78MtVqN9u3bo6ioCF5eXnByckJGRgZKSkrg7+9vcpljZdq1a2e0d06j0eD+/ftGe9zK9gOA9PR0+Pv7668rFAp4eXnB2dlZ3+769esGfQVBQHp6OkJDQwEArVq1goODAxQKBfr3729wr7KvlZycjG+//dbgfl999RW++uorJCYmijosBgBKSqznC6a0VGtV4yHbwLhpuDq09ND/u1YrmLXfruxsnlJTiPg9l3mICpmN3zkkBuOGxLK22BG1GHTNmjXIzc3FZ599pk9oxowZg4MHD+L48eMYNGgQ8vPzERcXV+V7h4WF4fTp0/qZLwA4dOgQpFKpPukypVu3bnB1dcXBgwf114qLi3H48GGEhYUZ3P/q1au4ceOG/tqZM2eQk5ODAQMGAHh8amZISAiSkpIMXkOXpOkOSfnkk0/w+eefG/zz9NNPY/Dgwfj888/h5eVV5fdPRFSf6GrcicWi5URERJUTldSdPn0aYWFh6NWrl9FzzzzzDFavXg0AWLVqVZXvHRERARcXF0RHRyM5ORl79+5FbGwsIiIiDGrURUZGYsiQIfrHTk5OiIqKwpYtW7B161acOXMG8+bNQ05ODqZNm6ZvN3ToUHTo0AGzZ8/G999/j8TERCxcuBADBw7U16gDgJkzZ+LSpUtYsmQJUlJSEBcXhwMHDhicAhocHIyQkBCDf5ycnNC0aVOEhITwNEwiIvyvxp2nm+FBVm6NHCrtqytafvVmNs5euYurN7OZ5BEREZUhavlldna2wVJIe3t75Ofn6x87Ojqib9++OHr0aJXv7e7ujq1bt2Lp0qWIjo6Gi4sLxo0bhzlz5hi002q1KC0tNbg2ffp0CIKALVu2QKlUIiAgAJs3b4a3t7e+jYODAzZt2oSYmBjMnTsX9vb2GDJkCBYuXGhwrx49eiA+Ph6rV6/Gnj174OXlhZiYGIM6eEREZB5TNe6yNYXYeKDyfdcsWk5ERFQxUUmdp6enQRLn4eGB27dvG7Sxs7MzeeCJOXx8fPDZZ59V2MZUWQWJRIKoqChERUVV2Ldp06aIj4+vdBzPPfccnnvuuUrbPen48eNVak9E1FCUrXF39Wa2Wf1YtJyIiKhiopZftmnTBrdu3dI/DgoKQnJyMjIyMgAASqUSSUlJBjNkRERET9IVLReL++2IiIgeE5XU9e/fHykpKfrDTCIjI5GXl4cRI0Zg7NixGDp0KB48eICJEydadLBERFR/VPcQFe63IyIiekwiCEKV/wTMzc1FWloafHx84OrqCgA4ePAg1qxZg4yMDHh5eWHixIl49dVXLT7ghqC0VAulMq+uhwF7eyk8PV2QnZ1nVUe2knVj3FBVnb92DzuOphqUPXBxtjdadmlK2Xbcb9fw8DuHxGDckFi1HTtyuYtZdepEJXVUs5jUkS1j3JAYWq2AtDsqFAsSOEgEFJdo8Y9dl0Tfj/vtGg5+55AYjBsSy1qTOlHLL82h1Wrx9ddf19TtiYioHpFKJQhoI8eAbi0R0EYO/1ae3G9HRERkphpJ6r799luEh4dj0aJFNXF7IiKq5yyx3+56Ro7lBkRERGTFqlTSIDs7G9u3b8evv/4Ke3t79OjRAxEREXB2dgYAHDt2DJ988gkUCgUAGBQHJyIiqgpd0XKx++2UuQW4ejNbXxfP19sDUqmkJodMRERUJ8xO6h48eICXX34Zd+/ehW4b3rFjx3DkyBF89tlnePfdd/Htt98CAAYPHozo6Gj4+/vXzKiJiKhBMFW0XCsIZu23+/LoH9DkF+sf8xAVIiKqr8xO6tavX4///ve/GDBgAEaPHg0A2Lt3L5KTkzF58mScP38ePXv2xKJFi5jMERGRxZQtWq7VCvB0czKYvTPlyYQOYNFyIiKqv8xO6n744Qe0b98eCQkJ+mtDhw7Fiy++iAsXLmDUqFFYvnx5jQySiIhIR7ffbu2+X0X133k0FV07NOFSTCIiqjfMPijl7t276N27t8E1iUSCPn36AABmzZpl2ZERERGVQ7ffruwJmW6NHCrty6LlRERU35g9U1dYWAgPDw+j67prLVu2tNSYiIiIKmVqv122phAbD1yptO+6/b+yaDkREdUbNVanjoiIqKbp9tv17tgM/q3Nr21X9vRM3X6789fu1cQwiYiIalSVShpcuHABGzduNLh2/vx5AMCmTZv0p2I+afr06dUYHhERkfl8vT3MOkSlPNxvR0REtqhKSd3p06dx+vRpk8/94x//MLomkUiY1BERUa2p7iEquv12UqmE9e2IiMhmmJ3ULVu2rCbHQUREZBHVLVrO/XZERGRrzE7qdLXpiIiIrF11ipaXt9+O9e2IiMhaVWn5JRERka0QW7S8PNxvR0RE1oqnXxIRUYOg228nllJTiOsZOZYbEBERkYUwqSMiogajvKLlLs7mLVxR5hawaDkREVkdLr8kIqIGpTr77XYd/QO5+cX6xzxEhYiIrAGTOiIianDE7rd7MqEDeIgKERFZBy6/JCKiBq+6++12Hk3lUkwiIqozTOqIiIhQ/n47t0YOlfbVHaKi1Qrcc0dERLWOyy+JiIj+n6n9dtmaQmw8cKXSvhdT72PjgSsGSzi5546IiGqDqKRu0qRJlbaRSqVwdXVF27ZtMXjwYHTp0kXMSxEREdWqsvvtrt7MNqvfkXOZRte4546IiGqDqKTuxx9/BABIJBIIgvHSkrLXN23ahDFjxuCjjz4SOUwiIqK64evtUa2i5QALlxMRUc0Stafu8uXLePbZZ+Hj44OVK1fi+++/x+XLl/H9999j5cqVaN++PQYNGoQTJ05gy5Yt6NixI77++mvs2LHD0uMnIiKqUdU9RAVg4XIiIqpZopK6uLg4XL9+HV999RVeeOEFNG/eHI6OjmjevDleeOEFfPnll7h27Rq2bduGvn374l//+hfkcjm+/vprS4+fiIioxpV3iIrczQlDerQ06x4sXE5ERDVF1PLLAwcOIDw8HE899ZTJ55966ik8//zz+O677zB//nzIZDL0798fSUlJ1RosERFRXTF1iIqvtweuZ+SY3E9X1pdH/4CGhcuJiKgGiJqpUyqVKC4urrBNSUkJHj58qH/cpEkTaLVaMS9HRERkFXSHqPTu2Az+rT0hlUr0e+4qoymncPn5a/dqarhERNRAiErqWrVqhUOHDiE72/SJYNnZ2Th48CBatWqlv3bv3j24u7uLGyUREZGVYuFyIiKqa6KSutdeew0PHjzAmDFj8Pnnn+PXX3/Ff//7X/z666/4/PPPMWbMGDx8+BCvvfYaAECr1eLs2bMIDAy06OCJiIisQXULl1+9mc39dkREJJqoPXURERHIysrChg0bsGzZMoPnBEGAVCrFjBkzEBERAQDIycnB1KlT0bVrV7Pun5aWhpiYGFy8eBEuLi4YOXIk3nrrLTg6OlbYTxAEbNy4ETt27IBSqURAQAAWLFiA4OBgg3ZZWVmIiYlBcnIyHBwcMGTIECxYsACurq4G7Y4fP47Vq1cjPT0dXl5emDFjBsaOHat/XqPRYOHChfjtt9/w4MEDPPXUU+jcuTP+8pe/ICgoyKz3SkRE9UN1Cpev2/8r8gpK9I+5346IiKpCIpgqNGemGzdu4MCBA7h27Rpyc3Ph6uoKPz8/vPDCC2jbtq2oe6pUKrzwwgto06YNoqKikJWVheXLl2PEiBF4//33K+y7YcMGxMXFYf78+fDz88P27dtx+vRp7N+/H97e3gCA4uJijBkzBgAwZ84cFBQUYMWKFfD390dCQoL+XufOncOkSZMwbtw4DB8+HGfPnsX69euxevVqDBs2DADw8OFDfPzxx+jduzdatmyJ3NxcbN26Fb/99hu+/vpr0Z9BaakWSmWeqL6WZG8vhaenC7Kz81BSwv2QZB7GDYlVH2Pn6s1sxO68KLo/i5ZXrj7GDdU8xg2JVduxI5e7wM6u8sWVombqdNq0aYNZs2ZV5xZGdu3ahby8PKxZswYeHh4AgNLSUnzwwQeIiopC06ZNTfYrLCxEQkICpk6dismTJwMAunfvjmHDhmHz5s1YsmQJACApKQmpqalITExEu3btAAAymQzTpk3D5cuX9TNs69atQ1BQED788EMAQO/evZGRkYG4uDh9Ute4cWOsXLnSYBx9+/ZFSEgIkpKS8Oc//9mSHw0REdmY6hYuZ9FyIiIyh6g9dTXp5MmT6NOnjz6hA4Dw8HBotVqcOnWq3H4XLlxAbm4uwsPD9dccHR0xZMgQnDx50uD+fn5++oQOAEJDQ+Hh4YETJ04AAIqKipCSkqJP3nSGDx+OtLQ0ZGaWf3T1U089BScnp0pPByUiovqvuoeocL8dERGZo1ozdZcvX8Yvv/wCtVqN0tJSo+clEgmio6OrdE+FQmGwbw14PJPWpEkTKBSKCvsBMEjWAMDHxwdbt25FQUEBnJ2doVAojNpIJBK0bdtWf49bt26huLjY5L10r9Wy5f+KzWq1Wmi1WiiVSmzevBlSqRSjRo2q0vsmIqL6SXeIyo6jqQYzdi7O9gb76MrD/XZERFQZUUldTk4OoqOjceHCBVS0JU9MUqdWqyGTyYyuu7u7Q6VSVdjP0dERTk6GJ4/JZDIIggCVSgVnZ2eo1Wq4ublVeH/dz7Lj0D0uO45PP/0U69evB/B4SeaGDRv0e/jEsrev+0lU3fpdc9bxEukwbkis+hw7IZ2aoWdAU1y7lY2c3CJ4uDpCKwArtl+otG/ZxE9X3272uCD09GdiV5/jhmoO44bEstbYEZXULV++HOfPn0evXr0wevRoNGvWDHZ2dpYem82YMGECBg8ejPv372P37t2YMWMGPvvsM3Tq1EnU/aRSCTw9XSw8SvFkskZ1PQSyQYwbEqs+x07fxv87ZblUK6DxgSt4qCoQda+dR1PxXEgb2HG/HYD6HTdUcxg3JJa1xY6opO77779HUFAQtm7dConEsn+YyGQyaDQao+sqlarC4uUymQxFRUUoLCw0mK1Tq9WQSCT6vjKZDLm5uSbv37x5cwDQty07DrVabfC8TtOmTfUHuAwcOBDjxo1DXFycwWmaVaHVClCrH4nqa0l2dlLIZI2gVuejtJQnQ5F5GDckVkOMnQlDfBG/57Kovg9y8pHycyYC2sgtPCrb0hDjhqqPcUNi1XbsyGSNau70y8LCQvTo0cPiCR3weE9c2b1zGo0G9+/fN9rjVrYfAKSnp8Pf319/XaFQwMvLC87Ozvp2169fN+grCALS09MRGhoKAGjVqhUcHBygUCjQv39/g3s9+VqmSKVSBAQE4Pz58+a83XJZ0/G6paVaqxoP2QbGDYnVkGKna/unq7Xf7r4qH6VpD/V18Xy9PRrsSZkNKW7Ichg3JJa1xY6opM7f3x+3b9+29FgAAGFhYVi/fr3B3rpDhw5BKpXqky5TunXrBldXVxw8eFCf1BUXF+Pw4cMICwszuP+3336LGzduoE2bNgCAM2fOICcnBwMGDADw+NRMXVmCyMhIfd/ExET4+PgYHJJSVklJCS5fvlztPXVERNQwmCparhUE/GPXpUr7fnn0D2jy/3faMg9RISJqmEQldbNmzcLMmTNx6dIlBAcHW3RAERER2LZtG6Kjo/XFx2NjYxEREWFQoy4yMhJ37tzBkSNHAABOTk6IiopCfHw85HI5fH19sXPnTuTk5GDatGn6fkOHDkVCQgJmz56NuXPnIj8/H7GxsRg4cKC+Rh0AzJw5E5MmTcKSJUsQHh6OlJQUHDhwAKtWrdK3+fLLL3H58mX07dsXTZo0wYMHD7Br1y6kp6dj8eLFFv1ciIio/pJKJfBv7al/rNUKZtW3ezKhA/53iAqLlhMRNSyikroHDx5g4MCBeO211/DSSy+hU6dOcHV1Ndm2qkf7u7u7Y+vWrVi6dCmio6Ph4uKCcePGYc6cOQbttFqtURmF6dOnQxAEbNmyBUqlEgEBAdi8ebPBrJmDgwM2bdqEmJgYzJ07F/b29hgyZAgWLlxocK8ePXogPj4eq1evxp49e+Dl5YWYmBiDOnjt27fH4cOH8dFHH0GtVqNJkyYIDAzEnj17DJaAEhERVYWuvt3afb+K6s+i5UREDYtEqKgmQTn8/f0hkUgMyhmU3V8nCAIkEgl+//336o+ygSkt1UKpzKvrYcDeXgpPTxdkZ+dZ1Zphsm6MGxKLsWPs/LV7Rvvt3Bo5GM3QmTJ/fDCkUkm932/HuCExGDckVm3HjlzuUnMHpSxbtkxMNyIiIqoCU/vtsjWF2HjgSqV9WbSciKjhEJXUjR492tLjICIiIhPK7re7ejPbrH7lFS3nfjsiovrHukqhExERUYV8vT3g6eZUecNy7DyaCq22yjsviIjIijGpIyIisiG6Q1TEUmoKcT0jx3IDIiKiOmfW8kt/f39IpVJ89913aNu2rf6glMpIJBJcuVL5un8iIiIyX3e/Z6pVtFyZW4CrN7Pr/SEqREQNhVlJXc+ePQEAjRo1MnhMREREdYNFy4mISMespG7btm0VPiYiIqLax6LlREQEcE8dERFRvVHd/XY8RIWIyDYxqSMiIqpHdPvtyp6Q6dbIodK+Sk0hrt7MxtWb2Th75S6u3sxmkkdEZANE1akDAKVSib179+KXX36BRqNBaWmpURuJRIKtW7dWa4BERERUNSxaTkTUsIhK6q5evYrIyEio1WoIQvm/wTPnhEwiIiKyPBYtJyJqOEQldStWrIBKpcLMmTMxbtw4NGvWDHZ2dpYeGxEREVmIrmh5ZYeolGfn0VR07dCEpQ+IiKyQqD11ly5dwuDBg/Hmm2+iRYsWTOiIiIisHIuWExHVX6KSOgcHB3h7e1t6LERERFSDyjtExcXZvIU7OXmF0GoFHqRCRGRlRC2/7NmzJ3799VdLj4WIiIhqWHWKlt95kIe/rjttsISTB6kQEdU9UTN1b7/9NlJTU7F582ZLj4eIiIhqmO4Qld4dm8G/tSf8W3kazd6ZcuD0TaM9ebqDVM5fu1dTwyUiokqImqlbt24dOnTogH/84x/YtWsXAgIC4OLiYtROIpHg448/rvYgiYiIqObo9tut3Vf+KhwJgIoWWvIgFSKiuiMqqdu3b5/+3zMyMpCRkWGyHZM6IiIi26Dbb7fjaKrBbJzczQlhXZrjm+QbFfbXFS6XSiX6ZZ2+3h5M8oiIaoGopO7YsWOWHgcRERHVMVP77Xy9PfDj1Syz+rNwORFR3RCV1P30009o3Lgx+vfvb+nxEBERUR0qW7QcADxcKt9vB7BwORFRXRF1UMqiRYvwww8/WHosREREZIV0hcvF2nk0laUPiIhqkKikrkmTJigtLbX0WIiIiMgKWaJw+dWb2axvR0RUQ0Qtvxw0aBBOnTqFoqIiODo6WnpMREREZGXKO0jFxdneaNmlKdxvR0RUcySCIFT5V2UajQaRkZF4+umn8de//hUdOoj/7R0ZKy3VQqnMq+thwN5eCk9PF2Rn56GkRFvXwyEbwbghsRg7tkGrFUQVLi9PdffbMW5IDMYNiVXbsSOXu8DOrvLFlaJm6kaNGoWioiL8/vvv+OGHH+Dk5AS5XA6JxPDYYolEgqNHj4p5CSIiIrJCZQ9S0WoFeLo5GRUlNxfr2xERVZ+oPXWCIMDBwQHNmzdH8+bNIZfL9def/Eer5W8+iIiI6jNL7Le7npFjuQERETVAombqjh8/bulxEBERkY2q7n47ZW4Brt7MZtFyIiKRRCV1RERERE8yVbjc3P12Xx79A5r8Yv1jHqJCRFQ1TOqIiIjIIsTut3syoQNYtJyIqKqqldRdvHgRp0+fxr1791BUVGT0vEQiwccff1ydlyAiIiIbpdtvt3bfr6L68xAVIiLziErqSkpKMHfuXBw5cgSCIEAikeDJygi6x0zqiIiIGrby9tu5NXIwmqErS1e0XCqVcL8dEVEFRCV1W7ZsweHDhzF27FhMmDABY8eORWRkJIYPH46ffvoJGzduRJ8+fTB//nxLj5eIiIhsjKn9dtmaQmw8cKXSvixaTkRUOVElDf7973+jQ4cO+Oijj9CpUycAgJubG7p06YLXX38dX3zxBf7zn/8gOTnZooMlIiIi26Tbb9e7YzP4t/aEp5uTWf3Knp6p2293/tq9mhgmEZFNEpXU3bp1CyEhIfrHEokEJSX/+9Lt0KEDnn32WezcubP6IyQiIqJ6x9fbw+zEzpSdR1Oh1QqVNyQiagBEJXUODg5wdnbWP37qqaegVCoN2nh5eeHmzZuiBpWWloYpU6YgODgYoaGhiI2NNXkQS1mCIGDDhg0YOHAggoKCMH78eFy6dMmoXVZWFmbPno2uXbuiV69eWLRoEXJzc43aHT9+HCNGjEBgYCCGDh2KvXv3GjyvUCjw4YcfYvjw4ejSpQsGDRqExYsXG30WREREZMgSRcuv3szG7zeUOHEhE7/fUDLJI6IGS9SeuubNm+O///2v/nG7du3w008/6Q9HAYCff/4Z7u7uVb63SqVCZGQk2rRpg/j4eGRlZWH58uUoKCjA+++/X2HfjRs3Ii4uDvPnz4efnx+2b9+OqVOnYv/+/fD29gYAFBcX4/XXXwcArFy5EgUFBVixYgXmzZuHhIQE/b3OnTuHWbNmYdy4cVi4cCHOnj2LRYsWwcXFBcOGDQMAnD59GufOncP48ePh7++PO3fuIC4uDj/++CP2798PR0fHKr9/IiKihqK6Rcu5346I6DFRSV3Pnj1x7NgxfRI3fPhwrFixAlFRURgwYADOnz+P8+fPY+zYsVW+965du5CXl4c1a9bAw8MDAFBaWooPPvgAUVFRaNq0qcl+hYWFSEhIwNSpUzF58mQAQPfu3TFs2DBs3rwZS5YsAQAkJSUhNTUViYmJaNeuHQBAJpNh2rRpuHz5MoKCggAA69atQ1BQED788EMAQO/evZGRkYG4uDh9UvfCCy/g1Vdf1SeyANC6dWu88sor+P777zF06NAqv38iIqKGpDpFy8vbb8f6dkTU0Ihafjl27FgMHDgQWVlZAIDXXnsNAwcOxMmTJ7F06VIkJiYiMDAQ8+bNq/K9T548iT59+ugTOgAIDw+HVqvFqVOnyu134cIF5ObmIjw8XH/N0dERQ4YMwcmTJw3u7+fnp0/oACA0NBQeHh44ceIEAKCoqAgpKSn65E1n+PDhSEtLQ2ZmJgDA09PTIKEDgI4dOwIA7t3jBm4iIiJzlD1Exb+V+QepmML9dkTU0IiaqevUqRM++OAD/WMHBwesX78ev/zyCzIyMuDl5YWgoCBIpVXPGRUKhdEMn0wmQ5MmTaBQKCrsB8AgWQMAHx8fbN26FQUFBXB2doZCoTBqI5FI0LZtW/09bt26heLiYpP30r1Wy5YtTY7j/PnzBm2JiIioaqpbtJz17YiooRGV1JUnMDAQgYGB1bqHWq2GTCYzuu7u7g6VSlVhP0dHRzg5Gf5mTyaTQRAEqFQqODs7Q61Ww83NrcL7636WHYfucXnjKCwsxIoVK9CxY0f06dOngndZOXt7UZOoFmVnJzX4SWQOxg2JxdihJ4V0agapnRTbk65B+eR+u0b2yMuv+n47uZsTXh3qh57+XJZJ/L4h8aw1dqqV1BUVFeHMmTNQKBR49OgRoqOjATxObnJzc+Hp6Slqts5WLV68GJmZmdi1a5fRssyqkEol8PR0seDIqkcma1TXQyAbxLghsRg7pPN8n7Z4LqQNrigeQqkugFzmjFJBwHvrT1fat+x+O6WmEPF7LmNBZE/0DfKqqSGTjeH3DYllbbEjOqk7duwY3n//fSiVSv2BKbqk7tq1axg/fjxiY2Px0ksvVem+MpkMGo3G6LpKparwNE2ZTIaioiIUFhYazNap1WpIJBJ9X5lMZrJ8gUqlQvPmzQFA37bsONRqtcHzT1q1ahX+/e9/Y/369fD19a3sbVZIqxWgVj+q1j0swc5OCpmsEdTqfJSWaut6OGQjGDckFmOHytOycSO0bPz4L1BarQC5m5PB7F1VJOy7DL8WMi7FbOD4fUNi1XbsyGSNzJoVFJXUnT9/Hm+++SaaNGmCRYsW4dKlS/juu+/0zwcFBaFVq1Y4fPhwlZO6du3aGe2d02g0uH//vtEet7L9ACA9PR3+/v766wqFAl5eXvq6eu3atcP169cN+gqCgPT0dISGhgIAWrVqBQcHBygUCvTv39/gXk++ls62bduQkJCA5cuXG7SvjpIS6/mCKS3VWtV4yDYwbkgsxg5V5pXq7LdTF+LXtIfcb0cA+H1D4llb7IhaG/nPf/4Tbm5u2Lt3L1577TW0adPGqE3nzp1x9erVKt87LCwMp0+f1s+KAcChQ4cglUr1SZcp3bp1g6urKw4ePKi/VlxcjMOHDyMsLMzg/levXsWNGzf0186cOYOcnBwMGDAAwONTM0NCQpCUlGTwGomJifDx8TE4JOXAgQP46KOPMHfuXIwaNarK75eIiIiqRlffruwJmS7O5v2uet3+XxG78yI2fHsFsTsv4q/rTuP8NZ5aTUS2S9RM3eXLlzF06FDI5fJy2zRv3hzHjx+v8r0jIiKwbds2REdHIyoqCllZWYiNjUVERIRBjbrIyEjcuXMHR44cAQA4OTkhKioK8fHxkMvl8PX1xc6dO5GTk4Np06bp+w0dOhQJCQmYPXs25s6di/z8fMTGxmLgwIH6GnUAMHPmTEyaNAlLlixBeHg4UlJScODAAaxatUrf5scff8Q777yD3r17o1evXrh06ZL+uWbNmqFZs2ZVfv9ERERUOV19u7Q7KhQLEjhIBBSXaFnfjogaJFFJXVFREVxdXStso9vLVlXu7u7YunUrli5diujoaLi4uGDcuHGYM2eOQTutVovS0lKDa9OnT4cgCNiyZQuUSiUCAgKwefNmeHt769s4ODhg06ZNiImJwdy5c2Fvb48hQ4Zg4cKFBvfq0aMH4uPjsXr1auzZswdeXl6IiYkxqIOXkpKC4uJinDlzBmfOnDHoP2vWLMyePbvK75+IiIjMI5VKENBGDk9PF2Rn56GoqBSebk7IFrnfbufRVHTt0IRLMYnI5kgEQahydc4XX3wR7u7u2L59OwBgzZo1WLt2LX7//Xd9mxEjRsDR0RF79uyx3GgbiNJSLZTKvLoeBuztpfo/KK1pzTBZN8YNicXYITHKxs35a/dE77cDgPnjg7nfrgHg9w2JVduxI5e7mHVQiqg9dc8//zwuXLiAvXv3mnx+8+bNSE1NxfDhw8XcnoiIiEgU7rcjooZI1ExdXl4exo8fj7S0NPTu3RtFRUW4cOECpkyZgkuXLuHixYsICAjArl274OjoWBPjrtc4U0e2jHFDYjF2SIzy4karFXA9I0c/46YVBLP225WH++3qF37fkFjWOlMnak+di4sLtm/fjg8//BCHDh3S723bsmULJBIJwsPDsXjxYiZ0REREVCekUgn8W3vqH2u1AvfbEVG9Jbr4uLu7O1auXIl3330Xv/zyC1QqFVxdXREYGIinn37akmMkIiIiqhapVIIJ1alvpynE9Ywc+Hp7GMwAcs8dEVkD0Umdjqenp0EdOJ0NGzYgOTkZn3/+eXVfgoiIiKjadPvtdhxNNZixc3G2NypzYMrF1PvYeOCKQV9PNydMGNyBSzOJqE5VO6krT3p6On766aeauj0RERFRlenq24nZb3fkXKbRNda4IyJrUGNJHREREZE1svR+O4B77oiobokqaUBERERUX+j221WHUlOIqzezcfVmNs5euYurN7Oh1Vb5gHEiIlE4U0dEREQNXnn77eRuTuju18Tk0suy1u3/1WBvHvfbEVFtYVJHREREBNP77XSnXZqT1JU9bIX77YiotjCpIyIiIvp/ZffbAYCvtwdr3BGRVTM7qZs+fXqVbnz9+vUqD4aIiIjI2liixt3Vm9mQSiWsb0dENcLspO6HH36o8s0lEn5ZERERke2rbo077rcjoppkdlJ37NixmhwHERERkVWrTo077rcjoppkdlLXokWLmhwHERERkdWzdI077rcjIktgnToiIiIikapb44717YjIEnj6JREREVE1cL8dEdU1JnVERERE1cT9dkRUl5jUEREREVkA99sRUV3hnjoiIiKiGsD9dkRUWzhTR0RERFRDuN+OiGoDkzoiIiKiGsT9dkRU05jUEREREdWwmthv18XnafxxW6VPFH29Pbj/jqiBYlJHREREVMt0++3W7vtVVH+lphDz1p6CJr9Yf41LM4kaLh6UQkRERFQHdPvtPN2cDK67OJv3O/cnEzrgf0szz1+7Z7ExEpFt4EwdERERUR2pzn678rAUAlHDw6SOiIiIqA5Zer+drhSCVCrhfjuiBoJJHREREZEVqe5+O4ClEIgaGu6pIyIiIrIy5e23c2vkYFb/8kohcL8dUf3EmToiIiIiK2Rqv137Fu54O+FMtUohcL8dUf3DpI6IiIjISpXdbweg2qUQuN+OqP5hUkdERERkQ3RLM3ccTTWYsXNxtjdadmkK99sR1T9M6oiIiIhsTHVKIZS33y56dGcmdkQ2ikkdERERkQ2ydCmEnUdT0cXnafxxW8WlmUQ2xipPv0xLS8OUKVMQHByM0NBQxMbGoqioqNJ+giBgw4YNGDhwIIKCgjB+/HhcunTJqF1WVhZmz56Nrl27olevXli0aBFyc3ON2h0/fhwjRoxAYGAghg4dir179xq1Wbt2LaZMmYIePXrAz88Pv/zyi6j3TERERFQdulIIYik1hZi39hRid17Ehm+vIHbnRfx13WmemElkA6wuqVOpVIiMjERxcTHi4+MxZ84cfPXVV1i+fHmlfTdu3Ii4uDhMnjwZCQkJaNKkCaZOnYqMjAx9m+LiYrz++uu4ceMGVq5ciSVLliA5ORnz5s0zuNe5c+cwa9YsBAcHY+PGjQgPD8eiRYtw6NAhg3ZffvkliouL0bdvX8t8AEREREQilVcKwcXZvMVZmvxig8cshUBkG6xu+eWuXbuQl5eHNWvWwMPDAwBQWlqKDz74AFFRUWjatKnJfoWFhUhISMDUqVMxefJkAED37t0xbNgwbN68GUuWLAEAJCUlITU1FYmJiWjXrh0AQCaTYdq0abh8+TKCgoIAAOvWrUNQUBA+/PBDAEDv3r2RkZGBuLg4DBs2TP+6//nPfyCVSpGSkoKkpKQa+ESIiIiIzFed/Xbl0ZVCAGBwXy7PJLIOVpfUnTx5En369NEndAAQHh6OxYsX49SpUxgzZozJfhcuXEBubi7Cw8P11xwdHTFkyBAcOXLE4P5+fn76hA4AQkND4eHhgRMnTiAoKAhFRUVISUnB/PnzDV5j+PDhOHDgADIzM9GyZUsAgFRqdZOdRERE1MBZer+dUlOIA6dv4MTPdwzuwZMziayD1WUkCoXCIOECHs+kNWnSBAqFosJ+AIz6+vj44M6dOygoKCj3/hKJBG3bttXf49atWyguLjZ5rydfi4iIiMgWVHe/HQB8k5xulBRyeSaRdbC6mTq1Wg2ZTGZ03d3dHSqVqsJ+jo6OcHIyXEMuk8kgCAJUKhWcnZ2hVqvh5uZW4f11P8uOQ/e4onFYir193efbdnZSg59E5mDckFiMHRKDcWO+kE7NILWTYnvSNSifSM7cnnKA5lFxBT0rt/NYKrr7PYPUzBzk5BbBw9URfq08rXZpJuOGxLLW2LG6pI4e/zbN09OlroehJ5M1qushkA1i3JBYjB0Sg3Fjnuf7tMVzIW1wRfEQSnUB5DJn+LWRY8bHR/BQVSD6vkp1Id6KT4Y673+nlTd2d8aMUYHoG+RliaHXCMYNiWVtsWN1SZ1MJoNGozG6rlKp4O7uXmG/oqIiFBYWGszWqdVqSCQSfV+ZTGayfIFKpULz5s0BQN+27DjUarXB8zVFqxWgVj+q0dcwh52dFDJZI6jV+Sgt1db1cMhGMG5ILMYOicG4Eadl40Zo2fjxX0rzNPmYMMQX8XsuV+ueTyZ0APBQVYBlW3/C7HFB6OlvXXvuGDckVm3HjkzWyKxZQatL6tq1a2e0Z02j0eD+/ftGe9zK9gOA9PR0+Pv7668rFAp4eXnB2dlZ3+769esGfQVBQHp6OkJDQwEArVq1goODAxQKBfr3729wrydfqyaVlFjPF0xpqdaqxkO2gXFDYjF2SAzGTfV0bf80okd3xo6jqQb75uRuTgjr0hzfJN8Qfe/tSdfQpV1jq1yKybghsawtdqwuqQsLC8P69esN9tYdOnQIUqlUn3SZ0q1bN7i6uuLgwYP6pK64uBiHDx9GWFiYwf2//fZb3LhxA23atAEAnDlzBjk5ORgwYACAx6dmhoSEICkpCZGRkfq+iYmJ8PHx0Z98SURERFRfmCqF4OvtAQA48fN/q3Vy5tWb2ZBKJSyFQFRDrC6pi4iIwLZt2xAdHY2oqChkZWUhNjYWERERBjXqIiMjcefOHX25AicnJ0RFRSE+Ph5yuRy+vr7YuXMncnJyMG3aNH2/oUOHIiEhAbNnz8bcuXORn5+P2NhYDBw4UF+jDgBmzpyJSZMmYcmSJQgPD0dKSgoOHDiAVatWGYz3xx9/hFKpxB9//AEAOHv2LG7fvo0WLVogMDCwJj8qIiIiIosqWwpBZ8LgDli771fR9123/1fkFZToH7MUApFlSQRBEOp6EGWlpaVh6dKluHjxIlxcXDBy5EjMmTMHjo6O+jYTJ07E7du3cfz4cf01QRCwYcMG7NixA0qlEgEBAViwYAG6du1qcP+srCzExMQgOTkZ9vb2GDJkCBYuXAhXV1eDdseOHcPq1auRnp4OLy8vzJgxA+PGjTNoM3HiRPz4449G72H06NFYvny5qPdfWqqFUpknqq8l2dtL4enpguzsPKuaXibrxrghsRg7JAbjpvacv3bPaHmmWyMHaPLFn5wZPbpznSR2jBsSq7ZjRy53MWtPnVUmdQ0dkzqyZYwbEouxQ2IwbmqXVisYLM9s38IdbyecEb00U+7mhOVRffDHbVWtLs1k3JBY1prUWd3ySyIiIiKyTqaWZ1ZnaaZSU4h5a08ZzPZxaSZR1VlX1TwiIiIisind/Z5B9OjO8HRzMrju4mze3EHZ5ZvZmkKs3fcrzl+7B61WwNWb2Th75S6u3syGVssFZkSmcKaOiIiIiKrF1MmZWkHAP3ZdEn3PrQevGu3h4ywekWlM6oiIiIio2souzdRqBXi6OYneb5dbUAI8cWIm8L9ZvLo6YIXIWnH5JRERERFZnFQqwYTBHWrk3juPpqKkRMulmUT/jzN1RERERFQjdPvtLF0KgQesEBliUkdERERENcbUfrvqlkIAyj9ghUszqSHi8ksiIiIiqlG6/Xa9OzaDf2tP2NtLuTSTyII4U0dEREREta68pZmero4oKtEir8whKebi0kxqiJjUEREREVGdMLU009fbAxdT74suaA5waSY1PEzqiIiIiKjOlC2FANTcASs7j6aii8/TSM3MQXF6NhwkAny83CGVSkTfk8gaMKkjIiIiIqtTEwescGkm1Vc8KIWIiIiIrFJNHLBS3tLM89fuAXhcNJ2HrJCt4UwdEREREdmMmlyaqRWAXcfKHNzCmTyyARJBEPjrBytTWqqFUplX18OAvb0Unp4uyM7OQ0mJtq6HQzaCcUNiMXZIDMZNw6XVChavfVeR6NGdTR7qwv14DUttf+fI5S6ws6t8cSVn6oiIiIjI5pg6YGXC4A7VOjWzIlsPXjUuv8BZPLIS3FNHRERERPWCbmmmp5uTwXW3Rg7VvnduQYnRLGDZ/XhEdYUzdURERERUb9TEqZmV0ZVK+OO2ikszqU4wqSMiIiKieqW2l2ayVALVNS6/JCIiIqJ6r7ylmXI3J8wc1cnoelVVVCqBZRKopnGmjoiIiIgaBN3SzLQ7KhQLEjhIBPh4uUMqlUAqkdTITB4PWKHawJk6IiIiImowpFIJAtrIMaBbSwS0kev3vZU3k+fp6ggXZ/HzIJUdsMJZPLIEztQREREREcH0ISu+3h64mHqfs3hk1ThTR0RERET0/3SHrPTu2Az+rT0hlUpqrFQCZ/HIUjhTR0RERERUidoulVDZLJ5WKxjNKLKEQsPFpI6IiIiIyAy1WSoht6AEKCgxuKabxRvWyxspv9/jsk3S4/JLIiIiIiKRauqAlYoc+jGDyzbJAGfqiIiIiIiqobYPWKkIl202TEzqiIiIiIiqydTSTN0snlGS5eqIohIt8sosr7QELttsmJjUERERERHVEGuaxTv0Y4bRNV3CFz26M2fybBiTOiIiIiKiGmQts3gV2Xk0FVoB2HWMSzdtEZM6IiIiIqI6YE2zeEpNIdZ9Y/ya5i7dZMJXt5jUERERERHVkarM4sndnNAr4BmTyyhrWkVLN6uT8DEZtAyrTOrS0tIQExODixcvwsXFBSNHjsRbb70FR0fHCvsJgoCNGzdix44dUCqVCAgIwIIFCxAcHGzQLisrCzExMUhOToaDgwOGDBmCBQsWwNXV1aDd8ePHsXr1aqSnp8PLywszZszA2LFjDdoUFRVh1apV+Pbbb5GXl4euXbvivffeQ7t27SzyWRARERFRw1PeLJ5UKoFPC3erWbYJiE/4APCkTguRCIJgVYUrVCoVXnjhBbRp0wZRUVHIysrC8uXLMWLECLz//vsV9t2wYQPi4uIwf/58+Pn5Yfv27Th9+jT2798Pb29vAEBxcTHGjBkDAJgzZw4KCgqwYsUK+Pv7IyEhQX+vc+fOYdKkSRg3bhyGDx+Os2fPYv369Vi9ejWGDRumb/f+++8jMTER77zzDpo2bYr169cjIyMD3333Hdzc3ER9BqWlWiiVeaL6WpK9vRSeni7Izs5DSYm2rodDNoJxQ2IxdkgMxg2JUR/ixlTCUxfLNmtKTc7+VadvbceOXO4CO7vKS4tb3Uzdrl27kJeXhzVr1sDDwwMAUFpaig8++ABRUVFo2rSpyX6FhYVISEjA1KlTMXnyZABA9+7dMWzYMGzevBlLliwBACQlJSE1NRWJiYn62TSZTIZp06bh8uXLCAoKAgCsW7cOQUFB+PDDDwEAvXv3RkZGBuLi4vRJ3d27d7Fnzx4sXrwY48aNAwAEBgbi2Wefxa5duzB9+vSa+IiIiIiIqIGzlWWbYtXU7N/5a/fKfb6yvtbM6pK6kydPok+fPvqEDgDCw8OxePFinDp1Sj/LVtaFCxeQm5uL8PBw/TVHR0cMGTIER44cMbi/n5+fwfLI0NBQeHh44MSJEwgKCkJRURFSUlIwf/58g9cYPnw4Dhw4gMzMTLRs2RLJycnQarUGM3ceHh4IDQ3FyZMnmdQRERERUa2q6rJNuZsTxj/XHruO/WFw3ZpVlPCZ8mQyKLavruSDtbK6pE6hUBjtW5PJZGjSpAkUCkWF/QAY7WXz8fHB1q1bUVBQAGdnZygUCqM2EokEbdu21d/j1q1bKC4uNnkv3Wu1bNkSCoUCjRs3hru7u1G7PXv2VOFdExERERFZhqlZPKDihE8qkdSbpZvlSfpJ/EzlzqOp6NqhiQVHY1lWl9Sp1WrIZDKj6+7u7lCpVBX2c3R0hJOTk8F1mUwGQRCgUqng7OwMtVptcq/bk/fX/Sw7Dt1j3fPl3Usmk1U4VnPY21e+dram6dbvmrOOl0iHcUNiMXZIDMYNidHQ46azT2OjayGdmkFqJ8X2pGtQPjmTJ3NCSKdmOHjmZm0OsUZU5yQRpaYQaXdU6OzzNADrix2rS+ro8W9XPD1d6noYejJZo7oeAtkgxg2JxdghMRg3JAbjxtDzfdriuZA2uKJ4CKW6AHKZMzq2aww7qQTBvs9gwze/4KGqQN/+aY9GCAv2wtf/SavDUdeeYkGijxlrix2rS+pkMhk0Go3RdZVKZbTMsWy/oqIiFBYWGszWqdVqSCQSfV+ZTIbc3FyT92/evDkA6NuWHYdarTZ4vrx7qdXqCsdaGa1WgFr9SHR/S7Gzk0ImawS1Oh+lpbZ5MhTVPsYNicXYITEYNyQG46ZiLRs3QsvGj5MWterx30kDvN2xMjoU125lIye3CB6ujvBr5QmpVIIWT7vU6xk+HQeJALU6v1ZjRyZrZJunX7Zr185o75xGo8H9+/crrP2mey49PR3+/v766wqFAl5eXnB2dta3u379ukFfQRCQnp6O0NBQAECrVq3g4OAAhUKB/v37G9zryddq164dHjx4YJRwmtq3V1XWdLxuaanWqsZDtoFxQ2IxdkgMxg2Jwbipug4tPfT/rtUK0GoFdG3/NLq0a2xyr167Zm4mD2d5pZzTJmvypE6JRPwSTLmbE3y83PWJnLXFjtUldWFhYVi/fr3B3rpDhw5BKpXqky5TunXrBldXVxw8eFCf1BUXF+Pw4cMICwszuP+3336LGzduoE2bNgCAM2fOICcnBwMGDADw+NTMkJAQJCUlITIyUt83MTERPj4+aNmyJQCgX79+kEqlOHz4MF5++WUAj2f8kpOT8cYbb1juQyEiIiIismJiDmcBUOWTOquT8A3tafr0S3O8MriDVRc+t7qkLiIiAtu2bUN0dLS++HhsbCwiIiIMatRFRkbizp07+nIFTk5OiIqKQnx8PORyOXx9fbFz507k5ORg2rRp+n5Dhw5FQkICZs+ejblz5yI/Px+xsbEYOHCgvkYdAMycOROTJk3CkiVLEB4ejpSUFBw4cACrVq3St2nWrBnGjRuH2NhYSKVSNG3aFAkJCXBzc0NEREQtfFpERERERNatvISvoufElGaoaPbvlf+vNVedvtZMIgjVOQemZqSlpWHp0qW4ePEiXFxcMHLkSMyZMweOjo76NhMnTsTt27dx/Phx/TVBELBhwwbs2LEDSqUSAQEBWLBgAbp27Wpw/6ysLMTExCA5ORn29vYYMmQIFi5cCFdXV4N2x44dw+rVq5Geng4vLy/MmDFDX2Rcp6ioCKtWrcL+/fuRl5eHbt264d1339WXPxCjtFQLpTJPdH9LsbeXwtPTBdnZeVY1vUzWjXFDYjF2SAzGDYnBuLF9Wq1Q7uxfRc9Vt29tx45c7mLWnjqrTOoaOiZ1ZMsYNyQWY4fEYNyQGIwbEstakzrrKrBAREREREREVcKkjoiIiIiIyIYxqSMiIiIiIrJhTOqIiIiIiIhsGJM6IiIiIiIiG8akjoiIiIiIyIaxpIEVEgQBWq11/Gexs5OitJRH/VLVMG5ILMYOicG4ITEYNyRWbcaOVCqBRCKptB2TOiIiIiIiIhvG5ZdEREREREQ2jEkdERERERGRDWNSR0REREREZMOY1BEREREREdkwJnVEREREREQ2jEkdERERERGRDWNSR0REREREZMOY1BEREREREdkwJnVEREREREQ2jEkdERERERGRDWNSR0REREREZMOY1BEREREREdkwJnVEREREREQ2jEkdGUlLS8OUKVMQHByM0NBQxMbGoqioqK6HRVbk4MGDmDlzJsLCwhAcHIyRI0diz549EATBoN3u3bsxdOhQBAYGYsSIEfj+++/raMRkjfLy8hAWFgY/Pz/88ssvBs8xdsiUffv2YdSoUQgMDERISAhef/11FBQU6J8/fvw4RowYgcDAQAwdOhR79+6tw9GSNTh27BhefvlldO3aFf369cObb76JjIwMo3b8zmm4bt68iffffx8jR45Ex44d8eKLL5psZ06MaDQaLFy4EL169ULXrl3xl7/8Bffu3avptwCASR2VoVKpEBkZieLiYsTHx2POnDn46quvsHz58roeGlmRzz77DI0aNcI777yDdevWISwsDO+99x7Wrl2rb/Pdd9/hvffeQ3h4ODZu3Ijg4GDMmjULly5dqruBk1X55z//idLSUqPrjB0yZd26dVi6dCmGDx+OzZs348MPP0TLli31MXTu3DnMmjULwcHB2LhxI8LDw7Fo0SIcOnSojkdOdSUlJQWzZs1C+/btsXbtWixcuBBXr17F1KlTDX4ZwO+chi01NRUnTpxA69at4ePjY7KNuTHy1ltv4dSpU1iyZAn+8Y9/ID09HdOnT0dJSUnNvxGB6Anr168XgoODhezsbP21Xbt2CQEBAcLdu3frbmBkVR4+fGh07d133xW6desmlJaWCoIgCM8//7wwd+5cgzbjx48XXn/99VoZI1m3P/74QwgODhZ27twp+Pr6CpcvX9Y/x9ihstLS0oSOHTsK//nPf8ptM3XqVGH8+PEG1+bOnSuEh4fX9PDISr333nvCoEGDBK1Wq7925swZwdfXV/jpp5/01/id07Dp/t4iCILw9ttvCy+88IJRG3Ni5MKFC4Kvr6/www8/6K+lpaUJfn5+wnfffVcDIzfEmToycPLkSfTp0wceHh76a+Hh4dBqtTh16lTdDYysilwuN7oWEBCA3NxcPHr0CBkZGbhx4wbCw8MN2gwfPhxnzpzhcl5CTEwMIiIi0LZtW4PrjB0y5euvv0bLli0xYMAAk88XFRUhJSUFw4YNM7g+fPhwpKWlITMzszaGSVampKQELi4ukEgk+mtubm4AoN8uwO8ckkorTofMjZGTJ09CJpMhNDRU36Zdu3YICAjAyZMnLT/wMpjUkQGFQoF27doZXJPJZGjSpAkUCkUdjYpswfnz59G0aVO4urrqY6XsX9h9fHxQXFxscj8DNRyHDh3C9evXER0dbfQcY4dM+fnnn+Hr64t//vOf6NOnDzp37oyIiAj8/PPPAIBbt26huLjY6M8v3VIq/vnVMI0ZMwZpaWnYvn07NBoNMjIy8Mknn6Bjx47o1q0bAH7nUOXMjRGFQoG2bdsa/BIBeJzY1cZ3EJM6MqBWqyGTyYyuu7u7Q6VS1cGIyBacO3cOiYmJmDp1KgDoY6VsLOkeM5Yarvz8fCxfvhxz5syBq6ur0fOMHTLl/v37SE5Oxv79+7F48WKsXbsWEokEU6dOxcOHDxk3ZFKPHj2wZs0arFy5Ej169MDgwYPx8OFDbNy4EXZ2dgD4nUOVMzdG1Gq1fib4SbX1d2gmdURULXfv3sWcOXMQEhKCSZMm1fVwyMqtW7cOjRs3xtixY+t6KGRDBEHAo0eP8Omnn2LYsGEYMGAA1q1bB0EQ8MUXX9T18MhKXbhwAX/729/wpz/9CVu3bsWnn34KrVaLGTNmGByUQlQfMKkjAzKZDBqNxui6SqWCu7t7HYyIrJlarcb06dPh4eGB+Ph4/bp0XayUjSW1Wm3wPDUst2/fxpYtW/CXv/wFGo0GarUajx49AgA8evQIeXl5jB0ySSaTwcPDA/7+/vprHh4e6NixI/744w/GDZkUExOD3r1745133kHv3r0xbNgwbNiwAVeuXMH+/fsB8M8rqpy5MSKTyZCbm2vUv7b+Ds2kjgyYWver0Whw//59o70K1LAVFBQgKioKGo0GmzZtMlhyoIuVsrGkUCjg4OAAb2/vWh0rWYfMzEwUFxdjxowZ6NmzJ3r27Ik///nPAIBJkyZhypQpjB0yqX379uU+V1hYiFatWsHBwcFk3ADgn18NVFpamsEvAgCgWbNm8PT0xK1btwDwzyuqnLkx0q5dO6SnpxvV7E1PT6+V7yAmdWQgLCwMp0+f1v/2AXh8qIFUKjU4zYcatpKSErz11ltQKBTYtGkTmjZtavC8t7c32rRpY1QfKjExEX369IGjo2NtDpesREBAAD7//HODfxYsWAAA+OCDD7B48WLGDpn07LPPIicnB7///rv+WnZ2Nn777Td06tQJjo6OCAkJQVJSkkG/xMRE+Pj4oGXLlrU9ZLICXl5euHLlisG127dvIzs7Gy1atADAP6+ocubGSFhYGFQqFc6cOaNvk56ejitXriAsLKzGx2lf469ANiUiIgLbtm1DdHQ0oqKikJWVhdjYWERERBj9xZ0arg8++ADff/893nnnHeTm5hoU3+zYsSMcHR0xe/ZszJ8/H61atUJISAgSExNx+fJl7n9pwGQyGUJCQkw+16lTJ3Tq1AkAGDtkZPDgwQgMDMRf/vIXzJkzB05OTtiwYQMcHR0xYcIEAMDMmTMxadIkLFmyBOHh4UhJScGBAwewatWqOh491ZWIiAh8/PHHiImJwaBBg5CTk6Pf1/vk8fT8zmnY8vPzceLECQCPk/7c3Fx9AterVy/I5XKzYqRr167o168fFi5ciLfffhtOTk5YtWoV/Pz88Pzzz9f4+5AIZecIqcFLS0vD0qVLcfHiRbi4uGDkyJGYM2cOf1tFeoMGDcLt27dNPnfs2DH9b8V3796NjRs34s6dO2jbti3mzp2LZ599tjaHSlYuJSUFkyZNwp49exAYGKi/ztihspRKJZYtW4bvv/8excXF6NGjBxYsWGCwNPPYsWNYvXo10tPT4eXlhRkzZmDcuHF1OGqqS4IgYNeuXdi5cycyMjLg4uKC4OBgzJkzR1/uQoffOQ1XZmYmnnvuOZPPff755/pfRpoTIxqNBsuWLcORI0dQUlKCfv364d13362ViREmdURERERERDaMe+qIiIiIiIhsGJM6IiIiIiIiG8akjoiIiIiIyIYxqSMiIiIiIrJhTOqIiIiIiIhsGJM6IiIiIiIiG8akjoiIiIiIyIYxqSMiIqrnBg0ahEGDBtX1MIiIqIbY1/UAiIiIbEFmZiaee+65Ctu0aNECx48fr6URERERPcakjoiIqApatWqFESNGmHzOzc2tlkdDRETEpI6IiKhKWrVqhdmzZ9f1MIiIiPS4p46IiKgG+Pn5YeLEibh79y7mzp2LkJAQdOnSBRERETh9+rTJPkqlEh999BEGDRqEzp07o0+fPnjzzTdx/fp1k+2Liorw2WefYezYsejatSu6du2K4cOHY9myZVCpVEbt8/LyEBMTg379+qFz58546aWXcOjQIYu+byIiqn0SQRCEuh4EERGRtdPtqevXrx82b95caXs/Pz/4+flBo9HA09MTffv2hVKpxMGDB1FYWIi4uDgMHjxY316pVGL8+PG4desWevXqheDgYGRmZiIpKQmOjo7YtGkTevTooW9fUFCAKVOm4MKFC2jTpg369+8PBwcH3Lx5E6dPn8bOnTsREBAA4PFBKcXFxWjRogVUKhX69u2L/Px8JCYmoqCgAJs2bUK/fv0s/6EREVGt4PJLIiKiKrh16xbi4+NNPtelSxeEhYXpH1+7dg0vvvgi/vGPf0AikQAAJk2ahHHjxuG9995Dv3794OzsDAD4+9//jlu3biEqKgpz587V3+PEiROYMWMGFi5ciEOHDkEqfbzI5tNPP8WFCxcwcuRILFu2DHZ2dvo+Go1G307n3r17CAwMxOeffw5HR0cAwEsvvYTJkyfjX//6F5M6IiIbxqSOiIioCm7duoU1a9aYfG7SpEkGSZ2dnR3mzp2rT+gAwN/fHyNHjsSePXtw4sQJDB06FEVFRfjuu+/g4eGBmTNnGtxzwIABCA0NxalTp3DhwgX06NEDJSUl+PLLL+Hm5oZFixYZJHRA+Qe2LFiwQJ/QAUCfPn3QokUL/Prrr1X+HIiIyHpwTx0REVEV9OvXD9euXTP5z6JFiwzaNm/eHC1atDC6h24Z5ZUrVwAACoUChYWFCAoKQqNGjYzah4SEAAB+//13ffu8vDwEBgbC3d3drHHLZDJ4e3sbXW/atCnUarVZ9yAiIuvEpI6IiKiGPP300yavN27cGACQm5tr8LO89k2aNDFop9FoADxOyMxV3uydvb09tFqt2fchIiLrw6SOiIiohjx48MDk9YcPHwIAXF1dDX6W1153XddOJpMBALKysiw3WCIisllM6oiIiGrIf//7X9y+fdvo+rlz5wAAHTt2BAC0a9cOTk5O+OWXX5Cfn2/UPiUlBQD0p1m2bdsWrq6u+OWXX0yWLiAiooaFSR0REVENKS0txSeffIInqwddvXoV+/fvh1wux4ABAwAAjo6OeOGFF5CdnY2EhASDe5w8eRLJyclo3bo1unXrBuDxksnx48dDo9Hgo48+QmlpqUEfjUaDvLy8Gn53RERkLXj6JRERURVUVNIAAGbMmAEnJycAj2vVXbhwAWPHjjWoU1daWoqlS5fqyxkAwF//+lf89NNPWLduHS5evIguXbrg9u3bOHToEBo1aoSPP/7YoEzBm2++iZ9//hn79+/Hzz//jP79+8PR0RGZmZn44YcfsGPHDv3MHhER1W9M6oiIiKqgopIGABAZGalP6tzd3bFhwwasWLECu3fvRn5+Pjp27IjZs2cjNDTUoJ9cLsdXX32Ff/7znzh+/DjOnz8PV1dXPPfcc5g1axZ8fX0N2js5OeFf//oXvvjiC3z77bfYvXs3pFIpvLy8EBERYfLUTSIiqp8kwpNrQoiIiMgi/Pz80KtXL2zbtq2uh0JERPUc99QRERERERHZMCZ1RERERERENoxJHRERERERkQ3jnjoiIiIiIiIbxpk6IiIiIiIiG8akjoiIiIiIyIYxqSMiIiIiIrJhTOqIiIiIiIhsGJM6IiIiIiIiG8akjoiIiIiIyIYxqSMiIiIiIrJhTOqIiIiIiIhsGJM6IiIiIiIiG/Z/tgTXP2g85eYAAAAASUVORK5CYII=\n" }, "metadata": {} }, { "output_type": "stream", "name": "stdout", "text": [ "\n", "Epoch 1: LearningRateScheduler setting learning rate to 0.0006.\n", "Epoch 1/100\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 464ms/step - head_1_accuracy: 0.4640 - head_1_loss: 1.5715 - head_2_accuracy: 0.4574 - head_2_loss: 1.6279 - head_3_accuracy: 0.4851 - head_3_loss: 1.4113 - head_4_accuracy: 0.4864 - head_4_loss: 1.4108 - head_5_accuracy: 0.4713 - head_5_loss: 1.4806 - head_6_accuracy: 0.4497 - head_6_loss: 1.5988 - head_7_accuracy: 0.4701 - head_7_loss: 1.4964 - loss: 10.5981\n", "Epoch 1: val_head_1_accuracy improved from None to 0.70696, saving model to /content/drive/My Drive/Classification/multicp/models/GFNet_MultiHead_best.keras\n", "\n", "Epoch 1: finished saving model to /content/drive/My Drive/Classification/multicp/models/GFNet_MultiHead_best.keras\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m124s\u001b[0m 599ms/step - head_1_accuracy: 0.5544 - head_1_loss: 1.1778 - head_2_accuracy: 0.5476 - head_2_loss: 1.1973 - head_3_accuracy: 0.5668 - head_3_loss: 1.1285 - head_4_accuracy: 0.5605 - head_4_loss: 1.1330 - head_5_accuracy: 0.5558 - head_5_loss: 1.1552 - head_6_accuracy: 0.5467 - head_6_loss: 1.1959 - head_7_accuracy: 0.5596 - head_7_loss: 1.1546 - loss: 8.2207 - val_head_1_accuracy: 0.7070 - val_head_1_loss: 0.7630 - val_head_2_accuracy: 0.6998 - val_head_2_loss: 0.7900 - val_head_3_accuracy: 0.7081 - val_head_3_loss: 0.7770 - val_head_4_accuracy: 0.6979 - val_head_4_loss: 0.7991 - val_head_5_accuracy: 0.7028 - val_head_5_loss: 0.7875 - val_head_6_accuracy: 0.6916 - val_head_6_loss: 0.7765 - val_head_7_accuracy: 0.6988 - val_head_7_loss: 0.7723 - val_loss: 5.4628 - learning_rate: 6.0000e-04\n", "\n", "Epoch 2: LearningRateScheduler setting learning rate to 0.0005998489878878364.\n", "Epoch 2/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 181ms/step - head_1_accuracy: 0.7196 - head_1_loss: 0.7438 - head_2_accuracy: 0.7152 - head_2_loss: 0.7529 - head_3_accuracy: 0.7212 - head_3_loss: 0.7406 - head_4_accuracy: 0.7123 - head_4_loss: 0.7488 - head_5_accuracy: 0.7237 - head_5_loss: 0.7395 - head_6_accuracy: 0.7153 - head_6_loss: 0.7484 - head_7_accuracy: 0.7193 - head_7_loss: 0.7358 - loss: 5.2097\n", "Epoch 2: val_head_1_accuracy improved from 0.70696 to 0.80673, saving model to /content/drive/My Drive/Classification/multicp/models/GFNet_MultiHead_best.keras\n", "\n", "Epoch 2: finished saving model to /content/drive/My Drive/Classification/multicp/models/GFNet_MultiHead_best.keras\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 211ms/step - head_1_accuracy: 0.7519 - head_1_loss: 0.6595 - head_2_accuracy: 0.7467 - head_2_loss: 0.6666 - head_3_accuracy: 0.7482 - head_3_loss: 0.6608 - head_4_accuracy: 0.7481 - head_4_loss: 0.6606 - head_5_accuracy: 0.7518 - head_5_loss: 0.6567 - head_6_accuracy: 0.7471 - head_6_loss: 0.6595 - head_7_accuracy: 0.7488 - head_7_loss: 0.6587 - loss: 4.6677 - val_head_1_accuracy: 0.8067 - val_head_1_loss: 0.5372 - val_head_2_accuracy: 0.8032 - val_head_2_loss: 0.5437 - val_head_3_accuracy: 0.8028 - val_head_3_loss: 0.5497 - val_head_4_accuracy: 0.8067 - val_head_4_loss: 0.5425 - val_head_5_accuracy: 0.8049 - val_head_5_loss: 0.5425 - val_head_6_accuracy: 0.8063 - val_head_6_loss: 0.5443 - val_head_7_accuracy: 0.8023 - val_head_7_loss: 0.5458 - val_loss: 3.8039 - learning_rate: 5.9985e-04\n", "\n", "Epoch 3: LearningRateScheduler setting learning rate to 0.0005993961036077416.\n", "Epoch 3/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 191ms/step - head_1_accuracy: 0.8204 - head_1_loss: 0.5097 - head_2_accuracy: 0.8143 - head_2_loss: 0.5104 - head_3_accuracy: 0.8165 - head_3_loss: 0.5136 - head_4_accuracy: 0.8213 - head_4_loss: 0.5101 - head_5_accuracy: 0.8177 - head_5_loss: 0.5099 - head_6_accuracy: 0.8185 - head_6_loss: 0.5112 - head_7_accuracy: 0.8199 - head_7_loss: 0.5076 - loss: 3.5726\n", "Epoch 3: val_head_1_accuracy improved from 0.80673 to 0.84733, saving model to /content/drive/My Drive/Classification/multicp/models/GFNet_MultiHead_best.keras\n", "\n", "Epoch 3: finished saving model to /content/drive/My Drive/Classification/multicp/models/GFNet_MultiHead_best.keras\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m23s\u001b[0m 228ms/step - head_1_accuracy: 0.8373 - head_1_loss: 0.4586 - head_2_accuracy: 0.8339 - head_2_loss: 0.4593 - head_3_accuracy: 0.8354 - head_3_loss: 0.4606 - head_4_accuracy: 0.8370 - head_4_loss: 0.4582 - head_5_accuracy: 0.8369 - head_5_loss: 0.4569 - head_6_accuracy: 0.8364 - head_6_loss: 0.4604 - head_7_accuracy: 0.8348 - head_7_loss: 0.4576 - loss: 3.2430 - val_head_1_accuracy: 0.8473 - val_head_1_loss: 0.4511 - val_head_2_accuracy: 0.8434 - val_head_2_loss: 0.4572 - val_head_3_accuracy: 0.8406 - val_head_3_loss: 0.4751 - val_head_4_accuracy: 0.8399 - val_head_4_loss: 0.4632 - val_head_5_accuracy: 0.8418 - val_head_5_loss: 0.4634 - val_head_6_accuracy: 0.8427 - val_head_6_loss: 0.4544 - val_head_7_accuracy: 0.8413 - val_head_7_loss: 0.4653 - val_loss: 3.2265 - learning_rate: 5.9940e-04\n", "\n", "Epoch 4: LearningRateScheduler setting learning rate to 0.0005986418031757967.\n", "Epoch 4/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 188ms/step - head_1_accuracy: 0.8562 - head_1_loss: 0.3996 - head_2_accuracy: 0.8514 - head_2_loss: 0.4092 - head_3_accuracy: 0.8564 - head_3_loss: 0.4037 - head_4_accuracy: 0.8549 - head_4_loss: 0.4063 - head_5_accuracy: 0.8534 - head_5_loss: 0.4023 - head_6_accuracy: 0.8565 - head_6_loss: 0.4020 - head_7_accuracy: 0.8546 - head_7_loss: 0.4054 - loss: 2.8284\n", "Epoch 4: val_head_1_accuracy improved from 0.84733 to 0.86334, saving model to /content/drive/My Drive/Classification/multicp/models/GFNet_MultiHead_best.keras\n", "\n", "Epoch 4: finished saving model to /content/drive/My Drive/Classification/multicp/models/GFNet_MultiHead_best.keras\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m40s\u001b[0m 218ms/step - head_1_accuracy: 0.8684 - head_1_loss: 0.3630 - head_2_accuracy: 0.8664 - head_2_loss: 0.3665 - head_3_accuracy: 0.8676 - head_3_loss: 0.3649 - head_4_accuracy: 0.8689 - head_4_loss: 0.3654 - head_5_accuracy: 0.8675 - head_5_loss: 0.3639 - head_6_accuracy: 0.8689 - head_6_loss: 0.3643 - head_7_accuracy: 0.8684 - head_7_loss: 0.3637 - loss: 2.5767 - val_head_1_accuracy: 0.8633 - val_head_1_loss: 0.3993 - val_head_2_accuracy: 0.8650 - val_head_2_loss: 0.3944 - val_head_3_accuracy: 0.8622 - val_head_3_loss: 0.4044 - val_head_4_accuracy: 0.8610 - val_head_4_loss: 0.4119 - val_head_5_accuracy: 0.8643 - val_head_5_loss: 0.4022 - val_head_6_accuracy: 0.8633 - val_head_6_loss: 0.4011 - val_head_7_accuracy: 0.8664 - val_head_7_loss: 0.3984 - val_loss: 2.8080 - learning_rate: 5.9864e-04\n", "\n", "Epoch 5: LearningRateScheduler setting learning rate to 0.000597586846108597.\n", "Epoch 5/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 194ms/step - head_1_accuracy: 0.8846 - head_1_loss: 0.3274 - head_2_accuracy: 0.8831 - head_2_loss: 0.3297 - head_3_accuracy: 0.8855 - head_3_loss: 0.3299 - head_4_accuracy: 0.8861 - head_4_loss: 0.3243 - head_5_accuracy: 0.8815 - head_5_loss: 0.3278 - head_6_accuracy: 0.8845 - head_6_loss: 0.3303 - head_7_accuracy: 0.8854 - head_7_loss: 0.3239 - loss: 2.2933\n", "Epoch 5: val_head_1_accuracy improved from 0.86334 to 0.89118, saving model to /content/drive/My Drive/Classification/multicp/models/GFNet_MultiHead_best.keras\n", "\n", "Epoch 5: finished saving model to /content/drive/My Drive/Classification/multicp/models/GFNet_MultiHead_best.keras\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m23s\u001b[0m 229ms/step - head_1_accuracy: 0.8925 - head_1_loss: 0.3041 - head_2_accuracy: 0.8895 - head_2_loss: 0.3061 - head_3_accuracy: 0.8923 - head_3_loss: 0.3057 - head_4_accuracy: 0.8915 - head_4_loss: 0.3037 - head_5_accuracy: 0.8897 - head_5_loss: 0.3057 - head_6_accuracy: 0.8912 - head_6_loss: 0.3060 - head_7_accuracy: 0.8917 - head_7_loss: 0.3031 - loss: 2.1555 - val_head_1_accuracy: 0.8912 - val_head_1_loss: 0.3015 - val_head_2_accuracy: 0.8893 - val_head_2_loss: 0.3103 - val_head_3_accuracy: 0.8875 - val_head_3_loss: 0.3050 - val_head_4_accuracy: 0.8896 - val_head_4_loss: 0.3074 - val_head_5_accuracy: 0.8884 - val_head_5_loss: 0.3037 - val_head_6_accuracy: 0.8900 - val_head_6_loss: 0.3042 - val_head_7_accuracy: 0.8891 - val_head_7_loss: 0.3017 - val_loss: 2.1303 - learning_rate: 5.9759e-04\n", "\n", "Epoch 6: LearningRateScheduler setting learning rate to 0.0005962322946584844.\n", "Epoch 6/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 196ms/step - head_1_accuracy: 0.9099 - head_1_loss: 0.2573 - head_2_accuracy: 0.9082 - head_2_loss: 0.2639 - head_3_accuracy: 0.9051 - head_3_loss: 0.2604 - head_4_accuracy: 0.9099 - head_4_loss: 0.2573 - head_5_accuracy: 0.9095 - head_5_loss: 0.2597 - head_6_accuracy: 0.9056 - head_6_loss: 0.2610 - head_7_accuracy: 0.9090 - head_7_loss: 0.2584 - loss: 1.8180\n", "Epoch 6: val_head_1_accuracy improved from 0.89118 to 0.91972, saving model to /content/drive/My Drive/Classification/multicp/models/GFNet_MultiHead_best.keras\n", "\n", "Epoch 6: finished saving model to /content/drive/My Drive/Classification/multicp/models/GFNet_MultiHead_best.keras\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m23s\u001b[0m 228ms/step - head_1_accuracy: 0.9205 - head_1_loss: 0.2244 - head_2_accuracy: 0.9194 - head_2_loss: 0.2280 - head_3_accuracy: 0.9168 - head_3_loss: 0.2272 - head_4_accuracy: 0.9201 - head_4_loss: 0.2240 - head_5_accuracy: 0.9216 - head_5_loss: 0.2246 - head_6_accuracy: 0.9168 - head_6_loss: 0.2269 - head_7_accuracy: 0.9176 - head_7_loss: 0.2259 - loss: 1.5965 - val_head_1_accuracy: 0.9197 - val_head_1_loss: 0.2376 - val_head_2_accuracy: 0.9197 - val_head_2_loss: 0.2433 - val_head_3_accuracy: 0.9195 - val_head_3_loss: 0.2434 - val_head_4_accuracy: 0.9206 - val_head_4_loss: 0.2422 - val_head_5_accuracy: 0.9190 - val_head_5_loss: 0.2431 - val_head_6_accuracy: 0.9202 - val_head_6_loss: 0.2420 - val_head_7_accuracy: 0.9220 - val_head_7_loss: 0.2417 - val_loss: 1.6869 - learning_rate: 5.9623e-04\n", "\n", "Epoch 7: LearningRateScheduler setting learning rate to 0.0005945795127439488.\n", "Epoch 7/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 202ms/step - head_1_accuracy: 0.9203 - head_1_loss: 0.2199 - head_2_accuracy: 0.9195 - head_2_loss: 0.2240 - head_3_accuracy: 0.9174 - head_3_loss: 0.2233 - head_4_accuracy: 0.9204 - head_4_loss: 0.2208 - head_5_accuracy: 0.9205 - head_5_loss: 0.2224 - head_6_accuracy: 0.9197 - head_6_loss: 0.2209 - head_7_accuracy: 0.9182 - head_7_loss: 0.2186 - loss: 1.5499\n", "Epoch 7: val_head_1_accuracy did not improve from 0.91972\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 211ms/step - head_1_accuracy: 0.9250 - head_1_loss: 0.2069 - head_2_accuracy: 0.9245 - head_2_loss: 0.2089 - head_3_accuracy: 0.9232 - head_3_loss: 0.2095 - head_4_accuracy: 0.9244 - head_4_loss: 0.2067 - head_5_accuracy: 0.9259 - head_5_loss: 0.2084 - head_6_accuracy: 0.9268 - head_6_loss: 0.2072 - head_7_accuracy: 0.9244 - head_7_loss: 0.2055 - loss: 1.4674 - val_head_1_accuracy: 0.8691 - val_head_1_loss: 0.4512 - val_head_2_accuracy: 0.8680 - val_head_2_loss: 0.4545 - val_head_3_accuracy: 0.8666 - val_head_3_loss: 0.4515 - val_head_4_accuracy: 0.8691 - val_head_4_loss: 0.4435 - val_head_5_accuracy: 0.8680 - val_head_5_loss: 0.4569 - val_head_6_accuracy: 0.8712 - val_head_6_loss: 0.4500 - val_head_7_accuracy: 0.8708 - val_head_7_loss: 0.4588 - val_loss: 3.1667 - learning_rate: 5.9458e-04\n", "\n", "Epoch 8: LearningRateScheduler setting learning rate to 0.0005926301645762779.\n", "Epoch 8/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 203ms/step - head_1_accuracy: 0.9285 - head_1_loss: 0.2084 - head_2_accuracy: 0.9238 - head_2_loss: 0.2119 - head_3_accuracy: 0.9253 - head_3_loss: 0.2106 - head_4_accuracy: 0.9260 - head_4_loss: 0.2052 - head_5_accuracy: 0.9260 - head_5_loss: 0.2111 - head_6_accuracy: 0.9237 - head_6_loss: 0.2061 - head_7_accuracy: 0.9240 - head_7_loss: 0.2103 - loss: 1.4637\n", "Epoch 8: val_head_1_accuracy improved from 0.91972 to 0.94640, saving model to /content/drive/My Drive/Classification/multicp/models/GFNet_MultiHead_best.keras\n", "\n", "Epoch 8: finished saving model to /content/drive/My Drive/Classification/multicp/models/GFNet_MultiHead_best.keras\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m24s\u001b[0m 236ms/step - head_1_accuracy: 0.9424 - head_1_loss: 0.1638 - head_2_accuracy: 0.9401 - head_2_loss: 0.1651 - head_3_accuracy: 0.9408 - head_3_loss: 0.1635 - head_4_accuracy: 0.9412 - head_4_loss: 0.1626 - head_5_accuracy: 0.9401 - head_5_loss: 0.1651 - head_6_accuracy: 0.9398 - head_6_loss: 0.1632 - head_7_accuracy: 0.9389 - head_7_loss: 0.1648 - loss: 1.1594 - val_head_1_accuracy: 0.9464 - val_head_1_loss: 0.1807 - val_head_2_accuracy: 0.9466 - val_head_2_loss: 0.1765 - val_head_3_accuracy: 0.9459 - val_head_3_loss: 0.1818 - val_head_4_accuracy: 0.9469 - val_head_4_loss: 0.1757 - val_head_5_accuracy: 0.9466 - val_head_5_loss: 0.1744 - val_head_6_accuracy: 0.9452 - val_head_6_loss: 0.1769 - val_head_7_accuracy: 0.9476 - val_head_7_loss: 0.1795 - val_loss: 1.2451 - learning_rate: 5.9263e-04\n", "\n", "Epoch 9: LearningRateScheduler setting learning rate to 0.0005903862129838371.\n", "Epoch 9/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 210ms/step - head_1_accuracy: 0.9528 - head_1_loss: 0.1357 - head_2_accuracy: 0.9529 - head_2_loss: 0.1319 - head_3_accuracy: 0.9514 - head_3_loss: 0.1323 - head_4_accuracy: 0.9514 - head_4_loss: 0.1351 - head_5_accuracy: 0.9541 - head_5_loss: 0.1336 - head_6_accuracy: 0.9544 - head_6_loss: 0.1316 - head_7_accuracy: 0.9539 - head_7_loss: 0.1339 - loss: 0.9342\n", "Epoch 9: val_head_1_accuracy did not improve from 0.94640\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 218ms/step - head_1_accuracy: 0.9538 - head_1_loss: 0.1322 - head_2_accuracy: 0.9537 - head_2_loss: 0.1309 - head_3_accuracy: 0.9527 - head_3_loss: 0.1307 - head_4_accuracy: 0.9537 - head_4_loss: 0.1321 - head_5_accuracy: 0.9551 - head_5_loss: 0.1321 - head_6_accuracy: 0.9539 - head_6_loss: 0.1310 - head_7_accuracy: 0.9534 - head_7_loss: 0.1319 - loss: 0.9300 - val_head_1_accuracy: 0.9035 - val_head_1_loss: 0.3151 - val_head_2_accuracy: 0.9046 - val_head_2_loss: 0.3182 - val_head_3_accuracy: 0.9032 - val_head_3_loss: 0.3181 - val_head_4_accuracy: 0.9042 - val_head_4_loss: 0.3124 - val_head_5_accuracy: 0.9023 - val_head_5_loss: 0.3264 - val_head_6_accuracy: 0.9030 - val_head_6_loss: 0.3196 - val_head_7_accuracy: 0.9067 - val_head_7_loss: 0.3082 - val_loss: 2.2177 - learning_rate: 5.9039e-04\n", "\n", "Epoch 10: LearningRateScheduler setting learning rate to 0.0005878499174356684.\n", "Epoch 10/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 208ms/step - head_1_accuracy: 0.9500 - head_1_loss: 0.1389 - head_2_accuracy: 0.9496 - head_2_loss: 0.1406 - head_3_accuracy: 0.9499 - head_3_loss: 0.1369 - head_4_accuracy: 0.9503 - head_4_loss: 0.1386 - head_5_accuracy: 0.9500 - head_5_loss: 0.1371 - head_6_accuracy: 0.9494 - head_6_loss: 0.1372 - head_7_accuracy: 0.9523 - head_7_loss: 0.1373 - loss: 0.9666\n", "Epoch 10: val_head_1_accuracy improved from 0.94640 to 0.95824, saving model to /content/drive/My Drive/Classification/multicp/models/GFNet_MultiHead_best.keras\n", "\n", "Epoch 10: finished saving model to /content/drive/My Drive/Classification/multicp/models/GFNet_MultiHead_best.keras\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m25s\u001b[0m 243ms/step - head_1_accuracy: 0.9604 - head_1_loss: 0.1104 - head_2_accuracy: 0.9595 - head_2_loss: 0.1123 - head_3_accuracy: 0.9607 - head_3_loss: 0.1097 - head_4_accuracy: 0.9604 - head_4_loss: 0.1098 - head_5_accuracy: 0.9602 - head_5_loss: 0.1091 - head_6_accuracy: 0.9596 - head_6_loss: 0.1104 - head_7_accuracy: 0.9622 - head_7_loss: 0.1093 - loss: 0.7786 - val_head_1_accuracy: 0.9582 - val_head_1_loss: 0.1261 - val_head_2_accuracy: 0.9608 - val_head_2_loss: 0.1201 - val_head_3_accuracy: 0.9594 - val_head_3_loss: 0.1289 - val_head_4_accuracy: 0.9582 - val_head_4_loss: 0.1268 - val_head_5_accuracy: 0.9580 - val_head_5_loss: 0.1295 - val_head_6_accuracy: 0.9592 - val_head_6_loss: 0.1245 - val_head_7_accuracy: 0.9582 - val_head_7_loss: 0.1293 - val_loss: 0.8854 - learning_rate: 5.8785e-04\n", "\n", "Epoch 11: LearningRateScheduler setting learning rate to 0.0005850238317663965.\n", "Epoch 11/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 211ms/step - head_1_accuracy: 0.9695 - head_1_loss: 0.0954 - head_2_accuracy: 0.9699 - head_2_loss: 0.0947 - head_3_accuracy: 0.9683 - head_3_loss: 0.0972 - head_4_accuracy: 0.9682 - head_4_loss: 0.0944 - head_5_accuracy: 0.9676 - head_5_loss: 0.0961 - head_6_accuracy: 0.9683 - head_6_loss: 0.0960 - head_7_accuracy: 0.9670 - head_7_loss: 0.0957 - loss: 0.6695\n", "Epoch 11: val_head_1_accuracy improved from 0.95824 to 0.97703, saving model to /content/drive/My Drive/Classification/multicp/models/GFNet_MultiHead_best.keras\n", "\n", "Epoch 11: finished saving model to /content/drive/My Drive/Classification/multicp/models/GFNet_MultiHead_best.keras\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m24s\u001b[0m 238ms/step - head_1_accuracy: 0.9744 - head_1_loss: 0.0794 - head_2_accuracy: 0.9742 - head_2_loss: 0.0799 - head_3_accuracy: 0.9737 - head_3_loss: 0.0803 - head_4_accuracy: 0.9734 - head_4_loss: 0.0795 - head_5_accuracy: 0.9732 - head_5_loss: 0.0797 - head_6_accuracy: 0.9738 - head_6_loss: 0.0798 - head_7_accuracy: 0.9726 - head_7_loss: 0.0799 - loss: 0.5640 - val_head_1_accuracy: 0.9770 - val_head_1_loss: 0.0725 - val_head_2_accuracy: 0.9782 - val_head_2_loss: 0.0696 - val_head_3_accuracy: 0.9777 - val_head_3_loss: 0.0717 - val_head_4_accuracy: 0.9784 - val_head_4_loss: 0.0705 - val_head_5_accuracy: 0.9768 - val_head_5_loss: 0.0750 - val_head_6_accuracy: 0.9759 - val_head_6_loss: 0.0738 - val_head_7_accuracy: 0.9777 - val_head_7_loss: 0.0711 - val_loss: 0.5032 - learning_rate: 5.8502e-04\n", "\n", "Epoch 12: LearningRateScheduler setting learning rate to 0.0005819108016047332.\n", "Epoch 12/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 200ms/step - head_1_accuracy: 0.9708 - head_1_loss: 0.0851 - head_2_accuracy: 0.9700 - head_2_loss: 0.0843 - head_3_accuracy: 0.9693 - head_3_loss: 0.0830 - head_4_accuracy: 0.9688 - head_4_loss: 0.0831 - head_5_accuracy: 0.9712 - head_5_loss: 0.0834 - head_6_accuracy: 0.9695 - head_6_loss: 0.0842 - head_7_accuracy: 0.9717 - head_7_loss: 0.0823 - loss: 0.5855\n", "Epoch 12: val_head_1_accuracy improved from 0.97703 to 0.97865, saving model to /content/drive/My Drive/Classification/multicp/models/GFNet_MultiHead_best.keras\n", "\n", "Epoch 12: finished saving model to /content/drive/My Drive/Classification/multicp/models/GFNet_MultiHead_best.keras\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m40s\u001b[0m 225ms/step - head_1_accuracy: 0.9731 - head_1_loss: 0.0783 - head_2_accuracy: 0.9728 - head_2_loss: 0.0787 - head_3_accuracy: 0.9720 - head_3_loss: 0.0772 - head_4_accuracy: 0.9728 - head_4_loss: 0.0778 - head_5_accuracy: 0.9745 - head_5_loss: 0.0774 - head_6_accuracy: 0.9734 - head_6_loss: 0.0781 - head_7_accuracy: 0.9739 - head_7_loss: 0.0769 - loss: 0.5497 - val_head_1_accuracy: 0.9787 - val_head_1_loss: 0.0657 - val_head_2_accuracy: 0.9773 - val_head_2_loss: 0.0691 - val_head_3_accuracy: 0.9787 - val_head_3_loss: 0.0674 - val_head_4_accuracy: 0.9775 - val_head_4_loss: 0.0673 - val_head_5_accuracy: 0.9777 - val_head_5_loss: 0.0695 - val_head_6_accuracy: 0.9796 - val_head_6_loss: 0.0652 - val_head_7_accuracy: 0.9782 - val_head_7_loss: 0.0677 - val_loss: 0.4708 - learning_rate: 5.8191e-04\n", "\n", "Epoch 13: LearningRateScheduler setting learning rate to 0.0005785139615081709.\n", "Epoch 13/100\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 208ms/step - head_1_accuracy: 0.9778 - head_1_loss: 0.0635 - head_2_accuracy: 0.9767 - head_2_loss: 0.0637 - head_3_accuracy: 0.9796 - head_3_loss: 0.0629 - head_4_accuracy: 0.9778 - head_4_loss: 0.0643 - head_5_accuracy: 0.9789 - head_5_loss: 0.0636 - head_6_accuracy: 0.9782 - head_6_loss: 0.0645 - head_7_accuracy: 0.9785 - head_7_loss: 0.0627 - loss: 0.4453\n", "Epoch 13: val_head_1_accuracy improved from 0.97865 to 0.98167, saving model to /content/drive/My Drive/Classification/multicp/models/GFNet_MultiHead_best.keras\n", "\n", "Epoch 13: finished saving model to /content/drive/My Drive/Classification/multicp/models/GFNet_MultiHead_best.keras\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m25s\u001b[0m 242ms/step - head_1_accuracy: 0.9787 - head_1_loss: 0.0606 - head_2_accuracy: 0.9773 - head_2_loss: 0.0619 - head_3_accuracy: 0.9788 - head_3_loss: 0.0614 - head_4_accuracy: 0.9791 - head_4_loss: 0.0613 - head_5_accuracy: 0.9796 - head_5_loss: 0.0609 - head_6_accuracy: 0.9787 - head_6_loss: 0.0624 - head_7_accuracy: 0.9788 - head_7_loss: 0.0617 - loss: 0.4344 - val_head_1_accuracy: 0.9817 - val_head_1_loss: 0.0544 - val_head_2_accuracy: 0.9812 - val_head_2_loss: 0.0580 - val_head_3_accuracy: 0.9812 - val_head_3_loss: 0.0600 - val_head_4_accuracy: 0.9805 - val_head_4_loss: 0.0594 - val_head_5_accuracy: 0.9819 - val_head_5_loss: 0.0588 - val_head_6_accuracy: 0.9817 - val_head_6_loss: 0.0575 - val_head_7_accuracy: 0.9812 - val_head_7_loss: 0.0575 - val_loss: 0.4064 - learning_rate: 5.7851e-04\n", "\n", "Epoch 14: LearningRateScheduler setting learning rate to 0.0005748367318067492.\n", "Epoch 14/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 196ms/step - head_1_accuracy: 0.9794 - head_1_loss: 0.0628 - head_2_accuracy: 0.9792 - head_2_loss: 0.0626 - head_3_accuracy: 0.9795 - head_3_loss: 0.0620 - head_4_accuracy: 0.9787 - head_4_loss: 0.0637 - head_5_accuracy: 0.9785 - head_5_loss: 0.0637 - head_6_accuracy: 0.9785 - head_6_loss: 0.0633 - head_7_accuracy: 0.9782 - head_7_loss: 0.0624 - loss: 0.4405\n", "Epoch 14: val_head_1_accuracy improved from 0.98167 to 0.98724, saving model to /content/drive/My Drive/Classification/multicp/models/GFNet_MultiHead_best.keras\n", "\n", "Epoch 14: finished saving model to /content/drive/My Drive/Classification/multicp/models/GFNet_MultiHead_best.keras\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m41s\u001b[0m 247ms/step - head_1_accuracy: 0.9812 - head_1_loss: 0.0552 - head_2_accuracy: 0.9808 - head_2_loss: 0.0557 - head_3_accuracy: 0.9814 - head_3_loss: 0.0547 - head_4_accuracy: 0.9811 - head_4_loss: 0.0561 - head_5_accuracy: 0.9809 - head_5_loss: 0.0567 - head_6_accuracy: 0.9805 - head_6_loss: 0.0554 - head_7_accuracy: 0.9806 - head_7_loss: 0.0551 - loss: 0.3927 - val_head_1_accuracy: 0.9872 - val_head_1_loss: 0.0440 - val_head_2_accuracy: 0.9863 - val_head_2_loss: 0.0442 - val_head_3_accuracy: 0.9865 - val_head_3_loss: 0.0451 - val_head_4_accuracy: 0.9868 - val_head_4_loss: 0.0442 - val_head_5_accuracy: 0.9858 - val_head_5_loss: 0.0449 - val_head_6_accuracy: 0.9872 - val_head_6_loss: 0.0447 - val_head_7_accuracy: 0.9863 - val_head_7_loss: 0.0444 - val_loss: 0.3117 - learning_rate: 5.7484e-04\n", "\n", "Epoch 15: LearningRateScheduler setting learning rate to 0.0005708828151590721.\n", "Epoch 15/100\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 202ms/step - head_1_accuracy: 0.9839 - head_1_loss: 0.0478 - head_2_accuracy: 0.9844 - head_2_loss: 0.0474 - head_3_accuracy: 0.9845 - head_3_loss: 0.0474 - head_4_accuracy: 0.9842 - head_4_loss: 0.0459 - head_5_accuracy: 0.9838 - head_5_loss: 0.0475 - head_6_accuracy: 0.9844 - head_6_loss: 0.0470 - head_7_accuracy: 0.9844 - head_7_loss: 0.0477 - loss: 0.3307\n", "Epoch 15: val_head_1_accuracy did not improve from 0.98724\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 214ms/step - head_1_accuracy: 0.9838 - head_1_loss: 0.0496 - head_2_accuracy: 0.9840 - head_2_loss: 0.0494 - head_3_accuracy: 0.9841 - head_3_loss: 0.0493 - head_4_accuracy: 0.9834 - head_4_loss: 0.0486 - head_5_accuracy: 0.9830 - head_5_loss: 0.0496 - head_6_accuracy: 0.9836 - head_6_loss: 0.0493 - head_7_accuracy: 0.9836 - head_7_loss: 0.0505 - loss: 0.3497 - val_head_1_accuracy: 0.9791 - val_head_1_loss: 0.0664 - val_head_2_accuracy: 0.9784 - val_head_2_loss: 0.0690 - val_head_3_accuracy: 0.9791 - val_head_3_loss: 0.0678 - val_head_4_accuracy: 0.9794 - val_head_4_loss: 0.0669 - val_head_5_accuracy: 0.9789 - val_head_5_loss: 0.0670 - val_head_6_accuracy: 0.9789 - val_head_6_loss: 0.0699 - val_head_7_accuracy: 0.9794 - val_head_7_loss: 0.0682 - val_loss: 0.4773 - learning_rate: 5.7088e-04\n", "\n", "Epoch 16: LearningRateScheduler setting learning rate to 0.0005666561928240443.\n", "Epoch 16/100\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 202ms/step - head_1_accuracy: 0.9867 - head_1_loss: 0.0446 - head_2_accuracy: 0.9851 - head_2_loss: 0.0450 - head_3_accuracy: 0.9869 - head_3_loss: 0.0444 - head_4_accuracy: 0.9874 - head_4_loss: 0.0445 - head_5_accuracy: 0.9869 - head_5_loss: 0.0443 - head_6_accuracy: 0.9862 - head_6_loss: 0.0447 - head_7_accuracy: 0.9860 - head_7_loss: 0.0459 - loss: 0.3134\n", "Epoch 16: val_head_1_accuracy improved from 0.98724 to 0.99350, saving model to /content/drive/My Drive/Classification/multicp/models/GFNet_MultiHead_best.keras\n", "\n", "Epoch 16: finished saving model to /content/drive/My Drive/Classification/multicp/models/GFNet_MultiHead_best.keras\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m25s\u001b[0m 240ms/step - head_1_accuracy: 0.9881 - head_1_loss: 0.0365 - head_2_accuracy: 0.9872 - head_2_loss: 0.0374 - head_3_accuracy: 0.9876 - head_3_loss: 0.0371 - head_4_accuracy: 0.9885 - head_4_loss: 0.0370 - head_5_accuracy: 0.9885 - head_5_loss: 0.0365 - head_6_accuracy: 0.9877 - head_6_loss: 0.0368 - head_7_accuracy: 0.9877 - head_7_loss: 0.0373 - loss: 0.2612 - val_head_1_accuracy: 0.9935 - val_head_1_loss: 0.0221 - val_head_2_accuracy: 0.9937 - val_head_2_loss: 0.0221 - val_head_3_accuracy: 0.9930 - val_head_3_loss: 0.0223 - val_head_4_accuracy: 0.9935 - val_head_4_loss: 0.0221 - val_head_5_accuracy: 0.9935 - val_head_5_loss: 0.0228 - val_head_6_accuracy: 0.9940 - val_head_6_loss: 0.0224 - val_head_7_accuracy: 0.9937 - val_head_7_loss: 0.0223 - val_loss: 0.1568 - learning_rate: 5.6666e-04\n", "\n", "Epoch 17: LearningRateScheduler setting learning rate to 0.000562161120652082.\n", "Epoch 17/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 211ms/step - head_1_accuracy: 0.9887 - head_1_loss: 0.0373 - head_2_accuracy: 0.9877 - head_2_loss: 0.0383 - head_3_accuracy: 0.9874 - head_3_loss: 0.0366 - head_4_accuracy: 0.9884 - head_4_loss: 0.0375 - head_5_accuracy: 0.9876 - head_5_loss: 0.0384 - head_6_accuracy: 0.9882 - head_6_loss: 0.0379 - head_7_accuracy: 0.9880 - head_7_loss: 0.0376 - loss: 0.2636\n", "Epoch 17: val_head_1_accuracy did not improve from 0.99350\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 220ms/step - head_1_accuracy: 0.9871 - head_1_loss: 0.0405 - head_2_accuracy: 0.9858 - head_2_loss: 0.0417 - head_3_accuracy: 0.9857 - head_3_loss: 0.0409 - head_4_accuracy: 0.9868 - head_4_loss: 0.0410 - head_5_accuracy: 0.9858 - head_5_loss: 0.0422 - head_6_accuracy: 0.9869 - head_6_loss: 0.0413 - head_7_accuracy: 0.9861 - head_7_loss: 0.0411 - loss: 0.2914 - val_head_1_accuracy: 0.9842 - val_head_1_loss: 0.0525 - val_head_2_accuracy: 0.9847 - val_head_2_loss: 0.0533 - val_head_3_accuracy: 0.9854 - val_head_3_loss: 0.0536 - val_head_4_accuracy: 0.9849 - val_head_4_loss: 0.0511 - val_head_5_accuracy: 0.9854 - val_head_5_loss: 0.0510 - val_head_6_accuracy: 0.9845 - val_head_6_loss: 0.0516 - val_head_7_accuracy: 0.9852 - val_head_7_loss: 0.0516 - val_loss: 0.3662 - learning_rate: 5.6216e-04\n", "\n", "Epoch 18: LearningRateScheduler setting learning rate to 0.0005574021247998313.\n", "Epoch 18/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 209ms/step - head_1_accuracy: 0.9868 - head_1_loss: 0.0364 - head_2_accuracy: 0.9876 - head_2_loss: 0.0362 - head_3_accuracy: 0.9880 - head_3_loss: 0.0362 - head_4_accuracy: 0.9886 - head_4_loss: 0.0346 - head_5_accuracy: 0.9873 - head_5_loss: 0.0364 - head_6_accuracy: 0.9882 - head_6_loss: 0.0349 - head_7_accuracy: 0.9866 - head_7_loss: 0.0353 - loss: 0.2500\n", "Epoch 18: val_head_1_accuracy did not improve from 0.99350\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m23s\u001b[0m 221ms/step - head_1_accuracy: 0.9903 - head_1_loss: 0.0287 - head_2_accuracy: 0.9904 - head_2_loss: 0.0292 - head_3_accuracy: 0.9905 - head_3_loss: 0.0293 - head_4_accuracy: 0.9905 - head_4_loss: 0.0279 - head_5_accuracy: 0.9897 - head_5_loss: 0.0289 - head_6_accuracy: 0.9907 - head_6_loss: 0.0284 - head_7_accuracy: 0.9896 - head_7_loss: 0.0292 - loss: 0.2035 - val_head_1_accuracy: 0.9833 - val_head_1_loss: 0.0427 - val_head_2_accuracy: 0.9835 - val_head_2_loss: 0.0435 - val_head_3_accuracy: 0.9826 - val_head_3_loss: 0.0426 - val_head_4_accuracy: 0.9833 - val_head_4_loss: 0.0448 - val_head_5_accuracy: 0.9831 - val_head_5_loss: 0.0453 - val_head_6_accuracy: 0.9833 - val_head_6_loss: 0.0442 - val_head_7_accuracy: 0.9831 - val_head_7_loss: 0.0433 - val_loss: 0.3080 - learning_rate: 5.5740e-04\n", "\n", "Epoch 19: LearningRateScheduler setting learning rate to 0.0005523839971727127.\n", "Epoch 19/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 208ms/step - head_1_accuracy: 0.9890 - head_1_loss: 0.0323 - head_2_accuracy: 0.9895 - head_2_loss: 0.0319 - head_3_accuracy: 0.9890 - head_3_loss: 0.0315 - head_4_accuracy: 0.9893 - head_4_loss: 0.0314 - head_5_accuracy: 0.9889 - head_5_loss: 0.0329 - head_6_accuracy: 0.9873 - head_6_loss: 0.0333 - head_7_accuracy: 0.9885 - head_7_loss: 0.0320 - loss: 0.2254\n", "Epoch 19: val_head_1_accuracy did not improve from 0.99350\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 215ms/step - head_1_accuracy: 0.9902 - head_1_loss: 0.0289 - head_2_accuracy: 0.9906 - head_2_loss: 0.0287 - head_3_accuracy: 0.9902 - head_3_loss: 0.0288 - head_4_accuracy: 0.9904 - head_4_loss: 0.0285 - head_5_accuracy: 0.9901 - head_5_loss: 0.0295 - head_6_accuracy: 0.9894 - head_6_loss: 0.0295 - head_7_accuracy: 0.9904 - head_7_loss: 0.0289 - loss: 0.2047 - val_head_1_accuracy: 0.9501 - val_head_1_loss: 0.1900 - val_head_2_accuracy: 0.9499 - val_head_2_loss: 0.1920 - val_head_3_accuracy: 0.9501 - val_head_3_loss: 0.1932 - val_head_4_accuracy: 0.9503 - val_head_4_loss: 0.1974 - val_head_5_accuracy: 0.9508 - val_head_5_loss: 0.1880 - val_head_6_accuracy: 0.9510 - val_head_6_loss: 0.1875 - val_head_7_accuracy: 0.9501 - val_head_7_loss: 0.1903 - val_loss: 1.3406 - learning_rate: 5.5238e-04\n", "\n", "Epoch 20: LearningRateScheduler setting learning rate to 0.0005471117905998783.\n", "Epoch 20/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 207ms/step - head_1_accuracy: 0.9815 - head_1_loss: 0.0517 - head_2_accuracy: 0.9818 - head_2_loss: 0.0525 - head_3_accuracy: 0.9822 - head_3_loss: 0.0526 - head_4_accuracy: 0.9811 - head_4_loss: 0.0531 - head_5_accuracy: 0.9820 - head_5_loss: 0.0516 - head_6_accuracy: 0.9823 - head_6_loss: 0.0511 - head_7_accuracy: 0.9821 - head_7_loss: 0.0518 - loss: 0.3644\n", "Epoch 20: val_head_1_accuracy did not improve from 0.99350\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 216ms/step - head_1_accuracy: 0.9804 - head_1_loss: 0.0557 - head_2_accuracy: 0.9802 - head_2_loss: 0.0564 - head_3_accuracy: 0.9804 - head_3_loss: 0.0557 - head_4_accuracy: 0.9802 - head_4_loss: 0.0557 - head_5_accuracy: 0.9809 - head_5_loss: 0.0550 - head_6_accuracy: 0.9810 - head_6_loss: 0.0552 - head_7_accuracy: 0.9800 - head_7_loss: 0.0566 - loss: 0.3942 - val_head_1_accuracy: 0.9831 - val_head_1_loss: 0.0596 - val_head_2_accuracy: 0.9824 - val_head_2_loss: 0.0622 - val_head_3_accuracy: 0.9831 - val_head_3_loss: 0.0604 - val_head_4_accuracy: 0.9835 - val_head_4_loss: 0.0602 - val_head_5_accuracy: 0.9826 - val_head_5_loss: 0.0604 - val_head_6_accuracy: 0.9819 - val_head_6_loss: 0.0612 - val_head_7_accuracy: 0.9828 - val_head_7_loss: 0.0629 - val_loss: 0.4305 - learning_rate: 5.4711e-04\n", "\n", "Epoch 21: LearningRateScheduler setting learning rate to 0.000541590813746441.\n", "Epoch 21/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 207ms/step - head_1_accuracy: 0.9881 - head_1_loss: 0.0340 - head_2_accuracy: 0.9878 - head_2_loss: 0.0341 - head_3_accuracy: 0.9880 - head_3_loss: 0.0345 - head_4_accuracy: 0.9879 - head_4_loss: 0.0339 - head_5_accuracy: 0.9876 - head_5_loss: 0.0346 - head_6_accuracy: 0.9881 - head_6_loss: 0.0349 - head_7_accuracy: 0.9884 - head_7_loss: 0.0333 - loss: 0.2393\n", "Epoch 21: val_head_1_accuracy did not improve from 0.99350\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 214ms/step - head_1_accuracy: 0.9908 - head_1_loss: 0.0278 - head_2_accuracy: 0.9905 - head_2_loss: 0.0278 - head_3_accuracy: 0.9904 - head_3_loss: 0.0284 - head_4_accuracy: 0.9903 - head_4_loss: 0.0278 - head_5_accuracy: 0.9899 - head_5_loss: 0.0285 - head_6_accuracy: 0.9907 - head_6_loss: 0.0283 - head_7_accuracy: 0.9906 - head_7_loss: 0.0277 - loss: 0.1982 - val_head_1_accuracy: 0.9921 - val_head_1_loss: 0.0283 - val_head_2_accuracy: 0.9923 - val_head_2_loss: 0.0285 - val_head_3_accuracy: 0.9921 - val_head_3_loss: 0.0289 - val_head_4_accuracy: 0.9930 - val_head_4_loss: 0.0278 - val_head_5_accuracy: 0.9916 - val_head_5_loss: 0.0292 - val_head_6_accuracy: 0.9921 - val_head_6_loss: 0.0283 - val_head_7_accuracy: 0.9921 - val_head_7_loss: 0.0284 - val_loss: 0.2008 - learning_rate: 5.4159e-04\n", "\n", "Epoch 22: LearningRateScheduler setting learning rate to 0.0005358266257680991.\n", "Epoch 22/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 207ms/step - head_1_accuracy: 0.9883 - head_1_loss: 0.0324 - head_2_accuracy: 0.9892 - head_2_loss: 0.0314 - head_3_accuracy: 0.9886 - head_3_loss: 0.0317 - head_4_accuracy: 0.9895 - head_4_loss: 0.0314 - head_5_accuracy: 0.9884 - head_5_loss: 0.0318 - head_6_accuracy: 0.9885 - head_6_loss: 0.0321 - head_7_accuracy: 0.9888 - head_7_loss: 0.0322 - loss: 0.2230\n", "Epoch 22: val_head_1_accuracy did not improve from 0.99350\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 215ms/step - head_1_accuracy: 0.9895 - head_1_loss: 0.0312 - head_2_accuracy: 0.9901 - head_2_loss: 0.0303 - head_3_accuracy: 0.9886 - head_3_loss: 0.0309 - head_4_accuracy: 0.9896 - head_4_loss: 0.0305 - head_5_accuracy: 0.9896 - head_5_loss: 0.0306 - head_6_accuracy: 0.9895 - head_6_loss: 0.0309 - head_7_accuracy: 0.9898 - head_7_loss: 0.0302 - loss: 0.2166 - val_head_1_accuracy: 0.9919 - val_head_1_loss: 0.0285 - val_head_2_accuracy: 0.9921 - val_head_2_loss: 0.0288 - val_head_3_accuracy: 0.9916 - val_head_3_loss: 0.0290 - val_head_4_accuracy: 0.9916 - val_head_4_loss: 0.0288 - val_head_5_accuracy: 0.9916 - val_head_5_loss: 0.0304 - val_head_6_accuracy: 0.9912 - val_head_6_loss: 0.0291 - val_head_7_accuracy: 0.9912 - val_head_7_loss: 0.0296 - val_loss: 0.2047 - learning_rate: 5.3583e-04\n", "\n", "Epoch 23: LearningRateScheduler setting learning rate to 0.0005298250307135374.\n", "Epoch 23/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 207ms/step - head_1_accuracy: 0.9955 - head_1_loss: 0.0161 - head_2_accuracy: 0.9950 - head_2_loss: 0.0168 - head_3_accuracy: 0.9954 - head_3_loss: 0.0164 - head_4_accuracy: 0.9954 - head_4_loss: 0.0170 - head_5_accuracy: 0.9960 - head_5_loss: 0.0163 - head_6_accuracy: 0.9951 - head_6_loss: 0.0168 - head_7_accuracy: 0.9949 - head_7_loss: 0.0160 - loss: 0.1154\n", "Epoch 23: val_head_1_accuracy did not improve from 0.99350\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 214ms/step - head_1_accuracy: 0.9959 - head_1_loss: 0.0144 - head_2_accuracy: 0.9953 - head_2_loss: 0.0152 - head_3_accuracy: 0.9960 - head_3_loss: 0.0143 - head_4_accuracy: 0.9959 - head_4_loss: 0.0144 - head_5_accuracy: 0.9960 - head_5_loss: 0.0143 - head_6_accuracy: 0.9955 - head_6_loss: 0.0146 - head_7_accuracy: 0.9956 - head_7_loss: 0.0146 - loss: 0.1028 - val_head_1_accuracy: 0.9919 - val_head_1_loss: 0.0276 - val_head_2_accuracy: 0.9919 - val_head_2_loss: 0.0282 - val_head_3_accuracy: 0.9916 - val_head_3_loss: 0.0288 - val_head_4_accuracy: 0.9912 - val_head_4_loss: 0.0293 - val_head_5_accuracy: 0.9910 - val_head_5_loss: 0.0277 - val_head_6_accuracy: 0.9916 - val_head_6_loss: 0.0284 - val_head_7_accuracy: 0.9914 - val_head_7_loss: 0.0289 - val_loss: 0.1978 - learning_rate: 5.2983e-04\n", "\n", "Epoch 24: LearningRateScheduler setting learning rate to 0.0005235920716802426.\n", "Epoch 24/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 206ms/step - head_1_accuracy: 0.9948 - head_1_loss: 0.0173 - head_2_accuracy: 0.9943 - head_2_loss: 0.0179 - head_3_accuracy: 0.9943 - head_3_loss: 0.0176 - head_4_accuracy: 0.9944 - head_4_loss: 0.0168 - head_5_accuracy: 0.9939 - head_5_loss: 0.0179 - head_6_accuracy: 0.9941 - head_6_loss: 0.0172 - head_7_accuracy: 0.9944 - head_7_loss: 0.0173 - loss: 0.1221\n", "Epoch 24: val_head_1_accuracy did not improve from 0.99350\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 215ms/step - head_1_accuracy: 0.9962 - head_1_loss: 0.0128 - head_2_accuracy: 0.9960 - head_2_loss: 0.0130 - head_3_accuracy: 0.9961 - head_3_loss: 0.0129 - head_4_accuracy: 0.9958 - head_4_loss: 0.0129 - head_5_accuracy: 0.9957 - head_5_loss: 0.0132 - head_6_accuracy: 0.9958 - head_6_loss: 0.0129 - head_7_accuracy: 0.9961 - head_7_loss: 0.0129 - loss: 0.0915 - val_head_1_accuracy: 0.9877 - val_head_1_loss: 0.0461 - val_head_2_accuracy: 0.9872 - val_head_2_loss: 0.0469 - val_head_3_accuracy: 0.9889 - val_head_3_loss: 0.0452 - val_head_4_accuracy: 0.9879 - val_head_4_loss: 0.0467 - val_head_5_accuracy: 0.9877 - val_head_5_loss: 0.0462 - val_head_6_accuracy: 0.9877 - val_head_6_loss: 0.0460 - val_head_7_accuracy: 0.9884 - val_head_7_loss: 0.0452 - val_loss: 0.3217 - learning_rate: 5.2359e-04\n", "\n", "Epoch 25: LearningRateScheduler setting learning rate to 0.0005171340247296157.\n", "Epoch 25/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 207ms/step - head_1_accuracy: 0.9814 - head_1_loss: 0.0547 - head_2_accuracy: 0.9816 - head_2_loss: 0.0552 - head_3_accuracy: 0.9821 - head_3_loss: 0.0544 - head_4_accuracy: 0.9827 - head_4_loss: 0.0551 - head_5_accuracy: 0.9823 - head_5_loss: 0.0564 - head_6_accuracy: 0.9818 - head_6_loss: 0.0549 - head_7_accuracy: 0.9817 - head_7_loss: 0.0553 - loss: 0.3860\n", "Epoch 25: val_head_1_accuracy did not improve from 0.99350\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 215ms/step - head_1_accuracy: 0.9804 - head_1_loss: 0.0570 - head_2_accuracy: 0.9807 - head_2_loss: 0.0567 - head_3_accuracy: 0.9809 - head_3_loss: 0.0564 - head_4_accuracy: 0.9807 - head_4_loss: 0.0572 - head_5_accuracy: 0.9808 - head_5_loss: 0.0580 - head_6_accuracy: 0.9804 - head_6_loss: 0.0569 - head_7_accuracy: 0.9800 - head_7_loss: 0.0580 - loss: 0.4042 - val_head_1_accuracy: 0.9889 - val_head_1_loss: 0.0320 - val_head_2_accuracy: 0.9872 - val_head_2_loss: 0.0336 - val_head_3_accuracy: 0.9884 - val_head_3_loss: 0.0323 - val_head_4_accuracy: 0.9882 - val_head_4_loss: 0.0330 - val_head_5_accuracy: 0.9882 - val_head_5_loss: 0.0322 - val_head_6_accuracy: 0.9889 - val_head_6_loss: 0.0321 - val_head_7_accuracy: 0.9877 - val_head_7_loss: 0.0332 - val_loss: 0.2287 - learning_rate: 5.1713e-04\n", "\n", "Epoch 26: LearningRateScheduler setting learning rate to 0.000510457392567511.\n", "Epoch 26/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 207ms/step - head_1_accuracy: 0.9946 - head_1_loss: 0.0172 - head_2_accuracy: 0.9947 - head_2_loss: 0.0170 - head_3_accuracy: 0.9950 - head_3_loss: 0.0178 - head_4_accuracy: 0.9951 - head_4_loss: 0.0170 - head_5_accuracy: 0.9943 - head_5_loss: 0.0170 - head_6_accuracy: 0.9948 - head_6_loss: 0.0174 - head_7_accuracy: 0.9955 - head_7_loss: 0.0178 - loss: 0.1211\n", "Epoch 26: val_head_1_accuracy did not improve from 0.99350\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 215ms/step - head_1_accuracy: 0.9946 - head_1_loss: 0.0164 - head_2_accuracy: 0.9945 - head_2_loss: 0.0162 - head_3_accuracy: 0.9951 - head_3_loss: 0.0162 - head_4_accuracy: 0.9949 - head_4_loss: 0.0157 - head_5_accuracy: 0.9947 - head_5_loss: 0.0162 - head_6_accuracy: 0.9947 - head_6_loss: 0.0164 - head_7_accuracy: 0.9951 - head_7_loss: 0.0165 - loss: 0.1148 - val_head_1_accuracy: 0.9916 - val_head_1_loss: 0.0296 - val_head_2_accuracy: 0.9919 - val_head_2_loss: 0.0298 - val_head_3_accuracy: 0.9919 - val_head_3_loss: 0.0298 - val_head_4_accuracy: 0.9914 - val_head_4_loss: 0.0296 - val_head_5_accuracy: 0.9914 - val_head_5_loss: 0.0305 - val_head_6_accuracy: 0.9916 - val_head_6_loss: 0.0292 - val_head_7_accuracy: 0.9916 - val_head_7_loss: 0.0298 - val_loss: 0.2100 - learning_rate: 5.1046e-04\n", "\n", "Epoch 27: LearningRateScheduler setting learning rate to 0.0005035688979965618.\n", "Epoch 27/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 206ms/step - head_1_accuracy: 0.9937 - head_1_loss: 0.0186 - head_2_accuracy: 0.9935 - head_2_loss: 0.0188 - head_3_accuracy: 0.9940 - head_3_loss: 0.0179 - head_4_accuracy: 0.9942 - head_4_loss: 0.0187 - head_5_accuracy: 0.9930 - head_5_loss: 0.0196 - head_6_accuracy: 0.9935 - head_6_loss: 0.0179 - head_7_accuracy: 0.9943 - head_7_loss: 0.0175 - loss: 0.1290\n", "Epoch 27: val_head_1_accuracy did not improve from 0.99350\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 214ms/step - head_1_accuracy: 0.9944 - head_1_loss: 0.0175 - head_2_accuracy: 0.9940 - head_2_loss: 0.0178 - head_3_accuracy: 0.9941 - head_3_loss: 0.0176 - head_4_accuracy: 0.9946 - head_4_loss: 0.0171 - head_5_accuracy: 0.9942 - head_5_loss: 0.0180 - head_6_accuracy: 0.9944 - head_6_loss: 0.0172 - head_7_accuracy: 0.9942 - head_7_loss: 0.0175 - loss: 0.1239 - val_head_1_accuracy: 0.9914 - val_head_1_loss: 0.0256 - val_head_2_accuracy: 0.9916 - val_head_2_loss: 0.0250 - val_head_3_accuracy: 0.9919 - val_head_3_loss: 0.0252 - val_head_4_accuracy: 0.9919 - val_head_4_loss: 0.0248 - val_head_5_accuracy: 0.9919 - val_head_5_loss: 0.0256 - val_head_6_accuracy: 0.9916 - val_head_6_loss: 0.0246 - val_head_7_accuracy: 0.9921 - val_head_7_loss: 0.0246 - val_loss: 0.1747 - learning_rate: 5.0357e-04\n", "\n", "Epoch 28: LearningRateScheduler setting learning rate to 0.0004964754771468882.\n", "Epoch 28/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 206ms/step - head_1_accuracy: 0.9950 - head_1_loss: 0.0176 - head_2_accuracy: 0.9949 - head_2_loss: 0.0167 - head_3_accuracy: 0.9947 - head_3_loss: 0.0168 - head_4_accuracy: 0.9951 - head_4_loss: 0.0172 - head_5_accuracy: 0.9946 - head_5_loss: 0.0172 - head_6_accuracy: 0.9944 - head_6_loss: 0.0176 - head_7_accuracy: 0.9950 - head_7_loss: 0.0172 - loss: 0.1202\n", "Epoch 28: val_head_1_accuracy improved from 0.99350 to 0.99374, saving model to /content/drive/My Drive/Classification/multicp/models/GFNet_MultiHead_best.keras\n", "\n", "Epoch 28: finished saving model to /content/drive/My Drive/Classification/multicp/models/GFNet_MultiHead_best.keras\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m24s\u001b[0m 235ms/step - head_1_accuracy: 0.9957 - head_1_loss: 0.0153 - head_2_accuracy: 0.9957 - head_2_loss: 0.0147 - head_3_accuracy: 0.9952 - head_3_loss: 0.0147 - head_4_accuracy: 0.9957 - head_4_loss: 0.0146 - head_5_accuracy: 0.9954 - head_5_loss: 0.0148 - head_6_accuracy: 0.9951 - head_6_loss: 0.0152 - head_7_accuracy: 0.9957 - head_7_loss: 0.0147 - loss: 0.1049 - val_head_1_accuracy: 0.9937 - val_head_1_loss: 0.0209 - val_head_2_accuracy: 0.9940 - val_head_2_loss: 0.0215 - val_head_3_accuracy: 0.9944 - val_head_3_loss: 0.0204 - val_head_4_accuracy: 0.9944 - val_head_4_loss: 0.0202 - val_head_5_accuracy: 0.9949 - val_head_5_loss: 0.0209 - val_head_6_accuracy: 0.9942 - val_head_6_loss: 0.0201 - val_head_7_accuracy: 0.9947 - val_head_7_loss: 0.0212 - val_loss: 0.1453 - learning_rate: 4.9648e-04\n", "\n", "Epoch 29: LearningRateScheduler setting learning rate to 0.0004891842724920025.\n", "Epoch 29/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 212ms/step - head_1_accuracy: 0.9968 - head_1_loss: 0.0103 - head_2_accuracy: 0.9972 - head_2_loss: 0.0106 - head_3_accuracy: 0.9966 - head_3_loss: 0.0108 - head_4_accuracy: 0.9971 - head_4_loss: 0.0103 - head_5_accuracy: 0.9973 - head_5_loss: 0.0102 - head_6_accuracy: 0.9969 - head_6_loss: 0.0109 - head_7_accuracy: 0.9960 - head_7_loss: 0.0112 - loss: 0.0743\n", "Epoch 29: val_head_1_accuracy improved from 0.99374 to 0.99745, saving model to /content/drive/My Drive/Classification/multicp/models/GFNet_MultiHead_best.keras\n", "\n", "Epoch 29: finished saving model to /content/drive/My Drive/Classification/multicp/models/GFNet_MultiHead_best.keras\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m24s\u001b[0m 239ms/step - head_1_accuracy: 0.9978 - head_1_loss: 0.0078 - head_2_accuracy: 0.9980 - head_2_loss: 0.0082 - head_3_accuracy: 0.9977 - head_3_loss: 0.0083 - head_4_accuracy: 0.9978 - head_4_loss: 0.0081 - head_5_accuracy: 0.9979 - head_5_loss: 0.0079 - head_6_accuracy: 0.9977 - head_6_loss: 0.0083 - head_7_accuracy: 0.9972 - head_7_loss: 0.0086 - loss: 0.0578 - val_head_1_accuracy: 0.9974 - val_head_1_loss: 0.0089 - val_head_2_accuracy: 0.9974 - val_head_2_loss: 0.0093 - val_head_3_accuracy: 0.9972 - val_head_3_loss: 0.0089 - val_head_4_accuracy: 0.9970 - val_head_4_loss: 0.0088 - val_head_5_accuracy: 0.9974 - val_head_5_loss: 0.0091 - val_head_6_accuracy: 0.9972 - val_head_6_loss: 0.0092 - val_head_7_accuracy: 0.9974 - val_head_7_loss: 0.0089 - val_loss: 0.0624 - learning_rate: 4.8918e-04\n", "\n", "Epoch 30: LearningRateScheduler setting learning rate to 0.0004817026256569431.\n", "Epoch 30/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 206ms/step - head_1_accuracy: 0.9995 - head_1_loss: 0.0031 - head_2_accuracy: 0.9996 - head_2_loss: 0.0028 - head_3_accuracy: 0.9995 - head_3_loss: 0.0029 - head_4_accuracy: 0.9992 - head_4_loss: 0.0029 - head_5_accuracy: 0.9996 - head_5_loss: 0.0026 - head_6_accuracy: 0.9995 - head_6_loss: 0.0028 - head_7_accuracy: 0.9996 - head_7_loss: 0.0026 - loss: 0.0196\n", "Epoch 30: val_head_1_accuracy did not improve from 0.99745\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 214ms/step - head_1_accuracy: 0.9991 - head_1_loss: 0.0036 - head_2_accuracy: 0.9991 - head_2_loss: 0.0035 - head_3_accuracy: 0.9991 - head_3_loss: 0.0035 - head_4_accuracy: 0.9993 - head_4_loss: 0.0034 - head_5_accuracy: 0.9992 - head_5_loss: 0.0032 - head_6_accuracy: 0.9991 - head_6_loss: 0.0033 - head_7_accuracy: 0.9993 - head_7_loss: 0.0032 - loss: 0.0240 - val_head_1_accuracy: 0.9949 - val_head_1_loss: 0.0156 - val_head_2_accuracy: 0.9954 - val_head_2_loss: 0.0162 - val_head_3_accuracy: 0.9958 - val_head_3_loss: 0.0154 - val_head_4_accuracy: 0.9947 - val_head_4_loss: 0.0157 - val_head_5_accuracy: 0.9956 - val_head_5_loss: 0.0154 - val_head_6_accuracy: 0.9949 - val_head_6_loss: 0.0156 - val_head_7_accuracy: 0.9949 - val_head_7_loss: 0.0157 - val_loss: 0.1073 - learning_rate: 4.8170e-04\n", "\n", "Epoch 31: LearningRateScheduler setting learning rate to 0.0004740380700258809.\n", "Epoch 31/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 207ms/step - head_1_accuracy: 0.9980 - head_1_loss: 0.0061 - head_2_accuracy: 0.9977 - head_2_loss: 0.0065 - head_3_accuracy: 0.9976 - head_3_loss: 0.0066 - head_4_accuracy: 0.9980 - head_4_loss: 0.0055 - head_5_accuracy: 0.9978 - head_5_loss: 0.0059 - head_6_accuracy: 0.9980 - head_6_loss: 0.0063 - head_7_accuracy: 0.9976 - head_7_loss: 0.0064 - loss: 0.0431\n", "Epoch 31: val_head_1_accuracy did not improve from 0.99745\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 215ms/step - head_1_accuracy: 0.9982 - head_1_loss: 0.0061 - head_2_accuracy: 0.9979 - head_2_loss: 0.0062 - head_3_accuracy: 0.9979 - head_3_loss: 0.0065 - head_4_accuracy: 0.9981 - head_4_loss: 0.0059 - head_5_accuracy: 0.9980 - head_5_loss: 0.0062 - head_6_accuracy: 0.9983 - head_6_loss: 0.0060 - head_7_accuracy: 0.9979 - head_7_loss: 0.0063 - loss: 0.0435 - val_head_1_accuracy: 0.9935 - val_head_1_loss: 0.0248 - val_head_2_accuracy: 0.9937 - val_head_2_loss: 0.0248 - val_head_3_accuracy: 0.9937 - val_head_3_loss: 0.0244 - val_head_4_accuracy: 0.9937 - val_head_4_loss: 0.0245 - val_head_5_accuracy: 0.9935 - val_head_5_loss: 0.0244 - val_head_6_accuracy: 0.9937 - val_head_6_loss: 0.0244 - val_head_7_accuracy: 0.9937 - val_head_7_loss: 0.0247 - val_loss: 0.1670 - learning_rate: 4.7404e-04\n", "\n", "Epoch 32: LearningRateScheduler setting learning rate to 0.0004661983231566398.\n", "Epoch 32/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 209ms/step - head_1_accuracy: 0.9973 - head_1_loss: 0.0091 - head_2_accuracy: 0.9971 - head_2_loss: 0.0088 - head_3_accuracy: 0.9974 - head_3_loss: 0.0090 - head_4_accuracy: 0.9970 - head_4_loss: 0.0091 - head_5_accuracy: 0.9977 - head_5_loss: 0.0089 - head_6_accuracy: 0.9973 - head_6_loss: 0.0090 - head_7_accuracy: 0.9976 - head_7_loss: 0.0092 - loss: 0.0630\n", "Epoch 32: val_head_1_accuracy did not improve from 0.99745\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 218ms/step - head_1_accuracy: 0.9975 - head_1_loss: 0.0081 - head_2_accuracy: 0.9976 - head_2_loss: 0.0079 - head_3_accuracy: 0.9977 - head_3_loss: 0.0079 - head_4_accuracy: 0.9974 - head_4_loss: 0.0082 - head_5_accuracy: 0.9980 - head_5_loss: 0.0077 - head_6_accuracy: 0.9975 - head_6_loss: 0.0082 - head_7_accuracy: 0.9979 - head_7_loss: 0.0080 - loss: 0.0566 - val_head_1_accuracy: 0.9963 - val_head_1_loss: 0.0107 - val_head_2_accuracy: 0.9963 - val_head_2_loss: 0.0106 - val_head_3_accuracy: 0.9963 - val_head_3_loss: 0.0103 - val_head_4_accuracy: 0.9963 - val_head_4_loss: 0.0103 - val_head_5_accuracy: 0.9963 - val_head_5_loss: 0.0108 - val_head_6_accuracy: 0.9961 - val_head_6_loss: 0.0106 - val_head_7_accuracy: 0.9963 - val_head_7_loss: 0.0103 - val_loss: 0.0709 - learning_rate: 4.6620e-04\n", "\n", "Epoch 33: LearningRateScheduler setting learning rate to 0.0004581912790097702.\n", "Epoch 33/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 206ms/step - head_1_accuracy: 0.9910 - head_1_loss: 0.0280 - head_2_accuracy: 0.9910 - head_2_loss: 0.0286 - head_3_accuracy: 0.9910 - head_3_loss: 0.0279 - head_4_accuracy: 0.9912 - head_4_loss: 0.0276 - head_5_accuracy: 0.9909 - head_5_loss: 0.0287 - head_6_accuracy: 0.9906 - head_6_loss: 0.0281 - head_7_accuracy: 0.9908 - head_7_loss: 0.0283 - loss: 0.1971\n", "Epoch 33: val_head_1_accuracy did not improve from 0.99745\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 214ms/step - head_1_accuracy: 0.9841 - head_1_loss: 0.0491 - head_2_accuracy: 0.9839 - head_2_loss: 0.0498 - head_3_accuracy: 0.9841 - head_3_loss: 0.0482 - head_4_accuracy: 0.9842 - head_4_loss: 0.0485 - head_5_accuracy: 0.9837 - head_5_loss: 0.0488 - head_6_accuracy: 0.9837 - head_6_loss: 0.0491 - head_7_accuracy: 0.9838 - head_7_loss: 0.0492 - loss: 0.3461 - val_head_1_accuracy: 0.9852 - val_head_1_loss: 0.0524 - val_head_2_accuracy: 0.9858 - val_head_2_loss: 0.0523 - val_head_3_accuracy: 0.9858 - val_head_3_loss: 0.0511 - val_head_4_accuracy: 0.9858 - val_head_4_loss: 0.0514 - val_head_5_accuracy: 0.9854 - val_head_5_loss: 0.0536 - val_head_6_accuracy: 0.9854 - val_head_6_loss: 0.0521 - val_head_7_accuracy: 0.9863 - val_head_7_loss: 0.0501 - val_loss: 0.3632 - learning_rate: 4.5819e-04\n", "\n", "Epoch 34: LearningRateScheduler setting learning rate to 0.000450025.\n", "Epoch 34/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 206ms/step - head_1_accuracy: 0.9930 - head_1_loss: 0.0185 - head_2_accuracy: 0.9936 - head_2_loss: 0.0184 - head_3_accuracy: 0.9930 - head_3_loss: 0.0180 - head_4_accuracy: 0.9933 - head_4_loss: 0.0182 - head_5_accuracy: 0.9920 - head_5_loss: 0.0192 - head_6_accuracy: 0.9935 - head_6_loss: 0.0188 - head_7_accuracy: 0.9931 - head_7_loss: 0.0190 - loss: 0.1300\n", "Epoch 34: val_head_1_accuracy did not improve from 0.99745\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 218ms/step - head_1_accuracy: 0.9954 - head_1_loss: 0.0119 - head_2_accuracy: 0.9959 - head_2_loss: 0.0120 - head_3_accuracy: 0.9954 - head_3_loss: 0.0121 - head_4_accuracy: 0.9957 - head_4_loss: 0.0119 - head_5_accuracy: 0.9954 - head_5_loss: 0.0123 - head_6_accuracy: 0.9957 - head_6_loss: 0.0123 - head_7_accuracy: 0.9954 - head_7_loss: 0.0123 - loss: 0.0856 - val_head_1_accuracy: 0.9949 - val_head_1_loss: 0.0171 - val_head_2_accuracy: 0.9947 - val_head_2_loss: 0.0177 - val_head_3_accuracy: 0.9949 - val_head_3_loss: 0.0169 - val_head_4_accuracy: 0.9949 - val_head_4_loss: 0.0171 - val_head_5_accuracy: 0.9942 - val_head_5_loss: 0.0175 - val_head_6_accuracy: 0.9949 - val_head_6_loss: 0.0173 - val_head_7_accuracy: 0.9944 - val_head_7_loss: 0.0180 - val_loss: 0.1206 - learning_rate: 4.5002e-04\n", "\n", "Epoch 35: LearningRateScheduler setting learning rate to 0.0004417077088780662.\n", "Epoch 35/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 205ms/step - head_1_accuracy: 0.9976 - head_1_loss: 0.0084 - head_2_accuracy: 0.9985 - head_2_loss: 0.0073 - head_3_accuracy: 0.9974 - head_3_loss: 0.0084 - head_4_accuracy: 0.9978 - head_4_loss: 0.0079 - head_5_accuracy: 0.9981 - head_5_loss: 0.0082 - head_6_accuracy: 0.9982 - head_6_loss: 0.0079 - head_7_accuracy: 0.9980 - head_7_loss: 0.0083 - loss: 0.0564\n", "Epoch 35: val_head_1_accuracy did not improve from 0.99745\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m40s\u001b[0m 213ms/step - head_1_accuracy: 0.9975 - head_1_loss: 0.0086 - head_2_accuracy: 0.9978 - head_2_loss: 0.0081 - head_3_accuracy: 0.9974 - head_3_loss: 0.0086 - head_4_accuracy: 0.9978 - head_4_loss: 0.0081 - head_5_accuracy: 0.9978 - head_5_loss: 0.0085 - head_6_accuracy: 0.9979 - head_6_loss: 0.0083 - head_7_accuracy: 0.9978 - head_7_loss: 0.0085 - loss: 0.0592 - val_head_1_accuracy: 0.9914 - val_head_1_loss: 0.0341 - val_head_2_accuracy: 0.9914 - val_head_2_loss: 0.0354 - val_head_3_accuracy: 0.9914 - val_head_3_loss: 0.0339 - val_head_4_accuracy: 0.9910 - val_head_4_loss: 0.0346 - val_head_5_accuracy: 0.9910 - val_head_5_loss: 0.0352 - val_head_6_accuracy: 0.9912 - val_head_6_loss: 0.0345 - val_head_7_accuracy: 0.9914 - val_head_7_loss: 0.0345 - val_loss: 0.2423 - learning_rate: 4.4171e-04\n", "\n", "Epoch 36: LearningRateScheduler setting learning rate to 0.00043324778045110196.\n", "Epoch 36/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 221ms/step - head_1_accuracy: 0.9972 - head_1_loss: 0.0090 - head_2_accuracy: 0.9971 - head_2_loss: 0.0087 - head_3_accuracy: 0.9971 - head_3_loss: 0.0086 - head_4_accuracy: 0.9974 - head_4_loss: 0.0085 - head_5_accuracy: 0.9976 - head_5_loss: 0.0087 - head_6_accuracy: 0.9969 - head_6_loss: 0.0093 - head_7_accuracy: 0.9970 - head_7_loss: 0.0088 - loss: 0.0616\n", "Epoch 36: val_head_1_accuracy improved from 0.99745 to 0.99791, saving model to /content/drive/My Drive/Classification/multicp/models/GFNet_MultiHead_best.keras\n", "\n", "Epoch 36: finished saving model to /content/drive/My Drive/Classification/multicp/models/GFNet_MultiHead_best.keras\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m25s\u001b[0m 247ms/step - head_1_accuracy: 0.9976 - head_1_loss: 0.0073 - head_2_accuracy: 0.9979 - head_2_loss: 0.0069 - head_3_accuracy: 0.9978 - head_3_loss: 0.0069 - head_4_accuracy: 0.9980 - head_4_loss: 0.0069 - head_5_accuracy: 0.9981 - head_5_loss: 0.0069 - head_6_accuracy: 0.9976 - head_6_loss: 0.0072 - head_7_accuracy: 0.9977 - head_7_loss: 0.0071 - loss: 0.0497 - val_head_1_accuracy: 0.9979 - val_head_1_loss: 0.0073 - val_head_2_accuracy: 0.9979 - val_head_2_loss: 0.0074 - val_head_3_accuracy: 0.9979 - val_head_3_loss: 0.0073 - val_head_4_accuracy: 0.9979 - val_head_4_loss: 0.0073 - val_head_5_accuracy: 0.9977 - val_head_5_loss: 0.0074 - val_head_6_accuracy: 0.9977 - val_head_6_loss: 0.0076 - val_head_7_accuracy: 0.9979 - val_head_7_loss: 0.0074 - val_loss: 0.0503 - learning_rate: 4.3325e-04\n", "\n", "Epoch 37: LearningRateScheduler setting learning rate to 0.0004246537331499159.\n", "Epoch 37/100\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 210ms/step - head_1_accuracy: 0.9997 - head_1_loss: 0.0026 - head_2_accuracy: 0.9995 - head_2_loss: 0.0028 - head_3_accuracy: 0.9996 - head_3_loss: 0.0024 - head_4_accuracy: 0.9997 - head_4_loss: 0.0024 - head_5_accuracy: 0.9994 - head_5_loss: 0.0027 - head_6_accuracy: 0.9994 - head_6_loss: 0.0028 - head_7_accuracy: 0.9995 - head_7_loss: 0.0028 - loss: 0.0186\n", "Epoch 37: val_head_1_accuracy improved from 0.99791 to 0.99884, saving model to /content/drive/My Drive/Classification/multicp/models/GFNet_MultiHead_best.keras\n", "\n", "Epoch 37: finished saving model to /content/drive/My Drive/Classification/multicp/models/GFNet_MultiHead_best.keras\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m25s\u001b[0m 245ms/step - head_1_accuracy: 0.9997 - head_1_loss: 0.0024 - head_2_accuracy: 0.9996 - head_2_loss: 0.0024 - head_3_accuracy: 0.9998 - head_3_loss: 0.0020 - head_4_accuracy: 0.9997 - head_4_loss: 0.0023 - head_5_accuracy: 0.9995 - head_5_loss: 0.0023 - head_6_accuracy: 0.9996 - head_6_loss: 0.0023 - head_7_accuracy: 0.9996 - head_7_loss: 0.0026 - loss: 0.0164 - val_head_1_accuracy: 0.9988 - val_head_1_loss: 0.0042 - val_head_2_accuracy: 0.9988 - val_head_2_loss: 0.0043 - val_head_3_accuracy: 0.9986 - val_head_3_loss: 0.0041 - val_head_4_accuracy: 0.9991 - val_head_4_loss: 0.0041 - val_head_5_accuracy: 0.9986 - val_head_5_loss: 0.0043 - val_head_6_accuracy: 0.9986 - val_head_6_loss: 0.0043 - val_head_7_accuracy: 0.9986 - val_head_7_loss: 0.0043 - val_loss: 0.0295 - learning_rate: 4.2465e-04\n", "\n", "Epoch 38: LearningRateScheduler setting learning rate to 0.0004159342204516539.\n", "Epoch 38/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 205ms/step - head_1_accuracy: 0.9999 - head_1_loss: 0.0017 - head_2_accuracy: 1.0000 - head_2_loss: 0.0016 - head_3_accuracy: 1.0000 - head_3_loss: 0.0015 - head_4_accuracy: 0.9999 - head_4_loss: 0.0016 - head_5_accuracy: 0.9999 - head_5_loss: 0.0015 - head_6_accuracy: 1.0000 - head_6_loss: 0.0017 - head_7_accuracy: 1.0000 - head_7_loss: 0.0015 - loss: 0.0111\n", "Epoch 38: val_head_1_accuracy did not improve from 0.99884\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m38s\u001b[0m 212ms/step - head_1_accuracy: 0.9998 - head_1_loss: 0.0015 - head_2_accuracy: 0.9999 - head_2_loss: 0.0013 - head_3_accuracy: 0.9998 - head_3_loss: 0.0013 - head_4_accuracy: 0.9998 - head_4_loss: 0.0014 - head_5_accuracy: 0.9999 - head_5_loss: 0.0014 - head_6_accuracy: 0.9999 - head_6_loss: 0.0015 - head_7_accuracy: 0.9998 - head_7_loss: 0.0014 - loss: 0.0099 - val_head_1_accuracy: 0.9979 - val_head_1_loss: 0.0089 - val_head_2_accuracy: 0.9979 - val_head_2_loss: 0.0091 - val_head_3_accuracy: 0.9979 - val_head_3_loss: 0.0090 - val_head_4_accuracy: 0.9979 - val_head_4_loss: 0.0092 - val_head_5_accuracy: 0.9979 - val_head_5_loss: 0.0090 - val_head_6_accuracy: 0.9979 - val_head_6_loss: 0.0091 - val_head_7_accuracy: 0.9979 - val_head_7_loss: 0.0090 - val_loss: 0.0603 - learning_rate: 4.1593e-04\n", "\n", "Epoch 39: LearningRateScheduler setting learning rate to 0.0004070980221664819.\n", "Epoch 39/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 220ms/step - head_1_accuracy: 1.0000 - head_1_loss: 8.4691e-04 - head_2_accuracy: 1.0000 - head_2_loss: 8.1438e-04 - head_3_accuracy: 1.0000 - head_3_loss: 8.8505e-04 - head_4_accuracy: 1.0000 - head_4_loss: 7.0479e-04 - head_5_accuracy: 1.0000 - head_5_loss: 8.3771e-04 - head_6_accuracy: 1.0000 - head_6_loss: 8.4379e-04 - head_7_accuracy: 1.0000 - head_7_loss: 8.3552e-04 - loss: 0.0058\n", "Epoch 39: val_head_1_accuracy did not improve from 0.99884\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m23s\u001b[0m 228ms/step - head_1_accuracy: 0.9999 - head_1_loss: 8.9537e-04 - head_2_accuracy: 0.9998 - head_2_loss: 9.1499e-04 - head_3_accuracy: 0.9998 - head_3_loss: 0.0010 - head_4_accuracy: 0.9999 - head_4_loss: 8.0450e-04 - head_5_accuracy: 0.9998 - head_5_loss: 9.4798e-04 - head_6_accuracy: 0.9999 - head_6_loss: 9.0450e-04 - head_7_accuracy: 0.9998 - head_7_loss: 8.9763e-04 - loss: 0.0065 - val_head_1_accuracy: 0.9979 - val_head_1_loss: 0.0080 - val_head_2_accuracy: 0.9981 - val_head_2_loss: 0.0081 - val_head_3_accuracy: 0.9981 - val_head_3_loss: 0.0079 - val_head_4_accuracy: 0.9979 - val_head_4_loss: 0.0080 - val_head_5_accuracy: 0.9979 - val_head_5_loss: 0.0082 - val_head_6_accuracy: 0.9979 - val_head_6_loss: 0.0080 - val_head_7_accuracy: 0.9979 - val_head_7_loss: 0.0082 - val_loss: 0.0561 - learning_rate: 4.0710e-04\n", "\n", "Epoch 40: LearningRateScheduler setting learning rate to 0.0003981540355970607.\n", "Epoch 40/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 209ms/step - head_1_accuracy: 0.9980 - head_1_loss: 0.0063 - head_2_accuracy: 0.9981 - head_2_loss: 0.0065 - head_3_accuracy: 0.9981 - head_3_loss: 0.0061 - head_4_accuracy: 0.9984 - head_4_loss: 0.0060 - head_5_accuracy: 0.9982 - head_5_loss: 0.0062 - head_6_accuracy: 0.9982 - head_6_loss: 0.0064 - head_7_accuracy: 0.9978 - head_7_loss: 0.0064 - loss: 0.0439\n", "Epoch 40: val_head_1_accuracy did not improve from 0.99884\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 216ms/step - head_1_accuracy: 0.9947 - head_1_loss: 0.0159 - head_2_accuracy: 0.9949 - head_2_loss: 0.0154 - head_3_accuracy: 0.9947 - head_3_loss: 0.0152 - head_4_accuracy: 0.9949 - head_4_loss: 0.0153 - head_5_accuracy: 0.9949 - head_5_loss: 0.0154 - head_6_accuracy: 0.9954 - head_6_loss: 0.0154 - head_7_accuracy: 0.9940 - head_7_loss: 0.0158 - loss: 0.1094 - val_head_1_accuracy: 0.9926 - val_head_1_loss: 0.0243 - val_head_2_accuracy: 0.9921 - val_head_2_loss: 0.0258 - val_head_3_accuracy: 0.9921 - val_head_3_loss: 0.0274 - val_head_4_accuracy: 0.9921 - val_head_4_loss: 0.0267 - val_head_5_accuracy: 0.9923 - val_head_5_loss: 0.0254 - val_head_6_accuracy: 0.9921 - val_head_6_loss: 0.0262 - val_head_7_accuracy: 0.9921 - val_head_7_loss: 0.0264 - val_loss: 0.1838 - learning_rate: 3.9815e-04\n", "\n", "Epoch 41: LearningRateScheduler setting learning rate to 0.0003891112665797161.\n", "Epoch 41/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 202ms/step - head_1_accuracy: 0.9960 - head_1_loss: 0.0121 - head_2_accuracy: 0.9955 - head_2_loss: 0.0130 - head_3_accuracy: 0.9953 - head_3_loss: 0.0132 - head_4_accuracy: 0.9962 - head_4_loss: 0.0123 - head_5_accuracy: 0.9960 - head_5_loss: 0.0120 - head_6_accuracy: 0.9960 - head_6_loss: 0.0130 - head_7_accuracy: 0.9963 - head_7_loss: 0.0126 - loss: 0.0882\n", "Epoch 41: val_head_1_accuracy did not improve from 0.99884\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 211ms/step - head_1_accuracy: 0.9970 - head_1_loss: 0.0105 - head_2_accuracy: 0.9970 - head_2_loss: 0.0107 - head_3_accuracy: 0.9970 - head_3_loss: 0.0103 - head_4_accuracy: 0.9972 - head_4_loss: 0.0105 - head_5_accuracy: 0.9969 - head_5_loss: 0.0104 - head_6_accuracy: 0.9970 - head_6_loss: 0.0109 - head_7_accuracy: 0.9971 - head_7_loss: 0.0107 - loss: 0.0747 - val_head_1_accuracy: 0.9935 - val_head_1_loss: 0.0257 - val_head_2_accuracy: 0.9940 - val_head_2_loss: 0.0251 - val_head_3_accuracy: 0.9937 - val_head_3_loss: 0.0243 - val_head_4_accuracy: 0.9935 - val_head_4_loss: 0.0248 - val_head_5_accuracy: 0.9937 - val_head_5_loss: 0.0251 - val_head_6_accuracy: 0.9940 - val_head_6_loss: 0.0243 - val_head_7_accuracy: 0.9935 - val_head_7_loss: 0.0243 - val_loss: 0.1729 - learning_rate: 3.8911e-04\n", "\n", "Epoch 42: LearningRateScheduler setting learning rate to 0.000379978820416326.\n", "Epoch 42/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 202ms/step - head_1_accuracy: 0.9974 - head_1_loss: 0.0068 - head_2_accuracy: 0.9981 - head_2_loss: 0.0060 - head_3_accuracy: 0.9976 - head_3_loss: 0.0060 - head_4_accuracy: 0.9978 - head_4_loss: 0.0063 - head_5_accuracy: 0.9979 - head_5_loss: 0.0069 - head_6_accuracy: 0.9979 - head_6_loss: 0.0062 - head_7_accuracy: 0.9980 - head_7_loss: 0.0063 - loss: 0.0445\n", "Epoch 42: val_head_1_accuracy did not improve from 0.99884\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m21s\u001b[0m 210ms/step - head_1_accuracy: 0.9985 - head_1_loss: 0.0046 - head_2_accuracy: 0.9985 - head_2_loss: 0.0047 - head_3_accuracy: 0.9986 - head_3_loss: 0.0044 - head_4_accuracy: 0.9987 - head_4_loss: 0.0045 - head_5_accuracy: 0.9988 - head_5_loss: 0.0048 - head_6_accuracy: 0.9987 - head_6_loss: 0.0044 - head_7_accuracy: 0.9988 - head_7_loss: 0.0044 - loss: 0.0321 - val_head_1_accuracy: 0.9963 - val_head_1_loss: 0.0121 - val_head_2_accuracy: 0.9963 - val_head_2_loss: 0.0126 - val_head_3_accuracy: 0.9963 - val_head_3_loss: 0.0122 - val_head_4_accuracy: 0.9963 - val_head_4_loss: 0.0124 - val_head_5_accuracy: 0.9963 - val_head_5_loss: 0.0129 - val_head_6_accuracy: 0.9968 - val_head_6_loss: 0.0117 - val_head_7_accuracy: 0.9958 - val_head_7_loss: 0.0128 - val_loss: 0.0865 - learning_rate: 3.7998e-04\n", "\n", "Epoch 43: LearningRateScheduler setting learning rate to 0.00037076589270605275.\n", "Epoch 43/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 207ms/step - head_1_accuracy: 0.9996 - head_1_loss: 0.0027 - head_2_accuracy: 0.9995 - head_2_loss: 0.0027 - head_3_accuracy: 0.9996 - head_3_loss: 0.0028 - head_4_accuracy: 0.9995 - head_4_loss: 0.0027 - head_5_accuracy: 0.9995 - head_5_loss: 0.0027 - head_6_accuracy: 0.9995 - head_6_loss: 0.0028 - head_7_accuracy: 0.9995 - head_7_loss: 0.0029 - loss: 0.0193\n", "Epoch 43: val_head_1_accuracy did not improve from 0.99884\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 216ms/step - head_1_accuracy: 0.9986 - head_1_loss: 0.0067 - head_2_accuracy: 0.9985 - head_2_loss: 0.0066 - head_3_accuracy: 0.9985 - head_3_loss: 0.0069 - head_4_accuracy: 0.9983 - head_4_loss: 0.0066 - head_5_accuracy: 0.9982 - head_5_loss: 0.0070 - head_6_accuracy: 0.9983 - head_6_loss: 0.0068 - head_7_accuracy: 0.9985 - head_7_loss: 0.0066 - loss: 0.0476 - val_head_1_accuracy: 0.9921 - val_head_1_loss: 0.0330 - val_head_2_accuracy: 0.9921 - val_head_2_loss: 0.0328 - val_head_3_accuracy: 0.9928 - val_head_3_loss: 0.0328 - val_head_4_accuracy: 0.9919 - val_head_4_loss: 0.0329 - val_head_5_accuracy: 0.9921 - val_head_5_loss: 0.0332 - val_head_6_accuracy: 0.9923 - val_head_6_loss: 0.0327 - val_head_7_accuracy: 0.9923 - val_head_7_loss: 0.0328 - val_loss: 0.2322 - learning_rate: 3.7077e-04\n", "\n", "Epoch 44: LearningRateScheduler setting learning rate to 0.000361481760086154.\n", "Epoch 44/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 206ms/step - head_1_accuracy: 0.9865 - head_1_loss: 0.0391 - head_2_accuracy: 0.9868 - head_2_loss: 0.0380 - head_3_accuracy: 0.9862 - head_3_loss: 0.0391 - head_4_accuracy: 0.9867 - head_4_loss: 0.0395 - head_5_accuracy: 0.9869 - head_5_loss: 0.0380 - head_6_accuracy: 0.9861 - head_6_loss: 0.0390 - head_7_accuracy: 0.9863 - head_7_loss: 0.0399 - loss: 0.2728\n", "Epoch 44: val_head_1_accuracy did not improve from 0.99884\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 213ms/step - head_1_accuracy: 0.9906 - head_1_loss: 0.0261 - head_2_accuracy: 0.9906 - head_2_loss: 0.0256 - head_3_accuracy: 0.9907 - head_3_loss: 0.0260 - head_4_accuracy: 0.9909 - head_4_loss: 0.0260 - head_5_accuracy: 0.9910 - head_5_loss: 0.0254 - head_6_accuracy: 0.9905 - head_6_loss: 0.0262 - head_7_accuracy: 0.9906 - head_7_loss: 0.0264 - loss: 0.1835 - val_head_1_accuracy: 0.9979 - val_head_1_loss: 0.0094 - val_head_2_accuracy: 0.9977 - val_head_2_loss: 0.0100 - val_head_3_accuracy: 0.9979 - val_head_3_loss: 0.0094 - val_head_4_accuracy: 0.9979 - val_head_4_loss: 0.0095 - val_head_5_accuracy: 0.9979 - val_head_5_loss: 0.0093 - val_head_6_accuracy: 0.9977 - val_head_6_loss: 0.0098 - val_head_7_accuracy: 0.9979 - val_head_7_loss: 0.0098 - val_loss: 0.0667 - learning_rate: 3.6148e-04\n", "\n", "Epoch 45: LearningRateScheduler setting learning rate to 0.0003521357708911958.\n", "Epoch 45/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 204ms/step - head_1_accuracy: 0.9993 - head_1_loss: 0.0034 - head_2_accuracy: 0.9994 - head_2_loss: 0.0033 - head_3_accuracy: 0.9993 - head_3_loss: 0.0033 - head_4_accuracy: 0.9994 - head_4_loss: 0.0032 - head_5_accuracy: 0.9996 - head_5_loss: 0.0034 - head_6_accuracy: 0.9997 - head_6_loss: 0.0032 - head_7_accuracy: 0.9993 - head_7_loss: 0.0032 - loss: 0.0230\n", "Epoch 45: val_head_1_accuracy did not improve from 0.99884\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 212ms/step - head_1_accuracy: 0.9991 - head_1_loss: 0.0035 - head_2_accuracy: 0.9992 - head_2_loss: 0.0035 - head_3_accuracy: 0.9991 - head_3_loss: 0.0035 - head_4_accuracy: 0.9992 - head_4_loss: 0.0034 - head_5_accuracy: 0.9993 - head_5_loss: 0.0035 - head_6_accuracy: 0.9993 - head_6_loss: 0.0033 - head_7_accuracy: 0.9992 - head_7_loss: 0.0035 - loss: 0.0244 - val_head_1_accuracy: 0.9974 - val_head_1_loss: 0.0069 - val_head_2_accuracy: 0.9972 - val_head_2_loss: 0.0075 - val_head_3_accuracy: 0.9974 - val_head_3_loss: 0.0071 - val_head_4_accuracy: 0.9972 - val_head_4_loss: 0.0074 - val_head_5_accuracy: 0.9979 - val_head_5_loss: 0.0067 - val_head_6_accuracy: 0.9974 - val_head_6_loss: 0.0069 - val_head_7_accuracy: 0.9974 - val_head_7_loss: 0.0071 - val_loss: 0.0476 - learning_rate: 3.5214e-04\n", "\n", "Epoch 46: LearningRateScheduler setting learning rate to 0.00034273733574007183.\n", "Epoch 46/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 204ms/step - head_1_accuracy: 1.0000 - head_1_loss: 0.0013 - head_2_accuracy: 1.0000 - head_2_loss: 0.0013 - head_3_accuracy: 1.0000 - head_3_loss: 0.0013 - head_4_accuracy: 1.0000 - head_4_loss: 0.0015 - head_5_accuracy: 0.9999 - head_5_loss: 0.0014 - head_6_accuracy: 0.9998 - head_6_loss: 0.0015 - head_7_accuracy: 1.0000 - head_7_loss: 0.0013 - loss: 0.0096\n", "Epoch 46: val_head_1_accuracy did not improve from 0.99884\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 211ms/step - head_1_accuracy: 1.0000 - head_1_loss: 0.0012 - head_2_accuracy: 0.9998 - head_2_loss: 0.0013 - head_3_accuracy: 0.9999 - head_3_loss: 0.0013 - head_4_accuracy: 0.9999 - head_4_loss: 0.0012 - head_5_accuracy: 0.9997 - head_5_loss: 0.0014 - head_6_accuracy: 0.9998 - head_6_loss: 0.0013 - head_7_accuracy: 1.0000 - head_7_loss: 0.0012 - loss: 0.0090 - val_head_1_accuracy: 0.9979 - val_head_1_loss: 0.0071 - val_head_2_accuracy: 0.9981 - val_head_2_loss: 0.0075 - val_head_3_accuracy: 0.9984 - val_head_3_loss: 0.0072 - val_head_4_accuracy: 0.9981 - val_head_4_loss: 0.0073 - val_head_5_accuracy: 0.9984 - val_head_5_loss: 0.0071 - val_head_6_accuracy: 0.9981 - val_head_6_loss: 0.0069 - val_head_7_accuracy: 0.9984 - val_head_7_loss: 0.0072 - val_loss: 0.0505 - learning_rate: 3.4274e-04\n", "\n", "Epoch 47: LearningRateScheduler setting learning rate to 0.0003332959180603083.\n", "Epoch 47/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 206ms/step - head_1_accuracy: 0.9996 - head_1_loss: 0.0015 - head_2_accuracy: 0.9995 - head_2_loss: 0.0016 - head_3_accuracy: 0.9995 - head_3_loss: 0.0016 - head_4_accuracy: 0.9997 - head_4_loss: 0.0015 - head_5_accuracy: 0.9996 - head_5_loss: 0.0015 - head_6_accuracy: 0.9997 - head_6_loss: 0.0016 - head_7_accuracy: 0.9995 - head_7_loss: 0.0016 - loss: 0.0110\n", "Epoch 47: val_head_1_accuracy did not improve from 0.99884\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 218ms/step - head_1_accuracy: 0.9994 - head_1_loss: 0.0019 - head_2_accuracy: 0.9995 - head_2_loss: 0.0018 - head_3_accuracy: 0.9995 - head_3_loss: 0.0018 - head_4_accuracy: 0.9996 - head_4_loss: 0.0018 - head_5_accuracy: 0.9995 - head_5_loss: 0.0018 - head_6_accuracy: 0.9997 - head_6_loss: 0.0018 - head_7_accuracy: 0.9994 - head_7_loss: 0.0019 - loss: 0.0129 - val_head_1_accuracy: 0.9977 - val_head_1_loss: 0.0056 - val_head_2_accuracy: 0.9977 - val_head_2_loss: 0.0057 - val_head_3_accuracy: 0.9977 - val_head_3_loss: 0.0054 - val_head_4_accuracy: 0.9977 - val_head_4_loss: 0.0059 - val_head_5_accuracy: 0.9977 - val_head_5_loss: 0.0056 - val_head_6_accuracy: 0.9977 - val_head_6_loss: 0.0056 - val_head_7_accuracy: 0.9977 - val_head_7_loss: 0.0057 - val_loss: 0.0397 - learning_rate: 3.3330e-04\n", "\n", "Epoch 48: LearningRateScheduler setting learning rate to 0.00032382102455919367.\n", "Epoch 48/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 207ms/step - head_1_accuracy: 0.9997 - head_1_loss: 0.0016 - head_2_accuracy: 0.9995 - head_2_loss: 0.0020 - head_3_accuracy: 0.9997 - head_3_loss: 0.0014 - head_4_accuracy: 0.9997 - head_4_loss: 0.0016 - head_5_accuracy: 0.9997 - head_5_loss: 0.0016 - head_6_accuracy: 0.9997 - head_6_loss: 0.0017 - head_7_accuracy: 0.9997 - head_7_loss: 0.0014 - loss: 0.0112\n", "Epoch 48: val_head_1_accuracy did not improve from 0.99884\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 214ms/step - head_1_accuracy: 0.9997 - head_1_loss: 0.0015 - head_2_accuracy: 0.9997 - head_2_loss: 0.0017 - head_3_accuracy: 0.9996 - head_3_loss: 0.0014 - head_4_accuracy: 0.9996 - head_4_loss: 0.0015 - head_5_accuracy: 0.9995 - head_5_loss: 0.0016 - head_6_accuracy: 0.9996 - head_6_loss: 0.0016 - head_7_accuracy: 0.9997 - head_7_loss: 0.0013 - loss: 0.0106 - val_head_1_accuracy: 0.9984 - val_head_1_loss: 0.0045 - val_head_2_accuracy: 0.9991 - val_head_2_loss: 0.0047 - val_head_3_accuracy: 0.9988 - val_head_3_loss: 0.0045 - val_head_4_accuracy: 0.9988 - val_head_4_loss: 0.0047 - val_head_5_accuracy: 0.9988 - val_head_5_loss: 0.0045 - val_head_6_accuracy: 0.9991 - val_head_6_loss: 0.0045 - val_head_7_accuracy: 0.9991 - val_head_7_loss: 0.0044 - val_loss: 0.0320 - learning_rate: 3.2382e-04\n", "\n", "Epoch 49: LearningRateScheduler setting learning rate to 0.0003143221956513316.\n", "Epoch 49/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 206ms/step - head_1_accuracy: 0.9994 - head_1_loss: 0.0027 - head_2_accuracy: 0.9990 - head_2_loss: 0.0025 - head_3_accuracy: 0.9994 - head_3_loss: 0.0028 - head_4_accuracy: 0.9991 - head_4_loss: 0.0026 - head_5_accuracy: 0.9995 - head_5_loss: 0.0024 - head_6_accuracy: 0.9994 - head_6_loss: 0.0023 - head_7_accuracy: 0.9993 - head_7_loss: 0.0026 - loss: 0.0179\n", "Epoch 49: val_head_1_accuracy did not improve from 0.99884\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 215ms/step - head_1_accuracy: 0.9996 - head_1_loss: 0.0018 - head_2_accuracy: 0.9995 - head_2_loss: 0.0018 - head_3_accuracy: 0.9997 - head_3_loss: 0.0019 - head_4_accuracy: 0.9996 - head_4_loss: 0.0018 - head_5_accuracy: 0.9997 - head_5_loss: 0.0018 - head_6_accuracy: 0.9997 - head_6_loss: 0.0018 - head_7_accuracy: 0.9995 - head_7_loss: 0.0018 - loss: 0.0128 - val_head_1_accuracy: 0.9974 - val_head_1_loss: 0.0086 - val_head_2_accuracy: 0.9974 - val_head_2_loss: 0.0090 - val_head_3_accuracy: 0.9974 - val_head_3_loss: 0.0086 - val_head_4_accuracy: 0.9974 - val_head_4_loss: 0.0091 - val_head_5_accuracy: 0.9974 - val_head_5_loss: 0.0091 - val_head_6_accuracy: 0.9974 - val_head_6_loss: 0.0087 - val_head_7_accuracy: 0.9974 - val_head_7_loss: 0.0090 - val_loss: 0.0602 - learning_rate: 3.1432e-04\n", "\n", "Epoch 50: LearningRateScheduler setting learning rate to 0.0003048089958522507.\n", "Epoch 50/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 205ms/step - head_1_accuracy: 0.9999 - head_1_loss: 0.0011 - head_2_accuracy: 1.0000 - head_2_loss: 0.0010 - head_3_accuracy: 1.0000 - head_3_loss: 9.3265e-04 - head_4_accuracy: 0.9999 - head_4_loss: 0.0010 - head_5_accuracy: 0.9998 - head_5_loss: 9.4709e-04 - head_6_accuracy: 1.0000 - head_6_loss: 0.0010 - head_7_accuracy: 1.0000 - head_7_loss: 9.4225e-04 - loss: 0.0070\n", "Epoch 50: val_head_1_accuracy did not improve from 0.99884\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 213ms/step - head_1_accuracy: 0.9999 - head_1_loss: 8.3662e-04 - head_2_accuracy: 1.0000 - head_2_loss: 8.0830e-04 - head_3_accuracy: 1.0000 - head_3_loss: 7.5065e-04 - head_4_accuracy: 0.9999 - head_4_loss: 7.4933e-04 - head_5_accuracy: 0.9998 - head_5_loss: 7.7645e-04 - head_6_accuracy: 1.0000 - head_6_loss: 7.8437e-04 - head_7_accuracy: 1.0000 - head_7_loss: 7.7285e-04 - loss: 0.0055 - val_head_1_accuracy: 0.9981 - val_head_1_loss: 0.0077 - val_head_2_accuracy: 0.9981 - val_head_2_loss: 0.0080 - val_head_3_accuracy: 0.9981 - val_head_3_loss: 0.0076 - val_head_4_accuracy: 0.9981 - val_head_4_loss: 0.0081 - val_head_5_accuracy: 0.9981 - val_head_5_loss: 0.0077 - val_head_6_accuracy: 0.9981 - val_head_6_loss: 0.0075 - val_head_7_accuracy: 0.9981 - val_head_7_loss: 0.0078 - val_loss: 0.0532 - learning_rate: 3.0481e-04\n", "\n", "Epoch 51: LearningRateScheduler setting learning rate to 0.00029529100414774935.\n", "Epoch 51/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 204ms/step - head_1_accuracy: 0.9999 - head_1_loss: 5.9916e-04 - head_2_accuracy: 0.9999 - head_2_loss: 5.9018e-04 - head_3_accuracy: 0.9999 - head_3_loss: 6.0695e-04 - head_4_accuracy: 0.9999 - head_4_loss: 5.3210e-04 - head_5_accuracy: 0.9999 - head_5_loss: 6.0987e-04 - head_6_accuracy: 0.9999 - head_6_loss: 5.4520e-04 - head_7_accuracy: 0.9999 - head_7_loss: 5.9345e-04 - loss: 0.0041\n", "Epoch 51: val_head_1_accuracy did not improve from 0.99884\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 211ms/step - head_1_accuracy: 0.9996 - head_1_loss: 0.0011 - head_2_accuracy: 0.9996 - head_2_loss: 0.0011 - head_3_accuracy: 0.9998 - head_3_loss: 0.0010 - head_4_accuracy: 0.9998 - head_4_loss: 0.0010 - head_5_accuracy: 0.9998 - head_5_loss: 0.0011 - head_6_accuracy: 0.9997 - head_6_loss: 0.0011 - head_7_accuracy: 0.9996 - head_7_loss: 0.0012 - loss: 0.0077 - val_head_1_accuracy: 0.9968 - val_head_1_loss: 0.0094 - val_head_2_accuracy: 0.9970 - val_head_2_loss: 0.0096 - val_head_3_accuracy: 0.9970 - val_head_3_loss: 0.0096 - val_head_4_accuracy: 0.9972 - val_head_4_loss: 0.0099 - val_head_5_accuracy: 0.9972 - val_head_5_loss: 0.0095 - val_head_6_accuracy: 0.9970 - val_head_6_loss: 0.0093 - val_head_7_accuracy: 0.9968 - val_head_7_loss: 0.0098 - val_loss: 0.0654 - learning_rate: 2.9529e-04\n", "\n", "Epoch 52: LearningRateScheduler setting learning rate to 0.00028577780434866853.\n", "Epoch 52/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 205ms/step - head_1_accuracy: 0.9997 - head_1_loss: 0.0014 - head_2_accuracy: 0.9997 - head_2_loss: 0.0014 - head_3_accuracy: 0.9997 - head_3_loss: 0.0014 - head_4_accuracy: 0.9998 - head_4_loss: 0.0013 - head_5_accuracy: 0.9998 - head_5_loss: 0.0013 - head_6_accuracy: 0.9996 - head_6_loss: 0.0014 - head_7_accuracy: 0.9996 - head_7_loss: 0.0015 - loss: 0.0096\n", "Epoch 52: val_head_1_accuracy did not improve from 0.99884\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 212ms/step - head_1_accuracy: 0.9992 - head_1_loss: 0.0022 - head_2_accuracy: 0.9992 - head_2_loss: 0.0023 - head_3_accuracy: 0.9993 - head_3_loss: 0.0022 - head_4_accuracy: 0.9992 - head_4_loss: 0.0022 - head_5_accuracy: 0.9993 - head_5_loss: 0.0021 - head_6_accuracy: 0.9991 - head_6_loss: 0.0023 - head_7_accuracy: 0.9991 - head_7_loss: 0.0024 - loss: 0.0158 - val_head_1_accuracy: 0.9956 - val_head_1_loss: 0.0166 - val_head_2_accuracy: 0.9956 - val_head_2_loss: 0.0168 - val_head_3_accuracy: 0.9958 - val_head_3_loss: 0.0175 - val_head_4_accuracy: 0.9956 - val_head_4_loss: 0.0168 - val_head_5_accuracy: 0.9956 - val_head_5_loss: 0.0168 - val_head_6_accuracy: 0.9958 - val_head_6_loss: 0.0163 - val_head_7_accuracy: 0.9958 - val_head_7_loss: 0.0165 - val_loss: 0.1177 - learning_rate: 2.8578e-04\n", "\n", "Epoch 53: LearningRateScheduler setting learning rate to 0.0002762789754408063.\n", "Epoch 53/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 205ms/step - head_1_accuracy: 0.9971 - head_1_loss: 0.0078 - head_2_accuracy: 0.9975 - head_2_loss: 0.0087 - head_3_accuracy: 0.9975 - head_3_loss: 0.0083 - head_4_accuracy: 0.9973 - head_4_loss: 0.0081 - head_5_accuracy: 0.9975 - head_5_loss: 0.0084 - head_6_accuracy: 0.9973 - head_6_loss: 0.0086 - head_7_accuracy: 0.9973 - head_7_loss: 0.0073 - loss: 0.0572\n", "Epoch 53: val_head_1_accuracy did not improve from 0.99884\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 212ms/step - head_1_accuracy: 0.9971 - head_1_loss: 0.0079 - head_2_accuracy: 0.9976 - head_2_loss: 0.0085 - head_3_accuracy: 0.9973 - head_3_loss: 0.0083 - head_4_accuracy: 0.9973 - head_4_loss: 0.0083 - head_5_accuracy: 0.9977 - head_5_loss: 0.0082 - head_6_accuracy: 0.9972 - head_6_loss: 0.0084 - head_7_accuracy: 0.9975 - head_7_loss: 0.0079 - loss: 0.0581 - val_head_1_accuracy: 0.9937 - val_head_1_loss: 0.0226 - val_head_2_accuracy: 0.9937 - val_head_2_loss: 0.0228 - val_head_3_accuracy: 0.9944 - val_head_3_loss: 0.0215 - val_head_4_accuracy: 0.9940 - val_head_4_loss: 0.0226 - val_head_5_accuracy: 0.9942 - val_head_5_loss: 0.0222 - val_head_6_accuracy: 0.9942 - val_head_6_loss: 0.0224 - val_head_7_accuracy: 0.9947 - val_head_7_loss: 0.0213 - val_loss: 0.1566 - learning_rate: 2.7628e-04\n", "\n", "Epoch 54: LearningRateScheduler setting learning rate to 0.0002668040819396918.\n", "Epoch 54/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 207ms/step - head_1_accuracy: 0.9976 - head_1_loss: 0.0081 - head_2_accuracy: 0.9976 - head_2_loss: 0.0082 - head_3_accuracy: 0.9975 - head_3_loss: 0.0082 - head_4_accuracy: 0.9972 - head_4_loss: 0.0080 - head_5_accuracy: 0.9981 - head_5_loss: 0.0080 - head_6_accuracy: 0.9977 - head_6_loss: 0.0081 - head_7_accuracy: 0.9978 - head_7_loss: 0.0077 - loss: 0.0562\n", "Epoch 54: val_head_1_accuracy did not improve from 0.99884\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 215ms/step - head_1_accuracy: 0.9971 - head_1_loss: 0.0091 - head_2_accuracy: 0.9971 - head_2_loss: 0.0091 - head_3_accuracy: 0.9972 - head_3_loss: 0.0091 - head_4_accuracy: 0.9968 - head_4_loss: 0.0090 - head_5_accuracy: 0.9976 - head_5_loss: 0.0089 - head_6_accuracy: 0.9971 - head_6_loss: 0.0091 - head_7_accuracy: 0.9973 - head_7_loss: 0.0088 - loss: 0.0637 - val_head_1_accuracy: 0.9852 - val_head_1_loss: 0.0592 - val_head_2_accuracy: 0.9854 - val_head_2_loss: 0.0570 - val_head_3_accuracy: 0.9861 - val_head_3_loss: 0.0537 - val_head_4_accuracy: 0.9861 - val_head_4_loss: 0.0542 - val_head_5_accuracy: 0.9856 - val_head_5_loss: 0.0556 - val_head_6_accuracy: 0.9858 - val_head_6_loss: 0.0536 - val_head_7_accuracy: 0.9863 - val_head_7_loss: 0.0539 - val_loss: 0.3814 - learning_rate: 2.6680e-04\n", "\n", "Epoch 55: LearningRateScheduler setting learning rate to 0.00025736266425992817.\n", "Epoch 55/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 206ms/step - head_1_accuracy: 0.9964 - head_1_loss: 0.0106 - head_2_accuracy: 0.9964 - head_2_loss: 0.0110 - head_3_accuracy: 0.9966 - head_3_loss: 0.0106 - head_4_accuracy: 0.9964 - head_4_loss: 0.0101 - head_5_accuracy: 0.9964 - head_5_loss: 0.0108 - head_6_accuracy: 0.9969 - head_6_loss: 0.0098 - head_7_accuracy: 0.9964 - head_7_loss: 0.0105 - loss: 0.0735\n", "Epoch 55: val_head_1_accuracy did not improve from 0.99884\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 213ms/step - head_1_accuracy: 0.9976 - head_1_loss: 0.0075 - head_2_accuracy: 0.9976 - head_2_loss: 0.0077 - head_3_accuracy: 0.9974 - head_3_loss: 0.0077 - head_4_accuracy: 0.9974 - head_4_loss: 0.0075 - head_5_accuracy: 0.9978 - head_5_loss: 0.0076 - head_6_accuracy: 0.9976 - head_6_loss: 0.0073 - head_7_accuracy: 0.9975 - head_7_loss: 0.0075 - loss: 0.0533 - val_head_1_accuracy: 0.9963 - val_head_1_loss: 0.0162 - val_head_2_accuracy: 0.9963 - val_head_2_loss: 0.0160 - val_head_3_accuracy: 0.9961 - val_head_3_loss: 0.0164 - val_head_4_accuracy: 0.9961 - val_head_4_loss: 0.0163 - val_head_5_accuracy: 0.9958 - val_head_5_loss: 0.0167 - val_head_6_accuracy: 0.9963 - val_head_6_loss: 0.0161 - val_head_7_accuracy: 0.9961 - val_head_7_loss: 0.0161 - val_loss: 0.1148 - learning_rate: 2.5736e-04\n", "\n", "Epoch 56: LearningRateScheduler setting learning rate to 0.00024796422910880423.\n", "Epoch 56/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 207ms/step - head_1_accuracy: 0.9973 - head_1_loss: 0.0056 - head_2_accuracy: 0.9982 - head_2_loss: 0.0055 - head_3_accuracy: 0.9979 - head_3_loss: 0.0053 - head_4_accuracy: 0.9979 - head_4_loss: 0.0051 - head_5_accuracy: 0.9980 - head_5_loss: 0.0058 - head_6_accuracy: 0.9979 - head_6_loss: 0.0053 - head_7_accuracy: 0.9974 - head_7_loss: 0.0053 - loss: 0.0379\n", "Epoch 56: val_head_1_accuracy did not improve from 0.99884\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 216ms/step - head_1_accuracy: 0.9983 - head_1_loss: 0.0043 - head_2_accuracy: 0.9986 - head_2_loss: 0.0043 - head_3_accuracy: 0.9985 - head_3_loss: 0.0044 - head_4_accuracy: 0.9984 - head_4_loss: 0.0040 - head_5_accuracy: 0.9986 - head_5_loss: 0.0046 - head_6_accuracy: 0.9984 - head_6_loss: 0.0041 - head_7_accuracy: 0.9983 - head_7_loss: 0.0043 - loss: 0.0303 - val_head_1_accuracy: 0.9965 - val_head_1_loss: 0.0066 - val_head_2_accuracy: 0.9970 - val_head_2_loss: 0.0064 - val_head_3_accuracy: 0.9968 - val_head_3_loss: 0.0065 - val_head_4_accuracy: 0.9965 - val_head_4_loss: 0.0069 - val_head_5_accuracy: 0.9970 - val_head_5_loss: 0.0065 - val_head_6_accuracy: 0.9965 - val_head_6_loss: 0.0064 - val_head_7_accuracy: 0.9968 - val_head_7_loss: 0.0068 - val_loss: 0.0459 - learning_rate: 2.4796e-04\n", "\n", "Epoch 57: LearningRateScheduler setting learning rate to 0.0002386182399138461.\n", "Epoch 57/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 206ms/step - head_1_accuracy: 0.9990 - head_1_loss: 0.0038 - head_2_accuracy: 0.9991 - head_2_loss: 0.0035 - head_3_accuracy: 0.9990 - head_3_loss: 0.0037 - head_4_accuracy: 0.9991 - head_4_loss: 0.0035 - head_5_accuracy: 0.9991 - head_5_loss: 0.0036 - head_6_accuracy: 0.9990 - head_6_loss: 0.0035 - head_7_accuracy: 0.9990 - head_7_loss: 0.0035 - loss: 0.0251\n", "Epoch 57: val_head_1_accuracy did not improve from 0.99884\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 214ms/step - head_1_accuracy: 0.9993 - head_1_loss: 0.0026 - head_2_accuracy: 0.9995 - head_2_loss: 0.0025 - head_3_accuracy: 0.9994 - head_3_loss: 0.0026 - head_4_accuracy: 0.9995 - head_4_loss: 0.0025 - head_5_accuracy: 0.9995 - head_5_loss: 0.0025 - head_6_accuracy: 0.9994 - head_6_loss: 0.0027 - head_7_accuracy: 0.9994 - head_7_loss: 0.0024 - loss: 0.0178 - val_head_1_accuracy: 0.9981 - val_head_1_loss: 0.0043 - val_head_2_accuracy: 0.9984 - val_head_2_loss: 0.0044 - val_head_3_accuracy: 0.9981 - val_head_3_loss: 0.0043 - val_head_4_accuracy: 0.9979 - val_head_4_loss: 0.0047 - val_head_5_accuracy: 0.9986 - val_head_5_loss: 0.0044 - val_head_6_accuracy: 0.9986 - val_head_6_loss: 0.0042 - val_head_7_accuracy: 0.9984 - val_head_7_loss: 0.0042 - val_loss: 0.0308 - learning_rate: 2.3862e-04\n", "\n", "Epoch 58: LearningRateScheduler setting learning rate to 0.0002293341072939474.\n", "Epoch 58/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 207ms/step - head_1_accuracy: 0.9998 - head_1_loss: 9.8855e-04 - head_2_accuracy: 0.9998 - head_2_loss: 8.3885e-04 - head_3_accuracy: 0.9998 - head_3_loss: 7.7700e-04 - head_4_accuracy: 1.0000 - head_4_loss: 7.0051e-04 - head_5_accuracy: 0.9998 - head_5_loss: 7.9263e-04 - head_6_accuracy: 0.9998 - head_6_loss: 7.9805e-04 - head_7_accuracy: 1.0000 - head_7_loss: 7.2222e-04 - loss: 0.0056\n", "Epoch 58: val_head_1_accuracy did not improve from 0.99884\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 216ms/step - head_1_accuracy: 0.9998 - head_1_loss: 8.5821e-04 - head_2_accuracy: 0.9998 - head_2_loss: 8.0394e-04 - head_3_accuracy: 0.9998 - head_3_loss: 7.3094e-04 - head_4_accuracy: 0.9999 - head_4_loss: 6.4928e-04 - head_5_accuracy: 0.9998 - head_5_loss: 6.5184e-04 - head_6_accuracy: 0.9998 - head_6_loss: 6.9985e-04 - head_7_accuracy: 0.9999 - head_7_loss: 7.5618e-04 - loss: 0.0052 - val_head_1_accuracy: 0.9961 - val_head_1_loss: 0.0163 - val_head_2_accuracy: 0.9963 - val_head_2_loss: 0.0167 - val_head_3_accuracy: 0.9963 - val_head_3_loss: 0.0161 - val_head_4_accuracy: 0.9963 - val_head_4_loss: 0.0167 - val_head_5_accuracy: 0.9963 - val_head_5_loss: 0.0167 - val_head_6_accuracy: 0.9965 - val_head_6_loss: 0.0166 - val_head_7_accuracy: 0.9963 - val_head_7_loss: 0.0161 - val_loss: 0.1163 - learning_rate: 2.2933e-04\n", "\n", "Epoch 59: LearningRateScheduler setting learning rate to 0.00022012117958367398.\n", "Epoch 59/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 206ms/step - head_1_accuracy: 0.9988 - head_1_loss: 0.0030 - head_2_accuracy: 0.9991 - head_2_loss: 0.0027 - head_3_accuracy: 0.9992 - head_3_loss: 0.0027 - head_4_accuracy: 0.9991 - head_4_loss: 0.0029 - head_5_accuracy: 0.9992 - head_5_loss: 0.0030 - head_6_accuracy: 0.9990 - head_6_loss: 0.0030 - head_7_accuracy: 0.9991 - head_7_loss: 0.0029 - loss: 0.0202\n", "Epoch 59: val_head_1_accuracy did not improve from 0.99884\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 213ms/step - head_1_accuracy: 0.9991 - head_1_loss: 0.0022 - head_2_accuracy: 0.9994 - head_2_loss: 0.0020 - head_3_accuracy: 0.9995 - head_3_loss: 0.0019 - head_4_accuracy: 0.9994 - head_4_loss: 0.0020 - head_5_accuracy: 0.9995 - head_5_loss: 0.0020 - head_6_accuracy: 0.9993 - head_6_loss: 0.0020 - head_7_accuracy: 0.9995 - head_7_loss: 0.0020 - loss: 0.0142 - val_head_1_accuracy: 0.9979 - val_head_1_loss: 0.0085 - val_head_2_accuracy: 0.9979 - val_head_2_loss: 0.0085 - val_head_3_accuracy: 0.9981 - val_head_3_loss: 0.0086 - val_head_4_accuracy: 0.9979 - val_head_4_loss: 0.0089 - val_head_5_accuracy: 0.9981 - val_head_5_loss: 0.0087 - val_head_6_accuracy: 0.9981 - val_head_6_loss: 0.0089 - val_head_7_accuracy: 0.9981 - val_head_7_loss: 0.0089 - val_loss: 0.0615 - learning_rate: 2.2012e-04\n", "\n", "Epoch 60: LearningRateScheduler setting learning rate to 0.00021098873342028398.\n", "Epoch 60/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 207ms/step - head_1_accuracy: 0.9999 - head_1_loss: 0.0010 - head_2_accuracy: 0.9997 - head_2_loss: 0.0013 - head_3_accuracy: 0.9998 - head_3_loss: 9.5157e-04 - head_4_accuracy: 0.9999 - head_4_loss: 9.6459e-04 - head_5_accuracy: 0.9997 - head_5_loss: 0.0011 - head_6_accuracy: 0.9997 - head_6_loss: 0.0011 - head_7_accuracy: 0.9999 - head_7_loss: 0.0011 - loss: 0.0076\n", "Epoch 60: val_head_1_accuracy did not improve from 0.99884\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 216ms/step - head_1_accuracy: 0.9998 - head_1_loss: 9.1234e-04 - head_2_accuracy: 0.9998 - head_2_loss: 0.0011 - head_3_accuracy: 0.9999 - head_3_loss: 8.1201e-04 - head_4_accuracy: 0.9999 - head_4_loss: 8.2191e-04 - head_5_accuracy: 0.9998 - head_5_loss: 9.6083e-04 - head_6_accuracy: 0.9998 - head_6_loss: 9.2278e-04 - head_7_accuracy: 0.9998 - head_7_loss: 9.6144e-04 - loss: 0.0065 - val_head_1_accuracy: 0.9981 - val_head_1_loss: 0.0048 - val_head_2_accuracy: 0.9981 - val_head_2_loss: 0.0047 - val_head_3_accuracy: 0.9986 - val_head_3_loss: 0.0048 - val_head_4_accuracy: 0.9981 - val_head_4_loss: 0.0051 - val_head_5_accuracy: 0.9984 - val_head_5_loss: 0.0049 - val_head_6_accuracy: 0.9986 - val_head_6_loss: 0.0047 - val_head_7_accuracy: 0.9986 - val_head_7_loss: 0.0048 - val_loss: 0.0342 - learning_rate: 2.1099e-04\n", "\n", "Epoch 61: LearningRateScheduler setting learning rate to 0.00020194596440293946.\n", "Epoch 61/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 206ms/step - head_1_accuracy: 0.9997 - head_1_loss: 0.0012 - head_2_accuracy: 0.9997 - head_2_loss: 0.0012 - head_3_accuracy: 0.9997 - head_3_loss: 0.0010 - head_4_accuracy: 0.9997 - head_4_loss: 0.0012 - head_5_accuracy: 0.9998 - head_5_loss: 9.1536e-04 - head_6_accuracy: 0.9997 - head_6_loss: 0.0011 - head_7_accuracy: 0.9997 - head_7_loss: 0.0012 - loss: 0.0078\n", "Epoch 61: val_head_1_accuracy did not improve from 0.99884\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 214ms/step - head_1_accuracy: 0.9998 - head_1_loss: 7.3811e-04 - head_2_accuracy: 0.9998 - head_2_loss: 7.1475e-04 - head_3_accuracy: 0.9998 - head_3_loss: 6.6405e-04 - head_4_accuracy: 0.9998 - head_4_loss: 7.1150e-04 - head_5_accuracy: 0.9999 - head_5_loss: 5.8346e-04 - head_6_accuracy: 0.9998 - head_6_loss: 7.0487e-04 - head_7_accuracy: 0.9998 - head_7_loss: 7.2622e-04 - loss: 0.0049 - val_head_1_accuracy: 0.9979 - val_head_1_loss: 0.0071 - val_head_2_accuracy: 0.9981 - val_head_2_loss: 0.0070 - val_head_3_accuracy: 0.9979 - val_head_3_loss: 0.0072 - val_head_4_accuracy: 0.9981 - val_head_4_loss: 0.0076 - val_head_5_accuracy: 0.9979 - val_head_5_loss: 0.0073 - val_head_6_accuracy: 0.9979 - val_head_6_loss: 0.0071 - val_head_7_accuracy: 0.9979 - val_head_7_loss: 0.0070 - val_loss: 0.0508 - learning_rate: 2.0195e-04\n", "\n", "Epoch 62: LearningRateScheduler setting learning rate to 0.00019300197783351806.\n", "Epoch 62/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 206ms/step - head_1_accuracy: 0.9999 - head_1_loss: 4.8949e-04 - head_2_accuracy: 0.9999 - head_2_loss: 4.8758e-04 - head_3_accuracy: 0.9999 - head_3_loss: 4.9895e-04 - head_4_accuracy: 1.0000 - head_4_loss: 4.2098e-04 - head_5_accuracy: 0.9999 - head_5_loss: 5.0777e-04 - head_6_accuracy: 0.9999 - head_6_loss: 5.2340e-04 - head_7_accuracy: 0.9999 - head_7_loss: 5.9183e-04 - loss: 0.0035\n", "Epoch 62: val_head_1_accuracy did not improve from 0.99884\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 216ms/step - head_1_accuracy: 0.9999 - head_1_loss: 4.6254e-04 - head_2_accuracy: 0.9999 - head_2_loss: 4.4557e-04 - head_3_accuracy: 0.9999 - head_3_loss: 5.1055e-04 - head_4_accuracy: 1.0000 - head_4_loss: 4.0495e-04 - head_5_accuracy: 0.9999 - head_5_loss: 5.0058e-04 - head_6_accuracy: 0.9999 - head_6_loss: 4.9137e-04 - head_7_accuracy: 0.9999 - head_7_loss: 5.3897e-04 - loss: 0.0034 - val_head_1_accuracy: 0.9979 - val_head_1_loss: 0.0058 - val_head_2_accuracy: 0.9979 - val_head_2_loss: 0.0057 - val_head_3_accuracy: 0.9979 - val_head_3_loss: 0.0056 - val_head_4_accuracy: 0.9979 - val_head_4_loss: 0.0060 - val_head_5_accuracy: 0.9979 - val_head_5_loss: 0.0059 - val_head_6_accuracy: 0.9979 - val_head_6_loss: 0.0057 - val_head_7_accuracy: 0.9979 - val_head_7_loss: 0.0056 - val_loss: 0.0406 - learning_rate: 1.9300e-04\n", "\n", "Epoch 63: LearningRateScheduler setting learning rate to 0.00018416577954834612.\n", "Epoch 63/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 207ms/step - head_1_accuracy: 1.0000 - head_1_loss: 3.7766e-04 - head_2_accuracy: 1.0000 - head_2_loss: 3.9401e-04 - head_3_accuracy: 1.0000 - head_3_loss: 3.6625e-04 - head_4_accuracy: 1.0000 - head_4_loss: 4.4076e-04 - head_5_accuracy: 1.0000 - head_5_loss: 3.7987e-04 - head_6_accuracy: 1.0000 - head_6_loss: 4.2320e-04 - head_7_accuracy: 1.0000 - head_7_loss: 4.2294e-04 - loss: 0.0028\n", "Epoch 63: val_head_1_accuracy did not improve from 0.99884\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 214ms/step - head_1_accuracy: 1.0000 - head_1_loss: 3.5968e-04 - head_2_accuracy: 1.0000 - head_2_loss: 3.6346e-04 - head_3_accuracy: 1.0000 - head_3_loss: 3.3663e-04 - head_4_accuracy: 1.0000 - head_4_loss: 3.9076e-04 - head_5_accuracy: 1.0000 - head_5_loss: 3.4314e-04 - head_6_accuracy: 1.0000 - head_6_loss: 3.7400e-04 - head_7_accuracy: 1.0000 - head_7_loss: 4.0075e-04 - loss: 0.0026 - val_head_1_accuracy: 0.9981 - val_head_1_loss: 0.0051 - val_head_2_accuracy: 0.9984 - val_head_2_loss: 0.0049 - val_head_3_accuracy: 0.9981 - val_head_3_loss: 0.0050 - val_head_4_accuracy: 0.9981 - val_head_4_loss: 0.0052 - val_head_5_accuracy: 0.9981 - val_head_5_loss: 0.0051 - val_head_6_accuracy: 0.9981 - val_head_6_loss: 0.0050 - val_head_7_accuracy: 0.9984 - val_head_7_loss: 0.0048 - val_loss: 0.0354 - learning_rate: 1.8417e-04\n", "\n", "Epoch 64: LearningRateScheduler setting learning rate to 0.00017544626685008413.\n", "Epoch 64/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 206ms/step - head_1_accuracy: 1.0000 - head_1_loss: 2.2050e-04 - head_2_accuracy: 1.0000 - head_2_loss: 1.9989e-04 - head_3_accuracy: 1.0000 - head_3_loss: 1.9728e-04 - head_4_accuracy: 1.0000 - head_4_loss: 2.1945e-04 - head_5_accuracy: 1.0000 - head_5_loss: 2.0582e-04 - head_6_accuracy: 1.0000 - head_6_loss: 1.8559e-04 - head_7_accuracy: 1.0000 - head_7_loss: 2.1398e-04 - loss: 0.0014\n", "Epoch 64: val_head_1_accuracy improved from 0.99884 to 0.99907, saving model to /content/drive/My Drive/Classification/multicp/models/GFNet_MultiHead_best.keras\n", "\n", "Epoch 64: finished saving model to /content/drive/My Drive/Classification/multicp/models/GFNet_MultiHead_best.keras\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m24s\u001b[0m 237ms/step - head_1_accuracy: 1.0000 - head_1_loss: 2.6731e-04 - head_2_accuracy: 1.0000 - head_2_loss: 2.1250e-04 - head_3_accuracy: 1.0000 - head_3_loss: 2.2450e-04 - head_4_accuracy: 1.0000 - head_4_loss: 2.4152e-04 - head_5_accuracy: 1.0000 - head_5_loss: 2.2248e-04 - head_6_accuracy: 1.0000 - head_6_loss: 2.1734e-04 - head_7_accuracy: 1.0000 - head_7_loss: 2.3949e-04 - loss: 0.0016 - val_head_1_accuracy: 0.9991 - val_head_1_loss: 0.0026 - val_head_2_accuracy: 0.9991 - val_head_2_loss: 0.0026 - val_head_3_accuracy: 0.9991 - val_head_3_loss: 0.0026 - val_head_4_accuracy: 0.9991 - val_head_4_loss: 0.0026 - val_head_5_accuracy: 0.9991 - val_head_5_loss: 0.0026 - val_head_6_accuracy: 0.9991 - val_head_6_loss: 0.0026 - val_head_7_accuracy: 0.9991 - val_head_7_loss: 0.0026 - val_loss: 0.0182 - learning_rate: 1.7545e-04\n", "\n", "Epoch 65: LearningRateScheduler setting learning rate to 0.00016685221954889804.\n", "Epoch 65/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 212ms/step - head_1_accuracy: 1.0000 - head_1_loss: 2.2640e-04 - head_2_accuracy: 1.0000 - head_2_loss: 2.4941e-04 - head_3_accuracy: 1.0000 - head_3_loss: 2.3695e-04 - head_4_accuracy: 1.0000 - head_4_loss: 2.6543e-04 - head_5_accuracy: 1.0000 - head_5_loss: 2.2759e-04 - head_6_accuracy: 1.0000 - head_6_loss: 2.6224e-04 - head_7_accuracy: 1.0000 - head_7_loss: 2.8744e-04 - loss: 0.0018\n", "Epoch 65: val_head_1_accuracy did not improve from 0.99907\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m23s\u001b[0m 224ms/step - head_1_accuracy: 1.0000 - head_1_loss: 2.3549e-04 - head_2_accuracy: 1.0000 - head_2_loss: 2.4203e-04 - head_3_accuracy: 1.0000 - head_3_loss: 2.4720e-04 - head_4_accuracy: 1.0000 - head_4_loss: 2.7433e-04 - head_5_accuracy: 1.0000 - head_5_loss: 2.3620e-04 - head_6_accuracy: 1.0000 - head_6_loss: 2.4202e-04 - head_7_accuracy: 1.0000 - head_7_loss: 2.6963e-04 - loss: 0.0018 - val_head_1_accuracy: 0.9991 - val_head_1_loss: 0.0028 - val_head_2_accuracy: 0.9991 - val_head_2_loss: 0.0029 - val_head_3_accuracy: 0.9993 - val_head_3_loss: 0.0028 - val_head_4_accuracy: 0.9988 - val_head_4_loss: 0.0029 - val_head_5_accuracy: 0.9993 - val_head_5_loss: 0.0029 - val_head_6_accuracy: 0.9991 - val_head_6_loss: 0.0029 - val_head_7_accuracy: 0.9991 - val_head_7_loss: 0.0029 - val_loss: 0.0202 - learning_rate: 1.6685e-04\n", "\n", "Epoch 66: LearningRateScheduler setting learning rate to 0.00015839229112193386.\n", "Epoch 66/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 207ms/step - head_1_accuracy: 1.0000 - head_1_loss: 2.0885e-04 - head_2_accuracy: 1.0000 - head_2_loss: 3.3188e-04 - head_3_accuracy: 1.0000 - head_3_loss: 2.6763e-04 - head_4_accuracy: 1.0000 - head_4_loss: 2.2323e-04 - head_5_accuracy: 1.0000 - head_5_loss: 2.6023e-04 - head_6_accuracy: 1.0000 - head_6_loss: 2.4406e-04 - head_7_accuracy: 1.0000 - head_7_loss: 2.2449e-04 - loss: 0.0018\n", "Epoch 66: val_head_1_accuracy did not improve from 0.99907\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 216ms/step - head_1_accuracy: 1.0000 - head_1_loss: 2.1491e-04 - head_2_accuracy: 1.0000 - head_2_loss: 2.5830e-04 - head_3_accuracy: 1.0000 - head_3_loss: 2.1848e-04 - head_4_accuracy: 1.0000 - head_4_loss: 2.0791e-04 - head_5_accuracy: 1.0000 - head_5_loss: 2.3395e-04 - head_6_accuracy: 1.0000 - head_6_loss: 2.2349e-04 - head_7_accuracy: 1.0000 - head_7_loss: 2.2121e-04 - loss: 0.0016 - val_head_1_accuracy: 0.9984 - val_head_1_loss: 0.0035 - val_head_2_accuracy: 0.9984 - val_head_2_loss: 0.0033 - val_head_3_accuracy: 0.9986 - val_head_3_loss: 0.0033 - val_head_4_accuracy: 0.9984 - val_head_4_loss: 0.0035 - val_head_5_accuracy: 0.9981 - val_head_5_loss: 0.0034 - val_head_6_accuracy: 0.9981 - val_head_6_loss: 0.0035 - val_head_7_accuracy: 0.9986 - val_head_7_loss: 0.0034 - val_loss: 0.0241 - learning_rate: 1.5839e-04\n", "\n", "Epoch 67: LearningRateScheduler setting learning rate to 0.00015007500000000006.\n", "Epoch 67/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 206ms/step - head_1_accuracy: 0.9992 - head_1_loss: 0.0024 - head_2_accuracy: 0.9991 - head_2_loss: 0.0024 - head_3_accuracy: 0.9993 - head_3_loss: 0.0022 - head_4_accuracy: 0.9994 - head_4_loss: 0.0023 - head_5_accuracy: 0.9992 - head_5_loss: 0.0020 - head_6_accuracy: 0.9991 - head_6_loss: 0.0024 - head_7_accuracy: 0.9990 - head_7_loss: 0.0022 - loss: 0.0158\n", "Epoch 67: val_head_1_accuracy did not improve from 0.99907\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 214ms/step - head_1_accuracy: 0.9994 - head_1_loss: 0.0021 - head_2_accuracy: 0.9994 - head_2_loss: 0.0020 - head_3_accuracy: 0.9994 - head_3_loss: 0.0020 - head_4_accuracy: 0.9996 - head_4_loss: 0.0020 - head_5_accuracy: 0.9994 - head_5_loss: 0.0018 - head_6_accuracy: 0.9993 - head_6_loss: 0.0020 - head_7_accuracy: 0.9993 - head_7_loss: 0.0019 - loss: 0.0138 - val_head_1_accuracy: 0.9974 - val_head_1_loss: 0.0097 - val_head_2_accuracy: 0.9974 - val_head_2_loss: 0.0096 - val_head_3_accuracy: 0.9977 - val_head_3_loss: 0.0092 - val_head_4_accuracy: 0.9977 - val_head_4_loss: 0.0097 - val_head_5_accuracy: 0.9974 - val_head_5_loss: 0.0095 - val_head_6_accuracy: 0.9977 - val_head_6_loss: 0.0100 - val_head_7_accuracy: 0.9974 - val_head_7_loss: 0.0096 - val_loss: 0.0680 - learning_rate: 1.5007e-04\n", "\n", "Epoch 68: LearningRateScheduler setting learning rate to 0.00014190872099022978.\n", "Epoch 68/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 206ms/step - head_1_accuracy: 0.9996 - head_1_loss: 0.0011 - head_2_accuracy: 1.0000 - head_2_loss: 0.0011 - head_3_accuracy: 0.9998 - head_3_loss: 0.0011 - head_4_accuracy: 0.9998 - head_4_loss: 0.0011 - head_5_accuracy: 0.9995 - head_5_loss: 0.0012 - head_6_accuracy: 0.9995 - head_6_loss: 0.0011 - head_7_accuracy: 0.9992 - head_7_loss: 0.0013 - loss: 0.0080\n", "Epoch 68: val_head_1_accuracy did not improve from 0.99907\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 215ms/step - head_1_accuracy: 0.9998 - head_1_loss: 8.1644e-04 - head_2_accuracy: 1.0000 - head_2_loss: 7.8380e-04 - head_3_accuracy: 0.9998 - head_3_loss: 7.5905e-04 - head_4_accuracy: 0.9998 - head_4_loss: 7.7435e-04 - head_5_accuracy: 0.9998 - head_5_loss: 8.7285e-04 - head_6_accuracy: 0.9998 - head_6_loss: 8.0914e-04 - head_7_accuracy: 0.9996 - head_7_loss: 9.1125e-04 - loss: 0.0058 - val_head_1_accuracy: 0.9986 - val_head_1_loss: 0.0049 - val_head_2_accuracy: 0.9986 - val_head_2_loss: 0.0050 - val_head_3_accuracy: 0.9986 - val_head_3_loss: 0.0049 - val_head_4_accuracy: 0.9986 - val_head_4_loss: 0.0051 - val_head_5_accuracy: 0.9986 - val_head_5_loss: 0.0051 - val_head_6_accuracy: 0.9986 - val_head_6_loss: 0.0049 - val_head_7_accuracy: 0.9986 - val_head_7_loss: 0.0049 - val_loss: 0.0349 - learning_rate: 1.4191e-04\n", "\n", "Epoch 69: LearningRateScheduler setting learning rate to 0.00013390167684336024.\n", "Epoch 69/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 207ms/step - head_1_accuracy: 1.0000 - head_1_loss: 2.1346e-04 - head_2_accuracy: 1.0000 - head_2_loss: 2.2391e-04 - head_3_accuracy: 1.0000 - head_3_loss: 2.3251e-04 - head_4_accuracy: 1.0000 - head_4_loss: 2.3567e-04 - head_5_accuracy: 1.0000 - head_5_loss: 2.2658e-04 - head_6_accuracy: 1.0000 - head_6_loss: 2.0035e-04 - head_7_accuracy: 1.0000 - head_7_loss: 2.3965e-04 - loss: 0.0016\n", "Epoch 69: val_head_1_accuracy did not improve from 0.99907\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 214ms/step - head_1_accuracy: 1.0000 - head_1_loss: 2.0895e-04 - head_2_accuracy: 1.0000 - head_2_loss: 2.3698e-04 - head_3_accuracy: 1.0000 - head_3_loss: 2.1928e-04 - head_4_accuracy: 1.0000 - head_4_loss: 2.3536e-04 - head_5_accuracy: 1.0000 - head_5_loss: 2.2587e-04 - head_6_accuracy: 1.0000 - head_6_loss: 2.0033e-04 - head_7_accuracy: 1.0000 - head_7_loss: 2.2483e-04 - loss: 0.0016 - val_head_1_accuracy: 0.9988 - val_head_1_loss: 0.0043 - val_head_2_accuracy: 0.9988 - val_head_2_loss: 0.0046 - val_head_3_accuracy: 0.9988 - val_head_3_loss: 0.0042 - val_head_4_accuracy: 0.9988 - val_head_4_loss: 0.0045 - val_head_5_accuracy: 0.9988 - val_head_5_loss: 0.0045 - val_head_6_accuracy: 0.9988 - val_head_6_loss: 0.0044 - val_head_7_accuracy: 0.9988 - val_head_7_loss: 0.0043 - val_loss: 0.0308 - learning_rate: 1.3390e-04\n", "\n", "Epoch 70: LearningRateScheduler setting learning rate to 0.00012606192997411915.\n", "Epoch 70/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 206ms/step - head_1_accuracy: 1.0000 - head_1_loss: 2.0197e-04 - head_2_accuracy: 1.0000 - head_2_loss: 2.1139e-04 - head_3_accuracy: 1.0000 - head_3_loss: 2.2619e-04 - head_4_accuracy: 1.0000 - head_4_loss: 1.9287e-04 - head_5_accuracy: 1.0000 - head_5_loss: 2.1274e-04 - head_6_accuracy: 1.0000 - head_6_loss: 1.8570e-04 - head_7_accuracy: 1.0000 - head_7_loss: 2.1923e-04 - loss: 0.0015\n", "Epoch 70: val_head_1_accuracy did not improve from 0.99907\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 214ms/step - head_1_accuracy: 1.0000 - head_1_loss: 2.5354e-04 - head_2_accuracy: 1.0000 - head_2_loss: 2.5219e-04 - head_3_accuracy: 1.0000 - head_3_loss: 2.6467e-04 - head_4_accuracy: 1.0000 - head_4_loss: 2.3583e-04 - head_5_accuracy: 1.0000 - head_5_loss: 2.7808e-04 - head_6_accuracy: 1.0000 - head_6_loss: 2.4353e-04 - head_7_accuracy: 1.0000 - head_7_loss: 2.6841e-04 - loss: 0.0018 - val_head_1_accuracy: 0.9986 - val_head_1_loss: 0.0044 - val_head_2_accuracy: 0.9986 - val_head_2_loss: 0.0047 - val_head_3_accuracy: 0.9986 - val_head_3_loss: 0.0043 - val_head_4_accuracy: 0.9986 - val_head_4_loss: 0.0046 - val_head_5_accuracy: 0.9986 - val_head_5_loss: 0.0046 - val_head_6_accuracy: 0.9986 - val_head_6_loss: 0.0044 - val_head_7_accuracy: 0.9986 - val_head_7_loss: 0.0044 - val_loss: 0.0311 - learning_rate: 1.2606e-04\n", "\n", "Epoch 71: LearningRateScheduler setting learning rate to 0.00011839737434305693.\n", "Epoch 71/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 207ms/step - head_1_accuracy: 1.0000 - head_1_loss: 1.7967e-04 - head_2_accuracy: 1.0000 - head_2_loss: 1.8203e-04 - head_3_accuracy: 1.0000 - head_3_loss: 1.9818e-04 - head_4_accuracy: 1.0000 - head_4_loss: 1.9652e-04 - head_5_accuracy: 1.0000 - head_5_loss: 1.8083e-04 - head_6_accuracy: 1.0000 - head_6_loss: 1.6058e-04 - head_7_accuracy: 1.0000 - head_7_loss: 2.0223e-04 - loss: 0.0013\n", "Epoch 71: val_head_1_accuracy did not improve from 0.99907\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 214ms/step - head_1_accuracy: 0.9999 - head_1_loss: 2.3809e-04 - head_2_accuracy: 1.0000 - head_2_loss: 2.2263e-04 - head_3_accuracy: 0.9999 - head_3_loss: 2.4626e-04 - head_4_accuracy: 1.0000 - head_4_loss: 2.1355e-04 - head_5_accuracy: 1.0000 - head_5_loss: 2.0701e-04 - head_6_accuracy: 1.0000 - head_6_loss: 2.0706e-04 - head_7_accuracy: 1.0000 - head_7_loss: 2.4581e-04 - loss: 0.0016 - val_head_1_accuracy: 0.9977 - val_head_1_loss: 0.0069 - val_head_2_accuracy: 0.9979 - val_head_2_loss: 0.0070 - val_head_3_accuracy: 0.9977 - val_head_3_loss: 0.0068 - val_head_4_accuracy: 0.9977 - val_head_4_loss: 0.0071 - val_head_5_accuracy: 0.9977 - val_head_5_loss: 0.0070 - val_head_6_accuracy: 0.9977 - val_head_6_loss: 0.0069 - val_head_7_accuracy: 0.9977 - val_head_7_loss: 0.0070 - val_loss: 0.0480 - learning_rate: 1.1840e-04\n", "\n", "Epoch 72: LearningRateScheduler setting learning rate to 0.00011091572750799748.\n", "Epoch 72/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 207ms/step - head_1_accuracy: 1.0000 - head_1_loss: 2.4668e-04 - head_2_accuracy: 1.0000 - head_2_loss: 2.4875e-04 - head_3_accuracy: 1.0000 - head_3_loss: 2.7213e-04 - head_4_accuracy: 1.0000 - head_4_loss: 2.8063e-04 - head_5_accuracy: 1.0000 - head_5_loss: 3.1753e-04 - head_6_accuracy: 1.0000 - head_6_loss: 2.1871e-04 - head_7_accuracy: 1.0000 - head_7_loss: 2.2927e-04 - loss: 0.0018\n", "Epoch 72: val_head_1_accuracy did not improve from 0.99907\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 214ms/step - head_1_accuracy: 1.0000 - head_1_loss: 2.6143e-04 - head_2_accuracy: 0.9999 - head_2_loss: 2.9784e-04 - head_3_accuracy: 1.0000 - head_3_loss: 2.5083e-04 - head_4_accuracy: 0.9999 - head_4_loss: 3.0117e-04 - head_5_accuracy: 0.9999 - head_5_loss: 3.4045e-04 - head_6_accuracy: 1.0000 - head_6_loss: 2.3855e-04 - head_7_accuracy: 0.9999 - head_7_loss: 2.5817e-04 - loss: 0.0020 - val_head_1_accuracy: 0.9991 - val_head_1_loss: 0.0054 - val_head_2_accuracy: 0.9991 - val_head_2_loss: 0.0054 - val_head_3_accuracy: 0.9991 - val_head_3_loss: 0.0053 - val_head_4_accuracy: 0.9991 - val_head_4_loss: 0.0055 - val_head_5_accuracy: 0.9991 - val_head_5_loss: 0.0055 - val_head_6_accuracy: 0.9991 - val_head_6_loss: 0.0054 - val_head_7_accuracy: 0.9991 - val_head_7_loss: 0.0053 - val_loss: 0.0382 - learning_rate: 1.1092e-04\n", "\n", "Epoch 73: LearningRateScheduler setting learning rate to 0.00010362452285311177.\n", "Epoch 73/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 207ms/step - head_1_accuracy: 1.0000 - head_1_loss: 2.3341e-04 - head_2_accuracy: 1.0000 - head_2_loss: 2.3398e-04 - head_3_accuracy: 1.0000 - head_3_loss: 2.5782e-04 - head_4_accuracy: 1.0000 - head_4_loss: 2.9049e-04 - head_5_accuracy: 1.0000 - head_5_loss: 2.6433e-04 - head_6_accuracy: 1.0000 - head_6_loss: 2.8686e-04 - head_7_accuracy: 1.0000 - head_7_loss: 3.9170e-04 - loss: 0.0020\n", "Epoch 73: val_head_1_accuracy did not improve from 0.99907\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 215ms/step - head_1_accuracy: 1.0000 - head_1_loss: 2.5377e-04 - head_2_accuracy: 1.0000 - head_2_loss: 2.4463e-04 - head_3_accuracy: 1.0000 - head_3_loss: 2.3417e-04 - head_4_accuracy: 1.0000 - head_4_loss: 2.1168e-04 - head_5_accuracy: 1.0000 - head_5_loss: 2.2248e-04 - head_6_accuracy: 0.9999 - head_6_loss: 2.7214e-04 - head_7_accuracy: 1.0000 - head_7_loss: 2.7076e-04 - loss: 0.0017 - val_head_1_accuracy: 0.9981 - val_head_1_loss: 0.0056 - val_head_2_accuracy: 0.9984 - val_head_2_loss: 0.0057 - val_head_3_accuracy: 0.9984 - val_head_3_loss: 0.0054 - val_head_4_accuracy: 0.9981 - val_head_4_loss: 0.0058 - val_head_5_accuracy: 0.9979 - val_head_5_loss: 0.0056 - val_head_6_accuracy: 0.9979 - val_head_6_loss: 0.0056 - val_head_7_accuracy: 0.9981 - val_head_7_loss: 0.0056 - val_loss: 0.0377 - learning_rate: 1.0362e-04\n", "\n", "Epoch 74: LearningRateScheduler setting learning rate to 9.653110200343824e-05.\n", "Epoch 74/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 207ms/step - head_1_accuracy: 1.0000 - head_1_loss: 3.0383e-04 - head_2_accuracy: 1.0000 - head_2_loss: 2.5527e-04 - head_3_accuracy: 1.0000 - head_3_loss: 2.7134e-04 - head_4_accuracy: 1.0000 - head_4_loss: 2.8601e-04 - head_5_accuracy: 1.0000 - head_5_loss: 3.1985e-04 - head_6_accuracy: 1.0000 - head_6_loss: 2.5299e-04 - head_7_accuracy: 1.0000 - head_7_loss: 2.4808e-04 - loss: 0.0019\n", "Epoch 74: val_head_1_accuracy did not improve from 0.99907\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 214ms/step - head_1_accuracy: 1.0000 - head_1_loss: 2.0845e-04 - head_2_accuracy: 1.0000 - head_2_loss: 1.7228e-04 - head_3_accuracy: 1.0000 - head_3_loss: 1.6934e-04 - head_4_accuracy: 1.0000 - head_4_loss: 1.7543e-04 - head_5_accuracy: 1.0000 - head_5_loss: 1.9927e-04 - head_6_accuracy: 1.0000 - head_6_loss: 1.8499e-04 - head_7_accuracy: 1.0000 - head_7_loss: 1.7543e-04 - loss: 0.0013 - val_head_1_accuracy: 0.9988 - val_head_1_loss: 0.0051 - val_head_2_accuracy: 0.9991 - val_head_2_loss: 0.0052 - val_head_3_accuracy: 0.9988 - val_head_3_loss: 0.0051 - val_head_4_accuracy: 0.9988 - val_head_4_loss: 0.0054 - val_head_5_accuracy: 0.9986 - val_head_5_loss: 0.0053 - val_head_6_accuracy: 0.9986 - val_head_6_loss: 0.0052 - val_head_7_accuracy: 0.9986 - val_head_7_loss: 0.0052 - val_loss: 0.0367 - learning_rate: 9.6531e-05\n", "\n", "Epoch 75: LearningRateScheduler setting learning rate to 8.96426074324889e-05.\n", "Epoch 75/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 207ms/step - head_1_accuracy: 1.0000 - head_1_loss: 1.7401e-04 - head_2_accuracy: 1.0000 - head_2_loss: 2.0292e-04 - head_3_accuracy: 1.0000 - head_3_loss: 1.6291e-04 - head_4_accuracy: 1.0000 - head_4_loss: 1.7888e-04 - head_5_accuracy: 1.0000 - head_5_loss: 1.6429e-04 - head_6_accuracy: 1.0000 - head_6_loss: 1.8978e-04 - head_7_accuracy: 1.0000 - head_7_loss: 2.0047e-04 - loss: 0.0013\n", "Epoch 75: val_head_1_accuracy did not improve from 0.99907\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 216ms/step - head_1_accuracy: 1.0000 - head_1_loss: 1.6779e-04 - head_2_accuracy: 1.0000 - head_2_loss: 2.0090e-04 - head_3_accuracy: 1.0000 - head_3_loss: 1.7171e-04 - head_4_accuracy: 1.0000 - head_4_loss: 1.8519e-04 - head_5_accuracy: 1.0000 - head_5_loss: 1.7336e-04 - head_6_accuracy: 1.0000 - head_6_loss: 1.9316e-04 - head_7_accuracy: 1.0000 - head_7_loss: 1.8957e-04 - loss: 0.0013 - val_head_1_accuracy: 0.9988 - val_head_1_loss: 0.0038 - val_head_2_accuracy: 0.9986 - val_head_2_loss: 0.0039 - val_head_3_accuracy: 0.9986 - val_head_3_loss: 0.0039 - val_head_4_accuracy: 0.9986 - val_head_4_loss: 0.0040 - val_head_5_accuracy: 0.9986 - val_head_5_loss: 0.0040 - val_head_6_accuracy: 0.9984 - val_head_6_loss: 0.0038 - val_head_7_accuracy: 0.9986 - val_head_7_loss: 0.0039 - val_loss: 0.0274 - learning_rate: 8.9643e-05\n", "\n", "Epoch 76: LearningRateScheduler setting learning rate to 8.29659752703842e-05.\n", "Epoch 76/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 207ms/step - head_1_accuracy: 1.0000 - head_1_loss: 2.6632e-04 - head_2_accuracy: 1.0000 - head_2_loss: 2.3152e-04 - head_3_accuracy: 1.0000 - head_3_loss: 2.1111e-04 - head_4_accuracy: 1.0000 - head_4_loss: 2.5426e-04 - head_5_accuracy: 1.0000 - head_5_loss: 2.2389e-04 - head_6_accuracy: 1.0000 - head_6_loss: 1.7628e-04 - head_7_accuracy: 1.0000 - head_7_loss: 2.4249e-04 - loss: 0.0016\n", "Epoch 76: val_head_1_accuracy did not improve from 0.99907\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 214ms/step - head_1_accuracy: 1.0000 - head_1_loss: 1.7346e-04 - head_2_accuracy: 1.0000 - head_2_loss: 1.6300e-04 - head_3_accuracy: 1.0000 - head_3_loss: 1.4919e-04 - head_4_accuracy: 1.0000 - head_4_loss: 1.6304e-04 - head_5_accuracy: 1.0000 - head_5_loss: 1.5308e-04 - head_6_accuracy: 1.0000 - head_6_loss: 1.4268e-04 - head_7_accuracy: 1.0000 - head_7_loss: 1.6461e-04 - loss: 0.0011 - val_head_1_accuracy: 0.9986 - val_head_1_loss: 0.0039 - val_head_2_accuracy: 0.9988 - val_head_2_loss: 0.0041 - val_head_3_accuracy: 0.9986 - val_head_3_loss: 0.0039 - val_head_4_accuracy: 0.9988 - val_head_4_loss: 0.0041 - val_head_5_accuracy: 0.9984 - val_head_5_loss: 0.0041 - val_head_6_accuracy: 0.9986 - val_head_6_loss: 0.0040 - val_head_7_accuracy: 0.9986 - val_head_7_loss: 0.0041 - val_loss: 0.0284 - learning_rate: 8.2966e-05\n", "\n", "Epoch 77: LearningRateScheduler setting learning rate to 7.650792831975739e-05.\n", "Epoch 77/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 207ms/step - head_1_accuracy: 1.0000 - head_1_loss: 2.2597e-04 - head_2_accuracy: 1.0000 - head_2_loss: 2.0583e-04 - head_3_accuracy: 1.0000 - head_3_loss: 3.2714e-04 - head_4_accuracy: 1.0000 - head_4_loss: 3.0439e-04 - head_5_accuracy: 1.0000 - head_5_loss: 2.0418e-04 - head_6_accuracy: 1.0000 - head_6_loss: 3.4513e-04 - head_7_accuracy: 0.9998 - head_7_loss: 3.9201e-04 - loss: 0.0020\n", "Epoch 77: val_head_1_accuracy did not improve from 0.99907\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 216ms/step - head_1_accuracy: 1.0000 - head_1_loss: 1.6922e-04 - head_2_accuracy: 1.0000 - head_2_loss: 1.5649e-04 - head_3_accuracy: 1.0000 - head_3_loss: 2.0469e-04 - head_4_accuracy: 1.0000 - head_4_loss: 1.8778e-04 - head_5_accuracy: 1.0000 - head_5_loss: 1.5690e-04 - head_6_accuracy: 1.0000 - head_6_loss: 2.1506e-04 - head_7_accuracy: 0.9999 - head_7_loss: 2.3352e-04 - loss: 0.0013 - val_head_1_accuracy: 0.9986 - val_head_1_loss: 0.0042 - val_head_2_accuracy: 0.9986 - val_head_2_loss: 0.0042 - val_head_3_accuracy: 0.9986 - val_head_3_loss: 0.0041 - val_head_4_accuracy: 0.9986 - val_head_4_loss: 0.0044 - val_head_5_accuracy: 0.9986 - val_head_5_loss: 0.0043 - val_head_6_accuracy: 0.9986 - val_head_6_loss: 0.0041 - val_head_7_accuracy: 0.9986 - val_head_7_loss: 0.0043 - val_loss: 0.0296 - learning_rate: 7.6508e-05\n", "\n", "Epoch 78: LearningRateScheduler setting learning rate to 7.027496928646257e-05.\n", "Epoch 78/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 207ms/step - head_1_accuracy: 1.0000 - head_1_loss: 1.3523e-04 - head_2_accuracy: 1.0000 - head_2_loss: 1.2498e-04 - head_3_accuracy: 1.0000 - head_3_loss: 1.3457e-04 - head_4_accuracy: 1.0000 - head_4_loss: 1.3304e-04 - head_5_accuracy: 1.0000 - head_5_loss: 1.2047e-04 - head_6_accuracy: 1.0000 - head_6_loss: 1.3215e-04 - head_7_accuracy: 1.0000 - head_7_loss: 1.3281e-04 - loss: 9.1326e-04\n", "Epoch 78: val_head_1_accuracy did not improve from 0.99907\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 214ms/step - head_1_accuracy: 1.0000 - head_1_loss: 1.1866e-04 - head_2_accuracy: 1.0000 - head_2_loss: 1.1424e-04 - head_3_accuracy: 1.0000 - head_3_loss: 1.2914e-04 - head_4_accuracy: 1.0000 - head_4_loss: 1.1386e-04 - head_5_accuracy: 1.0000 - head_5_loss: 1.1019e-04 - head_6_accuracy: 1.0000 - head_6_loss: 1.1754e-04 - head_7_accuracy: 1.0000 - head_7_loss: 1.1810e-04 - loss: 8.2978e-04 - val_head_1_accuracy: 0.9988 - val_head_1_loss: 0.0038 - val_head_2_accuracy: 0.9988 - val_head_2_loss: 0.0039 - val_head_3_accuracy: 0.9988 - val_head_3_loss: 0.0038 - val_head_4_accuracy: 0.9988 - val_head_4_loss: 0.0040 - val_head_5_accuracy: 0.9988 - val_head_5_loss: 0.0040 - val_head_6_accuracy: 0.9988 - val_head_6_loss: 0.0038 - val_head_7_accuracy: 0.9988 - val_head_7_loss: 0.0039 - val_loss: 0.0274 - learning_rate: 7.0275e-05\n", "\n", "Epoch 79: LearningRateScheduler setting learning rate to 6.427337423190096e-05.\n", "Epoch 79/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 207ms/step - head_1_accuracy: 1.0000 - head_1_loss: 1.2244e-04 - head_2_accuracy: 1.0000 - head_2_loss: 1.5272e-04 - head_3_accuracy: 1.0000 - head_3_loss: 1.2570e-04 - head_4_accuracy: 1.0000 - head_4_loss: 1.5261e-04 - head_5_accuracy: 1.0000 - head_5_loss: 1.2802e-04 - head_6_accuracy: 1.0000 - head_6_loss: 1.2470e-04 - head_7_accuracy: 1.0000 - head_7_loss: 1.4298e-04 - loss: 9.4917e-04\n", "Epoch 79: val_head_1_accuracy did not improve from 0.99907\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 219ms/step - head_1_accuracy: 1.0000 - head_1_loss: 1.5008e-04 - head_2_accuracy: 1.0000 - head_2_loss: 1.6580e-04 - head_3_accuracy: 1.0000 - head_3_loss: 1.4695e-04 - head_4_accuracy: 1.0000 - head_4_loss: 1.7475e-04 - head_5_accuracy: 1.0000 - head_5_loss: 1.4446e-04 - head_6_accuracy: 1.0000 - head_6_loss: 1.5258e-04 - head_7_accuracy: 1.0000 - head_7_loss: 1.5573e-04 - loss: 0.0011 - val_head_1_accuracy: 0.9988 - val_head_1_loss: 0.0037 - val_head_2_accuracy: 0.9984 - val_head_2_loss: 0.0039 - val_head_3_accuracy: 0.9988 - val_head_3_loss: 0.0037 - val_head_4_accuracy: 0.9988 - val_head_4_loss: 0.0039 - val_head_5_accuracy: 0.9988 - val_head_5_loss: 0.0040 - val_head_6_accuracy: 0.9986 - val_head_6_loss: 0.0038 - val_head_7_accuracy: 0.9986 - val_head_7_loss: 0.0038 - val_loss: 0.0270 - learning_rate: 6.4273e-05\n", "\n", "Epoch 80: LearningRateScheduler setting learning rate to 5.850918625355897e-05.\n", "Epoch 80/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 206ms/step - head_1_accuracy: 1.0000 - head_1_loss: 2.3843e-04 - head_2_accuracy: 1.0000 - head_2_loss: 2.4457e-04 - head_3_accuracy: 1.0000 - head_3_loss: 2.4586e-04 - head_4_accuracy: 1.0000 - head_4_loss: 2.4747e-04 - head_5_accuracy: 1.0000 - head_5_loss: 2.2079e-04 - head_6_accuracy: 1.0000 - head_6_loss: 3.3819e-04 - head_7_accuracy: 1.0000 - head_7_loss: 2.2575e-04 - loss: 0.0018\n", "Epoch 80: val_head_1_accuracy did not improve from 0.99907\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 214ms/step - head_1_accuracy: 1.0000 - head_1_loss: 2.4607e-04 - head_2_accuracy: 1.0000 - head_2_loss: 2.3397e-04 - head_3_accuracy: 1.0000 - head_3_loss: 2.4148e-04 - head_4_accuracy: 0.9999 - head_4_loss: 2.5094e-04 - head_5_accuracy: 1.0000 - head_5_loss: 2.1663e-04 - head_6_accuracy: 1.0000 - head_6_loss: 2.6044e-04 - head_7_accuracy: 1.0000 - head_7_loss: 2.0870e-04 - loss: 0.0017 - val_head_1_accuracy: 0.9984 - val_head_1_loss: 0.0043 - val_head_2_accuracy: 0.9984 - val_head_2_loss: 0.0044 - val_head_3_accuracy: 0.9984 - val_head_3_loss: 0.0042 - val_head_4_accuracy: 0.9984 - val_head_4_loss: 0.0045 - val_head_5_accuracy: 0.9981 - val_head_5_loss: 0.0044 - val_head_6_accuracy: 0.9984 - val_head_6_loss: 0.0042 - val_head_7_accuracy: 0.9981 - val_head_7_loss: 0.0045 - val_loss: 0.0307 - learning_rate: 5.8509e-05\n", "\n", "Epoch 81: LearningRateScheduler setting learning rate to 5.298820940012169e-05.\n", "Epoch 81/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 207ms/step - head_1_accuracy: 1.0000 - head_1_loss: 1.7584e-04 - head_2_accuracy: 1.0000 - head_2_loss: 2.5268e-04 - head_3_accuracy: 1.0000 - head_3_loss: 1.8981e-04 - head_4_accuracy: 1.0000 - head_4_loss: 2.1298e-04 - head_5_accuracy: 1.0000 - head_5_loss: 2.0815e-04 - head_6_accuracy: 1.0000 - head_6_loss: 2.0871e-04 - head_7_accuracy: 1.0000 - head_7_loss: 2.1744e-04 - loss: 0.0015\n", "Epoch 81: val_head_1_accuracy did not improve from 0.99907\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 219ms/step - head_1_accuracy: 0.9999 - head_1_loss: 2.8325e-04 - head_2_accuracy: 0.9999 - head_2_loss: 3.2561e-04 - head_3_accuracy: 0.9999 - head_3_loss: 2.9231e-04 - head_4_accuracy: 0.9999 - head_4_loss: 3.2106e-04 - head_5_accuracy: 0.9999 - head_5_loss: 3.1534e-04 - head_6_accuracy: 0.9999 - head_6_loss: 3.3550e-04 - head_7_accuracy: 0.9999 - head_7_loss: 3.3037e-04 - loss: 0.0022 - val_head_1_accuracy: 0.9986 - val_head_1_loss: 0.0048 - val_head_2_accuracy: 0.9984 - val_head_2_loss: 0.0051 - val_head_3_accuracy: 0.9984 - val_head_3_loss: 0.0047 - val_head_4_accuracy: 0.9986 - val_head_4_loss: 0.0050 - val_head_5_accuracy: 0.9986 - val_head_5_loss: 0.0050 - val_head_6_accuracy: 0.9984 - val_head_6_loss: 0.0048 - val_head_7_accuracy: 0.9984 - val_head_7_loss: 0.0050 - val_loss: 0.0344 - learning_rate: 5.2988e-05\n", "\n", "Epoch 82: LearningRateScheduler setting learning rate to 4.7716002827287234e-05.\n", "Epoch 82/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 205ms/step - head_1_accuracy: 1.0000 - head_1_loss: 1.3428e-04 - head_2_accuracy: 1.0000 - head_2_loss: 1.6806e-04 - head_3_accuracy: 1.0000 - head_3_loss: 1.2368e-04 - head_4_accuracy: 1.0000 - head_4_loss: 1.3480e-04 - head_5_accuracy: 1.0000 - head_5_loss: 1.2634e-04 - head_6_accuracy: 1.0000 - head_6_loss: 1.5143e-04 - head_7_accuracy: 1.0000 - head_7_loss: 1.3712e-04 - loss: 9.7570e-04\n", "Epoch 82: val_head_1_accuracy did not improve from 0.99907\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m40s\u001b[0m 214ms/step - head_1_accuracy: 1.0000 - head_1_loss: 1.5244e-04 - head_2_accuracy: 1.0000 - head_2_loss: 1.6252e-04 - head_3_accuracy: 1.0000 - head_3_loss: 1.4781e-04 - head_4_accuracy: 1.0000 - head_4_loss: 1.5430e-04 - head_5_accuracy: 1.0000 - head_5_loss: 1.4333e-04 - head_6_accuracy: 1.0000 - head_6_loss: 1.5762e-04 - head_7_accuracy: 1.0000 - head_7_loss: 1.7339e-04 - loss: 0.0011 - val_head_1_accuracy: 0.9981 - val_head_1_loss: 0.0057 - val_head_2_accuracy: 0.9979 - val_head_2_loss: 0.0060 - val_head_3_accuracy: 0.9981 - val_head_3_loss: 0.0055 - val_head_4_accuracy: 0.9981 - val_head_4_loss: 0.0059 - val_head_5_accuracy: 0.9979 - val_head_5_loss: 0.0058 - val_head_6_accuracy: 0.9981 - val_head_6_loss: 0.0057 - val_head_7_accuracy: 0.9981 - val_head_7_loss: 0.0059 - val_loss: 0.0398 - learning_rate: 4.7716e-05\n", "\n", "Epoch 83: LearningRateScheduler setting learning rate to 4.26978752001687e-05.\n", "Epoch 83/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 221ms/step - head_1_accuracy: 1.0000 - head_1_loss: 1.9931e-04 - head_2_accuracy: 1.0000 - head_2_loss: 2.1934e-04 - head_3_accuracy: 1.0000 - head_3_loss: 1.9647e-04 - head_4_accuracy: 1.0000 - head_4_loss: 2.1146e-04 - head_5_accuracy: 1.0000 - head_5_loss: 1.7278e-04 - head_6_accuracy: 1.0000 - head_6_loss: 1.8580e-04 - head_7_accuracy: 1.0000 - head_7_loss: 1.9330e-04 - loss: 0.0014\n", "Epoch 83: val_head_1_accuracy did not improve from 0.99907\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m23s\u001b[0m 228ms/step - head_1_accuracy: 1.0000 - head_1_loss: 1.8045e-04 - head_2_accuracy: 1.0000 - head_2_loss: 1.8593e-04 - head_3_accuracy: 0.9999 - head_3_loss: 2.0635e-04 - head_4_accuracy: 0.9999 - head_4_loss: 1.9616e-04 - head_5_accuracy: 1.0000 - head_5_loss: 1.5339e-04 - head_6_accuracy: 1.0000 - head_6_loss: 1.7105e-04 - head_7_accuracy: 1.0000 - head_7_loss: 1.8227e-04 - loss: 0.0013 - val_head_1_accuracy: 0.9986 - val_head_1_loss: 0.0051 - val_head_2_accuracy: 0.9986 - val_head_2_loss: 0.0053 - val_head_3_accuracy: 0.9986 - val_head_3_loss: 0.0050 - val_head_4_accuracy: 0.9986 - val_head_4_loss: 0.0053 - val_head_5_accuracy: 0.9986 - val_head_5_loss: 0.0052 - val_head_6_accuracy: 0.9986 - val_head_6_loss: 0.0050 - val_head_7_accuracy: 0.9986 - val_head_7_loss: 0.0052 - val_loss: 0.0363 - learning_rate: 4.2698e-05\n", "\n", "Epoch 84: LearningRateScheduler setting learning rate to 3.793887934791801e-05.\n", "Epoch 84/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 206ms/step - head_1_accuracy: 0.9998 - head_1_loss: 4.4407e-04 - head_2_accuracy: 0.9998 - head_2_loss: 4.8751e-04 - head_3_accuracy: 0.9998 - head_3_loss: 4.6467e-04 - head_4_accuracy: 0.9998 - head_4_loss: 5.0533e-04 - head_5_accuracy: 0.9998 - head_5_loss: 3.6066e-04 - head_6_accuracy: 0.9998 - head_6_loss: 4.3121e-04 - head_7_accuracy: 0.9998 - head_7_loss: 5.0522e-04 - loss: 0.0032\n", "Epoch 84: val_head_1_accuracy did not improve from 0.99907\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 215ms/step - head_1_accuracy: 0.9998 - head_1_loss: 4.7884e-04 - head_2_accuracy: 0.9998 - head_2_loss: 5.0081e-04 - head_3_accuracy: 0.9998 - head_3_loss: 4.8490e-04 - head_4_accuracy: 0.9998 - head_4_loss: 5.3207e-04 - head_5_accuracy: 0.9998 - head_5_loss: 4.0518e-04 - head_6_accuracy: 0.9998 - head_6_loss: 4.6467e-04 - head_7_accuracy: 0.9998 - head_7_loss: 4.9421e-04 - loss: 0.0034 - val_head_1_accuracy: 0.9974 - val_head_1_loss: 0.0075 - val_head_2_accuracy: 0.9977 - val_head_2_loss: 0.0075 - val_head_3_accuracy: 0.9974 - val_head_3_loss: 0.0073 - val_head_4_accuracy: 0.9974 - val_head_4_loss: 0.0078 - val_head_5_accuracy: 0.9979 - val_head_5_loss: 0.0075 - val_head_6_accuracy: 0.9977 - val_head_6_loss: 0.0074 - val_head_7_accuracy: 0.9979 - val_head_7_loss: 0.0074 - val_loss: 0.0523 - learning_rate: 3.7939e-05\n", "\n", "Epoch 85: LearningRateScheduler setting learning rate to 3.344380717595574e-05.\n", "Epoch 85/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 201ms/step - head_1_accuracy: 1.0000 - head_1_loss: 1.5865e-04 - head_2_accuracy: 1.0000 - head_2_loss: 2.0058e-04 - head_3_accuracy: 1.0000 - head_3_loss: 1.4592e-04 - head_4_accuracy: 1.0000 - head_4_loss: 2.4723e-04 - head_5_accuracy: 1.0000 - head_5_loss: 1.7766e-04 - head_6_accuracy: 1.0000 - head_6_loss: 2.0892e-04 - head_7_accuracy: 1.0000 - head_7_loss: 1.7619e-04 - loss: 0.0013\n", "Epoch 85: val_head_1_accuracy did not improve from 0.99907\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m21s\u001b[0m 208ms/step - head_1_accuracy: 1.0000 - head_1_loss: 1.4489e-04 - head_2_accuracy: 1.0000 - head_2_loss: 1.7183e-04 - head_3_accuracy: 1.0000 - head_3_loss: 1.4239e-04 - head_4_accuracy: 1.0000 - head_4_loss: 1.6157e-04 - head_5_accuracy: 1.0000 - head_5_loss: 1.5693e-04 - head_6_accuracy: 1.0000 - head_6_loss: 1.5067e-04 - head_7_accuracy: 1.0000 - head_7_loss: 1.5723e-04 - loss: 0.0011 - val_head_1_accuracy: 0.9986 - val_head_1_loss: 0.0056 - val_head_2_accuracy: 0.9986 - val_head_2_loss: 0.0057 - val_head_3_accuracy: 0.9986 - val_head_3_loss: 0.0055 - val_head_4_accuracy: 0.9986 - val_head_4_loss: 0.0058 - val_head_5_accuracy: 0.9986 - val_head_5_loss: 0.0057 - val_head_6_accuracy: 0.9986 - val_head_6_loss: 0.0055 - val_head_7_accuracy: 0.9986 - val_head_7_loss: 0.0056 - val_loss: 0.0398 - learning_rate: 3.3444e-05\n", "\n", "Epoch 86: LearningRateScheduler setting learning rate to 2.9217184840928013e-05.\n", "Epoch 86/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 204ms/step - head_1_accuracy: 1.0000 - head_1_loss: 1.2932e-04 - head_2_accuracy: 1.0000 - head_2_loss: 1.1127e-04 - head_3_accuracy: 1.0000 - head_3_loss: 1.0970e-04 - head_4_accuracy: 1.0000 - head_4_loss: 9.8542e-05 - head_5_accuracy: 1.0000 - head_5_loss: 1.3586e-04 - head_6_accuracy: 1.0000 - head_6_loss: 9.4978e-05 - head_7_accuracy: 1.0000 - head_7_loss: 1.2301e-04 - loss: 8.0267e-04\n", "Epoch 86: val_head_1_accuracy did not improve from 0.99907\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 212ms/step - head_1_accuracy: 1.0000 - head_1_loss: 1.0601e-04 - head_2_accuracy: 1.0000 - head_2_loss: 1.0509e-04 - head_3_accuracy: 1.0000 - head_3_loss: 1.0590e-04 - head_4_accuracy: 1.0000 - head_4_loss: 9.3769e-05 - head_5_accuracy: 1.0000 - head_5_loss: 1.3096e-04 - head_6_accuracy: 1.0000 - head_6_loss: 9.4794e-05 - head_7_accuracy: 1.0000 - head_7_loss: 1.1655e-04 - loss: 7.6046e-04 - val_head_1_accuracy: 0.9988 - val_head_1_loss: 0.0048 - val_head_2_accuracy: 0.9988 - val_head_2_loss: 0.0050 - val_head_3_accuracy: 0.9988 - val_head_3_loss: 0.0047 - val_head_4_accuracy: 0.9988 - val_head_4_loss: 0.0050 - val_head_5_accuracy: 0.9986 - val_head_5_loss: 0.0049 - val_head_6_accuracy: 0.9986 - val_head_6_loss: 0.0048 - val_head_7_accuracy: 0.9988 - val_head_7_loss: 0.0049 - val_loss: 0.0344 - learning_rate: 2.9217e-05\n", "\n", "Epoch 87: LearningRateScheduler setting learning rate to 2.526326819325076e-05.\n", "Epoch 87/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 209ms/step - head_1_accuracy: 1.0000 - head_1_loss: 8.6912e-05 - head_2_accuracy: 1.0000 - head_2_loss: 8.5418e-05 - head_3_accuracy: 1.0000 - head_3_loss: 9.1322e-05 - head_4_accuracy: 1.0000 - head_4_loss: 8.7069e-05 - head_5_accuracy: 1.0000 - head_5_loss: 8.2643e-05 - head_6_accuracy: 1.0000 - head_6_loss: 9.3699e-05 - head_7_accuracy: 1.0000 - head_7_loss: 1.0581e-04 - loss: 6.3287e-04\n", "Epoch 87: val_head_1_accuracy did not improve from 0.99907\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 216ms/step - head_1_accuracy: 1.0000 - head_1_loss: 1.1428e-04 - head_2_accuracy: 1.0000 - head_2_loss: 1.1215e-04 - head_3_accuracy: 1.0000 - head_3_loss: 1.2300e-04 - head_4_accuracy: 1.0000 - head_4_loss: 1.0790e-04 - head_5_accuracy: 1.0000 - head_5_loss: 1.0663e-04 - head_6_accuracy: 1.0000 - head_6_loss: 1.3342e-04 - head_7_accuracy: 1.0000 - head_7_loss: 1.3978e-04 - loss: 8.4541e-04 - val_head_1_accuracy: 0.9986 - val_head_1_loss: 0.0037 - val_head_2_accuracy: 0.9986 - val_head_2_loss: 0.0039 - val_head_3_accuracy: 0.9986 - val_head_3_loss: 0.0037 - val_head_4_accuracy: 0.9986 - val_head_4_loss: 0.0039 - val_head_5_accuracy: 0.9984 - val_head_5_loss: 0.0038 - val_head_6_accuracy: 0.9984 - val_head_6_loss: 0.0037 - val_head_7_accuracy: 0.9986 - val_head_7_loss: 0.0038 - val_loss: 0.0267 - learning_rate: 2.5263e-05\n", "\n", "Epoch 88: LearningRateScheduler setting learning rate to 2.1586038491829064e-05.\n", "Epoch 88/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 207ms/step - head_1_accuracy: 1.0000 - head_1_loss: 8.7862e-05 - head_2_accuracy: 1.0000 - head_2_loss: 8.0875e-05 - head_3_accuracy: 1.0000 - head_3_loss: 7.9574e-05 - head_4_accuracy: 1.0000 - head_4_loss: 7.8262e-05 - head_5_accuracy: 1.0000 - head_5_loss: 7.8525e-05 - head_6_accuracy: 1.0000 - head_6_loss: 7.6732e-05 - head_7_accuracy: 1.0000 - head_7_loss: 7.9327e-05 - loss: 5.6116e-04\n", "Epoch 88: val_head_1_accuracy did not improve from 0.99907\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 214ms/step - head_1_accuracy: 1.0000 - head_1_loss: 1.0268e-04 - head_2_accuracy: 1.0000 - head_2_loss: 8.2170e-05 - head_3_accuracy: 1.0000 - head_3_loss: 8.5282e-05 - head_4_accuracy: 1.0000 - head_4_loss: 8.7867e-05 - head_5_accuracy: 1.0000 - head_5_loss: 9.1277e-05 - head_6_accuracy: 1.0000 - head_6_loss: 8.6031e-05 - head_7_accuracy: 1.0000 - head_7_loss: 9.1765e-05 - loss: 6.3323e-04 - val_head_1_accuracy: 0.9986 - val_head_1_loss: 0.0030 - val_head_2_accuracy: 0.9984 - val_head_2_loss: 0.0032 - val_head_3_accuracy: 0.9986 - val_head_3_loss: 0.0030 - val_head_4_accuracy: 0.9984 - val_head_4_loss: 0.0031 - val_head_5_accuracy: 0.9986 - val_head_5_loss: 0.0031 - val_head_6_accuracy: 0.9986 - val_head_6_loss: 0.0030 - val_head_7_accuracy: 0.9984 - val_head_7_loss: 0.0031 - val_loss: 0.0218 - learning_rate: 2.1586e-05\n", "\n", "Epoch 89: LearningRateScheduler setting learning rate to 1.8189198395266834e-05.\n", "Epoch 89/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 204ms/step - head_1_accuracy: 1.0000 - head_1_loss: 1.1694e-04 - head_2_accuracy: 1.0000 - head_2_loss: 1.1085e-04 - head_3_accuracy: 1.0000 - head_3_loss: 1.0970e-04 - head_4_accuracy: 1.0000 - head_4_loss: 9.7811e-05 - head_5_accuracy: 1.0000 - head_5_loss: 1.1038e-04 - head_6_accuracy: 1.0000 - head_6_loss: 1.1539e-04 - head_7_accuracy: 1.0000 - head_7_loss: 1.1907e-04 - loss: 7.8013e-04\n", "Epoch 89: val_head_1_accuracy did not improve from 0.99907\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 213ms/step - head_1_accuracy: 0.9999 - head_1_loss: 1.7302e-04 - head_2_accuracy: 1.0000 - head_2_loss: 1.6921e-04 - head_3_accuracy: 0.9999 - head_3_loss: 1.7520e-04 - head_4_accuracy: 1.0000 - head_4_loss: 1.4879e-04 - head_5_accuracy: 1.0000 - head_5_loss: 1.5476e-04 - head_6_accuracy: 0.9999 - head_6_loss: 1.9917e-04 - head_7_accuracy: 0.9999 - head_7_loss: 1.8995e-04 - loss: 0.0012 - val_head_1_accuracy: 0.9991 - val_head_1_loss: 0.0031 - val_head_2_accuracy: 0.9991 - val_head_2_loss: 0.0032 - val_head_3_accuracy: 0.9993 - val_head_3_loss: 0.0031 - val_head_4_accuracy: 0.9991 - val_head_4_loss: 0.0031 - val_head_5_accuracy: 0.9991 - val_head_5_loss: 0.0032 - val_head_6_accuracy: 0.9991 - val_head_6_loss: 0.0032 - val_head_7_accuracy: 0.9993 - val_head_7_loss: 0.0032 - val_loss: 0.0223 - learning_rate: 1.8189e-05\n", "\n", "Epoch 90: LearningRateScheduler setting learning rate to 1.5076168233603417e-05.\n", "Epoch 90/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 205ms/step - head_1_accuracy: 1.0000 - head_1_loss: 1.1082e-04 - head_2_accuracy: 1.0000 - head_2_loss: 1.2595e-04 - head_3_accuracy: 1.0000 - head_3_loss: 1.5458e-04 - head_4_accuracy: 1.0000 - head_4_loss: 1.2873e-04 - head_5_accuracy: 1.0000 - head_5_loss: 1.4478e-04 - head_6_accuracy: 1.0000 - head_6_loss: 1.4313e-04 - head_7_accuracy: 1.0000 - head_7_loss: 1.4080e-04 - loss: 9.4879e-04\n", "Epoch 90: val_head_1_accuracy did not improve from 0.99907\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 212ms/step - head_1_accuracy: 1.0000 - head_1_loss: 1.1383e-04 - head_2_accuracy: 1.0000 - head_2_loss: 1.2487e-04 - head_3_accuracy: 1.0000 - head_3_loss: 1.4007e-04 - head_4_accuracy: 1.0000 - head_4_loss: 1.2645e-04 - head_5_accuracy: 1.0000 - head_5_loss: 1.3270e-04 - head_6_accuracy: 1.0000 - head_6_loss: 1.3532e-04 - head_7_accuracy: 1.0000 - head_7_loss: 1.3238e-04 - loss: 9.1453e-04 - val_head_1_accuracy: 0.9988 - val_head_1_loss: 0.0034 - val_head_2_accuracy: 0.9988 - val_head_2_loss: 0.0035 - val_head_3_accuracy: 0.9993 - val_head_3_loss: 0.0034 - val_head_4_accuracy: 0.9986 - val_head_4_loss: 0.0035 - val_head_5_accuracy: 0.9991 - val_head_5_loss: 0.0034 - val_head_6_accuracy: 0.9991 - val_head_6_loss: 0.0034 - val_head_7_accuracy: 0.9988 - val_head_7_loss: 0.0035 - val_loss: 0.0242 - learning_rate: 1.5076e-05\n", "\n", "Epoch 91: LearningRateScheduler setting learning rate to 1.2250082564331516e-05.\n", "Epoch 91/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 206ms/step - head_1_accuracy: 1.0000 - head_1_loss: 1.0654e-04 - head_2_accuracy: 1.0000 - head_2_loss: 1.2585e-04 - head_3_accuracy: 1.0000 - head_3_loss: 1.0860e-04 - head_4_accuracy: 1.0000 - head_4_loss: 1.2797e-04 - head_5_accuracy: 1.0000 - head_5_loss: 1.1415e-04 - head_6_accuracy: 1.0000 - head_6_loss: 1.1286e-04 - head_7_accuracy: 1.0000 - head_7_loss: 1.1911e-04 - loss: 8.1507e-04\n", "Epoch 91: val_head_1_accuracy did not improve from 0.99907\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 215ms/step - head_1_accuracy: 1.0000 - head_1_loss: 9.2870e-05 - head_2_accuracy: 1.0000 - head_2_loss: 9.7283e-05 - head_3_accuracy: 1.0000 - head_3_loss: 8.8716e-05 - head_4_accuracy: 1.0000 - head_4_loss: 9.7318e-05 - head_5_accuracy: 1.0000 - head_5_loss: 9.1200e-05 - head_6_accuracy: 1.0000 - head_6_loss: 9.0913e-05 - head_7_accuracy: 1.0000 - head_7_loss: 9.8124e-05 - loss: 6.6287e-04 - val_head_1_accuracy: 0.9988 - val_head_1_loss: 0.0033 - val_head_2_accuracy: 0.9986 - val_head_2_loss: 0.0035 - val_head_3_accuracy: 0.9988 - val_head_3_loss: 0.0034 - val_head_4_accuracy: 0.9986 - val_head_4_loss: 0.0034 - val_head_5_accuracy: 0.9988 - val_head_5_loss: 0.0034 - val_head_6_accuracy: 0.9988 - val_head_6_loss: 0.0034 - val_head_7_accuracy: 0.9986 - val_head_7_loss: 0.0034 - val_loss: 0.0240 - learning_rate: 1.2250e-05\n", "\n", "Epoch 92: LearningRateScheduler setting learning rate to 9.713787016162943e-06.\n", "Epoch 92/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 206ms/step - head_1_accuracy: 1.0000 - head_1_loss: 1.2623e-04 - head_2_accuracy: 1.0000 - head_2_loss: 1.0159e-04 - head_3_accuracy: 1.0000 - head_3_loss: 1.1988e-04 - head_4_accuracy: 1.0000 - head_4_loss: 1.1255e-04 - head_5_accuracy: 1.0000 - head_5_loss: 9.9855e-05 - head_6_accuracy: 1.0000 - head_6_loss: 1.3878e-04 - head_7_accuracy: 1.0000 - head_7_loss: 1.0941e-04 - loss: 8.0828e-04\n", "Epoch 92: val_head_1_accuracy did not improve from 0.99907\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 213ms/step - head_1_accuracy: 1.0000 - head_1_loss: 1.0485e-04 - head_2_accuracy: 1.0000 - head_2_loss: 9.4978e-05 - head_3_accuracy: 1.0000 - head_3_loss: 1.0548e-04 - head_4_accuracy: 1.0000 - head_4_loss: 1.0587e-04 - head_5_accuracy: 1.0000 - head_5_loss: 8.5736e-05 - head_6_accuracy: 1.0000 - head_6_loss: 1.1930e-04 - head_7_accuracy: 1.0000 - head_7_loss: 9.1812e-05 - loss: 7.1499e-04 - val_head_1_accuracy: 0.9988 - val_head_1_loss: 0.0034 - val_head_2_accuracy: 0.9986 - val_head_2_loss: 0.0035 - val_head_3_accuracy: 0.9988 - val_head_3_loss: 0.0034 - val_head_4_accuracy: 0.9986 - val_head_4_loss: 0.0035 - val_head_5_accuracy: 0.9986 - val_head_5_loss: 0.0035 - val_head_6_accuracy: 0.9986 - val_head_6_loss: 0.0034 - val_head_7_accuracy: 0.9986 - val_head_7_loss: 0.0035 - val_loss: 0.0243 - learning_rate: 9.7138e-06\n", "\n", "Epoch 93: LearningRateScheduler setting learning rate to 7.469835423722156e-06.\n", "Epoch 93/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 207ms/step - head_1_accuracy: 1.0000 - head_1_loss: 1.4285e-04 - head_2_accuracy: 1.0000 - head_2_loss: 1.2721e-04 - head_3_accuracy: 1.0000 - head_3_loss: 1.2472e-04 - head_4_accuracy: 1.0000 - head_4_loss: 1.2849e-04 - head_5_accuracy: 1.0000 - head_5_loss: 1.3162e-04 - head_6_accuracy: 1.0000 - head_6_loss: 1.4842e-04 - head_7_accuracy: 1.0000 - head_7_loss: 1.6497e-04 - loss: 9.6828e-04\n", "Epoch 93: val_head_1_accuracy did not improve from 0.99907\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 219ms/step - head_1_accuracy: 1.0000 - head_1_loss: 1.2533e-04 - head_2_accuracy: 1.0000 - head_2_loss: 1.2029e-04 - head_3_accuracy: 1.0000 - head_3_loss: 1.0835e-04 - head_4_accuracy: 1.0000 - head_4_loss: 1.2110e-04 - head_5_accuracy: 1.0000 - head_5_loss: 1.2622e-04 - head_6_accuracy: 1.0000 - head_6_loss: 1.3974e-04 - head_7_accuracy: 1.0000 - head_7_loss: 1.5159e-04 - loss: 9.0136e-04 - val_head_1_accuracy: 0.9986 - val_head_1_loss: 0.0036 - val_head_2_accuracy: 0.9986 - val_head_2_loss: 0.0037 - val_head_3_accuracy: 0.9984 - val_head_3_loss: 0.0036 - val_head_4_accuracy: 0.9986 - val_head_4_loss: 0.0037 - val_head_5_accuracy: 0.9984 - val_head_5_loss: 0.0037 - val_head_6_accuracy: 0.9984 - val_head_6_loss: 0.0036 - val_head_7_accuracy: 0.9984 - val_head_7_loss: 0.0037 - val_loss: 0.0257 - learning_rate: 7.4698e-06\n", "\n", "Epoch 94: LearningRateScheduler setting learning rate to 5.520487256051157e-06.\n", "Epoch 94/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 205ms/step - head_1_accuracy: 1.0000 - head_1_loss: 7.7686e-05 - head_2_accuracy: 1.0000 - head_2_loss: 8.9058e-05 - head_3_accuracy: 1.0000 - head_3_loss: 7.9761e-05 - head_4_accuracy: 1.0000 - head_4_loss: 8.7605e-05 - head_5_accuracy: 1.0000 - head_5_loss: 8.7203e-05 - head_6_accuracy: 1.0000 - head_6_loss: 8.6530e-05 - head_7_accuracy: 1.0000 - head_7_loss: 8.8879e-05 - loss: 5.9672e-04\n", "Epoch 94: val_head_1_accuracy did not improve from 0.99907\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 212ms/step - head_1_accuracy: 1.0000 - head_1_loss: 7.6739e-05 - head_2_accuracy: 1.0000 - head_2_loss: 8.9300e-05 - head_3_accuracy: 1.0000 - head_3_loss: 7.3299e-05 - head_4_accuracy: 1.0000 - head_4_loss: 8.3519e-05 - head_5_accuracy: 1.0000 - head_5_loss: 8.1743e-05 - head_6_accuracy: 1.0000 - head_6_loss: 8.3246e-05 - head_7_accuracy: 1.0000 - head_7_loss: 8.8555e-05 - loss: 5.8204e-04 - val_head_1_accuracy: 0.9984 - val_head_1_loss: 0.0035 - val_head_2_accuracy: 0.9986 - val_head_2_loss: 0.0037 - val_head_3_accuracy: 0.9984 - val_head_3_loss: 0.0035 - val_head_4_accuracy: 0.9986 - val_head_4_loss: 0.0037 - val_head_5_accuracy: 0.9984 - val_head_5_loss: 0.0036 - val_head_6_accuracy: 0.9984 - val_head_6_loss: 0.0035 - val_head_7_accuracy: 0.9984 - val_head_7_loss: 0.0036 - val_loss: 0.0254 - learning_rate: 5.5205e-06\n", "\n", "Epoch 95: LearningRateScheduler setting learning rate to 3.867705341515533e-06.\n", "Epoch 95/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 205ms/step - head_1_accuracy: 1.0000 - head_1_loss: 7.2094e-05 - head_2_accuracy: 1.0000 - head_2_loss: 7.6908e-05 - head_3_accuracy: 1.0000 - head_3_loss: 7.4242e-05 - head_4_accuracy: 1.0000 - head_4_loss: 7.0263e-05 - head_5_accuracy: 1.0000 - head_5_loss: 8.7491e-05 - head_6_accuracy: 1.0000 - head_6_loss: 6.8871e-05 - head_7_accuracy: 1.0000 - head_7_loss: 7.4934e-05 - loss: 5.2480e-04\n", "Epoch 95: val_head_1_accuracy did not improve from 0.99907\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 218ms/step - head_1_accuracy: 1.0000 - head_1_loss: 8.0039e-05 - head_2_accuracy: 1.0000 - head_2_loss: 8.2239e-05 - head_3_accuracy: 1.0000 - head_3_loss: 8.1359e-05 - head_4_accuracy: 1.0000 - head_4_loss: 7.3192e-05 - head_5_accuracy: 1.0000 - head_5_loss: 8.8066e-05 - head_6_accuracy: 1.0000 - head_6_loss: 7.7588e-05 - head_7_accuracy: 1.0000 - head_7_loss: 8.4613e-05 - loss: 5.7266e-04 - val_head_1_accuracy: 0.9984 - val_head_1_loss: 0.0035 - val_head_2_accuracy: 0.9986 - val_head_2_loss: 0.0037 - val_head_3_accuracy: 0.9984 - val_head_3_loss: 0.0035 - val_head_4_accuracy: 0.9986 - val_head_4_loss: 0.0037 - val_head_5_accuracy: 0.9984 - val_head_5_loss: 0.0036 - val_head_6_accuracy: 0.9984 - val_head_6_loss: 0.0035 - val_head_7_accuracy: 0.9984 - val_head_7_loss: 0.0036 - val_loss: 0.0254 - learning_rate: 3.8677e-06\n", "\n", "Epoch 96: LearningRateScheduler setting learning rate to 2.5131538914029374e-06.\n", "Epoch 96/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 204ms/step - head_1_accuracy: 1.0000 - head_1_loss: 8.8077e-05 - head_2_accuracy: 1.0000 - head_2_loss: 8.2294e-05 - head_3_accuracy: 1.0000 - head_3_loss: 7.7680e-05 - head_4_accuracy: 1.0000 - head_4_loss: 9.3074e-05 - head_5_accuracy: 1.0000 - head_5_loss: 7.5026e-05 - head_6_accuracy: 1.0000 - head_6_loss: 9.1188e-05 - head_7_accuracy: 1.0000 - head_7_loss: 8.3310e-05 - loss: 5.9065e-04\n", "Epoch 96: val_head_1_accuracy did not improve from 0.99907\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 212ms/step - head_1_accuracy: 1.0000 - head_1_loss: 7.6304e-05 - head_2_accuracy: 1.0000 - head_2_loss: 8.0098e-05 - head_3_accuracy: 1.0000 - head_3_loss: 7.6702e-05 - head_4_accuracy: 1.0000 - head_4_loss: 8.1186e-05 - head_5_accuracy: 1.0000 - head_5_loss: 7.5450e-05 - head_6_accuracy: 1.0000 - head_6_loss: 8.1438e-05 - head_7_accuracy: 1.0000 - head_7_loss: 7.3517e-05 - loss: 5.5005e-04 - val_head_1_accuracy: 0.9986 - val_head_1_loss: 0.0035 - val_head_2_accuracy: 0.9986 - val_head_2_loss: 0.0037 - val_head_3_accuracy: 0.9984 - val_head_3_loss: 0.0035 - val_head_4_accuracy: 0.9986 - val_head_4_loss: 0.0037 - val_head_5_accuracy: 0.9984 - val_head_5_loss: 0.0036 - val_head_6_accuracy: 0.9984 - val_head_6_loss: 0.0035 - val_head_7_accuracy: 0.9984 - val_head_7_loss: 0.0036 - val_loss: 0.0253 - learning_rate: 2.5132e-06\n", "\n", "Epoch 97: LearningRateScheduler setting learning rate to 1.4581968242032775e-06.\n", "Epoch 97/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 204ms/step - head_1_accuracy: 1.0000 - head_1_loss: 5.8405e-05 - head_2_accuracy: 1.0000 - head_2_loss: 6.1561e-05 - head_3_accuracy: 1.0000 - head_3_loss: 6.4054e-05 - head_4_accuracy: 1.0000 - head_4_loss: 5.6273e-05 - head_5_accuracy: 1.0000 - head_5_loss: 6.2291e-05 - head_6_accuracy: 1.0000 - head_6_loss: 6.4343e-05 - head_7_accuracy: 1.0000 - head_7_loss: 7.0708e-05 - loss: 4.3764e-04\n", "Epoch 97: val_head_1_accuracy did not improve from 0.99907\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 213ms/step - head_1_accuracy: 1.0000 - head_1_loss: 7.3701e-05 - head_2_accuracy: 1.0000 - head_2_loss: 8.1676e-05 - head_3_accuracy: 1.0000 - head_3_loss: 8.1073e-05 - head_4_accuracy: 1.0000 - head_4_loss: 6.8998e-05 - head_5_accuracy: 1.0000 - head_5_loss: 8.1660e-05 - head_6_accuracy: 1.0000 - head_6_loss: 7.6041e-05 - head_7_accuracy: 1.0000 - head_7_loss: 8.7236e-05 - loss: 5.5579e-04 - val_head_1_accuracy: 0.9986 - val_head_1_loss: 0.0035 - val_head_2_accuracy: 0.9986 - val_head_2_loss: 0.0037 - val_head_3_accuracy: 0.9984 - val_head_3_loss: 0.0035 - val_head_4_accuracy: 0.9986 - val_head_4_loss: 0.0037 - val_head_5_accuracy: 0.9984 - val_head_5_loss: 0.0036 - val_head_6_accuracy: 0.9984 - val_head_6_loss: 0.0035 - val_head_7_accuracy: 0.9984 - val_head_7_loss: 0.0036 - val_loss: 0.0254 - learning_rate: 1.4582e-06\n", "\n", "Epoch 98: LearningRateScheduler setting learning rate to 7.038963922582963e-07.\n", "Epoch 98/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 204ms/step - head_1_accuracy: 1.0000 - head_1_loss: 1.2783e-04 - head_2_accuracy: 1.0000 - head_2_loss: 1.8294e-04 - head_3_accuracy: 1.0000 - head_3_loss: 1.5101e-04 - head_4_accuracy: 1.0000 - head_4_loss: 1.3855e-04 - head_5_accuracy: 1.0000 - head_5_loss: 1.6236e-04 - head_6_accuracy: 1.0000 - head_6_loss: 1.8925e-04 - head_7_accuracy: 1.0000 - head_7_loss: 1.6060e-04 - loss: 0.0011\n", "Epoch 98: val_head_1_accuracy did not improve from 0.99907\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 212ms/step - head_1_accuracy: 1.0000 - head_1_loss: 1.4396e-04 - head_2_accuracy: 1.0000 - head_2_loss: 1.8260e-04 - head_3_accuracy: 1.0000 - head_3_loss: 1.6886e-04 - head_4_accuracy: 0.9999 - head_4_loss: 1.8887e-04 - head_5_accuracy: 1.0000 - head_5_loss: 1.6598e-04 - head_6_accuracy: 1.0000 - head_6_loss: 1.8678e-04 - head_7_accuracy: 1.0000 - head_7_loss: 1.6167e-04 - loss: 0.0012 - val_head_1_accuracy: 0.9986 - val_head_1_loss: 0.0035 - val_head_2_accuracy: 0.9986 - val_head_2_loss: 0.0037 - val_head_3_accuracy: 0.9984 - val_head_3_loss: 0.0035 - val_head_4_accuracy: 0.9986 - val_head_4_loss: 0.0037 - val_head_5_accuracy: 0.9984 - val_head_5_loss: 0.0036 - val_head_6_accuracy: 0.9984 - val_head_6_loss: 0.0035 - val_head_7_accuracy: 0.9984 - val_head_7_loss: 0.0036 - val_loss: 0.0253 - learning_rate: 7.0390e-07\n", "\n", "Epoch 99: LearningRateScheduler setting learning rate to 2.510121121636345e-07.\n", "Epoch 99/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 205ms/step - head_1_accuracy: 1.0000 - head_1_loss: 8.6316e-05 - head_2_accuracy: 1.0000 - head_2_loss: 1.0950e-04 - head_3_accuracy: 1.0000 - head_3_loss: 9.0880e-05 - head_4_accuracy: 1.0000 - head_4_loss: 1.0823e-04 - head_5_accuracy: 1.0000 - head_5_loss: 1.1266e-04 - head_6_accuracy: 1.0000 - head_6_loss: 9.8360e-05 - head_7_accuracy: 1.0000 - head_7_loss: 1.1050e-04 - loss: 7.1645e-04\n", "Epoch 99: val_head_1_accuracy did not improve from 0.99907\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 214ms/step - head_1_accuracy: 1.0000 - head_1_loss: 9.7482e-05 - head_2_accuracy: 1.0000 - head_2_loss: 1.3989e-04 - head_3_accuracy: 1.0000 - head_3_loss: 1.1443e-04 - head_4_accuracy: 1.0000 - head_4_loss: 1.2420e-04 - head_5_accuracy: 1.0000 - head_5_loss: 1.4264e-04 - head_6_accuracy: 1.0000 - head_6_loss: 1.3565e-04 - head_7_accuracy: 1.0000 - head_7_loss: 1.4550e-04 - loss: 9.0862e-04 - val_head_1_accuracy: 0.9986 - val_head_1_loss: 0.0035 - val_head_2_accuracy: 0.9986 - val_head_2_loss: 0.0037 - val_head_3_accuracy: 0.9984 - val_head_3_loss: 0.0035 - val_head_4_accuracy: 0.9986 - val_head_4_loss: 0.0037 - val_head_5_accuracy: 0.9984 - val_head_5_loss: 0.0036 - val_head_6_accuracy: 0.9984 - val_head_6_loss: 0.0035 - val_head_7_accuracy: 0.9984 - val_head_7_loss: 0.0036 - val_loss: 0.0254 - learning_rate: 2.5101e-07\n", "\n", "Epoch 100: LearningRateScheduler setting learning rate to 1e-07.\n", "Epoch 100/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 204ms/step - head_1_accuracy: 1.0000 - head_1_loss: 9.3320e-05 - head_2_accuracy: 1.0000 - head_2_loss: 9.8206e-05 - head_3_accuracy: 1.0000 - head_3_loss: 9.0910e-05 - head_4_accuracy: 1.0000 - head_4_loss: 9.7650e-05 - head_5_accuracy: 1.0000 - head_5_loss: 9.5586e-05 - head_6_accuracy: 1.0000 - head_6_loss: 1.0783e-04 - head_7_accuracy: 1.0000 - head_7_loss: 9.8717e-05 - loss: 6.8222e-04\n", "Epoch 100: val_head_1_accuracy did not improve from 0.99907\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m41s\u001b[0m 214ms/step - head_1_accuracy: 0.9999 - head_1_loss: 1.3872e-04 - head_2_accuracy: 0.9999 - head_2_loss: 1.4934e-04 - head_3_accuracy: 1.0000 - head_3_loss: 1.2709e-04 - head_4_accuracy: 0.9999 - head_4_loss: 1.4319e-04 - head_5_accuracy: 0.9999 - head_5_loss: 1.3788e-04 - head_6_accuracy: 0.9999 - head_6_loss: 1.4811e-04 - head_7_accuracy: 0.9999 - head_7_loss: 1.3474e-04 - loss: 9.8869e-04 - val_head_1_accuracy: 0.9986 - val_head_1_loss: 0.0035 - val_head_2_accuracy: 0.9986 - val_head_2_loss: 0.0037 - val_head_3_accuracy: 0.9986 - val_head_3_loss: 0.0035 - val_head_4_accuracy: 0.9986 - val_head_4_loss: 0.0037 - val_head_5_accuracy: 0.9984 - val_head_5_loss: 0.0036 - val_head_6_accuracy: 0.9984 - val_head_6_loss: 0.0035 - val_head_7_accuracy: 0.9984 - val_head_7_loss: 0.0036 - val_loss: 0.0253 - learning_rate: 1.0000e-07\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ "/usr/local/lib/python3.12/dist-packages/keras/src/layers/layer.py:424: UserWarning: `build()` was called on layer 'gf__patch_encoder', however the layer does not have a `build()` method implemented and it looks like it has unbuilt state. This will cause the layer to be marked as built, despite not being actually built, which may cause failures down the line. Make sure to implement a proper `build()` method.\n", " warnings.warn(\n", "/usr/local/lib/python3.12/dist-packages/keras/src/layers/layer.py:424: UserWarning: `build()` was called on layer 'gf__block', however the layer does not have a `build()` method implemented and it looks like it has unbuilt state. This will cause the layer to be marked as built, despite not being actually built, which may cause failures down the line. Make sure to implement a proper `build()` method.\n", " warnings.warn(\n", "/usr/local/lib/python3.12/dist-packages/keras/src/layers/layer.py:424: UserWarning: `build()` was called on layer 'gf__block_1', however the layer does not have a `build()` method implemented and it looks like it has unbuilt state. This will cause the layer to be marked as built, despite not being actually built, which may cause failures down the line. Make sure to implement a proper `build()` method.\n", " warnings.warn(\n", "/usr/local/lib/python3.12/dist-packages/keras/src/layers/layer.py:424: UserWarning: `build()` was called on layer 'gf__block_2', however the layer does not have a `build()` method implemented and it looks like it has unbuilt state. This will cause the layer to be marked as built, despite not being actually built, which may cause failures down the line. Make sure to implement a proper `build()` method.\n", " warnings.warn(\n", "/usr/local/lib/python3.12/dist-packages/keras/src/layers/layer.py:424: UserWarning: `build()` was called on layer 'gf__block_3', however the layer does not have a `build()` method implemented and it looks like it has unbuilt state. This will cause the layer to be marked as built, despite not being actually built, which may cause failures down the line. Make sure to implement a proper `build()` method.\n", " warnings.warn(\n", "/usr/local/lib/python3.12/dist-packages/keras/src/layers/layer.py:424: UserWarning: `build()` was called on layer 'gf__block_4', however the layer does not have a `build()` method implemented and it looks like it has unbuilt state. This will cause the layer to be marked as built, despite not being actually built, which may cause failures down the line. Make sure to implement a proper `build()` method.\n", " warnings.warn(\n", "/usr/local/lib/python3.12/dist-packages/keras/src/layers/layer.py:424: UserWarning: `build()` was called on layer 'gf__block_5', however the layer does not have a `build()` method implemented and it looks like it has unbuilt state. This will cause the layer to be marked as built, despite not being actually built, which may cause failures down the line. Make sure to implement a proper `build()` method.\n", " warnings.warn(\n", "/usr/local/lib/python3.12/dist-packages/keras/src/layers/layer.py:424: UserWarning: `build()` was called on layer 'gf__block_6', however the layer does not have a `build()` method implemented and it looks like it has unbuilt state. This will cause the layer to be marked as built, despite not being actually built, which may cause failures down the line. Make sure to implement a proper `build()` method.\n", " warnings.warn(\n", "/usr/local/lib/python3.12/dist-packages/keras/src/layers/layer.py:424: UserWarning: `build()` was called on layer 'gf__block_7', however the layer does not have a `build()` method implemented and it looks like it has unbuilt state. This will cause the layer to be marked as built, despite not being actually built, which may cause failures down the line. Make sure to implement a proper `build()` method.\n", " warnings.warn(\n", "/usr/local/lib/python3.12/dist-packages/keras/src/layers/layer.py:424: UserWarning: `build()` was called on layer 'gf__block_8', however the layer does not have a `build()` method implemented and it looks like it has unbuilt state. This will cause the layer to be marked as built, despite not being actually built, which may cause failures down the line. Make sure to implement a proper `build()` method.\n", " warnings.warn(\n", "/usr/local/lib/python3.12/dist-packages/keras/src/layers/layer.py:424: UserWarning: `build()` was called on layer 'gf__block_9', however the layer does not have a `build()` method implemented and it looks like it has unbuilt state. This will cause the layer to be marked as built, despite not being actually built, which may cause failures down the line. Make sure to implement a proper `build()` method.\n", " warnings.warn(\n", "/usr/local/lib/python3.12/dist-packages/keras/src/layers/layer.py:424: UserWarning: `build()` was called on layer 'gf__block_10', however the layer does not have a `build()` method implemented and it looks like it has unbuilt state. This will cause the layer to be marked as built, despite not being actually built, which may cause failures down the line. Make sure to implement a proper `build()` method.\n", " warnings.warn(\n", "/usr/local/lib/python3.12/dist-packages/keras/src/layers/layer.py:424: UserWarning: `build()` was called on layer 'gf__block_11', however the layer does not have a `build()` method implemented and it looks like it has unbuilt state. This will cause the layer to be marked as built, despite not being actually built, which may cause failures down the line. Make sure to implement a proper `build()` method.\n", " warnings.warn(\n" ] }, { "output_type": "display_data", "data": { "text/plain": [ "
" ], "image/png": "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\n" }, "metadata": {} }, { "output_type": "stream", "name": "stdout", "text": [ "\n", "============================== Training ViT_UNet_MultiHead ==============================\n" ] }, { "output_type": "display_data", "data": { "text/plain": [ "
" ], "image/png": "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\n" }, "metadata": {} }, { "output_type": "display_data", "data": { "text/plain": [ "
" ], "image/png": "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\n" }, "metadata": {} }, { "output_type": "stream", "name": "stdout", "text": [ "\n", "Epoch 1: LearningRateScheduler setting learning rate to 0.0006.\n", "Epoch 1/100\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 765ms/step - head_1_accuracy: 0.4103 - head_1_loss: 1.4964 - head_2_accuracy: 0.4648 - head_2_loss: 1.4032 - head_3_accuracy: 0.4805 - head_3_loss: 1.3856 - head_4_accuracy: 0.4569 - head_4_loss: 1.3776 - head_5_accuracy: 0.4762 - head_5_loss: 1.3905 - head_6_accuracy: 0.4720 - head_6_loss: 1.4411 - head_7_accuracy: 0.4819 - head_7_loss: 1.3684 - loss: 9.8636\n", "Epoch 1: val_head_1_accuracy improved from None to 0.78515, saving model to /content/drive/My Drive/Classification/multicp/models/ViT_UNet_MultiHead_best.keras\n", "\n", "Epoch 1: finished saving model to /content/drive/My Drive/Classification/multicp/models/ViT_UNet_MultiHead_best.keras\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m200s\u001b[0m 936ms/step - head_1_accuracy: 0.5432 - head_1_loss: 1.1880 - head_2_accuracy: 0.5688 - head_2_loss: 1.1521 - head_3_accuracy: 0.5778 - head_3_loss: 1.1304 - head_4_accuracy: 0.5616 - head_4_loss: 1.1332 - head_5_accuracy: 0.5813 - head_5_loss: 1.1325 - head_6_accuracy: 0.5795 - head_6_loss: 1.1652 - head_7_accuracy: 0.5751 - head_7_loss: 1.1176 - loss: 8.0973 - val_head_1_accuracy: 0.7852 - val_head_1_loss: 0.6328 - val_head_2_accuracy: 0.7545 - val_head_2_loss: 0.6566 - val_head_3_accuracy: 0.7638 - val_head_3_loss: 0.6682 - val_head_4_accuracy: 0.7434 - val_head_4_loss: 0.6872 - val_head_5_accuracy: 0.7585 - val_head_5_loss: 0.6712 - val_head_6_accuracy: 0.7835 - val_head_6_loss: 0.6709 - val_head_7_accuracy: 0.7763 - val_head_7_loss: 0.6493 - val_loss: 4.6360 - learning_rate: 6.0000e-04\n", "\n", "Epoch 2: LearningRateScheduler setting learning rate to 0.0005998489878878364.\n", "Epoch 2/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 152ms/step - head_1_accuracy: 0.7431 - head_1_loss: 0.7198 - head_2_accuracy: 0.7346 - head_2_loss: 0.7356 - head_3_accuracy: 0.7416 - head_3_loss: 0.7183 - head_4_accuracy: 0.7331 - head_4_loss: 0.7462 - head_5_accuracy: 0.7472 - head_5_loss: 0.7158 - head_6_accuracy: 0.7395 - head_6_loss: 0.7345 - head_7_accuracy: 0.7442 - head_7_loss: 0.7149 - loss: 5.0851\n", "Epoch 2: val_head_1_accuracy improved from 0.78515 to 0.80951, saving model to /content/drive/My Drive/Classification/multicp/models/ViT_UNet_MultiHead_best.keras\n", "\n", "Epoch 2: finished saving model to /content/drive/My Drive/Classification/multicp/models/ViT_UNet_MultiHead_best.keras\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m18s\u001b[0m 180ms/step - head_1_accuracy: 0.7597 - head_1_loss: 0.6723 - head_2_accuracy: 0.7548 - head_2_loss: 0.6814 - head_3_accuracy: 0.7596 - head_3_loss: 0.6736 - head_4_accuracy: 0.7520 - head_4_loss: 0.6872 - head_5_accuracy: 0.7651 - head_5_loss: 0.6726 - head_6_accuracy: 0.7588 - head_6_loss: 0.6839 - head_7_accuracy: 0.7593 - head_7_loss: 0.6711 - loss: 4.7866 - val_head_1_accuracy: 0.8095 - val_head_1_loss: 0.5535 - val_head_2_accuracy: 0.8137 - val_head_2_loss: 0.5648 - val_head_3_accuracy: 0.8067 - val_head_3_loss: 0.5594 - val_head_4_accuracy: 0.8081 - val_head_4_loss: 0.5569 - val_head_5_accuracy: 0.8039 - val_head_5_loss: 0.5610 - val_head_6_accuracy: 0.8084 - val_head_6_loss: 0.5555 - val_head_7_accuracy: 0.7981 - val_head_7_loss: 0.5724 - val_loss: 3.9178 - learning_rate: 5.9985e-04\n", "\n", "Epoch 3: LearningRateScheduler setting learning rate to 0.0005993961036077416.\n", "Epoch 3/100\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 165ms/step - head_1_accuracy: 0.8012 - head_1_loss: 0.5649 - head_2_accuracy: 0.8051 - head_2_loss: 0.5658 - head_3_accuracy: 0.8046 - head_3_loss: 0.5615 - head_4_accuracy: 0.7989 - head_4_loss: 0.5650 - head_5_accuracy: 0.8101 - head_5_loss: 0.5537 - head_6_accuracy: 0.8064 - head_6_loss: 0.5612 - head_7_accuracy: 0.8021 - head_7_loss: 0.5592 - loss: 3.9317\n", "Epoch 3: val_head_1_accuracy improved from 0.80951 to 0.85684, saving model to /content/drive/My Drive/Classification/multicp/models/ViT_UNet_MultiHead_best.keras\n", "\n", "Epoch 3: finished saving model to /content/drive/My Drive/Classification/multicp/models/ViT_UNet_MultiHead_best.keras\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 214ms/step - head_1_accuracy: 0.8186 - head_1_loss: 0.5146 - head_2_accuracy: 0.8201 - head_2_loss: 0.5203 - head_3_accuracy: 0.8240 - head_3_loss: 0.5090 - head_4_accuracy: 0.8164 - head_4_loss: 0.5198 - head_5_accuracy: 0.8256 - head_5_loss: 0.5105 - head_6_accuracy: 0.8228 - head_6_loss: 0.5117 - head_7_accuracy: 0.8209 - head_7_loss: 0.5125 - loss: 3.6336 - val_head_1_accuracy: 0.8568 - val_head_1_loss: 0.3979 - val_head_2_accuracy: 0.8550 - val_head_2_loss: 0.4032 - val_head_3_accuracy: 0.8561 - val_head_3_loss: 0.4028 - val_head_4_accuracy: 0.8582 - val_head_4_loss: 0.3957 - val_head_5_accuracy: 0.8561 - val_head_5_loss: 0.4067 - val_head_6_accuracy: 0.8603 - val_head_6_loss: 0.3961 - val_head_7_accuracy: 0.8613 - val_head_7_loss: 0.3906 - val_loss: 2.7889 - learning_rate: 5.9940e-04\n", "\n", "Epoch 4: LearningRateScheduler setting learning rate to 0.0005986418031757967.\n", "Epoch 4/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 166ms/step - head_1_accuracy: 0.8529 - head_1_loss: 0.4329 - head_2_accuracy: 0.8508 - head_2_loss: 0.4387 - head_3_accuracy: 0.8520 - head_3_loss: 0.4329 - head_4_accuracy: 0.8504 - head_4_loss: 0.4411 - head_5_accuracy: 0.8539 - head_5_loss: 0.4279 - head_6_accuracy: 0.8508 - head_6_loss: 0.4354 - head_7_accuracy: 0.8535 - head_7_loss: 0.4392 - loss: 3.0483\n", "Epoch 4: val_head_1_accuracy improved from 0.85684 to 0.88353, saving model to /content/drive/My Drive/Classification/multicp/models/ViT_UNet_MultiHead_best.keras\n", "\n", "Epoch 4: finished saving model to /content/drive/My Drive/Classification/multicp/models/ViT_UNet_MultiHead_best.keras\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 216ms/step - head_1_accuracy: 0.8630 - head_1_loss: 0.4055 - head_2_accuracy: 0.8616 - head_2_loss: 0.4087 - head_3_accuracy: 0.8632 - head_3_loss: 0.4030 - head_4_accuracy: 0.8607 - head_4_loss: 0.4107 - head_5_accuracy: 0.8644 - head_5_loss: 0.4012 - head_6_accuracy: 0.8620 - head_6_loss: 0.4062 - head_7_accuracy: 0.8633 - head_7_loss: 0.4079 - loss: 2.8712 - val_head_1_accuracy: 0.8835 - val_head_1_loss: 0.3479 - val_head_2_accuracy: 0.8907 - val_head_2_loss: 0.3414 - val_head_3_accuracy: 0.8968 - val_head_3_loss: 0.3279 - val_head_4_accuracy: 0.8912 - val_head_4_loss: 0.3337 - val_head_5_accuracy: 0.8898 - val_head_5_loss: 0.3377 - val_head_6_accuracy: 0.8942 - val_head_6_loss: 0.3380 - val_head_7_accuracy: 0.8947 - val_head_7_loss: 0.3458 - val_loss: 2.3735 - learning_rate: 5.9864e-04\n", "\n", "Epoch 5: LearningRateScheduler setting learning rate to 0.000597586846108597.\n", "Epoch 5/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 161ms/step - head_1_accuracy: 0.8795 - head_1_loss: 0.3535 - head_2_accuracy: 0.8781 - head_2_loss: 0.3602 - head_3_accuracy: 0.8802 - head_3_loss: 0.3510 - head_4_accuracy: 0.8799 - head_4_loss: 0.3568 - head_5_accuracy: 0.8830 - head_5_loss: 0.3478 - head_6_accuracy: 0.8778 - head_6_loss: 0.3581 - head_7_accuracy: 0.8780 - head_7_loss: 0.3534 - loss: 2.4809\n", "Epoch 5: val_head_1_accuracy improved from 0.88353 to 0.92088, saving model to /content/drive/My Drive/Classification/multicp/models/ViT_UNet_MultiHead_best.keras\n", "\n", "Epoch 5: finished saving model to /content/drive/My Drive/Classification/multicp/models/ViT_UNet_MultiHead_best.keras\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m20s\u001b[0m 193ms/step - head_1_accuracy: 0.8882 - head_1_loss: 0.3354 - head_2_accuracy: 0.8875 - head_2_loss: 0.3374 - head_3_accuracy: 0.8877 - head_3_loss: 0.3315 - head_4_accuracy: 0.8875 - head_4_loss: 0.3373 - head_5_accuracy: 0.8895 - head_5_loss: 0.3318 - head_6_accuracy: 0.8859 - head_6_loss: 0.3383 - head_7_accuracy: 0.8868 - head_7_loss: 0.3343 - loss: 2.3691 - val_head_1_accuracy: 0.9209 - val_head_1_loss: 0.2438 - val_head_2_accuracy: 0.9213 - val_head_2_loss: 0.2444 - val_head_3_accuracy: 0.9186 - val_head_3_loss: 0.2426 - val_head_4_accuracy: 0.9165 - val_head_4_loss: 0.2511 - val_head_5_accuracy: 0.9179 - val_head_5_loss: 0.2440 - val_head_6_accuracy: 0.9188 - val_head_6_loss: 0.2438 - val_head_7_accuracy: 0.9186 - val_head_7_loss: 0.2450 - val_loss: 1.7104 - learning_rate: 5.9759e-04\n", "\n", "Epoch 6: LearningRateScheduler setting learning rate to 0.0005962322946584844.\n", "Epoch 6/100\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 168ms/step - head_1_accuracy: 0.8844 - head_1_loss: 0.3460 - head_2_accuracy: 0.8837 - head_2_loss: 0.3529 - head_3_accuracy: 0.8804 - head_3_loss: 0.3507 - head_4_accuracy: 0.8789 - head_4_loss: 0.3533 - head_5_accuracy: 0.8817 - head_5_loss: 0.3457 - head_6_accuracy: 0.8830 - head_6_loss: 0.3529 - head_7_accuracy: 0.8819 - head_7_loss: 0.3541 - loss: 2.4559\n", "Epoch 6: val_head_1_accuracy did not improve from 0.92088\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m19s\u001b[0m 182ms/step - head_1_accuracy: 0.8887 - head_1_loss: 0.3304 - head_2_accuracy: 0.8882 - head_2_loss: 0.3344 - head_3_accuracy: 0.8868 - head_3_loss: 0.3306 - head_4_accuracy: 0.8855 - head_4_loss: 0.3363 - head_5_accuracy: 0.8865 - head_5_loss: 0.3282 - head_6_accuracy: 0.8876 - head_6_loss: 0.3344 - head_7_accuracy: 0.8879 - head_7_loss: 0.3339 - loss: 2.3511 - val_head_1_accuracy: 0.9135 - val_head_1_loss: 0.2414 - val_head_2_accuracy: 0.9102 - val_head_2_loss: 0.2466 - val_head_3_accuracy: 0.9146 - val_head_3_loss: 0.2411 - val_head_4_accuracy: 0.9139 - val_head_4_loss: 0.2438 - val_head_5_accuracy: 0.9128 - val_head_5_loss: 0.2439 - val_head_6_accuracy: 0.9132 - val_head_6_loss: 0.2447 - val_head_7_accuracy: 0.9111 - val_head_7_loss: 0.2497 - val_loss: 1.7100 - learning_rate: 5.9623e-04\n", "\n", "Epoch 7: LearningRateScheduler setting learning rate to 0.0005945795127439488.\n", "Epoch 7/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 165ms/step - head_1_accuracy: 0.9030 - head_1_loss: 0.2888 - head_2_accuracy: 0.9035 - head_2_loss: 0.2935 - head_3_accuracy: 0.9060 - head_3_loss: 0.2887 - head_4_accuracy: 0.9063 - head_4_loss: 0.2946 - head_5_accuracy: 0.9047 - head_5_loss: 0.2916 - head_6_accuracy: 0.9058 - head_6_loss: 0.2898 - head_7_accuracy: 0.9027 - head_7_loss: 0.2933 - loss: 2.0404\n", "Epoch 7: val_head_1_accuracy improved from 0.92088 to 0.92135, saving model to /content/drive/My Drive/Classification/multicp/models/ViT_UNet_MultiHead_best.keras\n", "\n", "Epoch 7: finished saving model to /content/drive/My Drive/Classification/multicp/models/ViT_UNet_MultiHead_best.keras\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m20s\u001b[0m 191ms/step - head_1_accuracy: 0.9038 - head_1_loss: 0.2859 - head_2_accuracy: 0.9032 - head_2_loss: 0.2904 - head_3_accuracy: 0.9063 - head_3_loss: 0.2864 - head_4_accuracy: 0.9059 - head_4_loss: 0.2917 - head_5_accuracy: 0.9053 - head_5_loss: 0.2873 - head_6_accuracy: 0.9056 - head_6_loss: 0.2888 - head_7_accuracy: 0.9035 - head_7_loss: 0.2896 - loss: 2.0398 - val_head_1_accuracy: 0.9213 - val_head_1_loss: 0.2241 - val_head_2_accuracy: 0.9162 - val_head_2_loss: 0.2311 - val_head_3_accuracy: 0.9197 - val_head_3_loss: 0.2225 - val_head_4_accuracy: 0.9186 - val_head_4_loss: 0.2284 - val_head_5_accuracy: 0.9239 - val_head_5_loss: 0.2222 - val_head_6_accuracy: 0.9186 - val_head_6_loss: 0.2283 - val_head_7_accuracy: 0.9220 - val_head_7_loss: 0.2194 - val_loss: 1.5734 - learning_rate: 5.9458e-04\n", "\n", "Epoch 8: LearningRateScheduler setting learning rate to 0.0005926301645762779.\n", "Epoch 8/100\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 170ms/step - head_1_accuracy: 0.9127 - head_1_loss: 0.2624 - head_2_accuracy: 0.9114 - head_2_loss: 0.2659 - head_3_accuracy: 0.9126 - head_3_loss: 0.2614 - head_4_accuracy: 0.9120 - head_4_loss: 0.2674 - head_5_accuracy: 0.9123 - head_5_loss: 0.2617 - head_6_accuracy: 0.9117 - head_6_loss: 0.2664 - head_7_accuracy: 0.9120 - head_7_loss: 0.2606 - loss: 1.8459\n", "Epoch 8: val_head_1_accuracy improved from 0.92135 to 0.92343, saving model to /content/drive/My Drive/Classification/multicp/models/ViT_UNet_MultiHead_best.keras\n", "\n", "Epoch 8: finished saving model to /content/drive/My Drive/Classification/multicp/models/ViT_UNet_MultiHead_best.keras\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 214ms/step - head_1_accuracy: 0.9151 - head_1_loss: 0.2601 - head_2_accuracy: 0.9124 - head_2_loss: 0.2650 - head_3_accuracy: 0.9146 - head_3_loss: 0.2602 - head_4_accuracy: 0.9135 - head_4_loss: 0.2649 - head_5_accuracy: 0.9144 - head_5_loss: 0.2593 - head_6_accuracy: 0.9126 - head_6_loss: 0.2631 - head_7_accuracy: 0.9151 - head_7_loss: 0.2586 - loss: 1.8491 - val_head_1_accuracy: 0.9234 - val_head_1_loss: 0.2318 - val_head_2_accuracy: 0.9237 - val_head_2_loss: 0.2350 - val_head_3_accuracy: 0.9227 - val_head_3_loss: 0.2344 - val_head_4_accuracy: 0.9248 - val_head_4_loss: 0.2353 - val_head_5_accuracy: 0.9262 - val_head_5_loss: 0.2301 - val_head_6_accuracy: 0.9227 - val_head_6_loss: 0.2364 - val_head_7_accuracy: 0.9239 - val_head_7_loss: 0.2363 - val_loss: 1.6347 - learning_rate: 5.9263e-04\n", "\n", "Epoch 9: LearningRateScheduler setting learning rate to 0.0005903862129838371.\n", "Epoch 9/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 161ms/step - head_1_accuracy: 0.9184 - head_1_loss: 0.2524 - head_2_accuracy: 0.9155 - head_2_loss: 0.2535 - head_3_accuracy: 0.9172 - head_3_loss: 0.2489 - head_4_accuracy: 0.9190 - head_4_loss: 0.2554 - head_5_accuracy: 0.9177 - head_5_loss: 0.2485 - head_6_accuracy: 0.9176 - head_6_loss: 0.2548 - head_7_accuracy: 0.9148 - head_7_loss: 0.2516 - loss: 1.7650\n", "Epoch 9: val_head_1_accuracy did not improve from 0.92343\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m36s\u001b[0m 168ms/step - head_1_accuracy: 0.9145 - head_1_loss: 0.2597 - head_2_accuracy: 0.9131 - head_2_loss: 0.2646 - head_3_accuracy: 0.9141 - head_3_loss: 0.2606 - head_4_accuracy: 0.9139 - head_4_loss: 0.2646 - head_5_accuracy: 0.9141 - head_5_loss: 0.2579 - head_6_accuracy: 0.9133 - head_6_loss: 0.2642 - head_7_accuracy: 0.9127 - head_7_loss: 0.2603 - loss: 1.8499 - val_head_1_accuracy: 0.9097 - val_head_1_loss: 0.2688 - val_head_2_accuracy: 0.9093 - val_head_2_loss: 0.2685 - val_head_3_accuracy: 0.9097 - val_head_3_loss: 0.2713 - val_head_4_accuracy: 0.9070 - val_head_4_loss: 0.2771 - val_head_5_accuracy: 0.9084 - val_head_5_loss: 0.2710 - val_head_6_accuracy: 0.9088 - val_head_6_loss: 0.2691 - val_head_7_accuracy: 0.9079 - val_head_7_loss: 0.2752 - val_loss: 1.8911 - learning_rate: 5.9039e-04\n", "\n", "Epoch 10: LearningRateScheduler setting learning rate to 0.0005878499174356684.\n", "Epoch 10/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 162ms/step - head_1_accuracy: 0.9148 - head_1_loss: 0.2662 - head_2_accuracy: 0.9134 - head_2_loss: 0.2701 - head_3_accuracy: 0.9109 - head_3_loss: 0.2629 - head_4_accuracy: 0.9136 - head_4_loss: 0.2714 - head_5_accuracy: 0.9133 - head_5_loss: 0.2667 - head_6_accuracy: 0.9136 - head_6_loss: 0.2692 - head_7_accuracy: 0.9126 - head_7_loss: 0.2678 - loss: 1.8745\n", "Epoch 10: val_head_1_accuracy improved from 0.92343 to 0.93828, saving model to /content/drive/My Drive/Classification/multicp/models/ViT_UNet_MultiHead_best.keras\n", "\n", "Epoch 10: finished saving model to /content/drive/My Drive/Classification/multicp/models/ViT_UNet_MultiHead_best.keras\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m19s\u001b[0m 191ms/step - head_1_accuracy: 0.9154 - head_1_loss: 0.2598 - head_2_accuracy: 0.9142 - head_2_loss: 0.2637 - head_3_accuracy: 0.9123 - head_3_loss: 0.2603 - head_4_accuracy: 0.9140 - head_4_loss: 0.2640 - head_5_accuracy: 0.9156 - head_5_loss: 0.2602 - head_6_accuracy: 0.9132 - head_6_loss: 0.2633 - head_7_accuracy: 0.9143 - head_7_loss: 0.2611 - loss: 1.8505 - val_head_1_accuracy: 0.9383 - val_head_1_loss: 0.2087 - val_head_2_accuracy: 0.9350 - val_head_2_loss: 0.2070 - val_head_3_accuracy: 0.9367 - val_head_3_loss: 0.2078 - val_head_4_accuracy: 0.9341 - val_head_4_loss: 0.2113 - val_head_5_accuracy: 0.9355 - val_head_5_loss: 0.2111 - val_head_6_accuracy: 0.9371 - val_head_6_loss: 0.2084 - val_head_7_accuracy: 0.9369 - val_head_7_loss: 0.2091 - val_loss: 1.4603 - learning_rate: 5.8785e-04\n", "\n", "Epoch 11: LearningRateScheduler setting learning rate to 0.0005850238317663965.\n", "Epoch 11/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 164ms/step - head_1_accuracy: 0.9322 - head_1_loss: 0.2105 - head_2_accuracy: 0.9348 - head_2_loss: 0.2086 - head_3_accuracy: 0.9335 - head_3_loss: 0.2080 - head_4_accuracy: 0.9316 - head_4_loss: 0.2146 - head_5_accuracy: 0.9337 - head_5_loss: 0.2109 - head_6_accuracy: 0.9331 - head_6_loss: 0.2071 - head_7_accuracy: 0.9332 - head_7_loss: 0.2087 - loss: 1.4683\n", "Epoch 11: val_head_1_accuracy did not improve from 0.93828\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m18s\u001b[0m 177ms/step - head_1_accuracy: 0.9292 - head_1_loss: 0.2156 - head_2_accuracy: 0.9300 - head_2_loss: 0.2136 - head_3_accuracy: 0.9296 - head_3_loss: 0.2130 - head_4_accuracy: 0.9274 - head_4_loss: 0.2187 - head_5_accuracy: 0.9292 - head_5_loss: 0.2155 - head_6_accuracy: 0.9300 - head_6_loss: 0.2141 - head_7_accuracy: 0.9286 - head_7_loss: 0.2140 - loss: 1.5194 - val_head_1_accuracy: 0.9246 - val_head_1_loss: 0.2272 - val_head_2_accuracy: 0.9239 - val_head_2_loss: 0.2240 - val_head_3_accuracy: 0.9244 - val_head_3_loss: 0.2306 - val_head_4_accuracy: 0.9255 - val_head_4_loss: 0.2301 - val_head_5_accuracy: 0.9269 - val_head_5_loss: 0.2229 - val_head_6_accuracy: 0.9244 - val_head_6_loss: 0.2257 - val_head_7_accuracy: 0.9253 - val_head_7_loss: 0.2251 - val_loss: 1.5819 - learning_rate: 5.8502e-04\n", "\n", "Epoch 12: LearningRateScheduler setting learning rate to 0.0005819108016047332.\n", "Epoch 12/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 165ms/step - head_1_accuracy: 0.9120 - head_1_loss: 0.2781 - head_2_accuracy: 0.9120 - head_2_loss: 0.2786 - head_3_accuracy: 0.9107 - head_3_loss: 0.2773 - head_4_accuracy: 0.9101 - head_4_loss: 0.2807 - head_5_accuracy: 0.9130 - head_5_loss: 0.2735 - head_6_accuracy: 0.9114 - head_6_loss: 0.2786 - head_7_accuracy: 0.9133 - head_7_loss: 0.2760 - loss: 1.9428\n", "Epoch 12: val_head_1_accuracy did not improve from 0.93828\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m18s\u001b[0m 174ms/step - head_1_accuracy: 0.9116 - head_1_loss: 0.2724 - head_2_accuracy: 0.9112 - head_2_loss: 0.2732 - head_3_accuracy: 0.9119 - head_3_loss: 0.2725 - head_4_accuracy: 0.9102 - head_4_loss: 0.2778 - head_5_accuracy: 0.9120 - head_5_loss: 0.2726 - head_6_accuracy: 0.9117 - head_6_loss: 0.2728 - head_7_accuracy: 0.9130 - head_7_loss: 0.2712 - loss: 1.9312 - val_head_1_accuracy: 0.8970 - val_head_1_loss: 0.3247 - val_head_2_accuracy: 0.8981 - val_head_2_loss: 0.3138 - val_head_3_accuracy: 0.8970 - val_head_3_loss: 0.3234 - val_head_4_accuracy: 0.8942 - val_head_4_loss: 0.3285 - val_head_5_accuracy: 0.8951 - val_head_5_loss: 0.3212 - val_head_6_accuracy: 0.8972 - val_head_6_loss: 0.3280 - val_head_7_accuracy: 0.8961 - val_head_7_loss: 0.3260 - val_loss: 2.2551 - learning_rate: 5.8191e-04\n", "\n", "Epoch 13: LearningRateScheduler setting learning rate to 0.0005785139615081709.\n", "Epoch 13/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 166ms/step - head_1_accuracy: 0.8946 - head_1_loss: 0.3178 - head_2_accuracy: 0.8963 - head_2_loss: 0.3122 - head_3_accuracy: 0.8945 - head_3_loss: 0.3132 - head_4_accuracy: 0.8977 - head_4_loss: 0.3159 - head_5_accuracy: 0.8970 - head_5_loss: 0.3124 - head_6_accuracy: 0.8960 - head_6_loss: 0.3150 - head_7_accuracy: 0.8964 - head_7_loss: 0.3152 - loss: 2.2017\n", "Epoch 13: val_head_1_accuracy did not improve from 0.93828\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m18s\u001b[0m 175ms/step - head_1_accuracy: 0.8967 - head_1_loss: 0.3134 - head_2_accuracy: 0.8967 - head_2_loss: 0.3111 - head_3_accuracy: 0.8964 - head_3_loss: 0.3099 - head_4_accuracy: 0.8977 - head_4_loss: 0.3133 - head_5_accuracy: 0.8966 - head_5_loss: 0.3098 - head_6_accuracy: 0.8974 - head_6_loss: 0.3123 - head_7_accuracy: 0.8974 - head_7_loss: 0.3128 - loss: 2.2040 - val_head_1_accuracy: 0.9244 - val_head_1_loss: 0.2306 - val_head_2_accuracy: 0.9251 - val_head_2_loss: 0.2244 - val_head_3_accuracy: 0.9260 - val_head_3_loss: 0.2257 - val_head_4_accuracy: 0.9253 - val_head_4_loss: 0.2295 - val_head_5_accuracy: 0.9255 - val_head_5_loss: 0.2287 - val_head_6_accuracy: 0.9258 - val_head_6_loss: 0.2279 - val_head_7_accuracy: 0.9255 - val_head_7_loss: 0.2293 - val_loss: 1.5976 - learning_rate: 5.7851e-04\n", "\n", "Epoch 14: LearningRateScheduler setting learning rate to 0.0005748367318067492.\n", "Epoch 14/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 168ms/step - head_1_accuracy: 0.9013 - head_1_loss: 0.3146 - head_2_accuracy: 0.9003 - head_2_loss: 0.3123 - head_3_accuracy: 0.8993 - head_3_loss: 0.3132 - head_4_accuracy: 0.9023 - head_4_loss: 0.3121 - head_5_accuracy: 0.9001 - head_5_loss: 0.3124 - head_6_accuracy: 0.8997 - head_6_loss: 0.3142 - head_7_accuracy: 0.8993 - head_7_loss: 0.3123 - loss: 2.1910\n", "Epoch 14: val_head_1_accuracy did not improve from 0.93828\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m18s\u001b[0m 176ms/step - head_1_accuracy: 0.9133 - head_1_loss: 0.2731 - head_2_accuracy: 0.9117 - head_2_loss: 0.2715 - head_3_accuracy: 0.9107 - head_3_loss: 0.2727 - head_4_accuracy: 0.9134 - head_4_loss: 0.2728 - head_5_accuracy: 0.9124 - head_5_loss: 0.2712 - head_6_accuracy: 0.9108 - head_6_loss: 0.2714 - head_7_accuracy: 0.9122 - head_7_loss: 0.2700 - loss: 1.9213 - val_head_1_accuracy: 0.9297 - val_head_1_loss: 0.2162 - val_head_2_accuracy: 0.9290 - val_head_2_loss: 0.2220 - val_head_3_accuracy: 0.9283 - val_head_3_loss: 0.2173 - val_head_4_accuracy: 0.9309 - val_head_4_loss: 0.2177 - val_head_5_accuracy: 0.9288 - val_head_5_loss: 0.2141 - val_head_6_accuracy: 0.9302 - val_head_6_loss: 0.2172 - val_head_7_accuracy: 0.9309 - val_head_7_loss: 0.2138 - val_loss: 1.5122 - learning_rate: 5.7484e-04\n", "\n", "Epoch 15: LearningRateScheduler setting learning rate to 0.0005708828151590721.\n", "Epoch 15/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 168ms/step - head_1_accuracy: 0.9233 - head_1_loss: 0.2301 - head_2_accuracy: 0.9239 - head_2_loss: 0.2309 - head_3_accuracy: 0.9209 - head_3_loss: 0.2299 - head_4_accuracy: 0.9192 - head_4_loss: 0.2354 - head_5_accuracy: 0.9224 - head_5_loss: 0.2304 - head_6_accuracy: 0.9208 - head_6_loss: 0.2347 - head_7_accuracy: 0.9221 - head_7_loss: 0.2317 - loss: 1.6231\n", "Epoch 15: val_head_1_accuracy did not improve from 0.93828\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m18s\u001b[0m 178ms/step - head_1_accuracy: 0.9312 - head_1_loss: 0.2095 - head_2_accuracy: 0.9302 - head_2_loss: 0.2114 - head_3_accuracy: 0.9295 - head_3_loss: 0.2095 - head_4_accuracy: 0.9282 - head_4_loss: 0.2125 - head_5_accuracy: 0.9292 - head_5_loss: 0.2101 - head_6_accuracy: 0.9284 - head_6_loss: 0.2123 - head_7_accuracy: 0.9287 - head_7_loss: 0.2119 - loss: 1.4917 - val_head_1_accuracy: 0.9093 - val_head_1_loss: 0.2735 - val_head_2_accuracy: 0.9086 - val_head_2_loss: 0.2665 - val_head_3_accuracy: 0.9093 - val_head_3_loss: 0.2655 - val_head_4_accuracy: 0.9090 - val_head_4_loss: 0.2712 - val_head_5_accuracy: 0.9086 - val_head_5_loss: 0.2714 - val_head_6_accuracy: 0.9086 - val_head_6_loss: 0.2672 - val_head_7_accuracy: 0.9084 - val_head_7_loss: 0.2709 - val_loss: 1.8903 - learning_rate: 5.7088e-04\n", "\n", "Epoch 16: LearningRateScheduler setting learning rate to 0.0005666561928240443.\n", "Epoch 16/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 169ms/step - head_1_accuracy: 0.9171 - head_1_loss: 0.2630 - head_2_accuracy: 0.9172 - head_2_loss: 0.2625 - head_3_accuracy: 0.9189 - head_3_loss: 0.2627 - head_4_accuracy: 0.9186 - head_4_loss: 0.2634 - head_5_accuracy: 0.9194 - head_5_loss: 0.2618 - head_6_accuracy: 0.9205 - head_6_loss: 0.2623 - head_7_accuracy: 0.9196 - head_7_loss: 0.2642 - loss: 1.8399\n", "Epoch 16: val_head_1_accuracy did not improve from 0.93828\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m19s\u001b[0m 181ms/step - head_1_accuracy: 0.8981 - head_1_loss: 0.3211 - head_2_accuracy: 0.8974 - head_2_loss: 0.3224 - head_3_accuracy: 0.8977 - head_3_loss: 0.3236 - head_4_accuracy: 0.8982 - head_4_loss: 0.3248 - head_5_accuracy: 0.8976 - head_5_loss: 0.3218 - head_6_accuracy: 0.8978 - head_6_loss: 0.3233 - head_7_accuracy: 0.8968 - head_7_loss: 0.3240 - loss: 2.2832 - val_head_1_accuracy: 0.8898 - val_head_1_loss: 0.2992 - val_head_2_accuracy: 0.8916 - val_head_2_loss: 0.2960 - val_head_3_accuracy: 0.8882 - val_head_3_loss: 0.3024 - val_head_4_accuracy: 0.8903 - val_head_4_loss: 0.3000 - val_head_5_accuracy: 0.8900 - val_head_5_loss: 0.2985 - val_head_6_accuracy: 0.8884 - val_head_6_loss: 0.3037 - val_head_7_accuracy: 0.8900 - val_head_7_loss: 0.3011 - val_loss: 2.0989 - learning_rate: 5.6666e-04\n", "\n", "Epoch 17: LearningRateScheduler setting learning rate to 0.000562161120652082.\n", "Epoch 17/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 168ms/step - head_1_accuracy: 0.9011 - head_1_loss: 0.2965 - head_2_accuracy: 0.9007 - head_2_loss: 0.2967 - head_3_accuracy: 0.8983 - head_3_loss: 0.2991 - head_4_accuracy: 0.8993 - head_4_loss: 0.2985 - head_5_accuracy: 0.9002 - head_5_loss: 0.2974 - head_6_accuracy: 0.8995 - head_6_loss: 0.2982 - head_7_accuracy: 0.8999 - head_7_loss: 0.2964 - loss: 2.0827\n", "Epoch 17: val_head_1_accuracy did not improve from 0.93828\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m18s\u001b[0m 177ms/step - head_1_accuracy: 0.9086 - head_1_loss: 0.2777 - head_2_accuracy: 0.9099 - head_2_loss: 0.2763 - head_3_accuracy: 0.9079 - head_3_loss: 0.2766 - head_4_accuracy: 0.9073 - head_4_loss: 0.2782 - head_5_accuracy: 0.9088 - head_5_loss: 0.2759 - head_6_accuracy: 0.9083 - head_6_loss: 0.2767 - head_7_accuracy: 0.9090 - head_7_loss: 0.2757 - loss: 1.9560 - val_head_1_accuracy: 0.9116 - val_head_1_loss: 0.2795 - val_head_2_accuracy: 0.9104 - val_head_2_loss: 0.2774 - val_head_3_accuracy: 0.9116 - val_head_3_loss: 0.2761 - val_head_4_accuracy: 0.9100 - val_head_4_loss: 0.2779 - val_head_5_accuracy: 0.9121 - val_head_5_loss: 0.2764 - val_head_6_accuracy: 0.9114 - val_head_6_loss: 0.2739 - val_head_7_accuracy: 0.9125 - val_head_7_loss: 0.2763 - val_loss: 1.9333 - learning_rate: 5.6216e-04\n", "\n", "Epoch 18: LearningRateScheduler setting learning rate to 0.0005574021247998313.\n", "Epoch 18/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 168ms/step - head_1_accuracy: 0.9042 - head_1_loss: 0.2870 - head_2_accuracy: 0.9035 - head_2_loss: 0.2911 - head_3_accuracy: 0.9018 - head_3_loss: 0.2882 - head_4_accuracy: 0.9043 - head_4_loss: 0.2921 - head_5_accuracy: 0.9050 - head_5_loss: 0.2887 - head_6_accuracy: 0.9026 - head_6_loss: 0.2902 - head_7_accuracy: 0.9020 - head_7_loss: 0.2895 - loss: 2.0268\n", "Epoch 18: val_head_1_accuracy did not improve from 0.93828\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m18s\u001b[0m 176ms/step - head_1_accuracy: 0.9070 - head_1_loss: 0.2781 - head_2_accuracy: 0.9066 - head_2_loss: 0.2806 - head_3_accuracy: 0.9066 - head_3_loss: 0.2777 - head_4_accuracy: 0.9077 - head_4_loss: 0.2819 - head_5_accuracy: 0.9083 - head_5_loss: 0.2778 - head_6_accuracy: 0.9079 - head_6_loss: 0.2787 - head_7_accuracy: 0.9061 - head_7_loss: 0.2787 - loss: 1.9727 - val_head_1_accuracy: 0.8958 - val_head_1_loss: 0.3177 - val_head_2_accuracy: 0.8972 - val_head_2_loss: 0.3111 - val_head_3_accuracy: 0.8970 - val_head_3_loss: 0.3131 - val_head_4_accuracy: 0.8986 - val_head_4_loss: 0.3173 - val_head_5_accuracy: 0.8954 - val_head_5_loss: 0.3092 - val_head_6_accuracy: 0.8981 - val_head_6_loss: 0.3102 - val_head_7_accuracy: 0.8956 - val_head_7_loss: 0.3140 - val_loss: 2.1852 - learning_rate: 5.5740e-04\n", "\n", "Epoch 19: LearningRateScheduler setting learning rate to 0.0005523839971727127.\n", "Epoch 19/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 167ms/step - head_1_accuracy: 0.8842 - head_1_loss: 0.3661 - head_2_accuracy: 0.8864 - head_2_loss: 0.3637 - head_3_accuracy: 0.8843 - head_3_loss: 0.3628 - head_4_accuracy: 0.8849 - head_4_loss: 0.3688 - head_5_accuracy: 0.8867 - head_5_loss: 0.3631 - head_6_accuracy: 0.8839 - head_6_loss: 0.3677 - head_7_accuracy: 0.8830 - head_7_loss: 0.3689 - loss: 2.5610\n", "Epoch 19: val_head_1_accuracy did not improve from 0.93828\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m18s\u001b[0m 175ms/step - head_1_accuracy: 0.8783 - head_1_loss: 0.3794 - head_2_accuracy: 0.8781 - head_2_loss: 0.3775 - head_3_accuracy: 0.8784 - head_3_loss: 0.3757 - head_4_accuracy: 0.8793 - head_4_loss: 0.3823 - head_5_accuracy: 0.8800 - head_5_loss: 0.3766 - head_6_accuracy: 0.8775 - head_6_loss: 0.3793 - head_7_accuracy: 0.8773 - head_7_loss: 0.3799 - loss: 2.6767 - val_head_1_accuracy: 0.9016 - val_head_1_loss: 0.2835 - val_head_2_accuracy: 0.9042 - val_head_2_loss: 0.2823 - val_head_3_accuracy: 0.9019 - val_head_3_loss: 0.2878 - val_head_4_accuracy: 0.9016 - val_head_4_loss: 0.2891 - val_head_5_accuracy: 0.9012 - val_head_5_loss: 0.2899 - val_head_6_accuracy: 0.8998 - val_head_6_loss: 0.2917 - val_head_7_accuracy: 0.9028 - val_head_7_loss: 0.2841 - val_loss: 2.0091 - learning_rate: 5.5238e-04\n", "\n", "Epoch 20: LearningRateScheduler setting learning rate to 0.0005471117905998783.\n", "Epoch 20/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 168ms/step - head_1_accuracy: 0.8929 - head_1_loss: 0.3355 - head_2_accuracy: 0.8939 - head_2_loss: 0.3304 - head_3_accuracy: 0.8923 - head_3_loss: 0.3344 - head_4_accuracy: 0.8913 - head_4_loss: 0.3359 - head_5_accuracy: 0.8906 - head_5_loss: 0.3328 - head_6_accuracy: 0.8883 - head_6_loss: 0.3370 - head_7_accuracy: 0.8908 - head_7_loss: 0.3289 - loss: 2.3349\n", "Epoch 20: val_head_1_accuracy did not improve from 0.93828\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m18s\u001b[0m 178ms/step - head_1_accuracy: 0.8999 - head_1_loss: 0.3073 - head_2_accuracy: 0.9007 - head_2_loss: 0.3065 - head_3_accuracy: 0.9001 - head_3_loss: 0.3078 - head_4_accuracy: 0.8990 - head_4_loss: 0.3091 - head_5_accuracy: 0.8989 - head_5_loss: 0.3063 - head_6_accuracy: 0.8977 - head_6_loss: 0.3074 - head_7_accuracy: 0.8988 - head_7_loss: 0.3048 - loss: 2.1703 - val_head_1_accuracy: 0.9381 - val_head_1_loss: 0.2049 - val_head_2_accuracy: 0.9378 - val_head_2_loss: 0.2045 - val_head_3_accuracy: 0.9364 - val_head_3_loss: 0.2046 - val_head_4_accuracy: 0.9383 - val_head_4_loss: 0.2041 - val_head_5_accuracy: 0.9369 - val_head_5_loss: 0.2036 - val_head_6_accuracy: 0.9371 - val_head_6_loss: 0.2026 - val_head_7_accuracy: 0.9374 - val_head_7_loss: 0.2025 - val_loss: 1.4243 - learning_rate: 5.4711e-04\n", "\n", "Epoch 21: LearningRateScheduler setting learning rate to 0.000541590813746441.\n", "Epoch 21/100\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 168ms/step - head_1_accuracy: 0.9021 - head_1_loss: 0.2987 - head_2_accuracy: 0.9057 - head_2_loss: 0.2970 - head_3_accuracy: 0.9036 - head_3_loss: 0.2975 - head_4_accuracy: 0.9041 - head_4_loss: 0.2980 - head_5_accuracy: 0.9032 - head_5_loss: 0.2976 - head_6_accuracy: 0.9026 - head_6_loss: 0.3003 - head_7_accuracy: 0.9040 - head_7_loss: 0.2971 - loss: 2.0863\n", "Epoch 21: val_head_1_accuracy did not improve from 0.93828\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m19s\u001b[0m 182ms/step - head_1_accuracy: 0.8769 - head_1_loss: 0.3776 - head_2_accuracy: 0.8777 - head_2_loss: 0.3770 - head_3_accuracy: 0.8769 - head_3_loss: 0.3780 - head_4_accuracy: 0.8773 - head_4_loss: 0.3765 - head_5_accuracy: 0.8769 - head_5_loss: 0.3767 - head_6_accuracy: 0.8761 - head_6_loss: 0.3776 - head_7_accuracy: 0.8760 - head_7_loss: 0.3771 - loss: 2.6610 - val_head_1_accuracy: 0.5722 - val_head_1_loss: 1.1764 - val_head_2_accuracy: 0.5710 - val_head_2_loss: 1.1573 - val_head_3_accuracy: 0.5650 - val_head_3_loss: 1.1589 - val_head_4_accuracy: 0.5682 - val_head_4_loss: 1.1395 - val_head_5_accuracy: 0.5677 - val_head_5_loss: 1.1774 - val_head_6_accuracy: 0.5691 - val_head_6_loss: 1.1904 - val_head_7_accuracy: 0.5680 - val_head_7_loss: 1.2062 - val_loss: 8.2118 - learning_rate: 5.4159e-04\n", "\n", "Epoch 22: LearningRateScheduler setting learning rate to 0.0005358266257680991.\n", "Epoch 22/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 167ms/step - head_1_accuracy: 0.6844 - head_1_loss: 0.9031 - head_2_accuracy: 0.6860 - head_2_loss: 0.8939 - head_3_accuracy: 0.6845 - head_3_loss: 0.8894 - head_4_accuracy: 0.6842 - head_4_loss: 0.8923 - head_5_accuracy: 0.6845 - head_5_loss: 0.8964 - head_6_accuracy: 0.6848 - head_6_loss: 0.8987 - head_7_accuracy: 0.6810 - head_7_loss: 0.8925 - loss: 6.2663\n", "Epoch 22: val_head_1_accuracy did not improve from 0.93828\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m18s\u001b[0m 175ms/step - head_1_accuracy: 0.7756 - head_1_loss: 0.6428 - head_2_accuracy: 0.7762 - head_2_loss: 0.6411 - head_3_accuracy: 0.7764 - head_3_loss: 0.6376 - head_4_accuracy: 0.7765 - head_4_loss: 0.6420 - head_5_accuracy: 0.7755 - head_5_loss: 0.6396 - head_6_accuracy: 0.7762 - head_6_loss: 0.6403 - head_7_accuracy: 0.7765 - head_7_loss: 0.6381 - loss: 4.5255 - val_head_1_accuracy: 0.9000 - val_head_1_loss: 0.3043 - val_head_2_accuracy: 0.8972 - val_head_2_loss: 0.3008 - val_head_3_accuracy: 0.8951 - val_head_3_loss: 0.3038 - val_head_4_accuracy: 0.8958 - val_head_4_loss: 0.3080 - val_head_5_accuracy: 0.8988 - val_head_5_loss: 0.3082 - val_head_6_accuracy: 0.8988 - val_head_6_loss: 0.3057 - val_head_7_accuracy: 0.8968 - val_head_7_loss: 0.3037 - val_loss: 2.1348 - learning_rate: 5.3583e-04\n", "\n", "Epoch 23: LearningRateScheduler setting learning rate to 0.0005298250307135374.\n", "Epoch 23/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 167ms/step - head_1_accuracy: 0.8762 - head_1_loss: 0.3772 - head_2_accuracy: 0.8773 - head_2_loss: 0.3778 - head_3_accuracy: 0.8793 - head_3_loss: 0.3746 - head_4_accuracy: 0.8774 - head_4_loss: 0.3764 - head_5_accuracy: 0.8766 - head_5_loss: 0.3742 - head_6_accuracy: 0.8750 - head_6_loss: 0.3787 - head_7_accuracy: 0.8762 - head_7_loss: 0.3760 - loss: 2.6350\n", "Epoch 23: val_head_1_accuracy did not improve from 0.93828\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m18s\u001b[0m 175ms/step - head_1_accuracy: 0.8851 - head_1_loss: 0.3483 - head_2_accuracy: 0.8860 - head_2_loss: 0.3492 - head_3_accuracy: 0.8868 - head_3_loss: 0.3469 - head_4_accuracy: 0.8860 - head_4_loss: 0.3472 - head_5_accuracy: 0.8861 - head_5_loss: 0.3443 - head_6_accuracy: 0.8846 - head_6_loss: 0.3468 - head_7_accuracy: 0.8850 - head_7_loss: 0.3464 - loss: 2.4528 - val_head_1_accuracy: 0.9035 - val_head_1_loss: 0.2952 - val_head_2_accuracy: 0.9039 - val_head_2_loss: 0.2937 - val_head_3_accuracy: 0.9023 - val_head_3_loss: 0.2921 - val_head_4_accuracy: 0.9028 - val_head_4_loss: 0.2934 - val_head_5_accuracy: 0.9039 - val_head_5_loss: 0.2938 - val_head_6_accuracy: 0.9030 - val_head_6_loss: 0.2936 - val_head_7_accuracy: 0.9035 - val_head_7_loss: 0.2916 - val_loss: 2.0539 - learning_rate: 5.2983e-04\n", "\n", "Epoch 24: LearningRateScheduler setting learning rate to 0.0005235920716802426.\n", "Epoch 24/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 167ms/step - head_1_accuracy: 0.8914 - head_1_loss: 0.3225 - head_2_accuracy: 0.8906 - head_2_loss: 0.3227 - head_3_accuracy: 0.8898 - head_3_loss: 0.3237 - head_4_accuracy: 0.8896 - head_4_loss: 0.3242 - head_5_accuracy: 0.8910 - head_5_loss: 0.3221 - head_6_accuracy: 0.8897 - head_6_loss: 0.3242 - head_7_accuracy: 0.8927 - head_7_loss: 0.3239 - loss: 2.2634\n", "Epoch 24: val_head_1_accuracy did not improve from 0.93828\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m18s\u001b[0m 175ms/step - head_1_accuracy: 0.8990 - head_1_loss: 0.2927 - head_2_accuracy: 0.8983 - head_2_loss: 0.2936 - head_3_accuracy: 0.8982 - head_3_loss: 0.2930 - head_4_accuracy: 0.8991 - head_4_loss: 0.2931 - head_5_accuracy: 0.8984 - head_5_loss: 0.2917 - head_6_accuracy: 0.8980 - head_6_loss: 0.2937 - head_7_accuracy: 0.9004 - head_7_loss: 0.2935 - loss: 2.0714 - val_head_1_accuracy: 0.9237 - val_head_1_loss: 0.2278 - val_head_2_accuracy: 0.9246 - val_head_2_loss: 0.2259 - val_head_3_accuracy: 0.9239 - val_head_3_loss: 0.2274 - val_head_4_accuracy: 0.9234 - val_head_4_loss: 0.2266 - val_head_5_accuracy: 0.9246 - val_head_5_loss: 0.2282 - val_head_6_accuracy: 0.9232 - val_head_6_loss: 0.2261 - val_head_7_accuracy: 0.9241 - val_head_7_loss: 0.2268 - val_loss: 1.5877 - learning_rate: 5.2359e-04\n", "\n", "Epoch 25: LearningRateScheduler setting learning rate to 0.0005171340247296157.\n", "Epoch 25/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 167ms/step - head_1_accuracy: 0.9089 - head_1_loss: 0.2713 - head_2_accuracy: 0.9092 - head_2_loss: 0.2720 - head_3_accuracy: 0.9098 - head_3_loss: 0.2698 - head_4_accuracy: 0.9083 - head_4_loss: 0.2723 - head_5_accuracy: 0.9073 - head_5_loss: 0.2706 - head_6_accuracy: 0.9063 - head_6_loss: 0.2725 - head_7_accuracy: 0.9087 - head_7_loss: 0.2697 - loss: 1.8982\n", "Epoch 25: val_head_1_accuracy did not improve from 0.93828\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m18s\u001b[0m 178ms/step - head_1_accuracy: 0.9146 - head_1_loss: 0.2513 - head_2_accuracy: 0.9152 - head_2_loss: 0.2525 - head_3_accuracy: 0.9156 - head_3_loss: 0.2499 - head_4_accuracy: 0.9148 - head_4_loss: 0.2537 - head_5_accuracy: 0.9144 - head_5_loss: 0.2515 - head_6_accuracy: 0.9137 - head_6_loss: 0.2527 - head_7_accuracy: 0.9148 - head_7_loss: 0.2504 - loss: 1.7793 - val_head_1_accuracy: 0.9211 - val_head_1_loss: 0.2481 - val_head_2_accuracy: 0.9218 - val_head_2_loss: 0.2429 - val_head_3_accuracy: 0.9216 - val_head_3_loss: 0.2413 - val_head_4_accuracy: 0.9218 - val_head_4_loss: 0.2400 - val_head_5_accuracy: 0.9220 - val_head_5_loss: 0.2418 - val_head_6_accuracy: 0.9220 - val_head_6_loss: 0.2430 - val_head_7_accuracy: 0.9220 - val_head_7_loss: 0.2473 - val_loss: 1.7019 - learning_rate: 5.1713e-04\n", "\n", "Epoch 26: LearningRateScheduler setting learning rate to 0.000510457392567511.\n", "Epoch 26/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 167ms/step - head_1_accuracy: 0.9189 - head_1_loss: 0.2502 - head_2_accuracy: 0.9157 - head_2_loss: 0.2503 - head_3_accuracy: 0.9174 - head_3_loss: 0.2490 - head_4_accuracy: 0.9190 - head_4_loss: 0.2491 - head_5_accuracy: 0.9189 - head_5_loss: 0.2482 - head_6_accuracy: 0.9178 - head_6_loss: 0.2499 - head_7_accuracy: 0.9187 - head_7_loss: 0.2485 - loss: 1.7453\n", "Epoch 26: val_head_1_accuracy did not improve from 0.93828\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m18s\u001b[0m 178ms/step - head_1_accuracy: 0.9223 - head_1_loss: 0.2308 - head_2_accuracy: 0.9220 - head_2_loss: 0.2325 - head_3_accuracy: 0.9223 - head_3_loss: 0.2308 - head_4_accuracy: 0.9236 - head_4_loss: 0.2314 - head_5_accuracy: 0.9239 - head_5_loss: 0.2300 - head_6_accuracy: 0.9234 - head_6_loss: 0.2319 - head_7_accuracy: 0.9233 - head_7_loss: 0.2310 - loss: 1.6342 - val_head_1_accuracy: 0.9139 - val_head_1_loss: 0.2626 - val_head_2_accuracy: 0.9146 - val_head_2_loss: 0.2589 - val_head_3_accuracy: 0.9151 - val_head_3_loss: 0.2600 - val_head_4_accuracy: 0.9151 - val_head_4_loss: 0.2583 - val_head_5_accuracy: 0.9148 - val_head_5_loss: 0.2563 - val_head_6_accuracy: 0.9137 - val_head_6_loss: 0.2596 - val_head_7_accuracy: 0.9139 - val_head_7_loss: 0.2605 - val_loss: 1.8100 - learning_rate: 5.1046e-04\n", "\n", "Epoch 27: LearningRateScheduler setting learning rate to 0.0005035688979965618.\n", "Epoch 27/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 167ms/step - head_1_accuracy: 0.9147 - head_1_loss: 0.2535 - head_2_accuracy: 0.9139 - head_2_loss: 0.2524 - head_3_accuracy: 0.9158 - head_3_loss: 0.2528 - head_4_accuracy: 0.9134 - head_4_loss: 0.2525 - head_5_accuracy: 0.9147 - head_5_loss: 0.2500 - head_6_accuracy: 0.9149 - head_6_loss: 0.2506 - head_7_accuracy: 0.9130 - head_7_loss: 0.2526 - loss: 1.7644\n", "Epoch 27: val_head_1_accuracy did not improve from 0.93828\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m18s\u001b[0m 175ms/step - head_1_accuracy: 0.9228 - head_1_loss: 0.2290 - head_2_accuracy: 0.9234 - head_2_loss: 0.2270 - head_3_accuracy: 0.9238 - head_3_loss: 0.2279 - head_4_accuracy: 0.9233 - head_4_loss: 0.2276 - head_5_accuracy: 0.9230 - head_5_loss: 0.2271 - head_6_accuracy: 0.9233 - head_6_loss: 0.2273 - head_7_accuracy: 0.9225 - head_7_loss: 0.2279 - loss: 1.6096 - val_head_1_accuracy: 0.9206 - val_head_1_loss: 0.2409 - val_head_2_accuracy: 0.9213 - val_head_2_loss: 0.2376 - val_head_3_accuracy: 0.9197 - val_head_3_loss: 0.2394 - val_head_4_accuracy: 0.9218 - val_head_4_loss: 0.2387 - val_head_5_accuracy: 0.9218 - val_head_5_loss: 0.2365 - val_head_6_accuracy: 0.9209 - val_head_6_loss: 0.2377 - val_head_7_accuracy: 0.9216 - val_head_7_loss: 0.2385 - val_loss: 1.6621 - learning_rate: 5.0357e-04\n", "\n", "Epoch 28: LearningRateScheduler setting learning rate to 0.0004964754771468882.\n", "Epoch 28/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 167ms/step - head_1_accuracy: 0.8977 - head_1_loss: 0.3174 - head_2_accuracy: 0.8969 - head_2_loss: 0.3165 - head_3_accuracy: 0.8974 - head_3_loss: 0.3154 - head_4_accuracy: 0.8982 - head_4_loss: 0.3181 - head_5_accuracy: 0.8966 - head_5_loss: 0.3159 - head_6_accuracy: 0.8971 - head_6_loss: 0.3173 - head_7_accuracy: 0.8943 - head_7_loss: 0.3161 - loss: 2.2165\n", "Epoch 28: val_head_1_accuracy did not improve from 0.93828\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m20s\u001b[0m 175ms/step - head_1_accuracy: 0.8527 - head_1_loss: 0.4485 - head_2_accuracy: 0.8513 - head_2_loss: 0.4475 - head_3_accuracy: 0.8520 - head_3_loss: 0.4475 - head_4_accuracy: 0.8527 - head_4_loss: 0.4503 - head_5_accuracy: 0.8522 - head_5_loss: 0.4466 - head_6_accuracy: 0.8527 - head_6_loss: 0.4470 - head_7_accuracy: 0.8514 - head_7_loss: 0.4468 - loss: 3.1650 - val_head_1_accuracy: 0.8023 - val_head_1_loss: 0.6092 - val_head_2_accuracy: 0.8028 - val_head_2_loss: 0.6027 - val_head_3_accuracy: 0.8058 - val_head_3_loss: 0.5898 - val_head_4_accuracy: 0.7991 - val_head_4_loss: 0.6012 - val_head_5_accuracy: 0.8058 - val_head_5_loss: 0.5988 - val_head_6_accuracy: 0.8028 - val_head_6_loss: 0.6051 - val_head_7_accuracy: 0.8118 - val_head_7_loss: 0.5957 - val_loss: 4.1908 - learning_rate: 4.9648e-04\n", "\n", "Epoch 29: LearningRateScheduler setting learning rate to 0.0004891842724920025.\n", "Epoch 29/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 167ms/step - head_1_accuracy: 0.8563 - head_1_loss: 0.4261 - head_2_accuracy: 0.8541 - head_2_loss: 0.4268 - head_3_accuracy: 0.8577 - head_3_loss: 0.4219 - head_4_accuracy: 0.8560 - head_4_loss: 0.4284 - head_5_accuracy: 0.8579 - head_5_loss: 0.4230 - head_6_accuracy: 0.8547 - head_6_loss: 0.4250 - head_7_accuracy: 0.8555 - head_7_loss: 0.4216 - loss: 2.9728\n", "Epoch 29: val_head_1_accuracy did not improve from 0.93828\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m18s\u001b[0m 177ms/step - head_1_accuracy: 0.8793 - head_1_loss: 0.3562 - head_2_accuracy: 0.8795 - head_2_loss: 0.3552 - head_3_accuracy: 0.8800 - head_3_loss: 0.3543 - head_4_accuracy: 0.8807 - head_4_loss: 0.3586 - head_5_accuracy: 0.8813 - head_5_loss: 0.3547 - head_6_accuracy: 0.8794 - head_6_loss: 0.3549 - head_7_accuracy: 0.8797 - head_7_loss: 0.3526 - loss: 2.5106 - val_head_1_accuracy: 0.9209 - val_head_1_loss: 0.2447 - val_head_2_accuracy: 0.9227 - val_head_2_loss: 0.2405 - val_head_3_accuracy: 0.9218 - val_head_3_loss: 0.2421 - val_head_4_accuracy: 0.9227 - val_head_4_loss: 0.2424 - val_head_5_accuracy: 0.9230 - val_head_5_loss: 0.2421 - val_head_6_accuracy: 0.9216 - val_head_6_loss: 0.2406 - val_head_7_accuracy: 0.9209 - val_head_7_loss: 0.2429 - val_loss: 1.6907 - learning_rate: 4.8918e-04\n", "\n", "Epoch 30: LearningRateScheduler setting learning rate to 0.0004817026256569431.\n", "Epoch 30/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 168ms/step - head_1_accuracy: 0.9108 - head_1_loss: 0.2745 - head_2_accuracy: 0.9119 - head_2_loss: 0.2724 - head_3_accuracy: 0.9099 - head_3_loss: 0.2742 - head_4_accuracy: 0.9119 - head_4_loss: 0.2748 - head_5_accuracy: 0.9118 - head_5_loss: 0.2738 - head_6_accuracy: 0.9119 - head_6_loss: 0.2730 - head_7_accuracy: 0.9096 - head_7_loss: 0.2730 - loss: 1.9156\n", "Epoch 30: val_head_1_accuracy did not improve from 0.93828\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m18s\u001b[0m 181ms/step - head_1_accuracy: 0.9179 - head_1_loss: 0.2521 - head_2_accuracy: 0.9185 - head_2_loss: 0.2526 - head_3_accuracy: 0.9170 - head_3_loss: 0.2528 - head_4_accuracy: 0.9185 - head_4_loss: 0.2532 - head_5_accuracy: 0.9175 - head_5_loss: 0.2515 - head_6_accuracy: 0.9186 - head_6_loss: 0.2515 - head_7_accuracy: 0.9174 - head_7_loss: 0.2527 - loss: 1.7838 - val_head_1_accuracy: 0.9118 - val_head_1_loss: 0.2620 - val_head_2_accuracy: 0.9128 - val_head_2_loss: 0.2546 - val_head_3_accuracy: 0.9132 - val_head_3_loss: 0.2584 - val_head_4_accuracy: 0.9125 - val_head_4_loss: 0.2582 - val_head_5_accuracy: 0.9125 - val_head_5_loss: 0.2592 - val_head_6_accuracy: 0.9125 - val_head_6_loss: 0.2604 - val_head_7_accuracy: 0.9132 - val_head_7_loss: 0.2608 - val_loss: 1.8017 - learning_rate: 4.8170e-04\n", "\n", "Epoch 31: LearningRateScheduler setting learning rate to 0.0004740380700258809.\n", "Epoch 31/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 167ms/step - head_1_accuracy: 0.9223 - head_1_loss: 0.2451 - head_2_accuracy: 0.9213 - head_2_loss: 0.2442 - head_3_accuracy: 0.9210 - head_3_loss: 0.2445 - head_4_accuracy: 0.9222 - head_4_loss: 0.2461 - head_5_accuracy: 0.9227 - head_5_loss: 0.2419 - head_6_accuracy: 0.9219 - head_6_loss: 0.2445 - head_7_accuracy: 0.9210 - head_7_loss: 0.2432 - loss: 1.7095\n", "Epoch 31: val_head_1_accuracy improved from 0.93828 to 0.94942, saving model to /content/drive/My Drive/Classification/multicp/models/ViT_UNet_MultiHead_best.keras\n", "\n", "Epoch 31: finished saving model to /content/drive/My Drive/Classification/multicp/models/ViT_UNet_MultiHead_best.keras\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m20s\u001b[0m 193ms/step - head_1_accuracy: 0.9312 - head_1_loss: 0.2131 - head_2_accuracy: 0.9302 - head_2_loss: 0.2125 - head_3_accuracy: 0.9295 - head_3_loss: 0.2139 - head_4_accuracy: 0.9302 - head_4_loss: 0.2141 - head_5_accuracy: 0.9309 - head_5_loss: 0.2113 - head_6_accuracy: 0.9307 - head_6_loss: 0.2124 - head_7_accuracy: 0.9302 - head_7_loss: 0.2129 - loss: 1.5047 - val_head_1_accuracy: 0.9494 - val_head_1_loss: 0.1464 - val_head_2_accuracy: 0.9501 - val_head_2_loss: 0.1460 - val_head_3_accuracy: 0.9492 - val_head_3_loss: 0.1479 - val_head_4_accuracy: 0.9499 - val_head_4_loss: 0.1468 - val_head_5_accuracy: 0.9501 - val_head_5_loss: 0.1462 - val_head_6_accuracy: 0.9487 - val_head_6_loss: 0.1468 - val_head_7_accuracy: 0.9485 - val_head_7_loss: 0.1470 - val_loss: 1.0231 - learning_rate: 4.7404e-04\n", "\n", "Epoch 32: LearningRateScheduler setting learning rate to 0.0004661983231566398.\n", "Epoch 32/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 166ms/step - head_1_accuracy: 0.9390 - head_1_loss: 0.1882 - head_2_accuracy: 0.9384 - head_2_loss: 0.1883 - head_3_accuracy: 0.9376 - head_3_loss: 0.1883 - head_4_accuracy: 0.9394 - head_4_loss: 0.1883 - head_5_accuracy: 0.9381 - head_5_loss: 0.1888 - head_6_accuracy: 0.9376 - head_6_loss: 0.1878 - head_7_accuracy: 0.9384 - head_7_loss: 0.1880 - loss: 1.3176\n", "Epoch 32: val_head_1_accuracy did not improve from 0.94942\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m18s\u001b[0m 175ms/step - head_1_accuracy: 0.9385 - head_1_loss: 0.1872 - head_2_accuracy: 0.9380 - head_2_loss: 0.1866 - head_3_accuracy: 0.9377 - head_3_loss: 0.1871 - head_4_accuracy: 0.9387 - head_4_loss: 0.1871 - head_5_accuracy: 0.9378 - head_5_loss: 0.1869 - head_6_accuracy: 0.9376 - head_6_loss: 0.1864 - head_7_accuracy: 0.9385 - head_7_loss: 0.1863 - loss: 1.3205 - val_head_1_accuracy: 0.9411 - val_head_1_loss: 0.1967 - val_head_2_accuracy: 0.9441 - val_head_2_loss: 0.1920 - val_head_3_accuracy: 0.9418 - val_head_3_loss: 0.1935 - val_head_4_accuracy: 0.9422 - val_head_4_loss: 0.1943 - val_head_5_accuracy: 0.9427 - val_head_5_loss: 0.1943 - val_head_6_accuracy: 0.9418 - val_head_6_loss: 0.1953 - val_head_7_accuracy: 0.9420 - val_head_7_loss: 0.1954 - val_loss: 1.3545 - learning_rate: 4.6620e-04\n", "\n", "Epoch 33: LearningRateScheduler setting learning rate to 0.0004581912790097702.\n", "Epoch 33/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 167ms/step - head_1_accuracy: 0.9336 - head_1_loss: 0.1975 - head_2_accuracy: 0.9351 - head_2_loss: 0.1968 - head_3_accuracy: 0.9361 - head_3_loss: 0.1972 - head_4_accuracy: 0.9355 - head_4_loss: 0.1977 - head_5_accuracy: 0.9348 - head_5_loss: 0.1968 - head_6_accuracy: 0.9358 - head_6_loss: 0.1962 - head_7_accuracy: 0.9347 - head_7_loss: 0.1970 - loss: 1.3792\n", "Epoch 33: val_head_1_accuracy did not improve from 0.94942\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m21s\u001b[0m 179ms/step - head_1_accuracy: 0.9413 - head_1_loss: 0.1787 - head_2_accuracy: 0.9414 - head_2_loss: 0.1797 - head_3_accuracy: 0.9427 - head_3_loss: 0.1796 - head_4_accuracy: 0.9416 - head_4_loss: 0.1797 - head_5_accuracy: 0.9414 - head_5_loss: 0.1796 - head_6_accuracy: 0.9414 - head_6_loss: 0.1785 - head_7_accuracy: 0.9416 - head_7_loss: 0.1794 - loss: 1.2675 - val_head_1_accuracy: 0.9476 - val_head_1_loss: 0.1472 - val_head_2_accuracy: 0.9464 - val_head_2_loss: 0.1462 - val_head_3_accuracy: 0.9473 - val_head_3_loss: 0.1482 - val_head_4_accuracy: 0.9473 - val_head_4_loss: 0.1482 - val_head_5_accuracy: 0.9469 - val_head_5_loss: 0.1492 - val_head_6_accuracy: 0.9487 - val_head_6_loss: 0.1465 - val_head_7_accuracy: 0.9471 - val_head_7_loss: 0.1475 - val_loss: 1.0315 - learning_rate: 4.5819e-04\n", "\n", "Epoch 34: LearningRateScheduler setting learning rate to 0.000450025.\n", "Epoch 34/100\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 173ms/step - head_1_accuracy: 0.9416 - head_1_loss: 0.1770 - head_2_accuracy: 0.9410 - head_2_loss: 0.1772 - head_3_accuracy: 0.9415 - head_3_loss: 0.1764 - head_4_accuracy: 0.9410 - head_4_loss: 0.1771 - head_5_accuracy: 0.9405 - head_5_loss: 0.1761 - head_6_accuracy: 0.9415 - head_6_loss: 0.1759 - head_7_accuracy: 0.9415 - head_7_loss: 0.1766 - loss: 1.2365\n", "Epoch 34: val_head_1_accuracy did not improve from 0.94942\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m19s\u001b[0m 189ms/step - head_1_accuracy: 0.9442 - head_1_loss: 0.1683 - head_2_accuracy: 0.9429 - head_2_loss: 0.1679 - head_3_accuracy: 0.9440 - head_3_loss: 0.1675 - head_4_accuracy: 0.9440 - head_4_loss: 0.1681 - head_5_accuracy: 0.9437 - head_5_loss: 0.1670 - head_6_accuracy: 0.9437 - head_6_loss: 0.1669 - head_7_accuracy: 0.9441 - head_7_loss: 0.1676 - loss: 1.1847 - val_head_1_accuracy: 0.9397 - val_head_1_loss: 0.1841 - val_head_2_accuracy: 0.9415 - val_head_2_loss: 0.1812 - val_head_3_accuracy: 0.9406 - val_head_3_loss: 0.1811 - val_head_4_accuracy: 0.9401 - val_head_4_loss: 0.1837 - val_head_5_accuracy: 0.9418 - val_head_5_loss: 0.1817 - val_head_6_accuracy: 0.9401 - val_head_6_loss: 0.1829 - val_head_7_accuracy: 0.9408 - val_head_7_loss: 0.1818 - val_loss: 1.2659 - learning_rate: 4.5002e-04\n", "\n", "Epoch 35: LearningRateScheduler setting learning rate to 0.0004417077088780662.\n", "Epoch 35/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 183ms/step - head_1_accuracy: 0.9231 - head_1_loss: 0.2382 - head_2_accuracy: 0.9225 - head_2_loss: 0.2385 - head_3_accuracy: 0.9231 - head_3_loss: 0.2369 - head_4_accuracy: 0.9212 - head_4_loss: 0.2380 - head_5_accuracy: 0.9222 - head_5_loss: 0.2375 - head_6_accuracy: 0.9225 - head_6_loss: 0.2383 - head_7_accuracy: 0.9214 - head_7_loss: 0.2379 - loss: 1.6652\n", "Epoch 35: val_head_1_accuracy improved from 0.94942 to 0.95684, saving model to /content/drive/My Drive/Classification/multicp/models/ViT_UNet_MultiHead_best.keras\n", "\n", "Epoch 35: finished saving model to /content/drive/My Drive/Classification/multicp/models/ViT_UNet_MultiHead_best.keras\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 211ms/step - head_1_accuracy: 0.9312 - head_1_loss: 0.2133 - head_2_accuracy: 0.9303 - head_2_loss: 0.2143 - head_3_accuracy: 0.9309 - head_3_loss: 0.2134 - head_4_accuracy: 0.9302 - head_4_loss: 0.2140 - head_5_accuracy: 0.9305 - head_5_loss: 0.2126 - head_6_accuracy: 0.9308 - head_6_loss: 0.2136 - head_7_accuracy: 0.9308 - head_7_loss: 0.2136 - loss: 1.5097 - val_head_1_accuracy: 0.9568 - val_head_1_loss: 0.1262 - val_head_2_accuracy: 0.9543 - val_head_2_loss: 0.1263 - val_head_3_accuracy: 0.9555 - val_head_3_loss: 0.1269 - val_head_4_accuracy: 0.9559 - val_head_4_loss: 0.1267 - val_head_5_accuracy: 0.9552 - val_head_5_loss: 0.1262 - val_head_6_accuracy: 0.9564 - val_head_6_loss: 0.1255 - val_head_7_accuracy: 0.9571 - val_head_7_loss: 0.1252 - val_loss: 0.8796 - learning_rate: 4.4171e-04\n", "\n", "Epoch 36: LearningRateScheduler setting learning rate to 0.00043324778045110196.\n", "Epoch 36/100\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - head_1_accuracy: 0.9329 - head_1_loss: 0.1927 - head_2_accuracy: 0.9329 - head_2_loss: 0.1917 - head_3_accuracy: 0.9345 - head_3_loss: 0.1926 - head_4_accuracy: 0.9340 - head_4_loss: 0.1939 - head_5_accuracy: 0.9324 - head_5_loss: 0.1922 - head_6_accuracy: 0.9332 - head_6_loss: 0.1925 - head_7_accuracy: 0.9326 - head_7_loss: 0.1933 - loss: 1.3489\n", "Epoch 36: val_head_1_accuracy did not improve from 0.95684\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m19s\u001b[0m 190ms/step - head_1_accuracy: 0.9356 - head_1_loss: 0.1844 - head_2_accuracy: 0.9346 - head_2_loss: 0.1838 - head_3_accuracy: 0.9363 - head_3_loss: 0.1842 - head_4_accuracy: 0.9355 - head_4_loss: 0.1853 - head_5_accuracy: 0.9354 - head_5_loss: 0.1835 - head_6_accuracy: 0.9357 - head_6_loss: 0.1838 - head_7_accuracy: 0.9356 - head_7_loss: 0.1847 - loss: 1.3023 - val_head_1_accuracy: 0.9469 - val_head_1_loss: 0.1718 - val_head_2_accuracy: 0.9415 - val_head_2_loss: 0.1735 - val_head_3_accuracy: 0.9450 - val_head_3_loss: 0.1722 - val_head_4_accuracy: 0.9445 - val_head_4_loss: 0.1728 - val_head_5_accuracy: 0.9452 - val_head_5_loss: 0.1722 - val_head_6_accuracy: 0.9448 - val_head_6_loss: 0.1728 - val_head_7_accuracy: 0.9457 - val_head_7_loss: 0.1706 - val_loss: 1.1991 - learning_rate: 4.3325e-04\n", "\n", "Epoch 37: LearningRateScheduler setting learning rate to 0.0004246537331499159.\n", "Epoch 37/100\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 171ms/step - head_1_accuracy: 0.9430 - head_1_loss: 0.1800 - head_2_accuracy: 0.9421 - head_2_loss: 0.1789 - head_3_accuracy: 0.9429 - head_3_loss: 0.1783 - head_4_accuracy: 0.9437 - head_4_loss: 0.1787 - head_5_accuracy: 0.9413 - head_5_loss: 0.1784 - head_6_accuracy: 0.9426 - head_6_loss: 0.1774 - head_7_accuracy: 0.9429 - head_7_loss: 0.1770 - loss: 1.2488\n", "Epoch 37: val_head_1_accuracy improved from 0.95684 to 0.96288, saving model to /content/drive/My Drive/Classification/multicp/models/ViT_UNet_MultiHead_best.keras\n", "\n", "Epoch 37: finished saving model to /content/drive/My Drive/Classification/multicp/models/ViT_UNet_MultiHead_best.keras\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m21s\u001b[0m 206ms/step - head_1_accuracy: 0.9479 - head_1_loss: 0.1607 - head_2_accuracy: 0.9473 - head_2_loss: 0.1607 - head_3_accuracy: 0.9477 - head_3_loss: 0.1607 - head_4_accuracy: 0.9483 - head_4_loss: 0.1606 - head_5_accuracy: 0.9474 - head_5_loss: 0.1602 - head_6_accuracy: 0.9475 - head_6_loss: 0.1595 - head_7_accuracy: 0.9479 - head_7_loss: 0.1595 - loss: 1.1330 - val_head_1_accuracy: 0.9629 - val_head_1_loss: 0.1203 - val_head_2_accuracy: 0.9619 - val_head_2_loss: 0.1200 - val_head_3_accuracy: 0.9617 - val_head_3_loss: 0.1206 - val_head_4_accuracy: 0.9617 - val_head_4_loss: 0.1211 - val_head_5_accuracy: 0.9613 - val_head_5_loss: 0.1197 - val_head_6_accuracy: 0.9622 - val_head_6_loss: 0.1204 - val_head_7_accuracy: 0.9622 - val_head_7_loss: 0.1201 - val_loss: 0.8390 - learning_rate: 4.2465e-04\n", "\n", "Epoch 38: LearningRateScheduler setting learning rate to 0.0004159342204516539.\n", "Epoch 38/100\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 179ms/step - head_1_accuracy: 0.9477 - head_1_loss: 0.1557 - head_2_accuracy: 0.9475 - head_2_loss: 0.1548 - head_3_accuracy: 0.9483 - head_3_loss: 0.1551 - head_4_accuracy: 0.9467 - head_4_loss: 0.1558 - head_5_accuracy: 0.9481 - head_5_loss: 0.1543 - head_6_accuracy: 0.9490 - head_6_loss: 0.1553 - head_7_accuracy: 0.9476 - head_7_loss: 0.1544 - loss: 1.0855\n", "Epoch 38: val_head_1_accuracy improved from 0.96288 to 0.96520, saving model to /content/drive/My Drive/Classification/multicp/models/ViT_UNet_MultiHead_best.keras\n", "\n", "Epoch 38: finished saving model to /content/drive/My Drive/Classification/multicp/models/ViT_UNet_MultiHead_best.keras\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 219ms/step - head_1_accuracy: 0.9499 - head_1_loss: 0.1470 - head_2_accuracy: 0.9498 - head_2_loss: 0.1467 - head_3_accuracy: 0.9499 - head_3_loss: 0.1465 - head_4_accuracy: 0.9486 - head_4_loss: 0.1481 - head_5_accuracy: 0.9500 - head_5_loss: 0.1463 - head_6_accuracy: 0.9508 - head_6_loss: 0.1466 - head_7_accuracy: 0.9492 - head_7_loss: 0.1468 - loss: 1.0381 - val_head_1_accuracy: 0.9652 - val_head_1_loss: 0.0984 - val_head_2_accuracy: 0.9647 - val_head_2_loss: 0.0994 - val_head_3_accuracy: 0.9652 - val_head_3_loss: 0.0992 - val_head_4_accuracy: 0.9654 - val_head_4_loss: 0.0983 - val_head_5_accuracy: 0.9640 - val_head_5_loss: 0.0990 - val_head_6_accuracy: 0.9647 - val_head_6_loss: 0.0985 - val_head_7_accuracy: 0.9650 - val_head_7_loss: 0.0988 - val_loss: 0.6899 - learning_rate: 4.1593e-04\n", "\n", "Epoch 39: LearningRateScheduler setting learning rate to 0.0004070980221664819.\n", "Epoch 39/100\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 179ms/step - head_1_accuracy: 0.8928 - head_1_loss: 0.3283 - head_2_accuracy: 0.8924 - head_2_loss: 0.3276 - head_3_accuracy: 0.8933 - head_3_loss: 0.3276 - head_4_accuracy: 0.8938 - head_4_loss: 0.3269 - head_5_accuracy: 0.8924 - head_5_loss: 0.3283 - head_6_accuracy: 0.8929 - head_6_loss: 0.3295 - head_7_accuracy: 0.8935 - head_7_loss: 0.3265 - loss: 2.2951\n", "Epoch 39: val_head_1_accuracy did not improve from 0.96520\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m20s\u001b[0m 192ms/step - head_1_accuracy: 0.8667 - head_1_loss: 0.3942 - head_2_accuracy: 0.8670 - head_2_loss: 0.3929 - head_3_accuracy: 0.8672 - head_3_loss: 0.3926 - head_4_accuracy: 0.8676 - head_4_loss: 0.3934 - head_5_accuracy: 0.8670 - head_5_loss: 0.3948 - head_6_accuracy: 0.8668 - head_6_loss: 0.3946 - head_7_accuracy: 0.8673 - head_7_loss: 0.3929 - loss: 2.7823 - val_head_1_accuracy: 0.9139 - val_head_1_loss: 0.2495 - val_head_2_accuracy: 0.9146 - val_head_2_loss: 0.2451 - val_head_3_accuracy: 0.9137 - val_head_3_loss: 0.2489 - val_head_4_accuracy: 0.9142 - val_head_4_loss: 0.2479 - val_head_5_accuracy: 0.9135 - val_head_5_loss: 0.2488 - val_head_6_accuracy: 0.9137 - val_head_6_loss: 0.2474 - val_head_7_accuracy: 0.9123 - val_head_7_loss: 0.2485 - val_loss: 1.7344 - learning_rate: 4.0710e-04\n", "\n", "Epoch 40: LearningRateScheduler setting learning rate to 0.0003981540355970607.\n", "Epoch 40/100\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 175ms/step - head_1_accuracy: 0.9078 - head_1_loss: 0.2721 - head_2_accuracy: 0.9091 - head_2_loss: 0.2704 - head_3_accuracy: 0.9095 - head_3_loss: 0.2725 - head_4_accuracy: 0.9067 - head_4_loss: 0.2753 - head_5_accuracy: 0.9069 - head_5_loss: 0.2736 - head_6_accuracy: 0.9087 - head_6_loss: 0.2732 - head_7_accuracy: 0.9082 - head_7_loss: 0.2737 - loss: 1.9110\n", "Epoch 40: val_head_1_accuracy did not improve from 0.96520\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m19s\u001b[0m 187ms/step - head_1_accuracy: 0.9117 - head_1_loss: 0.2619 - head_2_accuracy: 0.9118 - head_2_loss: 0.2597 - head_3_accuracy: 0.9126 - head_3_loss: 0.2603 - head_4_accuracy: 0.9108 - head_4_loss: 0.2632 - head_5_accuracy: 0.9116 - head_5_loss: 0.2623 - head_6_accuracy: 0.9119 - head_6_loss: 0.2615 - head_7_accuracy: 0.9121 - head_7_loss: 0.2620 - loss: 1.8488 - val_head_1_accuracy: 0.9418 - val_head_1_loss: 0.1754 - val_head_2_accuracy: 0.9404 - val_head_2_loss: 0.1760 - val_head_3_accuracy: 0.9401 - val_head_3_loss: 0.1758 - val_head_4_accuracy: 0.9401 - val_head_4_loss: 0.1753 - val_head_5_accuracy: 0.9394 - val_head_5_loss: 0.1760 - val_head_6_accuracy: 0.9406 - val_head_6_loss: 0.1749 - val_head_7_accuracy: 0.9404 - val_head_7_loss: 0.1756 - val_loss: 1.2305 - learning_rate: 3.9815e-04\n", "\n", "Epoch 41: LearningRateScheduler setting learning rate to 0.0003891112665797161.\n", "Epoch 41/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 168ms/step - head_1_accuracy: 0.9214 - head_1_loss: 0.2367 - head_2_accuracy: 0.9221 - head_2_loss: 0.2372 - head_3_accuracy: 0.9207 - head_3_loss: 0.2365 - head_4_accuracy: 0.9192 - head_4_loss: 0.2375 - head_5_accuracy: 0.9204 - head_5_loss: 0.2363 - head_6_accuracy: 0.9203 - head_6_loss: 0.2361 - head_7_accuracy: 0.9198 - head_7_loss: 0.2363 - loss: 1.6565\n", "Epoch 41: val_head_1_accuracy did not improve from 0.96520\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m18s\u001b[0m 176ms/step - head_1_accuracy: 0.9203 - head_1_loss: 0.2361 - head_2_accuracy: 0.9209 - head_2_loss: 0.2359 - head_3_accuracy: 0.9203 - head_3_loss: 0.2354 - head_4_accuracy: 0.9199 - head_4_loss: 0.2361 - head_5_accuracy: 0.9198 - head_5_loss: 0.2350 - head_6_accuracy: 0.9200 - head_6_loss: 0.2355 - head_7_accuracy: 0.9202 - head_7_loss: 0.2352 - loss: 1.6656 - val_head_1_accuracy: 0.9248 - val_head_1_loss: 0.2286 - val_head_2_accuracy: 0.9262 - val_head_2_loss: 0.2261 - val_head_3_accuracy: 0.9251 - val_head_3_loss: 0.2274 - val_head_4_accuracy: 0.9258 - val_head_4_loss: 0.2303 - val_head_5_accuracy: 0.9267 - val_head_5_loss: 0.2231 - val_head_6_accuracy: 0.9255 - val_head_6_loss: 0.2261 - val_head_7_accuracy: 0.9260 - val_head_7_loss: 0.2270 - val_loss: 1.5805 - learning_rate: 3.8911e-04\n", "\n", "Epoch 42: LearningRateScheduler setting learning rate to 0.000379978820416326.\n", "Epoch 42/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 167ms/step - head_1_accuracy: 0.8878 - head_1_loss: 0.3416 - head_2_accuracy: 0.8876 - head_2_loss: 0.3420 - head_3_accuracy: 0.8883 - head_3_loss: 0.3402 - head_4_accuracy: 0.8863 - head_4_loss: 0.3431 - head_5_accuracy: 0.8890 - head_5_loss: 0.3412 - head_6_accuracy: 0.8872 - head_6_loss: 0.3425 - head_7_accuracy: 0.8900 - head_7_loss: 0.3409 - loss: 2.3914\n", "Epoch 42: val_head_1_accuracy did not improve from 0.96520\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m18s\u001b[0m 175ms/step - head_1_accuracy: 0.8762 - head_1_loss: 0.3737 - head_2_accuracy: 0.8770 - head_2_loss: 0.3745 - head_3_accuracy: 0.8764 - head_3_loss: 0.3728 - head_4_accuracy: 0.8754 - head_4_loss: 0.3752 - head_5_accuracy: 0.8774 - head_5_loss: 0.3733 - head_6_accuracy: 0.8752 - head_6_loss: 0.3753 - head_7_accuracy: 0.8772 - head_7_loss: 0.3730 - loss: 2.6435 - val_head_1_accuracy: 0.9267 - val_head_1_loss: 0.2191 - val_head_2_accuracy: 0.9281 - val_head_2_loss: 0.2183 - val_head_3_accuracy: 0.9265 - val_head_3_loss: 0.2185 - val_head_4_accuracy: 0.9269 - val_head_4_loss: 0.2190 - val_head_5_accuracy: 0.9258 - val_head_5_loss: 0.2199 - val_head_6_accuracy: 0.9248 - val_head_6_loss: 0.2197 - val_head_7_accuracy: 0.9269 - val_head_7_loss: 0.2195 - val_loss: 1.5294 - learning_rate: 3.7998e-04\n", "\n", "Epoch 43: LearningRateScheduler setting learning rate to 0.00037076589270605275.\n", "Epoch 43/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 167ms/step - head_1_accuracy: 0.8825 - head_1_loss: 0.3442 - head_2_accuracy: 0.8797 - head_2_loss: 0.3449 - head_3_accuracy: 0.8819 - head_3_loss: 0.3451 - head_4_accuracy: 0.8823 - head_4_loss: 0.3450 - head_5_accuracy: 0.8829 - head_5_loss: 0.3454 - head_6_accuracy: 0.8829 - head_6_loss: 0.3461 - head_7_accuracy: 0.8807 - head_7_loss: 0.3458 - loss: 2.4166\n", "Epoch 43: val_head_1_accuracy did not improve from 0.96520\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m20s\u001b[0m 175ms/step - head_1_accuracy: 0.8929 - head_1_loss: 0.3157 - head_2_accuracy: 0.8911 - head_2_loss: 0.3154 - head_3_accuracy: 0.8920 - head_3_loss: 0.3155 - head_4_accuracy: 0.8920 - head_4_loss: 0.3165 - head_5_accuracy: 0.8927 - head_5_loss: 0.3160 - head_6_accuracy: 0.8933 - head_6_loss: 0.3164 - head_7_accuracy: 0.8925 - head_7_loss: 0.3158 - loss: 2.2330 - val_head_1_accuracy: 0.9346 - val_head_1_loss: 0.1814 - val_head_2_accuracy: 0.9343 - val_head_2_loss: 0.1823 - val_head_3_accuracy: 0.9348 - val_head_3_loss: 0.1829 - val_head_4_accuracy: 0.9355 - val_head_4_loss: 0.1821 - val_head_5_accuracy: 0.9346 - val_head_5_loss: 0.1831 - val_head_6_accuracy: 0.9348 - val_head_6_loss: 0.1822 - val_head_7_accuracy: 0.9346 - val_head_7_loss: 0.1812 - val_loss: 1.2731 - learning_rate: 3.7077e-04\n", "\n", "Epoch 44: LearningRateScheduler setting learning rate to 0.000361481760086154.\n", "Epoch 44/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 170ms/step - head_1_accuracy: 0.9250 - head_1_loss: 0.2128 - head_2_accuracy: 0.9258 - head_2_loss: 0.2122 - head_3_accuracy: 0.9248 - head_3_loss: 0.2120 - head_4_accuracy: 0.9248 - head_4_loss: 0.2130 - head_5_accuracy: 0.9248 - head_5_loss: 0.2147 - head_6_accuracy: 0.9246 - head_6_loss: 0.2128 - head_7_accuracy: 0.9252 - head_7_loss: 0.2131 - loss: 1.4906\n", "Epoch 44: val_head_1_accuracy did not improve from 0.96520\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m19s\u001b[0m 181ms/step - head_1_accuracy: 0.9303 - head_1_loss: 0.2012 - head_2_accuracy: 0.9302 - head_2_loss: 0.2015 - head_3_accuracy: 0.9297 - head_3_loss: 0.2010 - head_4_accuracy: 0.9298 - head_4_loss: 0.2018 - head_5_accuracy: 0.9295 - head_5_loss: 0.2030 - head_6_accuracy: 0.9293 - head_6_loss: 0.2011 - head_7_accuracy: 0.9299 - head_7_loss: 0.2023 - loss: 1.4258 - val_head_1_accuracy: 0.9381 - val_head_1_loss: 0.1943 - val_head_2_accuracy: 0.9378 - val_head_2_loss: 0.1951 - val_head_3_accuracy: 0.9378 - val_head_3_loss: 0.1930 - val_head_4_accuracy: 0.9364 - val_head_4_loss: 0.1950 - val_head_5_accuracy: 0.9383 - val_head_5_loss: 0.1945 - val_head_6_accuracy: 0.9378 - val_head_6_loss: 0.1939 - val_head_7_accuracy: 0.9378 - val_head_7_loss: 0.1938 - val_loss: 1.3548 - learning_rate: 3.6148e-04\n", "\n", "Epoch 45: LearningRateScheduler setting learning rate to 0.0003521357708911958.\n", "Epoch 45/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 169ms/step - head_1_accuracy: 0.9071 - head_1_loss: 0.2835 - head_2_accuracy: 0.9077 - head_2_loss: 0.2838 - head_3_accuracy: 0.9045 - head_3_loss: 0.2833 - head_4_accuracy: 0.9059 - head_4_loss: 0.2833 - head_5_accuracy: 0.9069 - head_5_loss: 0.2830 - head_6_accuracy: 0.9066 - head_6_loss: 0.2837 - head_7_accuracy: 0.9068 - head_7_loss: 0.2852 - loss: 1.9858\n", "Epoch 45: val_head_1_accuracy did not improve from 0.96520\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m18s\u001b[0m 177ms/step - head_1_accuracy: 0.8615 - head_1_loss: 0.4109 - head_2_accuracy: 0.8636 - head_2_loss: 0.4108 - head_3_accuracy: 0.8611 - head_3_loss: 0.4113 - head_4_accuracy: 0.8626 - head_4_loss: 0.4099 - head_5_accuracy: 0.8634 - head_5_loss: 0.4107 - head_6_accuracy: 0.8629 - head_6_loss: 0.4104 - head_7_accuracy: 0.8612 - head_7_loss: 0.4124 - loss: 2.9043 - val_head_1_accuracy: 0.8775 - val_head_1_loss: 0.3420 - val_head_2_accuracy: 0.8810 - val_head_2_loss: 0.3385 - val_head_3_accuracy: 0.8803 - val_head_3_loss: 0.3423 - val_head_4_accuracy: 0.8824 - val_head_4_loss: 0.3371 - val_head_5_accuracy: 0.8794 - val_head_5_loss: 0.3422 - val_head_6_accuracy: 0.8766 - val_head_6_loss: 0.3438 - val_head_7_accuracy: 0.8787 - val_head_7_loss: 0.3412 - val_loss: 2.3842 - learning_rate: 3.5214e-04\n", "\n", "Epoch 46: LearningRateScheduler setting learning rate to 0.00034273733574007183.\n", "Epoch 46/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 168ms/step - head_1_accuracy: 0.8573 - head_1_loss: 0.4105 - head_2_accuracy: 0.8590 - head_2_loss: 0.4066 - head_3_accuracy: 0.8572 - head_3_loss: 0.4096 - head_4_accuracy: 0.8585 - head_4_loss: 0.4081 - head_5_accuracy: 0.8579 - head_5_loss: 0.4081 - head_6_accuracy: 0.8575 - head_6_loss: 0.4063 - head_7_accuracy: 0.8576 - head_7_loss: 0.4096 - loss: 2.8588\n", "Epoch 46: val_head_1_accuracy did not improve from 0.96520\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m18s\u001b[0m 176ms/step - head_1_accuracy: 0.8687 - head_1_loss: 0.3757 - head_2_accuracy: 0.8698 - head_2_loss: 0.3744 - head_3_accuracy: 0.8680 - head_3_loss: 0.3760 - head_4_accuracy: 0.8692 - head_4_loss: 0.3752 - head_5_accuracy: 0.8698 - head_5_loss: 0.3747 - head_6_accuracy: 0.8695 - head_6_loss: 0.3728 - head_7_accuracy: 0.8683 - head_7_loss: 0.3756 - loss: 2.6503 - val_head_1_accuracy: 0.9037 - val_head_1_loss: 0.2981 - val_head_2_accuracy: 0.9035 - val_head_2_loss: 0.2972 - val_head_3_accuracy: 0.9023 - val_head_3_loss: 0.2990 - val_head_4_accuracy: 0.9046 - val_head_4_loss: 0.2983 - val_head_5_accuracy: 0.9030 - val_head_5_loss: 0.2979 - val_head_6_accuracy: 0.9042 - val_head_6_loss: 0.2985 - val_head_7_accuracy: 0.9037 - val_head_7_loss: 0.2969 - val_loss: 2.0759 - learning_rate: 3.4274e-04\n", "\n", "Epoch 47: LearningRateScheduler setting learning rate to 0.0003332959180603083.\n", "Epoch 47/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 167ms/step - head_1_accuracy: 0.8946 - head_1_loss: 0.3058 - head_2_accuracy: 0.8939 - head_2_loss: 0.3035 - head_3_accuracy: 0.8937 - head_3_loss: 0.3042 - head_4_accuracy: 0.8919 - head_4_loss: 0.3062 - head_5_accuracy: 0.8924 - head_5_loss: 0.3058 - head_6_accuracy: 0.8928 - head_6_loss: 0.3042 - head_7_accuracy: 0.8943 - head_7_loss: 0.3027 - loss: 2.1324\n", "Epoch 47: val_head_1_accuracy did not improve from 0.96520\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m18s\u001b[0m 175ms/step - head_1_accuracy: 0.9043 - head_1_loss: 0.2756 - head_2_accuracy: 0.9045 - head_2_loss: 0.2751 - head_3_accuracy: 0.9040 - head_3_loss: 0.2751 - head_4_accuracy: 0.9026 - head_4_loss: 0.2772 - head_5_accuracy: 0.9038 - head_5_loss: 0.2766 - head_6_accuracy: 0.9041 - head_6_loss: 0.2754 - head_7_accuracy: 0.9039 - head_7_loss: 0.2753 - loss: 1.9490 - val_head_1_accuracy: 0.9302 - val_head_1_loss: 0.2090 - val_head_2_accuracy: 0.9304 - val_head_2_loss: 0.2082 - val_head_3_accuracy: 0.9295 - val_head_3_loss: 0.2100 - val_head_4_accuracy: 0.9313 - val_head_4_loss: 0.2082 - val_head_5_accuracy: 0.9299 - val_head_5_loss: 0.2079 - val_head_6_accuracy: 0.9295 - val_head_6_loss: 0.2088 - val_head_7_accuracy: 0.9297 - val_head_7_loss: 0.2091 - val_loss: 1.4572 - learning_rate: 3.3330e-04\n", "\n", "Epoch 48: LearningRateScheduler setting learning rate to 0.00032382102455919367.\n", "Epoch 48/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 167ms/step - head_1_accuracy: 0.9155 - head_1_loss: 0.2497 - head_2_accuracy: 0.9183 - head_2_loss: 0.2487 - head_3_accuracy: 0.9163 - head_3_loss: 0.2478 - head_4_accuracy: 0.9160 - head_4_loss: 0.2501 - head_5_accuracy: 0.9177 - head_5_loss: 0.2497 - head_6_accuracy: 0.9160 - head_6_loss: 0.2477 - head_7_accuracy: 0.9174 - head_7_loss: 0.2482 - loss: 1.7419\n", "Epoch 48: val_head_1_accuracy did not improve from 0.96520\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m18s\u001b[0m 176ms/step - head_1_accuracy: 0.9184 - head_1_loss: 0.2376 - head_2_accuracy: 0.9196 - head_2_loss: 0.2376 - head_3_accuracy: 0.9186 - head_3_loss: 0.2365 - head_4_accuracy: 0.9189 - head_4_loss: 0.2377 - head_5_accuracy: 0.9195 - head_5_loss: 0.2371 - head_6_accuracy: 0.9181 - head_6_loss: 0.2373 - head_7_accuracy: 0.9193 - head_7_loss: 0.2366 - loss: 1.6768 - val_head_1_accuracy: 0.9339 - val_head_1_loss: 0.1986 - val_head_2_accuracy: 0.9327 - val_head_2_loss: 0.2006 - val_head_3_accuracy: 0.9332 - val_head_3_loss: 0.2039 - val_head_4_accuracy: 0.9339 - val_head_4_loss: 0.1996 - val_head_5_accuracy: 0.9341 - val_head_5_loss: 0.2002 - val_head_6_accuracy: 0.9334 - val_head_6_loss: 0.2004 - val_head_7_accuracy: 0.9329 - val_head_7_loss: 0.2006 - val_loss: 1.4005 - learning_rate: 3.2382e-04\n", "\n", "Epoch 49: LearningRateScheduler setting learning rate to 0.0003143221956513316.\n", "Epoch 49/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 168ms/step - head_1_accuracy: 0.9326 - head_1_loss: 0.2045 - head_2_accuracy: 0.9322 - head_2_loss: 0.2055 - head_3_accuracy: 0.9325 - head_3_loss: 0.2052 - head_4_accuracy: 0.9321 - head_4_loss: 0.2059 - head_5_accuracy: 0.9314 - head_5_loss: 0.2050 - head_6_accuracy: 0.9313 - head_6_loss: 0.2053 - head_7_accuracy: 0.9326 - head_7_loss: 0.2056 - loss: 1.4370\n", "Epoch 49: val_head_1_accuracy did not improve from 0.96520\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m18s\u001b[0m 179ms/step - head_1_accuracy: 0.9272 - head_1_loss: 0.2300 - head_2_accuracy: 0.9276 - head_2_loss: 0.2320 - head_3_accuracy: 0.9271 - head_3_loss: 0.2305 - head_4_accuracy: 0.9269 - head_4_loss: 0.2323 - head_5_accuracy: 0.9267 - head_5_loss: 0.2311 - head_6_accuracy: 0.9272 - head_6_loss: 0.2302 - head_7_accuracy: 0.9274 - head_7_loss: 0.2309 - loss: 1.6151 - val_head_1_accuracy: 0.7794 - val_head_1_loss: 0.7319 - val_head_2_accuracy: 0.7766 - val_head_2_loss: 0.7223 - val_head_3_accuracy: 0.7766 - val_head_3_loss: 0.7348 - val_head_4_accuracy: 0.7745 - val_head_4_loss: 0.7263 - val_head_5_accuracy: 0.7733 - val_head_5_loss: 0.7399 - val_head_6_accuracy: 0.7784 - val_head_6_loss: 0.7244 - val_head_7_accuracy: 0.7738 - val_head_7_loss: 0.7299 - val_loss: 5.0959 - learning_rate: 3.1432e-04\n", "\n", "Epoch 50: LearningRateScheduler setting learning rate to 0.0003048089958522507.\n", "Epoch 50/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 168ms/step - head_1_accuracy: 0.8281 - head_1_loss: 0.5165 - head_2_accuracy: 0.8274 - head_2_loss: 0.5129 - head_3_accuracy: 0.8284 - head_3_loss: 0.5139 - head_4_accuracy: 0.8298 - head_4_loss: 0.5147 - head_5_accuracy: 0.8294 - head_5_loss: 0.5162 - head_6_accuracy: 0.8284 - head_6_loss: 0.5137 - head_7_accuracy: 0.8294 - head_7_loss: 0.5121 - loss: 3.6001\n", "Epoch 50: val_head_1_accuracy did not improve from 0.96520\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m18s\u001b[0m 176ms/step - head_1_accuracy: 0.8665 - head_1_loss: 0.3992 - head_2_accuracy: 0.8669 - head_2_loss: 0.3960 - head_3_accuracy: 0.8667 - head_3_loss: 0.3972 - head_4_accuracy: 0.8671 - head_4_loss: 0.3984 - head_5_accuracy: 0.8664 - head_5_loss: 0.3989 - head_6_accuracy: 0.8663 - head_6_loss: 0.3972 - head_7_accuracy: 0.8677 - head_7_loss: 0.3965 - loss: 2.8108 - val_head_1_accuracy: 0.9206 - val_head_1_loss: 0.2328 - val_head_2_accuracy: 0.9223 - val_head_2_loss: 0.2302 - val_head_3_accuracy: 0.9227 - val_head_3_loss: 0.2351 - val_head_4_accuracy: 0.9218 - val_head_4_loss: 0.2342 - val_head_5_accuracy: 0.9216 - val_head_5_loss: 0.2339 - val_head_6_accuracy: 0.9216 - val_head_6_loss: 0.2329 - val_head_7_accuracy: 0.9220 - val_head_7_loss: 0.2331 - val_loss: 1.6336 - learning_rate: 3.0481e-04\n", "\n", "Epoch 51: LearningRateScheduler setting learning rate to 0.00029529100414774935.\n", "Epoch 51/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 168ms/step - head_1_accuracy: 0.9058 - head_1_loss: 0.2854 - head_2_accuracy: 0.9053 - head_2_loss: 0.2826 - head_3_accuracy: 0.9052 - head_3_loss: 0.2850 - head_4_accuracy: 0.9065 - head_4_loss: 0.2847 - head_5_accuracy: 0.9065 - head_5_loss: 0.2851 - head_6_accuracy: 0.9077 - head_6_loss: 0.2845 - head_7_accuracy: 0.9074 - head_7_loss: 0.2832 - loss: 1.9905\n", "Epoch 51: val_head_1_accuracy did not improve from 0.96520\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m18s\u001b[0m 176ms/step - head_1_accuracy: 0.9125 - head_1_loss: 0.2633 - head_2_accuracy: 0.9121 - head_2_loss: 0.2616 - head_3_accuracy: 0.9119 - head_3_loss: 0.2634 - head_4_accuracy: 0.9123 - head_4_loss: 0.2633 - head_5_accuracy: 0.9123 - head_5_loss: 0.2632 - head_6_accuracy: 0.9130 - head_6_loss: 0.2625 - head_7_accuracy: 0.9131 - head_7_loss: 0.2626 - loss: 1.8579 - val_head_1_accuracy: 0.9390 - val_head_1_loss: 0.1807 - val_head_2_accuracy: 0.9385 - val_head_2_loss: 0.1799 - val_head_3_accuracy: 0.9394 - val_head_3_loss: 0.1809 - val_head_4_accuracy: 0.9394 - val_head_4_loss: 0.1816 - val_head_5_accuracy: 0.9381 - val_head_5_loss: 0.1804 - val_head_6_accuracy: 0.9381 - val_head_6_loss: 0.1805 - val_head_7_accuracy: 0.9378 - val_head_7_loss: 0.1810 - val_loss: 1.2621 - learning_rate: 2.9529e-04\n", "\n", "Epoch 52: LearningRateScheduler setting learning rate to 0.00028577780434866853.\n", "Epoch 52/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 168ms/step - head_1_accuracy: 0.9224 - head_1_loss: 0.2357 - head_2_accuracy: 0.9228 - head_2_loss: 0.2356 - head_3_accuracy: 0.9234 - head_3_loss: 0.2350 - head_4_accuracy: 0.9230 - head_4_loss: 0.2358 - head_5_accuracy: 0.9235 - head_5_loss: 0.2356 - head_6_accuracy: 0.9235 - head_6_loss: 0.2354 - head_7_accuracy: 0.9235 - head_7_loss: 0.2358 - loss: 1.6489\n", "Epoch 52: val_head_1_accuracy did not improve from 0.96520\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m18s\u001b[0m 176ms/step - head_1_accuracy: 0.9285 - head_1_loss: 0.2145 - head_2_accuracy: 0.9281 - head_2_loss: 0.2146 - head_3_accuracy: 0.9285 - head_3_loss: 0.2143 - head_4_accuracy: 0.9285 - head_4_loss: 0.2148 - head_5_accuracy: 0.9284 - head_5_loss: 0.2141 - head_6_accuracy: 0.9289 - head_6_loss: 0.2135 - head_7_accuracy: 0.9292 - head_7_loss: 0.2144 - loss: 1.5151 - val_head_1_accuracy: 0.9392 - val_head_1_loss: 0.1879 - val_head_2_accuracy: 0.9387 - val_head_2_loss: 0.1881 - val_head_3_accuracy: 0.9397 - val_head_3_loss: 0.1894 - val_head_4_accuracy: 0.9390 - val_head_4_loss: 0.1904 - val_head_5_accuracy: 0.9399 - val_head_5_loss: 0.1876 - val_head_6_accuracy: 0.9390 - val_head_6_loss: 0.1879 - val_head_7_accuracy: 0.9394 - val_head_7_loss: 0.1893 - val_loss: 1.3189 - learning_rate: 2.8578e-04\n", "\n", "Epoch 53: LearningRateScheduler setting learning rate to 0.0002762789754408063.\n", "Epoch 53/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 168ms/step - head_1_accuracy: 0.9287 - head_1_loss: 0.2248 - head_2_accuracy: 0.9297 - head_2_loss: 0.2238 - head_3_accuracy: 0.9286 - head_3_loss: 0.2235 - head_4_accuracy: 0.9281 - head_4_loss: 0.2240 - head_5_accuracy: 0.9291 - head_5_loss: 0.2244 - head_6_accuracy: 0.9282 - head_6_loss: 0.2248 - head_7_accuracy: 0.9271 - head_7_loss: 0.2246 - loss: 1.5700\n", "Epoch 53: val_head_1_accuracy did not improve from 0.96520\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m18s\u001b[0m 177ms/step - head_1_accuracy: 0.9312 - head_1_loss: 0.2036 - head_2_accuracy: 0.9318 - head_2_loss: 0.2028 - head_3_accuracy: 0.9312 - head_3_loss: 0.2029 - head_4_accuracy: 0.9310 - head_4_loss: 0.2040 - head_5_accuracy: 0.9316 - head_5_loss: 0.2033 - head_6_accuracy: 0.9313 - head_6_loss: 0.2036 - head_7_accuracy: 0.9299 - head_7_loss: 0.2035 - loss: 1.4377 - val_head_1_accuracy: 0.9422 - val_head_1_loss: 0.1663 - val_head_2_accuracy: 0.9422 - val_head_2_loss: 0.1668 - val_head_3_accuracy: 0.9425 - val_head_3_loss: 0.1672 - val_head_4_accuracy: 0.9422 - val_head_4_loss: 0.1685 - val_head_5_accuracy: 0.9422 - val_head_5_loss: 0.1665 - val_head_6_accuracy: 0.9413 - val_head_6_loss: 0.1676 - val_head_7_accuracy: 0.9420 - val_head_7_loss: 0.1675 - val_loss: 1.1712 - learning_rate: 2.7628e-04\n", "\n", "Epoch 54: LearningRateScheduler setting learning rate to 0.0002668040819396918.\n", "Epoch 54/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 168ms/step - head_1_accuracy: 0.9352 - head_1_loss: 0.1927 - head_2_accuracy: 0.9352 - head_2_loss: 0.1929 - head_3_accuracy: 0.9354 - head_3_loss: 0.1924 - head_4_accuracy: 0.9353 - head_4_loss: 0.1944 - head_5_accuracy: 0.9362 - head_5_loss: 0.1926 - head_6_accuracy: 0.9351 - head_6_loss: 0.1937 - head_7_accuracy: 0.9352 - head_7_loss: 0.1932 - loss: 1.3519\n", "Epoch 54: val_head_1_accuracy did not improve from 0.96520\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m20s\u001b[0m 176ms/step - head_1_accuracy: 0.9405 - head_1_loss: 0.1737 - head_2_accuracy: 0.9409 - head_2_loss: 0.1729 - head_3_accuracy: 0.9414 - head_3_loss: 0.1729 - head_4_accuracy: 0.9416 - head_4_loss: 0.1738 - head_5_accuracy: 0.9410 - head_5_loss: 0.1734 - head_6_accuracy: 0.9404 - head_6_loss: 0.1738 - head_7_accuracy: 0.9410 - head_7_loss: 0.1730 - loss: 1.2254 - val_head_1_accuracy: 0.9441 - val_head_1_loss: 0.1648 - val_head_2_accuracy: 0.9448 - val_head_2_loss: 0.1648 - val_head_3_accuracy: 0.9439 - val_head_3_loss: 0.1674 - val_head_4_accuracy: 0.9439 - val_head_4_loss: 0.1674 - val_head_5_accuracy: 0.9441 - val_head_5_loss: 0.1652 - val_head_6_accuracy: 0.9441 - val_head_6_loss: 0.1639 - val_head_7_accuracy: 0.9450 - val_head_7_loss: 0.1663 - val_loss: 1.1591 - learning_rate: 2.6680e-04\n", "\n", "Epoch 55: LearningRateScheduler setting learning rate to 0.00025736266425992817.\n", "Epoch 55/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 168ms/step - head_1_accuracy: 0.9373 - head_1_loss: 0.1942 - head_2_accuracy: 0.9384 - head_2_loss: 0.1938 - head_3_accuracy: 0.9376 - head_3_loss: 0.1934 - head_4_accuracy: 0.9375 - head_4_loss: 0.1943 - head_5_accuracy: 0.9377 - head_5_loss: 0.1924 - head_6_accuracy: 0.9363 - head_6_loss: 0.1924 - head_7_accuracy: 0.9385 - head_7_loss: 0.1937 - loss: 1.3541\n", "Epoch 55: val_head_1_accuracy did not improve from 0.96520\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m18s\u001b[0m 176ms/step - head_1_accuracy: 0.9418 - head_1_loss: 0.1787 - head_2_accuracy: 0.9423 - head_2_loss: 0.1782 - head_3_accuracy: 0.9414 - head_3_loss: 0.1781 - head_4_accuracy: 0.9422 - head_4_loss: 0.1783 - head_5_accuracy: 0.9419 - head_5_loss: 0.1777 - head_6_accuracy: 0.9412 - head_6_loss: 0.1773 - head_7_accuracy: 0.9418 - head_7_loss: 0.1783 - loss: 1.2589 - val_head_1_accuracy: 0.9478 - val_head_1_loss: 0.1519 - val_head_2_accuracy: 0.9483 - val_head_2_loss: 0.1531 - val_head_3_accuracy: 0.9480 - val_head_3_loss: 0.1536 - val_head_4_accuracy: 0.9476 - val_head_4_loss: 0.1543 - val_head_5_accuracy: 0.9492 - val_head_5_loss: 0.1522 - val_head_6_accuracy: 0.9492 - val_head_6_loss: 0.1522 - val_head_7_accuracy: 0.9480 - val_head_7_loss: 0.1532 - val_loss: 1.0705 - learning_rate: 2.5736e-04\n", "\n", "Epoch 56: LearningRateScheduler setting learning rate to 0.00024796422910880423.\n", "Epoch 56/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 167ms/step - head_1_accuracy: 0.9449 - head_1_loss: 0.1669 - head_2_accuracy: 0.9447 - head_2_loss: 0.1690 - head_3_accuracy: 0.9457 - head_3_loss: 0.1678 - head_4_accuracy: 0.9454 - head_4_loss: 0.1696 - head_5_accuracy: 0.9449 - head_5_loss: 0.1682 - head_6_accuracy: 0.9456 - head_6_loss: 0.1691 - head_7_accuracy: 0.9455 - head_7_loss: 0.1684 - loss: 1.1790\n", "Epoch 56: val_head_1_accuracy did not improve from 0.96520\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m18s\u001b[0m 175ms/step - head_1_accuracy: 0.9481 - head_1_loss: 0.1507 - head_2_accuracy: 0.9489 - head_2_loss: 0.1512 - head_3_accuracy: 0.9490 - head_3_loss: 0.1508 - head_4_accuracy: 0.9485 - head_4_loss: 0.1519 - head_5_accuracy: 0.9493 - head_5_loss: 0.1508 - head_6_accuracy: 0.9496 - head_6_loss: 0.1515 - head_7_accuracy: 0.9493 - head_7_loss: 0.1511 - loss: 1.0683 - val_head_1_accuracy: 0.9587 - val_head_1_loss: 0.1223 - val_head_2_accuracy: 0.9589 - val_head_2_loss: 0.1218 - val_head_3_accuracy: 0.9573 - val_head_3_loss: 0.1231 - val_head_4_accuracy: 0.9582 - val_head_4_loss: 0.1232 - val_head_5_accuracy: 0.9585 - val_head_5_loss: 0.1223 - val_head_6_accuracy: 0.9589 - val_head_6_loss: 0.1220 - val_head_7_accuracy: 0.9580 - val_head_7_loss: 0.1225 - val_loss: 0.8587 - learning_rate: 2.4796e-04\n", "\n", "Epoch 57: LearningRateScheduler setting learning rate to 0.0002386182399138461.\n", "Epoch 57/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 167ms/step - head_1_accuracy: 0.9517 - head_1_loss: 0.1513 - head_2_accuracy: 0.9518 - head_2_loss: 0.1510 - head_3_accuracy: 0.9525 - head_3_loss: 0.1510 - head_4_accuracy: 0.9517 - head_4_loss: 0.1520 - head_5_accuracy: 0.9506 - head_5_loss: 0.1506 - head_6_accuracy: 0.9520 - head_6_loss: 0.1507 - head_7_accuracy: 0.9527 - head_7_loss: 0.1510 - loss: 1.0577\n", "Epoch 57: val_head_1_accuracy did not improve from 0.96520\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m18s\u001b[0m 175ms/step - head_1_accuracy: 0.9524 - head_1_loss: 0.1455 - head_2_accuracy: 0.9524 - head_2_loss: 0.1455 - head_3_accuracy: 0.9521 - head_3_loss: 0.1453 - head_4_accuracy: 0.9517 - head_4_loss: 0.1465 - head_5_accuracy: 0.9518 - head_5_loss: 0.1443 - head_6_accuracy: 0.9515 - head_6_loss: 0.1448 - head_7_accuracy: 0.9527 - head_7_loss: 0.1447 - loss: 1.0266 - val_head_1_accuracy: 0.9543 - val_head_1_loss: 0.1363 - val_head_2_accuracy: 0.9531 - val_head_2_loss: 0.1376 - val_head_3_accuracy: 0.9531 - val_head_3_loss: 0.1371 - val_head_4_accuracy: 0.9534 - val_head_4_loss: 0.1372 - val_head_5_accuracy: 0.9541 - val_head_5_loss: 0.1366 - val_head_6_accuracy: 0.9538 - val_head_6_loss: 0.1373 - val_head_7_accuracy: 0.9536 - val_head_7_loss: 0.1371 - val_loss: 0.9587 - learning_rate: 2.3862e-04\n", "\n", "Epoch 58: LearningRateScheduler setting learning rate to 0.0002293341072939474.\n", "Epoch 58/100\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 166ms/step - head_1_accuracy: 0.9487 - head_1_loss: 0.1574 - head_2_accuracy: 0.9487 - head_2_loss: 0.1593 - head_3_accuracy: 0.9483 - head_3_loss: 0.1585 - head_4_accuracy: 0.9483 - head_4_loss: 0.1587 - head_5_accuracy: 0.9488 - head_5_loss: 0.1578 - head_6_accuracy: 0.9483 - head_6_loss: 0.1585 - head_7_accuracy: 0.9487 - head_7_loss: 0.1595 - loss: 1.1098\n", "Epoch 58: val_head_1_accuracy did not improve from 0.96520\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m18s\u001b[0m 180ms/step - head_1_accuracy: 0.9538 - head_1_loss: 0.1363 - head_2_accuracy: 0.9541 - head_2_loss: 0.1377 - head_3_accuracy: 0.9540 - head_3_loss: 0.1367 - head_4_accuracy: 0.9544 - head_4_loss: 0.1365 - head_5_accuracy: 0.9535 - head_5_loss: 0.1367 - head_6_accuracy: 0.9538 - head_6_loss: 0.1373 - head_7_accuracy: 0.9537 - head_7_loss: 0.1371 - loss: 0.9677 - val_head_1_accuracy: 0.9601 - val_head_1_loss: 0.1124 - val_head_2_accuracy: 0.9592 - val_head_2_loss: 0.1138 - val_head_3_accuracy: 0.9596 - val_head_3_loss: 0.1135 - val_head_4_accuracy: 0.9594 - val_head_4_loss: 0.1127 - val_head_5_accuracy: 0.9601 - val_head_5_loss: 0.1123 - val_head_6_accuracy: 0.9599 - val_head_6_loss: 0.1125 - val_head_7_accuracy: 0.9601 - val_head_7_loss: 0.1125 - val_loss: 0.7906 - learning_rate: 2.2933e-04\n", "\n", "Epoch 59: LearningRateScheduler setting learning rate to 0.00022012117958367398.\n", "Epoch 59/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 167ms/step - head_1_accuracy: 0.9511 - head_1_loss: 0.1438 - head_2_accuracy: 0.9504 - head_2_loss: 0.1429 - head_3_accuracy: 0.9506 - head_3_loss: 0.1432 - head_4_accuracy: 0.9515 - head_4_loss: 0.1440 - head_5_accuracy: 0.9513 - head_5_loss: 0.1438 - head_6_accuracy: 0.9503 - head_6_loss: 0.1433 - head_7_accuracy: 0.9513 - head_7_loss: 0.1438 - loss: 1.0048\n", "Epoch 59: val_head_1_accuracy did not improve from 0.96520\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m18s\u001b[0m 175ms/step - head_1_accuracy: 0.9557 - head_1_loss: 0.1328 - head_2_accuracy: 0.9553 - head_2_loss: 0.1326 - head_3_accuracy: 0.9551 - head_3_loss: 0.1321 - head_4_accuracy: 0.9554 - head_4_loss: 0.1334 - head_5_accuracy: 0.9555 - head_5_loss: 0.1328 - head_6_accuracy: 0.9548 - head_6_loss: 0.1326 - head_7_accuracy: 0.9549 - head_7_loss: 0.1331 - loss: 0.9384 - val_head_1_accuracy: 0.9626 - val_head_1_loss: 0.1012 - val_head_2_accuracy: 0.9631 - val_head_2_loss: 0.1028 - val_head_3_accuracy: 0.9631 - val_head_3_loss: 0.1029 - val_head_4_accuracy: 0.9633 - val_head_4_loss: 0.1019 - val_head_5_accuracy: 0.9645 - val_head_5_loss: 0.1018 - val_head_6_accuracy: 0.9640 - val_head_6_loss: 0.1015 - val_head_7_accuracy: 0.9633 - val_head_7_loss: 0.1014 - val_loss: 0.7136 - learning_rate: 2.2012e-04\n", "\n", "Epoch 60: LearningRateScheduler setting learning rate to 0.00021098873342028398.\n", "Epoch 60/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 167ms/step - head_1_accuracy: 0.9583 - head_1_loss: 0.1252 - head_2_accuracy: 0.9583 - head_2_loss: 0.1250 - head_3_accuracy: 0.9580 - head_3_loss: 0.1254 - head_4_accuracy: 0.9583 - head_4_loss: 0.1265 - head_5_accuracy: 0.9584 - head_5_loss: 0.1255 - head_6_accuracy: 0.9590 - head_6_loss: 0.1260 - head_7_accuracy: 0.9580 - head_7_loss: 0.1256 - loss: 0.8792\n", "Epoch 60: val_head_1_accuracy did not improve from 0.96520\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m18s\u001b[0m 175ms/step - head_1_accuracy: 0.9602 - head_1_loss: 0.1230 - head_2_accuracy: 0.9596 - head_2_loss: 0.1226 - head_3_accuracy: 0.9593 - head_3_loss: 0.1228 - head_4_accuracy: 0.9599 - head_4_loss: 0.1234 - head_5_accuracy: 0.9599 - head_5_loss: 0.1226 - head_6_accuracy: 0.9599 - head_6_loss: 0.1232 - head_7_accuracy: 0.9600 - head_7_loss: 0.1226 - loss: 0.8687 - val_head_1_accuracy: 0.9647 - val_head_1_loss: 0.1004 - val_head_2_accuracy: 0.9645 - val_head_2_loss: 0.1007 - val_head_3_accuracy: 0.9645 - val_head_3_loss: 0.1014 - val_head_4_accuracy: 0.9638 - val_head_4_loss: 0.1012 - val_head_5_accuracy: 0.9643 - val_head_5_loss: 0.1007 - val_head_6_accuracy: 0.9640 - val_head_6_loss: 0.1007 - val_head_7_accuracy: 0.9647 - val_head_7_loss: 0.0999 - val_loss: 0.7049 - learning_rate: 2.1099e-04\n", "\n", "Epoch 61: LearningRateScheduler setting learning rate to 0.00020194596440293946.\n", "Epoch 61/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 168ms/step - head_1_accuracy: 0.9602 - head_1_loss: 0.1214 - head_2_accuracy: 0.9603 - head_2_loss: 0.1210 - head_3_accuracy: 0.9612 - head_3_loss: 0.1221 - head_4_accuracy: 0.9608 - head_4_loss: 0.1215 - head_5_accuracy: 0.9607 - head_5_loss: 0.1214 - head_6_accuracy: 0.9600 - head_6_loss: 0.1219 - head_7_accuracy: 0.9599 - head_7_loss: 0.1206 - loss: 0.8497\n", "Epoch 61: val_head_1_accuracy did not improve from 0.96520\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m18s\u001b[0m 177ms/step - head_1_accuracy: 0.9612 - head_1_loss: 0.1115 - head_2_accuracy: 0.9624 - head_2_loss: 0.1111 - head_3_accuracy: 0.9625 - head_3_loss: 0.1118 - head_4_accuracy: 0.9627 - head_4_loss: 0.1116 - head_5_accuracy: 0.9620 - head_5_loss: 0.1115 - head_6_accuracy: 0.9613 - head_6_loss: 0.1117 - head_7_accuracy: 0.9616 - head_7_loss: 0.1111 - loss: 0.7881 - val_head_1_accuracy: 0.9610 - val_head_1_loss: 0.1037 - val_head_2_accuracy: 0.9622 - val_head_2_loss: 0.1042 - val_head_3_accuracy: 0.9617 - val_head_3_loss: 0.1039 - val_head_4_accuracy: 0.9608 - val_head_4_loss: 0.1041 - val_head_5_accuracy: 0.9619 - val_head_5_loss: 0.1036 - val_head_6_accuracy: 0.9613 - val_head_6_loss: 0.1046 - val_head_7_accuracy: 0.9619 - val_head_7_loss: 0.1036 - val_loss: 0.7295 - learning_rate: 2.0195e-04\n", "\n", "Epoch 62: LearningRateScheduler setting learning rate to 0.00019300197783351806.\n", "Epoch 62/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 168ms/step - head_1_accuracy: 0.9574 - head_1_loss: 0.1214 - head_2_accuracy: 0.9578 - head_2_loss: 0.1217 - head_3_accuracy: 0.9577 - head_3_loss: 0.1191 - head_4_accuracy: 0.9580 - head_4_loss: 0.1209 - head_5_accuracy: 0.9575 - head_5_loss: 0.1200 - head_6_accuracy: 0.9576 - head_6_loss: 0.1210 - head_7_accuracy: 0.9576 - head_7_loss: 0.1199 - loss: 0.8439\n", "Epoch 62: val_head_1_accuracy did not improve from 0.96520\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m18s\u001b[0m 177ms/step - head_1_accuracy: 0.9611 - head_1_loss: 0.1153 - head_2_accuracy: 0.9616 - head_2_loss: 0.1148 - head_3_accuracy: 0.9612 - head_3_loss: 0.1138 - head_4_accuracy: 0.9619 - head_4_loss: 0.1146 - head_5_accuracy: 0.9612 - head_5_loss: 0.1139 - head_6_accuracy: 0.9612 - head_6_loss: 0.1145 - head_7_accuracy: 0.9612 - head_7_loss: 0.1143 - loss: 0.8091 - val_head_1_accuracy: 0.9613 - val_head_1_loss: 0.1108 - val_head_2_accuracy: 0.9622 - val_head_2_loss: 0.1108 - val_head_3_accuracy: 0.9617 - val_head_3_loss: 0.1112 - val_head_4_accuracy: 0.9613 - val_head_4_loss: 0.1119 - val_head_5_accuracy: 0.9617 - val_head_5_loss: 0.1114 - val_head_6_accuracy: 0.9624 - val_head_6_loss: 0.1103 - val_head_7_accuracy: 0.9622 - val_head_7_loss: 0.1105 - val_loss: 0.7783 - learning_rate: 1.9300e-04\n", "\n", "Epoch 63: LearningRateScheduler setting learning rate to 0.00018416577954834612.\n", "Epoch 63/100\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 167ms/step - head_1_accuracy: 0.9588 - head_1_loss: 0.1160 - head_2_accuracy: 0.9573 - head_2_loss: 0.1161 - head_3_accuracy: 0.9570 - head_3_loss: 0.1177 - head_4_accuracy: 0.9573 - head_4_loss: 0.1170 - head_5_accuracy: 0.9580 - head_5_loss: 0.1157 - head_6_accuracy: 0.9568 - head_6_loss: 0.1163 - head_7_accuracy: 0.9581 - head_7_loss: 0.1158 - loss: 0.8146\n", "Epoch 63: val_head_1_accuracy improved from 0.96520 to 0.97193, saving model to /content/drive/My Drive/Classification/multicp/models/ViT_UNet_MultiHead_best.keras\n", "\n", "Epoch 63: finished saving model to /content/drive/My Drive/Classification/multicp/models/ViT_UNet_MultiHead_best.keras\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m20s\u001b[0m 200ms/step - head_1_accuracy: 0.9651 - head_1_loss: 0.1045 - head_2_accuracy: 0.9640 - head_2_loss: 0.1047 - head_3_accuracy: 0.9637 - head_3_loss: 0.1056 - head_4_accuracy: 0.9642 - head_4_loss: 0.1049 - head_5_accuracy: 0.9639 - head_5_loss: 0.1046 - head_6_accuracy: 0.9640 - head_6_loss: 0.1046 - head_7_accuracy: 0.9647 - head_7_loss: 0.1043 - loss: 0.7405 - val_head_1_accuracy: 0.9719 - val_head_1_loss: 0.0820 - val_head_2_accuracy: 0.9719 - val_head_2_loss: 0.0838 - val_head_3_accuracy: 0.9719 - val_head_3_loss: 0.0831 - val_head_4_accuracy: 0.9715 - val_head_4_loss: 0.0830 - val_head_5_accuracy: 0.9722 - val_head_5_loss: 0.0818 - val_head_6_accuracy: 0.9724 - val_head_6_loss: 0.0821 - val_head_7_accuracy: 0.9717 - val_head_7_loss: 0.0827 - val_loss: 0.5770 - learning_rate: 1.8417e-04\n", "\n", "Epoch 64: LearningRateScheduler setting learning rate to 0.00017544626685008413.\n", "Epoch 64/100\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 179ms/step - head_1_accuracy: 0.9632 - head_1_loss: 0.0984 - head_2_accuracy: 0.9639 - head_2_loss: 0.0988 - head_3_accuracy: 0.9635 - head_3_loss: 0.0986 - head_4_accuracy: 0.9622 - head_4_loss: 0.0995 - head_5_accuracy: 0.9645 - head_5_loss: 0.0972 - head_6_accuracy: 0.9634 - head_6_loss: 0.0976 - head_7_accuracy: 0.9636 - head_7_loss: 0.0985 - loss: 0.6887\n", "Epoch 64: val_head_1_accuracy did not improve from 0.97193\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m20s\u001b[0m 193ms/step - head_1_accuracy: 0.9658 - head_1_loss: 0.0948 - head_2_accuracy: 0.9668 - head_2_loss: 0.0946 - head_3_accuracy: 0.9666 - head_3_loss: 0.0949 - head_4_accuracy: 0.9656 - head_4_loss: 0.0956 - head_5_accuracy: 0.9672 - head_5_loss: 0.0941 - head_6_accuracy: 0.9662 - head_6_loss: 0.0947 - head_7_accuracy: 0.9670 - head_7_loss: 0.0948 - loss: 0.6699 - val_head_1_accuracy: 0.9717 - val_head_1_loss: 0.0756 - val_head_2_accuracy: 0.9719 - val_head_2_loss: 0.0760 - val_head_3_accuracy: 0.9719 - val_head_3_loss: 0.0762 - val_head_4_accuracy: 0.9722 - val_head_4_loss: 0.0763 - val_head_5_accuracy: 0.9722 - val_head_5_loss: 0.0755 - val_head_6_accuracy: 0.9722 - val_head_6_loss: 0.0751 - val_head_7_accuracy: 0.9717 - val_head_7_loss: 0.0757 - val_loss: 0.5302 - learning_rate: 1.7545e-04\n", "\n", "Epoch 65: LearningRateScheduler setting learning rate to 0.00016685221954889804.\n", "Epoch 65/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 171ms/step - head_1_accuracy: 0.9629 - head_1_loss: 0.1012 - head_2_accuracy: 0.9640 - head_2_loss: 0.1010 - head_3_accuracy: 0.9641 - head_3_loss: 0.1005 - head_4_accuracy: 0.9645 - head_4_loss: 0.1003 - head_5_accuracy: 0.9633 - head_5_loss: 0.1007 - head_6_accuracy: 0.9644 - head_6_loss: 0.0999 - head_7_accuracy: 0.9626 - head_7_loss: 0.1004 - loss: 0.7039\n", "Epoch 65: val_head_1_accuracy improved from 0.97193 to 0.97564, saving model to /content/drive/My Drive/Classification/multicp/models/ViT_UNet_MultiHead_best.keras\n", "\n", "Epoch 65: finished saving model to /content/drive/My Drive/Classification/multicp/models/ViT_UNet_MultiHead_best.keras\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m20s\u001b[0m 198ms/step - head_1_accuracy: 0.9671 - head_1_loss: 0.0928 - head_2_accuracy: 0.9680 - head_2_loss: 0.0925 - head_3_accuracy: 0.9675 - head_3_loss: 0.0922 - head_4_accuracy: 0.9677 - head_4_loss: 0.0927 - head_5_accuracy: 0.9675 - head_5_loss: 0.0922 - head_6_accuracy: 0.9679 - head_6_loss: 0.0916 - head_7_accuracy: 0.9670 - head_7_loss: 0.0918 - loss: 0.6521 - val_head_1_accuracy: 0.9756 - val_head_1_loss: 0.0737 - val_head_2_accuracy: 0.9752 - val_head_2_loss: 0.0738 - val_head_3_accuracy: 0.9749 - val_head_3_loss: 0.0745 - val_head_4_accuracy: 0.9754 - val_head_4_loss: 0.0744 - val_head_5_accuracy: 0.9761 - val_head_5_loss: 0.0739 - val_head_6_accuracy: 0.9759 - val_head_6_loss: 0.0738 - val_head_7_accuracy: 0.9759 - val_head_7_loss: 0.0740 - val_loss: 0.5167 - learning_rate: 1.6685e-04\n", "\n", "Epoch 66: LearningRateScheduler setting learning rate to 0.00015839229112193386.\n", "Epoch 66/100\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 183ms/step - head_1_accuracy: 0.9665 - head_1_loss: 0.0986 - head_2_accuracy: 0.9664 - head_2_loss: 0.0972 - head_3_accuracy: 0.9672 - head_3_loss: 0.0980 - head_4_accuracy: 0.9661 - head_4_loss: 0.0978 - head_5_accuracy: 0.9663 - head_5_loss: 0.0980 - head_6_accuracy: 0.9660 - head_6_loss: 0.0975 - head_7_accuracy: 0.9662 - head_7_loss: 0.0979 - loss: 0.6851\n", "Epoch 66: val_head_1_accuracy did not improve from 0.97564\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m21s\u001b[0m 201ms/step - head_1_accuracy: 0.9675 - head_1_loss: 0.0931 - head_2_accuracy: 0.9677 - head_2_loss: 0.0925 - head_3_accuracy: 0.9674 - head_3_loss: 0.0927 - head_4_accuracy: 0.9671 - head_4_loss: 0.0923 - head_5_accuracy: 0.9671 - head_5_loss: 0.0929 - head_6_accuracy: 0.9672 - head_6_loss: 0.0925 - head_7_accuracy: 0.9670 - head_7_loss: 0.0927 - loss: 0.6550 - val_head_1_accuracy: 0.9719 - val_head_1_loss: 0.0819 - val_head_2_accuracy: 0.9712 - val_head_2_loss: 0.0820 - val_head_3_accuracy: 0.9712 - val_head_3_loss: 0.0835 - val_head_4_accuracy: 0.9712 - val_head_4_loss: 0.0833 - val_head_5_accuracy: 0.9715 - val_head_5_loss: 0.0828 - val_head_6_accuracy: 0.9715 - val_head_6_loss: 0.0823 - val_head_7_accuracy: 0.9717 - val_head_7_loss: 0.0823 - val_loss: 0.5786 - learning_rate: 1.5839e-04\n", "\n", "Epoch 67: LearningRateScheduler setting learning rate to 0.00015007500000000006.\n", "Epoch 67/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 172ms/step - head_1_accuracy: 0.9652 - head_1_loss: 0.1004 - head_2_accuracy: 0.9649 - head_2_loss: 0.1011 - head_3_accuracy: 0.9651 - head_3_loss: 0.1014 - head_4_accuracy: 0.9641 - head_4_loss: 0.1011 - head_5_accuracy: 0.9650 - head_5_loss: 0.1006 - head_6_accuracy: 0.9638 - head_6_loss: 0.1015 - head_7_accuracy: 0.9658 - head_7_loss: 0.1013 - loss: 0.7073\n", "Epoch 67: val_head_1_accuracy did not improve from 0.97564\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m19s\u001b[0m 180ms/step - head_1_accuracy: 0.9679 - head_1_loss: 0.0908 - head_2_accuracy: 0.9681 - head_2_loss: 0.0908 - head_3_accuracy: 0.9681 - head_3_loss: 0.0913 - head_4_accuracy: 0.9674 - head_4_loss: 0.0914 - head_5_accuracy: 0.9681 - head_5_loss: 0.0910 - head_6_accuracy: 0.9674 - head_6_loss: 0.0915 - head_7_accuracy: 0.9682 - head_7_loss: 0.0917 - loss: 0.6448 - val_head_1_accuracy: 0.9715 - val_head_1_loss: 0.0785 - val_head_2_accuracy: 0.9715 - val_head_2_loss: 0.0793 - val_head_3_accuracy: 0.9710 - val_head_3_loss: 0.0793 - val_head_4_accuracy: 0.9708 - val_head_4_loss: 0.0804 - val_head_5_accuracy: 0.9710 - val_head_5_loss: 0.0790 - val_head_6_accuracy: 0.9719 - val_head_6_loss: 0.0785 - val_head_7_accuracy: 0.9708 - val_head_7_loss: 0.0792 - val_loss: 0.5532 - learning_rate: 1.5007e-04\n", "\n", "Epoch 68: LearningRateScheduler setting learning rate to 0.00014190872099022978.\n", "Epoch 68/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 167ms/step - head_1_accuracy: 0.9696 - head_1_loss: 0.0858 - head_2_accuracy: 0.9707 - head_2_loss: 0.0856 - head_3_accuracy: 0.9686 - head_3_loss: 0.0867 - head_4_accuracy: 0.9687 - head_4_loss: 0.0869 - head_5_accuracy: 0.9689 - head_5_loss: 0.0868 - head_6_accuracy: 0.9709 - head_6_loss: 0.0861 - head_7_accuracy: 0.9686 - head_7_loss: 0.0867 - loss: 0.6046\n", "Epoch 68: val_head_1_accuracy improved from 0.97564 to 0.98121, saving model to /content/drive/My Drive/Classification/multicp/models/ViT_UNet_MultiHead_best.keras\n", "\n", "Epoch 68: finished saving model to /content/drive/My Drive/Classification/multicp/models/ViT_UNet_MultiHead_best.keras\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m20s\u001b[0m 194ms/step - head_1_accuracy: 0.9719 - head_1_loss: 0.0792 - head_2_accuracy: 0.9722 - head_2_loss: 0.0797 - head_3_accuracy: 0.9716 - head_3_loss: 0.0801 - head_4_accuracy: 0.9717 - head_4_loss: 0.0803 - head_5_accuracy: 0.9718 - head_5_loss: 0.0793 - head_6_accuracy: 0.9727 - head_6_loss: 0.0799 - head_7_accuracy: 0.9714 - head_7_loss: 0.0801 - loss: 0.5642 - val_head_1_accuracy: 0.9812 - val_head_1_loss: 0.0604 - val_head_2_accuracy: 0.9810 - val_head_2_loss: 0.0610 - val_head_3_accuracy: 0.9784 - val_head_3_loss: 0.0616 - val_head_4_accuracy: 0.9807 - val_head_4_loss: 0.0610 - val_head_5_accuracy: 0.9807 - val_head_5_loss: 0.0602 - val_head_6_accuracy: 0.9810 - val_head_6_loss: 0.0603 - val_head_7_accuracy: 0.9796 - val_head_7_loss: 0.0612 - val_loss: 0.4252 - learning_rate: 1.4191e-04\n", "\n", "Epoch 69: LearningRateScheduler setting learning rate to 0.00013390167684336024.\n", "Epoch 69/100\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 176ms/step - head_1_accuracy: 0.9695 - head_1_loss: 0.0845 - head_2_accuracy: 0.9715 - head_2_loss: 0.0842 - head_3_accuracy: 0.9709 - head_3_loss: 0.0854 - head_4_accuracy: 0.9712 - head_4_loss: 0.0856 - head_5_accuracy: 0.9698 - head_5_loss: 0.0840 - head_6_accuracy: 0.9710 - head_6_loss: 0.0839 - head_7_accuracy: 0.9699 - head_7_loss: 0.0847 - loss: 0.5922\n", "Epoch 69: val_head_1_accuracy did not improve from 0.98121\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m19s\u001b[0m 190ms/step - head_1_accuracy: 0.9701 - head_1_loss: 0.0859 - head_2_accuracy: 0.9705 - head_2_loss: 0.0861 - head_3_accuracy: 0.9702 - head_3_loss: 0.0861 - head_4_accuracy: 0.9702 - head_4_loss: 0.0870 - head_5_accuracy: 0.9695 - head_5_loss: 0.0858 - head_6_accuracy: 0.9702 - head_6_loss: 0.0859 - head_7_accuracy: 0.9699 - head_7_loss: 0.0858 - loss: 0.6085 - val_head_1_accuracy: 0.9810 - val_head_1_loss: 0.0584 - val_head_2_accuracy: 0.9807 - val_head_2_loss: 0.0582 - val_head_3_accuracy: 0.9782 - val_head_3_loss: 0.0590 - val_head_4_accuracy: 0.9798 - val_head_4_loss: 0.0587 - val_head_5_accuracy: 0.9812 - val_head_5_loss: 0.0581 - val_head_6_accuracy: 0.9807 - val_head_6_loss: 0.0579 - val_head_7_accuracy: 0.9791 - val_head_7_loss: 0.0588 - val_loss: 0.4068 - learning_rate: 1.3390e-04\n", "\n", "Epoch 70: LearningRateScheduler setting learning rate to 0.00012606192997411915.\n", "Epoch 70/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 171ms/step - head_1_accuracy: 0.9729 - head_1_loss: 0.0808 - head_2_accuracy: 0.9723 - head_2_loss: 0.0803 - head_3_accuracy: 0.9724 - head_3_loss: 0.0811 - head_4_accuracy: 0.9726 - head_4_loss: 0.0808 - head_5_accuracy: 0.9732 - head_5_loss: 0.0804 - head_6_accuracy: 0.9721 - head_6_loss: 0.0809 - head_7_accuracy: 0.9731 - head_7_loss: 0.0807 - loss: 0.5650\n", "Epoch 70: val_head_1_accuracy did not improve from 0.98121\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m19s\u001b[0m 184ms/step - head_1_accuracy: 0.9727 - head_1_loss: 0.0798 - head_2_accuracy: 0.9730 - head_2_loss: 0.0797 - head_3_accuracy: 0.9730 - head_3_loss: 0.0803 - head_4_accuracy: 0.9730 - head_4_loss: 0.0802 - head_5_accuracy: 0.9729 - head_5_loss: 0.0795 - head_6_accuracy: 0.9724 - head_6_loss: 0.0800 - head_7_accuracy: 0.9729 - head_7_loss: 0.0801 - loss: 0.5652 - val_head_1_accuracy: 0.9740 - val_head_1_loss: 0.0772 - val_head_2_accuracy: 0.9738 - val_head_2_loss: 0.0785 - val_head_3_accuracy: 0.9740 - val_head_3_loss: 0.0785 - val_head_4_accuracy: 0.9738 - val_head_4_loss: 0.0781 - val_head_5_accuracy: 0.9747 - val_head_5_loss: 0.0768 - val_head_6_accuracy: 0.9745 - val_head_6_loss: 0.0772 - val_head_7_accuracy: 0.9740 - val_head_7_loss: 0.0789 - val_loss: 0.5452 - learning_rate: 1.2606e-04\n", "\n", "Epoch 71: LearningRateScheduler setting learning rate to 0.00011839737434305693.\n", "Epoch 71/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 168ms/step - head_1_accuracy: 0.9685 - head_1_loss: 0.0953 - head_2_accuracy: 0.9680 - head_2_loss: 0.0952 - head_3_accuracy: 0.9680 - head_3_loss: 0.0956 - head_4_accuracy: 0.9681 - head_4_loss: 0.0955 - head_5_accuracy: 0.9688 - head_5_loss: 0.0947 - head_6_accuracy: 0.9683 - head_6_loss: 0.0963 - head_7_accuracy: 0.9691 - head_7_loss: 0.0951 - loss: 0.6678\n", "Epoch 71: val_head_1_accuracy did not improve from 0.98121\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m18s\u001b[0m 177ms/step - head_1_accuracy: 0.9637 - head_1_loss: 0.1104 - head_2_accuracy: 0.9633 - head_2_loss: 0.1095 - head_3_accuracy: 0.9633 - head_3_loss: 0.1101 - head_4_accuracy: 0.9632 - head_4_loss: 0.1106 - head_5_accuracy: 0.9642 - head_5_loss: 0.1094 - head_6_accuracy: 0.9641 - head_6_loss: 0.1101 - head_7_accuracy: 0.9636 - head_7_loss: 0.1097 - loss: 0.7773 - val_head_1_accuracy: 0.9652 - val_head_1_loss: 0.0936 - val_head_2_accuracy: 0.9643 - val_head_2_loss: 0.0943 - val_head_3_accuracy: 0.9640 - val_head_3_loss: 0.0941 - val_head_4_accuracy: 0.9664 - val_head_4_loss: 0.0934 - val_head_5_accuracy: 0.9647 - val_head_5_loss: 0.0936 - val_head_6_accuracy: 0.9645 - val_head_6_loss: 0.0933 - val_head_7_accuracy: 0.9652 - val_head_7_loss: 0.0936 - val_loss: 0.6508 - learning_rate: 1.1840e-04\n", "\n", "Epoch 72: LearningRateScheduler setting learning rate to 0.00011091572750799748.\n", "Epoch 72/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 167ms/step - head_1_accuracy: 0.9628 - head_1_loss: 0.1104 - head_2_accuracy: 0.9628 - head_2_loss: 0.1100 - head_3_accuracy: 0.9618 - head_3_loss: 0.1105 - head_4_accuracy: 0.9634 - head_4_loss: 0.1101 - head_5_accuracy: 0.9621 - head_5_loss: 0.1110 - head_6_accuracy: 0.9626 - head_6_loss: 0.1111 - head_7_accuracy: 0.9628 - head_7_loss: 0.1098 - loss: 0.7730\n", "Epoch 72: val_head_1_accuracy improved from 0.98121 to 0.98260, saving model to /content/drive/My Drive/Classification/multicp/models/ViT_UNet_MultiHead_best.keras\n", "\n", "Epoch 72: finished saving model to /content/drive/My Drive/Classification/multicp/models/ViT_UNet_MultiHead_best.keras\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m20s\u001b[0m 193ms/step - head_1_accuracy: 0.9704 - head_1_loss: 0.0875 - head_2_accuracy: 0.9701 - head_2_loss: 0.0873 - head_3_accuracy: 0.9695 - head_3_loss: 0.0872 - head_4_accuracy: 0.9703 - head_4_loss: 0.0873 - head_5_accuracy: 0.9696 - head_5_loss: 0.0879 - head_6_accuracy: 0.9696 - head_6_loss: 0.0879 - head_7_accuracy: 0.9701 - head_7_loss: 0.0870 - loss: 0.6180 - val_head_1_accuracy: 0.9826 - val_head_1_loss: 0.0539 - val_head_2_accuracy: 0.9826 - val_head_2_loss: 0.0540 - val_head_3_accuracy: 0.9821 - val_head_3_loss: 0.0547 - val_head_4_accuracy: 0.9821 - val_head_4_loss: 0.0544 - val_head_5_accuracy: 0.9824 - val_head_5_loss: 0.0539 - val_head_6_accuracy: 0.9828 - val_head_6_loss: 0.0537 - val_head_7_accuracy: 0.9824 - val_head_7_loss: 0.0544 - val_loss: 0.3752 - learning_rate: 1.1092e-04\n", "\n", "Epoch 73: LearningRateScheduler setting learning rate to 0.00010362452285311177.\n", "Epoch 73/100\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 182ms/step - head_1_accuracy: 0.9720 - head_1_loss: 0.0777 - head_2_accuracy: 0.9739 - head_2_loss: 0.0776 - head_3_accuracy: 0.9721 - head_3_loss: 0.0790 - head_4_accuracy: 0.9734 - head_4_loss: 0.0782 - head_5_accuracy: 0.9733 - head_5_loss: 0.0776 - head_6_accuracy: 0.9733 - head_6_loss: 0.0789 - head_7_accuracy: 0.9722 - head_7_loss: 0.0778 - loss: 0.5468\n", "Epoch 73: val_head_1_accuracy did not improve from 0.98260\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m20s\u001b[0m 200ms/step - head_1_accuracy: 0.9735 - head_1_loss: 0.0748 - head_2_accuracy: 0.9745 - head_2_loss: 0.0748 - head_3_accuracy: 0.9739 - head_3_loss: 0.0759 - head_4_accuracy: 0.9742 - head_4_loss: 0.0754 - head_5_accuracy: 0.9742 - head_5_loss: 0.0745 - head_6_accuracy: 0.9744 - head_6_loss: 0.0757 - head_7_accuracy: 0.9733 - head_7_loss: 0.0751 - loss: 0.5314 - val_head_1_accuracy: 0.9803 - val_head_1_loss: 0.0580 - val_head_2_accuracy: 0.9810 - val_head_2_loss: 0.0576 - val_head_3_accuracy: 0.9805 - val_head_3_loss: 0.0585 - val_head_4_accuracy: 0.9798 - val_head_4_loss: 0.0583 - val_head_5_accuracy: 0.9807 - val_head_5_loss: 0.0580 - val_head_6_accuracy: 0.9807 - val_head_6_loss: 0.0577 - val_head_7_accuracy: 0.9803 - val_head_7_loss: 0.0580 - val_loss: 0.4034 - learning_rate: 1.0362e-04\n", "\n", "Epoch 74: LearningRateScheduler setting learning rate to 9.653110200343824e-05.\n", "Epoch 74/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 170ms/step - head_1_accuracy: 0.9715 - head_1_loss: 0.0801 - head_2_accuracy: 0.9719 - head_2_loss: 0.0803 - head_3_accuracy: 0.9720 - head_3_loss: 0.0803 - head_4_accuracy: 0.9706 - head_4_loss: 0.0809 - head_5_accuracy: 0.9717 - head_5_loss: 0.0800 - head_6_accuracy: 0.9718 - head_6_loss: 0.0798 - head_7_accuracy: 0.9708 - head_7_loss: 0.0804 - loss: 0.5618\n", "Epoch 74: val_head_1_accuracy improved from 0.98260 to 0.98329, saving model to /content/drive/My Drive/Classification/multicp/models/ViT_UNet_MultiHead_best.keras\n", "\n", "Epoch 74: finished saving model to /content/drive/My Drive/Classification/multicp/models/ViT_UNet_MultiHead_best.keras\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m20s\u001b[0m 198ms/step - head_1_accuracy: 0.9749 - head_1_loss: 0.0732 - head_2_accuracy: 0.9752 - head_2_loss: 0.0734 - head_3_accuracy: 0.9754 - head_3_loss: 0.0735 - head_4_accuracy: 0.9742 - head_4_loss: 0.0741 - head_5_accuracy: 0.9748 - head_5_loss: 0.0735 - head_6_accuracy: 0.9754 - head_6_loss: 0.0730 - head_7_accuracy: 0.9744 - head_7_loss: 0.0734 - loss: 0.5191 - val_head_1_accuracy: 0.9833 - val_head_1_loss: 0.0481 - val_head_2_accuracy: 0.9833 - val_head_2_loss: 0.0482 - val_head_3_accuracy: 0.9835 - val_head_3_loss: 0.0487 - val_head_4_accuracy: 0.9833 - val_head_4_loss: 0.0485 - val_head_5_accuracy: 0.9833 - val_head_5_loss: 0.0480 - val_head_6_accuracy: 0.9833 - val_head_6_loss: 0.0479 - val_head_7_accuracy: 0.9835 - val_head_7_loss: 0.0484 - val_loss: 0.3366 - learning_rate: 9.6531e-05\n", "\n", "Epoch 75: LearningRateScheduler setting learning rate to 8.96426074324889e-05.\n", "Epoch 75/100\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 180ms/step - head_1_accuracy: 0.9740 - head_1_loss: 0.0774 - head_2_accuracy: 0.9746 - head_2_loss: 0.0763 - head_3_accuracy: 0.9745 - head_3_loss: 0.0773 - head_4_accuracy: 0.9745 - head_4_loss: 0.0773 - head_5_accuracy: 0.9739 - head_5_loss: 0.0766 - head_6_accuracy: 0.9746 - head_6_loss: 0.0770 - head_7_accuracy: 0.9745 - head_7_loss: 0.0768 - loss: 0.5388\n", "Epoch 75: val_head_1_accuracy improved from 0.98329 to 0.98724, saving model to /content/drive/My Drive/Classification/multicp/models/ViT_UNet_MultiHead_best.keras\n", "\n", "Epoch 75: finished saving model to /content/drive/My Drive/Classification/multicp/models/ViT_UNet_MultiHead_best.keras\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m23s\u001b[0m 224ms/step - head_1_accuracy: 0.9756 - head_1_loss: 0.0706 - head_2_accuracy: 0.9760 - head_2_loss: 0.0696 - head_3_accuracy: 0.9759 - head_3_loss: 0.0706 - head_4_accuracy: 0.9761 - head_4_loss: 0.0704 - head_5_accuracy: 0.9755 - head_5_loss: 0.0700 - head_6_accuracy: 0.9760 - head_6_loss: 0.0703 - head_7_accuracy: 0.9762 - head_7_loss: 0.0701 - loss: 0.4964 - val_head_1_accuracy: 0.9872 - val_head_1_loss: 0.0452 - val_head_2_accuracy: 0.9870 - val_head_2_loss: 0.0454 - val_head_3_accuracy: 0.9870 - val_head_3_loss: 0.0456 - val_head_4_accuracy: 0.9872 - val_head_4_loss: 0.0456 - val_head_5_accuracy: 0.9870 - val_head_5_loss: 0.0450 - val_head_6_accuracy: 0.9868 - val_head_6_loss: 0.0450 - val_head_7_accuracy: 0.9870 - val_head_7_loss: 0.0453 - val_loss: 0.3146 - learning_rate: 8.9643e-05\n", "\n", "Epoch 76: LearningRateScheduler setting learning rate to 8.29659752703842e-05.\n", "Epoch 76/100\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 181ms/step - head_1_accuracy: 0.9770 - head_1_loss: 0.0700 - head_2_accuracy: 0.9764 - head_2_loss: 0.0712 - head_3_accuracy: 0.9765 - head_3_loss: 0.0716 - head_4_accuracy: 0.9767 - head_4_loss: 0.0707 - head_5_accuracy: 0.9775 - head_5_loss: 0.0703 - head_6_accuracy: 0.9772 - head_6_loss: 0.0700 - head_7_accuracy: 0.9759 - head_7_loss: 0.0711 - loss: 0.4949\n", "Epoch 76: val_head_1_accuracy did not improve from 0.98724\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m20s\u001b[0m 199ms/step - head_1_accuracy: 0.9787 - head_1_loss: 0.0641 - head_2_accuracy: 0.9787 - head_2_loss: 0.0652 - head_3_accuracy: 0.9788 - head_3_loss: 0.0652 - head_4_accuracy: 0.9787 - head_4_loss: 0.0646 - head_5_accuracy: 0.9792 - head_5_loss: 0.0643 - head_6_accuracy: 0.9788 - head_6_loss: 0.0645 - head_7_accuracy: 0.9787 - head_7_loss: 0.0648 - loss: 0.4571 - val_head_1_accuracy: 0.9842 - val_head_1_loss: 0.0508 - val_head_2_accuracy: 0.9842 - val_head_2_loss: 0.0510 - val_head_3_accuracy: 0.9840 - val_head_3_loss: 0.0508 - val_head_4_accuracy: 0.9845 - val_head_4_loss: 0.0512 - val_head_5_accuracy: 0.9840 - val_head_5_loss: 0.0504 - val_head_6_accuracy: 0.9842 - val_head_6_loss: 0.0505 - val_head_7_accuracy: 0.9840 - val_head_7_loss: 0.0511 - val_loss: 0.3522 - learning_rate: 8.2966e-05\n", "\n", "Epoch 77: LearningRateScheduler setting learning rate to 7.650792831975739e-05.\n", "Epoch 77/100\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 174ms/step - head_1_accuracy: 0.9742 - head_1_loss: 0.0706 - head_2_accuracy: 0.9731 - head_2_loss: 0.0712 - head_3_accuracy: 0.9735 - head_3_loss: 0.0704 - head_4_accuracy: 0.9733 - head_4_loss: 0.0711 - head_5_accuracy: 0.9742 - head_5_loss: 0.0704 - head_6_accuracy: 0.9745 - head_6_loss: 0.0704 - head_7_accuracy: 0.9741 - head_7_loss: 0.0706 - loss: 0.4948\n", "Epoch 77: val_head_1_accuracy did not improve from 0.98724\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m19s\u001b[0m 185ms/step - head_1_accuracy: 0.9770 - head_1_loss: 0.0652 - head_2_accuracy: 0.9763 - head_2_loss: 0.0655 - head_3_accuracy: 0.9765 - head_3_loss: 0.0654 - head_4_accuracy: 0.9771 - head_4_loss: 0.0653 - head_5_accuracy: 0.9769 - head_5_loss: 0.0651 - head_6_accuracy: 0.9771 - head_6_loss: 0.0650 - head_7_accuracy: 0.9770 - head_7_loss: 0.0652 - loss: 0.4612 - val_head_1_accuracy: 0.9845 - val_head_1_loss: 0.0464 - val_head_2_accuracy: 0.9847 - val_head_2_loss: 0.0468 - val_head_3_accuracy: 0.9847 - val_head_3_loss: 0.0469 - val_head_4_accuracy: 0.9845 - val_head_4_loss: 0.0468 - val_head_5_accuracy: 0.9845 - val_head_5_loss: 0.0463 - val_head_6_accuracy: 0.9845 - val_head_6_loss: 0.0463 - val_head_7_accuracy: 0.9845 - val_head_7_loss: 0.0466 - val_loss: 0.3248 - learning_rate: 7.6508e-05\n", "\n", "Epoch 78: LearningRateScheduler setting learning rate to 7.027496928646257e-05.\n", "Epoch 78/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 167ms/step - head_1_accuracy: 0.9772 - head_1_loss: 0.0649 - head_2_accuracy: 0.9770 - head_2_loss: 0.0645 - head_3_accuracy: 0.9770 - head_3_loss: 0.0650 - head_4_accuracy: 0.9776 - head_4_loss: 0.0648 - head_5_accuracy: 0.9776 - head_5_loss: 0.0648 - head_6_accuracy: 0.9781 - head_6_loss: 0.0649 - head_7_accuracy: 0.9772 - head_7_loss: 0.0642 - loss: 0.4530\n", "Epoch 78: val_head_1_accuracy did not improve from 0.98724\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m18s\u001b[0m 175ms/step - head_1_accuracy: 0.9784 - head_1_loss: 0.0635 - head_2_accuracy: 0.9783 - head_2_loss: 0.0631 - head_3_accuracy: 0.9783 - head_3_loss: 0.0633 - head_4_accuracy: 0.9787 - head_4_loss: 0.0636 - head_5_accuracy: 0.9787 - head_5_loss: 0.0635 - head_6_accuracy: 0.9788 - head_6_loss: 0.0637 - head_7_accuracy: 0.9782 - head_7_loss: 0.0631 - loss: 0.4482 - val_head_1_accuracy: 0.9845 - val_head_1_loss: 0.0457 - val_head_2_accuracy: 0.9847 - val_head_2_loss: 0.0459 - val_head_3_accuracy: 0.9852 - val_head_3_loss: 0.0460 - val_head_4_accuracy: 0.9849 - val_head_4_loss: 0.0460 - val_head_5_accuracy: 0.9847 - val_head_5_loss: 0.0456 - val_head_6_accuracy: 0.9849 - val_head_6_loss: 0.0455 - val_head_7_accuracy: 0.9849 - val_head_7_loss: 0.0458 - val_loss: 0.3202 - learning_rate: 7.0275e-05\n", "\n", "Epoch 79: LearningRateScheduler setting learning rate to 6.427337423190096e-05.\n", "Epoch 79/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 166ms/step - head_1_accuracy: 0.9791 - head_1_loss: 0.0605 - head_2_accuracy: 0.9799 - head_2_loss: 0.0608 - head_3_accuracy: 0.9790 - head_3_loss: 0.0615 - head_4_accuracy: 0.9792 - head_4_loss: 0.0612 - head_5_accuracy: 0.9799 - head_5_loss: 0.0613 - head_6_accuracy: 0.9781 - head_6_loss: 0.0615 - head_7_accuracy: 0.9782 - head_7_loss: 0.0620 - loss: 0.4286\n", "Epoch 79: val_head_1_accuracy did not improve from 0.98724\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m18s\u001b[0m 174ms/step - head_1_accuracy: 0.9797 - head_1_loss: 0.0587 - head_2_accuracy: 0.9804 - head_2_loss: 0.0591 - head_3_accuracy: 0.9800 - head_3_loss: 0.0593 - head_4_accuracy: 0.9801 - head_4_loss: 0.0594 - head_5_accuracy: 0.9804 - head_5_loss: 0.0596 - head_6_accuracy: 0.9793 - head_6_loss: 0.0594 - head_7_accuracy: 0.9795 - head_7_loss: 0.0597 - loss: 0.4194 - val_head_1_accuracy: 0.9870 - val_head_1_loss: 0.0432 - val_head_2_accuracy: 0.9865 - val_head_2_loss: 0.0433 - val_head_3_accuracy: 0.9868 - val_head_3_loss: 0.0435 - val_head_4_accuracy: 0.9870 - val_head_4_loss: 0.0434 - val_head_5_accuracy: 0.9870 - val_head_5_loss: 0.0430 - val_head_6_accuracy: 0.9872 - val_head_6_loss: 0.0430 - val_head_7_accuracy: 0.9870 - val_head_7_loss: 0.0433 - val_loss: 0.3026 - learning_rate: 6.4273e-05\n", "\n", "Epoch 80: LearningRateScheduler setting learning rate to 5.850918625355897e-05.\n", "Epoch 80/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 166ms/step - head_1_accuracy: 0.9794 - head_1_loss: 0.0609 - head_2_accuracy: 0.9793 - head_2_loss: 0.0611 - head_3_accuracy: 0.9793 - head_3_loss: 0.0604 - head_4_accuracy: 0.9796 - head_4_loss: 0.0599 - head_5_accuracy: 0.9793 - head_5_loss: 0.0602 - head_6_accuracy: 0.9802 - head_6_loss: 0.0600 - head_7_accuracy: 0.9796 - head_7_loss: 0.0606 - loss: 0.4231\n", "Epoch 80: val_head_1_accuracy did not improve from 0.98724\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m18s\u001b[0m 174ms/step - head_1_accuracy: 0.9819 - head_1_loss: 0.0553 - head_2_accuracy: 0.9821 - head_2_loss: 0.0554 - head_3_accuracy: 0.9820 - head_3_loss: 0.0552 - head_4_accuracy: 0.9817 - head_4_loss: 0.0548 - head_5_accuracy: 0.9821 - head_5_loss: 0.0553 - head_6_accuracy: 0.9826 - head_6_loss: 0.0552 - head_7_accuracy: 0.9819 - head_7_loss: 0.0553 - loss: 0.3903 - val_head_1_accuracy: 0.9852 - val_head_1_loss: 0.0424 - val_head_2_accuracy: 0.9854 - val_head_2_loss: 0.0426 - val_head_3_accuracy: 0.9845 - val_head_3_loss: 0.0427 - val_head_4_accuracy: 0.9849 - val_head_4_loss: 0.0427 - val_head_5_accuracy: 0.9852 - val_head_5_loss: 0.0424 - val_head_6_accuracy: 0.9847 - val_head_6_loss: 0.0424 - val_head_7_accuracy: 0.9852 - val_head_7_loss: 0.0427 - val_loss: 0.2973 - learning_rate: 5.8509e-05\n", "\n", "Epoch 81: LearningRateScheduler setting learning rate to 5.298820940012169e-05.\n", "Epoch 81/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 167ms/step - head_1_accuracy: 0.9805 - head_1_loss: 0.0596 - head_2_accuracy: 0.9806 - head_2_loss: 0.0595 - head_3_accuracy: 0.9811 - head_3_loss: 0.0591 - head_4_accuracy: 0.9810 - head_4_loss: 0.0586 - head_5_accuracy: 0.9803 - head_5_loss: 0.0593 - head_6_accuracy: 0.9813 - head_6_loss: 0.0592 - head_7_accuracy: 0.9806 - head_7_loss: 0.0593 - loss: 0.4146\n", "Epoch 81: val_head_1_accuracy did not improve from 0.98724\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m18s\u001b[0m 177ms/step - head_1_accuracy: 0.9814 - head_1_loss: 0.0577 - head_2_accuracy: 0.9811 - head_2_loss: 0.0578 - head_3_accuracy: 0.9814 - head_3_loss: 0.0577 - head_4_accuracy: 0.9813 - head_4_loss: 0.0574 - head_5_accuracy: 0.9811 - head_5_loss: 0.0575 - head_6_accuracy: 0.9815 - head_6_loss: 0.0576 - head_7_accuracy: 0.9814 - head_7_loss: 0.0579 - loss: 0.4075 - val_head_1_accuracy: 0.9865 - val_head_1_loss: 0.0429 - val_head_2_accuracy: 0.9870 - val_head_2_loss: 0.0429 - val_head_3_accuracy: 0.9872 - val_head_3_loss: 0.0431 - val_head_4_accuracy: 0.9865 - val_head_4_loss: 0.0430 - val_head_5_accuracy: 0.9865 - val_head_5_loss: 0.0428 - val_head_6_accuracy: 0.9868 - val_head_6_loss: 0.0428 - val_head_7_accuracy: 0.9865 - val_head_7_loss: 0.0429 - val_loss: 0.2993 - learning_rate: 5.2988e-05\n", "\n", "Epoch 82: LearningRateScheduler setting learning rate to 4.7716002827287234e-05.\n", "Epoch 82/100\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 167ms/step - head_1_accuracy: 0.9786 - head_1_loss: 0.0573 - head_2_accuracy: 0.9799 - head_2_loss: 0.0561 - head_3_accuracy: 0.9789 - head_3_loss: 0.0562 - head_4_accuracy: 0.9789 - head_4_loss: 0.0557 - head_5_accuracy: 0.9792 - head_5_loss: 0.0566 - head_6_accuracy: 0.9792 - head_6_loss: 0.0563 - head_7_accuracy: 0.9792 - head_7_loss: 0.0569 - loss: 0.3952\n", "Epoch 82: val_head_1_accuracy did not improve from 0.98724\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m18s\u001b[0m 179ms/step - head_1_accuracy: 0.9808 - head_1_loss: 0.0533 - head_2_accuracy: 0.9812 - head_2_loss: 0.0527 - head_3_accuracy: 0.9814 - head_3_loss: 0.0526 - head_4_accuracy: 0.9810 - head_4_loss: 0.0525 - head_5_accuracy: 0.9819 - head_5_loss: 0.0530 - head_6_accuracy: 0.9814 - head_6_loss: 0.0525 - head_7_accuracy: 0.9814 - head_7_loss: 0.0531 - loss: 0.3732 - val_head_1_accuracy: 0.9849 - val_head_1_loss: 0.0428 - val_head_2_accuracy: 0.9852 - val_head_2_loss: 0.0431 - val_head_3_accuracy: 0.9847 - val_head_3_loss: 0.0431 - val_head_4_accuracy: 0.9849 - val_head_4_loss: 0.0431 - val_head_5_accuracy: 0.9849 - val_head_5_loss: 0.0428 - val_head_6_accuracy: 0.9852 - val_head_6_loss: 0.0427 - val_head_7_accuracy: 0.9847 - val_head_7_loss: 0.0431 - val_loss: 0.2994 - learning_rate: 4.7716e-05\n", "\n", "Epoch 83: LearningRateScheduler setting learning rate to 4.26978752001687e-05.\n", "Epoch 83/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 167ms/step - head_1_accuracy: 0.9809 - head_1_loss: 0.0585 - head_2_accuracy: 0.9809 - head_2_loss: 0.0577 - head_3_accuracy: 0.9809 - head_3_loss: 0.0584 - head_4_accuracy: 0.9802 - head_4_loss: 0.0582 - head_5_accuracy: 0.9806 - head_5_loss: 0.0585 - head_6_accuracy: 0.9801 - head_6_loss: 0.0577 - head_7_accuracy: 0.9803 - head_7_loss: 0.0585 - loss: 0.4075\n", "Epoch 83: val_head_1_accuracy did not improve from 0.98724\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m18s\u001b[0m 175ms/step - head_1_accuracy: 0.9814 - head_1_loss: 0.0545 - head_2_accuracy: 0.9815 - head_2_loss: 0.0541 - head_3_accuracy: 0.9814 - head_3_loss: 0.0542 - head_4_accuracy: 0.9807 - head_4_loss: 0.0545 - head_5_accuracy: 0.9812 - head_5_loss: 0.0544 - head_6_accuracy: 0.9814 - head_6_loss: 0.0540 - head_7_accuracy: 0.9811 - head_7_loss: 0.0545 - loss: 0.3839 - val_head_1_accuracy: 0.9840 - val_head_1_loss: 0.0458 - val_head_2_accuracy: 0.9840 - val_head_2_loss: 0.0461 - val_head_3_accuracy: 0.9842 - val_head_3_loss: 0.0463 - val_head_4_accuracy: 0.9842 - val_head_4_loss: 0.0462 - val_head_5_accuracy: 0.9835 - val_head_5_loss: 0.0458 - val_head_6_accuracy: 0.9838 - val_head_6_loss: 0.0459 - val_head_7_accuracy: 0.9845 - val_head_7_loss: 0.0460 - val_loss: 0.3225 - learning_rate: 4.2698e-05\n", "\n", "Epoch 84: LearningRateScheduler setting learning rate to 3.793887934791801e-05.\n", "Epoch 84/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 167ms/step - head_1_accuracy: 0.9803 - head_1_loss: 0.0572 - head_2_accuracy: 0.9803 - head_2_loss: 0.0568 - head_3_accuracy: 0.9809 - head_3_loss: 0.0566 - head_4_accuracy: 0.9800 - head_4_loss: 0.0573 - head_5_accuracy: 0.9806 - head_5_loss: 0.0574 - head_6_accuracy: 0.9814 - head_6_loss: 0.0566 - head_7_accuracy: 0.9803 - head_7_loss: 0.0570 - loss: 0.3988\n", "Epoch 84: val_head_1_accuracy did not improve from 0.98724\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m18s\u001b[0m 175ms/step - head_1_accuracy: 0.9813 - head_1_loss: 0.0542 - head_2_accuracy: 0.9808 - head_2_loss: 0.0540 - head_3_accuracy: 0.9815 - head_3_loss: 0.0539 - head_4_accuracy: 0.9809 - head_4_loss: 0.0546 - head_5_accuracy: 0.9816 - head_5_loss: 0.0545 - head_6_accuracy: 0.9818 - head_6_loss: 0.0539 - head_7_accuracy: 0.9811 - head_7_loss: 0.0538 - loss: 0.3827 - val_head_1_accuracy: 0.9872 - val_head_1_loss: 0.0438 - val_head_2_accuracy: 0.9870 - val_head_2_loss: 0.0441 - val_head_3_accuracy: 0.9872 - val_head_3_loss: 0.0442 - val_head_4_accuracy: 0.9870 - val_head_4_loss: 0.0441 - val_head_5_accuracy: 0.9868 - val_head_5_loss: 0.0439 - val_head_6_accuracy: 0.9868 - val_head_6_loss: 0.0441 - val_head_7_accuracy: 0.9870 - val_head_7_loss: 0.0441 - val_loss: 0.3069 - learning_rate: 3.7939e-05\n", "\n", "Epoch 85: LearningRateScheduler setting learning rate to 3.344380717595574e-05.\n", "Epoch 85/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 167ms/step - head_1_accuracy: 0.9786 - head_1_loss: 0.0583 - head_2_accuracy: 0.9782 - head_2_loss: 0.0582 - head_3_accuracy: 0.9789 - head_3_loss: 0.0582 - head_4_accuracy: 0.9782 - head_4_loss: 0.0586 - head_5_accuracy: 0.9785 - head_5_loss: 0.0588 - head_6_accuracy: 0.9785 - head_6_loss: 0.0586 - head_7_accuracy: 0.9781 - head_7_loss: 0.0578 - loss: 0.4086\n", "Epoch 85: val_head_1_accuracy improved from 0.98724 to 0.98770, saving model to /content/drive/My Drive/Classification/multicp/models/ViT_UNet_MultiHead_best.keras\n", "\n", "Epoch 85: finished saving model to /content/drive/My Drive/Classification/multicp/models/ViT_UNet_MultiHead_best.keras\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m20s\u001b[0m 194ms/step - head_1_accuracy: 0.9804 - head_1_loss: 0.0550 - head_2_accuracy: 0.9802 - head_2_loss: 0.0551 - head_3_accuracy: 0.9807 - head_3_loss: 0.0546 - head_4_accuracy: 0.9804 - head_4_loss: 0.0549 - head_5_accuracy: 0.9804 - head_5_loss: 0.0550 - head_6_accuracy: 0.9804 - head_6_loss: 0.0551 - head_7_accuracy: 0.9802 - head_7_loss: 0.0547 - loss: 0.3883 - val_head_1_accuracy: 0.9877 - val_head_1_loss: 0.0397 - val_head_2_accuracy: 0.9877 - val_head_2_loss: 0.0399 - val_head_3_accuracy: 0.9882 - val_head_3_loss: 0.0400 - val_head_4_accuracy: 0.9879 - val_head_4_loss: 0.0400 - val_head_5_accuracy: 0.9877 - val_head_5_loss: 0.0397 - val_head_6_accuracy: 0.9872 - val_head_6_loss: 0.0398 - val_head_7_accuracy: 0.9877 - val_head_7_loss: 0.0398 - val_loss: 0.2785 - learning_rate: 3.3444e-05\n", "\n", "Epoch 86: LearningRateScheduler setting learning rate to 2.9217184840928013e-05.\n", "Epoch 86/100\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 180ms/step - head_1_accuracy: 0.9840 - head_1_loss: 0.0466 - head_2_accuracy: 0.9847 - head_2_loss: 0.0469 - head_3_accuracy: 0.9840 - head_3_loss: 0.0474 - head_4_accuracy: 0.9847 - head_4_loss: 0.0468 - head_5_accuracy: 0.9845 - head_5_loss: 0.0464 - head_6_accuracy: 0.9847 - head_6_loss: 0.0471 - head_7_accuracy: 0.9842 - head_7_loss: 0.0468 - loss: 0.3279\n", "Epoch 86: val_head_1_accuracy improved from 0.98770 to 0.98817, saving model to /content/drive/My Drive/Classification/multicp/models/ViT_UNet_MultiHead_best.keras\n", "\n", "Epoch 86: finished saving model to /content/drive/My Drive/Classification/multicp/models/ViT_UNet_MultiHead_best.keras\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m23s\u001b[0m 227ms/step - head_1_accuracy: 0.9838 - head_1_loss: 0.0480 - head_2_accuracy: 0.9841 - head_2_loss: 0.0482 - head_3_accuracy: 0.9841 - head_3_loss: 0.0482 - head_4_accuracy: 0.9845 - head_4_loss: 0.0479 - head_5_accuracy: 0.9841 - head_5_loss: 0.0479 - head_6_accuracy: 0.9843 - head_6_loss: 0.0482 - head_7_accuracy: 0.9841 - head_7_loss: 0.0482 - loss: 0.3400 - val_head_1_accuracy: 0.9882 - val_head_1_loss: 0.0390 - val_head_2_accuracy: 0.9879 - val_head_2_loss: 0.0391 - val_head_3_accuracy: 0.9882 - val_head_3_loss: 0.0393 - val_head_4_accuracy: 0.9879 - val_head_4_loss: 0.0394 - val_head_5_accuracy: 0.9879 - val_head_5_loss: 0.0389 - val_head_6_accuracy: 0.9879 - val_head_6_loss: 0.0389 - val_head_7_accuracy: 0.9879 - val_head_7_loss: 0.0390 - val_loss: 0.2725 - learning_rate: 2.9217e-05\n", "\n", "Epoch 87: LearningRateScheduler setting learning rate to 2.526326819325076e-05.\n", "Epoch 87/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 173ms/step - head_1_accuracy: 0.9803 - head_1_loss: 0.0486 - head_2_accuracy: 0.9808 - head_2_loss: 0.0479 - head_3_accuracy: 0.9807 - head_3_loss: 0.0484 - head_4_accuracy: 0.9807 - head_4_loss: 0.0487 - head_5_accuracy: 0.9811 - head_5_loss: 0.0479 - head_6_accuracy: 0.9809 - head_6_loss: 0.0480 - head_7_accuracy: 0.9807 - head_7_loss: 0.0482 - loss: 0.3377\n", "Epoch 87: val_head_1_accuracy did not improve from 0.98817\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m19s\u001b[0m 182ms/step - head_1_accuracy: 0.9820 - head_1_loss: 0.0458 - head_2_accuracy: 0.9828 - head_2_loss: 0.0455 - head_3_accuracy: 0.9825 - head_3_loss: 0.0456 - head_4_accuracy: 0.9827 - head_4_loss: 0.0463 - head_5_accuracy: 0.9824 - head_5_loss: 0.0457 - head_6_accuracy: 0.9824 - head_6_loss: 0.0457 - head_7_accuracy: 0.9821 - head_7_loss: 0.0458 - loss: 0.3234 - val_head_1_accuracy: 0.9882 - val_head_1_loss: 0.0389 - val_head_2_accuracy: 0.9875 - val_head_2_loss: 0.0392 - val_head_3_accuracy: 0.9872 - val_head_3_loss: 0.0393 - val_head_4_accuracy: 0.9875 - val_head_4_loss: 0.0394 - val_head_5_accuracy: 0.9879 - val_head_5_loss: 0.0389 - val_head_6_accuracy: 0.9875 - val_head_6_loss: 0.0390 - val_head_7_accuracy: 0.9877 - val_head_7_loss: 0.0391 - val_loss: 0.2733 - learning_rate: 2.5263e-05\n", "\n", "Epoch 88: LearningRateScheduler setting learning rate to 2.1586038491829064e-05.\n", "Epoch 88/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 167ms/step - head_1_accuracy: 0.9843 - head_1_loss: 0.0496 - head_2_accuracy: 0.9839 - head_2_loss: 0.0493 - head_3_accuracy: 0.9829 - head_3_loss: 0.0506 - head_4_accuracy: 0.9834 - head_4_loss: 0.0497 - head_5_accuracy: 0.9839 - head_5_loss: 0.0486 - head_6_accuracy: 0.9834 - head_6_loss: 0.0495 - head_7_accuracy: 0.9833 - head_7_loss: 0.0495 - loss: 0.3467\n", "Epoch 88: val_head_1_accuracy did not improve from 0.98817\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m18s\u001b[0m 176ms/step - head_1_accuracy: 0.9849 - head_1_loss: 0.0469 - head_2_accuracy: 0.9846 - head_2_loss: 0.0467 - head_3_accuracy: 0.9841 - head_3_loss: 0.0476 - head_4_accuracy: 0.9845 - head_4_loss: 0.0471 - head_5_accuracy: 0.9847 - head_5_loss: 0.0464 - head_6_accuracy: 0.9843 - head_6_loss: 0.0469 - head_7_accuracy: 0.9846 - head_7_loss: 0.0470 - loss: 0.3319 - val_head_1_accuracy: 0.9879 - val_head_1_loss: 0.0401 - val_head_2_accuracy: 0.9877 - val_head_2_loss: 0.0404 - val_head_3_accuracy: 0.9875 - val_head_3_loss: 0.0404 - val_head_4_accuracy: 0.9877 - val_head_4_loss: 0.0405 - val_head_5_accuracy: 0.9872 - val_head_5_loss: 0.0401 - val_head_6_accuracy: 0.9882 - val_head_6_loss: 0.0404 - val_head_7_accuracy: 0.9875 - val_head_7_loss: 0.0403 - val_loss: 0.2823 - learning_rate: 2.1586e-05\n", "\n", "Epoch 89: LearningRateScheduler setting learning rate to 1.8189198395266834e-05.\n", "Epoch 89/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 166ms/step - head_1_accuracy: 0.9824 - head_1_loss: 0.0514 - head_2_accuracy: 0.9834 - head_2_loss: 0.0509 - head_3_accuracy: 0.9829 - head_3_loss: 0.0505 - head_4_accuracy: 0.9844 - head_4_loss: 0.0504 - head_5_accuracy: 0.9840 - head_5_loss: 0.0501 - head_6_accuracy: 0.9841 - head_6_loss: 0.0508 - head_7_accuracy: 0.9831 - head_7_loss: 0.0509 - loss: 0.3551\n", "Epoch 89: val_head_1_accuracy improved from 0.98817 to 0.98863, saving model to /content/drive/My Drive/Classification/multicp/models/ViT_UNet_MultiHead_best.keras\n", "\n", "Epoch 89: finished saving model to /content/drive/My Drive/Classification/multicp/models/ViT_UNet_MultiHead_best.keras\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m20s\u001b[0m 198ms/step - head_1_accuracy: 0.9842 - head_1_loss: 0.0472 - head_2_accuracy: 0.9846 - head_2_loss: 0.0472 - head_3_accuracy: 0.9845 - head_3_loss: 0.0465 - head_4_accuracy: 0.9852 - head_4_loss: 0.0467 - head_5_accuracy: 0.9848 - head_5_loss: 0.0464 - head_6_accuracy: 0.9853 - head_6_loss: 0.0470 - head_7_accuracy: 0.9845 - head_7_loss: 0.0469 - loss: 0.3312 - val_head_1_accuracy: 0.9886 - val_head_1_loss: 0.0406 - val_head_2_accuracy: 0.9886 - val_head_2_loss: 0.0407 - val_head_3_accuracy: 0.9877 - val_head_3_loss: 0.0408 - val_head_4_accuracy: 0.9886 - val_head_4_loss: 0.0410 - val_head_5_accuracy: 0.9886 - val_head_5_loss: 0.0405 - val_head_6_accuracy: 0.9886 - val_head_6_loss: 0.0408 - val_head_7_accuracy: 0.9884 - val_head_7_loss: 0.0406 - val_loss: 0.2853 - learning_rate: 1.8189e-05\n", "\n", "Epoch 90: LearningRateScheduler setting learning rate to 1.5076168233603417e-05.\n", "Epoch 90/100\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 181ms/step - head_1_accuracy: 0.9824 - head_1_loss: 0.0520 - head_2_accuracy: 0.9824 - head_2_loss: 0.0521 - head_3_accuracy: 0.9825 - head_3_loss: 0.0515 - head_4_accuracy: 0.9829 - head_4_loss: 0.0514 - head_5_accuracy: 0.9831 - head_5_loss: 0.0519 - head_6_accuracy: 0.9830 - head_6_loss: 0.0512 - head_7_accuracy: 0.9829 - head_7_loss: 0.0520 - loss: 0.3621\n", "Epoch 90: val_head_1_accuracy did not improve from 0.98863\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m20s\u001b[0m 195ms/step - head_1_accuracy: 0.9832 - head_1_loss: 0.0485 - head_2_accuracy: 0.9831 - head_2_loss: 0.0488 - head_3_accuracy: 0.9834 - head_3_loss: 0.0482 - head_4_accuracy: 0.9838 - head_4_loss: 0.0479 - head_5_accuracy: 0.9838 - head_5_loss: 0.0482 - head_6_accuracy: 0.9838 - head_6_loss: 0.0481 - head_7_accuracy: 0.9835 - head_7_loss: 0.0485 - loss: 0.3414 - val_head_1_accuracy: 0.9886 - val_head_1_loss: 0.0394 - val_head_2_accuracy: 0.9884 - val_head_2_loss: 0.0395 - val_head_3_accuracy: 0.9884 - val_head_3_loss: 0.0397 - val_head_4_accuracy: 0.9882 - val_head_4_loss: 0.0398 - val_head_5_accuracy: 0.9889 - val_head_5_loss: 0.0394 - val_head_6_accuracy: 0.9886 - val_head_6_loss: 0.0395 - val_head_7_accuracy: 0.9886 - val_head_7_loss: 0.0394 - val_loss: 0.2767 - learning_rate: 1.5076e-05\n", "\n", "Epoch 91: LearningRateScheduler setting learning rate to 1.2250082564331516e-05.\n", "Epoch 91/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 173ms/step - head_1_accuracy: 0.9862 - head_1_loss: 0.0419 - head_2_accuracy: 0.9859 - head_2_loss: 0.0425 - head_3_accuracy: 0.9858 - head_3_loss: 0.0427 - head_4_accuracy: 0.9855 - head_4_loss: 0.0428 - head_5_accuracy: 0.9861 - head_5_loss: 0.0422 - head_6_accuracy: 0.9856 - head_6_loss: 0.0419 - head_7_accuracy: 0.9859 - head_7_loss: 0.0423 - loss: 0.2963\n", "Epoch 91: val_head_1_accuracy did not improve from 0.98863\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m19s\u001b[0m 181ms/step - head_1_accuracy: 0.9858 - head_1_loss: 0.0424 - head_2_accuracy: 0.9857 - head_2_loss: 0.0425 - head_3_accuracy: 0.9854 - head_3_loss: 0.0423 - head_4_accuracy: 0.9855 - head_4_loss: 0.0423 - head_5_accuracy: 0.9856 - head_5_loss: 0.0421 - head_6_accuracy: 0.9858 - head_6_loss: 0.0421 - head_7_accuracy: 0.9858 - head_7_loss: 0.0423 - loss: 0.2989 - val_head_1_accuracy: 0.9882 - val_head_1_loss: 0.0388 - val_head_2_accuracy: 0.9879 - val_head_2_loss: 0.0389 - val_head_3_accuracy: 0.9877 - val_head_3_loss: 0.0392 - val_head_4_accuracy: 0.9882 - val_head_4_loss: 0.0392 - val_head_5_accuracy: 0.9882 - val_head_5_loss: 0.0388 - val_head_6_accuracy: 0.9882 - val_head_6_loss: 0.0389 - val_head_7_accuracy: 0.9879 - val_head_7_loss: 0.0389 - val_loss: 0.2727 - learning_rate: 1.2250e-05\n", "\n", "Epoch 92: LearningRateScheduler setting learning rate to 9.713787016162943e-06.\n", "Epoch 92/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 166ms/step - head_1_accuracy: 0.9837 - head_1_loss: 0.0484 - head_2_accuracy: 0.9834 - head_2_loss: 0.0482 - head_3_accuracy: 0.9837 - head_3_loss: 0.0482 - head_4_accuracy: 0.9831 - head_4_loss: 0.0488 - head_5_accuracy: 0.9836 - head_5_loss: 0.0481 - head_6_accuracy: 0.9833 - head_6_loss: 0.0475 - head_7_accuracy: 0.9831 - head_7_loss: 0.0484 - loss: 0.3377\n", "Epoch 92: val_head_1_accuracy improved from 0.98863 to 0.98886, saving model to /content/drive/My Drive/Classification/multicp/models/ViT_UNet_MultiHead_best.keras\n", "\n", "Epoch 92: finished saving model to /content/drive/My Drive/Classification/multicp/models/ViT_UNet_MultiHead_best.keras\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 193ms/step - head_1_accuracy: 0.9851 - head_1_loss: 0.0455 - head_2_accuracy: 0.9844 - head_2_loss: 0.0454 - head_3_accuracy: 0.9848 - head_3_loss: 0.0454 - head_4_accuracy: 0.9841 - head_4_loss: 0.0459 - head_5_accuracy: 0.9848 - head_5_loss: 0.0454 - head_6_accuracy: 0.9846 - head_6_loss: 0.0453 - head_7_accuracy: 0.9841 - head_7_loss: 0.0456 - loss: 0.3216 - val_head_1_accuracy: 0.9889 - val_head_1_loss: 0.0384 - val_head_2_accuracy: 0.9891 - val_head_2_loss: 0.0386 - val_head_3_accuracy: 0.9886 - val_head_3_loss: 0.0387 - val_head_4_accuracy: 0.9886 - val_head_4_loss: 0.0387 - val_head_5_accuracy: 0.9889 - val_head_5_loss: 0.0383 - val_head_6_accuracy: 0.9889 - val_head_6_loss: 0.0386 - val_head_7_accuracy: 0.9884 - val_head_7_loss: 0.0384 - val_loss: 0.2693 - learning_rate: 9.7138e-06\n", "\n", "Epoch 93: LearningRateScheduler setting learning rate to 7.469835423722156e-06.\n", "Epoch 93/100\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 175ms/step - head_1_accuracy: 0.9849 - head_1_loss: 0.0470 - head_2_accuracy: 0.9844 - head_2_loss: 0.0478 - head_3_accuracy: 0.9849 - head_3_loss: 0.0475 - head_4_accuracy: 0.9852 - head_4_loss: 0.0478 - head_5_accuracy: 0.9844 - head_5_loss: 0.0474 - head_6_accuracy: 0.9857 - head_6_loss: 0.0470 - head_7_accuracy: 0.9845 - head_7_loss: 0.0477 - loss: 0.3322\n", "Epoch 93: val_head_1_accuracy did not improve from 0.98886\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m21s\u001b[0m 203ms/step - head_1_accuracy: 0.9854 - head_1_loss: 0.0438 - head_2_accuracy: 0.9851 - head_2_loss: 0.0443 - head_3_accuracy: 0.9851 - head_3_loss: 0.0439 - head_4_accuracy: 0.9853 - head_4_loss: 0.0440 - head_5_accuracy: 0.9852 - head_5_loss: 0.0437 - head_6_accuracy: 0.9855 - head_6_loss: 0.0440 - head_7_accuracy: 0.9850 - head_7_loss: 0.0440 - loss: 0.3109 - val_head_1_accuracy: 0.9879 - val_head_1_loss: 0.0397 - val_head_2_accuracy: 0.9882 - val_head_2_loss: 0.0398 - val_head_3_accuracy: 0.9879 - val_head_3_loss: 0.0399 - val_head_4_accuracy: 0.9879 - val_head_4_loss: 0.0399 - val_head_5_accuracy: 0.9879 - val_head_5_loss: 0.0396 - val_head_6_accuracy: 0.9882 - val_head_6_loss: 0.0398 - val_head_7_accuracy: 0.9877 - val_head_7_loss: 0.0397 - val_loss: 0.2786 - learning_rate: 7.4698e-06\n", "\n", "Epoch 94: LearningRateScheduler setting learning rate to 5.520487256051157e-06.\n", "Epoch 94/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 169ms/step - head_1_accuracy: 0.9853 - head_1_loss: 0.0467 - head_2_accuracy: 0.9843 - head_2_loss: 0.0470 - head_3_accuracy: 0.9849 - head_3_loss: 0.0474 - head_4_accuracy: 0.9848 - head_4_loss: 0.0475 - head_5_accuracy: 0.9846 - head_5_loss: 0.0473 - head_6_accuracy: 0.9846 - head_6_loss: 0.0475 - head_7_accuracy: 0.9843 - head_7_loss: 0.0478 - loss: 0.3313\n", "Epoch 94: val_head_1_accuracy did not improve from 0.98886\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m18s\u001b[0m 177ms/step - head_1_accuracy: 0.9860 - head_1_loss: 0.0436 - head_2_accuracy: 0.9856 - head_2_loss: 0.0440 - head_3_accuracy: 0.9858 - head_3_loss: 0.0438 - head_4_accuracy: 0.9858 - head_4_loss: 0.0441 - head_5_accuracy: 0.9857 - head_5_loss: 0.0439 - head_6_accuracy: 0.9857 - head_6_loss: 0.0439 - head_7_accuracy: 0.9858 - head_7_loss: 0.0441 - loss: 0.3104 - val_head_1_accuracy: 0.9884 - val_head_1_loss: 0.0388 - val_head_2_accuracy: 0.9886 - val_head_2_loss: 0.0390 - val_head_3_accuracy: 0.9884 - val_head_3_loss: 0.0390 - val_head_4_accuracy: 0.9882 - val_head_4_loss: 0.0391 - val_head_5_accuracy: 0.9884 - val_head_5_loss: 0.0388 - val_head_6_accuracy: 0.9884 - val_head_6_loss: 0.0390 - val_head_7_accuracy: 0.9879 - val_head_7_loss: 0.0388 - val_loss: 0.2723 - learning_rate: 5.5205e-06\n", "\n", "Epoch 95: LearningRateScheduler setting learning rate to 3.867705341515533e-06.\n", "Epoch 95/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 167ms/step - head_1_accuracy: 0.9833 - head_1_loss: 0.0458 - head_2_accuracy: 0.9841 - head_2_loss: 0.0453 - head_3_accuracy: 0.9836 - head_3_loss: 0.0459 - head_4_accuracy: 0.9842 - head_4_loss: 0.0458 - head_5_accuracy: 0.9838 - head_5_loss: 0.0455 - head_6_accuracy: 0.9838 - head_6_loss: 0.0454 - head_7_accuracy: 0.9837 - head_7_loss: 0.0456 - loss: 0.3192\n", "Epoch 95: val_head_1_accuracy improved from 0.98886 to 0.98933, saving model to /content/drive/My Drive/Classification/multicp/models/ViT_UNet_MultiHead_best.keras\n", "\n", "Epoch 95: finished saving model to /content/drive/My Drive/Classification/multicp/models/ViT_UNet_MultiHead_best.keras\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m20s\u001b[0m 192ms/step - head_1_accuracy: 0.9840 - head_1_loss: 0.0436 - head_2_accuracy: 0.9843 - head_2_loss: 0.0440 - head_3_accuracy: 0.9842 - head_3_loss: 0.0440 - head_4_accuracy: 0.9850 - head_4_loss: 0.0439 - head_5_accuracy: 0.9844 - head_5_loss: 0.0436 - head_6_accuracy: 0.9841 - head_6_loss: 0.0439 - head_7_accuracy: 0.9846 - head_7_loss: 0.0440 - loss: 0.3101 - val_head_1_accuracy: 0.9893 - val_head_1_loss: 0.0388 - val_head_2_accuracy: 0.9889 - val_head_2_loss: 0.0391 - val_head_3_accuracy: 0.9889 - val_head_3_loss: 0.0391 - val_head_4_accuracy: 0.9886 - val_head_4_loss: 0.0392 - val_head_5_accuracy: 0.9889 - val_head_5_loss: 0.0388 - val_head_6_accuracy: 0.9889 - val_head_6_loss: 0.0390 - val_head_7_accuracy: 0.9889 - val_head_7_loss: 0.0388 - val_loss: 0.2726 - learning_rate: 3.8677e-06\n", "\n", "Epoch 96: LearningRateScheduler setting learning rate to 2.5131538914029374e-06.\n", "Epoch 96/100\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 178ms/step - head_1_accuracy: 0.9832 - head_1_loss: 0.0484 - head_2_accuracy: 0.9824 - head_2_loss: 0.0481 - head_3_accuracy: 0.9826 - head_3_loss: 0.0476 - head_4_accuracy: 0.9833 - head_4_loss: 0.0479 - head_5_accuracy: 0.9832 - head_5_loss: 0.0477 - head_6_accuracy: 0.9837 - head_6_loss: 0.0477 - head_7_accuracy: 0.9836 - head_7_loss: 0.0481 - loss: 0.3355\n", "Epoch 96: val_head_1_accuracy did not improve from 0.98933\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m21s\u001b[0m 205ms/step - head_1_accuracy: 0.9844 - head_1_loss: 0.0461 - head_2_accuracy: 0.9840 - head_2_loss: 0.0460 - head_3_accuracy: 0.9843 - head_3_loss: 0.0455 - head_4_accuracy: 0.9850 - head_4_loss: 0.0459 - head_5_accuracy: 0.9848 - head_5_loss: 0.0457 - head_6_accuracy: 0.9851 - head_6_loss: 0.0454 - head_7_accuracy: 0.9846 - head_7_loss: 0.0459 - loss: 0.3236 - val_head_1_accuracy: 0.9884 - val_head_1_loss: 0.0386 - val_head_2_accuracy: 0.9886 - val_head_2_loss: 0.0388 - val_head_3_accuracy: 0.9884 - val_head_3_loss: 0.0388 - val_head_4_accuracy: 0.9884 - val_head_4_loss: 0.0389 - val_head_5_accuracy: 0.9884 - val_head_5_loss: 0.0385 - val_head_6_accuracy: 0.9884 - val_head_6_loss: 0.0388 - val_head_7_accuracy: 0.9882 - val_head_7_loss: 0.0386 - val_loss: 0.2708 - learning_rate: 2.5132e-06\n", "\n", "Epoch 97: LearningRateScheduler setting learning rate to 1.4581968242032775e-06.\n", "Epoch 97/100\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 167ms/step - head_1_accuracy: 0.9850 - head_1_loss: 0.0446 - head_2_accuracy: 0.9845 - head_2_loss: 0.0448 - head_3_accuracy: 0.9842 - head_3_loss: 0.0445 - head_4_accuracy: 0.9847 - head_4_loss: 0.0448 - head_5_accuracy: 0.9851 - head_5_loss: 0.0446 - head_6_accuracy: 0.9853 - head_6_loss: 0.0446 - head_7_accuracy: 0.9847 - head_7_loss: 0.0448 - loss: 0.3127\n", "Epoch 97: val_head_1_accuracy did not improve from 0.98933\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m18s\u001b[0m 179ms/step - head_1_accuracy: 0.9853 - head_1_loss: 0.0449 - head_2_accuracy: 0.9854 - head_2_loss: 0.0452 - head_3_accuracy: 0.9851 - head_3_loss: 0.0448 - head_4_accuracy: 0.9848 - head_4_loss: 0.0452 - head_5_accuracy: 0.9850 - head_5_loss: 0.0449 - head_6_accuracy: 0.9852 - head_6_loss: 0.0450 - head_7_accuracy: 0.9851 - head_7_loss: 0.0456 - loss: 0.3188 - val_head_1_accuracy: 0.9893 - val_head_1_loss: 0.0382 - val_head_2_accuracy: 0.9891 - val_head_2_loss: 0.0384 - val_head_3_accuracy: 0.9891 - val_head_3_loss: 0.0385 - val_head_4_accuracy: 0.9891 - val_head_4_loss: 0.0385 - val_head_5_accuracy: 0.9891 - val_head_5_loss: 0.0382 - val_head_6_accuracy: 0.9889 - val_head_6_loss: 0.0384 - val_head_7_accuracy: 0.9891 - val_head_7_loss: 0.0382 - val_loss: 0.2680 - learning_rate: 1.4582e-06\n", "\n", "Epoch 98: LearningRateScheduler setting learning rate to 7.038963922582963e-07.\n", "Epoch 98/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 167ms/step - head_1_accuracy: 0.9837 - head_1_loss: 0.0483 - head_2_accuracy: 0.9841 - head_2_loss: 0.0482 - head_3_accuracy: 0.9837 - head_3_loss: 0.0486 - head_4_accuracy: 0.9835 - head_4_loss: 0.0496 - head_5_accuracy: 0.9838 - head_5_loss: 0.0482 - head_6_accuracy: 0.9836 - head_6_loss: 0.0485 - head_7_accuracy: 0.9837 - head_7_loss: 0.0491 - loss: 0.3405\n", "Epoch 98: val_head_1_accuracy did not improve from 0.98933\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m20s\u001b[0m 175ms/step - head_1_accuracy: 0.9841 - head_1_loss: 0.0448 - head_2_accuracy: 0.9846 - head_2_loss: 0.0448 - head_3_accuracy: 0.9844 - head_3_loss: 0.0450 - head_4_accuracy: 0.9843 - head_4_loss: 0.0454 - head_5_accuracy: 0.9845 - head_5_loss: 0.0447 - head_6_accuracy: 0.9844 - head_6_loss: 0.0450 - head_7_accuracy: 0.9844 - head_7_loss: 0.0457 - loss: 0.3185 - val_head_1_accuracy: 0.9893 - val_head_1_loss: 0.0381 - val_head_2_accuracy: 0.9893 - val_head_2_loss: 0.0384 - val_head_3_accuracy: 0.9891 - val_head_3_loss: 0.0385 - val_head_4_accuracy: 0.9891 - val_head_4_loss: 0.0385 - val_head_5_accuracy: 0.9893 - val_head_5_loss: 0.0381 - val_head_6_accuracy: 0.9893 - val_head_6_loss: 0.0384 - val_head_7_accuracy: 0.9893 - val_head_7_loss: 0.0382 - val_loss: 0.2677 - learning_rate: 7.0390e-07\n", "\n", "Epoch 99: LearningRateScheduler setting learning rate to 2.510121121636345e-07.\n", "Epoch 99/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 167ms/step - head_1_accuracy: 0.9844 - head_1_loss: 0.0441 - head_2_accuracy: 0.9851 - head_2_loss: 0.0432 - head_3_accuracy: 0.9852 - head_3_loss: 0.0443 - head_4_accuracy: 0.9848 - head_4_loss: 0.0435 - head_5_accuracy: 0.9849 - head_5_loss: 0.0437 - head_6_accuracy: 0.9851 - head_6_loss: 0.0442 - head_7_accuracy: 0.9845 - head_7_loss: 0.0439 - loss: 0.3069\n", "Epoch 99: val_head_1_accuracy did not improve from 0.98933\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m18s\u001b[0m 175ms/step - head_1_accuracy: 0.9851 - head_1_loss: 0.0422 - head_2_accuracy: 0.9857 - head_2_loss: 0.0418 - head_3_accuracy: 0.9859 - head_3_loss: 0.0426 - head_4_accuracy: 0.9856 - head_4_loss: 0.0417 - head_5_accuracy: 0.9854 - head_5_loss: 0.0419 - head_6_accuracy: 0.9855 - head_6_loss: 0.0425 - head_7_accuracy: 0.9855 - head_7_loss: 0.0420 - loss: 0.2975 - val_head_1_accuracy: 0.9893 - val_head_1_loss: 0.0381 - val_head_2_accuracy: 0.9893 - val_head_2_loss: 0.0384 - val_head_3_accuracy: 0.9891 - val_head_3_loss: 0.0384 - val_head_4_accuracy: 0.9891 - val_head_4_loss: 0.0385 - val_head_5_accuracy: 0.9893 - val_head_5_loss: 0.0381 - val_head_6_accuracy: 0.9893 - val_head_6_loss: 0.0383 - val_head_7_accuracy: 0.9893 - val_head_7_loss: 0.0382 - val_loss: 0.2675 - learning_rate: 2.5101e-07\n", "\n", "Epoch 100: LearningRateScheduler setting learning rate to 1e-07.\n", "Epoch 100/100\n", "\u001b[1m101/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u2501\u001b[0m \u001b[1m0s\u001b[0m 166ms/step - head_1_accuracy: 0.9852 - head_1_loss: 0.0444 - head_2_accuracy: 0.9858 - head_2_loss: 0.0444 - head_3_accuracy: 0.9856 - head_3_loss: 0.0442 - head_4_accuracy: 0.9858 - head_4_loss: 0.0442 - head_5_accuracy: 0.9861 - head_5_loss: 0.0445 - head_6_accuracy: 0.9859 - head_6_loss: 0.0441 - head_7_accuracy: 0.9851 - head_7_loss: 0.0447 - loss: 0.3105\n", "Epoch 100: val_head_1_accuracy did not improve from 0.98933\n", "\u001b[1m102/102\u001b[0m \u001b[32m\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u001b[0m\u001b[37m\u001b[0m \u001b[1m18s\u001b[0m 175ms/step - head_1_accuracy: 0.9852 - head_1_loss: 0.0426 - head_2_accuracy: 0.9855 - head_2_loss: 0.0430 - head_3_accuracy: 0.9853 - head_3_loss: 0.0427 - head_4_accuracy: 0.9854 - head_4_loss: 0.0429 - head_5_accuracy: 0.9858 - head_5_loss: 0.0428 - head_6_accuracy: 0.9851 - head_6_loss: 0.0430 - head_7_accuracy: 0.9850 - head_7_loss: 0.0432 - loss: 0.3032 - val_head_1_accuracy: 0.9893 - val_head_1_loss: 0.0381 - val_head_2_accuracy: 0.9893 - val_head_2_loss: 0.0384 - val_head_3_accuracy: 0.9891 - val_head_3_loss: 0.0385 - val_head_4_accuracy: 0.9891 - val_head_4_loss: 0.0385 - val_head_5_accuracy: 0.9893 - val_head_5_loss: 0.0381 - val_head_6_accuracy: 0.9893 - val_head_6_loss: 0.0384 - val_head_7_accuracy: 0.9891 - val_head_7_loss: 0.0382 - val_loss: 0.2678 - learning_rate: 1.0000e-07\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ "/usr/local/lib/python3.12/dist-packages/keras/src/layers/layer.py:424: UserWarning: `build()` was called on layer 'vi_t__patch_encoder', however the layer does not have a `build()` method implemented and it looks like it has unbuilt state. This will cause the layer to be marked as built, despite not being actually built, which may cause failures down the line. Make sure to implement a proper `build()` method.\n", " warnings.warn(\n", "/usr/local/lib/python3.12/dist-packages/keras/src/layers/layer.py:424: UserWarning: `build()` was called on layer 'vi_t__class__token__norm', however the layer does not have a `build()` method implemented and it looks like it has unbuilt state. This will cause the layer to be marked as built, despite not being actually built, which may cause failures down the line. Make sure to implement a proper `build()` method.\n", " warnings.warn(\n" ] }, { "output_type": "display_data", "data": { "text/plain": [ "
" ], "image/png": "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\n" }, "metadata": {} }, { "output_type": "stream", "name": "stdout", "text": [ "Saved training workbook to /content/drive/My Drive/Classification/multicp/models/model_training_multihead_results.xlsx\n", "Saved model registry to /content/drive/My Drive/Classification/multicp/models/model_registry_multihead.json\n" ] }, { "output_type": "execute_result", "data": { "text/plain": [ " model_name best_model_path \\\n", "0 AlexNet_CNN_MultiHead /content/drive/My Drive/Classification/multicp... \n", "1 GFNet_MultiHead /content/drive/My Drive/Classification/multicp... \n", "2 ViT_UNet_MultiHead /content/drive/My Drive/Classification/multicp... \n", "\n", " final_model_path test_accuracy \\\n", "0 /content/drive/My Drive/Classification/multicp... 0.995592 \n", "1 /content/drive/My Drive/Classification/multicp... 0.999072 \n", "2 /content/drive/My Drive/Classification/multicp... 0.988631 \n", "\n", " cohen_kappa training_time_sec total_params trainable_params \\\n", "0 0.994022 837.408769 34010385 34010385 \n", "1 0.998741 2455.998824 25304841 25304841 \n", "2 0.984588 2106.346367 16180553 16180553 \n", "\n", " non_trainable_params \n", "0 0 \n", "1 0 \n", "2 0 " ], "text/html": [ "\n", "
\n", "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
model_namebest_model_pathfinal_model_pathtest_accuracycohen_kappatraining_time_sectotal_paramstrainable_paramsnon_trainable_params
0AlexNet_CNN_MultiHead/content/drive/My Drive/Classification/multicp.../content/drive/My Drive/Classification/multicp...0.9955920.994022837.40876934010385340103850
1GFNet_MultiHead/content/drive/My Drive/Classification/multicp.../content/drive/My Drive/Classification/multicp...0.9990720.9987412455.99882425304841253048410
2ViT_UNet_MultiHead/content/drive/My Drive/Classification/multicp.../content/drive/My Drive/Classification/multicp...0.9886310.9845882106.34636716180553161805530
\n", "
\n", "
\n", "\n", "
\n", " \n", "\n", " \n", "\n", " \n", "
\n", "\n", "\n", "
\n", " \n", " \n", " \n", "
\n", "\n", "
\n", "
\n" ], "application/vnd.google.colaboratory.intrinsic+json": { "type": "dataframe", "variable_name": "summary_df", "summary": "{\n \"name\": \"summary_df\",\n \"rows\": 3,\n \"fields\": [\n {\n \"column\": \"model_name\",\n \"properties\": {\n \"dtype\": \"string\",\n \"num_unique_values\": 3,\n \"samples\": [\n \"AlexNet_CNN_MultiHead\",\n \"GFNet_MultiHead\",\n \"ViT_UNet_MultiHead\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"best_model_path\",\n \"properties\": {\n \"dtype\": \"string\",\n \"num_unique_values\": 3,\n \"samples\": [\n \"/content/drive/My Drive/Classification/multicp/models/AlexNet_CNN_MultiHead_best.keras\",\n \"/content/drive/My Drive/Classification/multicp/models/GFNet_MultiHead_best.keras\",\n \"/content/drive/My Drive/Classification/multicp/models/ViT_UNet_MultiHead_best.keras\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"final_model_path\",\n \"properties\": {\n \"dtype\": \"string\",\n \"num_unique_values\": 3,\n \"samples\": [\n \"/content/drive/My Drive/Classification/multicp/models/AlexNet_CNN_MultiHead_final.keras\",\n \"/content/drive/My Drive/Classification/multicp/models/GFNet_MultiHead_final.keras\",\n \"/content/drive/My Drive/Classification/multicp/models/ViT_UNet_MultiHead_final.keras\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"test_accuracy\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.005316213103197044,\n \"min\": 0.988631090487239,\n \"max\": 0.9990719257540603,\n \"num_unique_values\": 3,\n \"samples\": [\n 0.9955916473317865,\n 0.9990719257540603,\n 0.988631090487239\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"cohen_kappa\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.007206194558262373,\n \"min\": 0.9845884524241899,\n \"max\": 0.9987414976265843,\n \"num_unique_values\": 3,\n \"samples\": [\n 0.9940221351087983,\n 0.9987414976265843,\n 0.9845884524241899\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"training_time_sec\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 851.6937277922311,\n \"min\": 837.4087686538696,\n \"max\": 2455.9988238811493,\n \"num_unique_values\": 3,\n \"samples\": [\n 837.4087686538696,\n 2455.9988238811493,\n 2106.346366882324\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"total_params\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 8915735,\n \"min\": 16180553,\n \"max\": 34010385,\n \"num_unique_values\": 3,\n \"samples\": [\n 34010385,\n 25304841,\n 16180553\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"trainable_params\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 8915735,\n \"min\": 16180553,\n \"max\": 34010385,\n \"num_unique_values\": 3,\n \"samples\": [\n 34010385,\n 25304841,\n 16180553\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"non_trainable_params\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0,\n \"min\": 0,\n \"max\": 0,\n \"num_unique_values\": 1,\n \"samples\": [\n 0\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n }\n ]\n}" } }, "metadata": {}, "execution_count": 19 }, { "output_type": "display_data", "data": { "text/plain": [ "
" ], "image/png": "iVBORw0KGgoAAAANSUhEUgAACAUAAAMsCAYAAAAm54nDAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzs3Xd4VMUax/FfekIgBQgJvSd0CD2U0AJIEVR6iSAioKCAFewFFRBFmoDSpYP0YqELKr0X6SWUEEp6z+79I7KXNSGAJNmwfD/Pc5/rzs7MeWf2JGzOec+MjdFoNAoAAAAAAAAAAAAAAFgdW0sHAAAAAAAAAAAAAAAAsgZJAQAAAAAAAAAAAAAAWCmSAgAAAAAAAAAAAAAAsFIkBQAAAAAAAAAAAAAAYKVICgAAAAAAAAAAAAAAwEqRFAAAAAAAAAAAAAAAgJUiKQAAAAAAAAAAAAAAACtFUgAAAAAAAAAAAAAAAFaKpAAAAAAAAAAAAAAAAKwUSQEAcrydO3fKz89PO3futFgMfn5+mjBhglnZoUOH1LVrV1WrVk1+fn46fvy4JkyYID8/v2yPLyQkRH5+flq2bFm2HxsAAAAAAOC/WrFihZ566ilVrFhRNWvWzPT+LXWtJqfLCdfbAABA9rG3dAAA8DhKSkrSkCFD5OjoqOHDh8vZ2VmFChXK8uOuXr1aN2/eVO/evbP8WNZq37592rFjh3r16iU3NzdLhwMAAAAAwBPrzJkzGj58uBo2bKh+/frJ2dnZ0iE9lrheBAAA7sfGaDQaLR0EAGRk586dev755zVnzhzVqVPHIjEkJCTIzs5O9vapuVRnzpxR69atNWLECHXq1MlULzk5WSkpKXJycsqSOPr3769Tp05p06ZNZuVGo1GJiYmyt7eXnZ1dlhzbWkyfPl2jR4/Wxo0bVaRIEUuHAwAAAADAE2vBggX6+OOP9euvv6p48eJZcoysvlaTE9zrelFGDAaDkpKS5ODgIFtbFhQGAMDa8a89ADwAJycnU0KAJN26dUuSlCdPHrN69vb2Fvkj08bGRk5OTjkmISAuLs7SIaQRGxtr6RAAAAAAAMBdbt68KSnt9ZXMZKlrNTlVQkKCDAaDbG1t5eTkREIAAABPCP7FB2BxoaGhevfdd9WgQQNVqlRJTZs21UcffaTExMR7ttmzZ49ee+01NW7cWJUqVVKjRo30xRdfKD4+3qxeWFiYhg8frsDAQFWqVEkNGjTQyy+/rJCQEFOdw4cP68UXX1SdOnVUpUoVNW3aVMOHDzfrx8/PTxMmTJAkDRs2TD179pQkDR48WH5+fgoODpZ0733qVq5cqY4dO6pq1aqqVauWevTooe3bt5ve37Bhg/r162eag6CgIE2aNEkpKSmmOsHBwdqyZYsuX74sPz8/+fn5qWnTppKkkJAQ+fn5admyZWbH/fPPP9W9e3dVq1ZNNWvW1Msvv6wzZ86Y1bkT84ULFzRs2DDVrFlTNWrU0PDhwx/o5n5wcLDatm2rI0eOqEePHqpataq++eYbSVJiYqLGjx+v5s2bmz6n0aNHp/ls/fz89Omnn2rVqlVq2bKlKleurOeee067d+9Oc7xjx46pb9++ql69uvz9/dWrVy8dOHDArM6yZcvk5+enXbt26eOPP1ZAQIAaNWqkCRMmaPTo0ZKkZs2amebx7vMBAAAAAIAn0YNcn7l06ZJee+011a5dW1WrVlXnzp21ZcsWs37u7FW/bt06TZ48WYGBgapcubJ69eqlCxcumOo1bdrUdK0lICDA7NrL3f99t6ZNm2rYsGGm10lJSZo4caJatGihypUrq06dOurWrZt27NhhqpPetZrk5GRNmjRJQUFBprF+8803aa5XNG3aVP3799eePXvUsWNHVa5cWc2aNdOKFSvuO593rtVMnz5d8+bNU7NmzVS1alX16dNHV69eldFo1KRJkxQYGKgqVaro5ZdfVnh4uFkfj3q96M5nsXbtWo0dO1YNGzZU1apVFR0dbXpv586dklJXxaxSpYrefvttsxj27Nmj8uXL66uvvrrvmAEAQM5lf/8qAJB1QkND1bFjR0VFRalz584qVaqUQkND9csvvyg+Pl6Ojo7ptvv5558VHx+vbt26ycPDQ4cOHdLcuXN17do1jR8/3lTv1Vdf1enTp9WzZ08VLlxYt27d0o4dO3T16lUVKVJEN2/e1IsvvihPT0/169dPbm5uCgkJ0W+//XbPmLt06SJvb29NmTJFwcHBqly5svLnz3/P+hMnTtSECRPk7++v1157TQ4ODjp48KD++usvNWjQQJK0fPly5cqVSy+88IJy5cqlv/76S+PHj1d0dLTeeecdSdKAAQMUFRWla9eumZIWXF1d73ncP/74Qy+99JKKFCmiQYMGKT4+XnPnzlW3bt20bNmyNEvnDxkyREWKFNHrr7+uY8eOacmSJcqbN6/eeuutex7jjvDwcL300ktq06aN2rVrp3z58slgMOjll1/W3r171blzZ5UuXVonT57U7Nmzdf78eX333XdmfezevVvr1q1TcHCwHB0dtWDBAvXt21dLliyRr6+vJOnUqVPq0aOHXF1d1bdvX9nb22vRokUKDg7W3LlzVbVqVbM+P/nkE+XNm1cDBw5UbGysAgMDdf78ea1Zs0bDhw+Xp6enJClv3rz3HSMAAAAAANbqQa7P3LhxQ127dlVcXJyCg4Pl6emp5cuX6+WXXzY9EHC3H374QTY2NurTp4+io6M1bdo0vfnmm1qyZIkk6d1339WKFSv022+/6eOPP1auXLnSfdAiIxMnTtTUqVPVqVMnValSRdHR0Tpy5IiOHj2q+vXr37Pd+++/r+XLl6tly5Z64YUXdOjQIU2dOlVnzpzRpEmTzOpeuHBBgwcPVseOHfXss8/qp59+0rBhw1SxYkWVLVv2vjGuXr1aSUlJCg4OVnh4uKZNm6YhQ4aobt262rlzp1566SVduHBBc+fO1ahRo/Tll1+a2mbW9aLvvvtODg4OevHFF5WYmCgHB4c0cZYuXVqDBw/W6NGj1bJlSzVr1kyxsbEaPny4SpUqpcGDB993rAAAIAczAoAFvf3228Zy5coZDx06lOY9g8FgNBqNxr/++svo6+tr/Ouvv0zvxcXFpak/depUo5+fn/Hy5ctGo9FojIiIMPr6+hqnTZt2z+P/9ttvRl9f33SPfzdfX1/j+PHjTa/vxLR+/XqzeuPHjzf6+vqaXp8/f95Yrlw548CBA40pKSnpju9e4/nggw+MVatWNSYkJJjK+vXrZ2zSpEmaupcuXTL6+voaf/rpJ1NZ+/btjQEBAcbbt2+byo4fP24sV66c8e23304T8/Dhw836HDhwoLF27dppjvVvPXv2NPr6+hoXLFhgVr5ixQpjuXLljLt37zYrX7BggdHX19e4d+9eU5mvr6/R19fXePjwYVPZ5cuXjZUrVzYOHDjQVPbKK68YK1asaLx48aKpLDQ01Ojv72/s0aOHqeynn34y+vr6Grt162ZMTk42O/60adOMvr6+xkuXLt13bAAAAAAAPAke5PrM559/bvT19TX7Oz86OtrYtGlTY5MmTUzXPe5cM2nVqpXZNY3Zs2cbfX19jX///bep7M41iZs3b5od89/XYe5o0qSJ8Z133jG9bteunbFfv34Zju3f12qOHz9u9PX1Nb733ntm9UaOHGn09fU1/vnnn2bH+/eYb968aaxUqZJx5MiRGR73zrWaunXrGiMjI03lX3/9tdHX19fYrl07Y1JSkqn89ddfN1asWNFszh71etGdz6JZs2Zp+krveltKSoqxW7duxnr16hlv3bpl/OSTT4wVKlS473UzAACQ87F9AACLMRgM2rBhg5o0aaLKlSuned/GxuaebZ2dnU3/HRsbq1u3bsnf319Go1HHjh0z1XFwcNCuXbsUERGRbj939qzbsmWLkpKSHmU46dqwYYMMBoMGDhyYZo+2u8d393iio6N169Yt1axZU3FxcTp79uxDH/f69es6fvy4nn32WXl4eJjKy5Urp3r16mnr1q1p2nTt2tXsdc2aNRUeHq7o6Oj7Hs/R0VHPPfecWdnPP/+s0qVLq1SpUrp165bpf3Xr1pUk0/J0d/j7+6tSpUqm14UKFVKzZs20fft2paSkKCUlRTt27FBQUJCKFi1qqlegQAG1bdtWe/fuTRNr586dZWdnd9/4AQAAAAB4Uj3o9ZmtW7eqSpUqqlmzpuk9V1dXdenSRZcvX9bp06fN2j333HNmK0DeaXfp0qVMi93NzU2nTp3S+fPnH7jNnWsiL7zwgll5nz59zN6/o0yZMmZjzps3r0qWLPnA43jqqadM158kqUqVKpKkdu3ayd7e3qw8KSlJoaGhprLMul70zDPPmPV1L7a2tho5cqRiY2P10ksvaf78+erXr1+65wUAAHi8sH0AAIu5deuWoqOjH2iptX+7cuWKxo8fr02bNqW54X/nxrCjo6PefPNNjRo1SvXr11fVqlXVuHFjPfPMM/Ly8pIk1a5dWy1bttTEiRM1a9Ys1a5dW0FBQXr66afvuXXBw7h48aJsbW1VunTpDOudOnVK3377rf766680N7ajoqIe+rhXrlyRJJUsWTLNe6VLl9b27dsVGxurXLlymcoLFSpkVs/NzU2SFBERody5c2d4PG9v7zTzdeHCBZ05c0YBAQHptrl586bZ6+LFi6epU6JECcXFxenWrVuSpLi4uHuOyWAw6OrVq2bn07+3SAAAAAAAAOYe9PrMlStX0mzbJ0mlSpUyvX9n+z/p3tcZIiMjHzVkk9dee02vvPKKWrZsKV9fXzVo0EDt27dXuXLl7tnm8uXLsrW1VbFixczKvby85ObmpsuXL5uVFyxYME0f7u7u93wA5d/+3f5OgsC9yiMiIkwPQ2TW9aKHuT5SrFgxDRo0SKNHj5avr69eeeWVB24LAAByLpICADx2UlJS9MILLygiIkJ9+/ZVqVKllCtXLoWGhmrYsGEyGAymur1791bTpk21YcMGbd++XePGjdP333+v2bNnq0KFCrKxsdH48eN14MABbd68Wb///rveffddzZw5U4sWLUqzB1tWiIyMVM+ePZU7d2699tprKlasmJycnHT06FGNGTPGbDxZ6d8rGdxhNBrv2za9bHODwSBfX1/Tfnb/5uPj83AB/gdOTk5ZfgwAAAAAAJDWo1xnuJeUlBSz17Vq1dJvv/2mjRs3aseOHVq6dKlmz56tTz75RJ06dcqwr4xWqLzbo65AeK/295ufzLxe9CCrBNxtx44dklJXogwPDzc9XAMAAB5fJAUAsJi8efMqd+7cOnXq1EO1O3nypM6fP69Ro0bpmWeeMZXf+YPl34oVK6Y+ffqoT58+On/+vJ555hnNmDFDY8aMMdWpVq2aqlWrpqFDh2r16tV68803tW7duvv+AXk/xYoVk8Fg0JkzZ1S+fPl06+zatUvh4eGaOHGiatWqZSoPCQlJU/dB/2C9k41/7ty5NO+dPXtWnp6eZqsEZIVixYrpxIkTCggIeKC4L1y4kKbs/PnzcnFxUd68eSVJLi4u9xyTra1tutn7//agcwgAAAAAwJPgQa/PFCpU6J5/k995P7O4u7unWVEgMTFRYWFhaep6eHioQ4cO6tChg2JiYtSzZ09NmDDhntd0ChcuLIPBoAsXLpit7Hjjxg1FRkaqcOHCmTaOR5EV14sexIIFC7Rjxw4NHTpUU6dO1YcffqjJkydnWv8AAMAy0k9HBIBsYGtrq6CgIG3evFmHDx9O8/69MsfvZFLf/b7RaNScOXPM6sXFxSkhIcGsrFixYnJ1dVViYqKk1CXZ/n2cOzfv79R5FEFBQbK1tdWkSZPSZHDfOW5640lMTNT8+fPT9Ofi4vJAy8MVKFBA5cuX14oVK8z+iD558qR27NihRo0a/afxPIxWrVopNDRUixcvTvNefHy8YmNjzcr279+vo0ePml5fvXpVGzduVP369WVnZyc7OzvVr19fGzduNPsD+MaNG1qzZo1q1Khx320OpNQ5lP7btgwAAAAAAFibB70+06hRIx06dEj79+83vRcbG6vFixercOHCKlOmTKbFVLRoUe3Zs8esbPHixWlWCrh9+7bZa1dXVxUrVizDazp3ronMnj3brHzmzJlm71taVlwvup9Lly5p9OjRatmypQYMGKB33nlHmzZt0ooVKx65bwAAYFmsFADAol5//XXt2LFDwcHB6ty5s0qXLq2wsDD9/PPPmj9/vmm/ubuVKlVKxYoV06hRoxQaGqrcuXPrl19+SZNBfv78efXu3VtPPfWUypQpIzs7O23YsEE3btxQmzZtJEnLly/XggULFBQUpGLFiikmJkaLFy9W7ty5FRgY+MjjK168uAYMGKDvvvtO3bt3V4sWLeTo6KjDhw+rQIECeuONN+Tv7y93d3cNGzZMwcHBsrGx0cqVK9NNiqhYsaLWrVunL7/8UpUrV1auXLnUtGnTdI/99ttv66WXXlKXLl3UsWNHxcfHa+7cucqTJ48GDRr0yGO7n/bt22v9+vX66KOPtHPnTlWvXl0pKSk6e/asfv75Z02bNk2VK1c21ff19dWLL76o4OBgOTo6asGCBZKkV1991VRnyJAh+uOPP9S9e3d1795ddnZ2WrRokRITE/XWW289UFwVK1aUJI0dO1atW7eWg4ODmjRpkuUrJwAAAAAAkFM9yPWZfv36ae3atXrppZcUHBwsd3d3rVixQiEhIZowYcI9l8P/Lzp16qSPPvpIr776qurVq6cTJ05o+/bt8vT0NKvXpk0b1a5dWxUrVpSHh4cOHz6sX375RT179rxn3+XKldOzzz6rRYsWKTIyUrVq1dLhw4e1fPlyBQUFqW7dupk2jkeRVdeL7sVoNOrdd9+Vs7OzPv74Y0lS165d9euvv+rzzz9XQECAvL29M2NoAADAAkgKAGBR3t7eWrx4scaNG6fVq1crOjpa3t7eCgwMvOd+Zw4ODpoyZYpGjBihqVOnysnJSc2bN1ePHj3Uvn17Uz0fHx+1adNGf/75p1atWiU7OzuVKlVK3377rVq2bClJql27tg4fPqx169bpxo0bypMnj6pUqaIxY8aoaNGimTLGwYMHq0iRIpo7d67Gjh0rFxcX+fn5mWL19PTUlClTNGrUKH377bdyc3NTu3btFBAQoBdffNGsr+7du+v48eNatmyZZs2apcKFC9/zj7x69epp2rRpGj9+vMaPHy97e3vVqlVLb731VqaNLSN3VkiYNWuWVq5cqd9++00uLi4qUqSIgoODVbJkSbP6tWrVUrVq1TRp0iRduXJFZcqU0Zdffqly5cqZ6pQtW1bz5s3T119/ralTp8poNKpKlSr66quvVLVq1QeKq0qVKho8eLAWLlyo33//XQaDQRs3biQpAAAAAADwxHqQ6zP58+fXwoUL9dVXX2nu3LlKSEiQn5+fpkyZosaNG2dqPJ07d1ZISIiWLl2q33//XTVq1NDMmTPVu3dvs3rBwcHatGmTduzYocTERBUqVEhDhgxJcz3l30aMGKEiRYpo+fLl2rBhg/Lnz6/+/ftny0MUDyqrrhfdy48//qhdu3ZpwoQJpm0cJenzzz9X27Zt9cEHH+j777/PlLEBAIDsZ2O81/rcAABkEz8/P/Xo0UMffvihpUMBAAAAAAAAAACwKpm3phMAAAAAAAAAAAAAAMhRSAoAAAAAAAAAAAAAAMBKkRQAAAAAAAAAAAAAAICVsjEajUZLBwEAAAAAAAAAAAAAADIfKwUAAAAAAAAAAAAAAGClSAoAAAAAAAAAAAAAAMBKkRQAAAAAAAAAAAAAAICVsrd0AEBWik+2dAQArNGE7WctHcIT563GpSwdAgAgE7j4D7J0CHhC3d490dIhAAAAAACQJZwf4I4/KwUAAAAAAAAAAAAAAGClSAoAAAAAAAAAAAAAAMBKkRQAAAAAAAAAAAAAAICVIikAAAAAAAAAAAAAAAArRVIAAAAAAAAAAAAAAABWiqQAAAAAAAAAAAAAAACsFEkBAAAAAAAAAAAAAABYKZICAAAAAAAAAAAAAACwUiQFAAAAAAAAAAAAAABgpUgKAAAAAAAAAAAAAADASpEUAAAAAAAAAAAAAACAlSIpAAAAAAAAAAAAAAAAK0VSAAAAAAAAAAAAAAAAVoqkAAAAAAAAAAAAAAAArBRJAQAAAAAAAAAAAAAAWCmSAgAAAAAAAAAAAAAAsFIkBQAAAAAAAAAAAAAAYKVICgAAAAAAAAAAAAAAwErZWzoA4HGw7KclmjNrhi6HhMjHp6C69QxW9x7BD9T22NEjmjBurA4e2C+j0agq1fw19PW3VK58ebN6SUlJmv7DVK1auVzXQ0NVwNtbzzzbQX369pO9/f9/VHfv2qm+Lzyf7rF+nL9IVapWM+83MVGzZ83Q6lUrdOXyZeXOk0cVK1bSBx99Km8fH0nSkcOHtGrlCu3etVNXrlyWh7uHqlStqoGvDVGJEiUfYqYyz+M85wf279PYr7/SiePH5OqaWy2eaqXXBg9VLldXs3oXLpzXpAnjtH/fXkVGRMinYEG1at1WvV54US4uLg801sz0uM75tO+naMvmTQq5dFExMTHy8SmohoGN1Lf/y8qbN6+p3uXLIWrdolm6fY786hu1at3mgcZqSce2rtHVEwd1/dzfirkdprIBQWrU+4106964cEp7V8/VjQunlJQQpzz5feTX4ClVaNxWtrZ2kqT46Eid3PGrLh7aqfBrF2VISZG7TxFVavasStdqlKbPiNDL2rtqjq6dPqqEmGjlzuul0rUbq0qLDrJ3dM7SsQMAAAAAAAAAgP+GpADkGGfOnNGIESO0f/9+ubq6qn379hoyZIgcHR0tGteSxQs14pOPFNS8pYKff0H79u3RqC9GKD4uTn369suw7fFjR9U7uLu8fQqq/yuDZDQYtGjhfL3Yu6fmLVyiEiVLmeq+O+wt/fbLz3rmuQ6qULGSDh88qEkTxuna1av68JPP0vTdvWewKlaqbFZWtFgxs9dJSUka9Ep/HTiwXx06dFJZPz9FRkbqyKGDioqOkrdSkwJmTp+mA/v3qXnLp+Tr66cbN8K0cP48de34nH5csEhly/r+1+n7Tx7nOT9x/Lj6vdhbJUuV1htvD9P1a9c0e9YMXbxwXt9NnWaqd+3qVfXo2kl5cudR12495e7uroMHD2jypAk6fuyoxk2c/F+m7j97nOf82NGj8itXTk+1aq1crq46d/asli1drN+3bdWin1YoV65cZvVbtW6rBoGBZmVVq1V7kGmyuEO/LFFSfJy8SvgpNuLWPevduHBKq0a/LvcChVWlZSfZOzop5Mge/bVoiqLCriqgywBJ0vWzx7Vn5WwVrVRL1Vp3k62tnc7t36HN00Yq/OpF1Wj3/6SQ6FthWjlyiBxdcqlik3ZyypVboWdPaN/qubpx8bRavPJRlo8fAAAAAAAAAAA8PJICkCNERESoV69eKlGihCZMmKDQ0FCNHDlS8fHx+vDDDy0WV3x8vCaOG6uGjRrr62/HS5I6dOosg8Gg76dMVsdOXeTm7n7P9pMmjJOTk7N+nL9QHh6ekqQ2T7dTu9YtNf7bsfpm3ARJqU/q//rzevUb8IoGvjpYktS5Szd5eHrqx9kz1bV7D/n6lTPru3r1mmre8qkM4587Z5b27N6tWT/OV+UqVe5ZL7hXb40cPUYOdyVgtGzVWh2feVozpn2vL0eNyfA4melxn/MJ476Rm5ubps/6Ublz55YkFSpcRJ989L7+2LFd9eo3kCStWb1SUZGRmvXjfJUpU1aS1LFzFxkNBq1etUKREREZjjMzPe5zfqf/u1WtWk1vDH1NW7dsTrMCQPkKFdT26fb3mZWcqc0bo5U7bwHZ2Nho1mvP3rPe8W3rUuu/+ZWcXfNIksoHttaaMW/p5B+/mZICPAsVV6fPpilPPm9T2/KN22r92OE69MsSVWnZSQ5OqSsAnP5roxJjo/X0W2PkWai4JKlcYGvJaNCpvzYqISZKTv8cCwAAAAAAAAAA5By2lg4AkKSFCxcqJiZGEydOVMOGDdWxY0e99dZbWrhwoUJDQy0W1+5dOxUeHq4uXbublXft1kNxcbHatm1Lhu337d2jugEBphulkuTlVUA1atXWtq2bFRsT80+9vZKkp1qZ37x8qlVrGY1G/fLz+nT7j4mJVnJycrrvGQwGzZs7R02DglS5ShUlJycrLi4u3brV/KubJQRIUvHiJVS6TFmdO3s2wzFmtsd5zqOjo/XXn3+oTdt2poQASXq6XXvlypVLv/6y3qyuJOXLl8+sj/xeXrK1tZW9g0OG48xMj/Oc30uhwoUlSVFRkem+Hxsbq6TExIfqMyfIk89bNjY2962XFB8rO3tHObmYb1mRyz2v7B2d/t9ffh+zhABJsrGxUfFqAUpJTlLUjaum8sT4WEmSi5uHWX0X97yysbGVrX32nbMAAAAAAAAAAODBkRSAHGHbtm0KCAiQh4eHqaxVq1YyGAzasWOHxeI6cfyYJKlCxUpm5RUqVJStra1OHD+eYfvExEQ5OaXdZ9vF2VlJSUk6ffqUJCkpKfXmpJOzk1k9Z+fUfeWPHT2Spo8P3x+uerVrqHb1Knqxd7COHjls9v6ZM6cVdv26fH399OlHH6huzWqqW7OaOj77tHbt/CvDuCXJaDTq5s0bZjd6s8PjPOenTv6t5ORkVahkHruDo6P8ypU3i71WrdqSpI8/eE8njh/XtatX9fP6dVqyaIG69whOs+R9Vnqc5/wOo9Go27dv6UZYmPbtTd36wM7OzjTPd5vy3UQF1PJXrepV1L1zB/2xY3uG43scFfStoqT4WG2fN0G3r15U1M1QHd+6Vuf3/6GqT3W+b/vYyNuSJOfc/18hoqBv6moj2+Z8q5uXzij6VpjO7N6q41vXqmLTdqYVBQAAAAAAAAAAQM7C9gHIEc6ePasOHTqYlbm5ucnLy0tns/lJ9buFhYXJzs4uzdPcDo6OcvfwUNj16xm2L1GypA4dOqCUlBTZ2dlJkpISE3X40CFJ0vV/VkEoXqKkJOnA/n0qUqSoqf2+fXtS6911HAcHBwU1b6kGgYHy9PDUmTNnNGfWdL3wfA/NnrdQ5ctXkCRdvHBBUuoWAm7uHvrgo08lSdN+mKpX+vfV/EVL0yzVfre1a1bpemioXhn02n1mKXM9znN+IyxMUupT8v/m5eVlelJekuo3DNTAVwdr+g9TtWXzJlP5S/0GaNDgoRmOMbM9znN+x80bN9SscQPTa28fH305eoxKliptKrO1sVVAvQZqGhSkAgW8dTnkkn6cPUsDB7ykcRMnK7BR4wear8eBX8OndPvKBZ34fb3+3v6zJMnG1lb1ur6i8o3aZNg2PiZKf2//RT5lKimXe15TedFKNVWj3fM6sH6RLh78f2JRtVZdVfOZXlkzEAAAAAAAAAAA8MhICkCOEBkZKTc3tzTl7u7uioiIsEBEqRIS4uVwj2XcnRydlJAQn2H7zl276/NPP9bHH7yn3n36ymA06IepkxX2z83j+H/aNwxspEKFCuubr0bL2dlFFSpW1OFDBzVx3FjZ29srIf7/x6nmX13V/KubXjdu2kzNW7RUp+faafzYrzX5++mSpNjY1CXbY2JitGjpCvkULChJql2nrtq2aqGZM6bpy1Fj0o373Nkz+nLEp6pazV/t2t973/Ks8DjP+Z2+HRzMt2KQJEentLEXKlxY1WvUVFDzlnL38NDv27Zo2g9TlS+/l7r16Hmfmco8j/Oc3+Hu7q6p02YqISFBJ44f08YNvyk2NtasTsFChTTlB/N2bZ9ur2fbtdHXX420qqQAW1s7uXkVVOEK1VWqRkPZOTjqzO4t+mPhZLm4e6pEtXrptjMaDNoyfbQS46IV0PXlNO/nzuetgmUrqUT1+nJyddOlI7t04OdFcnH3VMUm7bJ6WAAAAAAAAAAA4D8gKQDIgJNT6vLn6UlITEh3yfS7de7STaHXrmnWjOlatXK5JKlixUp6oc+L+uH7KcqVy/Wf4zhpwuSpeuv1IXpjyKuSJEdHRw154y1N+37KfZeSL1a8uBo3aaaNG341Pa3t/E9s1fyrmxICpNQbo/7Vq+vggf3p9nUjLEyDXumv3LnzaMzYcaYnv7OLNcz5nWXy75aYYB77+nVr9dnHH2rV2l/k7eMjSQpq3kIGg1Hfjh2jVm3aZNvWDY/znN/h4OiougGpN7obNW6iOnUD1KtnN+XNm0+NGje5Z5/uHh5q/+xzmjHte4Veu2b6LB53B39erCMbV6jzZ9Pl8M/2DKVqBmrt1+/ojwXfqVjlOrJN52f7j4WTFXJ0jxq98KbyFS1l9t6Z3Vu0fe54df7sB7l6ekmSSlavL6PBqN3LZqh0rcZyzp02uQsAAAAAAAAAAFiWraUDAKTUrQKioqLSlEdERMjd3T2dFtnDy8tLKSkpunnzpll5UmKiIsLD5VUg7TLx//bq4KHavG2HZs6Zp6XLV2n+4p9kMBolScWLlzDVK1OmrJatXKOfVq7RzDnztGHz7+rQsbPCb99W8RIl0u/8Lj4+PkpKSlJcXFxq7P/Eli9f/jR18+bLp8jIyDTlUVFRemXAS4qKjNJ3U6epQAHv+x43sz3Oc57fK/VGaVhY2uX2w8LCzGJfvHC+ypUrn+YmdOMmTRUfF6cTx4/f9/iZ5XGe83up5l9dXl5eWrdm9QP1KUkREeH3rfu4OLZljQqVq2pKCLijWNW6ig2/qaiboWna7Fs9T8e3rlGtZ19Q2brN0rx/fMta5StW2pQQcEfxqnWUnJigm5fOZO4gAAAAAAAAAABApiApADlCqVKldPbsWbOyqKgohYWFqVSpUvdolfX8ypWXJB07esSs/OjRIzIYDPIrV+6B+nFzd1f1GjVV1tdPkvTXn3/I28dHJf81NhsbG5UpU1bVa9SUu4eHdu/aKYPBoDp101/q+24hISFycnIyPW1d1tdX9vYOun497c2/sOvX5emZ16wsISFBrw0coAsXzmvCd1NUukyZBxpbZnuc57xMWV/Z29vr2BHz2JMSE/X3ieNmsd+8eUMpBkOaPpOTU5/YT0lOfqBxZobHec4zkpCQqOjotMlG6fUpSZ55896n5uMjLuq2jOmcX4aU1PPKaEgxKz+2ebX2rZmrSs2eUdWnOmfQZ0qackNKitn/AwAAAAAAAACAnIWkAOQIgYGB+uOPP8yeXv/5559la2ur+vXrWyyu2nXqyt3dQ4sXLjArX7xogZxdXBQY2NhUdvv2LZ07e+a+TzD/vH6djh45rB7BvWRre+8fwfj4eE2aME5eXl5q1aaNqfzWrVtp6v594oS2bN6kgHr1TX26uuZWw8BAHTywX+fO/v8J3rNnzujggf0KCPj/DdiUlBS9/cYQHTp4QGO+Gaeq1fwzHENWepznPE+ePKpTN0Br16xSTEy0qe7q1SsVGxurFi2eMpUVL15SJ44f0/nz58z6Xb9urWxtbVXWzy/DMWWmx3nOY2Nj041lw6+/KDIyQhUqVsqwz9DQUK1Y9pN8ff3k5XX/FREeF+4Fiujy8f2Kj/7/71SDIUXn9vwuB2cXuXn9f0uRM7u36s9FU1S6dhPV6dTvnn26FSism5fOKCI0xKz8zO4tsrGxVd4iJTN/IAAAAAAAAAAA4JHZWzoAQJK6du2qH3/8UQMHDlT//v0VGhqq0aNHq2vXrvL2zv4l7O9wdnbWwFdf0xcjPtWbQ19TvfoNtW/vHq1dvUqvDh4qdw8PU92F8+dpyncTNW3mHNWqXUeStHfPbk2dPEkB9erL3cNDhw8e1MoVy1S/QUP16Pm82bHeen2wvLwKqFTpMoqJidaKZT8pJOSSJk7+Xq6uuU313n5jiJydnVW1mr/y5s2ns2dOa+nSxXJxcdbgoW+a9fnq4Ne1868/9VKfXurWI/V4C+bNkZu7u17sN8BU7+vRI7Vl8yY1atxEERHhWrN6pVk/bZ9unynz+SAe/zkfqud7dFWfXsHq0Kmzrl+7pjmzZyqgXgPVbxhoqte7z4vasX2bXni+h7p26yEPDw9t27pF23/fpuc6dMrWrRse5zm/eOGC+vftrZZPtVaJUqVka2Oro0ePaN2aVSpUuLB6BP//+GO//kohly6qTt0AeXkV0JUrl7V08ULFxcXq7eHvZdHsZq4LB//SrZDURBJDSrJuhZzT/rWpyRzFqtZVvn9uzFd9qpO2zPhKq0YOkV/DVrJ3cNSZ3Vt14+Ip1Wj/vGztUv/5v37ub22dNUZOufOocLlqOr1zs9nxvEuXNyUQVGnRUSFH92j1V2+pYpOn5eTqpouHdyrkyB75NXhKrh75smsaAAAAAAAAAADAQyApADmCu7u7Zs+erc8++0wDBw6Uq6urOnbsqKFDh1o6NHXp1kP29g6aM3uGtmzeJB+fgnrrneHqEdzrvm0LFPCWra2dZs+crpiYGBUuUkQDXx2i53v1lr29+Y9fhYqVtHLFMi1dskhOTs6qXqOGvhz9tcqVL29Wr0mzIK1bs1o/zp6lmJhoeXp6qllQcw14eZCKFS9uVrd0mTKaMXuuvv1mjH6YOlm2tjaqXaeuhr75tlmyxd9/n5Akbd2yWVu3mN8UlLI3KUB6vOe8fIWKmjptpsZ9M0ZjRn2pXK6ueua5jho89HWzejVq1tLsuQs15bsJWrxwgcLDw1W4SGG9Onioevfp+x9n7r97XOfc28dbzZq31K5df2nVyhVKTk5SwUKF1bVbD/XtP0AeHp6muvXq1deSxZe0cME8RUVGKk+ePKpes5b69X9Z5StUfMQZzB7n9+/QqT83mF7fvHRGNy+lrgTi6pnflBRQpk5TOed214GfF+nwr0uVGB8rd+8iqt/jVZUPbG1qH371ogzJyYqPitC2OWPTHC+w1+umpICCvpX19NvfaN+auTq2ZY0SYqKUJ7+3arbvpSotO2XlsAEAsAovdWqgxrV8VatSCRUtmFc/rvpL/T6am25d//JF9f6ANqpeoZhy53LSuZAbmrXiD01ZtE0Gg9FUr2OL6modWEm1KpdQmWIFtG3PKbV8adw9+/x44NOqW7WkbGxstPPQOb337QodOnk5S8YL63Dt6lWtWP6Ttm3doosXL8jO1lZlyvrqpf4vq27A/bf/Ah5V1Yrpr6L32pA39OJL917pDHgU/O6DpS37aYnmzJqhyyEh8vEpqG49g9W9R7Clw8ITgvMPlsK5l/VsjEaj8f7VgMdTfPZtyw7gCTJh+1lLh/DEeatxKUuHAADIBC7+gywdgsWcWPuJcudy1p6j59W0djktXL873aQA//JFtXnW6zp9MUyzV/yp2PhEtaxfQU83qapJ8zfrza9+MtX95YfB8i9fVHuPXlAVvyI6cupKukkB1coV0aaZryskNFzTf9ouWxsb9evcUJ5urmoY/JVOXbiepWPPCW7vnmjpEB5LC+bN1bfffKUmTYNUzb+6UlKStXrVSh0/dlSfjPhCzzzbwdIhwspVreinuvXq6+l25g8rlCtfQWXKlLVQVLB2/O6DJS1ZvFAjPvlIQc1bql79Btq3b4/WrFqpwUPfUJ++JEMha3H+wVI49x6d8wMsA0BSAKwaSQEAsgJJAdmPpAAAsA5PclJAsYKeunj1tiQpbMfXWr5hf7pJARPf76aeT9dWyebv6XZkrKn812mDVcW3iHwC3zKVFfH20OXrETIajdqz5F3dDI9JNylg2fgBqlOlpCq3/1S3ImIkST753XRoxYfa+NcJdXtzWmYPN8chKeC/OX36lPLlyydPz7ymssTERHXu0F6xsbH6deNWC0aHJ0HVin7q0q2H3n3/Q0uHgicIv/tgKfHx8WrZrJEqV62mid9NNZUPf+dNbd64Ub9u3CI3d3cLRghrxvkHS+HcyxwPkhRgm/VhAAAAAADwZLuTEHA/brmdFZ+QrPCoOLPyazciFZeQZFYWEhquB8nzr+9fWpt3/m1KCLjT3+97T6tVw4pydXF8oNjw5ClTpqzZTTFJcnR0VIOGjRR67ZpiYqItFBmeNPHx8UpISLB0GHhC8LsPlrJ7106Fh4erS9fuZuVdu/VQXFystm3bYpnA8ETg/IOlcO5lH5ICAAAAAADIIbbtOSX3PC6a+H5X+ZX0VrGCnurbsYHaN62qMTN+/U99Ojnap0kokKS4+EQ5OTqoYplCjxo2njA3b4TJ2cVFzs4ulg4FT4BVK5arbs1qql29ip59urXWrVlt6ZDwhOJ3H7LaiePHJEkVKlYyK69QoaJsbW114vhxS4SFJwTnHyyFcy/7PMBiAgAAAAAAIDvMWLZDFUoX1Isd6qvPc/UlScnJKRo6aommLd3+n/o8ef66alcuIVtbGxkMqSsLONjbqVblEpKkQgU8MiN0PCEuXrigjRt+U/OWT8nOzs7S4cDKVavmrxZPtVLhwkV0Pey6Fi2Yr+HvvKno6Ch1/tfTZEBW4ncfskNYWJjs7OyUL18+s3IHR0e5e3go7Pp1C0WGJwHnHyyFcy/7kBQAAAAAAE+4sLAw7dixQ2fPnlV4eLgkycPDQ6VKlVL9+vXl5eVl2QCfIAaDUWcvhem3P45r2Yb9SkhIUuenauqbtzsp9EakVm859NB9fr/kd014r6umfNRD38zeIFsbGw176Sn55HeTJDk7OWT2MGCl4uLi9Obrg+Xk5KzBQ9+wdDh4Asyet9Ds9bPPdlDXzh00ftxYtXvmOTk7O1soMjxJ+N2H7JKQEC8Hh/S/lzk5OikhIT6bI8KThPMPlsK5l31ICgAAAACAJ1RSUpJGjRqlhQsXKiUlRV5eXnJ3d5ckRUREmDL2u3btqmHDhsnenj8hs9qbLzTXK90aq3L7TxQTlyhJ+um3/fr5+9f07fDOWvf7EaWkGB6qz2lLt6uIt6eG9mqm4HZ1JUl7j17QN7M2aNhLTykmln26cX8pKSl6582hOnvmtCZN+UEFCnhbOiQ8gRwcHdW1ew+N+OQjHTt6RNVr1LR0SLBy/O5DdnJyclZSUtotnyQpITFBTk4kQiHrcP7BUjj3sg9XdAAAAADgCfXtt99q5cqV+vDDD9WqVSvlyZPH7P3o6GitX79eX331lZydnfXmm29aKNInR79ODbV190lTQsAda7ce1ug3O6h4obw6e+nGQ/f78aTV+nbOBlUoXVAR0fE6evqKPhn0tCTp1EWWY8T9ffLR+9q2dYu+HDVGdeoGWDocPMF8fApKkiIjIiwcCZ4E/O5DdvLy8lJKSopu3rxptox2UmKiIsLD5VWggAWjg7Xj/IOlcO5lH1tLBwAAAAAAsIyVK1dq+PDh6ty5c5qEAEnKnTu3OnXqpHfeeUcrVqzI/gCfQAXy5ZGdXdo/1R3sU/cvtn+EfYzDo+L0x4GzOnr6iiSpaR0/hVy7rb/Phf7nPvFk+GbMKK1cvkxvvTNcrdq0tXQ4eMKFXLokSfLMm9fCkcDa8bsP2c2vXHlJ0rGjR8zKjx49IoPBIL9y5SwRFp4QnH+wFM697ENSAAAAAAA8oWJiYuTj43Pfej4+PoqJicmGiHDqQpia1imnvO6upjJbWxs916K6IqPjdDYkLFOO07FFddWsVEIT52+W0WjMlD5hnWbNmKbZM2eob78B6hHcy9Lh4Aly69atNGUxMdGa9+NseXp6qkKFihaICk8KfvfBEmrXqSt3dw8tXrjArHzxogVydnFRYGBjywSGJwLnHyyFcy/7sH0AAAAAADyhqlWrpilTpqhy5crprhQgpW4hMGXKFPn7+2dzdNaldWAlVfYtLElysLdVpbKF9U7flpJStwY4cir16f2vZ/6qmV/01rY5b2rGsh2KS0hS56dqqEaFYvpo4molJxtMfdavXloNqpeRJOX3zC1XF0dTn9v3ndaOfWdM9d7t10ob/zyhmxExql25hJ5vV1e/7DiqifO3ZNcU4DG0ccNvGvv1VypWvIRKliqlNatXmr0fEFBf+fLnt1B0sHaLFszT5o0bFNi4iQoWLKSwsOtauXyZrl69os9HjpaDo6OlQ4SV4ncfLMXZ2VkDX31NX4z4VG8OfU316jfUvr17tHb1Kr06eKjcPTwsHSKsGOcfLIVzL/uQFAAAAAAAT6gPPvhAvXr1UqNGjVSvXj2VKlXKlBwQHR2ts2fP6o8//pCrq6tmzZpl2WAfc880q6bgdnVNr/3LF5V/+aKSpMuh4aakgIXr9+hGeIze6tNCQ3o1k5urs06ev65BIxZo+k87zPpsXMtP7w9obVb28cCnJUkjpqwzJQVcuR6hlBSjhvRqpjy5nHX+8k198t0ajftxk1JSDALu5eTfJyRJFy+c13vD3k7z/rSZc7gxhixTzb+6DhzYr+U/LVV4eLhccrmoUqUq+vizz9nbHVmK332wpC7desje3kFzZs/Qls2b5ONTUG+9M5wVK5AtOP9gKZx72cPGyDqBsGLxyZaOAIA1mrD9rKVDeOK81biUpUMAAKsVGRmpBQsW6Pfff9fZs2cVGRkpSXJzc1OpUqUUGBiorl27ys3N7ZGP5eI/6JH7AP6L27snWjoEAAAAAACyhPMDLAPASgEAAAAA8ARzc3NT//791b9/f0uHAgAAAAAAgCxga+kAAAAAAAAAAAAAAABA1iApAAAAAAAAAAAAAAAAK0VSAAAAAAAAAAAAAAAAVoqkAAAAAAAAAAAAAAAArBRJAQAAAAAAAAAAAAAAWCmSAgAAAAAAAAAAAAAAsFIkBQAAAAAAAAAAAAAAYKVICgAAAAAAAAAAAAAAwErZWzoAAAAeN0ElvSwdAgAAAAAAAAAAwANhpQAAAAAAAAAAAAAAAKwUSQEAAAAAAAAAAAAAAFgpkgIAAAAAAAAAAAAAALBSJAUAAAAAAAAAAAAAAGClSAoAAAAAAAAAAAAAAMBKkRQAAAAAAAAAAAAAAICVIikAAAAAAAAAAAAAAAArRVIAAAAAAAAAAAAAAABWiqQAAAAAAAAAAAAAAACsFEkBAAAAAAAAAAAAAABYKZICAAAAAAAAAAAAAACwUiQFAAAAAAAAAAAAAABgpUgKAAAAAAAAAAAAAADASpEUAAAAAAAAAAAAAACAlSIpAAAAAAAAAAAAAAAAK0VSAAAAAAAAAAAAAAAAVoqkAAAAAAAAAAAAAAAArBRJAQAAAAAAAAAAAAAAWCl7SwcAPA6W/bREc2bN0OWQEPn4FFS3nsHq3iP4gdoeO3pEE8aN1cED+2U0GlWlmr+Gvv6WypUvb1bPYDBo6ZJFWrpooS5evCiXXC4qX76C+g14RdX8q5vVvXDhvCZNGKf9+/YqMiJCPgULqlXrtur1wotycXEx1UtKStL0H6Zq1crluh4aqgLe3nrm2Q7q07ef7O3//+MfGxOjWTOn6/Chgzpy+LAiIyP06Ygv1f7Z5x5h1v67nDTfRw4f0qqVK7R7105duXJZHu4eqlK1qga+NkQlSpQ06/OnJYu1ds0qnTt3VlGRkfIqUEA1a9XRgFcGqnDhImZ1o6KiNG3qZG3auEGhodeUN28+1QkI0ICXB6lgoUL/ceYeTU6a9927dqrvC8+ne6wf5y9SlarVzMqSEhM1e9YMrV61QlcuX1buPHlUsWIlffDRp/L28Um3nx+mTtbE8d+qdJmyWrZyzQONMycKv31TC6ZP1P6d2xUXF6vCxUroma4vqG5gUJq6t25c15wp3+jQ3r9kNBpVoWoNPT/gdXkXND8/Y2OitXz+dO3esUU3b1yXu4enKvnXVsfgfspfIP35BAAAAAAAAAAAOZON0Wg0WjoIQJIuXLig6dOn6+DBgzp16pRKlSqlNWse7UZdfPKjx7Vk8UKN+OQjBTVvqXr1G2jfvj1as2qlBg99Q3369suw7fFjR9WrZzd5+xRUx85dZDQYtGjhfEVGRGjewiUqUbKUqe6Y0SP14+yZavN0O1WvXlNRUZFaumSRrl29qlk/LlDlKlUkSdeuXlXH59opT+486ti5q9zd3XXw4AGtWrFMjZs01biJk019vvXGEP32y8965rkOqlCxkg4fPKhVK5erQ8fO+vCTz0z1Ll8OUesWzVSwYCEVLlJEe3bvslhSQE6b7zeGvKYD+/epecun5Ovrpxs3wrRw/jzFxsbqxwWLVLasr6nPzz/9WPHx8Srj6ys3NzddDgnRsqVLZDCkaPGylSpQwFtS6o3xnt066+yZM+rStZuKlyipixcvaPHC+XLNnVsrVq+Tq2vuzJ/cDOS0eb+TFNC9Z7AqVqpsdrz6DRrK0zOv6XVSUpIGvdxPBw7sV4cOnVTWz0+RkZE6cuig+r8ySGXKlE0Tc+i1a2rX9inZyEaFChd+6KSA45ejHqp+VomNida7A4MVEX5LTz3TVR558+mvrRt0/PA+DRo2Qg2aPmWqGx8Xq2Gv9FRcTLTadOwhOzt7rVs2X0ajNGrKPOVx85CUen5+MLi3Qi6cU4unO6pgkeK6duWSflu9VC65XPX1tCVyyeWa7WP1L54n248JAMh8Lv6DLB0CnlC3d0+0dAgAAAAAAGQJ5wdYBoCVApBjnDp1Slu3blXVqlVlMBiUE/JV4uPjNXHcWDVs1FhffztektShU2cZDAZ9P2WyOnbqIjd393u2nzRhnJycnPXj/IXy8PCUJLV5up3atW6p8d+O1TfjJkiSkpOTtWTRAjVv0VJfjPzK1L55y6fUpmWQ1q1dZbpZumb1SkVFRmrWj/NNNzvv3IhdvWqFIiMi5OburiOHD+nXn9er34BXNPDVwZKkzl26ycPTUz/Onqmu3XvI16+cJMnLq4A2btmu/F5eOnrksLp36ZjJM/lgcuJ8B/fqrZGjx8jB0dFUr2Wr1ur4zNOaMe17fTlqjKn8vQ8/ThNT02ZB6ta5g1avXKkXX0q9uX7o4AEdPXJYw9/7UF279zDVLVGypD56/1399eefahbU/GGn7z/LifN+R/XqNdW85VPKyNw5s7Rn927N+nF+mvb38vWYUapSJfV3ze3btx+oTU60ce0yXbtySe+PmqxK/rUkSc3bdtQHg3tr7vdjVbdhM9k7OEiSfl29RNcuX9TnE2artF9FSVK1WvX1Vr8uWrN0nrr1GShJOnX8sM78fUwvDHpbLdt1Nh2rUJHimvL1pzq8b5dqN2iSzSMFAAAAAAAAAAD/la2lAwDuaNq0qbZu3arx48erYsWKlg5HUurTyuHh4erStbtZedduPRQXF6tt27Zk2H7f3j2qGxBgulEqpd6Ar1GrtrZt3azYmBhJqTdL4+PjlTdffrP2efPmk62trZycnE1l0dHRkqR8+fKZ1c3v5SVbW1vTDcB9e/dKkp5q1cas3lOtWstoNOqXn9ebyhwdHZXfyyvDsWSHnDjf1fyrmyUESFLx4iVUukxZnTt79r5jKlS4sCQpKirSVBZzj8/QK3/qZ+Ds5HTffjNTTpz3u8XERCs5Of1lPwwGg+bNnaOmQUGqXKWKkpOTFRcXl2G8e/fs1oZff9Hbw97NsN7j4MSR/XJz9zQlBEiSra2t6gY2V/itmzp2aK+pfOfvG1Xar4IpIUCSChcroUr+tfTXtt9MZXGxqZ+Xu8f/V2OQJI+8qZ+bYzafnwAAAAAAAAAA4NGwUgByDFvbnJejcuL4MUlShYqVzMorVKgoW1tbnTh+XG2fbn/P9omJiene6HRxdlZSUpJOnz6lKlWrydnZWZWrVNWqFctVtVo107Lq30/5Tm5uburYqYupba1atTVz+g/6+IP39PLA1+Th4aEDB/ZryaIF6t4jWLly5ZIkJSUlSpKcnM1v4Dk7u0hK3QM+p8mJ850eo9GomzdvqHTptMvSS1J4+G2lpBh07eoVTZ08SZJUp27A/8dTqZJcXHJp0sRxcnN3V4mSpXTp4gWN/eYrVaxUWXUC6mV4/MyWk+f9w/eHKzY2VnZ2dvKvXkOvv/m22XYCZ86cVtj16/L19dOnH32gVSuXKykpSWV9ffX2sPdUu05ds/5SUlI08vPP9GyHjirr6/dQ85QTJSUlpXuT/s7nce7UCVWpUVcGg0EXz55W45bt0tQt7VdRh/b+pbjYGLnkclUp3wpycnbR4tlTlDuPuwoVTd0+YP608SrtV0GVq9fO8nEBAKwXS7jDUoatPWHpEPAEG9mmnKVDAAAAAPCEIykAyEBYWJjs7OzSPNHt4Ogodw8PhV2/nmH7EiVL6tChA0pJSZGdnZ0kKSkxUYcPHZIkXQ8NNdX9YuRXevvNoXr3nbdMZUWKFtXsuQtUpGhRU1n9hoEa+OpgTf9hqrZs3mQqf6nfAA0aPNT0uniJkpKkA/v3qUiR/7fft29P6rHvE7sl5MT5Ts/aNat0PTRUrwx6Ld33mzcJVGJialKGh4eH3nn3fQXUq29639Mzr0Z/PVaffvS++r3Y21Rer34DfT12vOzts/dXc06cdwcHBwU1b6kGgYHy9PDUmTNnNGfWdL3wfA/NnrdQ5ctXkCRdvHBBUuoWAm7uHvrgo08lSdN+mKpX+vfV/EVLTdtkSNKSRQt19eoVTZ0+62GnKUcqVKS4Du/fpbDQq/LyLmgqP3FkvyTp1s3Uzy46KlJJSYmmp/3v5vlP2e2bYXLJ5So3dw8Nfu9L/TB2hEa887KpXtWaARr6wSjZ2fHVAQAAAAAAAACAxwlX9oEMJCTEy+Gf5fj/zcnRSQkJ8Rm279y1uz7/9GN9/MF76t2nrwxGg36YOllhYWGSpPi72ru6uqp0mTKqUrWa6tQN0M0bYZox7QcNeW2gZs6ZJ0/P/y/lXahwYVWvUVNBzVvK3cNDv2/bomk/TFW+/F7q1qOnJKlhYCMVKlRY33w1Ws7OLqpQsaIOHzqoiePGyt7eXgnxGcduCTl1vu927uwZfTniU1Wt5q927Z9Nt86kKT8oMTFBZ8+c1do1qxQXm3Y5e0/PvCpXvoK6dq+u0mXK6O8TJzRzxjR9+P5wjRk7PsNxZracOO/V/Kurmn91U7vGTZupeYuW6vRcO40f+7Umfz9dkhT7z1L3MTExWrR0hXwKpt4Yr12nrtq2aqGZM6bpy1FjJKWu4PDdxPF6acAryps3/c/3cdOk1TP6be1P+nbEMD0/4HW5e+bTX1t/0+4dWyRJiQkJ//x/6mfg4Jj2c76zPUZiYoKpzM3dQyXK+KlFxc4qWryUzp85qdWL52jymE809INRWTwqAAAAAAAAAACQmUgKADLg5JS6/Hl6EhIT7rkH+h2du3RT6LVrmjVjulatXC5Jqlixkl7o86J++H6KcuVylZS613q/vi+oZq3aGv7eB6b2dQLq6bl2bTVrxnQNfSP1yer169bqs48/1Kq1v8jbx0eSFNS8hQwGo74dO0at2rSRh4ennJycNGHyVL31+hC9MeRVSZKjo6OGvPGWpn0/xbTNQE6SE+f7bjfCwjTolf7KnTuPxowdZ3oq/t/uLFnfoGEjNWnaTB2eaatcuXKZEjZCLl1S3z7P6/MvRimoRUtJUpOmQSpUqLA+eG+Ytv++VQ0aNspwrJkpp8/7HcWKF1fjJs20ccOvplUJnP+JrZp/dVNCgCQVLFRI/tWr6+CB/aayieO/lbu7u7p373mfGXl8FC9VVq8OG6Hp47/UR0NflCR55M2n519+XdPHj5SzS+rPueM/85SUmPZzTvpnVQtHx9RtCEKvhuiztwbolbc/UZ2GzSRJNes1lpd3IU0e87H279oh/9r10/QDAAAAAAAAAAByppy3iTuQg3h5eSklJUU3b940K09KTFREeLi8ChS4bx+vDh6qzdt2aOaceVq6fJXmL/5JBqNRklS8eAlJ0t49u3X61Ek1btLUrG3x4iVUqlQpHdi/z1S2eOF8lStX3pQQcEfjJk0VHxenE8ePm8rKlCmrZSvX6KeVazRzzjxt2Py7OnTsrPDbt1W8RImHmYpskRPn+46oqCi9MuAlRUVG6bup01SggPcDjalosWIqV76C1q1dbSpbuWKZEhMSFNi4iVndO/Ec2Jf2+FkpJ8/7v/n4+CgpKUlxcamrL9yJLV++tMvi582XT5GRkZKkCxfO66cli9WtZ7Cuh13X5cshunw5RAkJCUpOTtLlyyGKCA+/7/FzorqBQZq84Gd9PmG2Phs3UxN/XKMCPkUkSQULF5Mk5c7jJgcHR4XfupGm/e1/yjzzeUmStv66RolJiapep6FZvRoBgZKkk0cPZtlYAAAAAAAAAABA5mOlACADfuXKS5KOHT2ihoH/f3L76NEjMhgM8itX7l5Nzbi5u6t6jZqm13/9+Ye8fXxUslQpSdKtf27GGlJS0rRNTk5Wyl3lN2/ekJubezr1Up8ATklONiu3sbFRmTJlTa9/37ZVBoNBderWe6DYs1NOnG9JSkhI0GsDB+jChfP6ftpMlS5T5qHGFR8fb3oaW5Ju3rwpo9GY5jhJ/3x2yenElZVy6rynJyQkRE5OTqaVLsr6+sre3kHXr4emqRt2/bppO4LroaEyGAwa9cUIjfpiRJq6rVs0U4+ez+vt4e89wEhzHnsHB5X2q2h6fWT/TklSpeq1JUm2trYqWrKMzp46lqbt6RNHVKBgYbn8s6JDxO2bktEog8FgVu/O75YUQ/aenwAAAAAAAAAA4NGwUgCQgdp16srd3UOLFy4wK1+8aIGcXVwUGNjYVHb79i2dO3vG9ATzvfy8fp2OHjmsHsG9ZGub+iN456n9n9evM6t7/NhRnT9/TuXKlzeVFS9eUieOH9P58+fM6q5ft1a2trYq6+d3z2PHx8dr0oRx8vLyUqs2bTKM0xJy4nynpKTo7TeG6NDBAxrzzThVreaf7nGSk5MVGRGRpvzwoUM6feqkKlSqZCorXqKEjEajfv15vXms69ZIksqVr5DhmDJbTpz3W7dupenz7xMntGXzJgXUq2/q09U1txoGBurggf06d/aMqe7ZM2d08MB+BQSkJr+UKVtWY8dPSvO/0mXKqmDBQho7fpKe7dDxPjP1eLh6+aI2rF2m6nUaqlCR4qbyOg2b6szfx3Tm5P8TA65cOq+jB/aobmCQqaxgkeIyGo36c9tvZv3u2PKLJKlE6Xv/jgEAAAAAAAAAADkPKwUgx4iLi9PWrVslSZcvX1Z0dLR+/vlnSVLt2rWVN2/ebI/J2dlZA199TV+M+FRvDn1N9eo31L69e7R29Sq9Onio3D08THUXzp+nKd9N1LSZc1Srdh1JqculT508SQH16svdw0OHDx7UyhXLVL9BQ/Xo+bypbYWKlVS3Xn2tWrlc0THRCqhXXzfCwrRg3lw5OTmrZ3AvU93efV7Uju3b9MLzPdS1Ww95eHho29Yt2v77Nj3XoZPZsvZvvT5YXl4FVKp0GcXERGvFsp8UEnJJEyd/L1fX3GZjXTBvrqKiIhV2/bokaeuWzQoNvSZJ6tYjWHny5Mn0+f23nDjfX48eqS2bN6lR4yaKiAjXmtUrzWJu+3R7SVJsbKxaNGuslq1aqXTpsnLJ5aJTJ09q5Yplyp07j/oNeMXUpv0zz2rOzBn67JMPdeLEMZUuXVbHjx/V8p+WqnSZsmrWLEjZKSfO+9tvDJGzs7OqVvNX3rz5dPbMaS1dulguLs4aPPRNs/hfHfy6dv71p17q00vdeqQeb8G8OXJzd9eL/QZIkjw986ppOvM678fZkpTue4+LN/p2Ut3AIOXz8lbYtSv6bc1Pcs3jpr6Dh5vVa/F0J21av0Kj3x+ith17ys7eXmt/mid3z7xq26GnqV6jFm21ZumPmjbuC50//beKFC+l86dPaNP6lSpSvJRq12/y7xAAAAAAAAAAAEAOZmM0/rPpM2BhISEhatasWbrvzZkzR3Xq1HnoPuOT71/nQfy0ZLHmzJ6hyyEh8vEpqK7de6hHcC/Z2NiY6kyeNCHNzdJLFy/q888+0YnjRxUTE6PCRYro6XbP6vleveXg6Ggea3y8Zs+crp/Xr9OVyyFycHCQf/WaGvjqYLMnqKXUp8+nfDdBJ44fV3h4uAoXKax27Z9V7z59ZW///1yfmdN/0MoVy3Tl8mU5OTmreo0aennga2n6k6RWzZvqypXL6Y5/3a8bVbhwkf88fw8rJ833i72DtWf3rnvGevDo35KkpMREjf36K+3etVNXrlxWfHyCChQooDoBAXqp/8tp5i80NFTfTRyn3bt26npoqDw8PBTYqIleHTLUtOR9dstJ8z5v7hytW7Naly5eVExMtDw9PVW7boAGvDxIxYoX178dP3ZU334zRgcPHJCtrY1q16mroW++reLFS2Q45hd7B+v27dtatnLNQ83V8ctRD1U/K43/4l39ffSgIsJvKY+bh2oEBKpTcH+5p3Me3QwL1Zwp3+jQ3r9kNBpVoUoNPT/gdfkULmpW79aN61o8e4qOHdyrWzevK08ed/nXaaiufQbKzd0jm0Zmzr941icmAQCyXmZ9Pwce1rC1JywdAp5gI9s82JZsAAAAAPBfOD/AMgAkBcCqcdERQFbISUkBTwqSAgDAOvD9HJZCUgAsiaQAAAAAAFnpQZICbLM+DAAAAAAAAAAAAAAAYAkkBQAAAAAAAAAAAAAAYKVICgAAAAAAAAAAAAAAwEqRFAAAAAAAAAAAAAAAgJUiKQAAAAAAAAAAAAAAACtFUgAAAAAAAAAAAAAAAFaKpAAAAAAAAAAAAAAAAKwUSQEAAAAAAAAAAAAAAFgpkgIAAAAAAAAAAAAAALBSJAUAAAAAAAAAAAAAAGClSAoAAAAAAAAAAAAAAMBKkRQAAAAAAAAAAAAAAICVIikAAAAAAAAAAAAAAAArRVIAAAAAAAAAAAAAAABWiqQAAAAAAAAAAAAAAACsFEkBAAAAAAAAAAAAAABYKZICAAAAAAAAAAAAAACwUiQFAAAAAAAAAAAAAABgpUgKAAAAAAAAAAAAAADASpEUAAAAAAAAAAAAAACAlSIpAAAAAAAAAAAAAAAAK2Vv6QAAAHjcODuSUwcAALLPtatXtWL5T9q2dYsuXrwgO1tblSnrq5f6v6y6AfUsHR4eU872tmrum09VCuaRu4u9ohNSdDIsRj//fUPhcclmdf0L51HTMvnkk8dRCckGHbkWrdXHwhSTmGKq4+FsrzrF3VXBO7e8XB1lMBp1LSpRv568oZNhsdk9PFiBlcuX6cP3h9/z/S9GfaU2bdtlY0R4Uu3bu0cvPN9DkrRl+5/y9Mxr4YhgrfjOh5xg2U9LNGfWDF0OCZGPT0F16xms7j2CLR0WrNzihfO1a+dfOnzokK5du6p27Z/VZ1+MtHRYVoekAAAAAAAAcrDNmzZq5vQf1KRpkNq1f1YpKclavWql+vd9QZ+M+ELPPNvB0iHiMWMj6eV6ReWTx0nbz91WWHSi8ud2VIMSHipXwFVfbjqnhGSDJKl+CQ91quqjv8NitOLIdXm42CuwVF4V9XDW2G0XlGwwSpIqFcytZmXy6fC1KO2+FCFbGxvVKuquV+oV0/z9V7XrYoQFR4zHUY2atfT5yNFpyufOma2Tf59QnToBFogKTxqDwaCRX4yQi0suxcWR4ISsxXc+WNqSxQs14pOPFNS8pYKff0H79u3RqC9GKD4uTn369rN0eLBiM6dPU0xMjCpVrqwbN8IsHY7VsjEajUZLBwFklfjk+9cBgId1LizG0iE8ccoXdLV0CACATMD38//m9OlTypcvn9mTiYmJiercob1iY2P168atFozu8TBs7QlLh5CjlPB00ZDA4lp66Jq2nws3ldcu5q7u/gU1fVeIDl+Nlp2N9NlTZXUlMkETd1w01avg7ap+dYvqp0Oh+v3cbUmSTx5HRSWkmK0eYGdro7cbl5Cjva0++fVMto0vpxnZppylQ7Aa8fHxahpYT5WrVtPUH2ZYOhw8ARYvWqBJ479Vm7btNG/uHFYKQJbiOx8sKT4+Xi2bNVLlqtU08buppvLh77ypzRs36teNW+Tm7m7BCGHNrly5rIIFC8nGxkZ1a/qreYuWrBTwkJwfYBkA1j8GAAAAACAHK1OmbJobEI6OjmrQsJFCr11TTEy0hSLD48rZIfVyUFR8ill55D+ZO0kpqc+PFHRzUi5HO+2/HGlW71hojOKTU+RfOI+p7FpUollCgCSlGIw6FhojTxcHOdlzCQqPbuuWTYqJiVGbNk9bOhQ8ASLCwzVp/Ld6ZdBryuPmZulw8ATgOx8safeunQoPD1eXrt3Nyrt266G4uFht27bFMoHhiVCoUGHZ2NhYOgyrx19kAAAAAAA8hm7eCJOzi4ucnV0sHQoeM5fC45WQbFDr8vlVNn8uuTvbq3Q+F7Wr4KULt+N08p+VsextUy/MJRnSLjKZlGJUEXdn3e/SXR4nOyUkG5T4z3YEwKNYt2a1nJ2d1ax5c0uHgifApAnjlC+/lzp27mrpUPCE4zsfssOJ48ckSRUqVjIrr1ChomxtbXXi+HFLhAUgEz3AYgIAAAAAACAnuXjhgjZu+E3NWz4lOzs7S4eDx0xMYopm77msLtV8NLB+MVP58dBozdx9WXdyAMJikmQwGlUyr4t2XYww1SuQ21F5nFIvKbk42Co2Kf0b/vldHVSlUB4dvBIl9q7Eo4oID9eO7b+rSbMgubrmtnQ4sHIn/z6hpUsWaeLk7/l3FhbFdz5kl7CwMNnZ2Slfvnxm5Q6OjnL38FDY9esWigxAZmGlAAAAAABAhm7fvq3du3dbOgz8Iy4uTm++PlhOTs4aPPQNS4eDx1R0QopCwhO05liYpu0M0foTYSqVL5e6+xc01YlJTNGBy1GqXdRdjUvnVb5cDiqV10W9ahZS8j+ZAw526V9acrCzUe+ahZWUYtTqY2HZMiZYt99+/UVJSUlsHYBsMerLz1W/QaDq1W9g6VDwBOM7H7JTQkK8HBwc0n3PydFJCQnx2RwRgMzGSgEAAAAAgAzt2rVLQ4YM0XGWjLS4lJQUvfPmUJ09c1qTpvygAgW8LR0SHkP5cjloYP1imrfvqg5djZIkHbkWrVuxSepRvZDKX4zQ8eupWwgsPnhNDnY2eqZSAT1TqYAkafelCN2ISVLVQnnS3RbARlKvGoXkk8dRU/8KUWR8craNDdZr3drVcnf3UP2GgZYOBVbu5/XrdGD/fv20crWlQ8ETjO98yG5OTs5KSkpK972ExAQ5OTlnc0QAMhtJAQAAAAAAPCY++eh9bdu6RV+OGqM6dQMsHQ4eU7WLucvBzkZHQ6PNyo9cS31dMq+LKSkgPtmg6bsuy8PFXnlzOeh2bJJuxyVrcMNiikpIVlw6SQFdq/mogk9uzd17RaduxGb9gGD1rl65on1796hDp873fIoRyCxjx4xWi5Yt5eDgoMuXQyRJUZGRkqRr164pKSmJG7TIcnznQ3bz8vJSSkqKbt68abaFQFJioiLCw+VVoIAFowOQGUgKAAAAAIAn1NNPP9gSzDExMVkcCR7EN2NGaeXyZXp72Ltq1aatpcPBYyyPU+qexLY2Uspd5XY2NqnltjZp2oTHJSs8LvWJfxd7WxV1d9bBf1YZuFu7Cl6qU9xDyw6Hat/ltO8D/8X6dWtkNBrVpm07S4eCJ8C1a1e1bu0arVu7Js17XTs+Kz+/clq8bKUFIsOTgu98sAS/cuUlSceOHlHDwEam8qNHj8hgMMivXDlLhQYgk5AUAAAAAABPqLNnz6pMmTKqUKFChvUuX76sq1evZlNUSM+sGdM0e+YM9e03QD2Ce1k6HDzmrkcnydbGRv6F3LTrUoSpvHoRN0nS5fCM94xtW8FLtrY22nLmtll5kzJ51bRsPv168oa2nb19j9bAw1u/do0KFiwk/+o1LB0KngBjx09KU/bz+rX6Zf06jfhylLy9fSwQFZ4UfOeDpdSuU1fu7h5avHCBWVLA4kUL5OziosDAxpYLDkCmICkAAAAAAJ5QZcuWVfHixfXll19mWO+XX37R7t27sykq/NvGDb9p7NdfqVjxEipZqpTWrDZ/OjEgoL7y5c9voejwONp1MVxNyuRV56reKuzupGtRCSri7qy6xT10NTJBh+5aAaBZ2bwqmMdJF27Hy2A0qnLB3CpXILfWHg/TpbuSByoXzK32FQvoenSiQqMSVeOfBIM7/g6LUXRCioCHderUSZ08+bf69O0nG5u0q1gAma1ps6A0ZX+fOC5JatAwUJ6eebM7JDwh+M4HS3J2dtbAV1/TFyM+1ZtDX1O9+g21b+8erV29Sq8OHip3Dw9LhwgrtmXzJp38+4QkKTk5SSdP/q3vp3wnSWrcpKl8/VipIjOQFAAAAAAAT6gqVaro999/f6C6RqMxi6PBvdy5OHLxwnm9N+ztNO9PmzmHC8R4KLFJBn2z9bxalcuvij65Vb+Eh2KSUrTzYoTWHg9Tyl0/7lcjE1SlYB5V8sktGxsbXY1M0Mzdl3XwivnWAIXdnCVJBXI7KrhGoTTHnLj9ok4nxGbpuGCd1q1ZLUlqzRLaAKwc3/lgaV269ZC9vYPmzJ6hLZs3ycenoN56ZzirViDLbfztV61audz0+sTxYzpx/Jgkydvbh6SATGJj5MoOrFh8sqUjAGCNzoWxr3J2K1/Q1dIhAIBVunjxok6dOqVmzZplWC8+Pl43b95U4cKFH+l4fD+HpQxbe8LSIeAJNrINFzEBAAAAZB3nB1gGgJUCAAAAAOAJVaxYMRUrVuy+9ZydnR85IQAAAAAAAACWYWvpAAAAAAAAAAAAAAAAQNYgKQAAAAAAAAAAAAAAACtFUgAAAAAAAAAAAAAAAFaKpAAAAAAAAAAAAAAAAKyUvaUDAB4Hy35aojmzZuhySIh8fAqqW89gde8R/EBtjx09ognjxurggf0yGo2qUs1fQ19/S+XKlzfVuXw5RK1bNLtnH8916KSPPh0hSfrg3WFatXL5Pev+ummbvL29Ta+TEhM1e9YMrV61QlcuX1buPHlUsWIlffDRp/L28ZEkHTl8SKtWrtDuXTt15cplebh7qErVqhr42hCVKFHygcaZ2Zjz7MecP342rl+lCaM+vuf7Q98boUbNW0uSLl88r59XLdXJ40d09uQJJSUlauqCNfIuWChNu5e6tFFY6NU05S2f7qCX33gv0+IHAAAAAAAAAABZj6QA5Ajr16/XqlWrdPToUUVGRqp48eIKDg5Whw4dZGNjY9HYlixeqBGffKSg5i0V/PwL2rdvj0Z9MULxcXHq07dfhm2PHzuq3sHd5e1TUP1fGSSjwaBFC+frxd49NW/hEpUoWUqS5OmZV5+PHJ2m/Y7tv2vdmtUKqF/fVNaxcxfVCQgwq2c0GjXi049VqFBh8xulSUka9Ep/HTiwXx06dFJZPz9FRkbqyKGDioqOkrdSb5bOnD5NB/bvU/OWT8nX1083boRp4fx56trxOf24YJHKlvX9r9P3nzDnzPmTMOeZoWLV6hry7mdpylctnafzp0+pSvXaprITRw9p7bKFKlK8lIoUL6lzp//OsO+SZfzUvnNPs7JCRYtnTuAAAAAAAAAAACDb2BiNRqOlgwC6dOmiwoULKygoSJ6envrjjz80bdo0DRw4UIMGDfrP/cYnP1pc8fHxatmskSpXraaJ3001lQ9/501t3rhRv27cIjd393u2H/RyPx08cECr1/8iDw9PSVJY2HW1a91SAfUa6JtxEzI8fr8Xe+vokcPatO0POTk53bPevr179MLzPfTq4KHq22+AqXzm9B80cfw4zfpxvipXqXLP9gf271PFipXk4OhoKrtw4bw6PvO0glq01JejxmQYZ2Zizpnze8lJc34uLOaB62a3hIR49X62uXwrVNYnY74zlUdFRsje3l4uuVy1YuEczZrybYYrBRQvWVrvjxyfnaFnqHxBV0uHAADIBI/6/Rz4r4atPWHpEPAEG9mmnKVDAAAAAGDFnB9gGQDbrA8DuL/Jkyfrm2++UevWrRUQEKA33nhDHTt21MyZM2UwGCwW1+5dOxUeHq4uXbublXft1kNxcbHatm1Lhu337d2jugEBphulkuTlVUA1atXWtq2bFRtz7xuLYWHXtXvXTjUNapHhjVJJWr92jWxsbNSqTVtTmcFg0Ly5c9Q0KEiVq1RRcnKy4uLi0m1fzb+62Y1SSSpevIRKlymrc2fPZnjszMacM+f3Yk1znpV2/7FNcbExahTUyqw8j5u7XHI93I31pKQkxd9jPgEAAAAAAAAAwOOBpADkCHnz5k1TVr58eUVHRys2NtYCEaU6cfyYJKlCxUpm5RUqVJStra1OHD+eYfvExEQ5OTmnKXdxdlZSUpJOnz51z7Y/r1sng8GgNm2fzvAYSUlJ+vWX9apazV+FCxcxlZ85c1ph16/L19dPn370gerWrKa6Naup47NPa9fOvzLsU0pdqv3mzRtmN3qzA3POnKfH2uY8K23bsF6OTs4KCGz6SP0c2r9HXVrWU9dW9fVSlzZavXR+JkUIAAAAAAAAAACyE0kByLH27t0rb29v5c6d22IxhIWFyc7OTvny5TMrd3B0lLuHh8KuX8+wfYmSJXXo0AGlpKSYypISE3X40CFJ0vXQ0Hu2Xbd2lby8vFS7Tt0Mj/HHju0KDw9Pc1P14oULkqS5c2Zp9+5d+uCjT/XpiC+VkJCoV/r31cm/M14+c+2aVboeGqqWrVplWC+zMefMeXqsbc6zSlRkhPbt+kO16jV86FUB7laidFl17d1P73z6lQa9/aG8vH00feIYzZ46LhOjBQAAAAAAAAAA2YGkAORIe/bs0bp169SnTx+LxpGQEC8HB4d033NydFJCQnyG7Tt37a4L58/r4w/e05nTp3Xq1Em99+47CgsLkyTF36P9+fPndOzoUbVs1Ua2thn/mK5fu0b29g5q8ZT5Tc3Y2NQl22NiYvTD9Flq/+xzav/sc/p+2kwZjdLMGdPu2ee5s2f05YhPVbWav9q1fzbD42c25pw5T4+1zXlW+WPrBiUnJalRUOtH6ue9L77Vc916q06Dxgpq/Yw+HzdN/rUCtGrxPN24fu8kDwAAAAAAAAAAkPOQFIAc59q1axo6dKjq1Kmj559/3qKxODmlLn+enoTEhHSXTL9b5y7d1LffAK1bu0bPtW+jjs88rZCLF/VCnxclSbnu8STvujWrJem+S6rHxsRo8+aNqle/QZrlz53/ia2af3X5FCxoKi9YqJD8q1fXwQP70+3zRliYBr3SX7lz59GYseNkZ2eXYQyZjTlnzv/NGuc8q2zbsF553NxVvU69TO3XxsZG7Tr1UEpKso4c2JOpfQMAAAAAAAAAgKxFUgBylMjISL300kvy8PDQhAkT7vv0cFbz8vJSSkqKbt68aVaelJioiPBweRUocN8+Xh08VJu37dDMOfO0dPkqzV/8kwxGoySpePES6bZZv3aNSpQsmWaP93/btGmD4uPi1Dqdm6p3YsuXL3+a9/Lmy6fIyMg05VFRUXplwEuKiozSd1OnqUAB7/sNL9Mx58z5v1njnGeFsNCrOnZov+o1CpK9fforPzyK/AV8JEnRUWnnFAAAAAAAAAAA5FwkBSDHiI+PV//+/RUVFaVp06YpT548lg5JfuXKS5KOHT1iVn706BEZDAb5lSv3QP24ubureo2aKuvrJ0n6688/5O3jo5KlSqWpe+jQQV28eEGt22T89LSU+qR1rly51LhJ0zTvlfX1lb29g66ns9R32PXr8vTMa1aWkJCg1wYO0IUL5zXhuykqXabMA40tszHn2Y85tw6/b/xFRqNRgc1b3b/yf3DtSogkye1fqzUAAAAAAAAAAICcjaQA5AjJyckaMmSIzp49q2nTpsnbO2c8uVu7Tl25u3to8cIFZuWLFy2Qs4uLAgMbm8pu376lc2fPKC4uLsM+f16/TkePHFaP4F7proSwfm3qkur3u1l669Yt7fzrTzUNai4XF5c077u65lbDwEAdPLBf586eMZWfPXNGBw/sV0DA/5cXT0lJ0dtvDNGhgwc05ptxqlrNP8NjZyXmPPsx59Zh28b18vL2UYXKjzauqMgIpaSkmJUlJydp2fxZsndwUOVqNR+pfwAAAAAAAAAAkL3sLR0AIEmffPKJNm/erGHDhik6OloHDhwwvVehQgU5OjpaJC5nZ2cNfPU1fTHiU7059DXVq99Q+/bu0drVq/Tq4KFy9/Aw1V04f56mfDdR02bOUa3adSRJe/fs1tTJkxRQr77cPTx0+OBBrVyxTPUbNFSPns+nOV5KSop+Wb9eVapWU9FixTKM7Zf165ScnJzhTdVXB7+unX/9qZf69FK3HqnHWzBvjtzc3fVivwGmel+PHqktmzepUeMmiogI15rVK836aft0+/vOVWZhzlMx56msdc4z24Wzp3X+zCl16P6CbGxs0q0TEx2ltcsWSZJOHDkgSVq3fJFcc+eRa+7cavNcV0nSrh1bteTHaarXKEjeBQspKipS2zb8rIvnTqvnS4Pkmc5WDQAAAAAAAAAAIOciKQA5wo4dOyRJI0eOTPPexo0bVaRIkewOyaRLtx6yt3fQnNkztGXzJvn4FNRb7wxXj+Be921boIC3bG3tNHvmdMXExKhwkSIa+OoQPd+rt+zt0/74/fXnH7p584b69h+QTm/m1q1drbz58qnuXU9C/1vpMmU0Y/ZcffvNGP0wdbJsbW1Uu05dDX3zbbPVGP7++4QkaeuWzdq6ZXOafrL7ZilzzpzfYc1znpm2bVgvSWoY9NQ960RHRWn+jO/MylYu/lGS5OVd0JQUULxUGRUtUUpbf1uniIjbsrd3UMkyvnrr41Gq37h5Fo0AAAAAAAAAAABkFRuj0Wi0dBBAVolPtnQEAKzRubAYS4fwxClf0NXSIQAAMgHfz2Epw9aesHQIeIKNbFPO0iEAAAAAsGLOD7AMQNqNngEAAAAAAAAAAAAAgFUgKQAAAAAAAAAAAAAAACtFUgAAAAAAAAAAAAAAAFaKpAAAAAAAAAAAAAAAAKwUSQEAAAAAAAAAAAAAAFgpkgIAAAAAAAAAAAAAALBSJAUAAAAAAAAAAAAAAGClSAoAAAAAAAAAAAAAAMBKkRQAAAAAAAAAAAAAAICVIikAAAAAAAAAAAAAAAArRVIAAAAAAAAAAAAAAABWiqQAAAAAAAAAAAAAAACsFEkBAAAAAAAAAAAAAABYKRuj0Wi0dBBAVolPtnQEAKzRubAYS4fwxClf0NXSIQAAMgHfzwE8iX7ce8HSIeAJFVyjuKVDAAAAQDZwtr9/HVYKAAAAAAAAAAAAAADASpEUAAAAAAAAAAAAAACAlSIpAAAAAAAAAAAAAAAAK0VSAAAAAAAAAAAAAAAAVoqkAAAAAAAAAAAAAAAArBRJAQAAAAAAAAAAAAAAWCmSAgAAAAAAAAAAAAAAsFL2lg4AAIDHTb7cjpYOAQAAAAAAAAAA4IGwUgAAAAAAAAAAAAAAAFaKpAAAAAAAAAAAAAAAAKwUSQEAAAAAAAAAAAAAAFgpkgIAAAAAAAAAAAAAALBSJAUAAAAAAAAAAAAAAGClSAoAAAAAAAAAAAAAAMBKkRQAAAAAAAAAAAAAAICVIikAAAAAAAAAAAAAAAArRVIAAAAAAAAAAAAAAABWiqQAAAAAAAAAAAAAAACsFEkBAAAAAAAAAAAAAABYKZICAAAAAAAAAAAAAACwUiQFAAAAAAAAAAAAAABgpUgKAAAAAAAAAAAAAADASpEUAAAAAAAAAAAAAACAlSIpAAAAAAAAAAAAAAAAK0VSAAAAAAAAAAAAAAAAVoqkAAAAAAAAAAAAAAAArJS9pQMAJGnr1q364YcfdPr0aUVHR8vb21tBQUEaNGiQ8uTJY+nwtOynJZoza4Yuh4TIx6eguvUMVvcewQ/U9tjRI5owbqwOHtgvo9GoKtX8NfT1t1SufPk0dZMSEzV71gytXrVCVy5fVu48eVSxYiV98NGn8vbxMdW7cOG8Jk0Yp/379ioyIkI+BQuqVeu26vXCi3JxcXnoPnfv2qm+Lzyfbvw/zl+kKlWrPeBMZY7smG+DwaClSxZp6aKFunjxolxyuah8+QrqN+AVVfOvbqr3wbvDtGrl8nse79dN2+Tt7a24uDitXL5Mmzdv1OmTJxUbG6OixYqrY6fO6tCpi+zs7Extzp09oxXLftKff+zQpUsXlSuXq8pXqKCXB76qipUqP+RsZZ6snvfLl0PUukWze/bxXIdO+ujTEZIefN6lB/8sc9p5nhkS4uM1dvTnOnbksK6HXpPBkKJCRYqqTbtn9WynrrK3dzDVvXEjTEsXzNWxI4d04vhRxcXGavyUGfKvWTtNv3NmfK8d27bocsglxcXGqIC3jwIaBCq4Tz95eubNziECAAAAAAAAAIBHRFIAcoTw8HBVqVJFwcHB8vDw0KlTpzRhwgSdOnVKM2bMsGhsSxYv1IhPPlJQ85YKfv4F7du3R6O+GKH4uDj16dsvw7bHjx1V7+Du8vYpqP6vDJLRYNCihfP1Yu+emrdwiUqULGWqm5SUpEGv9NeBA/vVoUMnlfXzU2RkpI4cOqio6Ch5K/UG/rWrV9WjayflyZ1HXbv1lLu7uw4ePKDJkybo+LGjGjdx8kP3eUf3nsFpbkoXLVbsUafwoWTXfH8zZrR+nD1TbZ5up85duysqKlJLlyzSi72DNevHBapcpYokqWPnLqoTEGB2HKPRqBGffqxChQqbbkyHhFzSyC8+U526AQru1VuuuXPrjx3b9flnn+jQwYMa8eUoU/tlPy3V8mVLFdS8hTp37a7o6CgtXbxIwd276Lup01Q3oF4mzeaDy4559/TMq89Hjk7Tfsf237VuzWoF1K9vKnvQeZce/LO8Iyec55klISFB586eUd36DVWwUGHZ2NjoyKEDmvDNaB07clgfff7/+b50/pzmzZ6uIsWKq3SZsjpy6OA9+z15/JjK+vqpWYtWypUrly6cP6vVy3/Sn9u3acb8pXJxyZUdwwMAAAAAAAAAAJmApADkCO3btzd7XadOHTk6OuqDDz5QaGio2Q3A7BQfH6+J48aqYaPG+vrb8ZKkDp06y2Aw6Pspk9WxUxe5ubvfs/2kCePk5OSsH+cvlIeHpySpzdPt1K51S43/dqy+GTfBVHfunFnas3u3Zv04P81NzLutWb1SUZGRmvXjfJUpU1ZS6g1Uo8Gg1atWKDIiwhTTg/Z5R/XqNdW85VP3n5gskl3znZycrCWLFqh5i5b6YuRXpvbNWz6lNi2DtG7tKtN8Va3mr6rV/M2Os2/vHsXHxalN26dNZfnz59fSFatNn4kkdercVR++P1wrly9TvwGvqFjx4pKkVq3b6OVXBimXq6up7jPPddAzT7fW5EkTsj0pILvmPVeuXGr7dPs07VetWK7cuXOrUeOmprIHnfeH+SzvsPR5npnc3N01ddZ8s7JnOnaRa+48WrZ4vgYNfVv58ueXJPmVr6i1G3fIzd1dmzf8qiOHXr9nvyO++jZNWcXK1fTBO0O1Y9sWBbVsnanjAAAAAAAAAAAAWcfW0gEA9+Lh4SEp9Wl3S9m9a6fCw8PVpWt3s/Ku3XooLi5W27ZtybD9vr17VDcgwHSjVJK8vAqoRq3a2rZ1s2JjYiSlLn8+b+4cNQ0KUuUqVZScnKy4uLh0+4yOjpYk5cuXz6w8v5eXbG1tZe/g8NB93i0mJlrJycn3rZcVsmu+k5OTFR8fr7z58pu1z5s3n2xtbeXk5JzhcdavXSMbGxu1atPWVObpmdcsIeCOps2aS5LOnj1jKqtQsZJZQoAkeXh4qnr1mjp39myGx84K2TXv6QkLu67du3aqaVALOTk5ZXic9Ob9v36WljzPs0PBQoUkSdHRkaayXK6uGSZ3PHCfUVGPFhwAAAAAAAAAAMhWrBSAHCUlJUXJyck6ffq0Jk2apKZNm6pIkSIWi+fE8WOSUm/i3q1ChYqytbXViePH033y+Y7ExMR0b0q6ODsrKSlJp0+fUpWq1XTmzGmFXb8uX18/ffrRB1q1crmSkpJU1tdXbw97T7Xr1DW1rVWrtmZO/0Eff/CeXh74mjw8PHTgwH4tWbRA3XsEK1eu1GW9H6bPOz58f7hiY2NlZ2cn/+o19Pqbb2frHvfZNd/Ozs6qXKWqVq1YrqrVqql69ZqKiorU91O+k5ubmzp26nLPYyQlJenXX9arajV/FS58/3Pz5o0bkiRPT8/71JRu3giTh6fHfetltuya9/T8vG6dDAaD2dP/6bnXvP+Xz9LS53lWSEpKUkxMtBLi4/X38aNa8OMs+RQspMJF/vu2CEajURER4UpJTlHIpQuaMmFs6pzVrJWJkQMAgIdx88YNTZo4Xtu2blZEeLjy5/dS7bp19clnX1g6NFiplcuX6cP3h9/z/S9GfaU2bdtlY0SwFjERt7Vj2WydPbBTcdGRcnXPq2IVqumpvm+Y1Tvx12btWrtEN69ckKNzLpX2r6vALn2VK497mv62LZ6uswd2Kik+TnkLFVOdp7vKr3Zgdg4LViI+Pl5ffv6pDh86pNBrV5WSYlDRokX1zHMd1Llrdzn880AOkFWW/bREc2bN0OWQEPn4FFS3nsHq3iPY0mHhCcH5B0vh3Mt6JAUgR2nSpIlCQ0MlSQ0bNtTXX39t0XjCwsJkZ2eX5ql8B0dHuXt4KOz69QzblyhZUocOHVBKSors7OwkSUmJiTp86JAk6fo/Y7144YKk1OX+3dw99MFHn0qSpv0wVa/076v5i5bK16+cJKl+w0ANfHWwpv8wVVs2bzId66V+AzRo8FDT64fp08HBQUHNW6pBYKA8PTx15swZzZk1XS8830Oz5y1U+fIV/sPsPbzsmm9J+mLkV3r7zaF69523TGVFihbV7LkLVKRo0Xse448d2xUeHn7fm9h3jj33x9kqXKTIfW8679u7RwcPHtBL/V++b7+ZLTvn/d/WrV0lLy+vdJNU7pbRvD/oZ5lTzvOssHXTb/rkvbdNr8tVqKhhH34me/v//s/8rZs39cxTjU2vC3h768MRo1S8RKlHCRUAAPxH165eVa+e3SSlblNVwNtbYdev68jhQxaODNasRs1a+nzk6DTlc+fM1sm/T6hOnQALRIXHXeTN61rwWer1i6pN2ii3Z35Fh9/UtbN/m9U7sHG1NsyeoGIV/NW4W39F376hvb8sV+i5U+rx0XjZOzpKkhLiYrRgxFDFRoSreotn5OqRV3/v3KrVE0fIMGCYytdrmiYGICMJ8fE6c/q0GjYMVKHChWVja6uDB/brq1Ff6vChQxr5lWWvV8K6LVm8UCM++UhBzVsq+PkXtG/fHo36YoTi4+LUp28/S4cHK8f5B0vh3MseJAUgR/n+++8VFxen06dPa/LkyRowYIBmzpxputGY3RIS4u+Z/evk6KSEhPgM23fu2l2ff/qxPv7gPfXu01cGo0E/TJ2ssLAwSVL8P+1jY1OXV4+JidGipSvkU7CgJKl2nbpq26qFZs6Ypi9HjTH1W6hwYVWvUVNBzVvK3cNDv2/bomk/TFW+/F7q1qPnQ/dZzb+6qvlXN/XfuGkzNW/RUp2ea6fxY7/W5O+nP9S8/VfZNd+S5OrqqtJlyqhK1WqqUzdAN2+Eaca0HzTktYGaOWeePD3zpnuM9WvXyN7eQS2eanXf8Xz5+Wc6e+a0Jk7+PsObszdv3tSwt99Q4SJF9EKfvvftN7Nl57zf7fz5czp29Kh6Pt9btrYZ72aT0bw/6GeZU87zrFC9Zm2NnfSDoqKitHf3Xzpz6m/FP8B2IRlxc3fX2Ek/KCExQaf+PqFtmzYoLjY2kyIGAAAP67NPPpSdvZ3mL1pqtm0TkJWKFC2aJmk6Pj5eX3z2iWrVqav8Xl4WigyPs99mjpOtnZ16fjxRLnnc0q2Tkpyk35fMVBG/yur0zkjZ2NhIkgqVqaDlYz/UoS3rVL3FM5Kkg5vWKjz0ijoPG6ViFfwlSdWattW8Twdry4Lv5Vu7oezsebIbD87dw0NzFyw2K+vcpZty586jhfPn6s23h/H7D1kiPj5eE8eNVcNGjfX1t+MlSR06dZbBYND3UyarY6cuj7Q1JJARzj9YCude9sn4LgyQzcqVKyd/f3916tRJ3333nXbu3KnffvvNYvE4OaUuf56ehMSE++4937lLN/XtN0Dr1q7Rc+3bqOMzTyvk4kW90OdFSVKuXKn7yjv/0081/+qmm/dS6h7e/tWr6+CB/aay9evW6rOPP9THn36uDp06K6h5C33y2Rd6uv2z+nbsGIWH337oPtNTrHhxNW7STLt37VRKSkqGdTNLds13cnKy+vV9Qblz59G773+oZkHN1blrd02dPlOXLl7SrBnp3xyOjYnR5s0bVa9+g/teiJ01Y5p+WrpYA18drIaBje5ZLzY2Vq++0l+xMTH6dsJ3yuXqmmG/WSG75v3f1q1ZLUn3XXUho3n/r5/lHZY4z7NC3nz5VbNOgJoEtdCbwz9UQINGGjrwJdP2Ff+Fg4ODatYJUP2GjdW77wANfec9jfzsQ+34fUumxQ0AAB7MubNntP33ber9wovy8PBUQkLCPb+/AVlt65ZNiomJUZs29189Dfi3m1cu6tyh3arVupNc8rgpOTFRKcnJaerdCDmvhNho+dVpZEoIkKTS/nXl4OyiEzu3mMounzwilzzupoQASbKxtZVf7UDFRNzSpROsqILMUahwYUlSVFSkhSOBtdq9a6fCw8PVpWt3s/Ku3XooLi5W27ZtsUxgeCJw/sFSOPeyD0kByLH8/Pzk4OCgixcvWiwGLy8vpaSk6ObNm2blSYmJiggPl1eBAvft49XBQ7V52w7NnDNPS5ev0vzFP8lgNEqSihcvkXqcf/rJly9/mvZ58+VTZOT//9hYvHC+ypUrL28fH7N6jZs0VXxcnE4cP/7Qfd6Lj4+PkpKSFPeITxw/qOya7717duv0qZNq3MR8CcHixUuoVKlSOrB/X7p9b9q0QfFxcWp9n5vYK5cv07ffjFGnLl3Vb8Ar96yXlJio1we/qlMn/9a3E75T2bK+9x1fVsiuef+39WvXqETJkqpQsVKGfWc07//1s7xbdp/n2aFxsxaKi43V9q2b7l/5AVWu6q98+b302/q1mdYnAAB4MH/9+aek1ETAl/r0Uu3qVVSnRlW90r+vLl8OsXB0eNKsW7Nazs7Oata8uaVDwWPowtHUBxRyuXlq8ci39W3ftvq2b1stHfOuIsKumeql/JP4ZO/olKYPewdHXb9wRkaDwVQ33Xr/lIWeO5Xp48CTISkxUbdv39K1q1e1ccNvmjNzhgoVKqyixYpbOjRYqRPHj0lSmmtlFSpUlK2trem6L5AVOP9gKZx72YekAORYBw8eVFJSkooUKWKxGPzKlZckHTt6xKz86NEjMhgM8itX7oH6cXN3V/UaNVXW10+S9Neff8jbx0clS6XuzV3W11f29g66fj3t3uth16+bLWV/8+YNpfzzh+/dkpNT/2C+k2H/MH3eS0hIiJycnJQrV64HGOWjy675vvXPzW9DOk+GJycn3/OJ8XVrVitXrlxpbkDfbfOmDfrko/fVLKiF3n3/o3vWMxgMeu/dd7Rr55/6cvTXqlmr9gONLStk17zf7dChg7p48YJaP8DTRRnN+3/9LO+W3ed5dkj8Z8uG6OjozO03MUExmdwnAAC4v4sXz0uSPvv4Azk4OGj012M1eOgb2r9vr/q/+IJVJTciZ4sID9eO7b8rsHETubrmtnQ4eAyFh16WJP0281vZ2tur7cD3FNj5RV0+eVRLRg1T0j9/y3j4FJZsbHTl1FGz9reuXlJcVISSExMUH5P6t4lnwSKKvnVDETfMr39cPpn6N270bfMEeOBBbdjwmxo3CFDLoMZ6ffAgeXt7a/ykyRluEQk8irCwMNnZ2Slfvnxm5Q6OjnL38FDY9esWigxPAs4/WArnXvYhKQA5wqBBgzRlyhRt3rxZf/75p2bOnKlBgwbJz89PQUFBFourdp26cnf30OKFC8zKFy9aIGcXFwUGNjaV3b59S+fOnrnvBbmf16/T0SOH1SO4l2kfdVfX3GoYGKiDB/br3Nkzprpnz5zRwQP7FRBQz1RWvHhJnTh+TOfPnzPrd/26tbK1tVVZP7+H7vPWrVtp4vz7xAlt2bxJAfXq33e/98ySXfNdvEQJ03t3O37sqM6fP6dy5cun6efWrVva+defahrUXC4uLukea++e3XrnzddVvUZNfTl6TIbzNvLzz/TL+nV69/2PFNS8RYZjyGrZNe93W782deuA+yUF3G/eH+azzCnneWb6H3v3HV/z9cdx/J1EkhsrSyL2Fom99x4xWlp7U1TVppT212qp0kFV7b1q770JbanW3hRFUTIIsufvj+it20RoJblx83o+Hh7c8z3n+/18zz355rrfz/ecoKAHinsyI8PTNm9YJ0kq5l38X+8zLCxU4eEJ31/fvbv1+NEjef6HfQIAXg2hoaHP3BYVFaU7d+6kYjR42l/vjWs2N02dMVs+jZuq21s9NWr0WP3xx01t37rFzBEivdi9a6eioqJYOgD/WeST/2tkdHRWq6FjVaxybVVs2kY+PQYryO+OLhzeH789i6M8K9XSuR9369ftaxTk96duXTqjzdM+l7VN/A3Z6KgISVKp2k1kZW2tzVPH6vZv5xR0746ObF6u3479ZFIP+LcqVaqsWXMXaMI3k9WmXXtlsLUlEQ8pKiIiXLa2tolus7ezV8STxCkgJTD+YC6MvdRDWiPShFKlSmnbtm2aPXu24uLilCtXLrVp00Y9e/aUnZ2d2eIyGAzqN2Cgxo0do2FDBqpa9Zo6fuyotm7epAGDhsjRyclYd8WypZo5farmLlisipUqS4q/STxrxjRVrVZdjk5OOnPqlDZuWKfqNWqqU+euJscaMGiojvx8WG/36KYOneK3LV+6WFkdHdWzdx9jve49euqnHw/qra6d1L5DJzk5OengAV/9+MNBtWzVRu7u2f/1Pt9/b7AMBoNKlykrFxdXXbt6RWvWrJKDg0GDhgxL9n59ltTqb+/iJVSlWnVt2rhewSHBqlqtugL8/bV86feytzeoc5duCWLbuX2boqOjn3kT+86d2xrU/11ZWVmpYSMf7dq53WR70aKeKuoZ/8T994sXauWKZSpdpqwMDgZt2bzRpG69+g1T9an11BznkhQTE6Od27erVOkyypM3b5KxPa/f/817mVbGeXLatW2LNq5dpZp16ilnrtwKDQ3RL4d/0q9HDqt6zToqX7GySf1Fc2dJkn6/dkWStHPbZp0+GT99Z7de70iSbt28qSF9e6leo8bKm6/AkymazmnXti3KkTOX2rTvnIpnCABIDdOmTdPChQsVHBys7Nmzq2fPnurSpYtJnfPnz6t9+/a6wLR9ZmFvb5AkNfJpbJLI2MinsT764H2dPHlcLVu3MVd4SEe2bd0sR0cnVa9Zy9yh4BX115T+npVry+qp61nRSrVkPesr3fntvErVaSJJavTWYEVHRurA8tk6sHy2JMm7Wn05uefUb0d/lK19fOK4W96CavbuSO1Z+J2WfzZEkpTJ0UV1O72rPQu/M9YD/i3XbNnkmi1+Wc6GPo01d/ZMvdPrLW3etkvZ3NzMHB0skb29QVFPlk/5p4jICONnQiAlMP5gLoy91ENSANKE3r17q3fv3uYOI1HtOnRShgy2Wrxovnz375OHRw4NH/GBOiVy4/if3N2zy9raRosWzFNISIhy5c6tfgMGq2u37gmmGitUuLDmL/pe334zQXNmzZC1tZUqVa6iIcPeV/bsf9/oL1+hohZ9v0Izp0/RqhXLFRQUpFy5c2nAoCHq3qPXf9pn3foNtG3LZi1ZtFAhIcFydnZW/QYN1efd/sqbL3XXSUut/p48ZboWLZinHdu36dCPP8jW1lZly1VQvwGDlL9Awunut23dLBdXV1V5aoaFp92+dUuPHz+WJI0bOybB9j59+xuTAi5dvChJOnXyhE49uSFrcqxde1N9KvvU6ncpflmBwMAA9XqnTyJ7M/W8fpde/L1MS+M8uZQqU1ZnT5/Unp3b9OB+oGxsbJQnXwH1H/K+WrXrmKD+3JlTTF5v3bTe+O+/kgLcsmdX7XoNdfzXI9qxZaOio6OVPUdOtWzbQV179jZJEgEAvPrWrl2radOmqXXr1vLy8tLRo0c1fvx4+fr6avLkycqcmenB0wJ3d3dJMt6Y+IuNjY0cHZ306NEjc4SFdObPO3d0/NhRtWrT9plP8gDPk9kpflrYTFmdTMqtrW1kyJxV4aGPjWX2GTPpzSGj9SjATw8D7iprtuxyzJZdy8YMlkMWRxmeWsLCs1ItFS5XVX43rykuNlbZ8xfWHxdOSZKcPXKl/IkhXWjQyEdTJk/S/v171aZte3OHAwvk5uammJgYBQYGmkyjHRUZqYdBQXJ78pkQSAmMP5gLYy/1WMUlNu8wYCHCo80dAQBL9Cgs8cxFpBz3LHzxDAAp4Y033lDt2rU1ZMgQY9nRo0c1dOhQubi4aM6cOXJzc9OpU6eSZaYAPp//Nz/9+IP6vtNLvfv0Vb8Bg4zlUZGRqlyhjN54s5VGjf7MjBEiPZg/d7YmT5qoBYuXqlz5CuYO55Wy5NgNc4eQZvx++qjWTvhQVVp0Uo1Wfyehx0RH6dter6tkLR816jHkme3DQ4I1Y0A7FalQQ6/1/SDJYx1YMUe/blutHl/Ol0uO3Ml2Dq+SLuVfzQT4tOrSxYtq26qFBg8dprd6vm3ucGCBDh7w1YC+72jqjNmqWau2sfzkiePq1rmDxo7/Uq83f8N8AcKiMf5gLoy95GF4gWkAXr0FlAEAAAAAyeLGjRuqVs10Rp4KFSpo1apViomJUbt27XTt2jUzRYe/VKxUWS6urtq2dbMiIv5eG3vjhvWKiYlRlWrPnlUJSC7bt25Rjhw5VbZceXOHgldYHq9SypjVSRcO71N0ZKSx/OwPuxQXG6t8JZIeXz+snq/YmBiVb9wyyXoP7t7WqX1bVbBM5XSbEID/7sGD+0rsObp1a1dLil/KEEgJlSpXkaOjk1atWG5SvmrlchkcHFSrVh3zBIZ0gfEHc2HspR6WDwAAAACAdCpr1qy6f/9+gnIPDw8tW7ZMvXv3VseOHdWnz/OX/UHKsbOz09D33tdHH47QW1076bXmLXT3zztaumSJypWvoPoNGpk7RFi43367rMuXL6lHr96ysrIydzh4hWWwtVPt9m9r++yvtWLce/KuVl+PAv10fNcG5fYsoSIVqhvrHtm8QgG3rytHwWKytrHRlWOHdP3sMdVo3V05Cnqa7Hf+yF7yrFRLWV3d9ND/rk7u3SJD5ixq2H3QP0MAnmvr5k1avWqF6tZroNy58ygkNESHfvpRPx/6SbXr1FXlKlXNHSIslMFgUL8BAzVu7BgNGzJQ1arX1PFjR7V18yYNGDSEJR2Rohh/MBfGXuph+QBYNKYnBZASWD4g9bF8AACkjL59+8rBwUETJ05MdHtERIQGDRokX19fWVlZsXyAmW3ftlUL5s7W779fU5YsWdXQp7EGDh6iTE+tqw2khMmTJmr+3Nlas36TihT1fH4DmGD5gIQu/rxfR7as1P0//5B9xszyrFhLNdu8JTuHjMY6V08e0eEN3+v+nT8UGxsjtzwFVaFJK3lWqpVgf1umj9Pty+cU+ihIDlmyqlDZqqrWsosyZXVOzdNKc1g+4L85d/aMFs6fqzOnTyswMEA2NhmUv0ABNXutuTp06qwMGXjODilr7epVWrxovm7fuiUPjxxq37GTOnXpRmIeUgXjD+bC2Hs5L7J8AEkBsGh86QggJZAUkPpICgCAlLF9+3YtWrRIM2fOlNMzsu9jYmL06aef6qefftK+ffte6nh8PgeQHpEUAHMhKQAAACB9ICkA6R5fOgJICSQFpD6SAgDAMvD5HEB6RFIAzIWkAAAAgPThRZICrFM+DAAAAAAAAAAAAAAAYA4kBQAAAAAAAAAAAAAAYKFICgAAAAAAAAAAAAAAwEKRFAAAAAAAAAAAAAAAgIUiKQAAAAAAAAAAAAAAAAtFUgAAAAAAAAAAAAAAABaKpAAAAAAAAAAAAAAAACwUSQEAAAAAAAAAAAAAAFgokgIAAAAAAAAAAAAAALBQJAUAAAAAAAAAAAAAAGChSAoAAAAAAAAAAAAAAMBCkRQAAAAAAAAAAAAAAICFIikAAAAAAAAAAAAAAAALRVIAAAAAAAAAAAAAAAAWiqQAAAAAAAAAAAAAAAAsFEkBAAAAAAAAAAAAAABYqAzmDgAAgFeNrQ05dQAAAAAAAAAA4NXAXQ0AAAAAAAAAAAAAACwUSQEAAAAAAAAAAAAAAFgokgIAAAAAAAAAAAAAALBQJAUAAAAAAAAAAAAAAGChSAoAAAAAAAAAAAAAAMBCkRQAAAAAAAAAAAAAAICFIikAAAAAAAAAAAAAAAALRVIAAAAAAAAAAAAAAAAWiqQAAAAAAAAAAAAAAAAsFEkBAAAAAAAAAAAAAABYKJICAAAAAAAAAAAAAACwUCQFAAAAAAAAAAAAAABgoUgKAAAAAAAAAAAAAADAQpEUAAAAAAAAAAAAAACAhbKKi4uLM3cQQEoJjzZ3BAAsUVhkjLlDSHecM9qYOwQAQDLg8zkAAKnnd78Qc4eAdKyAeyZzhwAAQLphyPD8OswUAAAAAAAAAAAAAACAhSIpAAAAAAAAAAAAAAAAC0VSAAAAAAAAAAAAAAAAFuoFVhgAUl9ISIiaNGmie/fuac2aNSpZsqRZ41m3drUWL5yv27duycMjhzp07qKOnbq8UNvz585qyuRJOnXyhOLi4lSqTFkNGTpcxby8TOpFRUVp3pxZ2rRxvfzu3ZN79ux6481W6tGrtzJkMP1RjYyM1LQpk7V180Y9evRIRYp6qv/AwaparbpJvbmzZ8p3/z7d+uOmQkJC5OGRQzVr1Vavd96Vi4uLSV1/fz/NmDpFhw//pMCAALm5u6tO3fp6+50+cnJy/g+99nLSUp//+ssR9Xqra6LHWrJspUqVLmN8feinH7VzxzadOX1av1+7Kg+PHNq+e1+CdjOmTdHM6VOfeQ4LlyxT2XLlX+h8k0ta6vOzZ05r08YN+vWXI7pz57acHJ1UqnRp9Rs4WPnzFzDZZ+nins+Mq0rVapo1d4GktNnnL+ve3T+1eeM6HfrhoP64eUPWNtYqWKiI3ur1jipVqZag/uPHjzT124k6sG+PwsPD5V2ipAYOfV/FvLyNdY4d/UX93u7+zGO+02+g3urVJyVOBwAAAAAAAAAApACSApAmTZ8+XTExMeYOQ5K0etUKjR39iRo09FGXrm/p+PGj+nLcWIWHhalHr95Jtr1w/py6d+mo7B459E7f/oqLjdXKFcvUs3tnLV2xWvkLFDTW/XDkcO3euUNvtGwl7+IldObUKU2bMll3//xTo0Z/ZrLfjz8cqT27d6pTl67Kmze/Nm1cr/7v9tac+YtUrnwFY73z587Js1gxNW7SVBkzZdLv165p3ZpV+uHgAa1cu0EZM2aUJIWGhKhrx/YKCwtV2/Yd5eGRQ5cuXdSKZUv16y9HtGL1Ollbp97EImmxzyWpY+cuKl7CNEElT968Jq+3b92inTu2ycvLW27u7s+Ms36DhgnaStKUbycpNDRUJUqkbiJMWuvzBfPm6uSJ42ro01hFi3oqIMBfK5YtVfvWLbVk+UoVKVLUWPfzL75KENP5s2e19PvFJokyaa3Pk8NB331asnCeatepr6avt1BMTIy2bdmoge/20kefjtVrLVoa68bGxmrogHd15fJFderWQ05Ozlq7arn6vt1NC5euVt58+SVJ+QsU1Cdjv0hwrB1bN+vI4Z9UuWr1BNsAAAAAAAAAAEDaZRUXFxdn7iCAp129elWtW7fWiBEj9Mknn7zUTAHh0S8XS3h4uHzq11bJ0mU0dfosY/kHI4Zp/9692rXXV1kdHZ/Zvv+7vXXq5Elt3r7T+LS9v7+fmjf1UdVqNfTN5CmS4p+K7tS+jXr36at+AwYZ20/8+kstWbRAq9ZuUFHPYpKkM6dPq3OHNho67H11e6unJCkiIkKtWrwmF1dXLV66Islz2rNrp94bMlBffP2NmjRtJknatmWzPhgxTFOmz1Kt2nWMdadP/U6zZkzTijXr5fXUk8QpKS32+V8zBUz4ZrIa+jROMn4/v3tydnaRra2t+vd9R1d/+y3RmQISc/fPP9W4YV21bNUm0aSElJIW+/zkieMqXryEbO3sjPVu3Liu1m+8rgaNfDT+ywlJntOno/6nDevWauceX2X38Hhmvf/a52GRaSNp6drV3+Tikk1Ozn/P5hEZGaku7VsqLDRUm3b8Pfb27Nquj0a8p3FfTVK9hj6SpAf376vtG01VtXpNjRn/dZLHat28saysrLR64/aUOZnncM5oY5bjAgCS18t+PgcAAC/ud78Qc4eAdKyAeyZzhwAAQLpheIFpAFLv0V/gBY0dO1bt27dXgQIFnl85hf36yxEFBQWpXfuOJuXtO3RSWFioDh70TbL98WNHVaVqVZPp993c3FW+YiUdPLBfoSEhT+odkyQ1btLMpH3jJk0VFxennTv+vgm3Z9cO2djYqFWbdsYye3t7vdmqtU6dPKG7f/6ZZEw5c+WSFD+N+F+CQ4IlSa6uriZ1s7m5SZIM9vZJ7jM5pcU+f1pISLCio5/9bba7e3bZ2tomGeOzbN+2RXFxcWr62uv/qf1/lRb7vEzZciYJAZKUL19+FSpcRL9fu5ZkPJGRkdqze5fKV6iYZEKAZL4+Ty4FCxUxSQiQJDs7O1WrXlN+9+4qJOTvL4D279klF1dX1anf0Fjm7OKi+o18dNB3nyIjI595nHNnT+vWHzfl0/S15D8JAAAAAAAAAACQokgKQJqyY8cOXb58Wf369TN3KJKkixfOS5K8i5cwKff2Li5ra2tdvHAhyfaRkZGytzckKHcwGBQVFaUrV36TJEVFxd+MszeY3nw3GBwkxa/Xbozp4gXly5dfmTNnNqlbomQp4/anxcXF6cGD+wrw99fxY/FTwtvY2KhixUrGOuXLV5S1tbW+Gv+5Tp86qXt37+qHgwc0d/ZM1a3fQAUKFkryPJNTWuzzv4z66ANVq1RelcqVUs/uXXTu7JkXPKsXs23LZnl45FD5ChWTdb/Pk5b7/GlxcXEKDAwwST5IzA8HD+jxo0dq9lrzJOtJ5uvzlBYYGCCDwUEGw9/vy6WLF+RZzDvBUiDexUspPDxMN29cf+b+dm7bIknyaUJSAAAAAAAAAAAAr5oXmEwASB1hYWH64osvNGTIkAQ3vM3F399fNjY2CZ6gt7Wzk6OTk/z9/JJsn79AAZ0+fVIxMTGysYmf+joqMlJnTp+WJPnduydJypc/flaEkyeOK3fuPMb2x48fja/31HH8/f2NT/A/LVs2tyfbTWMKDAhQ/To1jK+ze3ho/FcTTG70FypcWB9/OkbfTPhKXTr+PQNB8xZv6pMxY5M8x+SWFvvc1tZWDRr6qEatWnJ2ctbVq1e1eOE8vdW1kxYtXZEsSytcufKbLl++pO49esnKyuql9/dvpMU+T8zWLZvkd++e+vYfmGS9bVs2y87OTg0a+SRZz5x9npL+uHlDB/btUb0GPsb3Q5ICA/xVtlyFBPWzZcsmSQrw91PhIkUTbI+JidGeXdvlXaKk8uTNl3KBAwAAAAAAAACAFEFSANKMGTNmyNXVVa1atTJ3KEYREeHPnAre3s5eERHhSbZv276jPh/zqT79+H/q3qOXYuNiNWfWDPn7+0uSwp+0r1mrtnLmzKVvvv5KBoODvIsX15nTpzR18iRlyJBBEeF/HyciIlx2/5hWXYpfQkCSSV1JcnR01Ky5CxQREaGLF85r757dCg0NTdA+u3t2lShRSjVr1VKOnLl0/NhRLV+6RE7Oznpv+IgkzzM5pcU+L1O2nMqULWd8XadefTVs5KM2LZvru0kTNWP2vJc86/gb2ZLUzAzT2KfFPv+n369d1fixY1S6TFk1b/HmM+sFBwfrh4O+qlGrtrJmzZpk3Obs85QSHham/70/RPb29uo7cKjJtoiIiARLMkiS3V/Xjme8z0d/+Vn3AwPVrUfv5A8YAAAAAAAAAACkOJICkCbcvn1b8+fP17Rp0/T48WNJMt64Dg0NVUhIiDJlypTqcdnbx09/npiIyIhEp0x/Wtt2HXTv7l0tnD9PmzaulyQVL15Cb/XoqTmzZypjxkxPjmOvKTNmafjQwXpv8ABJ8euCD35vuObOnqmMGTOaxJTY2t8RERHx2w2mMdna2alK1WqSpNp16qpylarq1rmDXFxcVbtOXUnSiePHNKBfHy1ZtlLFS5SUJNWr30CZM2fWzOlT9cabrVSocOGkOyuZpMU+T0zefPlUp2597d2zy+QJ+f8iLi5O27duUeEiRVXUs9h/3s9/ldb7PMDfX/37vqPMmbNowqTJSfb1nt07FRERoWbNkr7Rb+4+TwkxMTH6aOQw/X7tqiZNnSU3d3eT7fb29opK5NoR+de14xnv885tW2RjY6MGPk2SP2gAAAAAAAAAAJDiSApAmnDr1i1FRUWpd++ET6J27dpVpUuX1qpVq1I9Ljc3N8XExCgwMNBkavWoyEg9DApKcNMtMQMGDVG37j105cpvypIli4oU9dR3334jScqXL7+xXuHCRbRu4xZdvXpFjx4+VKFChWVvMGjCl+NV4an1zt3c3IzTsT8tIMD/yfakYypTtpzc3Ny0bctmY1LAmtUr5eLqakwI+EvtuvU0Y9oUnTp5ItWSAtJinz+Lh4eHoqKiFBYW9lJLXpw4fkx37tzWwMHv/ed9vIy03OePHz9W3z5v6/Gjx1qweKnc3bMnGce2LZuVJUsW1Xoytp/F3H2eEsZ/Nko//eCr0Z9/pQqVqiTY7prNzXideFpAQIAkKVsi147w8HD57t+jipWrytU1W7LHDAAAAAAAAAAAUh5JAUgTvLy8tHjxYpOyCxcuaPz48Ro9erRKliz5jJYpy7OYlyTp/LmzqlmrtrH83Lmzio2NlWexF3vCOKujo8qV/3st758PH1J2Dw8VKFjQpJ6VlZUKFy5ifP3DwQOKjY1V5SrVnoqpmH795YiCg4NNbkSfOX1KklTsScxJiYiIVHDwY+PrwIBAxcbEJqgXHRUd/3dM9HP3mVzSYp8/y61bt2Rvb//cWQWeZ9vWzbKyslLTZq+91H7+q7Ta5xERERrYr49u3Liu2XMXPDcxxd/fT7/+ckTN33gz0SU2nmbuPk9uUyZ9rS0b12vI8A/UqEmzROsU9SymkyeOKTY2VtbW1sbyc2dPy2BwUN6nkjf+8sOB/QoNCZFPE8voJwAAAAAAAAAA0iPr51cBUl7WrFlVuXJlkz9eXvE3KosXL67ixYubJa5KlavI0dFJq1YsNylftXK5DA4OqlWrjrHswYP7+v3aVYWFhSW5zx3bt+nc2TPq1KWbyY25fwoPD9e0KZPl5uamJs3+vsnXoFFjxcTEaO3qlcayyMhIbVy/TiVLlZZHjhyS4pddSCyWPbt26tGjh/IuXsJYli9/fgUGBujXX46YxrptiySpmJd3kueUnNJin9+/fz9B3UsXL8p3/z5VrVY9yX0+T1RUlHbv3KGy5corR86c/3k/LyMt9nlMTIzef2+wTp86qQnfTFbpMmWfex47tm1TbGysmj5n6YC00OfJ6ftF87R08QJ169lb7Tp2eWa9ug18dD8wUL57dxvLgh480L7dO1WjVp1EEyl2bd8ig8FBtevVT5HYAQAAAAAAAABAymOmACAJBoNB/QYM1LixYzRsyEBVq15Tx48d1dbNmzRg0BA5OjkZ665YtlQzp0/V3AWLVbFSZUnSsaO/ataMaaparbocnZx05tQpbdywTtVr1FSnzl1NjjV86CC5ubmrYKHCCgkJ1oZ1a3Xr1h+aOmO2MmX6e0aAUqVKq5FPY3337Te6HxioPHnzafPG9bpz57Y+/exzY72bN27onV7d5dO4qfIXLChrK2udO3dW27ZsUs5cudSpy9/H79CxkzauX6eB/fqoQ6cuypEzp479+qu2b9uiKtWqq1Sp0inUwwmlxT5//73BMhgMKl2mrFxcXHXt6hWtWbNKDg4GDRoyzGSfly/FJwtI0h83b+hx8GPNnjldUvyT2nXq1jOpf+inHxUUFKSmryV9IzslpcU+n/jVF/Ldv0+169TVw4dB2rJ5o8l+Xnu9RYLz2LZ1k9zc3Y1xPUta6PPk4rtvj6Z+O1F58uZT/gIFtX3rJpPtlapUM077X69BI60sWVpjP/2ffr92VY7Ozlq3arliYmP09rv9E+z74cMgHf7pB9Wt30gZM2ZKlfMBAAAAAAAAAADJj6QApFmVK1fWpUuXzB2G2nXopAwZbLV40Xz57t8nD48cGj7iA3Xq0u25bd3ds8va2kaLFsxTSEiIcuXOrX4DBqtrt+7KkMH0x8+7eAlt3LBOa1avlL29QeXKl9f4ryaqmFfC5QDGjv9K06Z8qy2bN+nRo4fx67dPm6nyT63Jnt0ju+o39NEvv/ysTRs3KDo6Sjly5lL7Dp3U650+cnJyNtbNX6CgVqxeq6nffautmzcpICBA7u7u6vZWD73bb+BL9N5/k9b6vG79Btq2ZbOWLFqokJBgOTs7q36Dhurzbn/lzZfPpO6F8+c1bcpkk7K/Xjdv8WaCpIBtWzYrQwZbNWrU+IX7JyWktT6/dOmiJOmA734d8N2f4Jj/TAq4/vs1nT93Tl26vfXcmRvSSp8nh98ux/fTHzdvaPRHIxNsnzZnoTEpwMbGRt9MnakpkyZo1YrvFREeIa/iJfTx6HHKl79Agrb7du9UdHT0M5cjAAAAAAAAAAAArwaruLi4OHMHAaSU8GhzRwDAEoVFxpg7hHTHOaONuUMAACQDPp8DAJB6fvcLMXcISMcKuDPrIAAAqcXwAtMA/PeFsAEAAAAAAAAAAAAAQJpGUgAAAAAAAAAAAAAAABaKpAAAAAAAAAAAAAAAACwUSQEAAAAAAAAAAAAAAFgokgIAAAAAAAAAAAAAALBQJAUAAAAAAAAAAAAAAGChSAoAAAAAAAAAAAAAAMBCkRQAAAAAAAAAAAAAAICFIikAAAAAAAAAAAAAAAALRVIAAAAAAAAAAAAAAAAWiqQAAAAAAAAAAAAAAAAsFEkBAAAAAAAAAAAAAABYKJICAAAAAAAAAAAAAACwUBnMHQAAAAAAAHi+dWtXa/HC+bp965Y8PHKoQ+cu6tipi7nDQjrA2ENacPzYUb3VtZMkyffHw3J2djFzRHiVRESEa/bkL/XbhbMK8L+n2JgYeeTMrfpNWqjJG22UIYOtSf3g4MdaNPNbHflxvyIiwlWkWAm99e4QFSrqZVIvLCxUS+dN0+EDe/Xw4QN55MilZi07qEmLNql5erAw/N6FOTH+YC6MvZRHUgAAAAAAAGnc6lUrNHb0J2rQ0Eddur6l48eP6stxYxUeFqYevXqbOzxYMMYe0oLY2Fh9MW6sHBwyKiws1Nzh4BUUGRGhP65fVbnK1eXukVPW1ta6ePaU5k+fqMsXzuq9j8cZ68bGxmrsyIG6fvWy3mjfVVmzOmn7xtX6aEhvTZy1VDlz55UkxcTEaPTwfrpy+byatmirHLnz6sSvhzXr2/EKfvxIbTr3NNfp4hXG712YE+MP5sLYSx1WcXFxceYOAkgp4dHmjgCAJQqLjDF3COmOc0Ybc4cAAEgGfD7/b8LDw+VTv7ZKli6jqdNnGcs/GDFM+/fu1a69vsrq6GjGCGGpGHtIK1atXK5p332rZq8119LvFzNTwAv63S/E3CGkebO/+1Lb1q/UgrW75OySTZL04/5dmjBmpN7/9CtVq91AkvQw6IH6dnlD5SpVNyYQ/OS7W1+PHqH+w0epQdM3jPv88pPhOvbzj5q9Yquc0vE4LeCeydwhvHL4vQtzYvzBXBh7ycPwAtMAWKd8GAAAAAAA4L/69ZcjCgoKUrv2HU3K23fopLCwUB086GuewGDxGHtICx4GBWnad9+qb/+BypI1q7nDgYVx98gpSQoJfmwsO3Rgr5ycXVWlZj1jmaOTs6rXaahfDvkqKjJSknT+9AlJUs16Pib7rFnPR5GREfrlJ98Ujh6Wht+7MCfGH8yFsZd6SAoAAAAAACANu3jhvCTJu3gJk3Jv7+Lx0x9fuGCOsJAOMPaQFkybMlmu2dzUum17c4cCCxAVFaVHDx/I3++ufv5hnzauXCK37DmUI1ceY53fr1xUwaLFZG1t+tV5kWIlFBEertu3bjzZV6SsrW2UwdbWpJ6dvUGSdPUy10j8O/zehTkx/mAujL3U8wKTCQAAAAAAAHPx9/eXjY2NXF1dTcpt7ezk6OQkfz8/M0UGS8fYg7ldvnRRa1av1NQZs2Vjw5JieHk//7BPEz/7wPi6sKe3+r//iWxs/v6a/EFggLxLlUvQ1tk1fnmBBwH+yl+wiHLlya/Y2BhdOn9G3iXLGutdOBM/g0BgANdI/Dv83oU5Mf5gLoy91ENSAAAAAACkc/7+/oqKilLOnPFT6MbFxWn37t26ceOG8ubNq/r16ytDBv77aC4REeGy/cdTiH+xt7NXRER4KkeE9IKxB3P7cvznql6jlqpVr2HuUGAhSpapoNETZigk+LFOH/9Fv1+9rIjwMJM6kZERsrW1S9DWzi6+LCIyQpJUq0FjrVw8W1O/Gq3eg0YqR+68OvnrYW3fuDp+PxERKXw2sDT83oU5Mf5gLoy91MO3OgAAAACQTgUHB2vQoEE6dOiQJKl+/fqaMGGC3nnnHR05ckQZMmRQdHS0vLy89P333ytTpkxmjjh9src3KCoqKtFtEZERsn8yTTGQ3Bh7MKcd27fp5IkTWrtxs7lDgQVxcnGVk0v8k4jVajfQ6u/n6ZNhfTXj+w1ydomfCcDOzl5RUZEJ2kZGxpfZ29lLkpxdsul/n0/St+M/1qfD+0qSMmbKrLcHvK/JX4ySwSFjapwSLAi/d2FOjD+YC2Mv9Vg/vwoAAAAAwBJNnTpV586d05gxYzR58mTdunVLAwcO1B9//KENGzbo7NmzWrFihfz9/bVgwQJzh5tuubm5KSYmRoGBgSblUZGRehgUJDd3dzNFBkvH2IM5TZrwlRr5+MjW1la3b9/S7du39PjRI0nS3bt35ed3z8wRwhJUq91A4WGh+uVHX2OZs2s2PbgfkKDug8D4Mudsbsay4qXLa+bSzfpmznKN/26+5q3eoaLeJSVJOXPnTdngYXH4vQtzYvzBXBh7qYekAAAAAABIp/bs2aMBAwaoTZs2atSokT7//HMdPHhQffv2VbFixSRJZcqUUc+ePbVz504zR5t+eRbzkiSdP3fWpPzcubOKjY2V55P3CkhujD2Y0927f2rb1i1q2qi+8c/S7xdLktq3flP9+/Q2c4SwBH9N8R8SEmwsK1DYU9cuX1RsbKxJ3csXzsjeYFCu3PlMym1sbFSwsKe8SpaRg0NGnTp2RJJUunzlFI4elobfuzAnxh/MhbGXelg+AAAAAADSqXv37qlo0aLG10WKFDH5+y/FihXT7du3UzU2/K1S5SpydHTSqhXLVbNWbWP5qpXLZXBwUK1adcwXHCwaYw/mNOm7aQnKdmzfqp3bt2ns+C+VPbuHGaLCq+rRwwfKktVJVlZWJuW7t62XJBX29DaWVatVX4cO7NHPP+xTtdoNjO0PHdijilVrydbO7pnHeRj0QOtXLFT+gkVICsC/xu9dmBPjD+bC2Es9JAUAAAAAQDqVOXNmBQUFGV9nyJBB2bNnl4ODg0m9iIgIWVsz0Zy5GAwG9RswUOPGjtGwIQNVrXpNHT92VFs3b9KAQUPk6ORk7hBhoRh7MKd69RskKLt08YIkqUbNWnJ2dkntkPAK8929TTs3rVXlGnWUPUcuhYWF6sSvh3Xq6M+qWK2WSpWrZKxbtXYDea5dpu++/FR/XL+mLI5O2rFxtWJjY9Whex+T/f5vUC95Fi+lHLny6MH9QO3ask7hYaH637jJfHbCv8bvXZgT4w/mwthLPSQFAAAAAEA6VbhwYZ06dUoNGzaUJFlbW+vAgQMJ6l26dEl587Iurjm169BJGTLYavGi+fLdv08eHjk0fMQH6tSlm7lDg4Vj7AGwBN4ly+ri2dP6Yd8OBd2/LxsbG+XMk089+g5Vs5btTera2Njo4y+maOHMb7Vl3QpFRoarsGdxDRw5Wrny5jepW6iol346sEf3/f2UMVMmlS5fRR17vCuPnLlT8exgSfi9C3Ni/MFcGHupwyouLi7O3EEAKSU82twRALBEYZEx5g4h3XHOaGPuEADAIh04cEAPHz5U8+bNk6w3YMAAlSpVSm+//fZLHY/P5wAApJ7f/ULMHQLSsQLumcwdAgAA6YbhBaYBICkAFo0vHQGkBJICUh9JAQBgGfh8DgBA6iEpAOZEUgAAAKnnRZICWNgIAAAAAAAAAAAAAAALRVIAAAAAAAAAAAAAAAAWiqQAAAAAAAAAAAAAAAAsFEkBAAAAAAAAAAAAAABYKJICAAAAAAAAAAAAAACwUCQFAAAAAAAAAAAAAABgoUgKAAAAAAAAAAAAAADAQpEUAAAAAAAAAAAAAACAhSIpAAAAAAAAAAAAAAAAC0VSAAAAAAAAAAAAAAAAFoqkAAAAAAAAAAAAAAAALBRJAQAAAAAAAAAAAAAAWKgM5g4AkKR169bpgw8+SFD+9ttva9iwYWaIyNS6tau1eOF83b51Sx4eOdShcxd17NTlhdqeP3dWUyZP0qmTJxQXF6dSZcpqyNDhKublZVIvKipK8+bM0qaN6+V3757cs2fXG2+2Uo9evZUhg+mPamRkpKZNmaytmzfq0aNHKlLUU/0HDlbVatWNdcLCwrRx/Trt379XVy5fVmhoiPLkzafWbdqqVZt2srGxeWbMW7ds0ocjhsvBIaN+PnriX/TUq2nVimX65cjPOnP6tO7e/VPNW7ypz8Z9Ye6w0oS0NPZ//eWIer3VNdFjLVm2UqVKlzG+PvTTj9q5Y5vOnD6t369dlYdHDm3fve/fd0Aad+/un9q8cZ0O/XBQf9y8IWsbaxUsVERv9XpHlapUS1D/8eNHmvrtRB3Yt0fh4eHyLlFSA4e+r2Je3ib1vp3whY4f+1V379xWRGSkPHLkVINGjdWp61vKmDFTap0eAAAAAAAAAABIBiQFIE2ZO3eusmTJYnydPXt2M0YTb/WqFRo7+hM1aOijLl3f0vHjR/XluLEKDwtTj169k2x74fw5de/SUdk9cuidvv0VFxurlSuWqWf3zlq6YrXyFyhorPvhyOHavXOH3mjZSt7FS+jMqVOaNmWy7v75p0aN/sxkvx9/OFJ7du9Upy5dlTdvfm3auF793+2tOfMXqVz5CpKkW7f+0BfjPlPlKlXVpVt3ZcqcWYd++lGffzZap0+d0tjxXyYac2hIiCZN/FoODhlfsudeHQvmzVVISIhKlCypgAB/c4eTZqTFsS9JHTt3UfESJU3K8uTNa/J6+9Yt2rljm7y8vOXm7v4SvZC2HfTdpyUL56l2nfpq+noLxcTEaNuWjRr4bi999OlYvdaipbFubGyshg54V1cuX1Snbj3k5OSstauWq+/b3bRw6WrlzZffWPf8ubMqU7a8cjd/U3b29rp88YKWLJirX4/8rJnzFsvamomGAAAAAAAAAAB4VVjFxcXFmTsI4K+ZAg4fPiwXF5dk22949Eu2Dw+XT/3aKlm6jKZOn2Us/2DEMO3fu1e79voqq6PjM9v3f7e3Tp08qc3bd8rJyVmS5O/vp+ZNfVS1Wg19M3mKJOnsmdPq1L6Nevfpq34DBhnbT/z6Sy1ZtECr1m5QUc9ikqQzp0+rc4c2GjrsfXV7q6ckKSIiQq1avCYXV1ctXrpCkvTgwX0FBgaqcOEiJjGN+ugDbVy/Tpu37VLefPkSxPztNxO0f98eeRcvof1796aLmQLu3LmtHDlyysrKSlUqlFXDRj7pfqaAtDj2/5opYMI3k9XQp3GS8fv53ZOzs4tsbW3Vv+87uvrbb8k6U0BYZEyy7etlXLv6m1xcssnJ2dlYFhkZqS7tWyosNFSbdvx9znt2bddHI97TuK8mqV5DH0nSg/v31faNpqpavabGjP86yWMtXbxAUyZ9rbmLlqtEqdIpc0JJcM747NlNAACvjpf9fA4AAF7c734h5g4B6VgBd2YaBAAgtRheYBoAHvUDkvDrL0cUFBSkdu07mpS379BJYWGhOnjQN8n2x48dVZWqVY03RSXJzc1d5StW0sED+xUaEvKk3jFJUuMmzUzaN27SVHFxcdq5Y7uxbM+uHbKxsVGrNu2MZfb29nqzVWudOnlCd//8U5Lk7OySICFAkurVbyhJunbtaoJtN25c1/eLF2rY+x8og036mUgkZ85csrKyMncYaUpaHPtPCwkJVnT0s+8quLtnl62tbZIxWoKChYqYJARIkp2dnapVrym/e3cVEvL3F0D79+ySi6ur6jy5BkiSs4uL6jfy0UHffYqMjEzyWDly5pIUvwQBAAAAAAAAAAB4dZAUgDTltddek5eXl+rXr69Zs2YpJsa8T+NevHBekuRdvIRJubd3cVlbW+vihQtJto+MjJS9vSFBuYPBoKioKF258pskKSoq/macvcHepJ7B4CApfipvY0wXLyhfvvzKnDmzSd0SJUsZtyclMCBAkuT8jxuJkvT1F+NUsVJl1axVO8l9wPKlxbH/l1EffaBqlcqrUrlS6tm9i86dPfOCZ5V+BAYGyGBwkMHw93tw6eIFeRbzTjD1v3fxUgoPD9PNG9dNyqOjoxX04IH8/fx05PBPmjX9O2XMlEne/1i6AQAAAAAAAAAApG3p51FgpGlubm4aMGCASpcuLSsrK+3bt0/ffvut7t27p1GjRpktLn9/f9nY2MjV1dWk3NbOTo5OTvL380uyff4CBXT69EnFxMTIxiZ+6uuoyEidOX1akuR3754kKV/+ApKkkyeOK3fuPMb2x48fja/31HH8/f2Vzc0twbGyZXN7sv3ZMUVFRur7JYuUK3fuBGuyHzzgq8OHftKqtRuTPCekD2lx7Nva2qpBQx/VqFVLzk7Ounr1qhYvnKe3unbSoqUr5OXl/ZJnbRn+uHlDB/btUb0GPsa+l6TAAH+VLVchQf1s2bJJkgL8/VS4SFFj+cXz59SrWwfj63z5C+jrb6fJ0dEp5YIHAAAAAAAAAADJjqQApAk1a9ZUzZo1ja9r1Kghe3t7LVq0SH369JG7u7tZ4oqICH/mFOT2dvaKiAhPsn3b9h31+ZhP9enH/1P3Hr0UGxerObNmyN/fX5IU/qR9zVq1lTNnLn3z9VcyGBzkXby4zpw+pamTJylDhgyKCP/7OBER4bKzs0sYj338k9ZP1/2n8Z9/pmtXr2jqjNnKkOHvH/+oyEh9/eV4tW7bXoUKF07ynJA+pMWxX6ZsOZUpW874uk69+mrYyEdtWjbXd5MmasbseS951q++8LAw/e/9IbK3t1ffgUNNtkVERMg2kWuH3V/Xjn+8pwUKFtJ3M+YqPCxMp0+f1K9HDissNDTlggcAAAAAAAAAACmC5QOQZjVp0kQxMTG68JxpylOSvX38VOeJiYiMSHR69Ke1bddBvXr30batW9SyRTO1fuN13bp5U2/16ClJypgx05Pj2GvKjFlydHLSe4MHqEnDevrogxHq/W4/ZXV0VMaMGU1iSmzt74iIiPjthsRjWjh/rtauWaV+AwYlWB5gyeKFCnrwQH37DUjyfJB+pMWxn5i8+fKpTt36+vWXI2ZfbsTcYmJi9NHIYfr92lWN+/pbuf0jmcre3l5RiVw7Iv+6dvzjPc2UObMqVammWnXrq/+g99SxS3e9P6S/frt0MeVOAgAAAAAAAAAAJDtmCgCS4ObmppiYGAUGBppMox4VGamHQUEJbrolZsCgIerWvYeuXPlNWbJkUZGinvru228kSfny5TfWK1y4iNZt3KKrV6/o0cOHKlSosOwNBk34crwqVKhoEtNfU68/LSDA/8n2hDFtXL9O334zQW3atVfvPn1Ntj1+/FhzZs1Q2/YdFRwSrOCQYElSaGio4hSn27dvyWBwSDCNPCxbWhz7z+Lh4aGoqCiFhYUpc+bM//5kLcT4z0bppx98Nfrzr1ShUpUE212zuRmvE08LCAiQJGVL5NrxtDr1Gmq0Rmr3zm0q4lksWWIGAAAAAAAAAAApj6QApFnbtm2TjY2NvL3Nt064ZzEvSdL5c2dNnq4/d+6sYmNj5VnsxW6MZXV0VLnyf6/l/fPhQ8ru4aECBQua1LOyslLhwkWMr384eECxsbGqXKXaUzEV06+/HFFwcLDJDdAzp09Jkoo9ifkv+/ft0ehPPlL9Bo304UefJIjt0aOHCg0N1cL5c7Vw/twE25s2qq+69err2ynTX+hcYRnS4th/llu3bsne3v65swpYsimTvtaWjes1ZPgHatSkWaJ1inoW08kTxxQbGytr678nCjp39rQMBgflfSpRIzFRkZGKjY1VcHBwcoYOAAAAAAAAAABSGEkBSBN69uypypUry9PTU5K0d+9erVq1Sl27dpWbm5vZ4qpUuYocHZ20asVykxujq1Yul8HBQbVq1TGWPXhwX0EPHsgjR045ODg8c587tm/TubNnNHT4CJMbc/8UHh6uaVMmy83NTU2a/X2Tr0Gjxlq0YL7Wrl6pbm/FT8UeGRmpjevXqWSp0vLIkcNY99jRXzVi2FCVK19B47+akOjxXFxcNem7aQnKl32/WKdPndQXX3+jbGZ8D2AeaXHs379/Xy4uLiZ1L128KN/9+1SjZs0k92nJvl80T0sXL1C3nr3VrmOXZ9ar28BH+/bsku/e3arX0EeSFPTggfbt3qkaterIzs5OkvT48SM5GByUwdbWpP3G9WskSV7exVPoTAAAAAAAAAAAQEogKQBpQoECBbR27VrdvXtXsbGxyp8/vz788EN16fLsG1ypwWAwqN+AgRo3doyGDRmoatVr6vixo9q6eZMGDBoiRycnY90Vy5Zq5vSpmrtgsSpWqiwp/qb8rBnTVLVadTk6OenMqVPauGGdqteoqU6du5oca/jQQXJzc1fBQoUVEhKsDevW6tatPzR1xmxlyvT3jAClSpVWI5/G+u7bb3Q/MFB58ubT5o3rdefObX362efGenfu3Nag/u/KyspKDRv5aNfO7SbHK1rUU0U9i8nBwUH16jdIcO779+7R2TNnEt1maXz379PlJ+ukR0dH6fLlS5o9M35mhDp166loOpwqPS2O/fffGyyDwaDSZcrKxcVV165e0Zo1q+TgYNCgIcNM9nn5UnyygCT9cfOGHgc/Nr6nRT2LqU7deinRbanOd98eTf12ovLkzaf8BQpq+9ZNJtsrVakmV9dskqR6DRppZcnSGvvp//T7tatydHbWulXLFRMbo7ff7W9sc/zoL/rmq3GqW99HefLmU3R0lE4ePybffbvl5V1CjZu9nqrnCAAAAAAAAAAAXg5JAUgTPvroI3OH8EztOnRShgy2Wrxovnz375OHRw4NH/GBOnXp9ty27u7ZZW1to0UL5ikkJES5cudWvwGD1bVbd2XIYPrj5128hDZuWKc1q1fK3t6gcuXLa/xXE1XMyyvBfseO/0rTpnyrLZs36dGjh/FrtU+bqfJPrb9++9YtPX78WJI0buyYBPvo07d/urzZnZi9u3dp08b1xtcXL5zXxQvnJUnZs3uk235Ka2O/bv0G2rZls5YsWqiQkGA5OzurfoOG6vNuf+XNl8+k7oXz5zVtymSTsr9eN2/xpsUkBfx2OT6Z5Y+bNzT6o5EJtk+bs9CYFGBjY6Nvps7UlEkTtGrF94oIj5BX8RL6ePQ45ctfwNimUOGiKl+hsn44sE8BAf5SXJxy5c6jHr3fVeduPWRra5c6JwcAAAAAAAAAAJKFVVxcXJy5gwBSSni0uSMAYInCImPMHUK645zRxtwhAACSAZ/PAQBIPb/7hZg7BKRjBdwzmTsEAADSDcMLTAOQPhdgBgAAAAAAAAAAAAAgHSApAAAAAAAAAAAAAAAAC0VSAAAAAAAAAAAAAAAAFoqkAAAAAAAAAAAAAAAALBRJAQAAAAAAAAAAAAAAWKgM5g4AAAAAAAAAAJC8CrhnMncISMf8HkWYOwSkU+5Z7c0dAgCkScwUAAAAAAAAAAAAAACAhSIpAAAAAAAAAAAAAAAAC0VSAAAAAAAAAAAAAAAAFoqkAAAAAAAAAAAAAAAALBRJAQAAAAAAAAAAAAAAWCiSAgAAAAAAAAAAAAAAsFAkBQAAAAAAAAAAAAAAYKFICgAAAAAAAAAAAAAAwEKRFAAAAAAAAAAAAAAAgIUiKQAAAAAAAAAAAAAAAAtFUgAAAAAAAAAAAAAAABaKpAAAAAAAAAAAAAAAACwUSQEAAAAAAAAAAAAAAFgokgIAAAAAAAAAAAAAALBQGcwdAAAArxobaytzhwAAAAAAAAAAAPBCmCkAAAAAAAAAAAAAAAALRVIAAAAAAAAAAAAAAAAWiqQAAAAAAAAAAAAAAAAsFEkBAAAAAAAAAAAAAABYKJICAAAAAAAAAAAAAACwUCQFAAAAAAAAAAAAAABgoUgKAAAAAAAAAAAAAADAQpEUAAAAAAAAAAAAAACAhSIpAAAAAAAAAAAAAAAAC0VSAAAAAAAAAAAAAAAAFoqkAAAAAAAAAAAAAAAALBRJAQAAAAAAAAAAAAAAWCiSAgAAAAAAAAAAAAAAsFAkBQAAAAAAAAAAAAAAYKFICgAAAAAAAAAAAAAAwEJlMHcAAAAAAADg+datXa3FC+fr9q1b8vDIoQ6du6hjpy7mDgsWbtWKZfrlyM86c/q07t79U81bvKnPxn1h7rCQjnDtg7kw9pBc/O7d1c4t63Xkpx90+9YNWVvbKH/BwurUvbfKVaqSoH7w40eaM22SfjqwTxHhYfL0Lql3Br6nIp7eCeqGhoRo6YJZOrhvlwID/JXV0VneJUvp/VGfy2BwSI3Tg4Xh2gdzYeylPGYKAAAAAAAgjVu9aoVGj/pIhQoV0cgPP1apMmX05bixmj93trlDg4VbMG+ufjlyRIUKF1aGDDxbgtTFtQ/mwthDcjp0cL9WLlmgnLnzqHvvAer0Vm+FhYZoxKDe2rFlg0nd2NhY/e+9/tq3a5tatG6vXv2GKujBfQ3r21O3/rhhUjck+LGGvNtdO7ZsUJ2GTTRw+Ed6o21HRUZEKioyKhXPEJaCax/MhbGXOqzi4uLizB0EkFLCo80dAQBLFBkda+4Q0p2sBvIYAcAS8Pn8vwkPD5dP/doqWbqMpk6fZSz/YMQw7d+7V7v2+iqro6MZI4Qlu3PntnLkyCkrKytVqVBWDRv5MFMAUgXXPpgLYy95+D2KMHcIacb1a1fk7OIqRydnY1lkZKT6dG2j8LBQLdu421h+YM9Ojf14uD7+fIJq1WskSQp6cF9vtXtdFavU0IdjvjTW/e7rsdq/e7umL1ypHDlzp94JpXHuWe3NHcIriWsfzIWxlzwML5C/zTfsAAAAAACkYb/+ckRBQUFq176jSXn7Dp0UFhaqgwd9zRMY0oWcOXPJysrK3GEgHeLaB3Nh7CG55S9Y2CQhQJLs7OxUqVpN+fvdU2hIiLH84P7dcnZxVY06DYxlTs4uql3PR4d/2K/IyEhJ8UsM7NyyUU1btFaOnLkVFRVl3Ab8F1z7YC6MvdRDUgDSlPXr1+uNN95QyZIlVblyZfXq1Uvh4eHmDkvr1q7WG683UcWyJfV6k0ZatnTJC7c9f+6s3u3dU9UqlVPVimX1zts9dPHChQT1oqKiNHP6VDX1qa8KZUqoqU99zZ45XdHRpo9TnT1zWuPGjtGbzZupcoUy8qlfR8OHDtL1678n2OfHH45U6eKeCf60eK1xkjFv3bJJpYt7qkqFsi98nsktpfv89u1bifbNX39Gj/rIWPdZ/fjXn3v37hnrvuj7+E9zZs1Q6eKeatnitRc+z+SWGuM8NjZWq1YuV9uWLVSlQlnVrVVNfd/ppZMnjpvU+/WXI8/s79OnTprUPfTTj/rk4w/VssVrKlvSS00a1ntmnDdv3NB7gweqRtWKqly+tLp17qBfjvz8wueZFq1ZtVwjhw3Waz71VLG0lz79+INE6x0/9quGDuyrZo3qqnrF0vKpV1MD3n1bp/7R93+JiorUgrmz1LpF0/j6dWtocP93dO/e3ZQ8HQAAkIiLF85LkryLlzAp9/YuLmtr60Q/dwHAq45rH8yFsYfU8iAwQAaDQfYGg7HsyuWLKuzpJWtr01s3nt4lFB4erts3r0uSzp46ocjICOXKnUdjPhyq1+pW0mt1KmpQ7666cvliap4GLATXPpgLYy/1sBgc0owZM2Zozpw56tOnj8qUKaMHDx7o8OHDiomJMWtcq1et0NjRn6hBQx916fqWjh8/qi/HjVV4WJh69OqdZNsL58+pe5eOyu6RQ+/07a+42FitXLFMPbt31tIVq5W/QEFj3Q9HDtfunTv0RstW8i5eQmdOndK0KZN1988/NWr0Z8Z6C+bN1ckTx9XQp7GKFvVUQIC/VixbqvatW2rJ8pUqUqSoSQx2dnb6ZMxYk7LMmbM8M+bQkBBNmvi1HBwy/ptuSlap0efOzi76/IuvErT/6ccftG3LZlWtXt1Y1rptO1WuWtWkXlxcnMaO+VQ5c+ZS9uzZjeUv+j4+7d7du5o7Z5bF97kkfTPhKy1ZtEDNXm+utu076vHjR1qzeqV6du+ihUuWq2SpUib77ti5i4qXKGlSlidvXpPX27du0c4d2+Tl5S03d/dnxnn3zz/VtVM7WVvbqPtbPeXg4KCN69fp3d49NXveQpWvUPFFuytNWbxgrkJDQuRdopQCAvyfWe/mjeuytrZWqzbt5OqaTY8eP9L2rZvVu0cXTZo6U9Wq1zTWjY6K0uD+fXT65Em90aq1ihTx1KNHj3Tu7GkFP36s7Nk9UuPUAABmFBoaqh49euiTTz6Rl5eXucNJ9/z9/WVjYyNXV1eTcls7Ozk6Ocnfz89MkQFAyuHaB3Nh7CE13P7jpn703ata9RrKxsbGWH4/0F+lypRPUN8lm5skKSDAXwUKF9XtP25KkubN+E45c+XWiI/HKiQkWEvmzdT7/XtpzrL1cn3SBngRXPtgLoy91ENSANKEa9euaerUqZo+fbpq165tLPfx8TFjVPFrmUydPEk1a9fRxG+/kyS1atNWsbGxmj1zhlq3aZfkWibTpkyWvb1BS5atkNOTKaKavd5czZv66LtvJ+mbyVMkxT/9v2vHdvXu01f9BgySJLVt10FOzs5asmiB2nfspKKexSRJXbp11xdfTZCtnZ3xOD5Nmqr1G69r/tzZGv/lBJMYbGwy6LXXW7zwOc+eNUOZMmVSxUqVtX/v3hdul1xSq88zZsyYaL9s2rBemTNnVu06fz9tXrpMWZUuYzprwvFjRxUeFqZmr71uLPs37+PTJk74UqVKlVZsbKwePHjwol2VbFKrz6Ojo7V65XI1bOSjcV98bWzf0Kexmvk00LatmxIkBZQrV0ENfZKe2WLA4CEaNfoz2draqn/fd3T1t98SrTd/7mw9fvxYazdsNiYqtGzdVm+81kRffzleK1ave05PpU2z5i2Wx5M1XmtVSfifxr+80bKN3mjZxqSsTdsOatGskZZ/v9gkKWDZ94t0/OhRzV34vYqXLPXPXQEALMS5c+eeuS00NFQnT57U2bNnFRsbK0kqXrx4aoWGf4iICJetrW2i2+zt7BURYf7Z1QAguXHtg7kw9pDSwsPD9Nn/hsne3l49+w422RYZESFbu4Tjz+7Jd8GRERGSpLCwUEmSlZWVvpoyVw4Z4x82KlS0mAa93UWb1q7QW+8MSMGzgKXh2gdzYeylHpYPQJqwbt065c6d2yQhIC142bVMjh87qipVqxpvlEqSm5u7ylespIMH9hvXizp+7JgkqXGTZibtGzdpqri4OO3csd1YVqZsOZOEAEnKly+/ChUuot+vXUs0jpiYGAUHByd9spJu3Liu7xcv1LD3P1AGG/PkDKVWnyfG399Pv/5yRPUaNJK9vX2Sx9m+dYusrKzUpNnf0/3/m/fxL8eO/qo9u3bq/ZEfJnm8lJRafR4dHa3w8HC5uGYzae/i4ipra2vZ2xuUmJCQ4CSXX3B3z/7MDw0mcR4/Ks9iXiYzFzg4OKh23Xq6cP6cbty4/tx9pEU5XmKNV4ODg5ydnRX8+JGxLDY2ViuWLlGdevVVvGSp+PctLCy5wgUApCGtWrVS69at1bp1a5N/t27dWl27dpUkjRo1yrgN5mNvb1BUVFSi2yIiI575OQoAXmVc+2AujD2kpJiYGH3+8fu6ef2qPh43UdncTGe9tLO3V1RkwvEXGRlp3C7J+N1lleq1jQkBkuRdorQ8cubS+TMnU+gMYKm49sFcGHuph6QApAmnTp1S0aJFNX36dFWtWlUlSpRQ+/btderUKbPG9bJrmURGRiZ6wXIwxF/krlyJf6I5Kir+Q529wfRGtMHgICl+vfakxMXFKTAwwOSm7F/Cw8NUrXJ5Va9cXjWrVtK4z0Y/88b411+MU8VKlVWzlvmSM1KrzxOzY9s2xcbGmjz9n5ioqCjt2rldpcuUVa5cuZ8q/3fvY0xMjL74/DO92aq1ihT1TPKYKSm1+txgMKhkqdLatGG9tm7ZpD/v3NHlSxc16n8jlTVrVrVu0y7BPkZ99IGqVSqvSuVKqWf3Ljp39sx/PU1FRkbKYEg8Tkk6n8TTkpYkODhYQQ8e6Prv1zTtu0m6euU3Vaz89/IY165ekb+/n4oU9dTnY0apVpVyqlmlnDq0bqGjvxwxY+QAgOTm7u4uV1dXjR49WosXL9aiRYuMf6ZPny5JGjlypHEbzMfNzU0xMTEKDAw0KY+KjNTDoKAkl1ACgFcV1z6YC2MPKWnS+NE68tNBDfvoM5WtUDnBdhdXNwUGJlwe8v6TJSOzPVkS4K+lAZxdXBPUdXJ20eNHj5MzbKQDXPtgLoy91MPyAUgT/P39dfbsWV2+fFmffPKJHBwcNHPmTPXo0UO7du1KsJZIasb1MmuZ5C9QQKdPn1RMTIxxbaioyEidOX1akuR3754kKV/+ApKkkyeOK3fuPMb2x48fja/3nONs3bJJfvfuqW//gSbl2dzc1L1HL3l5eys2Nk6HfvxBK1cs06VLFzVv4RJlyPD3JeDgAV8dPvSTVq3dmOSxUlpq9Xlitm3dJDc3N1WqXCXJYxz66UcFBQUlSB74t+/j6pUr9OefdzRr3sIkj5fSUrPPx33xtd4fNkQfjhhuLMudJ48Wfb9cufP83We2trZq0NBHNWrVkrOTs65evarFC+fpra6dtGjpCnl5ef/r88yfv4COHz+mkJBgZcqU2Vh+4sTx+Dj9nj02LMkHw4fo50M/Sorv55at26ln73eN2/+4eUNS/BICjlkd9cHHoyVJC+fO0sC+b2vRstVmTWIBACSfHTt2aNq0aRo/frw6duyovn37KlOmTJKkx4/jv0T09vZWxYoVzRkmJHkW85IUn2T6dALvuXPxyzt4Fku4RBUAvOq49sFcGHtIKbOnTNTOrRv07uD3Va9R00TrFCriqbOnjis2NlbW1n8/03nx/BkZDAblyptfklSkWPx3YwH+Cb/PCgzwV558BZL/BGDRuPbBXBh7qYeZApAmxMXFKTQ0VJMnT1bjxo1Vu3ZtzZgxQ3Fxcfr+++/NFtfLrmXStn1H3bh+XZ9+/D9dvXJFv/12Wf/7cIT8/eMzO8OftK9Zq7Zy5sylb77+Snt279KdO7e1c8c2TZ08SRkyZFBE+LOP8/u1qxo/doxKlymr5i3eNNk2aMh7Gjx0mHwaN1WTps302bgvNGDQEJ08cVy7d+001ouKjNTXX45X67btVahw4Rfqm5SSWn3+T9ev/67z587Jp0kzkw/cidm+dYsyZLBVo8ZNTMr/zfsYFPRA06d+p7f79JWLi0uSx0tpqdnnmTJlUqHChdWuQyd9M3mq/vfxJ4qJjtHggf304MF9Y70yZctp4rff6c2WrVWnXn31fLu3lixbJSsrK303aeJ/Os+27Tvo8aNHev+9Ibpw4byuX/9dX43/XOfOxs/gkNTPmSXpP2iops6cq48/HasSpUorKipKMTF/L88QFhq/Jl1oSIimzVmg11u8qddbvKlps+crLk5avGCeuUIHACSzjBkzavjw4VqzZo0uXLggHx8frV+/3txhIRGVKleRo6OTVq1YblK+auVyGRwcVKtWHfMEBgApiGsfzIWxh5Sw6vsFWr1skTp066WW7To/s16teg314H6gfvTdYyx7GPRAB/ftUpUadWT3ZFnZPPkKqGARTx36wVcPgx4Y6x49ckj+9+6qfMWkH3oC/olrH8yFsZd6mCkAaULWrFnl5OSkYk9l/Dg5Ocnb21tXrlwxW1wvu5ZJ23YddO/uXS2cP0+bNsZ/wVq8eAm91aOn5syeqYwZMz05jr2mzJil4UMH673BAyRJdnZ2GvzecM2dPVMZn1oX6mkB/v7q3/cdZc6cRRMmTTY+pZ2Uzl27a9qUyTry8yE1adpMkrRk8UIFPXigvv0GPLd9SkutPv+nbVs2S9Jzlw4IDQnR/v17Va16jQTLNfyb93Hqd9/K0dFRHTs++z8BqSW1+jw6Olq9e72lChUr6YP/fWxsX7lqNbVs/poWzp+nIe8NT/QYkpQ3Xz7VqVtfe/fsMpmV4EXVqFlbIz/8WJMnTVT71vEJNHnz5tOAQYM1aeLXz/w5szR/ZV5KUpPXXlfndq00+uMP9eXEyZIk+yfLKZQuU04eHjmMdT1y5FSZsuV0+tSJ1A0YAJDiChUqpPnz52vHjh368ssvtWzZMg0YMEBWVlbmDg1PGAwG9RswUOPGjtGwIQNVrXpNHT92VFs3b9KAQUPk6ORk7hBhwXz379PlSxclSdHRUbp8+ZJmz4xfYqRO3Xoq6smTO0gZXPtgLow9JLcfffdqzrRJypUnn/LmL6g9O7aYbC9fqapxGYCadRvKq0QpTfh8lG78fk2OTk7avG6lYmNi1bXXuybt3h00XCMGvaMh73RTszfaKCTksdYuX6LcefPp9ZYJl+kEksK1D+bC2Es9JAUgTShcuLBu3ryZ6LaIiIhUjuZvT69l8vTU6v9mLZMBg4aoW/ceunLlN2XJkkVFinrqu2+/kSTly5ffWK9w4SJat3GLrl69okcPH6pQocKyNxg04cvxqlAh4ZStjx8/Vt8+b+vxo8dasHip3N2zv9A5GQwGOTo56eHDh8b9zJk1Q23bd1RwSLCCQ4IlSaGhoYpTnG7fviWDwSHVlnBIzT5/2vatW5S/QAF5Fy+R5L737duj8LAwNX1G8sCLvI83blzX2tWrNHzkh/Lz/3tq/oiICEVHR+n27VvKnClzqv2yS60+P3b0V1357bKGvT/SpG2+fPlVsGBBnXwyjX9SPDw8FBUVpbCwMGXOnPm59f+pQ6fOavFmS/12+ZJsbW3lWcxL69euiY8jf/qbVs3W1k616tTTovlzFB4eLoPBoGxu8e+3SyI/884uLrp08UJqhwkASCWNGzdWnTp1NH36dPXr18/c4eAf2nXopAwZbLV40Xz57t8nD48cGj7iA3Xq0s3cocHC7d29y5j8K0kXL5zXxQvnJUnZs3uQFIAUxbUP5sLYQ3K6duWSJOn2Hzf05egPE2yfMG2eMSnAxsZGn0+crtlTJ2rD6mWKjAhXUa8SGvbR2ARLApQpX0njv5mhhXOmav7M72RvMKharbp6u/9QOaSTh1+QvLj2wVwYe6mDpACkCXXr1tW6det04cIFeXnFP8X64MEDnTt3Tt27dzdbXMm1lklWR0eVK1/B+Prnw4eU3cNDBQoWNKlnZWWlwoWLGF//cPCAYmNjVblKNZN6ERERGtivj27cuK7Zcxf8qyn/Q0KCFfTggZyd46esf/TooUJDQ7Vw/lwtnD83Qf2mjeqrbr36+nbK9Bc+xstI7T6XpNOnT+nmzRvq23/gc/e7bctmZcyYUXXq1ntmnee9j3737ik2NlZfjhurL8eNTdC+aaP66tS5q97/4H/PjSc5pFaf3w8MlCTFxsQkaBsdHa2YRMr/6datW7K3t3+pp/ozZsyo0mXKGl8f+fmQDAaDypQt95/3+SqLiAiPX8IlJEQGg0GFixRVhgy28vdLuCZdgL+fnJ2dE9kLAMBSGAwGDR06VO3bt9etW7eMn82RNrRq01at2rQ1dxhIZz4b94U+G/eFucNAOsa1D+bC2ENy6dqrr7r26vvC9bNkzar3Phyt9z4c/dy65SpVUblKLBWA5MO1D+bC2Et5JAUgTWjQoIFKliypgQMHasiQIbK3t9fs2bNlZ2enjh07mi2up9cyefpmaWJrmTx4cF9BDx7II0dOOTg4PHOfO7Zv07mzZzR0+Igk164PDw/XtCmT5ebmpibNmhnLY2Ji9P57g3X61El9O2W6yc3Np/311HmmTKZPU8+eMV1xcXGqXqOmJMnFxVWTvpuWoP2y7xfr9KmT+uLrb5TNze2ZcSY3c/T59q3xSwc0bZb00gH379/XkZ8Pq3HTZkke72mJvY+FixRJtM+nfvetQkNC9P4H/1OePHleaP/JIbX6PF/+/MZt1WvWMta9cP6crl//3eQX/v379+Xi4mKyz0sXL8p3/z7VqFkzyZ+df+PkiePau2e32rTroCxZsiTLPtOq+4GBCZ7+f/zokfbt2a3sHjmM2zJlyqTqNWvpx4O+uv77NeUvEJ/U8fu1qzp96qTebM0HMwBID3LmzKmcOXOaOwwAAAAAAAAkA5ICkCZYW1tr9uzZGj9+vEaNGqWoqChVqFBBS5culVsq3pD+p3+zlsmKZUs1c/pUzV2wWBUrVZYUP136rBnTVLVadTk6OenMqVPauGGdqteoqU6du5oca/jQQXJzc1fBQoUVEhKsDevW6tatPzR1xmyTG/sTv/pCvvv3qXadunr4MEhbNm802c9rr7eQJAUE+Ktd6zfVpEkz5X/ypPbhn37UDwcPqHqNmqpbr74kycHBQfXqN0hw7vv37tHZM2cS3ZaSUrPPpfgki53bt6tU6TLKkzdvkrHt3L5N0dHRSSYPvMj76Ozskmi/Ll2ySJIsts+9i5dQlWrVtWnjegWHBKtqteoK8PfX8qXfy97eoM5PTQX0/nuDZTAYVLpMWbm4uOra1Stas2aVHBwMGjRkmEn8ly/FJwtI0h83b+hx8GPjGqdFPYsZZ3W4c+e2hg8drDp168k1WzZdvXJFa1atUJGinho4eEiK9G1qOOi7X79d/nuN1yuXL2ne7BmSpFp16qlIUU9J0qB+veWe3UMlSpaSs4uL7v75pzZvXK8Afz+N++obk332HTBYvx45rHff7q52HbpIklYuX6KsWR31Vs93UvHsAAAAAAAAAADAyyIpAGmGi4uLvv76a3OHkcDLrGXi7p5d1tY2WrRgnkJCQpQrd271GzBYXbt1V4YMpj9+3sVLaOOGdVqzeqXs7Q0qV768xn81UcX+MWXrpUvxN/8O+O7XAd/9CY75V1JAlixZVat2Hf18+JA2bdqg2JgY5cmbTwMHD1XX7j2S7UnrlJBafS7FT3EfGBigXu/0ee6+t23dLBdXV1WpWu2ZdV70fUxrUqvPJ0+ZrkUL5mnH9m069OMPsrW1VdlyFdRvwCDjE+mSVLd+A23bsllLFi1USEiwnJ2dVb9BQ/V5t7/y5stnss8L589r2pTJJmV/vW7e4k1jUkDmTJnl5uamFcuW6uHDILlnz64Onbro7Xf6JJhR41Wyb+8ubd20wfj60sULunTxgiTJPbuHMSng9TdaaveO7Vr2/SI9fvxYWbNkVYlSpTX2i69VtlwFk30WLFRYs+Yv1pRvJ2r+nJmytrZShUpVNHDIMLlnz55q5wYAAAAAAAAAAF6eVVxcXJy5gwBSSni0uSMAYIkio2PNHUK6k9WQdhOZAAAvjs/nAAAA6YPfowhzh4B0yj2rvblDAIBUZ3iBaQD4hh0AAAAAAAAAAAAAAAtFUgAAAAAAAAAAAAAAABaKpAAAAAAAAAAAAAAAACwUSQEAAAAAAAAAAAAAAFgokgIAAAAAAAAAAAAAALBQJAUAAAAAAAAAAAAAAGChSAoAAAAAAAAAAAAAAMBCkRQAAAAAAAAAAAAAAICFIikAAAAAAAAAAAAAAAALRVIAAAAAAAAAAAAAAAAWiqQAAAAAAAAAAAAAAAAsFEkBAAAAAAAAAAAAAABYKJICAAAAAAAAAAAAAACwUCQFAAAAAAAAAAAAAABgoUgKAAAAAAAAAAAAAADAQpEUAAAAAAAAAAAAAACAhSIpAAAAAAAAAAAAAAAAC0VSAAAAAAAAAAAAAAAAFoqkAAAAAAAAAAAAAAAALBRJAQAAAAAAAAAAAAAAWKgM5g4AAIBXjV0GcuoAAAAAAAAAAMCrgbsaAAAAAAAAAAAAAABYKJICAAAAAAAAAAAAAACwUCQFAAAAAAAAAAAAAABgoUgKAAAAAAAAAAAAAADAQpEUAAAAAAAAAAAAAACAhSIpAAAAAAAAAAAAAAAAC0VSAAAAAAAAAAAAAAAAFiqDuQMAAAAAAAAAAACWwz2rvblDQDrl9yjC3CEgneK6h7SOmQIAAAAAAAAAAAAAALBQJAUAAAAAAAAAAAAAAGChSAoAAAAAAAAAAAAAAMBCkRQAAAAAAAAAAAAAAICFIikAAAAAAAAAAAAAAAALRVIAAAAAAAAAAAAAAAAWiqQAAAAAAAAAAAAAAAAsFEkBAAAAAAAAAAAAAABYKJICAAAAAAAAAAAAAACwUCQFAAAAAAAAAAAAAABgoUgKAAAAAAAAAAAAAADAQmUwdwDAq2Dd2tVavHC+bt+6JQ+PHOrQuYs6duryQm3PnzurKZMn6dTJE4qLi1OpMmU1ZOhwFfPyMqkXGxurNatXas3KFbp586YcMjrIy8tbvfv0VZmy5Uzq3rhxXdOmTNaJ48f06OFDeeTIoSZNX1O3t3rKwcHBpG5UZKQWLZyvzZs26M7t28qcJYuKFy+hjz8Zo+weHpKkK1d+08xpU3T+/DkFBgTIYDCoYKHC6vZWT9WpW+8leu6/o89TH32e+uhzAAAAAAAAAACQ0qzi4uLizB0EkFLCo19+H6tXrdDY0Z+oQUMfVateQ8ePH9WWTRs1aMh76tGrd5JtL5w/p26dOyi7Rw61bttOcbGxWrlimR49fKilK1Yrf4GCxroTvvpCSxYtULPXm6tcuQp6/PiR1qxeqbt//qmFS5arZKlSkqS7f/6p1i2bK0vmLGrdtr0cHR116tRJbdqwTnXq1tPkqTOM+4yKilL/d3vr5MkTatWqjYp4eurRo0c6e/qU3unbX4ULF5Ek/XDwgJZ9v1ily5SVm5u7wsPDtGf3Lh0/dlQffzJGrdu2e/mO/Bfoc/qcPqfP/8lAGiMAWITk+HwOAAAAAM/i9yjC3CEgnXLPam/uEJCOvcj35yQF4D+Ji4tTVFSU7OzszB1Kkl72S8fw8HD51K+tkqXLaOr0WcbyD0YM0/69e7Vrr6+yOjo+s33/d3vr1MmT2rx9p5ycnCVJ/v5+at7UR1Wr1dA3k6dIkqKjo1W9cnnVrFVbEyZ9Z2x/69YfaubTQB07d9GIDz6SJM2dPVNTJk/S2o1bjDfeJOmjD0Zo86YN+uHQL8aYFsybo6nfTdbCJcuMN/5eVExMjDq0aamIyAht3LLjX7V9GfQ5fS7R5/R5QiQFAIBlICkAAAAAQEoiKQDmQlIAzOlFvj+3Tvkw8F+dOHFCffr0UY0aNVSmTBm1aNFCGzZsMKnz6NEjffbZZ6pVq5ZKlCihevXqaeLEiSZ1fH191b59e5UuXVoVK1ZUly5ddP78eUnSunXr5Onpqfv375u0adGihUaOHGl8PXLkSL322ms6cOCAmjdvrpIlS2rfvn0KDQ3VmDFj5OPjo9KlS6tevXoaNWqUHj9+nOB8NmzYoDfeeEMlS5ZU5cqV9fbbb+v27du6f/++SpQooVWrViVo06ZNGw0aNOi/duFL+/WXIwoKClK79h1Nytt36KSwsFAdPOibZPvjx46qStWqxpt2kuTm5q7yFSvp4IH9Cg0JkRR/4y48PFwurtlM2ru4uMra2lr29gZjWXBwsCTJ1dXVpG42NzdZW1srg62tpPgpw5d+v1j1GjRQyVKlFB0drbCwsBc+dxsbG2X3yKHHjxK+lymJPqfPJfqcPgcAAAAAAAAAAMmFpIA07M6dOypXrpw+//xzzZgxQ40aNdJHH32k9evXS5IiIyPVrVs3bd68WT179tScOXM0YMAAPXjwwLiPbdu2qU+fPnJ1ddXEiRM1YcIElStXTvfu3fvX8fj5+Wns2LHq3r275syZIy8vL4WHhysmJkZDhgzRnDlzNGjQIP3666/q27evSdu5c+dqxIgRKl68uKZOnarPP/9c+fLl0/379+Xi4qKGDRtq7dq1Jm1+++03nT59Wq1bt/4PvZc8Ll6IT57wLl7CpNzbu7isra118cKFJNtHRkaa3HT7i4PBoKioKF258pskyWAwqGSp0tq0Yb22btmkP+/c0eVLFzXqfyOVNWtWtW7z9xTbFStWkiR9+vH/dPHCBd3980/t2L5Nq1cuV8dOXZQxY0ZJ0tWrV+Tv56eiRT015pOPVaVCGVWpUEat33xdvxz5OdF4Q0ND9eDBff1x86aWLFqon348qMpVqrxgbyUP+pw+l+hz+hwAAAAAAAAAACQXJuNNw5o1a2b8d1xcnCpWrKh79+5p5cqVevPNN7VhwwadP39eK1asUNmyZY1133zzTWObL7/8UtWrV9e0adOM22vXrv2f4nn48KHmzJmj0qVLm5SPHj3a+O/o6Gjlzp1bHTt21O+//64CBQro8ePHmjp1qtq1a6cxY8YY6zZo0MD477Zt26p79+66evWqChUqJElau3atcuTIoerVq/+neJODv7+/bGxsEjw5a2tnJ0cnJ/n7+SXZPn+BAjp9+qRiYmJkY2MjSYqKjNSZ06clSX5PJWeM++JrvT9siD4cMdxYljtPHi36frly58ljLKtes5b6DRikeXNmyXf/PmP52737qP+gIcbXN2/ckCR9v3ihsjo66eNP4vt+7pxZ6vtOLy1buUZFPYuZxDvx6y+0ZtVKSZK1tbXqN2ioD/436jm9lLzoc/pcos/pcwAAAAAAAAAAkFxICkjDHj58qClTpmjv3r26d++eYmJiJElOTk6SpMOHD6tQoUImCQFPu3btmu7evasRI0YkSzxOTk4JEgKk+GUBFi5cqBs3big0NNRYfv36dRUoUEAnTpxQWFhYkk/8V6lSRXny5NGaNWs0YsQIRUdHa9OmTWrXrp2src03oUVERLhsn0yZ/U/2dvaKiAhPsn3b9h31+ZhP9enH/1P3Hr0UGxerObNmyN/fX5IU/lT7TJkyqVDhwipVuowqV6mqwAB/zZ87R4MH9tOCxUvl7OxirJszVy6VK19BDRr6yNHJST8c9NXcObPkms1NHTp1liSFhsZPHx4SEqKVazbII0cOSVKlylX0WpNGWjB/rsZ/OcEk3s5duqlho8by9/PTzp3bFRMbq6ioqH/XaS+JPqfP/0KfPxt9DgAAAAAAAAAAXhRJAWnYyJEjdeLECfXr10+FCxdW5syZtXz5cm3fvl2SFBQUJHd392e2DwoKkqQk6/wb2bJlS1C2e/dujRgxQu3atdOQIUPk5OQkf39/9evXTxERES8ch5WVldq0aaPFixfrvffek6+vr+7fv6+WLVsmS+z/lb294Zk3riIiIxKdvvtpbdt10L27d7Vw/jxt2hi/7EPx4iX0Vo+emjN7pjJmzCQpfoaF3r3eUoWKlfTB/z42tq9ctZpaNn9NC+fP05D34p/y3b5tqz77dJQ2bd2p7B4ekqQGDRspNjZO306aoCbNmsnJyVmGJ7GVKVvOeNNOknLkzKmy5crp1MkTCeItULCQChSMn6nh9RZv6J23e2hAvz5aumK1rKysXqjPXhZ9Tp9L9Dl9DgAAAAAAAAAAkov5HsFGkiIiIuTr66t3331XXbp0UdWqVVWyZEnFxcUZ6zg5OckviSmm/5pRIKk69vb2kpTg5tSjR48S1E3sxs2OHTvk5eWlMWPGqHbt2ipdurSyZs36r+OQpJYtWyooKEi+vr5as2aNKleurDxPTW1tDm5uboqJiVFgYKBJeVRkpB4GBcntBRIuBgwaov0Hf9KCxUu1Zv0mLVu1VrFP3sd8+fJLko4d/VVXfrusOnXrmbTNly+/ChYsqJMnjhvLVq1YpmLFvIw37f5Sp249hYeFGdci/ys2V9eEyRwurq6Jvsf/1LChj86dPaMb139/bt3kQp/T5xJ9Tp8DAAAAAAAAAIDkQlJAGhUZGanY2FiT6aWDg4O1b9/f6zxXq1ZNV69e1alTpxLdR8GCBeXh4aF169Y98zjZs2eXFL/UwF+uXr2qP//884XiDA9POAX25s2bTV6XLVtWDg4OWrt2bZL7cnNzU506dTR37lz98MMPatWq1QvFkJI8i3lJks6fO2tSfu7cWcXGxsqzWLHEmiWQ1dFR5cpXUJGinpKknw8fUnYPDxUoWFCSdP/JjcHYJ0tEPC06Otq4dIQkBQYGKCY2NpF68YkdMdHRkqQiRYsqQwZb+fndS1DX38/PZMrwZ/lrCvPHj4OfWze50Of0uUSf0+cAAAAAAAAAACC5kBSQRmXJkkUlS5bUnDlztGPHDu3Zs0c9evRQ5syZjXVatGghb29v9e7dW0uWLNHPP/+sjRs36uOP46eItrKy0ogRI/Tjjz9qwIAB2rNnjw4ePKjvvvtO+/fvlySVLl1aOXLk0Lhx4+Tr66stW7YYlwF4EdWqVdPp06c1bdo0HTp0SOPHj9fhw4cTnEu/fv20YsUKjRo1SgcOHND+/fv1xRdf6MyZMyZ127ZtqxMnTihjxozy8fF5iR5MHpUqV5Gjo5NWrVhuUr5q5XIZHBxUq1YdY9mDB/f1+7WrCgsLS3KfO7Zv07mzZ9SpSzdZW8f/CObLn9+47WkXzp/T9eu/q5iXl7EsX74CunjhvK7/4wnb7du2ytraWkU8428OZsqUWTVr1dKpkyf0+7WrxnrXrl7VqZMnVLVqNWPZP59WluJnj9i8aaMMBoMKFSqU5DklJ/qcPpfoc/ocAAAAAAAAAAAklwzmDgDPNnHiRI0aNUojR46Uk5OTunTpotDQUM2fP1+SZGdnp4ULF2rSpEmaNWuWgoKC5OHhoWbNmhn30bRpUxkMBs2cOVNDhw6Vvb29vL291bBhQ0mSra2tpk6dqk8//VSDBg1S3rx59eGHH+qLL754oRjbt2+vW7du6fvvv9e8efNUo0YNTZw4UW3btjWp9/bbb8vFxUULFy7UunXrlClTJpUtW1aurq4m9WrUqCEHBwc1a9bMuLSBORkMBvUbMFDjxo7RsCEDVa16TR0/dlRbN2/SgEFD5PhU8sSKZUs1c/pUzV2wWBUrVZYUP3X3rBnTVLVadTk6OenMqVPauGGdqteoqU6duxrbehcvoSrVqmvTxvUKDglW1WrVFeDvr+VLv5e9vUGdu3Qz1u3eo6d++vGg3uraSe07dJKTk5MOHvDVjz8cVMtWbeTunt1Yd8CgoTry82G93aObOnSKP97ypYuV1dFRPXv3Mdb7bPQohQQHq3yFinJ3z66AAH9t27pZv1+7pveGj1TGTJlSqosToM/pc4k+p88BAAAAAAAAAEBysYp7epF6wMwOHz6s7t27a+3atSpRosRL7y88OhmCkrR29SotXjRft2/dkodHDrXv2EmdunSTlZWVsc6MaVMS3Lj74+ZNff7ZaF28cE4hISHKlTu3Xm/+prp26y5bOzvTWMPDtWjBPO3Yvk13bt+Sra2typaroH4DBpk8zStJZ06f1szpU3TxwgUFBQUpV+5cat7iTXXv0UsZMpjm+lw4f07ffjNBp06elLW1lSpVrqIhw943rjkuxT8JvGHdGv12+bIePgxSxoyZ5F28uDp07Kw69eonTyf+S/R56qPPUx99/uIMpDECgEVIrs/nAAAAAJAYv0cR5g4B6ZR7VvM/6Ir060W+PycpAGnCvXv3dPPmTY0fP1729vZavnz58xu9AL50BADLQFIAAFgGPp8DAAAASEkkBcBcSAqAOb3I9+fWKR8G8HyrVq1S167xU1CPHTvWzNEAAAAAAAAAAAAAgGVgpgBYNJ5EAgDLwEwBAGAZ+HwOAAAAICUxUwDMhZkCYE7MFAAAAAAAAAAAAAAAQDpGUgAAAAAAAAAAAAAAABaKpAAAAAAAAAAAAAAAACwUK/QCAAAAAPAKWLd2tRYvnK/bt27JwyOHOnTuoo6dupg7LKQDjD2YE+MP5sLYg7kw9pBc/O7d1c4t63Xkpx90+9YNWVvbKH/BwurUvbfKVaqSoH7w40eaM22SfjqwTxHhYfL0Lql3Br6nIp7eJvVmfPuVTp84qnt/3lFkZKTcPXKoTgMftenYXQ4ZM6bW6cHCcO1LecwUAAAAAABAGrd61QqNHvWRChUqopEffqxSZcroy3FjNX/ubHOHBgvH2IM5Mf5gLow9mAtjD8np0MH9WrlkgXLmzqPuvQeo01u9FRYaohGDemvHlg0mdWNjY/W/9/pr365tatG6vXr1G6qgB/c1rG9P3frjhkndSxfOqUSZcur6dl/1HfK+ypSvqBVL5uuDIe8qNjY2Fc8QloJrX+qwiouLizN3EEBKCY82dwQAgORgYG4jALAIfD7/b8LDw+VTv7ZKli6jqdNnGcs/GDFM+/fu1a69vsrq6GjGCGGpGHswJ8YfzIWxB3Nh7CUPv0cR5g4hzbh+7YqcXVzl6ORsLIuMjFSfrm0UHhaqZRt3G8sP7NmpsR8P18efT1Cteo0kSUEP7uutdq+rYpUa+nDMl0kea/WyRZo9ZaImz1ki7xKlU+aE0jj3rPbmDuGVxLUvebzI9+fMFAAAAAAAQBr26y9HFBQUpHbtO5qUt+/QSWFhoTp40Nc8gcHiMfZgTow/mAtjD+bC2ENyy1+wsElCgCTZ2dmpUrWa8ve7p9CQEGP5wf275eziqhp1GhjLnJxdVLuejw7/sF+RkZFJHssjR05JUsjjx8l4BkgPuPalHpICAAAAAABIwy5eOC9J8i5ewqTc27u4rK2tdfHCBXOEhXSAsQdzYvzBXBh7MBfGHlLLg8AAGQwG2RsMxrIrly+qsKeXrK1Nbxt6epdQeHi4bt+8blIeEx2th0EPFODvp6NHDmnBrKnKmDGTPL1LpsYpwIJw7Us9TMYLAAAAAEAa5u/vLxsbG7m6upqU29rZydHJSf5+fmaKDJaOsQdzYvzBXBh7MBfGHlLD7T9u6kffvapVr6FsbGyM5fcD/VWqTPkE9V2yuUmSAgL8VaBwUWP5pYvnNOjtLsbXefLm15ivv2Oad/xrXPtSD0kBAAAAAAATAQEBuvAkG9/b2zvBf86RuiIiwmVra5voNns7e0VEhKdyREgvGHswJ8YfzIWxB3Nh7CGlhYeH6bP/DZO9vb169h1ssi0yIkK2dgnHn52dnXH70/IVKKQvJ89WeHiYzp05qRO//qyw0NAUix2Wi2tf6iEpAAAAAADSqW+++UadOnVS9uzZJUmxsbEaN26cVqxYoZiYGMXFxSlDhgzq0qWLRowYYeZo0y97e4OioqIS3RYRGSF7e0Oi24CXxdiDOTH+YC6MPZgLYw8pKSYmRp9//L5uXr+qz7+Zrmxu7ibb7eztFRWZcPxFRkYatz8tU6bMKlepiiSpWq262rdzqz4ZMUjTF65UoSKeKXQWsERc+1KP9fOrAAAAAAAs0Zw5c3Tv3j3j67lz52rZsmXq2rWrVq1apdWrV6tz585atGiRli5dasZI0zc3NzfFxMQoMDDQpDwqMlIPg4Lk5u7+jJbAy2HswZwYfzAXxh7MhbGHlDRp/Ggd+emghn30mcpWqJxgu4urmwID/ROU3w+IL8v2ZBmBZ6lRp4EkyXf3jmSIFukJ177UQ1IAAAAAAKRTcXFxJq9XrVqljh076v3331fJkiVVsmRJjRw5Uq1bt9aqVavMFCU8i3lJks6fO2tSfu7cWcXGxsqzWDFzhIV0gLEHc2L8wVwYezAXxh5SyuwpE7Vz6wb1GTRc9Ro1TbROoSKeunLpgmJjY03KL54/I4PBoFx58yd5jKioSMXGxiok5HFyhY10gmtf6iEpAAAAAAAgSbpz547q1auXoLx+/fq6fv166gcESVKlylXk6OikVSuWm5SvWrlcBgcH1apVxzyBweIx9mBOjD+YC2MP5sLYQ0pY9f0CrV62SB269VLLdp2fWa9WvYZ6cD9QP/ruMZY9DHqgg/t2qUqNOrKzs5MkBT9+pOjohFO9b9u0TpJUtFjxZD4DWDqufakng7kDAAAAAACYT3BwsIKCgiRJzs7OCWYP+Iu1NTnl5mIwGNRvwECNGztGw4YMVLXqNXX82FFt3bxJAwYNkaOTk7lDhIVi7MGcGH8wF8YezIWxh+T2o+9ezZk2Sbny5FPe/AW1Z8cWk+3lK1WVs4urJKlm3YbyKlFKEz4fpRu/X5Ojk5M2r1up2JhYde31rrHNqeNHNW3SF6pVt6Fy5cmrqKgonT11XD/67lVRr+Kq3/i1VD1HvPq49qUeq7hnfeMDWIDwaHNHAABIDgbSGAEgRRQrVkxWVlbG13FxcRo4cKD69u1rUm/OnDlau3atdux4ufUh+Xz+ctauXqXFi+br9q1b8vDIofYdO6lTl24m7yGQEhh7MCfGH8yFsQdzYey9HL9HEeYOIc1YPHe6lsyb+cztE6bNU+lyFY2vHz96pNlTJ+rQwf2KjAhXUa8S6j3gPXl6/f30/51bf+j7+TN19vQJ3Q8IUFxcnHLmzq2adRuqTafucnDImKLnlJa5Z7U3dwivNK59L+dFvj8nKQAWjS8dAcAykBQAAClj/fr1Ccrc3NxUo0YNk7KePXuqUKFC+vDDD1/qeHw+BwAAAJCSSAqAuZAUAHMiKQDpHl86AoBlICkAACwDn88BAAAApCSSAmAuJAXAnF7k+3O+YgcA4F9yrtjf3CGkO2Enppo7BAAAAAAAAAAAXknW5g4AAAAAAAAAAAAAAACkDJICAAAAAAAAAAAAAACwUCQFAAAAAAAAAAAAAABgoUgKAAAAAAAAAAAAAADAQpEUAAAAAAAAAAAAAACAhSIpAAAAAAAAAAAAAAAAC0VSAAAAAAAAAAAAAAAAFoqkAAAAAAAAAAAAAAAALBRJAQAAAAAAAAAAAAAAWCiSAgAAAAAAAAAAAAAAsFAkBQAAAAAAAAAAAAAAYKFICgAAAAAAAAAAAAAAwEKRFAAAAAAAAAAAAAAAgIUiKQAAAAAAAAAAAAAAAAtFUgAAAAAAAAAAAAAAABaKpAAAAAAAAAAAAAAAACwUSQEAAAAAAAAAAAAAAFgokgIAAAAAAAAAAAAAALBQGcwdAPAqWLd2tRYvnK/bt27JwyOHOnTuoo6durxQ2/PnzmrK5Ek6dfKE4uLiVKpMWQ0ZOlzFvLxM6sXGxmrN6pVas3KFbt68KYeMDvLy8lbvPn1Vpmy5BPu9cP6cZkybohPHjysyMkK5cudRqzZt1alzV0lSWFiYNq5fp/379+rK5csKDQ1Rnrz51LpNW7Vq0042NjYm+/P399OMqVN0+PBPCgwIkJu7u+rUra+33+kjJyfn/9hz/11a6vOPPxypTRvXP/N4u/YdVPbs2SVJUVFRmjdnljZtXC+/e/fknj273nizlXr06q0MGf6+5J49c1qbNm7Qr78c0Z07t+Xk6KRSpUur38DByp+/wL/pqmTzqva5JJ08cVyTJn6tixfOK1OmzGrUuIkGDhqijJky/ed9pnXVyhTU3gVDJUm5645QYFCIcVvzuqXUq3VNlSiSUy6OGRXwIFi/nLmusTO36fzVP03207pROTWtVUIVS+ZX4bzuOnj0N/m8PTnRY9rZZtCod5up42uV5JTFQWd/u6NPp23RviMXU+5EAQAAAAAAAADAS7GKi4uLM3cQQEoJj375faxetUJjR3+iBg19VK16DR0/flRbNm3UoCHvqUev3km2vXD+nLp17qDsHjnUum07xcXGauWKZXr08KGWrlit/AUKGutO+OoLLVm0QM1eb65y5Sro8eNHWrN6pe7++acWLlmukqVKGese+ulHDezXR8W8vOXTuKkyZsyoP/64qbjYWA0Z9r4k6bffLqvNm81VuUpVVa1WXZkyZ9ahn37Uvj279XrzNzR2/JfG/YWGhKjVG68rLCxUbdt3lIdHDl26dFFrVq1UocKFtWL1Ollbp97EImmtz0+dPKE//rhpcpy4uDiNHfOpcubMpfWbthrLh783WLt37tAbLVvJu3gJnTl1Sps2rler1m01avRnxnrvDR6okyeOq6FPYxUt6qmAAH+tWLZUoaGhWrJ8pYoUKZoMPfniXuU+v3jhgrp2aqcCBQupVZu28rt7V4sWzlfFSpU1fdZcY71/s8/nca7Y/4XrpgQrKysdWva+Cud1V+aM9gmSAj7o3VheBXPo1MU/FBAUouyuWdWtRRV5ZHNUne4TdebybWPdnXMGqaxXHh07d0OlPHPr7G93npkUsGh8d71Zv6ymLtuvKzf91aV5ZZX3zqfGvSfr0MlrKXrOYSempuj+AQCpIzk+nwMAAADAs/g9ijB3CEin3LPamzsEpGOGF5gGgKQAWLSX/dIxPDxcPvVrq2TpMpo6fZax/IMRw7R/717t2uurrI6Oz2zf/93eOnXypDZv32l82t7f30/Nm/qoarUa+mbyFElSdHS0qlcur5q1amvCpO+M7W/d+kPNfBqoY+cuGvHBR5Kk4OBgNW/qo9Jly2ripO+eebP+wYP7CgwMVOHCRUzKR330gTauX6fN23Ypb758kqRtWzbrgxHDNGX6LNWqXcdYd/rU7zRrxjStWLNeXl7e/6Ln/ru02OeJOX7sqN7q2kkDBg1Rr959JMU//d+pfRv17tNX/QYMMtad+PWXWrJogVat3aCinsUkxT/ZXrx4Cdna2Rnr3bhxXa3feF0NGvlo/JcT/k23vZRXuc8lqV+ft3Xp4gVt2LJDmTNnliStW7Naoz/5SDNmz1O16jX+9T6fx9xJAb1a19AnfV/Tim2/qn+nugmSAhLj7pJFV3aM1cKNhzXw8xXG8tzZnXTb76Hi4uJ0dPWHCgwKSTQpoELxfPrh++H64Jv1+nbJXkmSvV0GHVv9P/k/eKy63b9J3pP8B5ICAMAykBQAAAAAICWRFABzISkA5vQiSQGp9+gv0qTIyEjFxsaaO4w069dfjigoKEjt2nc0KW/foZPCwkJ18KBvku2PHzuqKlWrmky/7+bmrvIVK+nggf0KDYm/iRcdHa3w8HC5uGYzae/i4ipra2vZ2xuMZdu2blZgYIAGDBwia2trhYaGJvoeOju7JEgIkKR69RtKkq5du2osCw4JliS5urqa1M3m5iZJMtin3i+ztNjnidm+dYusrKzUpNlrTx37mCSpcZNmJnUbN2mquLg47dyx3VhWpmw5k4QAScqXL78KFS6i36+l7BPX//Qq93lwcLB+PnxIzV5rbkwIkKTXm7dQxowZtWvn9sR2leQ+0zrnrBn1Sd/X9NmMrQp6HPbC7fzuP1ZoeKScsjiYlN+6F6QXyQ98s0EZRUfHaN66n4xlEZHRWrjxsKqULqjc2Z1eOBYAAAAAAAAAAJB6SApIRSNHjtRrr72mQ4cO6fXXX1epUqXUuXNn3bp1S0FBQRo0aJDKlSunBg0aaNu2bSZtff/P3n3H13T/cRx/C1nIMBJixwqRSMwQeyuKqk1Qaq9qi6itWqpmY6+atfduUfxKqb2pvRMRIiF7/P5IXb0SswjX6/l4eMj5nu8553O+ufe6zvmcz3fHDn322WcqXbq0ihYtqkaNGmnXrl2JjhEQEKA+ffrI29tbhQsXVs2aNTV37lzD+sqVK2vYsGGaMWOGKlWqpMKFCys4OFhxcXGaPHmyKleuLDc3N9WsWVOLFy9OtP8nHT58WJ06dVLZsmXl6empevXqafXq1Yb1YWFh8vT01KxZsxJt26NHDzVp0sSwfO7cObVo0ULu7u6qXr261q5dqy5dusjH58XmNH8Tzpw+JUlyLeRm1O7qWkhmZmY6c/r0M7ePiopK8kantZWVoqOjdf78OUmSlZWV3At7aO3qVdqwfq1u3bypv8+e0aD+vrK1tVXDRo/Had+ffypt2rS6fTtAdWvXUOkSReRdspiGDxusyMjnZ0EG3bkjSUqX7vEN3GLFSsjMzEyjRnynY0ePKMDfX//btVMzp09VpSpV5Zw7z3P3+7q8i2P+pOjoaP26ZZM8PIsoa9Zs/2qPkiRZWhknUVhZJdyEPXXyxDNjj4+PV1DQHaOb62/D+zzm5/4+q5iYGLm6GcdubmEhlwIFnxn70/b5rhvUpY4CgkI0c8Ufz+1rl9ZaGdOlVaG8WTRlcHPZ2Vjr931nX+m4HgWy69zV2wp9GGHUfuDEZUlSYZf3ZwwBAAAAAAAAAPiQvEAxAbxOgYGBGjlypDp37qxUqVJp+PDh+vrrr2Vtba3ixYurcePGWrp0qXr37i0PDw9lzZpVknT9+nVVqlRJbdu2lZmZmXbt2qUOHTpo7ty58vLykiTdu3fPcJO9V69eypYtm65cuaKrV43n0P7111+VM2dO9e/fX2ZmZkqdOrVGjRqlefPmqXPnzipSpIh27NihwYMHKyYmRi1btnzq+dy8eVNFixZVs2bNZGFhoUOHDmnAgAGKj4/XJ598otSpU6ty5crasGGD2rVrZ9juwYMH2rFjh3r37i0poXx527ZtZWtrqx9//FGSNGnSJIWEhChHjhyv7xfwkgIDA5UyZcpET9CbW1jIzt5egbdvP3P7XM7OOnbsiGJjY5UyZUpJUnRUlI4fOyZJuh0QYOj7/cgf1efrXvqmb29DW7bs2TV3wSJly57d0Hb1ymXFxMaqZ/cu+qRBQ/X44isd2P+XFi2cr9CQUP0w+uklvKOjorRg/lxlzZZNhdzcDe158ubVwCHDNHb0KPk0f3xjtm69TzR42PBnnuPr9i6O+ZP27P5DwcHBql3nY6P2nLmcJSVMDZAt2+PtDx06kHDs58S+Yf1a3Q4IUJduPZ7Z73V7n8f8TmCgpITKBE9ycHAwVG94mX2+y9zyZdHnn5ZR/e5TFBf3/Kf7d877Si7OmSVJoQ8jNGLGJs1Z/ecrHTtzRlv5B4Ykave/k9Dm5PD0KSYAAAAAAAAAAEDyISngLbt//74WLFigfPkSyrrfvn1b3377rdq3b6+uXbtKktzd3fXbb79p69atat26tSQZ3ZiPi4uTl5eXzp8/r6VLlxqSAubMmaOgoCBt2rRJ2bIlPLFZunTpRDFER0drxowZSp06tSTp7t27WrBggdq1a6fu3btLksqWLat79+5p0qRJatasmeFG35Nq135cJj0+Pl4lSpRQQECAlixZok8++cTQp0uXLrp8+bJy5colSdq6datiYmL00UcfSZJWrFihoKAgLVq0yBC7m5ubqlevnqxJAZGRETI3N09ynaWFpSIjI5Jc90jjps313bAhGjKwv9q0/Vxx8XGaMW2KAv+5kRnxr+3TpEmjPHnzqrCHp7xKlVbQnUDNnjlDX/Toqp/nLVS6dOklSWHhYYoID1ejJk3l+03C/OtVq1VXdHSUli9doi7deyhnzlxJxjPiu2918cJ5TZwyXalSGb/9MzlmkptbYZUrX15OWbLq0MEDWrRwvuzTpdNXvfu+yHC9Fu/imD9p04b1SpXKXNVrfmTUXq58BWXJklVjfxwlKytruRYqpOPHjmrihHFKlSqVIiOeHvulixc0YvgweXgWUd16nzzzHF+393nMH+3b3Nwi0TYWls+O/Wn7fJeN6dNIW3af0ra9Z16of8chC2WTxkrO2TKoVd1Ssra0UMqUKRQT8/yEgidZW5orMjrxRNARkdGG9QAAAAAAAAAA4N1DUsBb5ujoaEgIkGS4Se7t7W1os7W1Vfr06eXv729o8/f317hx47Rnzx4FBgYa5n8uVKiQoc+ff/6pUqVKGW6qP42Xl5chIUCSjh07pujoaNWsWdOo30cffaT169fr8uXLypMn6fLx9+/fl5+fn7Zt26aAgADFxsZKkuzt7Q19ypUrJ1tbW23YsMGQ+LBhwwZ5eXkpY8aEucVPnDih/PnzG8WeLVs2FShQ4Jnn8qZZWiaUP09KZFTkc+dAb9ykmQL8/TVn9iytXbNKklSokJs+a9tOM6ZPVerUaSQlzLXe4fPPVLxESfXrP9CwvVdpbzWoW0dzZs9Sr696G2KSpI9qGc+BXqv2x1q+dImOHTmSZFLAnNkztWL5UnXt3lPlylcwWnf40EF179pJ839ZYqggULlKVaVNm1ZTJ09U/U8+VZ68eZ95rq/Luzjm/xb28KF+/32bvMuUTVTm39LSUn5Tpqn3l1/oqy8SEmwsLCz0xVe9NXP6VKP33b/dCQxUty4dlTatjUaPm/DUJJw35X0ec6t/Yns0dcO/RUU+PfZn7fNd1bB6UZXycFaxht+/8Db7jl0y/Lxs80EdXpkw7v3GrXrp44dHRsvSPPHXBqt/kgHCI5N+DQEAAAAAAAAAgORlltwBfGhsbW2Nlh89nWtjY2PUbmFhYZgfPi4uTp07d9bBgwfVo0cPzZs3T8uXL1f58uUVFfX4RlhwcLAcHROX0H7SkyXC79+/L0mGG/SPPFoODg5+6r58fX21fv16tW3bVrNmzdLy5cv16aefGsVlYWGh6tWra+PGjZISpjnYs2eP6tR5fFP79u3bSp8+8RPCSbW9TQ4ODoqNjVVQUJBRe3RUlO4HB8vhBca7e89e+n3Xbv08b6GWr1qrX5auUNw/SR2Pbt4fPLBf58/9rYqVKhttmzNnLuXOnVtHDh96HNM/x3zy9/horEJC7ieKYc2qlRo/drQaNWmqDp26JFq/fNkSpc+QwWhKAUmqUKmy4uPjdfTI4eee5+vyLo75v23fvlUR4eGq9ZSS83nz5tPKNeu1Ys16/Txvobb+/j992rCxgu/dU85/koD+LTQ0VF06tVdoSKgmT5spR8dMzz2/1+19HvOMDg6SpMDAxFMcBAYGPjX25/0e30Xff1FfK387rKjoGOVwSq8cTullb2MtScqWKd1zy/cHh4Zr5/6/1eSj4q90fP87IcrsYJuoPXPGhLZbgYk/ewAAAAAAAAAAQPKjUsB74MqVKzp16pQmTZqkqlWrGtojnihFbm9v/9w5yyUpRYoUibaTpKCgIGXK9PiG5J07d4zWPykyMlI7duyQr6+vfHx8DO2//PJLor516tTR8uXLdebMGR05ckRmZmaqXr26Yb2jo6NOnz6daLu7d+8qTZo0zz2nN8WlQEFJ0qmTJ4yerj958oTi4uLk8oKVDGzt7FS02OMbcXv/3KNMmTPLOXduSdLdf27Gxv1TaeHfYmJiDBUYJMnVtZD27tmtgIAA5XLObWh/9Lt/svz679u3aujgAapStbq+GTA4yfiC7gQpLjYu8bH/KRUeE5u4ZPib8i6O+b9tXL9OqVOnTnRj+99SpEihvHkfVwT5366dCdN+lPI26hcZGakeXTvpypXLmj7z57dWjeFJ7/OY582XX6lSpdKpEydUo2YtQ3t0VJTOnjn91KkBXuT3+K7J7pReTZ3Sq2mtEonW7V3sq6Nnr6tU05HP3Ie1pbns0lq/0vGPnb2uCsXzySaNlUIfPv73p4RbLsN6AAAAAAAAAADw7qFSwHvgUcWAf8/5fePGDR0+bPz0dunSpbV3717dvHnzpfbv7u4uc3Nzbd682ah906ZNypAhg2uDYmIAAKZtSURBVGGKgydFRUUpLi7OKK4HDx5o+/btifqWLFlSDg4O2rBhgzZs2KDy5csbVUdwc3PT2bNnde3aNUPb9evXdebMi82b/aaU9ColOzt7LV28yKh96ZJFsrK2VvnyFQ1t9+7d1aWLFxQeHv7MfW7etFEnTxxXC5/WMjNLeAs+eoJ886aNRn1Pnzqpy5cvqUDBgoa2Rzc5V69cbtR31YrlSpUqlYqXLGloO3hgv/p+/aWKFiuuEaNGG473pJy5ciko6I72/7XPONaN6yVJBQq6PvOcXqd3ccwfuXv3rvbt/VOVq1aTtfWL3ViNiIjQJL8JcnBw0Ee1axvaY2Nj1eerL3Ts6BGNHjtBHp5FXmh/b8L7POY2NjbyKlVaG9av1cOHDwzt69atUVhYmKpXr5lom1f5Pb4LGveanujPsi0HJUltB8xVn9ErDH0d0qVNtH0Op/SqWDK/Dp2++krHX7X1sFKlSql2DcoY2izMU6lVvVL669glXQ8IfqX9AgAAAAAAAACAN4tKAe+B3LlzK3PmzBozZozi4uIUFhamn376KdFUAW3atNGaNWvUsmVLde7cWdmzZ9e1a9d0+fJl9e6deJ7uR9KnT6+WLVtq1qxZsrCwkKenp3bu3Kn169dr4MCBT53f3MbGRu7u7poxY4bSp0+vVKlSafr06UqbNq3u3r1r1DdlypSqWbOmVq1apaCgII0dO9Zo/aeffqqpU6eqU6dO6t49YS72iRMnKmPGjIkqG7xNVlZW6tq9h74fPkxf9+oh7zLldOjgAW1Yt1bde/aS3b+qKCz+ZaGmTp6omT/PU4mSXpISbspPmzJJpb3LyM7eXsePHtWa1StVpmw5tWjZyrCtayE3lfIuo7VrVunBwwcq7V1GdwIDtWjhAllaWqmlT2tD34IFXVW/wadavXKFYmJjVbx4CR3Y/5d+3bJZ7dp3NJSfv3nzhnp266wUKVKoWvUa+nXLJqNzy5/fRfldEp4Ab9a8hdasWqkeXTupWQsfOWXJooP792vTxvUq5V1GhQt7vKkhTuRdHPNHtmzaqJiYGNWq/fSS872/7CkHB0flzpNXDx8+0OqVK3T9+jVNnDJdadI8vlE7ZtRI7fh9uypUrKT794O1ft0ao/3U+bjeqw7hS3vfx7x7z15q1aKp2rb20aeNGuu2v7/mzf1Zpb3Lqky58q+0z3fRuh3HErUVdskmSfp19ykFBT80tO9f9o12/PW3jp29rnshYcqbw0Gt63vLPFVKDfzJ+LVWpmgelS2aUKUiY7q0SmNtob6f15Ak/XHovHYfupCwzxNXtOLXQxrWva4c0qfVhWt31PLjksrplEGdhi58I+cMAAAAAAAAAAD+O5IC3gMWFhby8/PTsGHD1LNnTzk5Oalz587au3evTpw4YeiXLl06LVq0SGPGjNHo0aMVHh6urFmzqnnz5s89Rp8+fWRjY6Ply5dr6tSpypo1q4YOHaqmTZs+c7sxY8Zo0KBB8vX1lb29vXx8fBQWFqbZs2cn6lunTh3Nnz9fqVOnVqVKlYzWWVlZafbs2Ro8eLC+/vprZcqUSV26dNHq1auNKgokhybNWihVKnPNmztbO37frsyZndS7bz+1SOIG5pMcHTPJzCyl5v48Sw8fPlTWbNnUtfsXatW6jVKlMn77TfCbrLk/z9LmTRu154//ydzcXEWKFlfX7j2NpgmQpAGDhsrJKYvWrFqp7Vu3KkuWLOrdt59atmpj6HPj+nWFhoZKkr4fPixRbJ26dDMkBeRyzq3Fy1Zo4k/jtWHdWt25c0eOjo5q/Vlbde7a42WH7D97F8dckjZuWKf0GTKoVGnvROsecS3kpjWrV2r5siWytLRS0WLFNGLUmERPwZ89m1AFY+eO37Vzx++J9vM2kwKk93vMC7oW0rSZP2vC2NEa/cMIpU6TRvUbNFTPXl8m2f9F9vm+m7HsD31UrpCqeReUTWorBd4L1ba9pzVq1q86ed64mkzFEi4a0KmWUduQrgkJE8OnbjQkBUhSu4HzNLhLHTWrXVLpbFPrxLkbatBzqlEfAAAAAAAAILk42lomdwj4QIWERyd3CPiAWdmYP7dPivj4+Pi3EAvw0oKDg1W1alW1adNG3bp1e6V9RMS85qAAQFK6Eq/2mYRXF354YnKHAAB4Dfh+DgAAAAAwRSQFIDk5vkBSAJUC8M6YPn26MmbMqKxZsyowMFCzZ89WbGysPv300+QODQAAAAAAAAAAAADeSyQF4J1hZmamKVOmKCAgQClTppSHh4fmzp0rJyen5A4NAAAAAAAAAAAAAN5LTB8Ak0Z5UgBvAtMHvH1MHwAApoHv5wAAAAAAU8T0AUhOLzJ9gNlbiAMAAAAAAAAAAAAAACQDkgIAAAAAAAAAAAAAADBRJAUAAAAAAAAAAAAAAGCiSAoAAAAAAAAAAAAAAMBEkRQAAAAAAAAAAAAAAICJIikAAAAAAAAAAAAAAAATRVIAAAAAAAAAAAAAAAAmiqQAAAAAAAAAAAAAAABMFEkBAAAAAAAAAAAAAACYKJICAAAAAAAAAAAAAAAwUSQFAAAAAAAAAAAAAABgokgKAAAAAAAAAAAAAADARJEUAAAAAAAAAAAAAACAiSIpAAAAAAAAAAAAAAAAE0VSAAAAAAAAAAAAAAAAJoqkAAAAAAAAAAAAAAAATBRJAQAAAAAAAAAAAAAAmCiSAgAAAAAAAAAAAAAAMFEkBQAAAAAAAAAAAAAAYKJICgAAAAAAAAAAAAAAwESRFAAAAAAAAAAAAAAAgIkiKQAAAAAAAAAAAAAAABNFUgAAAAAAAAAAAAAAACaKpAAAAAAAAAAAAAAAAEwUSQEAAAAAAAAAAAAAAJgokgIAAAAAAAAAAAAAADBRqZI7AAAAAAAA8HwrVyzTvDmzdeP6dWXO7KRmLX3UvIVPcoeFDwCvPSQnXn9IDksX/6K/9u3V8WPH5O9/S3XrfaJvvx+Z3GHhA8HnHpKD/61bWr1qhXbt3KGrV68opZmZ8ubLr/YdO6tUae/kDg/vqVXLF+vQ/r906sQx3Q7wV8069dR/yHeJ+h05dECL58/Rub9PK/jePaW1sVHe/AXUul1HFfYsatR33uzp2r1rh25cv6bwsIdyzJRZpcuWl0/bDkqXLv3bOrX3EpUCAAAAAAB4xy1bulhDBw1Qnjz55PvNQBX29NQP3w/X7JnTkzs0mDhee0hOvP6QXH6eNVN/7dunPHnzKlUqnqvD28PnHpLL79u36edZM5QjR0516/6FOnTqoocPH6rj559p9aoVyR0e3lO/zJ2tQwf2yTlPXqVM+fR/T69dvawUZmaq16CxevXpr6Yt2+hu0B1179BG+/b8YdT379OnlC+/i1q17aBeffqrbIVK2rh2tbq0banw8LA3fUrvtRTx8fHxyR0E8KZExCR3BABMUboS3ZI7hA9O+OGJyR0CAOA14Pv5q4mIiFCNKhXk7uGpiZOnGdr79f1av2/bpl+37ZCtnV0yRghTxWsPyYnXH5LTzZs35OSURSlSpFCp4kVUrXoNKgXgjeNzD8np/PlzypAhg9GT1lFRUWr8aT2FhYXp1207kzG690NIeHRyh/DO8b91U5kyOylFihSqXq6EKlSpnmSlgKRERISrSb2aypu/gMb4TXtm3x3bftPAvr00+LtRqlqj1usI/b3jaGP+3D5UCgAAAAAA4B22/699Cg4OVpOmzY3amzZrofDwMO3atSN5AoPJ47WH5MTrD8kpS5asSpEiRXKHgQ8Mn3tITnnz5ktUet3CwkJly1VQgL+/Hj58kEyR4X2W+Z8Eu1dhZWUte/v0ehAa+ty+TlmySNIL9f2QkRQAAAAAAMA77MzpU5Ik10JuRu2uroVkZmamM6dPJ0dY+ADw2kNy4vUH4EPD5x7eRUF3AmVlbS0rK+vkDgUfgIcPHig4+J6uXL6oaZPG6+KFcypWwitRv/j4eAUH31PQnTs6evigxv84QilTplSR4iWSIer3BxMiAQAAAADwDgsMDFTKlCmVIUMGo3ZzCwvZ2dsr8PbtZIoMpo7XHpITrz8AHxo+9/CuuXrlirZt/U3VatRUypQpkzscfAAG9ftKf/25W5Jkbm6ueg0aqfXnnRL1uxsUpPo1KxqWHTNl0qDhPyhnrtxvK9T3EkkBAAAAAPCBioqKUmxsrKytHz/1cffuXS1cuFDnzp1TVFSU3Nzc1KxZs0QXJ/H2REZGyNw86fkBLS0sFRkZ8ZYjwoeC1x6SE68/AB8aPvfwLgkPD9fXX/aUpaWVevb6KrnDwQeiU7deatqitW4H+GvThrWKjo5WbGxson62dnYaN2mGIqMide7sGe3avlXhYWHJEPH7haQAAAAAAPhAdevWTdmyZdOgQYMkSceOHVO7du0UFxcnV1dXSdLs2bO1cOFCLViwQHny5EnOcD9YlpZWio6OTnJdZFSkLC2t3nJE+FDw2kNy4vUH4EPD5x7eFbGxser7dS9dvHBek6bOkKNjpuQOCR+IfC4FDD9Xr/Wx2rVopO+H9NfwUeOM+pmbm6u4V2lJUplyFVWshJe6tPORffr0KlOu4tsM+b1iltwBAAAAAACSx7Fjx1S6dGnD8ogRI5QvXz5t375d8+fP1/z587Vt2zblyJFDI0eOTMZIP2wODg6KjY1VUFCQUXt0VJTuBwfLwdExmSKDqeO1h+TE6w/Ah4bPPbwrhg4eoF07d+jb70bKq1Tp528AvAHm5uYqU6Gidv2+VZERz66U4u5RRBkyOui3TRveUnTvJ5ICAAAAAOADFRYWpnTp0hmWjx8/rk6dOsnOzs7Qli5dOnXo0EEHDhxIjhAhyaVAQUnSqZMnjNpPnjyhuLg4uRQokNRmwH/Gaw/JidcfgA8Nn3t4F4wd/YPWrFqp3n376aPadZI7HHzgIiMiFR8fr7Cwh8/tGxUVqYcPHryFqN5fJAUAAAAAwAcqT548OnLkiGHZ1tZWkZGRifpFRkY+dX5TvHklvUrJzs5eSxcvMmpfumSRrKytVb58xeQJDCaP1x6SE68/AB8aPveQ3ObMnqm5P8/W5x06qYVP6+QOBx+Qe3eDErWFhoZo5/bf5Jgps9KlzyBJCg8PU0REeKK+O7b9ptCQELm4Fnrjsb7PUiV3AMD7YOWKZZo3Z7ZuXL+uzJmd1Kylj5q38HmhbU+dPCG/CeN09MhhxcfHq7BnEfX6srcKFCxo1C8uLk7Lly3R8iWLdfXqVVmntlbBgq7q0KmLPIsUNep75cplTfKboMOHDirk/n1ldnLSR7XqqPVn7WRtbW3UNzoqSnPnzNa6tat188YNpbWxUaFCbho4eJgyZc5s1Pf0qZOaMslPhw8dUlRUpLJmy65PGzVWi5atXmHU/htTH/Pz589p6iQ/nTp1UkF37sjKykq58+RV68/aqWKlyv9h5F4dY/5+8fbMrW0/fylJylapr4KCH2dL1q1UWJ83LCe3fFmU3i617tx7oL+OX9bwqRt16sIto/00rF5Utcq7qYR7LuXN4ahdB86pRvsJSR7TwjyVBnWureZ1Ssrexlonzt3UkEnrtX3fmTd3ogCAN6pVq1b67rvvVKBAAZUtW1Y+Pj4aM2aMcuXKpXz58kmSzpw5owkTJqhSpUrJHO2Hy8rKSl2799D3w4fp61495F2mnA4dPKAN69aqe89esrO3T+4QYaJ47SE58fpDctrx+3b9fTbh/7oxMdH6+++zmj51siSpYqXKyu/CE9t4/fjcQ3LatvU3jRvzo3LkzCXn3Lm1ft0ao/WlS5dRhowZkyk6vK9279qh83+flSTFxMTowrm/NXfmNElSmQoVlTefiyTp6x6d5eiYSQXd3JUufXoF+Ptr07pVuhMYqCHfjzbs7/rVq+rV5XNVrl5TOXI6y8zMTGdOn9SvG9fLKUtWNWra8u2f5HuEpIC3xNfXVydOnND69evfyHZ+fn4qU6aMihYt+sx+L6N48eJq3bq1unfv/tr2+T5atnSxhg8drKrVasin1Wc6dOiAfvh+uCLCw9X28w7P3Pb0qZNq49NcmTI7qWOXboqPi9OSxb+oXZuWWrh4mXI55zb0HTt6lObP/Vm1P66rxk2bKzQ0RMuXLVG7Nj6aM3+R3AsXliT537qlFk0bySatjZo2ayk7OzsdPXpEUyb56fSpk5owcYphn9HR0erWpaOOHDmsTz9tpHwuLgoJCdGJY0cV+iBUmfQ4KWDP7j/Uo2snFfjnBm3q1Kl17dpV3fb3f80j+nwfwpjfunlTDx8+VN16n8jBwVEREeHa+tuv6tmtswYOHqaGjZu8gZF9Osb87Y/5f5EiRQqN6dtID8IilTa1ZaL1hfJlUXBomCb98rvuBD9Upgy2al2vlP43v7cqthmj43/fMPRt36icihTMroMnryi9XZpnHnfGsJb6pEoRTfzld52/Giiful5a7ddZNTtM0J4jF1/7eQIA3rxPPvlE/v7+6tSpk7Jly6b8+fPr9u3bqlu3ruz/uegYHBwsNzc39evXL3mD/cA1adZCqVKZa97c2drx+3Zlzuyk3n378QQP3jhee0hOvP6QXLb99qvWrlllWD5z+pTOnD4lScqUKTNJAXhj+NxDcnmUCHX1ymX19+2TaP3Mn+eRFICXtmP7b9q8/nGCybmzp3Xu7GlJkkOmTIakgNp1P9G2Xzdp6S/z9SA0VDa2tirkVliDho+SR5Fihu0dMmVShcrVdGj/Pm1ev0YxMTHK5JRFDRo3U6t2HUieeo4U8fHx8ckdxIfg6tWrCgsLU4GXnPfnRZMCXFxc1KdPH7Vr1+6/hGnEFJICImL+4/YREapRpYLcPTw1cfI0Q3u/vl/r923b9Ou2HbL913yrT+rWuYOOHjmidZu2yN4+Ya7WwMDbqlurhkp7l9XYCX6SEjKkyngVU7nyFTR63E+G7a9fv6baNaqqeUsf9e03QJI0c/pU+U0YpxVr1itv3nyGvgP69dW6tav1vz1/GWL6edYMTfxpgubM/8VwszUpDx48UN1aNeRRpIjGjPtJZmbJN7PIhzLmSYmNjVWzRg0UGRWpNes3v9S2/wVj/vJjnq5Et5c6zuv2ecOyGtyljhZv3K9uLSolqhSQFMf0Njq/ebjmrPlTPb5bbGjPlsleN27fV3x8vA4s+0ZBwQ+TrBRQvFBO/W9Bb/Ubu0rj52+TJFlapNLBZf0VeC9UldqMfb0n+YTwwxPf6P4B4EN38eJFrVy5UkePHtWdO3cUFxcnOzs75c2bV5UqVVLVqlWVIkWK/3yc//r9HAAAAACAd1FIeHRyh4APmKPN86d8TL47fx+YHDlyvHRCAJLf/r/2KTg4WE2aNjdqb9qshcLDw7Rr145nbn/o4AGVKl3acKNUkhwcHFWsREnt2vm7wh4m3MSLiYlRRESE0mcwzrRLnz6DzMzMZGlpZWh78OCBJClDhgxGfTM6OMjMzEyp/pnrNS4uTgsXzFPlqlXlXriwYmJiFB6eeK4VSdq4YZ2Cgu6oe49eMjMzU1hYmOLi4p55bm/KhzLmSUmZMqUyZXZSaEjoC2/zOjDmb3/M/4t0tqk1uEsdfTtlg4JDX/xcb98NVVhElOxtjKdeuB4QrBfJD/ykqqdiYmI1a+VuQ1tkVIzmrPlTpTxyK1sm+xeOBQDw7smdO7e+/vprzZ8/X5s2bdKWLVu0dOlSff/996pWrdprSQgAAAAAAABA8iAp4F8OHDggFxcXXb161dDWqVMnubi46Ny5c4a2L7/8Uh06PC6nHRUVpbFjx6pSpUpyc3PTRx99pHXr1hnt29fXV3Xq1El0vPr168vd3V0ff/yxdu/erXr16snX1zdRbPv27VP9+vXl6emphg0b6sSJE4Z1Li4J5TVGjRolFxcXubi4aN++fZKk+Ph4zZo1SzVq1JCbm5uqVKmiOXPmJNr/1q1bVbNmTbm7u6thw4Y6duzYC43Z6tWr1axZM5UsWVIlSpSQj4+P0bb79u2Ti4uLjh8/brRdbGysypQpozFjxhjafvvtN9WoUUPu7u5q3LixTp48qeLFi8vPz++FYnkTHpUFcy3kZtTu6lron7lKTj9z+6ioKKMbnY9YW1kpOjpa588nvK6srKzkXthDa1ev0ob1a3Xr5k39ffaMBvX3la2trRo2elzWvESJkpKkIQP768zp0/K/dUubN23UsiWL1LyFj1KnTi1JunDhvAJv31b+/C4aNnigShX3VKninmr4ycf6a99eo3j2/fmn0qZNq9u3A1S3dg2VLlFE3iWLafiwwYqMjHzJUftvPpQxfyQsLEz37t3VtatXNX/uHO3+Y5e8SpV6wdF6PRjztz/m/8WgLnUUEBSimSv+eG5fu7TWypgurQrlzaIpg5vLzsZav+87+0rH9SiQXeeu3lbowwij9gMnLkuSCrtke6X9AgAAAAAAAACANytVcgfwLilcuLAsLS21f/9+5ciRQ3FxcTp48KChLV++hBLW+/fvl4+Pj2G7nj176tChQ+ratavy5MmjnTt3qnfv3rK1tVWFChWSPNbt27fVvn17ubq6avz48QoNDdWQIUMUGhqqggULGvUNDAzU8OHD1aFDB9nY2GjMmDHq1q2bfvvtN5mbm2vJkiVq0qSJfHx8DIkHefPmlSR99913WrZsmTp16iQPDw8dOnRIo0ePlqWlpZo1ayZJOn36tHr06KHy5curX79+un79ur744gtFRUU9d8yuX7+u+vXrK0eOHIqKitKGDRvUokULrV27Vs7OzipRooQcHR21ceNGubu7G7bbu3ev7ty5Y4j31KlT6tmzpypVqqRvvvlGN27cUK9evV4ohjcpMDBQKVOmTPS0srmFhezs7RV4+/Yzt8/l7Kxjx44oNjZWKVOmlCRFR0Xp+D+JE7cDAgx9vx/5o/p83Uvf9O1taMuWPbvmLlikbNmzG9rKlCuvrt17ataMadrx+3ZDe/sOndStZy/D8tUrVyRJC+bNka2dvQYOHiZJmjljmrp0/Fy/LFlumP/s6pXLiomNVc/uXfRJg4bq8cVXOrD/Ly1aOF+hIaH6YfSbLQv+bx/KmD8y5seRWr50iSTJzMxMVapWU7/+g54zSq8XY/72x/xVueXLos8/LaP63acoLu75T/fvnPeVXJwzS5JCH0ZoxIxNmrP6z1c6duaMtvIPDEnU7n8noc3J4elTTAAAAAAAAAAAgORDUsC/WFhYqHDhwjpw4IA+/fRTnT17VuHh4WrQoIH279+v5s2b68qVK7p9+7ZKlCghKeHm9vbt2zVr1iyVLVtWklSmTBkFBgbKz8/vqUkBc+bMUcqUKTVt2jSlTZtWkpQtWza1aNEiUd/79+9rwYIFhqQEa2trtWrVSkePHlXx4sXl6ekpSXJycjL8LElXr17VggULNHToUDVpkvAErre3tyIiIjRp0iQ1adJEZmZmmj59upycnDRp0iTDDT1LS0v179//uWPWrdvjebXj4uJUpkwZHTt2TKtWrdKXX34pMzMz1apVSxs3blSfPn0MZUfXr1+vfPnyGaocTJs2TdmyZZOfn59hPvs0adKoT58+z43hTYqMjJC5edLzcFhaWCoyMiLJdY80btpc3w0boiED+6tN288VFx+nGdOmKDAwUJIU8a/t06RJozx586qwh6e8SpVW0J1AzZ45Q1/06Kqf5y1UunTpDX2zZM2qosWKq2q1GrKzt9f/du3QzBnTlCGjg5q1aClJCgtLKNn+8OFDLVm+WpmdnCRJJb1Kqc5H1fXz7Jka8cPohL7hYYoID1ejJk3l+03CnO5Vq1VXdHSUli9doi7deyhnzlwvP4Cv4EMZ80da+rRWteo1FXj7trZs2aTYuDhFR7/duYcY87c/5q9qTJ9G2rL7lLbtPfNC/TsOWSibNFZyzpZBreqWkrWlhVKmTKGYmOcnFDzJ2tJckdGJJ4KOiIw2rAcAAAAAAAAAAO8ekgKeULx4ca1fv15SQkUANzc3lS9fXkOGDDG0WVtby80tocz27t27ZW9vr1KlSikm5vHNEm9vbw0ZMsToydl/O378uLy8vAwJAY+ObW9vn6ivo6OjISFAelwFIOBfT98mZc+ePZKk6tWrJ4ptxowZunXrlrJmzaqjR4+qcuXKRnHWrFnzhZICLly4oLFjx+rw4cMKCgoytF++fNnwc+3atTVnzhwdPHhQxYsXV1RUlLZu3aq2bdsa+hw/flxVq1Y1JARIUpUqVZ57/DfN0tLqqTcLI6MikyyZ/m+NmzRTgL+/5syepbVrVkmSChVy02dt22nG9KlKnTqNpIS51jt8/pmKlyipfv0HGrb3Ku2tBnXraM7sWer1VcKT1Zs2btC3QwZp7YYtypQ54QngqtWqKy4uXuPHjdZHtWvL3j6drP6JzbNIUcONUklyypJFRYoW1dEjh43OU5I+qmU8xUWt2h9r+dIlOnbkyFtLCvhQxvwR59x55Jw7jyTp43r11bF9W3Xv2kkLFy97a3P3MuZvf8xfRcPqRVXKw1nFGn7/wtvsO3bJ8POyzQd1eGXCuPcbt+qljx8eGS1L88RfG6z+SQYIj3w/EisAAAAAAAAAAPjQmD2/y4elZMmSunbtmgICAnTgwAEVL15cxYsX1507d3T58mUdOHBAHh4ehqdq7927p+DgYBUqVMjoz4ABAxQTE2N4UvZJgYGBSp8+faL2pNpsbW2Nlh8d+3lzvd+7d0/x8fEqVaqUUWyfffaZJOnWrVuGWJ4sG542bVpZWlo+c/8PHjxQ27ZtdfPmTfn6+mrhwoVavny5ChQoYBRb4cKFlSNHDkOyxa5duxQSEmKYOuBRDE+e+4vE8KY5ODgoNjbWKOFBSiiNfj84WA6Ojs/dR/eevfT7rt36ed5CLV+1Vr8sXaG4+ISndB/daD94YL/On/tbFStVNto2Z85cyp07t44cPmRoW7r4FxUoUNBwo/SRipUqKyI83DD/+6PYMmTImCim9BkyKCTkcRnwx32NXwePfichIfefe56vy4cy5k9TrVoNnTxxXFcuX3pu39eFMX/7Y/4qvv+ivlb+dlhR0THK4ZReOZzSy97GWpKULVO655bvDw4N1879f6vJR8Vf6fj+d0KU2cE2UXvmjAlttwLf3ucEAAAAAAAAAAB4cVQKeIKnp6fMzc21f/9+wzQC9vb2ypcvn/bv36/9+/erfv36hv52dnZKnz69pk+fnuT+krrJLyXchLt7926i9qTaXpWdnZ1SpEihX375JcnS4M7OzoZYnrwZ+ODBg+cmHRw5ckT+/v6aNm2aChR4PGd3aGioMj9xI6927dpasmSJBgwYoI0bN8rDw0PZ/zV/eFLj8SIxvGkuBQpKkk6dPKFy5R9PBXHy5AnFxcXJpUCBp21qxNbOTkWLPb4Rt/fPPcqUObOcc+eWJN39Z/zjYmMTbRsTE6PYf7UHBd2RrW3im38xMQlP6cb+UxUiX/78SpXKXLdvJ64oEXj7tlGZdlfXQtq7Z7cCAgKUyzm3of32P3PJ/7vvm/ahjPnTPCrVHxr64Ll9XxfG/O2P+avI7pReTZ3Sq2mtEonW7V3sq6Nnr6tU05HP3Ie1pbns0lq/0vGPnb2uCsXzySaNlUIfPp4SooRbLsN6AAAAAAAAAADw7qFSwBNSp04tV1dXLVmyRMHBwSpWrJgkqUSJElq7dq2uX7+u4sUf3/Ty9vbW3bt3ZW5uLnd390R/LCwskjyOu7u79u7dqwcPHt+EOnDggIKDg18pbnNz80Q30EuXLi1JCg4OTjK2R1MXFC5cWL///rvRDbnNmzc/95gRERGGYz9y6NAh3bhxI1HfOnXq6O7du9q+fbu2b9+u2rVrG613d3fXjh07FBcXZ2jbunXrc2N400p6lZKdnb2WLl5k1L50ySJZWVurfPmKhrZ79+7q0sULCg8Pf+Y+N2/aqJMnjquFT2vDdAk5c+UyrPu306dO6vLlSypQsKChLWdOZ505fUqXn3iqedPGDTIzM1M+FxdJUpo0aVWufHkdPXJYly5eMPS7eOGCjh45rNKlvQ1t1Wt+JElavXK50T5XrViuVKlSqXjJks88p9fpQxnzJxNxJCk6Olrr1q6RlZWV8uTJ88xzep0Y87c/5q+ica/pif4s23JQktR2wFz1Gb3C0NchXdpE2+dwSq+KJfPr0Omrr3T8VVsPK1WqlGrXoIyhzcI8lVrVK6W/jl3S9YDgV9ovAAAAAAAAAAB4s6gUkITixYtr1qxZKlSokOHGefHixbVw4UKZm5urSJEihr5lypRRpUqV9Pnnn+vzzz+Xi4uLwsPDdf78eV25ckXfffddksdo06aNFi1apI4dO6pdu3YKCQnRpEmTlC5dulea0zp37tzatm2bihcvLmtrazk7O8vZ2VktWrRQnz591K5dO3l4eCg6OlqXL1/Wvn37NHnyZElShw4d1LBhQ3Xt2lXNmjXT9evXNWvWrOeW7vf09FTq1Kk1dOhQdejQQQEBAfLz81OmTJkS9c2bN69cXFz07bffKjIyUrVq1TJa37FjRzVs2FDdu3dX48aNdfPmTc2ePVuWlpbJOse3lZWVunbvoe+HD9PXvXrIu0w5HTp4QBvWrVX3nr1kZ29v6Lv4l4WaOnmiZv48TyVKeklKKJc+bcoklfYuIzt7ex0/elRrVq9UmbLl1KJlK8O2roXcVMq7jNauWaUHDx+otHcZ3QkM1KKFC2RpaaWWPq0Nfdu0bafdf+zSZ61aqGmzFrK3t9eunTv0x/92qcGnjeTo+Hj8u/f8Uvv2/qn2bVurWYuE4y1aOE+2dnZq16GToV/Bgq6q3+BTrV65QjGxsSpevIQO7P9Lv27ZrHbtOxrt8037UMb826GD9PDBAxUrXkKOjpl0506gNm5Yp0sXL+qr3r5KnSbNmxriRBjztz/mr2LdjmOJ2gq7ZJMk/br7lIKCHxra9y/7Rjv++lvHzl7XvZAw5c3hoNb1vWWeKqUG/rTGaB9liuZR2aJ5JUkZ06VVGmsL9f28hiTpj0PntftQQrLF/hNXtOLXQxrWva4c0qfVhWt31PLjksrplEGdhi58I+cMAAAAAAAAAAD+O5ICklCyZEnNmjXLqCJAiRIJ5Zrd3NxkZWVl1P+nn37S9OnTtWjRIt24cUM2NjbKly+fGjRo8NRjODo6asaMGRo+fLh69OihHDlyqH///ho2bJhsbGxeOuZBgwbp+++/V/v27RUREaF58+bJy8tLAwYMkLOzs5YsWaJJkyYpTZo0cnZ2Vs2aNQ3burq6asKECRo9erS6deumfPnyady4cWrXrt0zj5kxY0ZNmDBBo0aNUpcuXZQrVy4NHTpUM2fOTLJ/nTp1NGbMGJUuXVoODg5G61xdXTV+/HiNGTPGEMPIkSPVqlWrVxqP16lJsxZKlcpc8+bO1o7ftytzZif17ttPLf51A/NpHB0zycwspeb+PEsPHz5U1mzZ1LX7F2rVuo1SpTJ++03wm6y5P8/S5k0bteeP/yUkoBQtrq7dexqV9C9WvITmLlisqZP9tHTxIgUHBytrtqzq3rOX2rT93GifefLm1ey5CzR+7GjNmDZFZmYpVNKrlHp93SdR8saAQUPl5JRFa1at1PatW5UlSxb17ttPLVu1efXBe0UfwpjXqFlLq1cu19LFi3T/frBSp04j10KF9EWvr1WxcpX/OIIvjzF/+2P+Js1Y9oc+KldI1bwLyia1lQLvhWrb3tMaNetXnTx/06hvxRIuGtDJOFFrSNePJUnDp240JAVIUruB8zS4Sx01q11S6WxT68S5G2rQc6pRHwAAAAAAAAAA8G5JER8fH5/cQSDB5cuX9dFHH+n777/XJ598ktzhJLs///xTbdq00fz581XyFcvXR8S85qAAQFK6Et2SO4QPTvjhickdAgDgNeD7OQAAAADAFIWERyd3CPiAOdqYP7cPlQKS0ZgxY+Ti4iJHR0ddu3ZN06ZNk4ODg6pXr57coSWLIUOGqHTp0rK3t9f58+c1efJkubq6GlVsAAAAAAAAAAAAAAC8OJICklF0dLRGjx6tO3fuyMrKSiVLllSfPn2U5h2f1/pNCQkJ0bfffqvg4GClTZtW5cqVU9++fWVmZpbcoQEAAAAAAAAAAADAe4npA2DSKE8K4E1g+oC3j+kDAMA08P0cAAAAAGCKmD4AyelFpg/gEWwAAAAAAAAAAAAAAEwUSQEAAAAAAAAAAAAAAJgokgIAAAAAAAAAAAAAADBRJAUAAAAAAAAAAAAAAGCiSAoAAAAAAAAAAAAAAMBEkRQAAAAAAAAAAAAAAICJIikAAAAAAAAAAAAAAAATRVIAAAAAAAAAAAAAAAAmiqQAAAAAAAAAAAAAAABMFEkBAAAAAAAAAAAAAACYKJICAAAAAAAAAAAAAAAwUSQFAAAAAAAAAAAAAABgokgKAAAAAAAAAAAAAADARJEUAAAAAAAAAAAAAACAiSIpAAAAAAAAAAAAAAAAE0VSAAAAAAAAAAAAAAAAJoqkAAAAAAAAAAAAAAAATBRJAQAAAAAAAAAAAAAAmKgU8fHx8ckdBAAAAAAAAAAAAAAAeP2oFAAAAAAAAAAAAAAAgIkiKQAAAAAAAAAAAAAAABNFUgAAAAAAAAAAAAAAACaKpAAAAAAAAAAAAAAAAEwUSQEAAAAAAAAAAAAAAJgokgIAAAAAAAAAAAAAADBRJAUAAAAAAAAAAAAAAGCiSAoAAAAAAAAAAAAAAMBEkRQAAAAAAAAAAAAAAICJIikAAAAAAAAAAAAAAAATRVIAAAAAAAAAAAAAAAAmiqQAAAAAAAAAAAAAAABMFEkBAAAAAAAAAAAAAACYKJICgHdQ5cqVNWzYsBfu7+vrqzp16rzBiJCUffv2ycXFRcePHze0ubi4aNasWckY1aubM2eOKlasqIIFC6pLly6aNGmSPvvsMxUvXjzReQJPs3LlSq1bty65wwAAwGRcuHBBn332mTw9PVWmTBmNGjVKUVFRyR0WPgBXrlzRoEGDVK9ePbm6uvJ/Trw1mzZtUufOnVW+fHl5enqqXr16Wr58ueLj45M7NJi4nTt3qmXLlipVqpTc3NxUpUoVjRgxQqGhockdGj4wDx8+VPny5bkeh7di5cqVcnFxSfRn9OjRyR0aPhCrVq1S/fr15e7uLi8vL33++eeKiIhI7rBMUqrkDgBAYhMnTpStre0L9+/SpYvCwsLeYEQwdZcvX9bIkSPVvn17VapUSenSpVPr1q2VI0cOeXt7a8uWLckdIt4Tq1atUurUqfXxxx8ndygAALz37t+/r9atWytXrlzy8/NTQECARo4cqYiICA0aNCi5w4OJO3funHbu3CkPDw/FxcVxQxZvzZw5c5Q1a1b5+voqXbp02rNnjwYOHCh/f39169YtucODCQsODlbhwoXl4+Mje3t7nTt3Tn5+fjp37pxmz56d3OHhAzJ58mTFxsYmdxj4wMycOVM2NjaG5UyZMiVjNPhQTJkyRTNmzFCnTp3k6empe/fu6c8//+Qz8A0hKQB4DaKiopQqVSqZmb2e4huurq4v1T9Hjhyv5bjvu/j4eEVHR8vCwiK5Q3nvXLp0SfHx8WrcuLGyZ88uSdqxY4fMzMy0b9++9yYpICIiQlZWVskdxgeJsQcA4PVbvHixHj58qIkTJ8re3l6SFBsbq6FDh6pjx45cqMMbVblyZVWtWlVSQnW6EydOJHNE+FBMmTJF6dOnNyyXLl1awcHB+vnnn9WlS5fXdu0FeFK9evWMlr28vGRhYaGBAwcqICCAf3fxVly4cEG//PKL+vbtq8GDByd3OPiAFCpUyOjfX+BNu3jxoiZOnKjJkyerQoUKhvYaNWokY1SmjW/RwBMeleLfuXOn6tSpI3d3dzVo0EBHjhwx9HlU3n/GjBmqVKmSChcurODgYEkJ5XY+/vhjubu7q1y5cho3blyirKaAgAD16dNH3t7eKly4sGrWrKm5c+cm2v8j586dU/v27eXl5SUPDw/VqFFDM2bMSBTzv509e1bt2rWTp6enihUrph49eujmzZtGfVxcXDRjxgz5+fnJ29tbXl5e6tev33tTdeDfv6u6devK3d1d27dv1+HDh9WqVSvDuX/11VcKCgoy2jYqKkrjxo1TlSpV5ObmpvLly8vX19ew/vDhw+rUqZPKli1rKFe4evXqt3yGb4evr686deokSapatapcXFy0cuXK/3ShZfr06apWrZrc3d1VqlQptWnTRteuXTOsf974S9Kvv/6qevXqyd3dXWXLltWIESMUGRlpWP9o+oYdO3aoR48eKlq0qHr27ClJCgkJ0ZAhQ1S2bFm5ubmpQYMG+uOPP175fN6kZ72/fXx81LFjR6P+p0+flouLi/bt22doc3Fx0fTp0zVq1CiVKlVKRYoUka+vrx48eGDo82i8du7cqW7dusnT01Nly5bV1KlTE8W0f/9+NW3aVIULFzZ8Ljz6jJOk69evG14nAwYMkJeXlxo1aiQfHx/99ddf2rFjh6HUmJ+f32seMQAAPhy7du1S6dKlDQkBkvTRRx8pLi5Ou3fvTr7A8EHgxiuSS1I3JAoWLKgHDx68N9crYDoe/RscHR2dvIHggzF8+HA1bdpUzs7OyR0KALxRK1euVLZs2YwSAvBmUSkASEJgYKCGDh2q7t27y9bWVjNmzFC7du3066+/KkOGDJISbljmzJlT/fv3l5mZmVKnTq2ff/5ZP/74o1q3bi1fX19duHDBkBTw9ddfS5Lu3bunJk2aSJJ69eqlbNmy6cqVK7p69epT4+nUqZMyZsyo7777TmnTptXVq1fl7+//1P63bt1Sy5YtlT17dv3444+KjIzUuHHj1LJlS61du1Zp06Y19F24cKGKFSumkSNH6vLlyxo1apQyZMhgiPddd/v2bQ0fPlydO3eWk5OTzM3N5ePjowoVKmjcuHEKDw/X+PHj1aVLFy1ZssSwXffu3bV371517NhRnp6eunv3rn799VfD+ps3b6po0aJq1qyZLCwsdOjQIQ0YMEDx8fH65JNPkuNU35guXbooT548Gj16tCZOnCgHB4f/VH1i9erVmjBhgnr06CFPT0+Fhobq4MGDevjwoaHP88Z/27Zt6tGjh2rXrq2vvvpKFy9e1Lhx43Tr1i399NNPRscbOHCg6tatq0mTJsnMzExRUVH67LPPFBQUpC+++EKZMmXS2rVr1bFjR8McWe+Sl31/P838+fNVqFAh/fDDD7p+/bpGjx5teO//28CBA1W7dm35+flpz549GjdunOzs7NSsWTNJ0okTJ/TZZ5/Jy8tLEyZM0J07dzRmzBidP39eixcvVsqUKQ37Gjt2rCpUqKAxY8YoLi5OWbJkUe/evWVlZaW+fftKkjJnzvwfRgcAgA/bxYsX9emnnxq12draysHBQRcvXkymqADg7Tt48KAyZcpkdD0DeFNiY2MVExOj8+fPa9KkSapcubKyZcuW3GHhA7B582b9/fff8vPz08mTJ5M7HHxg6tSpo3v37ilLlixq3LixPv/8c6PrgMDrdvToUeXPn1+TJ0/W/PnzFRoaKjc3N/Xr108eHh7JHZ5JIikASEJwcLDGjx+v0qVLS5JKliypChUqaM6cOfrqq68kJWQIz5gxQ6lTp5YkPXjwQD/99JM+//xzffnll5KkMmXKyNzcXCNHjlS7du2ULl06zZkzR0FBQdq0aZPhPxSPjpOUu3fv6vr16+rfv78qV64sSSpVqtQz458zZ45iYmI0e/ZsQ0ZzwYIFVbt2ba1atUo+Pj6Gvg4ODhozZowkqXz58jp16pS2bNny3iQF3L9/XzNmzDD8I9GyZUu5ublp4sSJSpEihSQpf/78hooCFSpU0O7du7Vjxw6NGTPGqMLCv3+uXbu24ef4+HiVKFFCAQEBWrJkicklBeTIkcOQfVywYMH//B/dY8eOycXFxegJ90dlRyW90PhPnDhRnp6eRq9Na2trDRo0SGfPnjW6sV+5cmX17t3bsLxixQqdOXNGa9asUd68eSVJ5cqV05UrVzR58mRNmDDhP53f6/Qq7++nsbCw0KRJkwxf1i0tLTVgwAB169ZNefLkMfQrVaqU4YZ9uXLlFBQUpClTpqhJkyYyMzPT1KlT5eDgoKlTp8rc3FyS5OTkpHbt2mnnzp2GOCWpQIEC+u6774ziSJs2rVKnTi1PT89XOg8AAPBYSEiIbG1tE7Xb2dnp/v37yRARALx9Bw4c0MaNGw3/jwHetEqVKikgIEBSwv+bH12bAN6k8PBwjRw5Ur169SIBCm+Vg4ODunfvLg8PD6VIkULbt2/X+PHjFRAQoEGDBiV3eDBhgYGBOnHihP7++28NHjxY1tbWmjp1qtq2bWv0gC5eH2rBAUmwsbExulFvY2Mjb29vHT161NDm5eVlSAiQEsrNh4WFqWbNmoqJiTH88fb2VkREhM6dOydJ+vPPP1WqVKkXvvGaLl06Zc2aVWPHjtWqVate6AniAwcOyMvLy6jMaJ48eVSgQAEdPHjQqK+3t7fRcp48eV7pKeXkYm9vb0gICA8P16FDh1SzZk1DVndMTIxy5colJycnHT9+XFLC78Da2troxv+T7t+/r+HDh6tSpUoqVKiQChUqpCVLlujSpUtv5bzeB/Hx8Uav9UfTZLi6uurUqVMaMWKEDhw4kKjE3vPG/+HDhzp9+nSiuYNq1aolSYlewxUrVjRa3r17t/Lnz69cuXIlei8+eg28K17l/f00lSpVMsrerVmzpuLj4xOdc7Vq1YyWa9SooYCAAMOxDxw4oCpVqhgSAiSpbNmysrW1fe7YAwAAAMDr5O/vr169esnLy0utWrVK7nDwgZg+fboWL16s4cOH6+LFi+rUqVOiqUGB123KlCnKkCFDoipRwJtWrlw5devWTeXKlVPZsmU1aNAgtWnTRosXL9bt27eTOzyYsPj4eIWFhWnChAmqWbOmKlSooClTpig+Pl4LFixI7vBMEpUCgCQkNX9dhgwZdOHCBaPlf7t3754kPfUp8lu3bklKqEKQL1++F44lRYoUmjVrlsaNG6dhw4YpLCxMhQoVUr9+/VSiRIkktwkJCVHBggWTPIcnnyh68skjc3NzRUVFvXB8yS1jxoyGn0NCQhQbG6sRI0ZoxIgRifr++3fg4OBgqCSQFF9fXx0+fFhdu3ZV3rx5lTZtWi1atEibNm16/Sfxnvrrr7+MLsqULFlS8+fPV4MGDfTw4UMtXbpUc+bMkY2NjerXr6+vv/5aVlZWzx3/0NBQxcfHJ3qP2djYyMLCItFrOKn34qlTp1SoUKFE+37XSl69yvv7aZ4ch7Rp08rS0jLRl/cnP98evYcCAwOVJUsWhYSEJJmFmdTnB9maAAC8Wba2tgoNDU3Ufv/+fdnZ2SVDRADw9oSEhKh9+/ayt7eXn5+fzMx4tglvR4ECBSRJRYoUkbu7u+rVq6fffvtNNWvWTObIYKpu3Lih2bNna9KkSYbvfmFhYYa/Hz58qDRp0iRniPjAfPTRR5o9e7ZOnz4tR0fH5A4HJsrW1lb29vaGf3elhIdAXV1ddf78+WSMzHSRFAAk4e7du4nagoKC5ODgYFh+8obmo4tyEydOTHIO7UeVAezt7V86w87Z2Vk//fSToqOjdfjwYY0dO1adOnXSrl27kvxCaGdnp6CgoCTPIVeuXC917Hfdv38PNjY2SpEihTp27GhUrv6RdOnSSUr4HQQGBio+Pj7JG9ORkZHasWOHfH19jaZa+OWXX97AGby/ChUqpOXLlxuWH70WzczM1Lp1a7Vu3VoBAQHasGGDxowZo3Tp0qlr167PHf9Hv8cn34ehoaGKiopKdAE8qfeii4tLorL276pnvb8tLCwSVVp4WqngJ9/zDx48UGRkZKIv7k+O6507dyTJ8Pn2rM+P5409AAB4vXLnzq2LFy8atYWGhiowMFC5c+dOpqgA4M2LiIhQx44dFRoaqiVLlsjGxia5Q8IHysXFRebm5rp69WpyhwITdv36dUVHR6tDhw6J1rVq1UoeHh5aunRpMkQGAG9O3rx5n/rva2Rk5FuO5sNAii2QhNDQUP35559Gy3v27DGUqU9KkSJFZG1tLX9/f7m7uyf68+iGdOnSpbV3717dvHnzpeMyNzdXyZIl1aFDBz148OCpyQXFihXT3r17jW4eXrx4UWfPnlWxYsVe+rjvi0fzmF+8eDHJ38GjxAxvb2+Fh4c/9an/qKgoxcXFGZVPf/DggbZv3/5WzuN9kTZtWqPxTerCdKZMmdS2bVu5uLgYLmg/b/zTpEmjggULavPmzUbtj/o/7zXs7e2ta9euydHRMcnXwbsqqfd35syZdenSJcXHxxv67d69O8ntf//9d6Nyhps3b1aKFCkSnfNvv/1mtLxlyxY5OjoakpmKFSumbdu2KSYmxuiYISEhL/T5YW5uzpc2AABek/Lly2vPnj0KCQkxtG3evFlmZmYqU6ZMMkYGAG9OTEyMvvjiC128eFEzZ85UpkyZkjskfMCOHj2q6OjoF54GFHgVBQsW1Lx584z+9OvXT5I0dOhQDR48OJkjxIdm48aNSpkypVxdXZM7FJiwSpUqKTg4WKdPnza03bt3TydPnkyyCjD+OyoFAEmwt7dX//791aNHD9nY2GjGjBmKj49X69atn7qNra2tevTooR9//FH+/v4qWbKkUqZMqWvXrmnbtm3y8/OTtbW12rRpozVr1qhly5bq3LmzsmfPrmvXruny5cvq3bt3ov2eOXNGP/zwg2rVqqXs2bPrwYMHmjZtmrJmzaocOXIkGUubNm20cuVKtW3bVp07d1ZkZKTGjx8vJyenp05vYCr69Omj1q1b64svvlDt2rVla2srf39/7dmzRw0aNJCXl5e8vb1VoUIFffPNN7p69ao8PDwUHBysLVu2aPz48bKxsZG7u7tmzJih9OnTK1WqVJo+fbrSpk2bZBUJU/XXX3/p7t27hlI9e/fu1Y0bN5Q1a9Zn3lwfNGiQbG1t5enpKVtbWx06dEhnzpxRs2bNJOm54y9J3bp1U9euXfX111+rbt26unTpksaNG6caNWrIxcXlmXHXr19fixcvVqtWrdS2bVvlypVLoaGhOnXqlKKjo/XVV1+9ngF6DZ73/q5Ro4aWL1+ub7/9VlWrVtWhQ4e0ZcuWJPcVFRWlrl27qlmzZrp+/bpGjx6tGjVqKE+ePEb99u7dqx9++EFlypTR7t27tWbNGg0aNMhQirNTp05q2rSpOnbsKB8fH925c0djxoxR4cKFVaFCheeeU+7cubV69Wpt375dDg4OcnR05CIeAACvqGnTppo/f766du2qjh07KiAgQKNGjVLTpk359xVvXHh4uHbu3CkpoazxgwcPDIm7JUuWTHLaPeB1GDp0qH7//Xf5+vrqwYMHOnLkiGGdq6urLCwski84mLRu3brJzc1NLi4usrKy0pkzZzRr1iy5uLgkWZESeF1sbW3l5eWV5LpChQpxcwxvVLt27eTl5WW45rpt2zYtXbpUrVq1MqqcDLxuVatWlbu7u3r06KFevXrJ0tJS06dPl4WFhZo3b57c4ZkkkgKAJDg4OOjrr7/WqFGjdPXqVeXLl0+zZs0ymr8+KW3btlWmTJn0888/a8GCBUqVKpVy5MihihUrGp46T5cunRYtWqQxY8Zo9OjRCg8PV9asWZ/6Iefg4KCMGTNq2rRpCggIkI2NjYoXL64ff/zxqfOjOzk5af78+Ro1apS+/vprw5NEvr6+Sps27X8bnHdc0aJF9csvv8jPz0/9+vVTdHS0MmfOrFKlSilnzpyGfn5+fpo4caKWLFmiiRMnKkOGDEZPW40ZM0aDBg2Sr6+v7O3t5ePjo7CwMM2ePTs5TitZ+Pn56a+//jIsjx49WpL0ySefaOTIkU/drkiRIlq6dKmWLVum8PBwZc+eXf369VOjRo2M9v2s8a9SpYomTJigSZMmqUuXLrK3t1fjxo1f6Ia+hYWF5s2bJz8/P02dOlWBgYGGuYjetS8Tz3t/ly9fXr1799aCBQu0atUqlS9fXkOHDlWbNm0S7cvHx0d3795Vnz59FBUVpWrVqmnQoEGJ+g0bNkxLlizRokWLlCZNGvXs2VMtWrQwrHdzc9Ps2bM1duxYde/eXalTp1blypXVt2/fp37m/Fv79u119epV9e3bVyEhIerWrZu6d+/+n8YJAIAPlZ2dnebOnatvv/1WXbt2VZo0adSwYUP16tUruUPDByAoKEg9e/Y0anu0PG/evKfevAD+q0fV0ZL6f+e2bdt4YhtvTOHChbVx40ZNnz5d8fHxypo1qxo1aqR27dqRjALAZDk7O2vFihXy9/dXXFyccuXKpW+++cZoWl3gTTAzM9P06dM1YsQIDRo0SNHR0SpevLgWLlxIQsobkiL+3zWJAcjX11cnTpzQ+vXrkzsUAHghLi4u6tOnj9q1a/fUPvv27VOrVq20fPnyd3oaBQAAAAAAAAAA8HqZJXcAAAAAAAAAAAAAAADgzSApAAAAAAAAAAAAAAAAE8X0AQAAAAAAAAAAAAAAmCgqBQAAAAAAAAAAAAAAYKJICgAAAAAAAAAAAAAAwESRFAAAAAAAAAAAAAAAgIkiKQAAAAAAAAAAAAAAABNFUgAAAAAAAAAAAAAAACaKpAAAAAAAAAAAAAAAAEwUSQEAAAAAAAAAAAAAAJgokgIAAAAAAAAAAAAAADBRJAUAAAAAAAAAAAAAAGCiSAoAAAAAAAAAAAAAAMBEkRQAAAAAAAAAAAAAAICJIikAAAAAAAAAAAAAAAATRVIAAAAAAAAAAAAAAAAmiqQAAAAAAAAAAAAAAABMFEkBAAAAAAAAAAAAAACYKJICAAAAAAAAAAAAAAAwUSQFAAAAAAAAAAAAAABgokgKAAAAAAAAAAAAAADARJEUAAAAAAAAAAAAAACAiSIpAAAAAAAAAAAAAAAAE0VSAAAAAAAAAAAAAAAAJoqkAAAAAAAAAAAAAAAATBRJAQAAAAAAAAAAAAAAmCiSAgAAAAAAAAAAAAAAMFEkBQAAAAAAAAAAAAAAYKJICgAAAAAAAAAAAAAAwESRFAAAAAAAAAAAAAAAgIkiKQAAAAAAAAAAAAAAABNFUgAAAAAAAAAAAAAAACaKpAAAAAAAAAAAAAAAAEwUSQEAAAAAAAAAAAAAAJgokgIAAAAAAAAAAAAAADBRJAUAAAAAAAAAAAAAAGCiSAoAAAAAAAAAAAAAAMBEkRQAAAAAAAAAAAAAAICJIikAAAAAAAAAAAAAAAATRVIAAAAAAAAAAAAAAAAmiqQAAAAAAAAAAAAAAABMFEkBAAAAAAAAAAAAAACYKJICAAAAAAAAAAAAAAAwUSQFAAAAAAAAAAAAAABgokgKAAAAAAAAAAAAAADARJEUAAAAAAAAAAAAAACAiSIpAAAAAAAAAAAAAAAAE0VSAAAAAAAAAAAAAAAAJoqkAAAAAAAAAAAAAAAATBRJAQAAAAAAAAAAAAAAmCiSAgAAAAAAAAAAAAAAMFEkBQAAAAAAAAAAAAAAYKJICgAAAAAAAAAAAAAAwESRFAAAAAAAAAAAAAAAgIkiKQAAAAAAAAAAAAAAABNFUgAAAAAAAAAAAAAAACaKpAAAAAAAAAAAAAAAAEwUSQEAAAAAAAAAAAAAAJgokgIAAAAAAAAAAAAAADBRJAUAAAAAAAAAAAAAAGCiSAoAAAAAAAAAAAAAAMBEkRQAAAAAAAAAAAAAAICJIikAAAAAAAAAAAAAAAATRVIAAAAAAAAAAAAAAAAmiqQAAAAAAAAAAAAAAABMFEkBAAAAAAAAAAAAAACYKJICAAAAAAAAAAAAAAAwUSQFAAAAAAAAAAAAAABgokgKAAAAAAAAAAAAAADARJEUAAAAAAAAAAAAAACAiSIpAAAAAAAAAAAAAAAAE0VSAAAAAAAAAAAAAAAAJoqkAAAAAAAAAAAAAAAATBRJAQAAAAAAAAAAAAAAmCiSAgAAAAAAAAAAAAAAMFEkBQAAAAAAAAAAAAAAYKJICgAAAAAAAAAAAAAAwESRFAAAAAAAAAAAAAAAgIkiKQAAAAAAAAAAAAAAABNFUgAAAAAAAAAAAAAAACaKpAAAAAAAAAAAAAAAAEwUSQEAAAAAAAAAAAAAAJgokgIAAAAAAAAAAAAAADBRJAUAAAAAAAAAAAAAAGCiSAoAAAAAAAAAAAAAAMBEkRQAAAAAAAAAAAAAAICJIikAAAAAAAAAAAAAAAATRVIAAAAAAAAAAAAAAAAmiqQAAAAAAAAAAAAAAABMFEkBAAAAAAAAAAAAAACYKJICAAAAAAAAAAAAAAAwUSQFAAAAAAAAAAAAAABgokgKAAAAAAAAAAAAAADARJEUAAAAAAAAAAAAAACAiSIpAAAAAAAAAAAAAAAAE0VSAAAAAAAAAAAAAAAAJoqkAAAAAAAAAAAAAAAATBRJAQAAAAAAAAAAAAAAmCiSAgAAAAAAAAAAAAAAMFEkBQAAAAAAAAAAAAAAYKJICgAAAAAAAAAAAAAAwESRFAAAAAAAAAAAAAAAgIkiKQAAAAAAAAAAAAAAABNFUgAAAAAAAAAAAAAAACaKpAAAAAAAAAAAAAAAAEwUSQEAAAAAAAAAAAAAAJgokgIAAAAAAAAAAAAAADBRJAUAAAAAAAAAAAAAAGCiSAoAAAAAAAAAAAAAAMBEkRQAAAAAAAAAAAAAAICJIikAAAAAAAAAAAAAAAATRVIAAAAAAAAAAAAAAAAmiqQAAAAAAAAAAAAAAABMFEkBAAAAAAAAAAAAAACYKJICAAAAAAAAAAAAAAAwUSQFAAAAAAAAAAAAAABgokgKAAAAAAAAAAAAAADARJEUAAAAAAAAAAAAAACAiSIpAAAAAAAAAAAAAAAAE0VSAAAAAAAAAAAAAAAAJoqkAAAAAAAAAAAAAAAATBRJAQAAAAAAAAAAAAAAmCiSAgAAAAAAAAAAAAAAMFEkBQAAAAAAAAAAAAAAYKJICgAAAAAAAAAAAAAAwESRFAAAAAAAAAAAAAAAgIkiKQAAAAAAAAAAAAAAABOVKrkDAN6kiJjkjgAA8DpY8Y0FAEyCdZFuyR0CAAAAAACASQk/PPG5fagUAAAAAAAAAAAAAACAiSIpAAAAAAAAAAAAAAAAE0VSAAAAAAAAAAAAAAAAJoqkAAAAAAAAAAAAAAAATFSq5A4AAEzJyhXLNG/ObN24fl2ZMzupWUsfNW/h80Lbnjp5Qn4TxunokcOKj49XYc8i6vVlbxUoWNCoX1xcnJYvW6LlSxbr6tWrsk5trYIFXdWhUxd5Filq1PfKlcua5DdBhw8dVMj9+8rs5KSPatVR68/aydra2qhvdFSU5s6ZrXVrV+vmjRtKa2OjQoXcNHDwMGXKnFmSdP78OU2d5KdTp04q6M4dWVlZKXeevGr9WTtVrFT5P4wcAOBD5eLi8tw+I0aMUIMGDZ66ft++fTp8+LA6der00se/fv26qlSpogkTJqhmzZovvT0AAAD+m/aNyqpiifwq4ZZL2Z3Sa/7aveoweMFT+1fyclGfttVVpGAOmZml0LkrtzVu7lYt//WQoU/D6kVVq7ybSrjnUt4cjtp14JxqtJ+Q5P7y5HDQ4C515O2ZW+ls0+ia/10t2XxA4+dtU3hEtFHfUh7O+q5nfXkWyK6QhxFa+dshDfJbq4fhUYY+5Yrl068zeyZ5rAqtRuuv45cNy1tm9FT54vkS9ft19ynV6zbZsFwwd2YN6FRLRQrmUKYMtgqLiNKZS/4aN3erNu468dSxAgAAeISkAAB4TZYtXazhQwerarUa8mn1mQ4dOqAfvh+uiPBwtf28wzO3PX3qpNr4NFemzE7q2KWb4uPitGTxL2rXpqUWLl6mXM65DX3Hjh6l+XN/Vu2P66px0+YKDQ3R8mVL1K6Nj+bMXyT3woUlSf63bqlF00aySWujps1ays7OTkePHtGUSX46feqkJkycYthndHS0unXpqCNHDuvTTxspn4uLQkJCdOLYUYU+CFUmJSQF3Lp5Uw8fPlTdep/IwcFRERHh2vrbr+rZrbMGDh6mho2bvIGRBQCYsiVLlhgtN2nSRD4+PqpTp46hLUeOHM/cx19//aXZs2e/UlIAAAAAktdXbaopbWorHTh5WZkz2j2zr0/dUpo6uLm27T2rwRPXKTYuTvlzOipbpnRG/do3KqciBbPr4MkrSm+X5qn7y5bJXv+b31shD8I1dcku3b0fJq/CzhrUuY6KFMyhxr2mG/oWzp9VG6d215lLAeo7dqWyOtrri1ZVlCeHg+p3m5Jo35N++V0HTl41artwLTBRv+v+9zTQb61R263A+0bLObKkV9rUVlqwbp9uBd5XaisL1a/qqRUTOqnrt4s0e+Xupw8aAACASAoAgNciIiJCEyeMU7kKFTVm/E+SpE8bNVZcXJymT52iho2ayNbu6f+xneQ3QZaWVpr/y2LZ2yf8R7b2x3VVt1YN/TR+nMZO8JMkxcTEaNmSRapWvYa+H/mjYftqNWqqdo2q2rhhrSEpYP26NQoNCdGc+b8ob96ErPOGjZsoPi5O69auVsj9+4aYFsybowP792vO/F8M2yelXPkKKle+glFb0+Yt1axRA82f9zNJAQCAl+bp6ZmozcnJKcn2D0FERISsrKySOwwAAIC3pvrn43X11j1JUuDuMU/tl8Mpvcb7NtaUxTv19Y8rnrnPdgPm6sbt+4qPj9eBZd88tV+z2iWVzja1qnw2Vqcv+kuSZq/cLTOzFGr5sZfsbawVHBouSRrava6CQ8NVo/0EhT6MkCRduRWkKYNaqEqpAtq294zRvncfvqBVW4889/zvPwjX4o37n9lnyx+ntOWPU0ZtU5bs1J5f+qpHy0okBQAAgOcyS+4ATFV8fLyioqKe39FEfejnjw/P/r/2KTg4WE2aNjdqb9qshcLDw7Rr145nbn/o4AGVKl3akBAgSQ4OjipWoqR27fxdYQ8fSkpICoiIiFD6DBmNtk+fPoPMzMxkafn4JsKDBw8kSRkyZDDqm9HBQWZmZkplbi4pYTqChQvmqXLVqnIvXFgxMTEKDw9/4XNPmTKlMmV2UmhI6AtvAwDAi4qLi9PkyZNVuXJlubm5qWbNmlq8eLFhvZ+fnyZOnKiwsDC5uLjIxcVFPj4JU/dcuHBBvXr1UoUKFeTh4aFatWpp9uzZiouLe+V49u3bJxcXF+3cuVPdunWTp6enypYtq6lTpxr1e5FjX79+XS4uLlq5cqUGDBggLy8vNWrUSJK0Y8cOffbZZypdurSKFi2qRo0aadeuXUbHWLlypVxcXHT8+HG1bdtWHh4eqlGjhvbs2aO4uDiNGzdO3t7e8vb21pgxY4yO7e/vr549e8rb21vu7u6qXLmyvv/++1ceFwAAgFf1KCHgedo3KquUKVNo2JQNkqQ01hZP7Xs9IFjx8fHP3adt2oTrKLfvGl/T8L9zX7GxcYqKjpUk2aSxUhWvAlq04S9DQoAkLVyXsPxpdePpHB9Jm9pSKVM+/xJ8ypRmzzyfpMTFxeu6/z3Z2aR+qe0AAMCH6b1NCng0Z2jZsmXl6empevXqafXq1Yn6hYSE6Ntvv1X58uXl5uamypUra8wY44zTHTt2qGnTpvLw8FCJEiXk4+OjU6cSMi8fXWi7e/eu0Tb16tWTr6+vYdnX11d16tTRzp07VbduXbm7u2v79u0KCwvTsGHDVKNGDXl4eKhy5coaNGiQQkMT3zxbvXq16tevL3d3d3l5eal9+/a6ceOG7t69Kzc3Ny1dujTRNo0aNVLPnknPUSW92MW+CxcuqFu3bipZsqQ8PDxUt25drV+/3rA+MjJSI0aMUNmyZeXu7q569erpt99+M9rH085fSvhdtWrVSp6enipWrJi++uorBQUFPTVm4H105nTCZ4ZrITejdlfXQjIzM9OZ06efuX1UVJTRDf1HrK2sFB0drfPnz0mSrKys5F7YQ2tXr9KG9Wt16+ZN/X32jAb195Wtra0aNnr8pH6JEiUlSUMG9teZ06flf+uWNm/aqGVLFql5Cx+lTp3wn8YLF84r8PZt5c/vomGDB6pUcU+VKu6php98rL/27U0y3rCwMN27d1fXrl7V/LlztPuPXfIqVeoFRwsAgBc3atQoTZw4UZ988ommTp2qsmXLavDgwVqwIGGe2UaNGqlhw4aysrLSkiVLtGTJEg0ePFiSdPv2bTk7O2vw4MGaPn26GjdurEmTJmny5MnPOuQLGThwoLJnzy4/Pz99/PHHGjdunBYtWmRY/zLHHjt2rOLj4zVmzBj17t1bUkLCQKVKlTRq1Cj5+fmpaNGi6tChg/bt25do+759+6pixYqaOHGiHB0d1a1bN3333Xfy9/fXDz/8oObNm2v69OnasGGDYZs+ffro7NmzGjBggGbOnKkePXokmbDg5+f3n8cKAADgdajkVUBnLweoZtlCOr/5W93ZM1Y3dvygQV1qK0WKFK+0z10HEq63TBncQoXzZ1W2TPZqWL2o2jcsp8mLdigsIuGhJ7e8WWRunlKHThlPBxAdE6tjZ6/LwyVbon1PG9JSgbvHKHjvOG2e3kNFXZOeEitfTkcF7RmjO3vG6tJv32tQl9pKlSrpy/aprSyUwT6NnLNlVPcWlVSjjKt2/HX2lc4dAAB8WN7b6QNu3rypokWLqlmzZrKwsNChQ4c0YMAAxcfH65NPPpGUcJOtdevWunHjhrp27ar8+fPL399fBw8eNOxn48aN+vLLL1WlShWNGTNG5ubmOnTokAICAuTq6vpSMd2+fVvDhw9X586d5eTkpCxZsigiIkKxsbHq1auX0qdPr1u3bmnq1Knq0qWL5s+fb9h25syZ+vHHH9WwYUP16tVL0dHR2rt3r+7evSt3d3dVq1ZNK1asUOPGjQ3bnDt3TseOHVOPHj2eGlOfPn10+/ZtDRgwQBkyZNCtW7d04sQJw/rLly+rSZMmcnJyUv/+/eXg4KC///5bN2/eNPT5+uuv9b///U9ffPGFcufOrTVr1qh79+6aNGmSqlSp8szzP3z4sHx8fFShQgWNGzdO4eHhGj9+vLp06WI0f6yPj49u3LhhSCQA3jeBgYFKmTJloqfyzS0sZGdvr8Dbt5+5fS5nZx07dkSxsbFKmTKlJCk6KkrHjx2TJN0OCDD0/X7kj+rzdS9907e3oS1b9uyau2CRsmXPbmgrU668unbvqVkzpmnH74/fW+07dFK3nr0My1evXJGUMIWArZ29Bg4eJkmaOWOaunT8XL8sWa78LgWM4h3z40gtX5rwHjYzM1OVqtXUr/+g54wSAAAv5+7du1qwYIHatWun7t27S5LKli2re/fuadKkSWrWrJkyZ86szJkzy8zMLNGUA6VLl1bp0qUlJVSyKlasmCIiIrRgwQJ169btP8VWqlQp9e3bV5JUrlw5BQUFacqUKWrSpInMzMxe6tgFChTQd999Z9TWsmVLw89xcXHy8vLS+fPntXTpUnl5eSXq27x5QrWiTJky6eOPP9aJEycM37fLlSun7du3a/Pmzfr4448lScePH9eXX36pWrVqGfZTv359w88pUqRQypQpX/kCOwAAwOuWN7uDYuPiNG1IS42du1XH/76hepU91K/9R0qVMqUG+a196X3+tue0hkxapz5ta+jjio+nUxw5Y7OGTn780FRmB1tJkv+dkET78L8TIu8ieQzL0TExWrX1sDb/cVJBwQ9VMHdm9fSpoq2zvlClNmN19Ox1Q9+L1wO1c//fOnn+plJbW+iTqkXUr/1HypfDUT6+Pyc61sivGqh9w7KSpNjYOK3ZfkS9RiZ+kAwAAOBJ721SQO3atQ0/x8fHq0SJEgoICNCSJUsMSQGrV6/WqVOntHjxYhUpUsTQ/9H6+Ph4/fDDDypTpowmTZpkWF+hgvF82S/q/v37mjFjhjw8PIzahw4davg5JiZG2bJlU/PmzXXp0iU5OzsrNDRUEydOVJMmTTRs2DBD36pVqxp+bty4sdq0aaMLFy4oT56EL5krVqyQk5OTypQp89SYnnexz8/PT+bm5lq0aJHSpk0rSfL29jasP3PmjH799VcNHTpUTZs2lSSVL19eN27cSJQUkNT59+/fX25ubpo4caLhgmL+/PkNVQUejbWZmZnhRijwPoqMjJD5P+X4n2RpYanIyIgk1z3SuGlzfTdsiIYM7K82bT9XXHycZkybosDAQElSxL+2T5MmjfLkzavCHp7yKlVaQXcCNXvmDH3Ro6t+nrdQ6dKlN/TNkjWrihYrrqrVasjO3l7/27VDM2dMU4aMDmrWIuFmQ1hYwtQEDx8+1JLlq5XZyUmSVNKrlOp8VF0/z56pET+MNoq3pU9rVateU4G3b2vLlk2KjYtTdHT0yw0aAADPcezYMUVHR6tmzZpG7R999JHWr1+vy5cvG74bJyUyMlLTpk3TunXrdOvWLaN/qx4+fKg0adK8cmzVqlUzWq5Ro4bWrFkjf39/ZcmS5aWOXbFixUT79/f317hx47Rnzx4FBgYayt8WKlQoUd9//38gV65ckhKSFv7N2dlZly5dMiy7urpq9uzZSpkypcqUKaOcOXMa9c+aNauhehoAAMC74FEp/gETVmvMnK2SpNXbjiidXWp1bVZRo2Zt0YOwyJfe75Wbd/XHofNave2I7t5/qJrlCqlPu+oKCArR1CUJ0zdZWSZc84mMikm0fURUtKytHl8T2nv0kvYenWVY3rDzuFZuPaz9S77RsO51Va/b48pRnYf+YrSvRRv2a+KAZmr3aRn5Lfxdfx2/bLR+4sLftWrrYTk52OnTakWV0sxMFubv7SV+AADwFr233xju378vPz8/bdu2TQEBAYqNTZjfyd7e3tDnzz//VJ48eYwSAv7t4sWL8vf3Nzzh81/Z29snSgiQEpIT5syZoytXrigsLMzQfvnyZTk7O+vw4cMKDw9Xw4YNn7rvUqVKKXv27Fq+fLn69u2rmJgYrV271vAk0tM872Lf3r17VaNGDUNCwJMeVVVI6kLsiBEjFBYWZihB/uT5h4eH69ChQ+rTp4/h9yMlXKh0cnLS8ePHDUkBc+fOfeo5AO8DS0urp94Uj4yKTHJqgH9r3KSZAvz9NWf2LK1ds0qSVKiQmz5r204zpk9V6tQJNw5iYmLU4fPPVLxESfXrP9CwvVdpbzWoW0dzZs9Sr68SKghs2rhB3w4ZpLUbtihT5sySpKrVqisuLl7jx43WR7Vry94+naz+ic2zSFFDQoAkOWXJoiJFi+rokcOJ4nXOnUfOuRNuwnxcr746tm+r7l07aeHiZTxRCAB4be7fvy9Jypgxo1H7o+Xg4OBnbv/jjz9q2bJl6tq1q9zc3GRjY6Nt27ZpypQpioyM/E9JAenTpzdafhRTYGCgsmTJ8lLHfrLSUFxcnDp37qzQ0FD16NFDOXPmlLW1tX766SfdunUrUSw2NjaGny0sEuaitbW1Nepjbm6uqKgow/K4ceM0btw4jR8/XkOHDpWzs7O+/PJLVa9e/RVHBAAA4M0Kj4xW2tSWWrr5oFH70s0HVaNMIXkUyKbdhy681D4b1SimSQOaqXD9YbpxO1iStGb7UZmlMNPwnvW0dPNB3b3/UBGRCdd8LC0SX063sjBXeMSzH5S4eO2O1u88pnqVPWRmlkJxcfFP7Tth/ja1+7SMKnm5JEoK+PtygP6+nFBN8pf1f2nd5K5aMaGjyvmMTmJPAAAAjz39bvI7ztfXV+vXr1fbtm01a9YsLV++XJ9++qnRha7g4GA5Ojo+dR+PLiI+q8/LePJipST99ttv6tu3rwoXLqzx48dr6dKlhqoEkZGRLxxHihQp1KhRI61du1YxMTHasWOH7t69qwYNGjwzpnHjxqlUqVIaP368qlevrpo1a+rXX381rH/eGN2/f1/m5uZGyRaPzjU+Pl6hoaFPPf+QkBDFxsZqxIgRKlSokNGfmzdvJnlBE3hfOTg4KDY2VkFBQUbt0VFRuh8cLIcX+Jzp3rOXft+1Wz/PW6jlq9bql6UrFPfPU4E5c+aSJB08sF/nz/2tipUqG22bM2cu5c6dW0cOHzK0LV38iwoUKGhICHikYqXKiggP15nTpxNi/ye2DBkSf4alz5BBISGJS+M9qVq1Gjp54riuXL703L4AALyoR99Bn/z39c6dO0brn2bz5s1q0qSJOnToIG9vb7m7uytVqteTF3337t0kY3JwcHjpYz+ZUHflyhWdOnVKvr6+atSokUqWLCl3d3dFRDy78tDLcHR01IgRI7R3714tW7ZMzs7O6tWrl65du/bajgEAAPA63QpMSBgNCAo1ag+8m7Cczjb1S++zQ+NyOnr2miEh4JENO48pjbWlPApkkyT5ByZcG8mc0fbJXShzRltDbM9y3f+eLC3Mlcba8tn9Au5JktLbPT+BddXWIyrulkv5cr6e69sAAMB0vZdJAZGRkdqxY4c6d+4sHx8flS5dWu7u7oaSmo/Y29vr9jPm8X50EfFZfSwtE76kPfkEcFI3yZJ6Onbz5s0qWLCghg0bpgoVKsjDwyPRUzsvEockNWjQQMHBwdqxY4eWL18uLy8vZf/X/OFJed7FvueNkZ2dnaKjow1PaT1y584dpUiRwuippCfP38bGRilSpFCnTp20fPnyRH86d+78zNiB94lLgYKSpFMnTxi1nzx5QnFxcXIpUOCF9mNrZ6eixYorX34XSdLeP/coU+bMcs6dW5J095+bInH/qr7xSExMjFFVjqCgO4qNi0uiX8LnWWxMQsm7fPnzK1Uqc92+HZCob+Dt20bTETzNo+kRQkMfPLcvAAAvyt3dXebm5tq8ebNR+6ZNm5QhQwZDqfwnn4J/JDIy0mh6n9jYWG3YsOG1xPbbb78ZLW/ZskWOjo7K/E8y3n859qPk4X9vf+PGDR0+nLh6z39lZmamwoUL64svvlBMTIyuXLny2o8BAADwOhw+fVWSlMXRzqjdySFh+c69l78m4ZjeRimTqMJqniphmtNUKRPWnbxwU9HRsSrqmiNRv8Iu2XTs7+vPPZZztowKj4h67hQHzln/qUD1Audj/c+0BnZprZ/bFwAAfNjey6SAqKgoxcXFGV0ke/DggbZv327Uz9vbWxcuXNDRo0eT3E/u3LmVOXNmrVy58qnHypQpk6SEqQYeuXDhwgs/5R4RkXie8XXr1hktFylSRNbW1lqxYsUz9+Xg4KCKFStq5syZ+t///qdPP/30hWKQnn6xr3Tp0tqyZYsePEj6S2axYsUkKdGF2M2bN8vV1dUwdUBSUqdOLU9PT128eFHu7u6J/mTLlu2F4wfedSW9SsnOzl5LFy8yal+6ZJGsrK1VvnxFQ9u9e3d16eIFhYeHP3Ofmzdt1MkTx9XCp7VhmpCc/9z82Lxpo1Hf06dO6vLlSypQsKChLWdOZ505fUqXn3h6f9PGDTIzM1M+l4TEgzRp0qpc+fI6euSwLl18XGbv4oULOnrksEqX9ja0PfmkppSQNLVu7RpZWVk9c15nAABeVvr06dWyZUvNmjVLEydO1B9//KHvvvtO69evV5cuXZQyZcLF2jx58igmJkZz587VsWPHDN/dvb29tWzZMq1atcqQVJxU8sCr2Lt3r3744Qf98ccf+uGHH7RmzRp16tTJ8G/2fzn2o/+njBkzRr///rs2bNigtm3bvrYKZ6GhoWrcuLEWLlyoPXv2aOfOnfrxxx9la2srV1dXSQlJCK6urpo4ceJrOSYAAMB/tXxLQnXENvUfX6dIkSKFWtUtpaDghzp06uUrHp27clseBbIpbw7j71mNaxZXbGycTpy7KUkKeRCh7X+dUbPaJZU29eMn/ZvXKSmbNFZa+dvj5M2M6RJP0+qeP6tqV3DX1r1nDA+22aSxkoV54kpSvu0TpnHduueUoc0hiX2mSmWm5nVKKiw8SqcvUpEVAAA82+upnfmW2djYyN3dXTNmzFD69OmVKlUqTZ8+XWnTpjUq41mvXj398ssv6tChg7p166Z8+fIpICBABw4c0LfffqsUKVKob9+++vLLL9W9e3fVq1dPFhYWOnLkiNzd3VWpUiV5eHjIyclJ33//vb766is9ePBA06dPf26p0ke8vb01bNgwTZo0SUWKFNHOnTv1559/Jjqfrl27avTo0YqPj1eVKlUUFxenffv2qXbt2nJ3dzf0bdy4sTp06CBbW1vVqFHjmccODQ1Vu3btVK9ePTk7Oys6Olrz5883utjXrVs37dixQ82bN9fnn38uBwcHXbiQcLOyffv2KlCggKpXr66RI0cqIiJCzs7OWrt2rQ4fPqzJkyc/9/z79Omj1q1b64svvlDt2rVla2srf39/7dmzRw0aNJCXl5ckqXXr1rp582aiJ66A94WVlZW6du+h74cP09e9esi7TDkdOnhAG9atVfeevWT3r8+Mxb8s1NTJEzXz53kqUTLhPXDwwH5NmzJJpb3LyM7eXsePHtWa1StVpmw5tWjZyrCtayE3lfIuo7VrVunBwwcq7V1GdwIDtWjhAllaWqmlT2tD3zZt22n3H7v0WasWatqshezt7bVr5w798b9davBpIzk6ZjL07d7zS+3b+6fat22tZi0Sjrdo4TzZ2tmpXYdOhn7fDh2khw8eqFjxEnJ0zKQ7dwK1ccM6Xbp4UV/19lXq/zA3MwAASenTp49sbGy0fPlyTZ06VVmzZtXQoUPVtGlTQ59KlSqpefPmmj59uoKCglSiRAnNnz9fAwcO1ODBg/Xtt9/K2tpan3zyiapVq6YBAwb857iGDRumJUuWaNGiRUqTJo169uypFi1aGNb/l2NbWFjIz89Pw4YNU8+ePeXk5KTOnTtr7969OnHixHO3fx5LS0vlz59f8+fP161bt2RlZSU3NzfNmjVL6dMnVAiKj49XbGxsompsAAAAr1ut8m5yz59VkmSeykxu+bKq7+cJ1z037DxuuDG/bscxbd93Rr3bVlMG+zQ6/vcNfVypsMoUzauu3y5SVHSMYZ9liuZR2aJ5JSXcpE9jbWHY5x+Hzmv3oYSHIsbN26oaZVy1dfYXmrpkl+4GP9RH5d1Us2whzV6522hagCET1+n3OV/p15lfaPbK3crqaK+ePpX1257T+m3PaUO/+SM/U3hktPYevaTAu6EqmDuz2n5aRmERURr40xpDP88C2TV3RBst23JQF64GytrKXHUreci7SB7NXP6Hjpx5XH1g4oBmskljpT8OndfNwGBlymCrph+VUIHcmdV3zEo9DH89ia8AAMB0pYh/T6/yXLlyRYMGDdLRo0dlb28vHx8fhYWFafbs2UZlNe/fv69x48Zp69atCg4OVubMmVW7dm316tXL0Gf79u2aOnWqzpw5I0tLS7m6usrX11cF/3ni9sSJExoyZIjOnTunHDly6JtvvtHIkSNVsGBBjRw5UpLk6+urEydOaP369UZxxsbGavTo0Vq9erUiIyNVtmxZtWvXTo0bN9aECRNUs2ZNQ98VK1Zozpw5unTpktKkSaMiRYpo0KBBypIli9H+ihUrpvr162vIkCHPHKOoqCgNGzZMBw4cMLrY17NnTxUuXNjQ7/z58xozZoz++usvxcbGKleuXOrQoYNq1aolKaHawdixY7Vx40YFBwcrd+7c6tatm6pXr27Yx9POX5KOHz8uPz8/HTp0SNHR0cqcObNKlSqlzp07G8qr+vj46MaNG4mqPfxXETHP7wO8TiuWLdW8ubN14/p1Zc7spKbNW6iFT2uj6TWmTPJLlBRw7epVffftUJ05fVIPHz5U1mzZ9HHdT9SqdRuZW1gYHSMiIkJzf56lzZs26uaN6zI3N1eRosXVtXtPo0oBknT82DFNneynM6dPKzg4WFmzZVXdep+oTdvPE81rfPrUSY0fO1pHjxyRmVkKlfQqpV5f91HOnLkMfTZt3KDVK5fr3N9/6/79YKVOnUauhQqpWfOWqli5ymseTeAxq/cyjRGAKdq3b59atWql5cuXGyXv4sVYF+mW3CEAAIB3zPShLeVTt1SS69oPmq8F6/YZltNYW2hI14/1afWiSm+XWn9fvq2xc37T4k0HjLbr37GWBnSqleQ+h0/dqO+mPa7AWLxQTvXvVEseLtmUwT6NLt8I0oJ1+zR27lbFxhpPy+jtmVvDe9aTZ4HsCg2L1MpfD2mg31qjKQG6NKugph+VUO7sDrJNY6U7wQ/0+76z+m76Rl28dsfQL2eWDPquZz0VK5RDmTLYKi4+XmcuBejnlbs1a8Vuo+M2qlFMreuXVqG8WZTBLo1CwyJ0+PQ1TVm8Uxt2Hn/OCAMAAFMXfvj5lR7f26SAD9Wff/6pNm3aaMWKFXJzc0vucN55JAUAgGkgKQDAu4KkgP+GpAAAAAAAAIDX60WSArjE/p4ICAjQ1atX9eOPP6po0aIkBAAAAACv2aOS+U9jZmb2FqMBAAAAAAAAXg+SAt4TS5cu1eTJk1WwYEENHz48ucMBAAAATM6qVavUr1+/p67v1q2bunfvrrNnz77FqAAAAAAAAID/hukDYNKYPgAATAPTBwB4G+7du6fr168/db2jo6MyZcr0FiMyPUwfAAAAAAAA8HoxfQAAAAAAvKB06dIpXbp0yR0GAAAAAAAA8FoxKSYAAAAAAAAAAAAAACaKpAAAAAAAAAAAAAAAAEwUSQEAAAAAAAAAAAAAAJgokgIAAAAAAAAAAAAAADBRJAUAAAAAAAAAAAAAAGCiSAoAAAAAAAAAAAAAAMBEkRQAAAAAAAAAAAAAAICJIikAAAAAAAAAAAAAAAATlepVNtq2bZsWLlyoEydOKCwsTI6Ojipbtqw+++wzOTs7v/B+fH19deLECa1fv/5Vwnjtrl+/ripVqmjChAn/b+++47Iq/z+OvwBZCjLcipoDcSHDPck9cmduTPPrXuE2NUMtzZWKqEjONFPLkWmWI0eZmokjd5YZTkRAHCBw8/uDH7fess2y8P18PHzEfZ3rXOdzjuHjus/5nM9Fs2bNjO3Hjh2jd+/eeHt7s3DhQqytrV9glCLyb7bxiw2sWrGMq6GhFCxYiC7dfenazTdT+545/QsB8z7ixPEQEhMTqeTphd/wUZQtV86kn8Fg4PMN6/h83WdcuXIF25y2lCtXnr79B+Lp5Z3m+MFBi1gwfy6lSruycYvpv7u9e/py9KcjKfapVbsOi5YsfaY4RUTk383NzS3DPtOmTaN9+/bPNL6vry85c+YkKCjomfZPT0BAAMuWLSMkJOSFxSAiIiIiz0efN+rwatUyVK34CkULOfPJl4foO2l1mv3rV3dj9FtN8CpXDHNzMy7+cYuPVu7i82+PGft0aOJNi3oVqer+CqWL5Wf/0Ys07TMv1fFKFcvHpIEtqeVZEqfcufjzxh3W7TjK3FW7eRgTZ9K3hkcJ3h/WFs+yRbl7P4aNO4/xbsCX3H/4yNinbmVXvv14WKrH8ukxiyOnLhs/fxM8jHpVXFP0+/aHM7QZvND4uVzJgkzo3wKvcsUokCc3D2Iece73G3y0chfb9/+S5rUSERERSZblpIBZs2YRHBxM06ZNmTJlCs7Ozly5coUvvvgCPz8/Nm/e/DeE+eKcOHGCPn364OHhQWBgoBICRCRNG9Z/xlT/STRq3BTfHr04duwoH34wlZiHD3nrf33T3ffsmdP09O1KgYKF6DdwMIkGA+s++5TePbuz5rMNvFKipLHvnFkz+GTlcl5r1ZqOnbsSHX2Xzzeso3dPX1Z8shb3SpVSjH/zxg0+Dg7C1jZnmjEUKFiQoW8PN2nLly//M8cpIiL/buvWrTP53KlTJ3x9fWnZsqWxrVixYs88/qRJkzA3V2EyEREREUnfiJ6Nsctpw9HTlymY1yHdvr6ta7B4Uld2HzrPpAVbSTAYKFM8Py4FnEz69XmjLl7livLz6T9wdsiV5nguBRw58Mko7t57yOJ1+7kT9YDqlUrw7oCWeJUrRke/Jca+lcoUYfviIZz7/SZj5mykSH5H3u7RkFLF8tF28KIUYwd++h1HT18xabv0Z1iKfqE3IpgY8KVJ2/WwKJPPxQo7Y5fThtVbD3M9LIqcNla0beTJF/P6M2jKWpZt/CHtiyYiIiJCFpMC9u3bR3BwMAMHDmTYsMfZjlWrVuX111/nu+++e+4BvkinTp2id+/eVKhQgcWLF2NjY/OiQ/pPiYmJ0TWTl0ZMTAwL5n1EXZ9XmT13PgCvv9ERg8HAksWL6PBGJ3I7pP3FNjBgHtbWNnzy6Wc4OiZ9kX2tVWtat2jK/LkfMWdeAADx8fFsWLeWxk2a8sH0mcb9GzdtxmtNG7F925epJgXMnvUhlSp5YDAYiIiISDUGOzt7WrZqk+55ZjZOERH59/P09EzRVqhQoVTbk2Vlfle6dOlnjOzlpjm0iIiIvGya/G8uV64n3asI+2F2mv2KFXJm7tiOLPpsHyNnfpHumL0nrOTqrSgSExM5uuGdNPt1ea0aTrlz0rDXHM7+dgOAZRt/wNzcjO6tquNob0tk9EMA/Ie0JjL6IU37zCP6fgwAf1wPZ9G73WhYoyy7D50zGfuHkEts2nU8w/OPuveQz7b/lG6fb74/wzffnzFpW7RuHwc/HcPQ7vWVFCAiIiIZytKrO8uWLSNv3rwMHDgw1e3169c3/hwbG8u0adOoU6cO7u7utGnThp07d6a63+HDh2nbti2enp506NCBX34xLXmUmJjI0qVLadq0KRUrVqRhw4asWLHCpE9AQABeXl6cP3+eLl264OHhQcuWLTlw4EBWTtHozJkz9O7dm7JlyxIUFGRyY+7SpUv4+fnh4+ODh4cHLVq0YNmyZRgMBmOf0NBQ3Nzc2LRpE++88w6VK1emWrVqTJs2jfj4eGO/jRs34ubmxvHjx+nRowceHh40aNCAzz//3CSekJAQ+vfvT506dfD09KRNmzaZqspw9+5dJkyYQN26dXF3d8fHxwc/Pz+TPjdv3mT06NHUqlWLSpUq0axZM1auXGncbjAYWLhwIQ0aNKBixYo0a9aMzz77zGSM5Ot/8uRJOnXqhLu7O2vWrDFerwEDBlC5cmU8PT3p27cvV66YZsmK/Nf9dOQwkZGRdOrc1aS9c5duPHz4gP3796a7/7Gfj1KjZk3jg3ZIeku/ctVq7N/3HQ/u3weSkgJiYmJwzpPXZH9n5zyYm5tjbZ3yIcLPR39i17ffMHps2l+Ck8XHxxuP9VfiFBGR/7705nezZs2iVatWeHl5UbduXYYPH86tW7dM9vf19aVfv34pxstovr5582a6dOlCtWrVqFq1Kr6+vpw8eTLVGE+ePEmHDh1wd3enefPmmUpS/qtz0+c5fz98+DBubm7s3buXoUOH4u3tbUy+zsx1SL6mZ86coVOnTlSqVIl27dpx5swZYmNjmTRpElWrVqVevXopvj9dvHiRPn36UL16dTw8PGjatCnBwcGZvg4iIiIiz0tyQkBG+rxRBwsLMyYv2gZALlurNPuG3owkMTExwzFz2yXdR7l1J9qk/cbtKBISDDyKSwDAPpcNDauXZe22I8aEAIA1W5M+v94k9eUc7XJaY2GR8S14CwvzdM8nNQZDIqE3InCwT7sqpIiIiEiyTFcKiI+P59ixYzRp0gRLS8sM+48cOZIDBw7w9ttvU7JkSbZs2cKQIUMIDAykYcOGxn5hYWFMnTqVvn37Ym9vz+zZsxk8eDA7d+40Huf9999nw4YN9O/fHw8PD44dO8asWbOwtramS5cuxrHi4uIYOXIkPXr0YODAgQQHBzN06FD27NmDk5NTihjTcv78eSZNmkTp0qUJCgrC1tbWZPutW7coUaIErVq1IleuXJw9e5aAgAAePHjA4MGDTfrOmTOHOnXqMHfuXM6cOcP8+fOxtLRk5MiRJv2GDx9Op06d6NOnD9u3b2f8+PHkz5+fevXqAXDt2jW8vb3p0qULVlZWHDt2jAkTJpCYmEi7du3SPJdp06Zx4MABRowYQZEiRQgLC2P//v3G7REREXTq1AkAPz8/XFxc+OOPP0xujM6YMYNVq1YxYMAAvLy82Lt3L5MmTSI+Pp7u3bubXP8RI0bQs2dP/Pz8cHR05M8//6Rz5864uroyffp0zMzMWLx4MT179mTHjh1YWSVNdseOHcumTZs4f/58pv+eRP5Nzp1NytYuX6GiSXv58hUwNzfn3Nmz6b6F/+jRo1Qf6Nva2BAXF8evv16kkocnNjY2uFfy4MvNm/Dw9MTbuwrR0XdZsnghuXPnpsMbnUz2T0hIYPr7U2j3egdcy6S/dvQfly9To4oncXFx5MmTl/Yd3qDfgEEm/+ZnNk4REckeUpvfAYSHh9OvXz/y58/PnTt3WL58Ob6+vmzbto0cOdL+ipGZ+XpoaCht27alWLFiPHr0iG3bttGtWze+/PJLSpQoYTKWn58fb731Fi4uLqxdu5bBgwcbH9qnJrNz08x4nvP3iRMn0rp1awIDA41LLmTlOowZM4aePXuSN29eZs2axeDBg/H29iZPnjzMnTuX3bt3M23aNCpVqoS3d9IN6/79+5M3b17ef/997OzsuHLlCjdu3DCOe/jwYXr06MG0adNo3759pq+LiIiIyN+lfvWynL98k2Z1KvDB220pUsCJO1H3CVq/nymLtmcqCeBp+49eZGSvJiya1I2pi7ZxJ+o+NTxK0qdDXRau3cuDmEcAVCxdGEtLC46dMU0mjYtP4OT5UDzcXFKMHfRed+xz2RAfn8APIZd4Z+7mFPsDuBbPT/jB2VhbWXLj9l2Wb/qBD5Z8TXy8IUXfnDZW2NpYktvOlpY+7jStXZ7Pvz2W5fMWERGRl0+mkwIiIyN59OgRhQsXzrDvuXPn+Pbbb/H396dz584A1KtXj6tXr6ZICoiKimL16tW4uroCYGtrS48ePThx4gRVqlThypUrrF69Gn9/f+PD61q1ahETE0NgYCCdOnUy3jhLvsno4+MDQIkSJWjYsCH79++nTZv0S2I/aeHChTg6OrJkyRJy5Uq55lTNmjWpWbMmkFTFoHLlysTExLB69eoUSQHFihVj2rRpANStW5eYmBiWL19Onz59cHiilHibNm2Mb1LVrVuXP//8k8DAQONNxddee83YNzExkapVq3Lz5k3WrVuXblLAqVOnaNmypUmfJ8dasWIF4eHhfP3117i4uBjPL9mdO3dYvXo1vXv3ZsiQIQDUqVOHiIgIAgMD6dKlCxYWFsDjG7MtWrQw7j9mzBgcHBxYvnw51tbWAHh7e9OwYUM2bNhAt27dADA3NzeOI/JfFBYWhoWFBXny5DFpt7SywsHRkbCn3p582islSnDy5HESEhIe/049esSp/38j8NbNm8a+H0yfyeiRfrwzZpSxzaVoUVauXotL0aIm425Y9xnXr18jaOmKdI/vUrQoVatVp7RrGR4+fMCub78hOGgRf/xxmZmz5z5TnCIi8t+X2vwOMM5vISkBzcvLi3r16nHo0CHq1KmT7ngZzdefnE8bDAZq167NyZMn2bRpE8OHDzcZa8CAAXTo0AFImqM2adKEoKAg5syZk+rxFyxYkKm5aWY8z/l7gwYNGDVqlElbVq7Dk9fUYDAYk6nHjRsHQI0aNdixYwc7duzA29ubO3fuEBoayvjx42nQoIGxz5PMzMywsLAwftcSERERedFKF81HgsFA0HvdmbNyF6cuXKVNAw/G9WlODgsL3g34Mstj7jx4lvcCtzL6raa0evXxcozTg3fgv/Ar4+eC+XIDcOP23RRj3Lh9l1pepYyf4+Lj2bQrhB3fnyY88j7lShZkmG9Ddi19m/o953DifKix72+hYez76QKnf71GTlsr2jXyYlyf5rgWy4/v2OUpjjV9RHv6dEiabyckGNiy5zh+09dn+bxFRETk5ZPppIBkZmZmGfb5+eefAWjWrJlJe/PmzZk2bRoPHjwgZ86kskb58+c3JgTA47VHb/7/g6WDBw8C0KRJE5Oy+7Vq1SI4OJjr169TpEgRIOnB8pMPtF1cXLCxsTGOlVl16tTh+++/Z968eYwfPz7F9tjYWIKCgti6dSvXr18nLi7OuO3+/fsmiQSNGzc22bdp06YsXLiQCxcuULVq1TT7NWnShBkzZhgfvEVFRREQEMDu3bu5efMmCQlJpauS39ZKS/ny5dm0aRP58uWjbt26lClTxmT7jz/+SI0aNYwJAU87efIkcXFxqf5dfvXVV1y+fJlSpR5PepNvRib74YcfaNGiBRYWFsa/v9y5c1O+fHmTZSI++OADPvjgg3TPReTfLDY2Js0qKtZW1sTGxqS6LVnHzl15f/J7vDdxPD3f+h+GRAPBQYsICwsDIOaJ/XPlykWp0qWp5OFJ9Ro1Cb8dxrKPg3l76CCWr1qDk5MzAJGRESxcMJ8+/Qfi7Oyc7vH9p5j+/rVq3ZbJkybyxefr8e3R0/j2f1biFBGR7OHp+R3Avn37WLRoERcvXuTevXvG9suXL6ebFJCZ+fqlS5eYM2cOISEhhIeHm4z9tCfn0BYWFjRq1Ihdu3alefzMzk0z43nO31999dUUbZm9Dk9f01deeQVI+r6UzMLCgmLFihkrATg5OVGkSBHmzJlDVFQUNWvWpGDBgibjVqtWjTNnTNetFREREXmRkkvxT5i3mdkrkuZ8m3cfx8khJ4O6vMqMpd9w70Fslsf949odvj/2K5t3H+dO1H2a1a3A6N5NuBl+l8Xrkiqu2lgn3fOJfRSfYv+YR3HY2jy+J3ToxO8cOrHU+HnbvlNs3BXCT+veYfKQ1rQZvNC4bYD/pyZjrd32EwsmdKH367UJWPMdR05dNtm+YM13bNoVQqF8Drze2BsLc3OsLLN8i19EREReQpmeMTg6OmJtbc21a9cy7BsVFYWlpWWKG1558+YlMTGR6OhoY1JA7ty5TfokP1SLjU2awEVERJCYmJjizZVkTyYF2NjYpCj5aWlpaRwrs9544w28vLwICAjA0dGRQYMGmWyfOXMmGzZsYNCgQVSsWBF7e3t2797NokWLiI2NNUkKePpBXN68SeuAJz9AS/b028V58+YlLi6OiIgI8ubNy9ixYwkJCWHQoEGULl0aOzs71q5dy9dff53uuUycONH4NtSMGTMoVKgQffv2pWvXpHXPIyMjTZIynhYVFWUS99PnERkZaWyztbVNUVkhIiKClStXsnLlyhRjZ2YZCpH/CmtrG5MEoSfFPopNteT+kzp26sLNGzdYsWwpX27ZBECFChXp9VZvgpcsJmfOpN+t+Ph4+v6vF1WqVmPc+InG/avXrEX71i1ZsWwpfiOS3jRcMH8uDg4OdO3aPeUBM6FHz1588fl6Dv148HFSQCbjFBGR7CG1+d3JkycZOHAgDRs2pE+fPuTJkwczMzM6duyY4bw7o/n6vXv3eOutt3B2dmbs2LEULlwYa2trJkyYkGJsS0tLk8pbkDSnfnqe/aTnOTd9nvP3p8fKynV4+pomn4e9vX2K80ve18zMjKVLl/LRRx8xefJkHjx4QIUKFRg3bpxJ4rKIiIjIv8nD2DjsclqzfsfPJu3rd/xM09oV8Cjrwg/HLmVpzDeaViZwQhcqtZ3M1VuRAGzZcwJzM3OmDmvD+h0/cyfqPjGxSfd8rK1S3k63sbLkYUzq94SS/fbnbb7ad5I2DTwwNzfDYEh7qYN5n+ym9+u1qV/dLUVSwIXLN7lwOSmh9tOvjrB14SC+mNePur6zsnDWIiIi8jLKdFJAjhw58Pb25tChQ8THx6e7VqiDgwNxcXFERUWZ3Ki7ffs2ZmZmKW5QpcfBwQEzMzM+/fTTVG/UPbme5vM0ePBgIiMjmT9/Ps7OznTp0sW4bceOHXTq1Im+ffsa2/bt25fqOHfu3DH5fPv2bQDy5ctn0h4eHk6BAgVM+llaWuLk5ERsbCx79+5l7Nix+Pr6Gvt8+qlpJmlq7O3tGT9+POPHj+f8+fOsWrUKf39/ypQpQ5UqVXB0dORWOmXNn1w39un4ntwOqVeRcHBwwMfHx5iE8KTUlmYQ+a/Kly8fCQkJhIeHm9zYj3v0iKjISPLlz5/hGEOG+fFmz7f49deL2Nvb41rGjflzk8ofFy/+CgA/H/2JXy9eYOTosSb7Fi/+CiVLluR4SNI6cn/8cZkvNqxn1Nh3uBX2+Hc8NjaW+Pg4rl4NxS6XHQ7pVBspULAQ8Dg5KCtxiohI9pDa/G7Xrl3Y2dkxd+5cY2n5q1evPpfjHT9+nBs3bhAUFETZsmWN7dHR0SneZE/t+0Z4eHiKefaTnufc9HnO35++zlm5Ds+qRIkSzJ8/n7i4OEJCQpgzZw79+/dn//79mqeLiIjIv9L1sChci+fnZni0SXvYnaTPTrlzZnnMvh3rcuL8n8aEgGTb9p2kR5saeJR14bvD57kRlrRsQMG8uVOMUTBvbq6HRaVof1rojQisrSzJZWtN9P20Ky2G3owAwNkh4znZpl3HCZzYBdfi+bn4R/pLV4qIiMjLLUsLRPbq1YuwsDAWL16c6vbkB+OVK1cGkh6eP2nHjh2UL1/eWCUgM5JLYUZGRuLu7p7ij52dXVZOIUvGjx9Pq1atmDx5Mtu3bze2x8bGmiQoJCQksG3btlTH2Llzp8nnb775Bltb2xRl/J/u9+2331KhQgUsLCx49OgRBoPB5Jj37t1jz549WTofNzc347qily4lZc3WrFmTQ4cOpVkBwt3dHUtLyxR/l19//TV58uQxlidNS82aNbl48SLly5dP8XdXsmTJLMUv8m/mVrYcAGdOm5YePn36FwwGA25P3NBPT24HB7wrV8G1jBsAh348SIGCBSnx/78vd/6/fLDh/0sQPyk+Pt5YmvjWzZsYDAY+/GAqLZo0NP45dfIEf1y+TIsmDQlaFJhuLKGhfwIpK55kJk4REcm+YmKSlsx58kH21q1bn9vYYPrW/rFjx9JMOnhyDp2QkMCuXbvw8PBIc/znOTf9O+fvWb0Of4WlpSXVqlWjb9++3Lt3L92EYREREZEXKeTsFQAK5zetFlUoX9Ln2xH3UuyTkfzO9liYp7xFbpnDAoAcFknbTl+6RlxcAt7li6XoV8nNhZMXQjM8VgmXvDyMeZThEgclivx/pdlMnI/t/y9r4GBnm2FfERERebllacEhHx8f/ve//xEQEMCvv/7Ka6+9hpOTE6GhoXzxxRdER0fj4+ND2bJladKkCdOnTycmJoYSJUrw5ZdfEhISwsKFCzM+0BNKlChBt27dGD16NL1798bDw4O4uDguX77M4cOHszxeVpiZmTF9+nTu3r3L6NGjyZ07N3Xq1KFWrVps2LCB0qVL4+TkxKeffsqjR49SHePKlSuMGzeOFi1acObMGZYsWcKbb76ZotTpli1bsLGxoXz58mzfvp2ffvqJJUuWAElv+7u7uxMcHIyzszM5cuRgyZIl2NnZpahE8LTOnTvTuHFjXF1dsbCwYPPmzVhaWlKlShUAevbsyZYtW+jevTsDBgygaNGi/Pnnn1y+fJlRo0bh7OxM9+7dWbp0KVZWVnh6erJv3z6++uorJk6ciIWFRbrHHzp0KB06dKB379507NiRvHnzcvv2bY4cOUKVKlVo2bIlAO+88w6bN2/WuqXyn1Wteg0cHBxZ/9la6tZ7vPby+nVrsbG1pV69V41tERF3iIyIoGChwtjapv2lbcfX2zn9yymGjxpjfBOz+P8n4uz4eju169Yz9j175jSXL//O6290BKC0qysfzU/50H/B/Lk8uH+f0ePGU7RoUSDpIYWVlZVJ6eHExESCgxYBUKt22mtDpxWniIhkX7Vr12blypVMmTKFxo0bExISwpYtW57L2J6enuTMmRN/f3/69u3LzZs3CQgIMHkjP5mlpaVx+S4XFxfWrl3LjRs3CAxMO+kts3PTzPi75u9ZvQ7P4ty5c3z44Ye0aNGCokWLcu/ePYKCgihSpAjFiiXd6D5y5Ag9e/bkgw8+oG3bts/luCIiIiJ/xeffHKNjsyr0bFuL9wKTklLNzMzo0boG4ZH3OXbmzyyPefGPWzSqWZbSxfLz65XHyZEdm1UhIcHALxeTXqS6ey+GPUfO0eW1akwL3mF8sN+1ZTXsc9mwcWeIcd+8TnYpEhTcyxThNR93vvnhDImJSUsH2OeyIfZRPI/i4k36ju3TDIBdBx/fJ83nZJciSSBHDnO6tqzGg4ePOPvb9Syfu4iIiLxcspQUADBq1Ci8vLxYs2YN77zzDg8fPiR//vzUqVOH3r17G/vNnDmTOXPmEBwcTGRkJCVLlmT+/Pk0aNAgy0FOmDCBEiVKsG7dOgIDA8mVKxclSpSgWbNmWR4rq3LkyMH8+fPp1asXQ4YMYfny5UycOJFJkyYxZcoUbG1tadeuHY0bN2bChAkp9vfz8+PIkSMMGzYMCwsLunbtip+fX4p+s2fPZs6cOQQGBpInTx6mTJmCj4+PyfZ3332XsWPH4ujoiK+vLw8ePGDZsmXpxu/t7c3mzZsJDQ3F3NycMmXKsHjxYkqVKgWAk5MTa9euZfbs2cyaNYuHDx9SpEgRk5Kqo0ePxt7ens8//5zFixdTpEgR/P396dy5c4bXr3jx4mzYsIG5c+fi7+/PgwcPyJcvH1WrVsXNzc3Yz2AwGN9wFvkvsrGxYdCQoXwwdTIj/YZSq3Zdjv18lG1bv2TIMD+TMv2ffbqGxQsX8PHyVVStVh1IWhYgaFEgNWvVxsHRkVMnTrBl80Zq16lLt+49jPuWr1CRGrVq8+WWTdy7f4+atWpzOyyMtWtWY21tQ3ffNwFwcnKmQcNGKeJc80nSGspPbjt75jRjR42gWYvXKFasGDGxsezZtZPjIcd4/Y1OlCtfwdg3s3GKiEj25ePjw8iRI1m9ejUbN27E29uboKAgmjZt+pfHzps3L/PmzWPGjBkMHDiQV155BX9/fz7++OMUfS0tLZkzZw7+/v5cuHABFxcX5s+fb1Ju/2mZnZtmxt81f8/qdXgW+fLlI2/evAQFBXHz5k3s7e2pUqUKM2fONCb9JiYmkpCQgMFgeC7HFBEREUlLi3oVcS9TBADLHOZUdC3CmP8lzS237TtlfDC/de9J9hw+x6i3GpPHMRenLlylVf1K1PYuzaApa00ertf2LkUd79JA0kP6XLZWxjG/P/YrPxxLqqL60apdNK1dnl3L3mbxuv3cibxP83oVaVanAss2/mCyLMB7C7by3YoRfPvx2yzb+ANF8jsyzLcBOw+eZefBs8Z+n0zvxcPYOA6d+J2wO9GUK1mQt16vzYOYR0yc/ziZ1rNsUVZO68mGb37m0pUwbG0saV3fg1pepfj48+85fu5x9YEFE7pgn8uG74/9yrWwSArkyU3n5lUpW7IgY2Zv5P7D1F9YExEREUlmlpicmijPVWhoKA0bNmTevHnpJi9s3LiRcePG8eOPP6Zaolv+mpj4jPuIPE9fbFjPqpXLuBoaSsGChejctRvdfN80KbG8KDAgRVLAn1eu8P4Uf86dPc39+/cp4uJCq9bt6PFmTyyfeIMfkkoKr1y+lB1fb+fa1VAsLS3x8q7CoCHDKFuuXLrx9e7pS0REBBu3fGVsCw39k3lzZvHLL6cIv30bM3NzSpYsSfsOHenwRieT2LMSp8jzZJPlNEYRkb+H5u9/ja3X4BcdgoiIiPzLLPHvjm/rGqlu6/PuJ6zeetj4OZetFe8NasXrTbxxdsjJhcu3mLNiJ599fdRkv/H9WjChf4tUx5y6eDvvBz1eKrZKheKM798CDzcX8jjm4vLVcFZvPcyclbtISDBNkKzlWZKpw9rgWbYo0Q9i2fjtMSYGfGmyJMDALj50bl6VkkXzkTuXDbcj7/Hd4fO8v2Q7v/1529iveOE8vD+sDZUrFKNAntwYEhM59/tNlm/8gaVf/GBy3DeaVubNtjWpULoweRxyEf0ghpCzf7Los31s23cqgyssIiIi2d3DkAUZ9lFSwN9ESQH/DkoKEBHJHpQUICL/Fpq//zVKChAREREREREReb4ykxTw0txiTy5/mRZzc3OthS0iIiIi8hIzGAzplstPLq0vIiIiIiIiIiLyX/LSVApIfqMnLYMHD2bIkCH/YETyT1ClABGR7EGVAkTknxAQEMCCBWlnVk+bNo327dv/gxFlP6oUICIiIiIiIiLyfGn5gCdEREQQGhqa5vb8+fNToECBfzAi+ScoKUBEJHtQUoCI/BNu3rzJrVu30tzu4uKCk5PTPxhR9qOkABERERERERGR50vLBzzByclJN/BERERERCRNBQoUUKKwiIiIiIiIiIhkO+YvOgARERERERERERERERERERH5eygpQEREREREREREREREREREJJsyS0xMTHzRQYj8XbRmqYhI9pCZNZFEROTfLyb+RUcgIiIiIiIiIpK92OTIuI8qBYiIiIiIiIiIiIiIiIiIiGRTSgoQERERERERERERERERERHJppQUICIiIiIiIiIiIiIiIiIikk0pKUBERERERERERERERERERCSbyvGiAxARya5cCjjSo01NmtetQKli+UlIMHDm0nWmf7yD7w6fN+lbMG9uBnV9laoVX8G7fDHsc9nQ5H/zOPDzxVTHruFRgveHtcWzbFHu3o9h485jvBvwJfcfPkrR17OsC+P7v0Ytz5LYWFny+9XbLNv4AwvX7ks3/tb1K/G/DnWp6FoYZ4ec3I64x5FTl5m6eDtnLl1/9gsjIiIiIiIiIvIvt/GLDaxasYyroaEULFiILt196drN90WHJSIiIvJMXppKAW5ubhn+2bhx4zOP7+vrS79+/bK8X4MGDZg8efIzHzcrfH19M7wGY8eOJSAgAC8vr38kJpHsrOWrlRjRszGX/ryNf+BXTA/egV1Oa7YvHoJv6xomfV2LF2BkryYUzu/I6V+vpTtupTJF2L54CLY2VoyZs5EVmw7yVvvarJnZO0XfhjXKsnflCPI72TE9eAcjZ37O1wd+oUh+xwzjr+BamMjoBwR++h3Dpq1nyYbv8XBz4cAno3AvUyRL10JERCAgIAA3Nze6deuWYtv7779PgwYNXkBUsGvXLtasWfPcx/0757ljx46lZcuWLzQGEREREcm+Nqz/DP93J1CqlCtj35lIJU9PPvxgKss+XvKiQxMRERF5Ji9NpYB169aZfO7UqRO+vr4mNxOLFSv2zONPmjQJc/Os51gsWLCA3LlzP/Nxs2LSpEncu3fP+Nnf3x8bGxvGjBljbHN2dsbKygofH59/JCaR7GzfTxco02Ii4ZH3jW3Bn3/P4c/G8u6A1/jky0PG9pCzVyjsM5qIuw9o18iTGh4l0xzXf0hrIqMf0rTPPKLvxwDwx/VwFr3bjYY1yrL70DkA7HPZ8PGUHuw4cJouo5aSmJiYpfinLdmRom3FpoP8umMqfd6oy9D3P8vSeCIikuTo0aMcPnyY6tWrv+hQgKSkgF9++SXVZIW/4p+c54qIiIiIPC8xMTEsmPcRdX1eZfbc+QC8/kZHDAYDSxYvosMbncjt4PCCoxQRERHJmpcmKcDT0zNFW6FChVJtTxYTE4ONjU2mxi9duvQzxVW+fPln2u9ZPB2jnZ0dOXPmTPUaFCxY8B+KSiT7OvvbjRRtj+Li+eaH0wzzbYhdTmvuPYgFMP43I/a5bGhYvSwBa/YYEwIA1mw9wowRr/N6E29jUkCn5lUomDc3kwK3kpiYSE4bKx7GxmU5OeBJt+5E8yDmEY72ts88hojIyyxnzpyULl2ahQsX/muSAjIrMTGRuLg4rKysMtX/n5znZidZ+Q4iIiIiIs/fT0cOExkZSafOXU3aO3fpxvavtrJ//15atmrzgqITEREReTYvzfIBGUkumX/y5Ek6deqEu7u7sYzqrFmzaNWqFV5eXtStW5fhw4dz69Ytk/2fXj4gebzz58/TpUsXPDw8aNmyJQcOHDDZ7+mSpsmlUA8fPkzbtm3x9PSkQ4cO/PLLLyb7RUdHM3LkSLy8vKhZsyZz5sxh2bJluLm5Pbdrkezw4cO4ublx4MABhg0bhpeXF6+++ipbt24FYNWqVbz66qtUq1aN8ePH8+iR6ZrmN27cYOTIkVSvXp1KlSrRrVu3FOcj8jIpkCc39x/G8iDmUcadn1KxdGEsLS04duaKSXtcfAInz4fi4eZibGtQ3Y2o6IcUzu/IiU0TCf9xDre+n8W8dzphbZX5nDAHO1vyOtlRoXRhFk3qioO9Ld8dPp/l2EVEJMnAgQM5dOgQx44dS7ff1atXGTp0KJUrV8bT05PevXtz/rzpv7/Jc8k1a9ZQv359KleuzMCBA7lz506mYhk7diybNm3i4sWLJstJJW9r2bIl+/bto3Xr1ri7u7Nnzx4ePHjA5MmTadq0KR4eHjRo0IB3332X6OjoVGN78liZmecuW7aM119/ncqVK1OzZk369evH77//nmr8+/bto2XLlri7u9O+fXuOHz+e4TmHhITQo0cPPD09qVy5MiNGjCA8PDxT1wtMvzd06NABd3d3mjdvznfffWfSb+/evfTq1YuaNWvi7e3NG2+8wf79+036bNy4ETc3N0JCQujVqxeenp7MmDEj09ch+ZoePHiQVq1aUalSJbp3705oaCiRkZEMGzYMb29vGjVqxPbt2032/fnnn+nWrRuVK1fGy8uLVq1asWnTpkxfBxEREZHs6tzZMwCUr1DRpL18+QqYm5tz7uzZFxGWiIiIyF+ipIAnxMXFMWLECFq3bk1wcDC1a9cGIDw8nH79+hEUFMT48eO5evUqvr6+xMfHZzjeyJEjad++PQsWLMDZ2ZmhQ4cSERGR7n5hYWFMnTqV3r17M3fuXGJjYxk8eDBxcXHGPuPGjWPv3r2MGjWK6dOnc+nSJVatWvXXL0I63nvvPVxdXVmwYAEeHh6MHj2amTNn8v333+Pv78/QoUPZsmULy5YtM+4TFRVF165dOXfuHBMnTiQgIABbW1vefPNNk5uvyWvshoaG/q3nIPKilSyalzYNPNi8+zgGQ9bf2C+YL6kM843bd1Nsu3H7LoXyPS5fV6pYPnLkMGfDR33Z9eNZOo8IZtWWH+n7Rl2W+HfP9DH3rRrBn3umc3TDO7ze2JtpwV+zYvOPWY5dRESS1K9fn/LlyxMYGJhmn3v37uHr68uZM2fw9/dn5syZRERE0L17d65fv27Sd8+ePezZs4d3332X8ePH89NPPzFlypRMxTJw4EB8fHwoWrQo69atY926dQwcONC4/datW0ydOpWePXsSHBxMuXLliImJISEhAT8/P4KDgxk2bBg//fSTyX5pycw898aNG3Tv3p2FCxcydepUDAYDnTt3JjIyMsVY/v7+xrGsrKzo3bt3ug/4Q0JC8PX1xd7eno8++ogpU6Zw6tSpTMX+pLi4OPz8/GjXrh0LFiygePHiDB482CRpIzQ0lPr16zNjxgwCAgLw9vamb9++HD58OMV4I0aMoEaNGixevJg2bdpk+TpMnz6dAQMGMGvWLK5cucLIkSPx8/OjTJkyBAQEUKFCBUaNGsXVq1eBpP+/+vXrh52dHXPmzGHhwoV07NiRu3cfzy+SExZSi1dEREQkOwsLC8PCwoI8efKYtFtaWeHg6EjYUy+LiYiIiPwXvDTLB2RG8s29Fi1amLRPmzbN+HNCQgJeXl7Uq1ePQ4cOUadOnXTHGzlyJD4+PgCUKFGChg0bsn//fuPNvtRERUWxevVqXF1dAbC1taVHjx6cOHGCKlWq8Ouvv7Jz504+/PBD2rZtC0DdunVp3rz5s556pjRr1ozBgwcDUKlSJXbu3Mm2bdvYuXMnlpaWABw5coQdO3bQv39/AFauXMndu3fZsGGDcSJds2ZNmjZtytKlSxk9ejQAZmZmWFhYYGZm9reeg8iLZGtjyZoZvXkYG8fE+V8+0xg21km/a7GPUiYlxTyKw9bG0vjZztaaXLbWLNlwgBEzPgdgy54TWFrmoE+HOkxetI1LV8IyPGa/99Zgn8uGEi556NG6BrbWVlhYmBEf/+zLEIiIvOwGDBjAkCFDOHnyJJUqVUqxfePGjVy7do1t27ZRqlQpAKpWrUr9+vVZuXKl8W1+SCrrv2jRImNZ/6tXrxIUFITBYMDcPP0c4GLFiuHs7My1a9dSXVIqKiqK4OBgPDw8TNr9/f2NP8fHx+Pi4kLXrl35/fffKVGiRJrHy2ieC/DOO+8Y+yckJFC7dm1q1qzJN998Q6dOnYzbIiMjmTt3LjVr1gSgWrVq+Pj4sGLFCkaMGJHq8WfPnk3FihVZsGCBcd5ZpkwZY0WE5Hl7RuLi4hgwYAAdOnQAoE6dOjRp0oSgoCDmzJkDQPfujxPwDAYD1atX59dff2X9+vUplo7o3Lkzffv2NWnL7HV4+preunWLKVOm0KdPHwYNGgSAu7s7O3fuZNeuXbz55pv8/vvvREdHM3z4cGOlseTrmMzc3FzzcxEREXkpxcbGGO91Ps3ayprY2JhUt4mIiIj8m6lSwFNSuxG4b98+OnfuTOXKlSlfvjz16tUD4PLly+mOZW5ubnJzzcXFBRsbG27evJnufvnz5zfe1AMoXbo0gHG/U6dOAdCwYUOTY9WvXz/dcf+q5MoJAPb29jg7O1OlShWTSfIrr7xi8vbaDz/8QPXq1XFwcCA+Pp74+HjMzc2pWrWq8TwABg8ezJkzZyhSpMjfeg4iL4q5uRmrpr9FuZIF6TpqKdfDop5pnJjYpDcpUyv/b2NlycOYx29aPvz/vut3HDXpt+7rnwCoXinthzZPOnzyd3b9eJbgDd/TamAgnVtUZcoQrZ0nIvJXNG7cmDJlyqRZLeDo0aO4uroaEwIAHB0dqVWrFj///LNJ36pVqxoTAgBKlSpFXFxclkrip8XR0TFFQgDA5s2badu2LV5eXlSoUIGuXZPWW81ofpzRPBfg+PHj9OrVi+rVq1O+fHk8PDx48OBBirHt7e1N5tr29vbUqlWLEydOpHrshw8fcuzYMZo1a0ZCQoJxbvrKK69QqFAhk7lpZjRu3Nj4s4WFBY0aNTI59o0bNxgzZgx169alfPnyVKhQge+//z7VpRBeffXVFG2ZvQ5PX9NXXnkFgFq1ahnbcufOjbOzMzdu3ACSkkHs7Ox477332L59e6rLTbRt25YzZ85QrVq1TF0PERERkezC2trGpJLVk2IfxWJtbfMPRyQiIiLy16lSwBNsbW3JlSuXSdvJkycZOHAgDRs2pE+fPuTJkwczMzM6duxIbGxsuuPZ2NiY3KAFsLS0zHC/3Llzp9gHMO4XFhaGpaUl9vb2Jv2cnZ3THfevevp4VlZWqcb66NHjddIjIiI4fvw4FSpUSDFesWLF/p5ARf6FFk7sSou6Feg1fiX7frrwzOPcCEsq61swb+4U2wrmzW2SbHA9LIoKpQtzK9x0jeewO/cAcLLPmeXjR0Y/ZN9PF+jUvArjPtK6wyIiz8rMzIz+/fszfPhwTp8+nWL73bt3yZs3b4r2PHnycPHiRZO2p+djyfPPjOacmZFaDDt37mTMmDF06tQJPz8/HB0dCQsLY9CgQX95nnvt2jXeeustKlasiL+/P/nz58fS0pJ+/fqlGDu1uW+ePHm4dOlSqse+e/cuCQkJTJs2zaQSWLKnl2VIj6WlJQ4ODiZtefLkISwsqQKPwWBgwIABREdHM3ToUIoXL46trS3z589P9ThPX+esXIe0rmlqc/fkfR0cHFi+fDnz589n9OjRJCQkUKVKFSZMmGCsHCAiIiLyssqXLx8JCQmEh4ebLCEQ9+gRUZGR5Muf/wVGJyIiIvJslBTwhNRKY+7atQs7Ozvmzp1rLL+avBbni5IvXz7i4uKIjo42udmX2hs+L5qDgwN169Zl2LBhKbY9nTAhkl198HZb3mxbk5EzPmf9jp8z3iEdpy9dIy4uAe/yxfhiZ4ix3TKHBZXcXPhi5zFjW8jZP2lUsxyF8zty8Y/H690Vypf0EON2xL1nisHW2hIHO9tnPAMREUnWvHlzAgICWLhwIYULFzbZ5uDgkOob5eHh4SkeRv+dUpsf79ixg3LlyjF58mRj25EjR57L8Q4cOMCDBw9YsGCB8WF3fHw8UVEpK+ykNvcNDw8nX758qY5tb2+PmZkZ/fr1o1GjRim2Ozk5ZTrOuLg4oqKiTP4unjz2H3/8wZkzZwgMDDQ5VkxM5krNZuU6PKtKlSrx8ccfExMTw+HDh/nwww8ZNGgQu3btem7HEBEREfkvcitbDoAzp3+hbr3HVWVPn/4Fg8GAW9myLyo0ERERkWem5QMyEBOTtIbUkzdEt27d+gIjgooVKwKwe/duY5vBYOC77757USGlqVatWly6dIlSpUrh7u5u8kdvIcnLwK9HQ/zebMSHH39D4Nq9f3m8u/di2HPkHF1eq4ZdTmtje9eW1bDPZcPGJxIFvvg2KUGgZ1vTNYJ7tatFXFwC+39+/KZp0YJOlHmlgEm/fE52KY5frJAzr1Yrw7GzV/7yuYiIvOzMzc3p378/u3fv5vz58ybbKleuzIULF/jtt9+MbVFRURw8eJDKlSs/1zgyU8nqScnz4yc9r/lxTEwMZmZm5MjxOHf566+/Jj4+PkXf6OhofvzxR5PPBw8eTHW5A4CcOXPi6enJb7/9lmJe6u7ujouLS5Zi3blzp/HnhIQEdu3aZTx28vV88jpdvXqVkJAQMiMr1+GvsrGxwcfHhy5duhAaGvpcKkyIiIiI/JdVq14DBwdH1n+21qR9/bq12NjaUq/eqy8mMBEREZG/QJUCMlC7dm1WrlzJlClTaNy4MSEhIWzZsuWFxuTq6krjxo2ZOnUqDx8+pHDhwqxfv9548/DfpGfPnmzdupXu3bvTo0cPChcuzJ07dzhx4gQFChSgZ8+eACxYsICFCxeyc+dOihQp8mKDFnlOWtevxAd+7bj4xy3O/X6Dzi2qmmzfc+gct+48Lu0/5n9NAShfqhAAXVtWpZZXSQA+/PgbY7/3FmzluxUj+Pbjt1m28QeK5HdkmG8Ddh48y86DZ439TpwPZcXmg/RsW4scFuYc+PlX6lVx5fUm3sxY+o3JUgMfT+lBvSqu2HoNNrb9tOEd9h65wMnzoUTcfUDpYvl4s20tLHNYMHH+i/13UEQku2jVqhWBgYEcPnzYZA7Uvn17VqxYQb9+/Xj77bextrZm0aJF5MiRgzfffPO5xlCqVCm++OILvvrqK4oXL46Tk1O6D8hr1arF5MmTCQwMxMvLi3379pk8nP8ratSoAcC4cePo3LkzFy9eZPny5SlK5AM4Ojoyfvx4hg4dir29PcHBwSQmJqZ7fUaPHs2bb77J22+/zWuvvUbu3Lm5ceMGBw8epH379lSvXj1TcVpaWrJo0SJiY2NxcXFh7dq13Lhxg8DAQABKlixJwYIFmT17NgaDgQcPHjB//nzyZ7LUbFauw7PYu3cvn3/+OY0aNaJw4cLcvn2b1atX4+3tjbV1UtLh5s2beeedd1ixYgXVqlV7LscVERER+S+wsbFh0JChfDB1MiP9hlKrdl2O/XyUbVu/ZMgwPxwcHV90iCIiIiJZpqSADPj4+DBy5EhWr17Nxo0b8fb2JigoiKZNm77QuD744AMmT57MjBkzsLKyol27dri6urJmzZoXGtfTnJycWLduHXPnzmXWrFlERkaSJ08ePDw8aNy4sbFfYmIiCQkJJCYmvsBoRZ4v9zJJD1Rci+dn+fspH1A0+d88k6SA9wa1Mtnes20t489PJgUcPxfKa/0DmDqsDTNGtCf6QSwrN//IxIAvUxxjyPuf8ef1CHq0qUHrBh5cuX6HUTM/Z8GnezOMP3jD9zSvW4HGtcphn9OGsIhodh86y4yl33L612sZ7i8iIhmzsLCgb9++TJgwwaTdzs6OTz75hOnTpzNx4kQMBgPe3t6sXr2aQoUKPdcYOnTowMmTJ5kyZQqRkZG0a9eO6dOnp9m/c+fOhIaGsnr1apYuXUqdOnWYPXs2HTt2/MuxuLm5MW3aNBYsWEC/fv0oV64c8+bN4+23307RN1++fIwcOZIZM2Zw5coVXF1dWbp0KXnz5k1zfG9vbz799FMCAgIYN24ccXFxFCxYkBo1alC8ePFMx2lpacmcOXPw9/fnwoULuLi4MH/+fMr+fylZKysrAgICmDx5MsOGDaNQoUIMGDCAQ4cO8csvvzzX6/AsihUrhrm5OXPnziU8PBxHR0fq1KnD8OHDjX0MBoPm5yIiIvLS6tSlGzlyWLJq5TL2freHggULMWrMOLr5Pt8EXREREZF/ilmi7vJkG926dcPc3JxPPvnkRYfyr/HkW88iIvLf9TBkwYsOQUQEgICAAJYtW5bppQDEVMzzXwFBREREREREROSlZpOJMgCqFPAf9c0333D9+nXKlCnDw4cP+eqrrzh69KixZKmIiIiIiIiIiIiIiIiIiIiSAv6jcubMyZYtW7h8+TJxcXGULFmSmTNn0qhRoxcdmoiIiIj8S2RU/j1HDn0deJLBYMBgMKS53cLC4h+MRkRERERERERE5PnQ8gGSrWn5ABGR7EHLB4g8G19fX44cOZLm9t27d+Pi4vIPRvTvNnbsWDZt2pTm9lWrVlG9evV/MKLsR8sHiIiIiIiIiIg8X5lZPkBJAZKtKSlARCR7UFKAyLP57bffuH//fprb3dzcsLKy+gcj+ncLDQ0lIiIize0lSpTAzs7uH4wo+1FSgIiIiIiIiIjI85WZpADVCxURERERyaZKliz5okP4T3FxcVHlBBERERERERERyXbMX3QAIiIiIiIiIiIiIiIiIiIi8vdQUoCIiIiIiIiIiIiIiIiIiEg2ZZaYmJj4ooMQERERERERERERERERERGR50+VAkRERERERERERERERERERLIpJQWIiIiIiIiIiIiIiIiIiIhkU0oKEBERERERERERERERERERyaaUFCAiIiIiIiIiIiIiIiIiIpJNKSlAREREREREREREREREREQkm1JSgIiIiIiIiIiIiIiIiIiISDalpAAREREREREREREREREREZFsSkkBIiIiIiIiIiIiIiIiIiIi2ZSSAkRERERERERERERERERERLKp/wN8N36lzccFMwAAAABJRU5ErkJggg==\n" }, "metadata": {} } ], "source": [ "training_wb = ensure_workbook(TRAINING_WORKBOOK)\n", "\n", "# Clear existing per-model sheets (keep Summary) to avoid stale data\n", "if 'Summary' in training_wb.sheetnames and len(training_wb.sheetnames) > 1:\n", " for sheet in training_wb.sheetnames[1:]:\n", " del training_wb[sheet]\n", "\n", "summary_rows = []\n", "registry = {}\n", "\n", "for model_name, spec in MODEL_SPECS.items():\n", " print('\\n' + '=' * 30 + f' Training {model_name} ' + '=' * 30)\n", " summary = run_training(model_name, spec, training_wb)\n", " summary_rows.append(summary)\n", " registry[model_name] = {\n", " 'best_model_path': summary['best_model_path'],\n", " 'final_model_path': summary['final_model_path'],\n", " 'custom_objects': sorted(CUSTOM_OBJECTS.keys()),\n", " 'patch_size': P_S,\n", " 'num_classes': num_classes,\n", " 'bands': B,\n", " }\n", "\n", "# Write consolidated summary sheet\n", "summary_df = pd.DataFrame(summary_rows)\n", "summary_ws = training_wb['Summary']\n", "summary_ws.delete_rows(1, summary_ws.max_row)\n", "for r_idx, row in enumerate(dataframe_to_rows(summary_df, index=False, header=True), start=1):\n", " for c_idx, val in enumerate(row, start=1):\n", " summary_ws.cell(row=r_idx, column=c_idx, value=val)\n", "autosize_columns(summary_ws)\n", "\n", "training_wb.save(TRAINING_WORKBOOK)\n", "MODEL_REGISTRY_PATH.write_text(json.dumps(registry, indent=2))\n", "print('Saved training workbook to', TRAINING_WORKBOOK)\n", "print('Saved model registry to', MODEL_REGISTRY_PATH)\n", "summary_df" ] }, { "cell_type": "markdown", "id": "100-smoke-hdr", "metadata": { "id": "100-smoke-hdr" }, "source": [ "# 10.0 \u2014 Smoke Check\n", "\n", "Reload each saved best model from the registry and assert that it returns exactly\n", "7 output heads on a 4-sample mini-batch." ] }, { "cell_type": "code", "execution_count": 20, "id": "100-smoke-code", "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "100-smoke-code", "executionInfo": { "status": "ok", "timestamp": 1779948832036, "user_tz": -330, "elapsed": 28613, "user": { "displayName": "Big Story", "userId": "07276682490797804347" } }, "outputId": "9b145954-8e77-4bd1-a70f-07c4de5fde95" }, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "\n", "Smoke check: AlexNet_CNN_MultiHead\n", "heads: 7 | sample shape: (4, 7)\n", "\n", "Smoke check: GFNet_MultiHead\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ "/usr/local/lib/python3.12/dist-packages/keras/src/layers/layer.py:424: UserWarning: `build()` was called on layer 'gf__patch_encoder', however the layer does not have a `build()` method implemented and it looks like it has unbuilt state. This will cause the layer to be marked as built, despite not being actually built, which may cause failures down the line. Make sure to implement a proper `build()` method.\n", " warnings.warn(\n", "/usr/local/lib/python3.12/dist-packages/keras/src/layers/layer.py:424: UserWarning: `build()` was called on layer 'gf__block', however the layer does not have a `build()` method implemented and it looks like it has unbuilt state. This will cause the layer to be marked as built, despite not being actually built, which may cause failures down the line. Make sure to implement a proper `build()` method.\n", " warnings.warn(\n", "/usr/local/lib/python3.12/dist-packages/keras/src/layers/layer.py:424: UserWarning: `build()` was called on layer 'gf__block_1', however the layer does not have a `build()` method implemented and it looks like it has unbuilt state. This will cause the layer to be marked as built, despite not being actually built, which may cause failures down the line. Make sure to implement a proper `build()` method.\n", " warnings.warn(\n", "/usr/local/lib/python3.12/dist-packages/keras/src/layers/layer.py:424: UserWarning: `build()` was called on layer 'gf__block_2', however the layer does not have a `build()` method implemented and it looks like it has unbuilt state. This will cause the layer to be marked as built, despite not being actually built, which may cause failures down the line. Make sure to implement a proper `build()` method.\n", " warnings.warn(\n", "/usr/local/lib/python3.12/dist-packages/keras/src/layers/layer.py:424: UserWarning: `build()` was called on layer 'gf__block_3', however the layer does not have a `build()` method implemented and it looks like it has unbuilt state. This will cause the layer to be marked as built, despite not being actually built, which may cause failures down the line. Make sure to implement a proper `build()` method.\n", " warnings.warn(\n", "/usr/local/lib/python3.12/dist-packages/keras/src/layers/layer.py:424: UserWarning: `build()` was called on layer 'gf__block_4', however the layer does not have a `build()` method implemented and it looks like it has unbuilt state. This will cause the layer to be marked as built, despite not being actually built, which may cause failures down the line. Make sure to implement a proper `build()` method.\n", " warnings.warn(\n", "/usr/local/lib/python3.12/dist-packages/keras/src/layers/layer.py:424: UserWarning: `build()` was called on layer 'gf__block_5', however the layer does not have a `build()` method implemented and it looks like it has unbuilt state. This will cause the layer to be marked as built, despite not being actually built, which may cause failures down the line. Make sure to implement a proper `build()` method.\n", " warnings.warn(\n", "/usr/local/lib/python3.12/dist-packages/keras/src/layers/layer.py:424: UserWarning: `build()` was called on layer 'gf__block_6', however the layer does not have a `build()` method implemented and it looks like it has unbuilt state. This will cause the layer to be marked as built, despite not being actually built, which may cause failures down the line. Make sure to implement a proper `build()` method.\n", " warnings.warn(\n", "/usr/local/lib/python3.12/dist-packages/keras/src/layers/layer.py:424: UserWarning: `build()` was called on layer 'gf__block_7', however the layer does not have a `build()` method implemented and it looks like it has unbuilt state. This will cause the layer to be marked as built, despite not being actually built, which may cause failures down the line. Make sure to implement a proper `build()` method.\n", " warnings.warn(\n", "/usr/local/lib/python3.12/dist-packages/keras/src/layers/layer.py:424: UserWarning: `build()` was called on layer 'gf__block_8', however the layer does not have a `build()` method implemented and it looks like it has unbuilt state. This will cause the layer to be marked as built, despite not being actually built, which may cause failures down the line. Make sure to implement a proper `build()` method.\n", " warnings.warn(\n", "/usr/local/lib/python3.12/dist-packages/keras/src/layers/layer.py:424: UserWarning: `build()` was called on layer 'gf__block_9', however the layer does not have a `build()` method implemented and it looks like it has unbuilt state. This will cause the layer to be marked as built, despite not being actually built, which may cause failures down the line. Make sure to implement a proper `build()` method.\n", " warnings.warn(\n", "/usr/local/lib/python3.12/dist-packages/keras/src/layers/layer.py:424: UserWarning: `build()` was called on layer 'gf__block_10', however the layer does not have a `build()` method implemented and it looks like it has unbuilt state. This will cause the layer to be marked as built, despite not being actually built, which may cause failures down the line. Make sure to implement a proper `build()` method.\n", " warnings.warn(\n", "/usr/local/lib/python3.12/dist-packages/keras/src/layers/layer.py:424: UserWarning: `build()` was called on layer 'gf__block_11', however the layer does not have a `build()` method implemented and it looks like it has unbuilt state. This will cause the layer to be marked as built, despite not being actually built, which may cause failures down the line. Make sure to implement a proper `build()` method.\n", " warnings.warn(\n" ] }, { "output_type": "stream", "name": "stdout", "text": [ "heads: 7 | sample shape: (4, 7)\n", "\n", "Smoke check: ViT_UNet_MultiHead\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ "/usr/local/lib/python3.12/dist-packages/keras/src/layers/layer.py:424: UserWarning: `build()` was called on layer 'vi_t__patch_encoder', however the layer does not have a `build()` method implemented and it looks like it has unbuilt state. This will cause the layer to be marked as built, despite not being actually built, which may cause failures down the line. Make sure to implement a proper `build()` method.\n", " warnings.warn(\n", "/usr/local/lib/python3.12/dist-packages/keras/src/layers/layer.py:424: UserWarning: `build()` was called on layer 'vi_t__class__token__norm', however the layer does not have a `build()` method implemented and it looks like it has unbuilt state. This will cause the layer to be marked as built, despite not being actually built, which may cause failures down the line. Make sure to implement a proper `build()` method.\n", " warnings.warn(\n", "WARNING:tensorflow:5 out of the last 138 calls to .one_step_on_data_distributed at 0x79afb59059e0> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has reduce_retracing=True option that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/guide/function#controlling_retracing and https://www.tensorflow.org/api_docs/python/tf/function for more details.\n" ] }, { "output_type": "stream", "name": "stdout", "text": [ "heads: 7 | sample shape: (4, 7)\n" ] } ], "source": [ "for model_name, info in json.loads(MODEL_REGISTRY_PATH.read_text()).items():\n", " print('\\nSmoke check:', model_name)\n", " model = load_model(info['best_model_path'], custom_objects=CUSTOM_OBJECTS, safe_mode=False)\n", " outputs = model.predict(x_test[:4], verbose=0)\n", " assert isinstance(outputs, list) and len(outputs) == 7, (\n", " f\"Expected 7 heads, got {len(outputs) if isinstance(outputs, list) else 1}\"\n", " )\n", " print('heads:', len(outputs), '| sample shape:', outputs[0].shape)" ] } ] }