neural_networks/binary_loss_functions.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Binary cross entropy vs cross entropy loss functions in PyTorch?\n",
    "\n",
    "Sometimes when designing a classifier we don't quite know how many output classes there will be. We can design a multi class model and then realise a binary classification model would suffice. When creating a multi class model in PyTorch we typically use the `CrossEntropyLoss` loss function. For a binary classification model we would usually use `BCEWithLogitsLoss`. However, for a binary classification problem, if we use `CrossEntropyLoss` loss we end up with twice as many weights than using `BCEWithLogitsLoss`. Does this matter...?\n",
    "\n",
    "To do a quite check we can create some dummy binary classification data and fit a few models. We'll fit the same model structure with different loss functions and see what the differences are."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Create data\n",
    "\n",
    "We create random data from a binary classification problem. Then we convert to PyTorch dataloaders for training our models.\n",
    "\n",
    "> Note: We use no parallel workers for the dataloader as it slows down loading data a lot when the dataset can fit in memory."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import numpy as np\n",
    "import scipy.special\n",
    "\n",
    "n = 100_000  # number of data points\n",
    "m = 4  # number of features\n",
    "\n",
    "torch.manual_seed(0)\n",
    "random = np.random.default_rng(seed=0)\n",
    "w = random.normal(size=(m, 1))  # weights vector\n",
    "b = random.normal(size=1)\n",
    "X = random.normal(size=(n, m))\n",
    "y_logit = b + np.dot(X, w) + random.normal(scale=0.0, size=(n, 1))\n",
    "y = random.binomial(n=1, p=scipy.special.expit(y_logit)).flatten()\n",
    "\n",
    "# split to train/test\n",
    "X_train, X_test, y_train, y_test = (\n",
    "    X[: int(n / 2)],\n",
    "    X[int(n / 2) :],\n",
    "    y[: int(n / 2)],\n",
    "    y[int(n / 2) :],\n",
    ")\n",
    "\n",
    "train_dataset = torch.utils.data.TensorDataset(\n",
    "    torch.Tensor(X_train), torch.Tensor(y_train)\n",
    ")\n",
    "test_dataset = torch.utils.data.TensorDataset(\n",
    "    torch.Tensor(X_test), torch.Tensor(y_test)\n",
    ")\n",
    "\n",
    "# create to data loader\n",
    "train_loader = torch.utils.data.DataLoader(\n",
    "    train_dataset, batch_size=int(n / 2), shuffle=False\n",
    ")\n",
    "test_loader = torch.utils.data.DataLoader(\n",
    "    test_dataset, batch_size=int(n / 2), shuffle=False\n",
    ")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Build models"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here we'll define some common functions. Namely, to train a pytorch lightning models and evaluate model performance.\n",
    "\n",
    "Metrics - we use log likelihood and accuracy (we have a class split of 50/50 so this is reasonable)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/rich/Developer/miniconda3/envs/pytorch_env/lib/python3.10/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
      "  from .autonotebook import tqdm as notebook_tqdm\n",
      "/var/folders/ky/4qby95090jbbq38_mh94x72r0000gn/T/ipykernel_69550/494113661.py:7: MatplotlibDeprecationWarning: The seaborn styles shipped by Matplotlib are deprecated since 3.6, as they no longer correspond to the styles shipped by seaborn. However, they will remain available as 'seaborn-v0_8-<style>'. Alternatively, directly use the seaborn API instead.\n",
      "  plt.style.use(\"seaborn-whitegrid\")\n"
     ]
    }
   ],
   "source": [
    "import sklearn.metrics\n",
    "import pandas as pd\n",
    "import pytorch_lightning as pl\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "plt.style.use(\"seaborn-whitegrid\")\n",
    "\n",
    "\n",
    "def tensor_to_sklearn_pred(pred):\n",
    "    return np.stack([1 - pred, pred]).transpose()\n",
    "\n",
    "\n",
    "def evaluate_predictions_with_skl(y_train, y_train_est, y_test, y_test_est) -> dict:\n",
    "    return {\n",
    "        \"log_loss_train\": sklearn.metrics.log_loss(y_train, y_train_est),\n",
    "        \"log_loss_test\": sklearn.metrics.log_loss(y_test, y_test_est),\n",
    "        \"accuracy_score_train\": sklearn.metrics.accuracy_score(\n",
    "            y_train, y_train_est[:, 1] > y_train_est[:, 0]\n",
    "        ),\n",
    "        \"accuracy_score_test\": sklearn.metrics.accuracy_score(\n",
    "            y_test, y_test_est[:, 1] > y_test_est[:, 0]\n",
    "        ),\n",
    "    }\n",
    "\n",
    "\n",
    "def evaluate_all_models(model_outputs: dict) -> pd.DataFrame:\n",
    "    results = []\n",
    "    for name, model_output in model_outputs.items():\n",
    "        _results = evaluate_predictions_with_skl(\n",
    "            y_train, model_output[0], y_test, model_output[1]\n",
    "        )\n",
    "        _results[\"name\"] = name\n",
    "        results.append(_results)\n",
    "    return pd.DataFrame(results)\n",
    "\n",
    "\n",
    "def train_torch_model(\n",
    "    model,\n",
    "    epochs: int = 100,\n",
    "    train_loader=train_loader,\n",
    "    test_loader=test_loader,\n",
    "    accelerator=\"gpu\",\n",
    "):\n",
    "    trainer = pl.Trainer(\n",
    "        max_epochs=epochs, enable_progress_bar=True, accelerator=accelerator\n",
    "    )\n",
    "    trainer.fit(model, train_loader, test_loader)\n",
    "\n",
    "\n",
    "def plot_training_logs(model):\n",
    "    fig, ax = plt.subplots(figsize=(8, 6))\n",
    "    ax.plot(np.array(model.log_train), label=\"train_LL\")\n",
    "    ax.plot(np.array(model.log_val), label=\"test_LL\")\n",
    "    ax.set(xlabel=\"Step\", ylabel=\"Logloss\")\n",
    "    ax.legend()\n",
    "    fig.show()\n",
    "\n",
    "\n",
    "def predict_data_loader(model, data_loader):\n",
    "    model.eval()\n",
    "\n",
    "    y_est = []\n",
    "    y_true = []\n",
    "    with torch.no_grad():\n",
    "        for img_batch, label_batch in data_loader:\n",
    "            output = model(img_batch)\n",
    "            probs = torch.nn.functional.sigmoid(output)\n",
    "\n",
    "            y_est.append(probs)\n",
    "            y_true.append(label_batch)\n",
    "\n",
    "    y_est = torch.cat(y_est)\n",
    "    y_true = torch.cat(y_true)\n",
    "\n",
    "    return y_est, y_true\n",
    "\n",
    "\n",
    "model_outputs = {}\n",
    "model_times = {}\n",
    "model_parameters = {}"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Binary cross entropy\n",
    "\n",
    "The model we build is a binary classifier with a single linear layer, a logistic regression. We set the criterion to `BCEWithLogitsLoss`.\n",
    "Given we have 4 features, there are only 5 parameters to learn here.\n",
    "\n",
    "We train the model for 50 epochs and time how long it takes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "GPU available: True (mps), used: True\n",
      "TPU available: False, using: 0 TPU cores\n",
      "IPU available: False, using: 0 IPUs\n",
      "HPU available: False, using: 0 HPUs\n",
      "\n",
      "  | Name       | Type              | Params\n",
      "-------------------------------------------------\n",
      "0 | classifier | Linear            | 5     \n",
      "1 | criterion  | BCEWithLogitsLoss | 0     \n",
      "-------------------------------------------------\n",
      "5         Trainable params\n",
      "0         Non-trainable params\n",
      "5         Total params\n",
      "0.000     Total estimated model params size (MB)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sanity Checking: 0it [00:00, ?it/s]"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/rich/Developer/miniconda3/envs/pytorch_env/lib/python3.10/site-packages/pytorch_lightning/trainer/connectors/data_connector.py:430: PossibleUserWarning: The dataloader, val_dataloader, does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` (try 8 which is the number of cpus on this machine) in the `DataLoader` init to improve performance.\n",
      "  rank_zero_warn(\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "                                                                           "
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/rich/Developer/miniconda3/envs/pytorch_env/lib/python3.10/site-packages/pytorch_lightning/trainer/connectors/data_connector.py:430: PossibleUserWarning: The dataloader, train_dataloader, does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` (try 8 which is the number of cpus on this machine) in the `DataLoader` init to improve performance.\n",
      "  rank_zero_warn(\n",
      "/Users/rich/Developer/miniconda3/envs/pytorch_env/lib/python3.10/site-packages/pytorch_lightning/loops/fit_loop.py:280: PossibleUserWarning: The number of training batches (1) is smaller than the logging interval Trainer(log_every_n_steps=50). Set a lower value for log_every_n_steps if you want to see logs for the training epoch.\n",
      "  rank_zero_warn(\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 49: 100%|██████████| 1/1 [00:00<00:00,  2.13it/s, v_num=195, train_loss=0.616, val_loss_step=0.618, val_loss_epoch=0.618]"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "`Trainer.fit` stopped: `max_epochs=50` reached.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 49: 100%|██████████| 1/1 [00:00<00:00,  2.11it/s, v_num=195, train_loss=0.616, val_loss_step=0.618, val_loss_epoch=0.618]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/var/folders/ky/4qby95090jbbq38_mh94x72r0000gn/T/ipykernel_69550/494113661.py:57: UserWarning: Matplotlib is currently using module://matplotlib_inline.backend_inline, which is a non-GUI backend, so cannot show the figure.\n",
      "  fig.show()\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 800x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import torch.nn as nn\n",
    "import timeit\n",
    "\n",
    "\n",
    "class BCEModel(pl.LightningModule):\n",
    "    def __init__(self, input_features: int, learning_rate=0.01):\n",
    "        super().__init__()\n",
    "\n",
    "        self.classifier = nn.Linear(input_features, 1)\n",
    "\n",
    "        # Define loss function\n",
    "        self.criterion = nn.BCEWithLogitsLoss()\n",
    "\n",
    "        # Define optimizer\n",
    "        self.learning_rate = learning_rate\n",
    "        self.optimizer = torch.optim.Adam(self.parameters(), lr=learning_rate)\n",
    "\n",
    "        # training logs\n",
    "        self.log_train = []\n",
    "        self.log_val = []\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = self.classifier(x)\n",
    "        return x.flatten()\n",
    "\n",
    "    def training_step(self, batch, batch_idx):\n",
    "        x, y = batch\n",
    "        y_hat = self(x)\n",
    "        loss = self.criterion(y_hat, y)\n",
    "        self.log(\"train_loss\", loss, prog_bar=True, on_step=True)\n",
    "        self.log_train.append(loss.detach().cpu().numpy())\n",
    "        return loss\n",
    "\n",
    "    def validation_step(self, batch, batch_idx):\n",
    "        x, y = batch\n",
    "        y_hat = self(x)\n",
    "        loss = self.criterion(y_hat, y)\n",
    "        self.log(\"val_loss\", loss, prog_bar=True, on_step=True)\n",
    "        self.log_val.append(loss.cpu().numpy())\n",
    "\n",
    "    def configure_optimizers(self):\n",
    "        return self.optimizer\n",
    "\n",
    "\n",
    "model_lightning = BCEModel(learning_rate=1e-1, input_features=m)\n",
    "\n",
    "start_time = timeit.default_timer()\n",
    "train_torch_model(model_lightning, epochs=50)\n",
    "model_times[\"logistic_reg_bce\"] = timeit.default_timer() - start_time\n",
    "\n",
    "plot_training_logs(model_lightning)\n",
    "\n",
    "y_train_est, y_true_train = predict_data_loader(model_lightning, train_loader)\n",
    "y_test_est, y_true_test = predict_data_loader(model_lightning, test_loader)\n",
    "model_outputs[\"logistic_reg_bce\"] = [\n",
    "    tensor_to_sklearn_pred(y_train_est),\n",
    "    tensor_to_sklearn_pred(y_test_est),\n",
    "]\n",
    "model_parameters[\"logistic_reg_bce\"] = model_lightning.parameters()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Cross Entropy\n",
    "\n",
    "Now we do the same but using `CrossEntropyLoss`. This requires an output per possible target class. We have a single class, where the target takes on 0 or 1. However for a multi class problem that is considered as two classes, 0 and 1. So we can adjust the single output, `p(x)`, to make the output in the form:\n",
    "\n",
    "```\n",
    "[p(x), 1-p(x)]\n",
    "```\n",
    "\n",
    "As the output is in logits we need to use the `expit` and `logit` function to do the transform. This is now the same model as before with 5 parameters, but using `CrossEntropyLoss`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "GPU available: True (mps), used: False\n",
      "TPU available: False, using: 0 TPU cores\n",
      "IPU available: False, using: 0 IPUs\n",
      "HPU available: False, using: 0 HPUs\n",
      "/Users/rich/Developer/miniconda3/envs/pytorch_env/lib/python3.10/site-packages/pytorch_lightning/trainer/setup.py:201: UserWarning: MPS available but not used. Set `accelerator` and `devices` using `Trainer(accelerator='mps', devices=1)`.\n",
      "  rank_zero_warn(\n",
      "\n",
      "  | Name       | Type             | Params\n",
      "------------------------------------------------\n",
      "0 | classifier | Linear           | 5     \n",
      "1 | criterion  | CrossEntropyLoss | 0     \n",
      "------------------------------------------------\n",
      "5         Trainable params\n",
      "0         Non-trainable params\n",
      "5         Total params\n",
      "0.000     Total estimated model params size (MB)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 0:   0%|          | 0/1 [00:00<?, ?it/s]                              torch.Size([50000, 4])\n",
      "torch.Size([50000, 2])\n",
      "torch.Size([50000])\n",
      "Epoch 1:   0%|          | 0/1 [00:00<?, ?it/s, v_num=196, train_loss=0.748, val_loss_step=0.689, val_loss_epoch=0.689]        torch.Size([50000, 4])\n",
      "torch.Size([50000, 2])\n",
      "torch.Size([50000])\n",
      "Epoch 2:   0%|          | 0/1 [00:00<?, ?it/s, v_num=196, train_loss=0.686, val_loss_step=0.650, val_loss_epoch=0.650]        torch.Size([50000, 4])\n",
      "torch.Size([50000, 2])\n",
      "torch.Size([50000])\n",
      "Epoch 3:   0%|          | 0/1 [00:00<?, ?it/s, v_num=196, train_loss=0.647, val_loss_step=0.633, val_loss_epoch=0.633]        torch.Size([50000, 4])\n",
      "torch.Size([50000, 2])\n",
      "torch.Size([50000])\n",
      "Epoch 4:   0%|          | 0/1 [00:00<?, ?it/s, v_num=196, train_loss=0.631, val_loss_step=0.630, val_loss_epoch=0.630]        torch.Size([50000, 4])\n",
      "torch.Size([50000, 2])\n",
      "torch.Size([50000])\n",
      "Epoch 5:   0%|          | 0/1 [00:00<?, ?it/s, v_num=196, train_loss=0.627, val_loss_step=0.630, val_loss_epoch=0.630]        torch.Size([50000, 4])\n",
      "torch.Size([50000, 2])\n",
      "torch.Size([50000])\n",
      "Epoch 6:   0%|          | 0/1 [00:00<?, ?it/s, v_num=196, train_loss=0.628, val_loss_step=0.632, val_loss_epoch=0.632]        torch.Size([50000, 4])\n",
      "torch.Size([50000, 2])\n",
      "torch.Size([50000])\n",
      "Epoch 7:   0%|          | 0/1 [00:00<?, ?it/s, v_num=196, train_loss=0.630, val_loss_step=0.635, val_loss_epoch=0.635]        torch.Size([50000, 4])\n",
      "torch.Size([50000, 2])\n",
      "torch.Size([50000])\n",
      "Epoch 8:   0%|          | 0/1 [00:00<?, ?it/s, v_num=196, train_loss=0.633, val_loss_step=0.637, val_loss_epoch=0.637]        torch.Size([50000, 4])\n",
      "torch.Size([50000, 2])\n",
      "torch.Size([50000])\n",
      "Epoch 9:   0%|          | 0/1 [00:00<?, ?it/s, v_num=196, train_loss=0.635, val_loss_step=0.639, val_loss_epoch=0.639]        torch.Size([50000, 4])\n",
      "torch.Size([50000, 2])\n",
      "torch.Size([50000])\n",
      "Epoch 10:   0%|          | 0/1 [00:00<?, ?it/s, v_num=196, train_loss=0.637, val_loss_step=0.640, val_loss_epoch=0.640]       torch.Size([50000, 4])\n",
      "torch.Size([50000, 2])\n",
      "torch.Size([50000])\n",
      "Epoch 11:   0%|          | 0/1 [00:00<?, ?it/s, v_num=196, train_loss=0.638, val_loss_step=0.638, val_loss_epoch=0.638]        torch.Size([50000, 4])\n",
      "torch.Size([50000, 2])\n",
      "torch.Size([50000])\n",
      "Epoch 12:   0%|          | 0/1 [00:00<?, ?it/s, v_num=196, train_loss=0.636, val_loss_step=0.634, val_loss_epoch=0.634]        torch.Size([50000, 4])\n",
      "torch.Size([50000, 2])\n",
      "torch.Size([50000])\n",
      "Epoch 13:   0%|          | 0/1 [00:00<?, ?it/s, v_num=196, train_loss=0.632, val_loss_step=0.629, val_loss_epoch=0.629]        torch.Size([50000, 4])\n",
      "torch.Size([50000, 2])\n",
      "torch.Size([50000])\n",
      "Epoch 14:   0%|          | 0/1 [00:00<?, ?it/s, v_num=196, train_loss=0.628, val_loss_step=0.625, val_loss_epoch=0.625]        torch.Size([50000, 4])\n",
      "torch.Size([50000, 2])\n",
      "torch.Size([50000])\n",
      "Epoch 15:   0%|          | 0/1 [00:00<?, ?it/s, v_num=196, train_loss=0.623, val_loss_step=0.622, val_loss_epoch=0.622]        torch.Size([50000, 4])\n",
      "torch.Size([50000, 2])\n",
      "torch.Size([50000])\n",
      "Epoch 16:   0%|          | 0/1 [00:00<?, ?it/s, v_num=196, train_loss=0.620, val_loss_step=0.621, val_loss_epoch=0.621]        torch.Size([50000, 4])\n",
      "torch.Size([50000, 2])\n",
      "torch.Size([50000])\n",
      "Epoch 17:   0%|          | 0/1 [00:00<?, ?it/s, v_num=196, train_loss=0.619, val_loss_step=0.620, val_loss_epoch=0.620]        torch.Size([50000, 4])\n",
      "torch.Size([50000, 2])\n",
      "torch.Size([50000])\n",
      "Epoch 18:   0%|          | 0/1 [00:00<?, ?it/s, v_num=196, train_loss=0.619, val_loss_step=0.621, val_loss_epoch=0.621]        torch.Size([50000, 4])\n",
      "torch.Size([50000, 2])\n",
      "torch.Size([50000])\n",
      "Epoch 19:   0%|          | 0/1 [00:00<?, ?it/s, v_num=196, train_loss=0.619, val_loss_step=0.621, val_loss_epoch=0.621]        torch.Size([50000, 4])\n",
      "torch.Size([50000, 2])\n",
      "torch.Size([50000])\n",
      "Epoch 20:   0%|          | 0/1 [00:00<?, ?it/s, v_num=196, train_loss=0.619, val_loss_step=0.622, val_loss_epoch=0.622]        torch.Size([50000, 4])\n",
      "torch.Size([50000, 2])\n",
      "torch.Size([50000])\n",
      "Epoch 21:   0%|          | 0/1 [00:00<?, ?it/s, v_num=196, train_loss=0.620, val_loss_step=0.623, val_loss_epoch=0.623]        torch.Size([50000, 4])\n",
      "torch.Size([50000, 2])\n",
      "torch.Size([50000])\n",
      "Epoch 22:   0%|          | 0/1 [00:00<?, ?it/s, v_num=196, train_loss=0.621, val_loss_step=0.623, val_loss_epoch=0.623]        torch.Size([50000, 4])\n",
      "torch.Size([50000, 2])\n",
      "torch.Size([50000])\n",
      "Epoch 23:   0%|          | 0/1 [00:00<?, ?it/s, v_num=196, train_loss=0.621, val_loss_step=0.624, val_loss_epoch=0.624]        torch.Size([50000, 4])\n",
      "torch.Size([50000, 2])\n",
      "torch.Size([50000])\n",
      "Epoch 24:   0%|          | 0/1 [00:00<?, ?it/s, v_num=196, train_loss=0.621, val_loss_step=0.623, val_loss_epoch=0.623]        torch.Size([50000, 4])\n",
      "torch.Size([50000, 2])\n",
      "torch.Size([50000])\n",
      "Epoch 25:   0%|          | 0/1 [00:00<?, ?it/s, v_num=196, train_loss=0.621, val_loss_step=0.622, val_loss_epoch=0.622]        torch.Size([50000, 4])\n",
      "torch.Size([50000, 2])\n",
      "torch.Size([50000])\n",
      "Epoch 26:   0%|          | 0/1 [00:00<?, ?it/s, v_num=196, train_loss=0.620, val_loss_step=0.621, val_loss_epoch=0.621]        torch.Size([50000, 4])\n",
      "torch.Size([50000, 2])\n",
      "torch.Size([50000])\n",
      "Epoch 27:   0%|          | 0/1 [00:00<?, ?it/s, v_num=196, train_loss=0.619, val_loss_step=0.620, val_loss_epoch=0.620]        torch.Size([50000, 4])\n",
      "torch.Size([50000, 2])\n",
      "torch.Size([50000])\n",
      "Epoch 28:   0%|          | 0/1 [00:00<?, ?it/s, v_num=196, train_loss=0.618, val_loss_step=0.619, val_loss_epoch=0.619]        torch.Size([50000, 4])\n",
      "torch.Size([50000, 2])\n",
      "torch.Size([50000])\n",
      "Epoch 29:   0%|          | 0/1 [00:00<?, ?it/s, v_num=196, train_loss=0.617, val_loss_step=0.618, val_loss_epoch=0.618]        torch.Size([50000, 4])\n",
      "torch.Size([50000, 2])\n",
      "torch.Size([50000])\n",
      "Epoch 30:   0%|          | 0/1 [00:00<?, ?it/s, v_num=196, train_loss=0.617, val_loss_step=0.618, val_loss_epoch=0.618]        torch.Size([50000, 4])\n",
      "torch.Size([50000, 2])\n",
      "torch.Size([50000])\n",
      "Epoch 31:   0%|          | 0/1 [00:00<?, ?it/s, v_num=196, train_loss=0.616, val_loss_step=0.618, val_loss_epoch=0.618]        torch.Size([50000, 4])\n",
      "torch.Size([50000, 2])\n",
      "torch.Size([50000])\n",
      "Epoch 32:   0%|          | 0/1 [00:00<?, ?it/s, v_num=196, train_loss=0.617, val_loss_step=0.619, val_loss_epoch=0.619]        torch.Size([50000, 4])\n",
      "torch.Size([50000, 2])\n",
      "torch.Size([50000])\n",
      "Epoch 33:   0%|          | 0/1 [00:00<?, ?it/s, v_num=196, train_loss=0.617, val_loss_step=0.620, val_loss_epoch=0.620]        torch.Size([50000, 4])\n",
      "torch.Size([50000, 2])\n",
      "torch.Size([50000])\n",
      "Epoch 34:   0%|          | 0/1 [00:00<?, ?it/s, v_num=196, train_loss=0.618, val_loss_step=0.620, val_loss_epoch=0.620]        torch.Size([50000, 4])\n",
      "torch.Size([50000, 2])\n",
      "torch.Size([50000])\n",
      "Epoch 35:   0%|          | 0/1 [00:00<?, ?it/s, v_num=196, train_loss=0.618, val_loss_step=0.620, val_loss_epoch=0.620]        torch.Size([50000, 4])\n",
      "torch.Size([50000, 2])\n",
      "torch.Size([50000])\n",
      "Epoch 36:   0%|          | 0/1 [00:00<?, ?it/s, v_num=196, train_loss=0.618, val_loss_step=0.619, val_loss_epoch=0.619]        torch.Size([50000, 4])\n",
      "torch.Size([50000, 2])\n",
      "torch.Size([50000])\n",
      "Epoch 37:   0%|          | 0/1 [00:00<?, ?it/s, v_num=196, train_loss=0.617, val_loss_step=0.619, val_loss_epoch=0.619]        torch.Size([50000, 4])\n",
      "torch.Size([50000, 2])\n",
      "torch.Size([50000])\n",
      "Epoch 38:   0%|          | 0/1 [00:00<?, ?it/s, v_num=196, train_loss=0.617, val_loss_step=0.618, val_loss_epoch=0.618]        torch.Size([50000, 4])\n",
      "torch.Size([50000, 2])\n",
      "torch.Size([50000])\n",
      "Epoch 39:   0%|          | 0/1 [00:00<?, ?it/s, v_num=196, train_loss=0.617, val_loss_step=0.618, val_loss_epoch=0.618]        torch.Size([50000, 4])\n",
      "torch.Size([50000, 2])\n",
      "torch.Size([50000])\n",
      "Epoch 40:   0%|          | 0/1 [00:00<?, ?it/s, v_num=196, train_loss=0.616, val_loss_step=0.618, val_loss_epoch=0.618]        torch.Size([50000, 4])\n",
      "torch.Size([50000, 2])\n",
      "torch.Size([50000])\n",
      "Epoch 41:   0%|          | 0/1 [00:00<?, ?it/s, v_num=196, train_loss=0.616, val_loss_step=0.618, val_loss_epoch=0.618]        torch.Size([50000, 4])\n",
      "torch.Size([50000, 2])\n",
      "torch.Size([50000])\n",
      "Epoch 42:   0%|          | 0/1 [00:00<?, ?it/s, v_num=196, train_loss=0.616, val_loss_step=0.618, val_loss_epoch=0.618]        torch.Size([50000, 4])\n",
      "torch.Size([50000, 2])\n",
      "torch.Size([50000])\n",
      "Epoch 43:   0%|          | 0/1 [00:00<?, ?it/s, v_num=196, train_loss=0.616, val_loss_step=0.618, val_loss_epoch=0.618]        torch.Size([50000, 4])\n",
      "torch.Size([50000, 2])\n",
      "torch.Size([50000])\n",
      "Epoch 44:   0%|          | 0/1 [00:00<?, ?it/s, v_num=196, train_loss=0.616, val_loss_step=0.619, val_loss_epoch=0.619]        torch.Size([50000, 4])\n",
      "torch.Size([50000, 2])\n",
      "torch.Size([50000])\n",
      "Epoch 45:   0%|          | 0/1 [00:00<?, ?it/s, v_num=196, train_loss=0.617, val_loss_step=0.619, val_loss_epoch=0.619]        torch.Size([50000, 4])\n",
      "torch.Size([50000, 2])\n",
      "torch.Size([50000])\n",
      "Epoch 46:   0%|          | 0/1 [00:00<?, ?it/s, v_num=196, train_loss=0.617, val_loss_step=0.619, val_loss_epoch=0.619]        torch.Size([50000, 4])\n",
      "torch.Size([50000, 2])\n",
      "torch.Size([50000])\n",
      "Epoch 47:   0%|          | 0/1 [00:00<?, ?it/s, v_num=196, train_loss=0.617, val_loss_step=0.618, val_loss_epoch=0.618]        torch.Size([50000, 4])\n",
      "torch.Size([50000, 2])\n",
      "torch.Size([50000])\n",
      "Epoch 48:   0%|          | 0/1 [00:00<?, ?it/s, v_num=196, train_loss=0.616, val_loss_step=0.618, val_loss_epoch=0.618]        torch.Size([50000, 4])\n",
      "torch.Size([50000, 2])\n",
      "torch.Size([50000])\n",
      "Epoch 49:   0%|          | 0/1 [00:00<?, ?it/s, v_num=196, train_loss=0.616, val_loss_step=0.618, val_loss_epoch=0.618]        torch.Size([50000, 4])\n",
      "torch.Size([50000, 2])\n",
      "torch.Size([50000])\n",
      "Epoch 49: 100%|██████████| 1/1 [00:00<00:00,  2.10it/s, v_num=196, train_loss=0.616, val_loss_step=0.618, val_loss_epoch=0.618]"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "`Trainer.fit` stopped: `max_epochs=50` reached.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 49: 100%|██████████| 1/1 [00:00<00:00,  2.09it/s, v_num=196, train_loss=0.616, val_loss_step=0.618, val_loss_epoch=0.618]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/var/folders/ky/4qby95090jbbq38_mh94x72r0000gn/T/ipykernel_69550/494113661.py:57: UserWarning: Matplotlib is currently using module://matplotlib_inline.backend_inline, which is a non-GUI backend, so cannot show the figure.\n",
      "  fig.show()\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 800x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "class CrossEntropyModel(pl.LightningModule):\n",
    "    def __init__(self, input_features: int, learning_rate=0.01):\n",
    "        super().__init__()\n",
    "\n",
    "        self.classifier = nn.Linear(input_features, 1)\n",
    "\n",
    "        # Define loss function\n",
    "        self.criterion = nn.CrossEntropyLoss()\n",
    "\n",
    "        # Define optimizer\n",
    "        self.learning_rate = learning_rate\n",
    "        self.optimizer = torch.optim.Adam(self.parameters(), lr=learning_rate)\n",
    "\n",
    "        # training logs\n",
    "        self.log_train = []\n",
    "        self.log_val = []\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = self.classifier(x)\n",
    "        x = torch.concat([torch.special.logit(1 - torch.special.expit(x)), x], dim=1)\n",
    "        return x\n",
    "\n",
    "    def training_step(self, batch, batch_idx):\n",
    "        x, y = batch\n",
    "        y_hat = self(x)\n",
    "        print(x.shape)\n",
    "        print(y_hat.shape)\n",
    "        print(y.shape)\n",
    "        loss = self.criterion(y_hat, y.type(torch.long))\n",
    "        self.log(\"train_loss\", loss, prog_bar=True, on_step=True)\n",
    "        self.log_train.append(loss.detach().cpu().numpy())\n",
    "        return loss\n",
    "\n",
    "    def validation_step(self, batch, batch_idx):\n",
    "        x, y = batch\n",
    "        y_hat = self(x)\n",
    "        loss = self.criterion(y_hat, y.type(torch.long))\n",
    "        self.log(\"val_loss\", loss, prog_bar=True, on_step=True)\n",
    "        self.log_val.append(loss.cpu().numpy())\n",
    "\n",
    "    def configure_optimizers(self):\n",
    "        return self.optimizer\n",
    "\n",
    "\n",
    "model_lightning = CrossEntropyModel(learning_rate=1e-1, input_features=m)\n",
    "\n",
    "start_time = timeit.default_timer()\n",
    "train_torch_model(model_lightning, epochs=50, accelerator=\"cpu\")\n",
    "model_times[\"logistic_reg_ce\"] = timeit.default_timer() - start_time\n",
    "\n",
    "plot_training_logs(model_lightning)\n",
    "\n",
    "y_train_est, y_true_train = predict_data_loader(model_lightning, train_loader)\n",
    "y_test_est, y_true_test = predict_data_loader(model_lightning, test_loader)\n",
    "model_outputs[\"logistic_reg_ce\"] = [y_train_est.numpy(), y_test_est.numpy()]\n",
    "model_parameters[\"logistic_reg_ce\"] = model_lightning.parameters()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Cross Entropy 2 classes\n",
    "\n",
    "The final model uses `CrossEntropyLoss` in the normal way. We create an output layer with 2 nodes. Therefore this model has twice as many parameters as before."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "GPU available: True (mps), used: True\n",
      "TPU available: False, using: 0 TPU cores\n",
      "IPU available: False, using: 0 IPUs\n",
      "HPU available: False, using: 0 HPUs\n",
      "\n",
      "  | Name       | Type             | Params\n",
      "------------------------------------------------\n",
      "0 | classifier | Linear           | 10    \n",
      "1 | criterion  | CrossEntropyLoss | 0     \n",
      "------------------------------------------------\n",
      "10        Trainable params\n",
      "0         Non-trainable params\n",
      "10        Total params\n",
      "0.000     Total estimated model params size (MB)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 49: 100%|██████████| 1/1 [00:00<00:00,  2.01it/s, v_num=197, train_loss=0.616, val_loss_step=0.618, val_loss_epoch=0.618]"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "`Trainer.fit` stopped: `max_epochs=50` reached.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 49: 100%|██████████| 1/1 [00:00<00:00,  2.00it/s, v_num=197, train_loss=0.616, val_loss_step=0.618, val_loss_epoch=0.618]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/var/folders/ky/4qby95090jbbq38_mh94x72r0000gn/T/ipykernel_69550/494113661.py:57: UserWarning: Matplotlib is currently using module://matplotlib_inline.backend_inline, which is a non-GUI backend, so cannot show the figure.\n",
      "  fig.show()\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAArEAAAIECAYAAAAO3XbrAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAABjHElEQVR4nO3deXxU1f3/8dedfbIHsgGyyC5uIChad0FF3JXWVkWtYrW4V622Vq1aXKrWllZbfoq2VfyqtdqitWpdqhQUVEARZJc1siRkm0xmv78/7iQkbLIkc3OT9/PxuI+5c+fO3M/kkPad47nnGKZpmoiIiIiIOIjL7gJERERERPaUQqyIiIiIOI5CrIiIiIg4jkKsiIiIiDiOQqyIiIiIOI5CrIiIiIg4jkKsiIiIiDiOx+4CMimRSFBTU4Pf78flUn4XERERaW9SqRTRaJT8/Hw8np1H1U4VYmtqali1apXdZYiIiIjIt+jTpw9du3bd6eudKsT6/X7A+qEEg8E2v14ymWTp0qUMHDgQt9vd5teT1qX2cz61ofOpDZ1PbehsdrRfQ0MDq1atasptO9OpQmzjEIJgMEhWVlabXy+ZTAKQlZWlX1wHUvs5n9rQ+dSGzqc2dDY72+/bhn5qYKiIiIiIOI5CrIiIiIg4jkKsiIiIiDiOQqyIiIiIOI5CrIiIiIg4jkKsiIiIiDiOQqyIiIiIOI5CrIiIiIg4jkKsiIiIiDiOQqyIiIiIOI5CrIiIiEg7FY1G2bBhg91ltEsKsSIiIiLt1IUXXsisWbP26r2nn34606dP3+caNm/ezJAhQ1i3bt0OX//973/P+PHj9/k6e8qT8SuKiIiIyG6pqqra6/f+61//asVK2h+FWBEREemUTNOkIZ7M6DWDXjeGYezWuZdffjnl5eXcfffdPP3009TV1TFixAg++OADfvSjH3HhhRfy4IMPMmfOHDZt2kRubi4XXXQRV199NQAnnXQS1157Leeddx7jx49n6NChzJ07l0WLFlFWVsZ1113H2LFj2/LrtimFWBEREel0TNNk3J8+4rPVe9/TuTdG9C7kb1cftVtB9umnn24Koj169OCSSy6hb9++PPjgg0SjUR555BHWrVvHyy+/TG5uLm+//TbXX389p512Gr17997u81566SWeeeYZ+vfvz+OPP85dd93FqFGj8Pv9bfFV25zGxIqIiEintHv9oe3LuHHj8Hq95OTkcN111/Hb3/6WnJwcNmzY0BRGN23atMP3nnrqqQwZMgSfz8e5555LXV0dlZWVmSy/VaknVkRERDodwzD429VHtevhBDtSUlLStF9ZWcmkSZNYtGgR++23HwcddBAAqVRqh+8tLi5u2vd4PLs81wkUYtvIlvoY10z7jOFdkwwdanc1IiIisi3DMMjyOSsKNQ/AN9xwAyeddBJTp07F4/FQVVXFSy+9ZGN1meWslnOQ+Wur+GjlFiqqvdxkdzEiIiLiSD6fj7q6uh2+VldXRyAQwO12s2XLFiZNmgRAPB5vk1oqKiqaenAblZWVARCLxbabzzYQCFBQUNAmtYBCbJtp/MsuHHduN72IiIjYa9y4cTz22GPk5eVt99oDDzzA/fffz9NPP01+fj5jx45lyJAhLF26lGOOOabVa7ngggu2O/bFF18AMH/+fI4//vgWr40dO5bHHnus1etopBDbRnL8jSHWtLkSERERcaoJEyYwYcKEHb527LHH8u9//3un733vvfea9p999tkWr+23334sWbJkt2ooLi5m0aJFuN3uHb5+3XXXcd111+3WZ7UmzU7QRvICXgAaFGJFREREWp16YttIrt/FSa65LEz2IZFM7fSvFxERERG7VFZWMnr06J2+bpomU6dOzWBFu08hto3kbv6Mp32P8J/kcELRcfh9XrtLEhEREWmha9euzJs3b6evJ5NJ5s+fn7mC9oCGE7QRTzICwH7GZkLRhM3ViIiIiHQsCrFtJZAPQK4Rpi6iECsiIiLSmhRi24rfmgojF4VYERERkdamENtWAlaIzaGBUKRtJh0WERER6awUYttKuifWbZg01NfaXIyIiIhIx6IQ21a8QZJY02pFQ9X21iIiIiLSwSjEthXDIOLOASARrra3FhEREXGkaDTKhg0b9vlzVq1ate/FtDMKsW0o6s4GFGJFRERk71x44YXMmjVrnz7jvffe44orrtjt80866SReeeWVHb42e/ZsBg0atE/1tBYtdtCG4t5ciEGqQWNiRURE2h3ThHg4s9f0ZoFh7PbpVVVV+3zJ6upqTNPc589pbxRi21DSaw0nMKMKsSIiIu2KacLTp8La2Zm9bs8j4fI3dyvIXn755ZSXl3P33Xfz5Zdfcv755/Pggw+yePFiCgsLufDCC7n00ksxDIONGzdyxx138MUXXxAIBDjkkEO46667+Prrr7n77ruJx+MMGzaMN998k9LS0gx80ban4QRtKOmzZigwFGJFRETaod3vEbXD008/Tffu3bnnnnu46qqruPTSSxkzZgyzZs3iiSee4Pnnn+fFF18E4De/+Q1lZWXMnDmTN954g3A4zP/7f/+PkSNHcs8999C9e3fmzZvXYQIsqCe2baWn2XLF6mwuRERERFowDKtHtJ0PJ2g0ffp0+vXrx0UXXQRA//79ueKKK3juuef4/ve/j9/v55NPPuFf//oXRx11FE899RQuV8fuq1SIbUNGesEDTzxkcyUiIiKyHcMAX7bdVeyW9evXs3DhQkaMGNF0LJVK4XZb03n+4he/YMqUKUydOpXbb7+dwYMH84tf/KLF+R2NQmwbcgXzAfAmFGJFRERk75WVlTFy5EimTp3adKyqqor6+noAFi1axAUXXMB1113Hli1bePzxx7n22mv5+OOP7Sq5zXXsfmabebKsEOtPKsSKiIjInvP5fNTV1XHmmWcyf/58pk+fTiKRYNOmTVx99dU8+OCDAPzpT3/ivvvuIxQKkZeXRzAYpLCwEAC/309DQwOJRGK3r1tbW8uGDRvYsGEDlZWVbNiwgVgs1vR642uN26ZNm1r3i+8G9cS2IV92AQCBVD2maWLsxRgYERER6bzGjRvHY489xoIFC3jqqad45JFH+NWvfoXb7eaEE07gjjvuAODee+/lnnvuYdSoUcRiMQ466CB+97vfAXD44YfTtWtXDj/8cF544YXdmuf1gQce4IEHHmhx7Mknn8Tv9wNw/PHHt3itqKiImTNntsZX3m0KsW3Il+6JzSVMQzxJlk8/bhEREdl9EyZMYMKECU3Pp02btsPzSkpKePzxx3f62uuvv77b13zvvfea9pPJJPPnz2fo0KFN42+XLFmy25/VljScoA35cwoAK8SGIrvfhS8iIiIiu6auwbaUnp0glzC1kQQleTbXIyIiIp3aeeedx9dff73T15988knHzGigENuW0vPE5hoNrIrEbS5GREREOrtXXnnF7hJajYYTtCX/1p7YkEKsiIiISKtRiG1LjYsdGCnC9Vq1S0RERKS1KMS2JW82yfSPOBKqsrkYERERkY5DIbYtGQYNRhYA8fpqe2sRERER6UAUYttYxJUOseEamysRERER6TgUYttY1JUNQEohVkRERKTVKMS2sZjb6ok1owqxIiIiIq1FIbaNxT1WTyyRWnsLEREREelAFGLbWCIdYl0xTbElIiIi0loUYttYymuFWHdcIVZERESktSjEtrGUNwcAr0KsiIiISKtRiG1rPqsn1peot7kQERERkY5DIbaNGX4rxAZSIZsrEREREek4FGLbmNuXC0BWKkw8mbK5GhEREZGOQSG2jbkCVk9srhEmFEnYXI2IiIhIx6AQ29Z81o1duTQQiirEioiIiLQGhdg2lvRs7YmtjcRtrkZERESkY1CIbWPJ9DyxuYSpa1CIFREREWkNCrFtrLEn1mckCddrmi0RERGR1qAQ28ZSniApDAAi9VtsrkZERESkY1CIbWuGi4grC4BYfY3NxYiIiIh0DAqxGRB1WzMUxOur7S1EREREpINQiM2AWDrEJhvUEysiIiLSGhRiMyDutUJsSiFWREREpFUoxGZAKr30rBGttbkSERERkY5BITYDUr48AIxonc2ViIiIiHQMCrGZELBCrDumECsiIiLSGhRiM8CVDrGeuEKsiIiISGtQiM0AVzAfAF8yZHMlIiIiIh2DQmwGeLMLAAgoxIqIiIi0CoXYDPBlWT2xwVQ9pmnaXI2IiIiI8ynEZoA/txCAHMKEY0mbqxERERFxPoXYDPBlFQCQS5hQNGFvMSIiIiIdgEJsBhgBazhBrtFAXSRuczUiIiIizqcQmwnpKbZyaaA2op5YERERkX2lEJsJfivE+o049fX1NhcjIiIi4ny2hNjKykomTpzIiBEjGDlyJJMmTSKR2HEP5V/+8hdOOukkDjvsMM4880zeeuutFq8/+eSTHHfccQwdOpTx48ezcuXKTHyFPePLbtqN1FXbV4eIiIhIB2FLiL3xxhvJyspixowZvPzyy3z00Uf8+c9/3u68Dz74gClTpvDUU08xd+5crr32Wm688UbWrVsHwKuvvsqzzz7L1KlTmT17NgceeCDXX399+5vGyuWmwcgCIFpfZXMxIiIiIs7nyfQFV69ezZw5c/jwww8JBoP07NmTiRMn8vDDDzNhwoQW565cuRLTNJs2t9uN1+vF47HKfumll7jwwgsZMGAAADfffDMvvfQSs2fP5sgjj9xpDclkkmSy7ae6arxGMpkk4s4mmAgTC1Vl5Nqy75q3nziT2tD51IbOpzZ0Njvab3evlfEQu2zZMgoKCigtLW061q9fP8rLy6mtrSUvL6/p+Omnn84rr7zC2LFjcbvdGIbBww8/TFlZGQDLly/nyiuvbDrf6/XSp08fFi9evMsQu3Tp0jb4Zju3YMECyghQCGwu/5r58+dn9PqybxYsWGB3CbKP1IbOpzZ0PrWhs7XH9st4iK2vrycYDLY41vg8HA63CLHxeJzBgwczadIkBg8ezGuvvcYdd9xBv379GDRo0A4/KxAIEA6Hd1nDwIEDycrKaqVvtHPJZJIFCxZw8MEHs+n9AgitpSDgZujQoW1+bdl3zdvP7XbbXY7sBbWh86kNnU9t6Gx2tF84HN6tDseMh9isrCwaGhpaHGt8np2d3eL4fffdx2GHHcYhhxwCwPnnn8/rr7/Oq6++yu23304wGCQSibR4TyQS2e5ztuV2uzP6i+R2u0n60uE8WqdfYofJ9L8XaX1qQ+dTGzqf2tDZMtl+u3udjN/YNWDAAKqrq6moqGg6tmLFCsrKysjNzW1xbnl5ObFYrMUxj8eD1+tt+qxly5Y1vRaPx1m1ahUDBw5sw2+wd1I+67sZ0VqbKxERERFxvoyH2D59+jB8+HDuv/9+QqEQa9eu5YknnmDcuHHbnXvSSSfx3HPPsXDhQlKpFG+++SazZ89m7NixgNUz+9xzz7F48WKi0SiPPvooRUVFjBgxItNf69ulFzxwx+tsLkRERETE+TI+nABg8uTJ3HvvvYwaNQqXy8U555zDxIkTARg2bBj33HMPZ511Ftdeey1ut5vrrruOmpoaevfuzeOPP84BBxwAwLhx46irq+Oaa65hy5YtHHzwwUyZMqWpp7Y9aVx61hNTiBURERHZV7aE2KKiIiZPnrzD1+bNm9e07/F4uO6667juuut2eK5hGFx++eVcfvnlbVJna3IHrZ5YbyJkcyUiIiIizqdlZzPEk1UAgD+pECsiIiKyrxRiM8SXXQBAIFVvbyEiIiIiHYBCbIb4cwoByDbriSdTNlcjIiIi4mwKsRkSyCkAIJcG6iIJe4sRERERcTiF2AxpHBObZ4QJKcSKiIiI7BOF2EzxW7MT5BKmNhK3uRgRERERZ1OIzZT0YgcBI06oPmxzMSIiIiLOphCbKemeWIBIqNq+OkREREQ6AIXYTHG5aTCCAERDW2wuRkRERMTZFGIzKOrKAiDeUGtzJSIiIiLOphCbQVFPDgCJ+mp7CxERERFxOIXYDIp7cgFINNTYXImIiIiIsynEZlDCa/XEEtFwAhEREZF9oRCbQSlfeoaCqEKsiIiIyL5QiM0gMz3NlkshVkRERGSfKMRmkJFe8MATr7O5EhERERFnU4jNIFcwHwBvImRzJSIiIiLOphCbQZ4sK8T6FGJFRERE9olCbAZ5swsACKTq7S1ERERExOEUYjPInw6xWal6TNO0txgRERERB1OIzaBgbhcAcglTH0vaXI2IiIiIcynEZpAv2xoTm2uECUUSNlcjIiIi4lwKsRlkBNIhlgbqInGbqxERERFxLoXYTEqH2CwjSm24weZiRERERJxLITaT/LlNu5FQtX11iIiIiDicQmwmub1EDD8A0VCVzcWIiIiIOJdCbIZFXDkAxNQTKyIiIrLXFGIzLOrOBiARrrG5EhERERHnUojNsJjH6olNNlTbW4iIiIiIgynEZljCa4XYVEOtzZWIiIiIOJdCbIalfHnWTlQhVkRERGRvKcRmWCo9zZYRq7O5EhERERHnUojNMMNv9cS6FWJFRERE9ppCbIa5gtaqXd6EQqyIiIjI3lKIzTB3sAAAXyJkbyEiIiIiDqYQm2HebKsn1p+st7kSEREREedSiM0wX3YBAMGUemJFRERE9pZCbIYFcgoByDHDxBIpm6sRERERcSaF2AwL5nYBINdoIBRN2FyNiIiIiDMpxGaYO2hNsZVLmLpI3OZqRERERJxJITbTAtaNXTlGhLpw1OZiRERERJxJITbT0osdAITrqu2rQ0RERMTBFGIzzeMjig+ASGiLzcWIiIiIOJNCrA0aXNkAxELV9hYiIiIi4lAKsTaIunMASIRrbK5ERERExJkUYm0Q86RDbEO1vYWIiIiIOJRCrA3i6RCbalBPrIiIiMjeUIi1QdKXa+1Ea+0tRERERMShFGJtkEpPs2VE62yuRERERMSZFGJtYPitnlhXTD2xIiIiIntDIdYGroDVE+uNh2yuRERERMSZFGJt4AoWAOBNKMSKiIiI7A2FWBt4s/MB8CcVYkVERET2hkKsDXzZBQAEUvX2FiIiIiLiUAqxNvDlFACQlQqTSpn2FiMiIiLiQAqxNsjK7QJArhGmPpawuRoRERER51GItUHjcIJcwoSiCrEiIiIie0oh1gZGwLqxK4cIdQ0xm6sRERERcR6FWDukV+xyGSb1dVU2FyMiIiLiPAqxdvAGiOMBIFJXbW8tIiIiIg6kEGuTsCsbgGio2t5CRERERBxIIdYmEVcOAPH6ansLEREREXEghVibxDxWiE00VNtbiIiIiIgDKcTaJJ4OsamGGpsrEREREXEehVibJHy5AJiRWpsrEREREXEehVibpNIh1ogqxIqIiIjsKYVYm5iNc8XG6myuRERERMR5FGJtYgSsEOuJK8SKiIiI7CmFWJu4g9bSs954yOZKRERERJxHIdYmniwrxPqTCrEiIiIie0oh1ia+7AIAAgqxIiIiIntMIdYmjSE2aIbtLURERETEgRRibRLM7QJADmGiiaTN1YiIiIg4i0KsTYK5hQDkEiYUSdhcjYiIiIizKMTapHF2ghwaqGuI21yNiIiIiLMoxNolvdiB2zCpr6uxuRgRERERZ1GItYs3SAI3AA2hLTYXIyIiIuIsCrF2MQzCRjYAkVC1vbWIiIiIOIxCrI0a3FaIjddX21uIiIiIiMMoxNoo6s4BIBGutrcQEREREYdRiLVR3GOF2GRYN3aJiIiI7AmFWBslvLkAmNFamysRERERcRaFWBslfVaIJaIQKyIiIrInFGJtZKbninXFFGJFRERE9oRCrI2MQHrBg1idzZWIiIiIOItCrI1c6RDrTYRsrkRERETEWTx2XLSyspI777yTOXPm4Ha7Oeuss7jtttvweFqWM2HCBD777LMWx8LhMBdccAH33nsvqVSK4cOHY5omhmE0nTNz5kyysrIy8l32hSerAACfQqyIiIjIHrElxN54442UlpYyY8YMKioq+PGPf8yf//xnJkyY0OK8p556qsXzl19+mT/84Q9ce+21ACxfvpx4PM7cuXPx+XwZq7+1eLMLAAgkFWJFRERE9kTGhxOsXr2aOXPmcOuttxIMBunZsycTJ05k2rRpu3zfypUrue+++3jkkUcoKSkBYMGCBQwaNMiRARbAlw6xwVS9vYWIiIiIOEzGe2KXLVtGQUEBpaWlTcf69etHeXk5tbW15OXl7fB999xzD+eccw4jRoxoOrZgwQKi0Sjnn38+69evp1+/ftx8880cdthhu6whmUySTCZb5wt9y3WaP27Ln2V912zCxOMJXC5jh+eJPb6t/aT9Uxs6n9rQ+dSGzmZH++3utTIeYuvr6wkGgy2ONT4Ph8M7DLGffvopn3/+OY888kiL44FAgEMOOYQbbriB/Px8pk2bxhVXXMH06dPp2bPnTmtYunRpK3yT3bdgwYIdHndXb6ILkEuYjz+bR5ZX99m1RztrP3EOtaHzqQ2dT23obO2x/TIeYrOysmhoaGhxrPF5dnb2Dt/z4osvctppp1FcXNzi+O23397i+RVXXMErr7zCBx98wMUXX7zTGgYOHJiRG7+SySQLFizg4IMPxu12b/e6WVMMMyCHBvr0H0z3wvZ/M1pn8m3tJ+2f2tD51IbOpzZ0NjvaLxwO71aHY8ZD7IABA6iurqaiooKioiIAVqxYQVlZGbm5ududn0gkePfdd3n88ce3e+2xxx7j1FNPZciQIU3HYrEYfr9/lzW43e6M/iLt9HrZXQDwGCkaGsK4i7b//mK/TP97kdanNnQ+taHzqQ2dLZPtt7vXyfh/v+7Tpw/Dhw/n/vvvJxQKsXbtWp544gnGjRu3w/OXLFlCNBrd4TjXpUuXMmnSJDZv3kwsFuMPf/gDoVCIk08+ua2/RuvwZZNIN0EktMXmYkREREScw5ZBmJMnTyaRSDBq1Ci+973vceyxxzJx4kQAhg0bxvTp05vOXbt2Lfn5+TvsXX3ggQfo1asXZ599NiNHjmTOnDk888wzFBQUZOqr7BvDoMGwhhA01FXZXIyIiIiIc9gyT2xRURGTJ0/e4Wvz5s1r8XzMmDGMGTNmh+cWFBTwwAMPtHp9mdTgyiY3GSJWX213KSIiIiKOodvhbRZ15wCQqK+xuRIRERER51CItVnMkw6xDdX2FiIiIiLiIAqxNounQ2yqodbmSkREREScQyHWZkmftbiDEVWIFREREdldCrE2M/3puWEVYkVERER2m0Ks3QJWT6w7VmdzISIiIiLOoRBrMyOQD4A3rhArIiIisrsUYm3mCaZDbCJkcyUiIiIizqEQazNPVgEAgaRCrIiIiMjuUoi1mS+nAIBgqt7eQkREREQcRCHWZoGcQgCyTIVYERERkd2lEGuzYK4VYnMIE4knba5GRERExBkUYm0WTA8nyKWBUCRubzEiIiIiDqEQazN34+wERpJQSNNsiYiIiOwOhVi7+XJIYQAQrtticzEiIiIizqAQazeXizBZAETrqu2tRURERMQhFGLbgQaXFWIjoWp7CxERERFxCIXYdiDizgEgFq62txARERERh1CIbQeiHivEJhtqbK5ERERExBkUYtuBRDrEphRiRURERHaLQmw7kPDlAmBGam2uRERERMQZ9jnErlixgo0bN7ZGLZ1WypcHgCuqECsiIiKyO/Y4xM6dO5dzzjkHgBdeeIHTTz+dUaNG8c4777R2bZ2H3wqxRkyLHYiIiIjsDs+evuHRRx/lhBNOwDRNpkyZwoMPPkhBQQGPPvooo0ePbosaOzwjYIVYb1whVkRERGR37HFP7MqVK7nhhhtYuXIlFRUVjB07lhNOOIF169a1RX2dgqtx6dlEyOZKRERERJxhj0Os2+2mvr6eDz/8kKFDh+Lz+Vi/fj05OTltUV+n4M0qAMCvECsiIiKyW/Z4OMHo0aO5+OKLWb9+Pb/4xS9Yvnw511xzDWeccUZb1Ncp+LILAAik6u0tRERERMQh9jjE3nnnnfzzn/8kEAgwduxYVq1axfe//30uueSStqivU/DlFACQpRArIiIislv2OMS63W7OPvts3G43AKtXr2b48OFNz2XPBXMLAcgmTDJl4nYZNlckIiIi0r7t8ZjY9957j2OPPRaAJ554guuuu47x48fz0ksvtXpxnUV2XhcAcglT0xC3uRoRERGR9m+PQ+wf//hHbrzxRlKpFM899xy///3vmTZtGk8++WRb1NcpNI6J9RsJKqurba1FRERExAn2eDjBmjVr+N73vseiRYtoaGjg6KOPxuPxUFFR0Rb1dQ7+PGJ48JGgdvM30KPE7opERERE2rU97okNBoNUVlby3nvvMXz4cDweD4sXL6awsLAt6uscDIMatzWkIFRVbnMxIiIiIu3fHvfEnn/++ZxzzjnU1tYyefJkvvzySyZMmMDll1/eFvV1GvWeLhQnNxGt+sbuUkRERETavT0Osddddx1HHHEEfr+foUOH8s0333DvvfdyyimntEV9nUY0UARRSNZttLsUERERkXZvj0MswEEHHcQHH3zAJ598QnFxMSeddFJr19XpJLKKoQZcoU12lyIiIiLS7u1xiF29ejWXXXYZ8Xic7t27U15ezq9//Wv+8pe/MGDAgLaosXPILgXA07DZ5kJERERE2r89vrHrgQceYMyYMXz44Ye89NJLfPjhh5x99tk8+OCDbVFfp+HJLwMgGNUsDyIiIiLfZo9D7Oeff85NN92Ey2W91eVyccMNN/D555+3enGdSaCgGwDZiS02VyIiIiLS/u1xiHW73YRCoRbHQqEQwWCw1YrqjLK7WiG2IFVFKmXaXI2IiIhI+7bHIfbEE0/k5ptvZuXKlcRiMVasWMGtt97KiSee2Bb1dRp5RfsBUEwN1eGYzdWIiIiItG97HGJvvvlmEokEY8eO5dBDD+WMM87A5/Nxyy23tEV9nYYv37qxK8uIUlmlIQUiIiIiu7LHsxMUFBTw7LPPsnbtWiorK+nRowfFxcVtUVvn4s8hTJAsGqjdvA56drO7IhEREZF2a7dD7CeffLLD46tWrWLVqlUAHH744a1SVGdV4y4kK9lAeIuWnhURERHZld0OsePHj9/l64Zh8NVXX+1zQZ1Z2NcVGsqJVm+wuxQRERGRdm23Q+zixYvbsg4Bov6u0AApLT0rIiIiskt7PCZ2Z8MKvF4vXbp0oVevXvtcVGeVzCqBajDqtfSsiIiIyK7scYi9/fbbKS8vx+VyUVhYSFVVFalUCpfLRTKZpG/fvkyZMoWePXu2Rb0dW641Q4FPS8+KiIiI7NIeT7F11llncdZZZzFnzhz+97//8cknnzBu3DiuvfZaPvvsM4455hgmTZrUFrV2eN689NKzsUqbKxERERFp3/Y4xP7jH//gl7/8JdnZ2QBkZWXx85//nBdffJHs7Gxuvvlm5s6d2+qFdgbBQmtarVwtPSsiIiKyS3scYsPhMLW1tS2O1dXVtViK1jCMfa+sE8ru2gPQ0rMiIiIi32aPQ+yYMWO45pprmDVrFqtWrWLWrFlcf/31nHLKKYRCIe6++25GjBjRFrV2ePnF3QHoSg1V9RGbqxERERFpv/b4xq6f//znTJo0iWuuuYaGhgYCgQDjxo3j5ptvZuHChdTW1vLLX/6yDUrt+Lx56Ru7jCRbKjfTNVczPYiIiIjsyB6HWL/fz7333stdd91FdXU1Xbt2bRo+MGLECPXC7guPn1ojlzyzjrqKddBHIVZERERkR/Y4xAK88847vPjii6xfv57i4mLGjRvHmWee2dq1dUq17kLyEnVaelZERERkF/Z4TOxrr73G7bffzsCBAxk/fjxDhgzhl7/8JX/729/aor5Op95XBEC8RkvPioiIiOzMHvfEPvnkk/zhD3/gyCOPbDp2/PHHc++99/Ld7363VYvrjGKBIghDUkvPioiIiOzUHvfElpeXM3LkyBbHjjjiCDZsUM9ha0hlFQPg0tKzIiIiIju1xyG2rKyMTz75pMWxTz75hO7du7daUZ2ZkdO49GyFzZWIiIiItF97PJzg0ksv5ZprruGCCy6gZ8+erFmzhhdffJGf/exnbVFfp+MpsJaezdLSsyIiIiI7tcch9rvf/S5ut5tXXnmFd955hx49evCrX/2KMWPGtEV9nU5WodWjnZtQiBURERHZmb2aYuu8887jvPPOa3qeTCb5+uuv2X///VutsM4qt8gKsV3MalIpE5dLS/iKiIiIbGuPx8TuSEVFBWPHjm2Nj+r08or3A6CQOqpCYZurEREREWmfWiXEApim2Vof1al5c4pI4sJlmGzZrAUPRERERHak1UJs49Kzso9cbqqNfABCFQqxIiIiIjvSaiFWWk+dpwsADVUKsSIiIiI7sts3dm07N2xzW7ZsaZVixBL2dYX4CuLVWkBCREREZEd2O8SOHz9+l69rOEHriQWKoR7MkJaeFREREdmR3Q6xixcvbss6pJlUdglUgqt+s92liIiIiLRLGhPbDrlySwDwRRRiRURERHZEIbYd8uWnl56Na9UuERERkR1RiG2HgumlZ/MSumFOREREZEcUYtuhvOIegLX0bDKlRSREREREtqUQ2w7lp5eezTPCVNXW2lyNiIiISPujENsOebIKiKUnjqjatN7makRERETaH4XY9sgwqDIKAaivVIgVERER2ZZCbDvVuPRspOobmysRERERaX8UYtupBn8RAPEahVgRERGRbSnEtlPxgBVizdAmmysRERERaX8UYtupVI61apdbS8+KiIiIbEchtp1y5ZYC4ItW2FyJiIiISPujENtO+Qu6AZAd09KzIiIiIttSiG2ngoVWiM1LaulZERERkW0pxLZTeUXW0rNdzWqSyZTN1YiIiIi0Lwqx7VRBsRVig0aMqir1xoqIiIg0pxDbTnmCuYQIAlBdoVW7RERERJpTiG3HalwFAIQUYkVERERasCXEVlZWMnHiREaMGMHIkSOZNGkSiURiu/MmTJjAsGHDWmyDBg3irrvuajrnySef5LjjjmPo0KGMHz+elStXZvKrtKmQpysA0Wqt2iUiIiLSnC0h9sYbbyQrK4sZM2bw8ssv89FHH/HnP/95u/Oeeuop5s2b17TdcccddOvWjWuvvRaAV199lWeffZapU6cye/ZsDjzwQK6//npM08zwN2obDX4rxCZqNthciYiIiEj74sn0BVevXs2cOXP48MMPCQaD9OzZk4kTJ/Lwww8zYcKEnb5v5cqV3HfffUydOpWSEms1q5deeokLL7yQAQMGAHDzzTfz0ksvMXv2bI488sidflYymSSZTLbuF9vJdZo/7qlYoBjqwKzbkJF6paV9bT+xn9rQ+dSGzqc2dDY72m93r5XxELts2TIKCgooLS1tOtavXz/Ky8upra0lLy9vh++75557OOeccxgxYkTTseXLl3PllVc2Pfd6vfTp04fFixfvMsQuXbq0Fb7J7luwYMFeva82FQAgWb2e+fPnt2JFsif2tv2k/VAbOp/a0PnUhs7WHtsv4yG2vr6eYDDY4ljj83A4vMMQ++mnn/L555/zyCOPfOtnBQIBwuHwLmsYOHAgWVlZe1P+HkkmkyxYsICDDz4Yt9u9x++fu3oAVEIedRwydGjrFyi7tK/tJ/ZTGzqf2tD51IbOZkf7hcPh3epwzHiIzcrKoqGhocWxxufZ2dk7fM+LL77IaaedRnFxcYvjwWCQSCTS4lgkEtnp5zRyu90Z/UXa2+sF0qt2Zce36BffRpn+9yKtT23ofGpD51MbOlsm2293r5PxG7sGDBhAdXU1FRUVTcdWrFhBWVkZubm5252fSCR49913Oeuss3b4WcuWLWt6Ho/HWbVqFQMHDmyb4jMsu0t3APK19KyIiIhICxkPsX369GH48OHcf//9hEIh1q5dyxNPPMG4ceN2eP6SJUuIRqMcdthh2712/vnn89xzz7F48WKi0SiPPvooRUVFLcbNOlleetWuLmaNBsSLiIiINGPLFFuTJ08mkUgwatQovve973HssccyceJEAIYNG8b06dObzl27di35+fn4/f7tPmfcuHFcdtllXHPNNRx55JEsWrSIKVOm4PV6M/Zd2lJBkdUT6zWSbKnQNFsiIiIijTI+JhagqKiIyZMn7/C1efPmtXg+ZswYxowZs8NzDcPg8ssv5/LLL2/1GtsDjy9ANbkUUEft5vUUl/awuyQRERGRdkHLzrZz1a5CAOq3aNUuERERkUYKse1cvbcLAJEqhVgRERGRRgqx7VzEXwRAslZjYkVEREQaKcS2c/Fgem7c+o32FiIiIiLSjijEtnc5JQB4wpttLkRERESk/VCIbefceWUABKIV33KmiIiISOehENvO+QuspWdz4lU2VyIiIiLSfijEtnM5XdNLz6a09KyIiIhII4XYdq5x6dkCs45ELGpzNSIiIiLtg0JsO1fYtYyE6cJlmFRXaq5YEREREVCIbffcHg9VRj4ANZvX2VyNiIiISPugEOsANW5r6dmwemJFREREAIVYR6j3dgUgWq1Vu0RERERAIdYRon4rxCbrFGJFREREQCHWERJZ1qpdRmiTzZWIiIiItA8KsU6QXnrW26ClZ0VERERAIdYRPPlaelZERESkOYVYBwg0Lj2b0KpdIiIiIqAQ6wjZXdOrdqWqbK5EREREpH1QiHWAgvTSs7mESUTqba5GRERExH4KsQ5QUFhE1PQCUL15vc3ViIiIiNhPIdYB3G4XlUYBALUVCrEiIiIiCrEOUevuAkB4S7nNlYiIiIjYTyHWIep9VoiNaelZEREREYVYp4j6iwFI1m20uRIRERER+ynEOkQqywqxRr2WnhURERFRiHWK9NKzPi09KyIiIqIQ6xSNS88GY5U2VyIiIiJiP4VYhwgWdgcgN64QKyIiIqIQ6xA5RVaILTCrwTTtLUZERETEZgqxDpGfXno2QIx4Q43N1YiIiIjYSyHWIQrzC6gzgwDUaOlZERER6eQUYh3C7TLY0rj0rEKsiIiIdHIKsQ5S67FW7Wqo0tKzIiIi0rkpxDpI2NcVgFj1NzZXIiIiImIvhVgHiQWKAEjVadUuERER6dwUYh0kmWWt2uUKK8SKiIhI56YQ6yCu3MalZytsrkRERETEXgqxDuLN6wZAVkwhVkRERDo3hVgHCRRaITY3scXmSkRERETspRDrIHlF1qpdBWY1pFL2FiMiIiJiI4VYByko7g6AhxTx+kqbqxERERGxj0KsgxTmZlNp5gJQs2mdzdWIiIiI2Ech1kFcLoPq9NKzdZVaelZEREQ6L4VYh2laenaLVu0SERGRzksh1mHCPmvVrniNQqyIiIh0XgqxDhNPLz1r1m20uRIRERER+yjEOkwyp3HpWS14ICIiIp2XQqzDuNMh1hfZbHMlIiIiIvZRiHUYX0Hj0rOaJ1ZEREQ6L4VYhwkWWgse5CW19KyIiIh0XgqxDpNX3Lj0bC0k4zZXIyIiImIPhViHKSwqI2FazRav1QwFIiIi0jkpxDpMQZafCvIBqNlcbnM1IiIiIvZQiHUYl8ug2lUIQGjzGpurEREREbGHQqwDbfJa42Ljm5bYXImIiIiIPRRiHagmd4C1s3GhvYWIiIiI2EQh1olKhgCQVb3U5kJERERE7KEQ60B5vQ8FoDiyCpIJe4sRERERsYFCrAP17DuYetOPjzipiuV2lyMiIiKScQqxDtS7KJdl9ASg8ut5NlcjIiIiknkKsQ7kdhls9PcFoHb15zZXIyIiIpJ5CrEOFS4cBICxaZHNlYiIiIhknkKsQ7nLDgQgr3aZzZWIiIiIZJ5CrEMV7j8UgKJ4OcTq7S1GREREJMMUYh1q/9692WzmA5DYoCEFIiIi0rkoxDpUj4Igy+gFQOVKzVAgIiIinYtCrEMZhkFFVj8A6td+YXM1IiIiIpmlEOtg0S6DAfBUfGVzJSIiIiKZpRDrYP7uBwFQUKdVu0RERKRzUYh1sOJ+Q0mZBnmpaghtsrscERERkYxRiHWw/j1KWG2WABArX2BzNSIiIiKZoxDrYEU5Pla6egNQuXK+vcWIiIiIZJBCrIMZhkFVzgAAIuu/tLkaERERkcxRiHW4RNEBAPi3LLa5EhEREZHMUYh1uKz9Dgaga3glpFI2VyMiIiKSGQqxDtet74FETS9+MwJVX9tdjoiIiEhGKMQ63MCyApaZPQBoWKcZCkRERKRzUIh1uPwsL6s9fQCoWjXf1lpEREREMkUhtgOozRsIQOIbzVAgIiIinYNCbEdQYs1QkFW1xOZCRERERDJDIbYDyOl1KABdousgHrG5GhEREZG2pxDbAfTu3ZcqMwcXKahQb6yIiIh0fAqxHUD/0lyWmD0BqFvzuc3ViIiIiLQ9hdgOIMvnYb1vfwBqVyvEioiISMenENtB1OdbMxSwcZG9hYiIiIhkgMeOi1ZWVnLnnXcyZ84c3G43Z511Frfddhsez/blzJkzh4cffpjly5eTl5fHhRdeyFVXXQVAKpVi+PDhmKaJYRhN75k5cyZZWVkZ+z7tgbvbgVAJOTVL7S5FREREpM3ZEmJvvPFGSktLmTFjBhUVFfz4xz/mz3/+MxMmTGhx3ooVK/jRj37E3XffzTnnnMOSJUu49NJL6d27N2PGjGH58uXE43Hmzp2Lz+ez46u0GwW9D4UvIT9RAeEtkNXF7pIyo3oNLJoO8TDkdYe8HtaW3wN82XZXJyIiIm0k4yF29erVzJkzhw8//JBgMEjPnj2ZOHEiDz/88HYh9vnnn2fUqFGce+65AAwePJgXXniBnJwcABYsWMCgQYM6fYAF6NezG+vMIvYzKjA3LsTY/1i7S2o79RWw8FX48u+w5qOdnxfI3xpqGwNufg/o0g/2GwFub+ZqFhERkVaV8RC7bNkyCgoKKC0tbTrWr18/ysvLqa2tJS8vr+n4F198wXe+8x1+8pOfMHPmTLp06cJll13GBRdcAFghNhqNcv7557N+/Xr69evHzTffzGGHHbbLGpLJJMlksm2+4DbXaf7YlnoXBvnI7MV+RgXVq+aT1+s7bX7NjIrWYSz5N8bCl2HF+xim9TM1MaDPMZgFvTDqvoGa9VBXjhGtg0iNtW3afpyw6c/D7DcKBpyC2X80ZHXd7pxMtp+0DbWh86kNnU9t6Gx2tN/uXivjIba+vp5gMNjiWOPzcDjcIsTW1NTw17/+lccee4xf//rXzJs3j6uuuor8/HzGjBlDIBDgkEMO4YYbbiA/P59p06ZxxRVXMH36dHr27LnTGpYuzey40QULFmTkOus8vSA1lw2LZrEyz/kh1kjFyds0hy7r36NgwyxcqWjTa/X5A9nSYxRV3U8gHize7r2ueD2+yGa8DZvxRSrwNWzCG9mMr2EzWTVL8UZrMBa9CotexcSgvvAAakqPoqb0SBpy+0KzMdaZaj9pO2pD51MbOp/a0NnaY/tlPMRmZWXR0NDQ4ljj8+zslmMYfT4fo0aN4oQTTgDg8MMP5+yzz+bf//43Y8aM4fbbb29x/hVXXMErr7zCBx98wMUXX7zTGgYOHJiRG7+SySQLFizg4IMPxu12t/n1Pv/kQNjwDwqj6xk4dGibX6/NNFRhvP8rjIWvYkSqmw6bXfphHnQ+5oHnEygaQHeg+958fipJsnwuxrK3rW3jAnKqFpFTtYgei6di5nXHHHAqyb6jWRAq5KBhh2ek/aT1Zfp3UFqf2tD51IbOZkf7hcPh3epwzHiIHTBgANXV1VRUVFBUVARYN3CVlZWRm5vb4tx+/foRi8VaHEsmk5imCcBjjz3GqaeeypAhQ5pej8Vi+P3+Xdbgdrsz+ouUqev5uh8MGyA/tBy3y9WiN9ExIrXw/Dgon2c9zymDg86Hg8dhdB/WYhaKveZ2Q+8jrW30XdYQhGVvw9K3YOV/MWrLMT57BtdnzzDU5cNYeQrGgefAwFMhkPetHy/tT6Z/56X1qQ2dT23obJlsv929Tsbnie3Tpw/Dhw/n/vvvJxQKsXbtWp544gnGjRu33bnf//73effdd/nnP/+JaZp88sknvPbaa5x99tmANSxg0qRJbN68mVgsxh/+8AdCoRAnn3xypr9Wu1Dc50Dipptgqh5q1tpdzp6LheH5C6wAm9UVLv47/GQRjLkfehy201CeSKZIpsy9v25+DxjxQ7jwBbjta7joZTh8Amb+frhSMYwlr8MrE+DhfvD892H+/0FD1d5fT0RERPaZLVNsTZ48mXvvvZdRo0bhcrk455xzmDhxIgDDhg3jnnvu4ayzzuKoo47iiSeeYPLkydxzzz106dKF2267jVGjRgHwwAMP8NBDD3H22WfT0NDAwQcfzDPPPENBQYEdX8t2A7p1YYXZncHGWpIbFuIu6GV3SbsvEYUXL4I1s8CfD+NfhW6H7vT0TbUR3l28iXe/2sTM5RUkUin2K8yid9cs+nTNbvG4X2EWPs9u/r3mDcKAk2HAyaROfYglH/6dwakluL6aDpXLYOm/rc3lhb4nwJCzYfDpnWdKMxERkXbClhBbVFTE5MmTd/javHnzWjw//vjjOf7443d4bkFBAQ888ECr1+dUvbtm8wY9Gcxaald9TuHg0+wuafck4/C3H8KK98CbDRf9bbsAa5omC8treeerjby3eBNfrKvZ7mO+rqjn64p6YHOL4y4DuhcEm0LtwNJcThxUQq+u3zIu2jBoyO+POXQcjLoTNi+GRf+0tk2LYPl/rO21G2D/46xAe8BZkL39TAciIiLSumwJsdI23C6Dyuz+0DCLyPr2dxfhDqWS8I8fw5J/gdsPP/g/6DUSgIZYklkrKnjnq028t3gjG2ujLd56aM8CRg8u4aQDSijM8rGqsp7VlWFWVdazpjLMqsowqyvrCceSrKtqYF1VA/9bbr33bhYyoCSHkw4oYfQBpRzWqxC3axfjbQ0DSg6wthNuh81L4at0oN2wAFa+b21v3AqDxsDQi6H/aHDrV0xERKQt6P9hO5hE1wNgHXgrv7K7lG9nmvD6TbDgb+DywPf+Cn2PZ11VmHtfW8SHyzYTiaeaTg963Rw7oIjRB5RywuBiSnIDLT6ue0GQ7/Tb9hImm0NRK9xWWCH3s9VVfLJqC8s2hVi2KcSUD1ZSkOXlxEEljDqghOMGFpMX+JaFEIoHQvGtcNytULkCvpoOX74CG76Ar16ztuwSOPQCGHqRFX5FRESk1SjEdjCBngfDOigMr4JEDDztdDUz04S37oC5fwHDBec9CYPGsKYyzA+e/Jj11da0a93zA4w6oJRRB5RwZN+uBLx7dmekYRiU5AYoyQ1weJ+t41ZrGuJ8uHQz7361kfeXbKY6HOfVeet5dd56PC6DI/bvwkmDiulmJr79Il37wTE3WduGL2H+8/DFi1C/CWb93tq6HwZDL4SDx0GwcI++g4iIiGxPIbaD6dFrILWzguQZDVC5HEqHfPub7PDfB+Djx639s34PB53Hqop6fvDkx3xTE6FvUTaTfzCMA7vntc60WtvID3o589DunHlodxLJFJ+truK9xZt456uNrNhcz6wVlcxaUQnAgM/+xykHlnLKkDIO7pGPa1fDDsoOsmZTOPkea9qu+c/D0jehfK61vXUHDB5rDTfodyK4NN2MiIjI3lCI7WAGdstjqdmTEcZSEt98iac9htj//RY+eMjaP+1hGHYxKzaHuPDJj9lYG6VfcTb/d+WRlOQFdvkxrcXjdjGyb1dG9u3Kz8YewKqKet5dvIl3Fm1gztdbhx08/v4KyvICjB5SwilDyjiyb9edz3rg9lqzFgw+HUKbrSET86fBxi9h4avWVtALjvspHPoDjZ0VERHZQ/p/zg6me36AmUYvRrCUmtWf03Xo9+wuqaU5T8I7d1v7o+6GkT9i+aY6fvDkbDbXRRlYmsO0CUdSnLvrBSvaUp+ibK44Zn8uO6oX/5szl0pfGe8u3sx/l2xiQ22E5z5ew3MfryHX7+GEwSWcMqSUEwYVk7uzcbQ5xXDURGv75vP0cIOXoHoNTL8W/veYdbPYQeerZ1ZERGQ3KcR2MIZhUJM7AELvEP/mS7vLaWn+8/DGLdb+sbfAsT9hyYY6LnrqYypCMQaX5TJtwki65tgXYLeV43NxzNDunDe8J5F4ko9WVvL2wo38Z9FGKkJRXvu8nNc+L8frNjiqXxGnHVTGmAPLKMzeyVjkboda26i74dOpVoDdsgJeuRJmPAon/MyapsuV8XVIREREHEUhtgMySw6AEASrlthdylaL/wX/vMbaH3k1nPQLvvqmlouems2W+hhDuuUxbcLInYe/diDgdXPioBJOHFTCpHMOYv66at5euJG3F21g5eZ6Ply6mQ+XbubOf3zJsQOKOPPQ7pw8pHTHPbS+LPjOdTD8hzBnCsycbM1D+7dLofRgOPHnMOg0Zy4dLCIikgEKsR1Qdq9DYSXkR7+BSC0E8uwtKLwFpl8HZgqGXQynPsCX5bVcPHU21eE4B/fI59krjqAgq/0G2G25XAaH9SrksF6F3H7aYJZvCvHWwg3864tvWPRNLe8v2cz7Szbj87g4aVAJZx7anZMGlxD0bTNcwJ8Dx94Mh0+Aj56Ajx6HjQvghR9YMxqceAf0H6UwKyIisg2F2A5o//32Y4NZSJlRBZu+alo8wDb/uRPClVAyBM74LV+U13LxU7OpjSQY2rOAv1x+BPnBb5mXtZ3rX5JD/5L+XHNif5ZvCvH6F+VM/7yclZvreXPhBt5cuIEsn5vRB5Ry5qHdOW5gEX5Ps0AbyIcTfwYjr4JZk2H2FGs2g2nnQ88j4aRfwP7H2vcFRURE2hkNvOuABpTmsiTVE4BYuc3jYlf9D+Y9Z+2f+TvmrQ9xUTrADu9dyLNXOD/Abqt/SQ43jh7Iuz85njeuP5Yfn9CP/QqDhGNJpn9ezpV//ZQRv3qHn7+6IL1MbjNZXWD0L+GGL+Coa8ETgLUfw1/OgH9MhMj2y+2KiIh0RgqxHVBRjo/Vnj4A1K75wr5CElF47UZrf8TlfJbqz/ipc6iLJDiiTxf+cvkRO7+jvwMwDIMh3fO4bcxgZvz0RF6d+B0uP3p/SvP81EUSPD97DSc9+l+umTaXL9dvE05ziuHUSXD9fBhxBWBYU3Q98R1Y+V8bvo2IiEj7ohDbARmGQV3+QADMjQvtK+R/v4XKZZBdwvyBN3DJ1DmEogmO7NuFP19+ODn+zjOaxTAMhvUq5K4zh/DR7aN4/sqRjBpcgmnCvxZ8wxm//x/jp85m1ooKTNPc+sa8bnDGb+CH/4bCPlC7Dv56NvzrFojV7/R6IiIiHZ1CbAflKj0QgOzqJdYSr5lWsRxmPAJAw+hJTPz7CupjSY7u35VnLjuCLF/nCbDbcrkMvtOviKmXHc6bNx7LOUO743YZzFhWwYVPzuacJ2bx5pcbSKWatVvvo+DqmdYNYACfPAl/OgbWzLbnS4iIiNhMIbaDKux9IEnTICtZC3UbMntx04TXb4RkDPqP5ldfD6a8JkKvLlk8ecmI7e/Q78QGl+Xx2+8P47+3nMAlR/XG73Hx+dpqrn7uM0Y/9gEvfbqWWCJlnezPgdMfhYtfgdzusGUlPDMG/nO3NXRDRESkE1GI7aD6dy9mlVlmPdmU4SEFn78Aq2aAJ8hnB/2CaXPWAvDQ+Yd06h7YXenZJYt7zz6ImbefxLUn9ic34GHl5np++vIXHP/w+0z939dbw2z/UTDxI2u5WjMFM38L/+8EazUwERGRTkIhtoMaUJrLYtOaoSCyfkHmLlxfCW/9HIDYsbdy09vVAFw0shdH9euauTocqijHzy2nDmLW7Sfxs9MGU5zr55uaCPe9vojTJ8/gs9VbrBODBXDun+CCaZBVBJsWwZMnwQcPQzJh63cQERHJBIXYDio/6KXc1xeA+kzOUPCfu6BhC5QM4dc1J7NmS5ju+QFuP21w5mroAHIDXq46vh8zfnoik849iK7ZPpZtCjHuTx/xi38soDYSt0484Ay4ZjYccCakEvD+r2DqyVC5wt4vICIi0sYUYjuwhsJBABibv8rMBb+eAfOtOWEXH34fUz+yhhHcf97BHXoqrbYU8Lq5aGRv3vnJ8Xx3+H6YJjz38RpO/s0HvPlleqxzdhF871k470lr0YTyudbwgsVv2Fq7iIhIW1KI7cC83Q8CIK9uRdv/J+ZEFF6/ydo97Idc86EH04Rxw/fjhEElbXvtTqAw28fD3z2U5yeMpE/XLDbWRrn6uc/40V8/ZUNNxFqW9pDvwY8/slb4itZaS9e+fz+kUnaXLyIi0uoUYjuw4l6DCZt+PGYMqr5u24s1mxP2cddFrNhcT3GunztPH9K21+1kvtO/iDdvPI5rTuyHx2Xw9qKNjP7NBzz70SprSq78HnDpa3DEVdYbPngI/u8CaKiyt3AREZFWphDbgQ0sy2Op2cN60paLHjSbE3bNEXcxedZmACadcxD5WRpG0NoCXje3njqY1647hqE9CwhFE9z5z4WM+9MslmyoA48Pxv4azp1iLVu77G1reMEGm5cgFhERaUUKsR1Y/5IclqZnKAh/3UaT4jebEzbVbxQ/mtuLZMrkjEO6ccqBZW1zTQHggG55/P3H3+Gesw4k2+dm7ppqTp88g0feWkIknoRDvw9XvA0FvaBqFTw1Gr74m91li4iItAqF2A4sy+dhcdZwAAJzn4Jv2mCWgmZzwv6l8HoWbwzRJdvHPWcd2PrXku24XQaXfqcP//nJ8Yw+oJREyuQP7y/n3CdmsWJzCLodCj/6APqdBIkGeGUC/Pt2SMbtLl1ERGSfKMR2cGu7j+U/yeG4UjF4+XKI1bfehzebE3bT8Bu5/6MwAL8860C65vhb7zryrboXBHnykuH88aLD6JLt46tvajnz9//j1XnrIKsLXPQyHHuzdfLsP8Jfz4a6jfYWLSIisg8UYju4A7rnc2v8R1S4ulo3Xv37ttb5YNO0AmzDFsziA7hq+ZHEkyYnDynlzEO6tc41ZI8YhsFpB3fj3zccy5F9uxCOJbnpxc+59W+fE06YMOouuOA58OXC6pnw/46HtXPsLltERGSvKMR2cBeN7EUqUMi1kR9jYsC8Z+HLV/b9g2c8Al+8ABj8o+dPmbe+nryAh1+dcxCGYez758teK80LMG3Ckdw4egAuA/722TrO+sNMFm+otRZFuPI9KBoIdd/AM2Phk6nWHyUiIiIOohDbwZXmBbjvnIP4ODWEJ5JnWwdfuxGqVu/9h376NLz3KwAqjvklt80JAnDnGUMozQvsY8XSGtwugxtHD2TahCMpyfWzfFOIs/8wk/+bswazaIAVZA84E1Jx+NdP4NWrIRa2u2wREZHdphDbCZx1aHdOO6iMx+LnsdA9GKI18PcJe7cAwsJX4fWfAGAeewtXLzuCWCLFcQOLGTd8v1auXPbVUf268sYNx3L8wGKiiRQ/e2UB178wnzozYK3yNfoeMFxWr/pTo7VcrYiIOIZCbCdgGAa/OucgCnKyuCr8YyLubFg3Bz54cM8+aMV78PcrARNGXM5f/Bfx6eoqsn1uHjjvYA0jaKeKcvw8c9nh3H7aYNwug9c+L+eM3/+PBetr4Zgb4ZLpkF0CmxZa88l+9ZrdJYuIiHwrhdhOomuOnwfOO4R1ZjG3RC63Dn74CHw9Y/c+YN2n8MLF1n9+PvBc3ut7K/f/ewkAt489gB4FwTaqXFqDy2Vw9fH9eOmqo+hREGR1ZZjz/jiTZ2Z+jdnnGLjqQ+h1lLVc7YsXw9u/aPulikVERPaBQmwncvKQUsYN34/Xk0fxuns0YMIrP4Lwll2/cdNimDYO4vXQ90T+e+B9XD3tc2LJFKcf3I2LjuiVkfpl3w3vXcgb1x/LKUNKiSdN7nltET969jOq3F2t5WqPutY6cdbv4a9nQd0GewsWERHZCYXYTuauM4fQPT/ArfUXstnfC+rK4Z/X7vzu9Oo18Oy50FAFPYYzY/hv+dHzXxJLphhzYBm//f5QXC4NI3CS/CwvU8YP55dnDsHndvGfRRs57Xcz+GhVLZw6Cb77l63TcE05DlbNtLtkERGR7SjEdjJ5AS8Pf/dQGghwWe3VpFxeWPIv+OSp7U+ur7ACbF05FA3io6P+xBX/9xWxRIpThpQy+QfD8Lr1T8iJDMPgsqP355WJ36FvcTYbaiNc+NTHPPr2EhKDz4If/RdKhkBoI/zlTJg5WdNwiYhIu6IE0gkd3b+IS4/qzUKzD781xlsH37oDNi7celKkFp47HyqXQ35PPjl2Kpe9sIJYIsXoA0r5w4WH4fPon4/THdQjn9evO4YLRvTENOH37y3ngv/3MWtd3WHCO3DIBWAm4T93wkvjIVJjd8kiIiKAQmyndftpB7B/UTaT60exMOcoSEbTy9KGIR6BFy6Eb+ZDVlfmHvc0419eRzSRYtTgEp64SAG2I8nyeXho3CH8/gfDyPV7+Gx1FWMnz+D1xTVw7hQ4/VFwea1ZC6YcDyv/a3fJIiIiCrGdVdDn5pHvHorLMBhfcSmRQDFsXgxv3g6vTIBVM8CXwxcnPM2F/6gkEk9x4qBinrhYAbajOvPQ7rxxw7EM61VAXSTBtc/P4/ZXFhA+9DK4/C3I7wlVX8Nfz7amWgtttrtkERHpxJRGOrHhvQu56vh+bCGPm2LpZWnn/sXqcXP7+OqEKVzwWoRIPMXxA4v548XD8Xvcdpctbahnlyxeuuoorj2xP4YBL3yyljN//z8WuQbAj2fCET8CDFjwEvxhOHz6DKRSdpctIiKdkEJsJ3fj6AEMLsvl3+HBvJl/gXXQcLHsuMmc/6aHhniSYwcUMWX8cAJeBdjOwOt2ccupg5g2YSSleX5WbK7nnMdn8sxnWzBP+7W1ZG23Q63xsa/fCE+f2nI8tYiISAYoxHZyfo+b33xvKF63wXUbx/LFkFtZOvoZznm3kHDMCrBPXjJCAbYT+k6/Iv59w3GMPqCUWDLFPa8t4od//oTVgUEw4T0Y8yD4cqzV3/50LLx9J8Tq7S5bREQ6CYVYYUj3PG4YNYAEHi5aeDjnvR2kPpbk6P5d+X/jFWA7sy7ZPp68ZDj3nn0gPo+L/y7ZzMm/+ZCH/rOc0LAr4Zo5cMCZ1gwGsybD40fCkjftLltERDoBhVgB4Orj+zG0ZwF10QShaIKj+nblqUsOJ+hTgO3sDMPgkqP68K/rjuHYAUXEkin++N8VnPjIf/nbshSp7z4LP3gR8ntBzRr4vwvghYugZr3dpYuISAemECsAeNwuHv3eofQoCDL6gBKmXjZCAVZaGFCay18vP4InLxlBn65ZbK6LcuvLX3DOEzP5LDASrvkYjr4BXB5Y/Dr84XCYfh2sma2FEkREpNV57C5A2o9+xTnM+OmJWkZWdsowDE4eUspxA4v488xV/P695Xyxrobz/ziLc4Z257bTfka3Qy6A12+CtbNh7l+trWt/GHohHPJ9yO9h99fIPNOEZAyScUjFIZmAVCK9H7f2m79mpsDj37q5/eAJbH3u8oCh31MR6dwUYqUFBVjZHX6Pm6uO78d5h+3HI28t4aXP1vKP+eW8tXAjPz6hHz8a/waB9R/B/Odh0T+sld/evRfe+xX0PdEKtIPPAG/A7q+y5+INUFsOdRsgXAmRamio3vVjpMYKqq3FcKWDrR+8QQgWQlZXyC6G7CLIKoLsrunHZseCheDSf4ATkY5BIVZE9lpxrp+Hxh3CxUf25p7XFvLp6ip+85+lvPjJWm47bTBjz3ocz9hfw6J/wrxpsGYWrHjX2gL5cND5MPRi6HGY/T2LpgkNVemA+o31WFsOdeVQ+83W/Yaq1rme4Qa311oNze1JP3rTvawuq+c2EYFE+jEVb1ZrChIN1hapturdrWu6ILcbFPSGwj5Q2Du9n37M7aaQKyKOoRArIvvs4P3y+dvVR/H6F9/wwBtfsb66gev/bx73ZPsYc1AZZxxyGkdcdhHuqpXw+Qvw+f9BzVr49GlrKxoEPQ+Hgj5bA1VBL8gpbb1QFQ1B7XqoWZd+bNxfZ+3Xrod4ePc+y5tlBb7sIggUkArkE/fmEfHk0eDOJezKpc7IppZsqs1sqlLZhPGTMjxN265Cu9tlkO1zkxPwkuP3pDcXuZ4kuZ4k2e4EQSOBKxmzam7YAvUV1hau2H4/XGH1Bpsp63vWrrf+oNjuwj7r594YbAv3t4aCdO1vhV6Pb+9+9iIibUAhVkRahWEYnHlod0YfUMqUD1fwl1mrqKyPMW32GqbNXkNxrp+xB5Vx+iE/ZsTxt+NaPcPqnf1qOlQssbZteQLWcrctegx7gScI8XprXtpYGGIhK8y12K/HFavngC3rcf1ni9VjuTuCXSCvO2Zed+LBUmp8JVQaXfnG7MKaeD7Lo3msCnnYUBulZkOcukiChnhyFx8YTW+tyzAgx+chN+ChONdPWX5fyvKGUJofoFvPAKV5AcryApTlB8jyeawe3XCFFdirV1tLCFetTu+vtgJ9MmYN/ahcvoMLuq2ff2Oo7doPug6w9vO629+TLiKdjkKsiLSqoM/NjaMHcs2J/floRSWvf2GNld1cF+UvH63mLx+tpjTPz9iDu3HGiF8z7LSHca14BypXWIGqeo0VqmrXWf8ZvXKZte0FA8hqfsCfB3k9IL8Hqbwe1PlK2OwqYV2qCyuj+SxpyGNtncmGmgjflEd2EE5NoGan1/N7XOQGvOQGrN7TrY9efJ7d71FOplLUR5PURRPURxOEItbUd3WROPWxJMmUiWlCXTRBXTRBeU2Ez9ftvK68gIdu+UFK8wP06hJk/6Lh9C05jr4HZtOjIIjH7bJuKKtdvzXUVq+GLSvToXaF9cfBlpXWtuztlhfwZkGXvlZvbZf900MV+lg9ufk91YMrIm1CIVZE2oTX7eK4gcUcN7CYX52TYubyCl7/4hveXrSBjbVRnpm5imdmrqJ7foCxBw/hgG5HUtzdT0men+IcP4V+A1fd+pbBtjFgpeLWamHeLPBlgy8LvNlN+6Y3m6grSCjp48u1lSRKD+LreCErat2srQqztryB8kUNJFLNp/6KARXbfY8u2T7K8gJ0y7d6Na3HIGV5AQqyvOQFvOSkw+qeBNW9ZZomkXiKumic+miSmoY4m2ojbKiNsKFm+8dwLEltJEFtpI4lG+u2+zyv26BXlyz6FufQtyib/Yv6sH/RgfQdkENRjg/DMKzxwnUbtvbSNt+qVlk93xu/tLZtGS7I2y89PKGPFXILelu9tzmlkFNitaV6ckVkDynEikib83lcnDi4hBMHlxBNHMSMpRW8/kU5/1m0kfKaCE/97+vt3uN2GRTl+CjO9VOSewDFOUMpzvVT3M0PQHU4TnVDjJpwnOqqONXhGNUNcWob4lSH480CagHQkN62qcvtokdhkP0Kg/TsksV+hUG65webwmppXqDdrVhnGAZBn9uaxzl31+eapkldNMHGdKj9pjrC6i31fF1Rz8rN1mM0kWLF5npWbN5+yeDcgIcBJTkMKMllQGkOA0oHM6D/CLoND1jhFqypwarXbA20227xsLUIRs0aWDVjx4V6s6xZFBpDbdNjCWQVk1NZAd+4IJgH/tz0HzBBBV+RTk4hVkQyyu9xM3pIKaOHlBKJJ/lg6Wbe/Woj39RE2FwXZXNdlMr6GMmUycbaKBtro0DtXl3L53GR64W+pfn07JJFz8Ks9KMVWkvzArg78LRyhmGQF7B6iweUbp94UymTb2ojrNwcagq2Kyvq+boixLqqBuoiCeauqWbumuoW78vxe+hfkmMF3FIr5PYvOZbu/U9p+fM0TQhtahZqv966H9povdY4hrk63dO+DTcwCGDb+9AMlxVmfTngz0n3wqcf3V7rJjW3b9f7rvRsEC53evNYY3+bH2v+3HBbNxoabuv6TcfcVqA2mr3HMABj66PVINvsN3tMpawb75q25Nb91DbHU8n0PMONj4n08W2OpZLpzzG3tgem9Wimtu43PhqG9bNxebb+rBr3XY0/u/RMGh5/+meevbUdNGxEMkwhVkRsE/C6OfXAMk49sKzF8XgyRWUoZoXakBVuN9VG2RyyQq7LMMjP8lIQ9JIf9FKQ5SU/6KMgy9ovSO97XTB//nyGDh2K292+elTbA5fLoEdBkB4FQY4dUNzitUg8yarKepZtDLFsU4hlG+tYtinEqop6QtEE89dWM39tdYv3+DwuenfJok9RNvsXZdOnazZ9irLYv+gQSvc7YsfzUMfqrTAb2pQOthuhfnNTyDXrNhCt2YTfSGDEQlboBSuERWutbftREmIHt69lqPVlgz8Hlzeb3vUJjE37W3MVB/J3sBVYj74cTfMmu00hVkTaHa/bRVl6DCrk7/XnJJO7mjVAdiXgdTO4LI/BZXktjscSKVZX1rNsU4il6WC7fGOIlRUhYomUFXg3hXbweS4r1HbNpk9RNj0KApTkBSjJ9VOaV0Zxj9543duHl1QyycLmf4ikUunZJ0LWtGmxOisIR9MBN1a/dSW0ZHzrSmnJ2Db76cemXsxmPZxNvZqp7Xs5zdTWx8b3NfZ2Nu6nkmzXywnpfXZwzEz34Lq2bk3PGx+Nrcdcnm16h5s93+41Fy16hA3D+oxtj2FYtTT/uexqPxG1ZgiJhiCZnn0jGYOG2HZzKRtAEcC63fiHZ7isISP+fAjkWTdjNj76c7c5lp8eXpJlDUnxBtOPWVuPufTHa0emECsiIrvN53ExoDSXAaW5jD24W9PxZMqkvLqBryvqm7ZVlfWsqqhnbVUDkXiKxRvqWLxhx92mhgFds32U5AYozfNTmmeF3OIcLzWbIoRyKsjP8pPj95AX8JAbKCaQU7p1bK7YJxlPT3cX2voYbdyvJxWppfzrr+hemI0rVmvNWdx8a1zZLhmz/jhoPL7zCTd2n9u3Ndh6g82GlXhbDjFxbXvM23J4iGtHQ0i2Pe7a8QbbHNvBsBKa/Tve9tgOh5mYzf6YanY82Xw56/g2z5svb934PLb1D75UvOXz9DFXMsaBRhB6vgIlg1qhUVqPQqyIiOwzt8uwxht3yeK4gS2HJsSTKdZVNfB1RYivK8KsrqxnY22EjbVRNtVG2FQXJZEyqQjFqAjFWLSjBcg++nS7Qx6X0TQzROPUZtk+N36PG5/Hhc/jwp9+tPbd+Jsfc7vwuF143QZul4HHtXXf63bhcRl4mh6t190ucLtcuA0Dt9uwHl3bbIZhdXgaYJDexxqjbD2yXfg2TZOUaf0xkDJNkimTpGlauST9vPF4ImkST6Wsx2SKRMokkUwRT5okmh1PpkwSzT+vad/6THOb46ZJi+/hMrZ+H5fLwO2i6ZjH5SLocxPwWI9Br5uAtwvBYDHBPDcBr7tpfLSZTLLRPZ9uQ4fCrob1xCPpZZrTw0QiNenH2p081qTHVDdsnSe6cZ90T3djD/zuzhMt2zEAv+EiFa4gPUK93VCIFRGRNuV1u9g/PU52R1Ipky3hGBtrI2yqjVqPddbjhpoG1m+uxvT4CUWT1EXihKIJUiYkUqY1S0U4zo5mn3CCxizbNLqgA/F5XAS9boJeFy4zQdGsj8gNesj2eZr++Mjxe8huNqdytt9Djr8L2f4SsnPdZBdZ52f73dZ8xrvDNK05pluE23TATcaaDTdp3uu47fFY+oa6ZMthIk3DSZoPMUkPJ2m8YW5HG9u83lintdOy9ubHdjTUZIfDTpo93/YmvJ0tb92857n5expvfkyfm8TFl19v4KCeR7bCv4rWpRArIiK2crkMinL8FOX4ObB7y9eSyeR2N+eZpkl9LEkoYi0AURdNUJfeD0eTRJMpYokU0USSWKJxP9VsP0ksfU7z3svGHs1Es97Opp7PdM9mslnvZePWcr7hPbMn4dVl0NQL6nFv7S32uq3nbpeBN/2ax+3Cu00PcWMvqvVofZZhbO1NNmC777e1V9j6Y6PxZ5BIpojEU0TiSRoat1iSaCLVVG/jz7sm/fdFed2+jQ/we1xk+61AawVbD1npnveA19X0GPBaPe4Bb+NxHwFvAL/Hne5RT/equw28XtfWYy163Vv+vFxNPdLp3mij8ThbzzGMpjZqj8NcUtv8+w163Tu+2XJbySSJ8tZfdbA1KMSKiIijGIbR1Itn3fxnv+YBIZGy/lO9SbN7u7D+c711bOtrZvpmL1eL/2xvhaHm/zl/R0MQ2qNUyiSaSLUItqFIjC8WLaFsvz40JFLURdIr0aX/+Gjcb9zqownqo0nqY9Z+PGkl/WgiRTQRY8v2Uxq3S80DrdvY2qYul9WerqbhJY3PreEnLmPrsca1RqD5o9nUd2vu4N9WIrX9HyKJ9Cp/zfUrzubfNxyXkUVa2opCrIiIyD5yuQxcGLSztTEyzuVqthhHWjKZJLnZx9ADSvZqqrtYImUF25gVbkPRBOF0wA3HkkTiVu/6Dh/jVu9wJP3Y2KMeT5kkd9IDn0hZvfPJlNn0x0nK3PqHyu72nqdMSCXTf8W0Q+50mHYyhVgRERFpt6wb83wUZrePxRR2dBNeKn3MbHqe3m8WgFPN3ke69zSV7klNpZr1qJpYN9phPTb21gJbbwykZQBtPOZy0TQUwuNyNQ13aOzRbz68JODZzeEE7ZhCrIiIiMhusoYH0KFX+3MK5w6EEBEREZFOSyFWRERERBxHIVZEREREHEchVkREREQcRyFWRERERBxHIVZEREREHEchVkREREQcRyFWRERERBxHIVZEREREHEchVkREREQcRyFWRERERBxHIVZEREREHEchVkREREQcRyFWRERERBxHIVZEREREHEchVkREREQcRyFWRERERBzHY3cBmZRKpQBoaGjIyPWSySQA4XAYt9udkWtK61H7OZ/a0PnUhs6nNnQ2O9qvMac15radMUzTNDNRUHtQWVnJqlWr7C5DRERERL5Fnz596Nq1605f71QhNpFIUFNTg9/vx+XSSAoRERGR9iaVShGNRsnPz8fj2fmggU4VYkVERESkY1B3pIiIiIg4jkKsiIiIiDiOQqyIiIiIOI5CbBuorKxk4sSJjBgxgpEjRzJp0iQSiYTdZclu2LJlCyeffDKzZ89uOvb555/z3e9+l2HDhnHSSSfxt7/9zcYKZWcWL17MD3/4Q4444giOPvpofvrTn7JlyxZAbegUH330Ed/97nc57LDDOProo7nvvvuIRCKA2tBJkskk48eP5/bbb286pvZzhjfeeIMhQ4YwbNiwpu3WW28F2mkbmtLqLr74YvPmm282w+GwuWbNGvP00083n3zySbvLkm/x6aefmqNHjzYHDhxofvzxx6ZpmmZ1dbV5xBFHmM8995wZj8fNWbNmmcOGDTM///xzm6uV5hoaGsyjjz7a/N3vfmdGo1Fzy5Yt5pVXXmleddVVakOHqKysNA8++GDz73//u5lMJs2NGzeaZ5xxhvm73/1Obegwv/3tb83Bgwebt912m2ma+t9RJ3nwwQfN22+/fbvj7bUN1RPbylavXs2cOXO49dZbCQaD9OzZk4kTJzJt2jS7S5NdePXVV7nlllu46aabWhx/++23KSgo4KKLLsLj8XDUUUdx5plnqj3bmfLycgYPHsw111yDz+ejsLCQCy64gE8++URt6BBdunRh1qxZnHfeeRiGQXV1NdFolC5duqgNHeSjjz7i7bff5pRTTmk6pvZzjgULFnDQQQdtd7y9tqFCbCtbtmwZBQUFlJaWNh3r168f5eXl1NbW2liZ7MoxxxzDf/7zH8aOHdvi+LJlyxg4cGCLY/3792fx4sWZLE++Rd++fXnqqadarCbz1ltvceCBB6oNHSQnJweA448/njPPPJPi4mLOO+88taFDVFZWcscdd/Doo48SDAabjqv9nCGVSrFw4UL++9//cuKJJ3Lcccdx5513UlNT027bUCG2ldXX17f45QWanofDYTtKkt1QXFy8wwmVd9SegUBAbdmOmabJY489xvvvv88dd9yhNnSgt99+mw8//BCXy8X111+vNnSAVCrFrbfeyg9/+EMGDx7c4jW1nzNs2bKFIUOGcOqpp/LGG2/wwgsvsGrVKm699dZ224YKsa0sKyurac3fRo3Ps7Oz7ShJ9kEwGGy6saRRJBJRW7ZToVCI66+/ntdee43nnnuOQYMGqQ0dKBAIUFpayq233sqMGTPUhg4wZcoUfD4f48eP3+41tZ8zFBUVMW3aNMaNG0cwGKR79+7ceuutfPjhh5im2S7bUCG2lQ0YMIDq6moqKiqajq1YsYKysjJyc3NtrEz2xsCBA1m2bFmLY8uXL2fAgAE2VSQ7s2bNGs4//3xCoRAvv/wygwYNAtSGTjF37lzGjBlDLBZrOhaLxfB6vfTv319t2M7985//ZM6cOYwYMYIRI0bw+uuv8/rrrzNixAj9DjrE4sWLeeSRRzCbLeQai8VwuVwccsgh7bINFWJbWZ8+fRg+fDj3338/oVCItWvX8sQTTzBu3Di7S5O9cPLJJ1NRUcGf//xn4vE4H3/8Ma+99hrnn3++3aVJMzU1NVx66aUcdthhTJ06lS5dujS9pjZ0hkGDBhGJRHj00UeJxWKsX7+ehx56iHHjxnHqqaeqDdu5N998k7lz5/Lpp5/y6aefcsYZZ3DGGWfw6aef6nfQIQoKCpg2bRpPPfUUiUSC8vJyHn74Yc4999x2+ztomM0jt7SKiooK7r33XmbPno3L5eKcc87hlltuaXHTibRfgwYN4q9//SsjR44ErLs1J02axNKlS+nSpQsTJ07kvPPOs7lKae6ZZ57hwQcfJBgMYhhGi9fmzZunNnSI5cuXc//997NgwQJyc3M588wzm2acUBs6S+McsQ8++CCg/x11ijlz5vCb3/yGpUuX4vf7Of3007n11lvx+/3tsg0VYkVERETEcTScQEREREQcRyFWRERERBxHIVZEREREHEchVkREREQcRyFWRERERBxHIVZEREREHEchVkREREQcRyFWRMRhVq9ebXcJIiK289hdgIiIbFVTU8Njjz3G+++/T01NDTk5ORx99NHcdNNNlJWV8dBDD1FVVdW0EpKISGelnlgRkXbkpptuoqqqipdffpn58+fzj3/8g1gsxg9/+EMSiQRVVVV2lygi0i4oxIqItCOfffYZJ598MsXFxQAUFRXx85//nEMPPZQpU6bw2muv8dprr3HWWWcBUFFRwS233MLRRx/NMcccw1133UUoFAJg9uzZHHfccfzud79j5MiRjBw5kkmTJhGLxWz7fiIirUXDCURE2pHTTz+du+++m08//ZQjjjiCQw89lB49ejQNH1i7di0ADz74IKlUiokTJ9KnTx/eeust4vE4P/vZz7jrrrv4zW9+A8DGjRv5+uuveffdd6moqODKK68kOzubG2+80a6vKCLSKtQTKyLSjvzqV7/irrvu4ptvvuGuu+7ipJNO4uSTT2b69Onbnfvll1+ycOFC7r77bnJycigsLOS2227jX//6V9OwA8Mwml7v06cPEyZM2OFniYg4jXpiRUTaEZfLxdlnn83ZZ5+NaZqsWLGCf/7zn/z0pz9tGmLQaN26dSSTSY4//vgWx30+X1OPbX5+PoWFhU2vdevWjU2bNrX9FxERaWMKsSIi7cSMGTO4/vrref/99ykoKMAwDPr378/NN9/MzJkzWbRoUYvzy8rKCAQCzJ49G7fbDUAsFmPt2rX07t2bzz77jLq6OhoaGggGg4AVfLt3757x7yYi0to0nEBEpJ04/PDD6dq1Kz/72c9YsmQJ8XicUCjE9OnTWbVqFSeccAI+n4+6ujoADjnkEHr37s2DDz5IfX09kUiE+++/n8suu4xkMglAMpnkoYceIhqNsnLlSqZOncq4cePs/JoiIq1CIVZEpJ0IBAI8//zzFBcX8+Mf/5gRI0ZwwgknMH36dJ555hn69evH2LFjmTt3LieccAIej4cpU6ZQUVHBKaecwjHHHMOaNWt45pln8Pv9TZ+bn5/PqFGjuOSSSzj33HOZMGGCjd9SRKR1GKZpmnYXISIirW/27NlccsklLFmyxO5SRERanXpiRURERMRxFGJFRERExHE0nEBEREREHEc9sSIiIiLiOAqxIiIiIuI4CrEiIiIi4jgKsSIiIiLiOAqxIiIiIuI4CrEiIiIi4jgKsSIiIiLiOAqxIiIiIuI4/x/7t6DcptIzRAAAAABJRU5ErkJggg==",
      "text/plain": [
       "<Figure size 800x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "class CrossEntropy2ClassModel(pl.LightningModule):\n",
    "    def __init__(self, input_features: int, learning_rate=0.01):\n",
    "        super().__init__()\n",
    "\n",
    "        self.classifier = nn.Linear(input_features, 2)\n",
    "\n",
    "        # Define loss function\n",
    "        self.criterion = nn.CrossEntropyLoss()\n",
    "\n",
    "        # Define optimizer\n",
    "        self.learning_rate = learning_rate\n",
    "        self.optimizer = torch.optim.Adam(self.parameters(), lr=learning_rate)\n",
    "\n",
    "        # training logs\n",
    "        self.log_train = []\n",
    "        self.log_val = []\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = self.classifier(x)\n",
    "        return x\n",
    "\n",
    "    def training_step(self, batch, batch_idx):\n",
    "        x, y = batch\n",
    "        y_hat = self(x)\n",
    "        loss = self.criterion(y_hat, y.type(torch.long))\n",
    "        self.log(\"train_loss\", loss, prog_bar=True, on_step=True)\n",
    "        self.log_train.append(loss.detach().cpu().numpy())\n",
    "        return loss\n",
    "\n",
    "    def validation_step(self, batch, batch_idx):\n",
    "        x, y = batch\n",
    "        y_hat = self(x)\n",
    "        loss = self.criterion(y_hat, y.type(torch.long))\n",
    "        self.log(\"val_loss\", loss, prog_bar=True, on_step=True)\n",
    "        self.log_val.append(loss.cpu().numpy())\n",
    "\n",
    "    def configure_optimizers(self):\n",
    "        return self.optimizer\n",
    "\n",
    "\n",
    "model_lightning = CrossEntropy2ClassModel(learning_rate=1e-1, input_features=m)\n",
    "\n",
    "start_time = timeit.default_timer()\n",
    "train_torch_model(model_lightning, epochs=50)\n",
    "model_times[\"logistic_reg_ce2\"] = timeit.default_timer() - start_time\n",
    "\n",
    "plot_training_logs(model_lightning)\n",
    "\n",
    "y_train_est, y_true_train = predict_data_loader(model_lightning, train_loader)\n",
    "y_test_est, y_true_test = predict_data_loader(model_lightning, test_loader)\n",
    "model_outputs[\"logistic_reg_ce2\"] = [y_train_est.numpy(), y_test_est.numpy()]\n",
    "model_parameters[\"logistic_reg_ce2\"] = model_lightning.parameters()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Results\n",
    "\n",
    "Lets check the model performance in a few ways:"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Performance\n",
    "\n",
    "We don't see any significant difference in performance between models. Log likelihood and accuracy are similar, within reason, across all models.\n",
    "These are small models to fit, so perhaps a much large model would present differently, and a model with twice as many parameters would overfit more readily..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>log_loss_train</th>\n",
       "      <th>log_loss_test</th>\n",
       "      <th>accuracy_score_train</th>\n",
       "      <th>accuracy_score_test</th>\n",
       "      <th>name</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0.616102</td>\n",
       "      <td>0.618044</td>\n",
       "      <td>0.65992</td>\n",
       "      <td>0.65580</td>\n",
       "      <td>logistic_reg_bce</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0.634614</td>\n",
       "      <td>0.635658</td>\n",
       "      <td>0.66044</td>\n",
       "      <td>0.65568</td>\n",
       "      <td>logistic_reg_ce</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0.643445</td>\n",
       "      <td>0.644258</td>\n",
       "      <td>0.65938</td>\n",
       "      <td>0.65642</td>\n",
       "      <td>logistic_reg_ce2</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   log_loss_train  log_loss_test  accuracy_score_train  accuracy_score_test   \n",
       "0        0.616102       0.618044               0.65992              0.65580  \\\n",
       "1        0.634614       0.635658               0.66044              0.65568   \n",
       "2        0.643445       0.644258               0.65938              0.65642   \n",
       "\n",
       "               name  \n",
       "0  logistic_reg_bce  \n",
       "1   logistic_reg_ce  \n",
       "2  logistic_reg_ce2  "
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "evaluate_all_models(model_outputs)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Training time\n",
    "\n",
    "We don't see any significant difference in training time between models."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'logistic_reg_bce': 28.00450733397156,\n",
       " 'logistic_reg_ce': 24.72408683411777,\n",
       " 'logistic_reg_ce2': 25.281254459172487}"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model_times"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Parameters\n",
    "\n",
    "The weights of the binary class models are similar to the true weights from the data generating function. However the 2 output model has twice as many parameters and thus the interpretation of the weights is not clear here:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True weights:\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([[ 0.12573022],\n",
       "       [-0.13210486],\n",
       "       [ 0.64042265],\n",
       "       [ 0.10490012]])"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True bias:\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([-0.53566937])"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "logistic_reg_bce: \n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[Parameter containing:\n",
       " tensor([[ 0.1037, -0.1576,  0.6802,  0.1207]], requires_grad=True),\n",
       " Parameter containing:\n",
       " tensor([-0.5245], requires_grad=True)]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "logistic_reg_ce: \n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[Parameter containing:\n",
       " tensor([[ 0.0615, -0.0684,  0.3213,  0.0474]], requires_grad=True),\n",
       " Parameter containing:\n",
       " tensor([-0.2585], requires_grad=True)]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "logistic_reg_ce2: \n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[Parameter containing:\n",
       " tensor([[-0.0351, -0.0528, -0.5174, -0.1480],\n",
       "         [ 0.0698, -0.2241,  0.0729, -0.0377]], requires_grad=True),\n",
       " Parameter containing:\n",
       " tensor([ 0.4980, -0.0408], requires_grad=True)]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "print(\"True weights:\")\n",
    "display(w)\n",
    "print(\"True bias:\")\n",
    "display(b)\n",
    "\n",
    "for name, params in model_parameters.items():\n",
    "    print(f\"{name}: \")\n",
    "    display(list(params))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Conclusion\n",
    "\n",
    "There is not noticeable impact on training times or performance.\n",
    "However, the parameter interpretation is much clearer from a model with a single output as we only have the one set of parameters. This probably depends on the use case - but if we want an interpretable model that matches the data generating process, we should use a model with a binary output based on `BCEWithLogitsLoss`. Otherwise it doesn't seem to matter for this type of problem."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "pytorch_env",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.10"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "155ead7e3e7cc87f1c8ac5b93741665d5692c3c80ccfbc75b55ba980f115c04c"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}