04_3_Graph_Prediction_TransformerConv_Model_ipynb.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "04.3: Graph_Prediction_TransformerConv_Model ipynb",
      "provenance": [],
      "authorship_tag": "ABX9TyOhsHjIZjxenjCFXbdSewlt",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/gulabpatel/Graph_Neural_Network/blob/main/04.3%3A%20Graph_Prediction_TransformerConv_Model_ipynb.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QyeV-HYJ77Jb"
      },
      "source": [
        "#Code Help"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Idoi1Pi7yQDq"
      },
      "source": [
        "Video walkthrough the code :\n",
        "1. https://www.youtube.com/watch?v=nAEb1lOf_4o\n",
        "2. https://www.youtube.com/watch?v=QLIkOtKS4os&t=1s\n",
        "3. https://www.youtube.com/watch?v=CJ-KdKCeiYg\n",
        "4. https://www.youtube.com/watch?v=ZyiW_ibeDGc"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rGtTyLBN7_J6"
      },
      "source": [
        "# Install required libraries"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kUH0u9x12NH4"
      },
      "source": [
        "!pip install mlflow"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bH7b9Ush24AX"
      },
      "source": [
        "!pip install arm-mango"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nwVU_tFs7dLG"
      },
      "source": [
        "!pip install deepchem"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "W7JOT6umzbHo",
        "outputId": "b3bf945f-95cf-4af6-acdf-8b1c4d3bae2e"
      },
      "source": [
        "import sys\n",
        "import os\n",
        "import requests\n",
        "import subprocess\n",
        "import shutil\n",
        "from logging import getLogger, StreamHandler, INFO\n",
        " \n",
        " \n",
        "logger = getLogger(__name__)\n",
        "logger.addHandler(StreamHandler())\n",
        "logger.setLevel(INFO)\n",
        " \n",
        " \n",
        "def install(\n",
        "        chunk_size=4096,\n",
        "        file_name=\"Miniconda3-latest-Linux-x86_64.sh\",\n",
        "        url_base=\"https://repo.continuum.io/miniconda/\",\n",
        "        conda_path=os.path.expanduser(os.path.join(\"~\", \"miniconda\")),\n",
        "        rdkit_version=None,\n",
        "        add_python_path=True,\n",
        "        force=False):\n",
        "    \"\"\"install rdkit from miniconda\n",
        "    ```\n",
        "    import rdkit_installer\n",
        "    rdkit_installer.install()\n",
        "    ```\n",
        "    \"\"\"\n",
        " \n",
        "    python_path = os.path.join(\n",
        "        conda_path,\n",
        "        \"lib\",\n",
        "        \"python{0}.{1}\".format(*sys.version_info),\n",
        "        \"site-packages\",\n",
        "    )\n",
        " \n",
        "    if add_python_path and python_path not in sys.path:\n",
        "        logger.info(\"add {} to PYTHONPATH\".format(python_path))\n",
        "        sys.path.append(python_path)\n",
        " \n",
        "    if os.path.isdir(os.path.join(python_path, \"rdkit\")):\n",
        "        logger.info(\"rdkit is already installed\")\n",
        "        if not force:\n",
        "            return\n",
        " \n",
        "        logger.info(\"force re-install\")\n",
        " \n",
        "    url = url_base + file_name\n",
        "    python_version = \"{0}.{1}.{2}\".format(*sys.version_info)\n",
        " \n",
        "    logger.info(\"python version: {}\".format(python_version))\n",
        " \n",
        "    if os.path.isdir(conda_path):\n",
        "        logger.warning(\"remove current miniconda\")\n",
        "        shutil.rmtree(conda_path)\n",
        "    elif os.path.isfile(conda_path):\n",
        "        logger.warning(\"remove {}\".format(conda_path))\n",
        "        os.remove(conda_path)\n",
        " \n",
        "    logger.info('fetching installer from {}'.format(url))\n",
        "    res = requests.get(url, stream=True)\n",
        "    res.raise_for_status()\n",
        "    with open(file_name, 'wb') as f:\n",
        "        for chunk in res.iter_content(chunk_size):\n",
        "            f.write(chunk)\n",
        "    logger.info('done')\n",
        " \n",
        "    logger.info('installing miniconda to {}'.format(conda_path))\n",
        "    subprocess.check_call([\"bash\", file_name, \"-b\", \"-p\", conda_path])\n",
        "    logger.info('done')\n",
        " \n",
        "    logger.info(\"installing rdkit\")\n",
        "    subprocess.check_call([\n",
        "        os.path.join(conda_path, \"bin\", \"conda\"),\n",
        "        \"install\",\n",
        "        \"--yes\",\n",
        "        \"-c\", \"rdkit\",\n",
        "        \"python==3.7.3\",\n",
        "        \"rdkit\" if rdkit_version is None else \"rdkit=={}\".format(rdkit_version)])\n",
        "    logger.info(\"done\")\n",
        " \n",
        "    import rdkit\n",
        "    logger.info(\"rdkit-{} installation finished!\".format(rdkit.__version__))\n",
        " \n",
        " \n",
        "if __name__ == \"__main__\":\n",
        "    install()"
      ],
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "add /root/miniconda/lib/python3.7/site-packages to PYTHONPATH\n",
            "python version: 3.7.11\n",
            "fetching installer from https://repo.continuum.io/miniconda/Miniconda3-latest-Linux-x86_64.sh\n",
            "done\n",
            "installing miniconda to /root/miniconda\n",
            "done\n",
            "installing rdkit\n",
            "done\n",
            "rdkit-2020.09.1 installation finished!\n"
          ],
          "name": "stderr"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nEDvB3kBxyIX",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "f434c159-f52d-4100-e77d-c95e9bbc233d"
      },
      "source": [
        "# !pip install --no-index torch-scatter -f https://pytorch-geometric.com/whl/$pytorch_version\n",
        "# !pip install --no-index torch-sparse -f https://pytorch-geometric.com/whl/$pytorch_version\n",
        "# !pip install --no-index torch-cluster -f https://pytorch-geometric.com/whl/$pytorch_version\n",
        "# !pip install --no-index torch-spline-conv -f https://pytorch-geometric.com/whl/$pytorch_version\n",
        "# !pip install torch-geometric\n",
        "\n",
        "!pip install -q torch-scatter -f https://pytorch-geometric.com/whl/torch-1.9.0+cu102.html\n",
        "!pip install -q torch-sparse -f https://pytorch-geometric.com/whl/torch-1.9.0+cu102.html\n",
        "!pip install -q torch-geometric"
      ],
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "\u001b[K     |████████████████████████████████| 3.0 MB 6.9 MB/s \n",
            "\u001b[K     |████████████████████████████████| 1.6 MB 6.7 MB/s \n",
            "\u001b[K     |████████████████████████████████| 222 kB 7.1 MB/s \n",
            "\u001b[K     |████████████████████████████████| 376 kB 11.5 MB/s \n",
            "\u001b[K     |████████████████████████████████| 45 kB 4.7 MB/s \n",
            "\u001b[?25h  Building wheel for torch-geometric (setup.py) ... \u001b[?25l\u001b[?25hdone\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KvsS5u6FnAj8"
      },
      "source": [
        "#Import Libraries"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "NUQ9iq6HmFYx",
        "outputId": "f63f76b6-2080-462a-8ebe-7458b07c6e13"
      },
      "source": [
        "import pandas as pd\n",
        "import numpy as np \n",
        "from rdkit import Chem\n",
        "import torch\n",
        "import torch.nn.functional as F \n",
        "from torch.nn import Linear, BatchNorm1d, ModuleList\n",
        "import torch_geometric\n",
        "from torch_geometric.data import Dataset, Data\n",
        "from torch_geometric.nn import TransformerConv, TopKPooling \n",
        "from torch_geometric.nn import global_mean_pool as gap, global_max_pool as gmp\n",
        "from torch_geometric.data import DataLoader\n",
        "from sklearn.metrics import confusion_matrix, f1_score, accuracy_score, precision_score, recall_score, roc_auc_score\n",
        "import mlflow.pytorch\n",
        "import matplotlib.pyplot as plt \n",
        "import seaborn as sns\n",
        "import os\n",
        "from tqdm import tqdm\n",
        "torch.manual_seed(42)\n",
        "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n",
        "print(f\"Torch version: {torch.__version__}\")\n",
        "print(f\"Cuda available: {torch.cuda.is_available()}\")\n",
        "print(f\"Torch geometric version: {torch_geometric.__version__}\")"
      ],
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Torch version: 1.9.0+cu102\n",
            "Cuda available: False\n",
            "Torch geometric version: 1.7.2\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "83GCbCzQnDld"
      },
      "source": [
        "#Prepare Dataset"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NrYN_8pJ6-Yu"
      },
      "source": [
        "## Approach 1: Custome features"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "P5WKTarKl9wZ"
      },
      "source": [
        "class MoleculeDataset(Dataset):\n",
        "    def __init__(self, root, filename, test=False, transform=None, pre_transform=None):\n",
        "        \"\"\"\n",
        "        root = Where the dataset should be stored. This folder is split\n",
        "        into raw_dir (downloaded dataset) and processed_dir (processed data). \n",
        "        \"\"\"\n",
        "        self.test = test\n",
        "        self.filename = filename\n",
        "        super(MoleculeDataset, self).__init__(root, transform, pre_transform)\n",
        "        \n",
        "    @property\n",
        "    def raw_file_names(self):\n",
        "        \"\"\" If this file exists in raw_dir, the download is not triggered.\n",
        "            (The download func. is not implemented here)  \n",
        "        \"\"\"\n",
        "        return self.filename\n",
        "\n",
        "    @property\n",
        "    def processed_file_names(self):\n",
        "        \"\"\" If these files are found in raw_dir, processing is skipped\"\"\"\n",
        "        self.data = pd.read_csv(self.raw_paths[0]).reset_index()\n",
        "\n",
        "        if self.test:\n",
        "            return [f'data_test_{i}.pt' for i in list(self.data.index)]\n",
        "        else:\n",
        "            return [f'data_{i}.pt' for i in list(self.data.index)]\n",
        "\n",
        "    def download(self):\n",
        "        pass\n",
        "\n",
        "    def process(self):\n",
        "        self.data = pd.read_csv(self.raw_paths[0])\n",
        "        for index, mol in tqdm(self.data.iterrows(), total=self.data.shape[0]):\n",
        "            mol_obj = Chem.MolFromSmiles(mol[\"smiles\"])\n",
        "            # Get node features\n",
        "            node_feats = self._get_node_features(mol_obj)\n",
        "            # Get edge features\n",
        "            edge_feats = self._get_edge_features(mol_obj)\n",
        "            # Get adjacency info\n",
        "            edge_index = self._get_adjacency_info(mol_obj)\n",
        "            # Get labels info\n",
        "            label = self._get_labels(mol[\"HIV_active\"])\n",
        "\n",
        "            # Create data object\n",
        "            data = Data(x=node_feats, \n",
        "                        edge_index=edge_index,\n",
        "                        edge_attr=edge_feats,\n",
        "                        y=label,\n",
        "                        smiles=mol[\"smiles\"]\n",
        "                        ) \n",
        "            if self.test:\n",
        "                torch.save(data, \n",
        "                    os.path.join(self.processed_dir, \n",
        "                                 f'data_test_{index}.pt'))\n",
        "            else:\n",
        "                torch.save(data, \n",
        "                    os.path.join(self.processed_dir, \n",
        "                                 f'data_{index}.pt'))\n",
        "\n",
        "    def _get_node_features(self, mol):\n",
        "        \"\"\" \n",
        "        This will return a matrix / 2d array of the shape\n",
        "        [Number of Nodes, Node Feature size]\n",
        "        \"\"\"\n",
        "        all_node_feats = []\n",
        "\n",
        "        for atom in mol.GetAtoms():\n",
        "            node_feats = []\n",
        "            # Feature 1: Atomic number        \n",
        "            node_feats.append(atom.GetAtomicNum())\n",
        "            # Feature 2: Atom degree\n",
        "            node_feats.append(atom.GetDegree())\n",
        "            # Feature 3: Formal charge\n",
        "            node_feats.append(atom.GetFormalCharge())\n",
        "            # Feature 4: Hybridization\n",
        "            node_feats.append(atom.GetHybridization())\n",
        "            # Feature 5: Aromaticity\n",
        "            node_feats.append(atom.GetIsAromatic())\n",
        "            # Feature 6: Total Num Hs\n",
        "            node_feats.append(atom.GetTotalNumHs())\n",
        "            # Feature 7: Radical Electrons\n",
        "            node_feats.append(atom.GetNumRadicalElectrons())\n",
        "            # Feature 8: In Ring\n",
        "            node_feats.append(atom.IsInRing())\n",
        "            # Feature 9: Chirality\n",
        "            node_feats.append(atom.GetChiralTag())\n",
        "\n",
        "            # Append node features to matrix\n",
        "            all_node_feats.append(node_feats)\n",
        "\n",
        "        all_node_feats = np.asarray(all_node_feats)\n",
        "        return torch.tensor(all_node_feats, dtype=torch.float)\n",
        "\n",
        "    def _get_edge_features(self, mol):\n",
        "        \"\"\" \n",
        "        This will return a matrix / 2d array of the shape\n",
        "        [Number of edges, Edge Feature size]\n",
        "        \"\"\"\n",
        "        all_edge_feats = []\n",
        "\n",
        "        for bond in mol.GetBonds():\n",
        "            edge_feats = []\n",
        "            # Feature 1: Bond type (as double)\n",
        "            edge_feats.append(bond.GetBondTypeAsDouble())\n",
        "            # Feature 2: Rings\n",
        "            edge_feats.append(bond.IsInRing())\n",
        "            # Append node features to matrix (twice, per direction)\n",
        "            all_edge_feats += [edge_feats, edge_feats]\n",
        "\n",
        "        all_edge_feats = np.asarray(all_edge_feats)\n",
        "        return torch.tensor(all_edge_feats, dtype=torch.float)\n",
        "\n",
        "    def _get_adjacency_info(self, mol):\n",
        "        \"\"\"\n",
        "        We could also use rdmolops.GetAdjacencyMatrix(mol)\n",
        "        but we want to be sure that the order of the indices\n",
        "        matches the order of the edge features\n",
        "        \"\"\"\n",
        "        edge_indices = []\n",
        "        for bond in mol.GetBonds():\n",
        "            i = bond.GetBeginAtomIdx()\n",
        "            j = bond.GetEndAtomIdx()\n",
        "            edge_indices += [[i, j], [j, i]]\n",
        "\n",
        "        edge_indices = torch.tensor(edge_indices)\n",
        "        edge_indices = edge_indices.t().to(torch.long).view(2, -1)\n",
        "        return edge_indices\n",
        "\n",
        "    def _get_labels(self, label):\n",
        "        label = np.asarray([label])\n",
        "        return torch.tensor(label, dtype=torch.int64)\n",
        "\n",
        "    def len(self):\n",
        "        return self.data.shape[0]\n",
        "\n",
        "    def get(self, idx):\n",
        "        \"\"\" - Equivalent to __getitem__ in pytorch\n",
        "            - Is not needed for PyG's InMemoryDataset\n",
        "        \"\"\"\n",
        "        if self.test:\n",
        "            data = torch.load(os.path.join(self.processed_dir, \n",
        "                                 f'data_test_{idx}.pt'))\n",
        "        else:\n",
        "            data = torch.load(os.path.join(self.processed_dir, \n",
        "                                 f'data_{idx}.pt'))   \n",
        "        return data"
      ],
      "execution_count": 7,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sbObZlmM7DFf"
      },
      "source": [
        "## Approach 2: Featurizer Library\n",
        "\n",
        "    import deepchem as dc"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ddqdbGR87G6O"
      },
      "source": [
        "import deepchem as dc\n",
        "class MoleculeDataset(Dataset):\n",
        "    def __init__(self, root, filename, test=False, transform=None, pre_transform=None):\n",
        "        \"\"\"\n",
        "        root = Where the dataset should be stored. This folder is split\n",
        "        into raw_dir (downloaded dataset) and processed_dir (processed data). \n",
        "        \"\"\"\n",
        "        self.test = test\n",
        "        self.filename = filename\n",
        "        super(MoleculeDataset, self).__init__(root, transform, pre_transform)\n",
        "        \n",
        "    @property\n",
        "    def raw_file_names(self):\n",
        "        \"\"\" If this file exists in raw_dir, the download is not triggered.\n",
        "            (The download func. is not implemented here)  \n",
        "        \"\"\"\n",
        "        return self.filename\n",
        "\n",
        "    @property\n",
        "    def processed_file_names(self):\n",
        "        \"\"\" If these files are found in raw_dir, processing is skipped\"\"\"\n",
        "        self.data = pd.read_csv(self.raw_paths[0]).reset_index()\n",
        "\n",
        "        if self.test:\n",
        "            return [f'data_test_{i}.pt' for i in list(self.data.index)]\n",
        "        else:\n",
        "            return [f'data_{i}.pt' for i in list(self.data.index)]\n",
        "        \n",
        "\n",
        "    def download(self):\n",
        "        pass\n",
        "\n",
        "    def process(self):\n",
        "        self.data = pd.read_csv(self.raw_paths[0]).reset_index()\n",
        "        featurizer = dc.feat.MolGraphConvFeaturizer(use_edges=True)\n",
        "        for index, mol in tqdm(self.data.iterrows(), total=self.data.shape[0]):\n",
        "            # Featurize molecule\n",
        "            f = featurizer.featurize(mol[\"smiles\"])\n",
        "            data = f[0].to_pyg_graph()\n",
        "            data.y = self._get_label(mol[\"HIV_active\"])\n",
        "            data.smiles = mol[\"smiles\"]\n",
        "            if self.test:\n",
        "                torch.save(data, \n",
        "                    os.path.join(self.processed_dir, \n",
        "                                 f'data_test_{index}.pt'))\n",
        "            else:\n",
        "                torch.save(data, \n",
        "                    os.path.join(self.processed_dir, \n",
        "                                 f'data_{index}.pt'))\n",
        "            \n",
        "\n",
        "    def _get_label(self, label):\n",
        "        label = np.asarray([label])\n",
        "        return torch.tensor(label, dtype=torch.int64)\n",
        "\n",
        "    def len(self):\n",
        "        return self.data.shape[0]\n",
        "\n",
        "    def get(self, idx):\n",
        "        \"\"\" - Equivalent to __getitem__ in pytorch\n",
        "            - Is not needed for PyG's InMemoryDataset\n",
        "        \"\"\"\n",
        "        if self.test:\n",
        "            data = torch.load(os.path.join(self.processed_dir, \n",
        "                                 f'data_test_{idx}.pt'))\n",
        "        else:\n",
        "            data = torch.load(os.path.join(self.processed_dir, \n",
        "                                 f'data_{idx}.pt'))        \n",
        "        return data"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Rb8jZ2qE9NS3"
      },
      "source": [
        "## Oversampling"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "yApE3is69Q8Q",
        "outputId": "487ee9d7-89ad-4451-c3f6-9e8906a1a78b"
      },
      "source": [
        "# data = pd.read_csv(\"https://raw.githubusercontent.com/gulabpatel/Graph_Neural_Network/master/data/HIV_train.csv\")\n",
        "# data.index = data[\"index\"]\n",
        "# data[\"HIV_active\"].value_counts()\n",
        "# start_index = data.iloc[0][\"index\"]\n",
        "\n",
        "# # %% Apply oversampling\n",
        "\n",
        "# # Check how many additional samples we need\n",
        "# neg_class = data[\"HIV_active\"].value_counts()[0]\n",
        "# pos_class = data[\"HIV_active\"].value_counts()[1]\n",
        "# multiplier = int(neg_class/pos_class) - 1\n",
        "\n",
        "# # Replicate the dataset for the positive class\n",
        "# replicated_pos = [data[data[\"HIV_active\"] == 1]]*multiplier\n",
        "\n",
        "# # Append replicated data\n",
        "# data = data.append(replicated_pos,\n",
        "#                     ignore_index=True)\n",
        "# print(data.shape)\n",
        "\n",
        "# # Shuffle dataset\n",
        "# data = data.sample(frac=1).reset_index(drop=True)\n",
        "\n",
        "# # Re-assign index (This is our ID later)\n",
        "# index = range(start_index, start_index + data.shape[0])\n",
        "# data.index = index\n",
        "# data[\"index\"] = data.index\n",
        "# data.head()\n",
        "\n",
        "# # %% Save\n",
        "# data.to_csv(\"HIV_train_oversampled.csv\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "(71634, 4)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2aYAVxWwnH8c"
      },
      "source": [
        "#Build GNN Model"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yfu9Zn_toY4M"
      },
      "source": [
        "##Parameters"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qc5OTWxUoCy6"
      },
      "source": [
        "HYPERPARAMETERS = {\n",
        "    \"batch_size\": [32, 128, 64],\n",
        "    \"learning_rate\": [0.1, 0.05, 0.01, 0.001],\n",
        "    \"weight_decay\": [0.0001, 0.00001, 0.001],\n",
        "    \"sgd_momentum\": [0.9, 0.8, 0.5],\n",
        "    \"scheduler_gamma\": [0.995, 0.9, 0.8, 0.5, 1],\n",
        "    \"pos_weight\" : [1.0, 1.3, 0.8, 0.9],  \n",
        "    \"model_embedding_size\": [8, 16, 32, 64, 128],\n",
        "    \"model_attention_heads\": [1, 2, 3, 4],\n",
        "    \"model_layers\": [2, 4, 5, 8, 10],\n",
        "    \"model_dropout_rate\": [0.2, 0.5, 0.9],\n",
        "    \"model_top_k_ratio\": [0.2, 0.5, 0.8, 0.9],\n",
        "    \"model_top_k_every_n\": [1, 2, 3],\n",
        "    \"model_dense_neurons\": [128, 64, 256, 32]\n",
        "}\n",
        "\n",
        "BEST_PARAMETERS = {\n",
        "    \"batch_size\": [128],\n",
        "    \"learning_rate\": [0.01],\n",
        "    \"weight_decay\": [0.0001],\n",
        "    \"sgd_momentum\": [0.8],\n",
        "    \"scheduler_gamma\": [0.8],\n",
        "    \"pos_weight\": [1.3],\n",
        "    \"model_embedding_size\": [64],\n",
        "    \"model_attention_heads\": [3],\n",
        "    \"model_layers\": [4],\n",
        "    \"model_dropout_rate\": [0.2],\n",
        "    \"model_top_k_ratio\": [0.5],\n",
        "    \"model_top_k_every_n\": [1],\n",
        "    \"model_dense_neurons\": [256]\n",
        "}"
      ],
      "execution_count": 8,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vxcLrpqa8LBe"
      },
      "source": [
        "## GNN Model"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "IWL2LJnemn4A"
      },
      "source": [
        "class GNN(torch.nn.Module):\n",
        "    def __init__(self, feature_size, model_params):\n",
        "        super(GNN, self).__init__()\n",
        "        embedding_size = model_params[\"model_embedding_size\"]\n",
        "        n_heads = model_params[\"model_attention_heads\"]\n",
        "        self.n_layers = model_params[\"model_layers\"]\n",
        "        dropout_rate = model_params[\"model_dropout_rate\"]\n",
        "        top_k_ratio = model_params[\"model_top_k_ratio\"]\n",
        "        self.top_k_every_n = model_params[\"model_top_k_every_n\"]\n",
        "        dense_neurons = model_params[\"model_dense_neurons\"]\n",
        "        edge_dim = model_params[\"model_edge_dim\"]\n",
        "\n",
        "        self.conv_layers = ModuleList([])\n",
        "        self.transf_layers = ModuleList([])\n",
        "        self.pooling_layers = ModuleList([])\n",
        "        self.bn_layers = ModuleList([])\n",
        "\n",
        "        # Transformation layer\n",
        "        self.conv1 = TransformerConv(feature_size, \n",
        "                                    embedding_size, \n",
        "                                    heads=n_heads, \n",
        "                                    dropout=dropout_rate,\n",
        "                                    edge_dim=edge_dim,\n",
        "                                    beta=True) \n",
        "\n",
        "        self.transf1 = Linear(embedding_size*n_heads, embedding_size)\n",
        "        self.bn1 = BatchNorm1d(embedding_size)\n",
        "\n",
        "        # Other layers\n",
        "        for i in range(self.n_layers):\n",
        "            self.conv_layers.append(TransformerConv(embedding_size, \n",
        "                                                    embedding_size, \n",
        "                                                    heads=n_heads, \n",
        "                                                    dropout=dropout_rate,\n",
        "                                                    edge_dim=edge_dim,\n",
        "                                                    beta=True))\n",
        "\n",
        "            self.transf_layers.append(Linear(embedding_size*n_heads, embedding_size))\n",
        "            self.bn_layers.append(BatchNorm1d(embedding_size))\n",
        "            if i % self.top_k_every_n == 0:\n",
        "                self.pooling_layers.append(TopKPooling(embedding_size, ratio=top_k_ratio))\n",
        "            \n",
        "\n",
        "        # Linear layers\n",
        "        self.linear1 = Linear(embedding_size*2, dense_neurons)\n",
        "        self.linear2 = Linear(dense_neurons, int(dense_neurons/2))  \n",
        "        self.linear3 = Linear(int(dense_neurons/2), 1)  \n",
        "\n",
        "    def forward(self, x, edge_attr, edge_index, batch_index):\n",
        "        # Initial transformation\n",
        "        x = self.conv1(x, edge_index, edge_attr)\n",
        "        x = torch.relu(self.transf1(x))\n",
        "        x = self.bn1(x)\n",
        "\n",
        "        # Holds the intermediate graph representations\n",
        "        global_representation = []\n",
        "\n",
        "        for i in range(self.n_layers):\n",
        "            x = self.conv_layers[i](x, edge_index, edge_attr)\n",
        "            x = torch.relu(self.transf_layers[i](x))\n",
        "            x = self.bn_layers[i](x)\n",
        "            # Always aggregate last layer\n",
        "            if i % self.top_k_every_n == 0 or i == self.n_layers:\n",
        "                x , edge_index, edge_attr, batch_index, _, _ = self.pooling_layers[int(i/self.top_k_every_n)](\n",
        "                    x, edge_index, edge_attr, batch_index\n",
        "                    )\n",
        "                # Add current representation\n",
        "                global_representation.append(torch.cat([gmp(x, batch_index), gap(x, batch_index)], dim=1))\n",
        "    \n",
        "        x = sum(global_representation)\n",
        "\n",
        "        # Output block\n",
        "        x = torch.relu(self.linear1(x))\n",
        "        x = F.dropout(x, p=0.8, training=self.training)\n",
        "        x = torch.relu(self.linear2(x))\n",
        "        x = F.dropout(x, p=0.8, training=self.training)\n",
        "        x = self.linear3(x)\n",
        "\n",
        "        return x"
      ],
      "execution_count": 9,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uNgPoWYipdYj"
      },
      "source": [
        "#Train Model"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "sVnzjYWa2rwU"
      },
      "source": [
        "def count_parameters(model):\n",
        "    return sum(p.numel() for p in model.parameters() if p.requires_grad)"
      ],
      "execution_count": 10,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2-BErlD8pfY9"
      },
      "source": [
        "def train_one_epoch(epoch, model, train_loader, optimizer, loss_fn):\n",
        "    # Enumerate over the data\n",
        "    all_preds = []\n",
        "    all_labels = []\n",
        "    running_loss = 0.0\n",
        "    step = 0\n",
        "    for _, batch in enumerate(tqdm(train_loader)):\n",
        "        # Use GPU\n",
        "        batch.to(device)  \n",
        "        # Reset gradients\n",
        "        optimizer.zero_grad() \n",
        "        # Passing the node features and the connection info\n",
        "        pred = model(batch.x.float(), \n",
        "                                batch.edge_attr.float(),\n",
        "                                batch.edge_index, \n",
        "                                batch.batch) \n",
        "        # Calculating the loss and gradients\n",
        "        loss = loss_fn(torch.squeeze(pred), batch.y.float())\n",
        "        loss.backward()  \n",
        "        optimizer.step()  \n",
        "        # Update tracking\n",
        "        running_loss += loss.item()\n",
        "        step += 1\n",
        "        all_preds.append(np.rint(torch.sigmoid(pred).cpu().detach().numpy()))\n",
        "        all_labels.append(batch.y.cpu().detach().numpy())\n",
        "    all_preds = np.concatenate(all_preds).ravel()\n",
        "    all_labels = np.concatenate(all_labels).ravel()\n",
        "    calculate_metrics(all_preds, all_labels, epoch, \"train\")\n",
        "    return running_loss/step\n",
        "\n",
        "def test(epoch, model, test_loader, loss_fn):\n",
        "    all_preds = []\n",
        "    all_preds_raw = []\n",
        "    all_labels = []\n",
        "    running_loss = 0.0\n",
        "    step = 0\n",
        "    for batch in test_loader:\n",
        "        batch.to(device)  \n",
        "        pred = model(batch.x.float(), \n",
        "                        batch.edge_attr.float(),\n",
        "                        batch.edge_index, \n",
        "                        batch.batch) \n",
        "        loss = loss_fn(torch.squeeze(pred), batch.y.float())\n",
        "\n",
        "         # Update tracking\n",
        "        running_loss += loss.item()\n",
        "        step += 1\n",
        "        all_preds.append(np.rint(torch.sigmoid(pred).cpu().detach().numpy()))\n",
        "        all_preds_raw.append(torch.sigmoid(pred).cpu().detach().numpy())\n",
        "        all_labels.append(batch.y.cpu().detach().numpy())\n",
        "    \n",
        "    all_preds = np.concatenate(all_preds).ravel()\n",
        "    all_labels = np.concatenate(all_labels).ravel()\n",
        "    print(all_preds_raw[0][:10])\n",
        "    print(all_preds[:10])\n",
        "    print(all_labels[:10])\n",
        "    calculate_metrics(all_preds, all_labels, epoch, \"test\")\n",
        "    log_conf_matrix(all_preds, all_labels, epoch)\n",
        "    return running_loss/step\n",
        "\n",
        "def log_conf_matrix(y_pred, y_true, epoch):\n",
        "    # Log confusion matrix as image\n",
        "    cm = confusion_matrix(y_pred, y_true)\n",
        "    classes = [\"0\", \"1\"]\n",
        "    df_cfm = pd.DataFrame(cm, index = classes, columns = classes)\n",
        "    plt.figure(figsize = (10,7))\n",
        "    cfm_plot = sns.heatmap(df_cfm, annot=True, cmap='Blues', fmt='g')\n",
        "    cfm_plot.figure.savefig(f'/content/data/images/cm_{epoch}.png')\n",
        "    mlflow.log_artifact(f\"/content/data/images/cm_{epoch}.png\")\n",
        "\n",
        "def calculate_metrics(y_pred, y_true, epoch, type):\n",
        "    print(f\"\\n Confusion matrix: \\n {confusion_matrix(y_pred, y_true)}\")\n",
        "    print(f\"F1 Score: {f1_score(y_pred, y_true)}\")\n",
        "    print(f\"Accuracy: {accuracy_score(y_pred, y_true)}\")\n",
        "    prec = precision_score(y_pred, y_true)\n",
        "    rec = recall_score(y_pred, y_true)\n",
        "    print(f\"Precision: {prec}\")\n",
        "    print(f\"Recall: {rec}\")\n",
        "    mlflow.log_metric(key=f\"Precision-{type}\", value=float(prec), step=epoch)\n",
        "    mlflow.log_metric(key=f\"Recall-{type}\", value=float(rec), step=epoch)\n",
        "    try:\n",
        "        roc = roc_auc_score(y_pred, y_true)\n",
        "        print(f\"ROC AUC: {roc}\")\n",
        "        mlflow.log_metric(key=f\"ROC-AUC-{type}\", value=float(roc), step=epoch)\n",
        "    except:\n",
        "        mlflow.log_metric(key=f\"ROC-AUC-{type}\", value=float(0), step=epoch)\n",
        "        print(f\"ROC AUC: notdefined\")\n",
        "\n",
        "# %% Run the training\n",
        "from mango import scheduler, Tuner\n",
        "\n",
        "def run_one_training(params):\n",
        "    params = params[0]\n",
        "    with mlflow.start_run() as run:\n",
        "        # Log parameters used in this experiment\n",
        "        for key in params.keys():\n",
        "            mlflow.log_param(key, params[key])\n",
        "\n",
        "        # Loading the dataset\n",
        "        print(\"Loading dataset...\")\n",
        "        train_dataset = MoleculeDataset(root=\"/content/data/\", filename=\"HIV_train_oversampled.csv\")\n",
        "        test_dataset = MoleculeDataset(root=\"/content/data/\", filename=\"HIV_test.csv\", test=True)\n",
        "        params[\"model_edge_dim\"] = train_dataset[0].edge_attr.shape[1]\n",
        "\n",
        "        # Prepare training\n",
        "        train_loader = DataLoader(train_dataset, batch_size=params[\"batch_size\"], shuffle=True)\n",
        "        test_loader = DataLoader(test_dataset, batch_size=params[\"batch_size\"], shuffle=True)\n",
        "\n",
        "        # Loading the model\n",
        "        print(\"Loading model...\")\n",
        "        model_params = {k: v for k, v in params.items() if k.startswith(\"model_\")}\n",
        "        model = GNN(feature_size=train_dataset[0].x.shape[1], model_params=model_params) \n",
        "        model = model.to(device)\n",
        "        print(f\"Number of parameters: {count_parameters(model)}\")\n",
        "        mlflow.log_param(\"num_params\", count_parameters(model))\n",
        "\n",
        "        # < 1 increases precision, > 1 recall\n",
        "        weight = torch.tensor([params[\"pos_weight\"]], dtype=torch.float32).to(device)\n",
        "        loss_fn = torch.nn.BCEWithLogitsLoss(pos_weight=weight)\n",
        "        optimizer = torch.optim.SGD(model.parameters(), \n",
        "                                    lr=params[\"learning_rate\"],\n",
        "                                    momentum=params[\"sgd_momentum\"],\n",
        "                                    weight_decay=params[\"weight_decay\"])\n",
        "        scheduler = torch.optim.lr_scheduler.ExponentialLR(optimizer, gamma=params[\"scheduler_gamma\"])\n",
        "        \n",
        "        # Start training\n",
        "        best_loss = 1000\n",
        "        early_stopping_counter = 0\n",
        "        for epoch in range(300): \n",
        "            if early_stopping_counter <= 10: # = x * 5 \n",
        "                # Training\n",
        "                model.train()\n",
        "                loss = train_one_epoch(epoch, model, train_loader, optimizer, loss_fn)\n",
        "                print(f\"Epoch {epoch} | Train Loss {loss}\")\n",
        "                mlflow.log_metric(key=\"Train loss\", value=float(loss), step=epoch)\n",
        "\n",
        "                # Testing\n",
        "                model.eval()\n",
        "                if epoch % 5 == 0:\n",
        "                    loss = test(epoch, model, test_loader, loss_fn)\n",
        "                    print(f\"Epoch {epoch} | Test Loss {loss}\")\n",
        "                    mlflow.log_metric(key=\"Test loss\", value=float(loss), step=epoch)\n",
        "                    \n",
        "                    # Update best loss\n",
        "                    if float(loss) < best_loss:\n",
        "                        best_loss = loss\n",
        "                        # Save the currently best model \n",
        "                        mlflow.pytorch.log_model(model, \"model\")\n",
        "                        early_stopping_counter = 0\n",
        "                    else:\n",
        "                        early_stopping_counter += 1\n",
        "\n",
        "                scheduler.step()\n",
        "            else:\n",
        "                print(\"Early stopping due to no improvement.\")\n",
        "                return [best_loss]\n",
        "    print(f\"Finishing training with best test loss: {best_loss}\")\n",
        "    return [best_loss]\n",
        "\n"
      ],
      "execution_count": 12,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2ZLkL1Rwqyfx"
      },
      "source": [
        "# Hyperparameter search"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "AVqACppXqzdm",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "22988505-bac1-4c42-d7c1-641e0776e978"
      },
      "source": [
        "# Hyperparameter search\n",
        "print(\"Running hyperparameter search...\")\n",
        "config = dict()\n",
        "config[\"optimizer\"] = \"Bayesian\"\n",
        "config[\"num_iteration\"] = 100\n",
        "\n",
        "tuner = Tuner(HYPERPARAMETERS, \n",
        "              objective=run_one_training,\n",
        "              conf_dict=config) \n",
        "results = tuner.minimize()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Running hyperparameter search...\n",
            "Loading dataset...\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "  0%|          | 18/71634 [00:00<06:42, 177.82it/s]"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "Processing...\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "100%|██████████| 71634/71634 [03:12<00:00, 372.06it/s]\n",
            "  1%|          | 46/3999 [00:00<00:08, 452.53it/s]"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "Done!\n",
            "Processing...\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "100%|██████████| 3999/3999 [00:09<00:00, 420.65it/s]\n",
            "  0%|          | 0/1120 [00:00<?, ?it/s]"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "Done!\n",
            "Loading model...\n",
            "Number of parameters: 107393\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "100%|██████████| 1120/1120 [01:45<00:00, 10.57it/s]\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            " Confusion matrix: \n",
            " [[21783 20998]\n",
            " [14067 14786]]\n",
            "F1 Score: 0.45750885715611805\n",
            "Accuracy: 0.5104978083033197\n",
            "Precision: 0.4132014308070646\n",
            "Recall: 0.5124597095622639\n",
            "ROC AUC: 0.5108171715806458\n",
            "Epoch 0 | Train Loss 0.7193575033651931\n",
            "[[0.4848217]\n",
            " [0.4848217]\n",
            " [0.4848217]\n",
            " [0.4848217]\n",
            " [0.4848217]\n",
            " [0.4848217]\n",
            " [0.4848217]\n",
            " [0.4848217]\n",
            " [0.4848217]\n",
            " [0.4848217]]\n",
            "[0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\n",
            "[0 1 0 0 0 0 0 0 0 0]\n",
            "\n",
            " Confusion matrix: \n",
            " [[3834  165]\n",
            " [   0    0]]\n",
            "F1 Score: 0.0\n",
            "Accuracy: 0.9587396849212303\n",
            "Precision: 0.0\n",
            "Recall: 0.0\n",
            "ROC AUC: notdefined\n",
            "Epoch 0 | Test Loss 0.6657595511466737\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "100%|██████████| 1120/1120 [01:36<00:00, 11.66it/s]\n",
            "  0%|          | 0/1120 [00:00<?, ?it/s]"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            " Confusion matrix: \n",
            " [[21225 20333]\n",
            " [14625 15451]]\n",
            "F1 Score: 0.4692074096568479\n",
            "Accuracy: 0.5119915124103079\n",
            "Precision: 0.4317851553767047\n",
            "Recall: 0.5137318792392606\n",
            "ROC AUC: 0.5122319341333219\n",
            "Epoch 1 | Train Loss 0.6932941076478788\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "100%|██████████| 1120/1120 [01:29<00:00, 12.53it/s]\n",
            "  0%|          | 0/1120 [00:00<?, ?it/s]"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            " Confusion matrix: \n",
            " [[25645 24029]\n",
            " [10205 11755]]\n",
            "F1 Score: 0.4071418675533388\n",
            "Accuracy: 0.5220984448725465\n",
            "Precision: 0.32849877040017883\n",
            "Recall: 0.5352914389799636\n",
            "ROC AUC: 0.5257787468282271\n",
            "Epoch 2 | Train Loss 0.6907515985092947\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "100%|██████████| 1120/1120 [01:29<00:00, 12.52it/s]\n",
            "  0%|          | 0/1120 [00:00<?, ?it/s]"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            " Confusion matrix: \n",
            " [[29868 27402]\n",
            " [ 5982  8382]]\n",
            "F1 Score: 0.33429050011964584\n",
            "Accuracy: 0.5339643186196499\n",
            "Precision: 0.23423876592890677\n",
            "Recall: 0.5835421888053467\n",
            "ROC AUC: 0.552535892726403\n",
            "Epoch 3 | Train Loss 0.6881342451487269\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "100%|██████████| 1120/1120 [01:32<00:00, 12.08it/s]\n",
            "  0%|          | 0/1120 [00:00<?, ?it/s]"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            " Confusion matrix: \n",
            " [[30637 27032]\n",
            " [ 5213  8752]]\n",
            "F1 Score: 0.35184626826669885\n",
            "Accuracy: 0.5498645894407683\n",
            "Precision: 0.2445785826067516\n",
            "Recall: 0.6267096312209094\n",
            "ROC AUC: 0.5789827959811911\n",
            "Epoch 4 | Train Loss 0.6847330038568803\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "100%|██████████| 1120/1120 [01:32<00:00, 12.08it/s]\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            " Confusion matrix: \n",
            " [[31304 27179]\n",
            " [ 4546  8605]]\n",
            "F1 Score: 0.35169101869827324\n",
            "Accuracy: 0.5571237122037022\n",
            "Precision: 0.24047060138609436\n",
            "Recall: 0.6543228651813551\n",
            "ROC AUC: 0.5947947619342475\n",
            "Epoch 5 | Train Loss 0.6818184408758368\n",
            "[[0.473637]\n",
            " [0.473637]\n",
            " [0.473637]\n",
            " [0.473637]\n",
            " [0.473637]\n",
            " [0.473637]\n",
            " [0.473637]\n",
            " [0.473637]\n",
            " [0.473637]\n",
            " [0.473637]]\n",
            "[0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\n",
            "[0 0 0 0 0 0 0 0 0 0]\n",
            "\n",
            " Confusion matrix: \n",
            " [[3834  165]\n",
            " [   0    0]]\n",
            "F1 Score: 0.0\n",
            "Accuracy: 0.9587396849212303\n",
            "Precision: 0.0\n",
            "Recall: 0.0\n",
            "ROC AUC: notdefined\n",
            "Epoch 5 | Test Loss 0.6461113975161598\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "100%|██████████| 1120/1120 [01:32<00:00, 12.06it/s]\n",
            "  0%|          | 0/1120 [00:00<?, ?it/s]"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            " Confusion matrix: \n",
            " [[30892 26487]\n",
            " [ 4958  9297]]\n",
            "F1 Score: 0.3715901596754531\n",
            "Accuracy: 0.5610324706145127\n",
            "Precision: 0.25980885311871227\n",
            "Recall: 0.6521922132585057\n",
            "ROC AUC: 0.595288668367868\n",
            "Epoch 6 | Train Loss 0.6789358463670526\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "100%|██████████| 1120/1120 [01:30<00:00, 12.31it/s]\n",
            "  0%|          | 0/1120 [00:00<?, ?it/s]"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            " Confusion matrix: \n",
            " [[31220 26608]\n",
            " [ 4630  9176]]\n",
            "F1 Score: 0.37007461181689855\n",
            "Accuracy: 0.563922159868219\n",
            "Precision: 0.2564274536105522\n",
            "Recall: 0.6646385629436476\n",
            "ROC AUC: 0.6022577195986829\n",
            "Epoch 7 | Train Loss 0.6779471314379147\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "100%|██████████| 1120/1120 [01:30<00:00, 12.38it/s]\n",
            "  0%|          | 0/1120 [00:00<?, ?it/s]"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            " Confusion matrix: \n",
            " [[30867 26306]\n",
            " [ 4983  9478]]\n",
            "F1 Score: 0.37727137028560054\n",
            "Accuracy: 0.5632102074433928\n",
            "Precision: 0.26486697965571204\n",
            "Recall: 0.6554180208837563\n",
            "ROC AUC: 0.5976528650585679\n",
            "Epoch 8 | Train Loss 0.6772041521434273\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "100%|██████████| 1120/1120 [01:29<00:00, 12.46it/s]\n",
            "  0%|          | 0/1120 [00:00<?, ?it/s]"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            " Confusion matrix: \n",
            " [[30997 26325]\n",
            " [ 4853  9459]]\n",
            "F1 Score: 0.3776349409134462\n",
            "Accuracy: 0.5647597509562499\n",
            "Precision: 0.2643360160965795\n",
            "Recall: 0.6609139183901621\n",
            "ROC AUC: 0.6008330800561814\n",
            "Epoch 9 | Train Loss 0.6762493279363427\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "100%|██████████| 1120/1120 [01:29<00:00, 12.45it/s]\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            " Confusion matrix: \n",
            " [[31009 26162]\n",
            " [ 4841  9622]]\n",
            "F1 Score: 0.3829880390869107\n",
            "Accuracy: 0.5672027249630064\n",
            "Precision: 0.26889112452492736\n",
            "Recall: 0.6652838276982646\n",
            "ROC AUC: 0.6038371002198447\n",
            "Epoch 10 | Train Loss 0.6751596766923155\n",
            "[[0.472838]\n",
            " [0.472838]\n",
            " [0.472838]\n",
            " [0.472838]\n",
            " [0.472838]\n",
            " [0.472838]\n",
            " [0.472838]\n",
            " [0.472838]\n",
            " [0.472838]\n",
            " [0.472838]]\n",
            "[0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\n",
            "[0 0 0 0 0 0 0 0 0 0]\n",
            "\n",
            " Confusion matrix: \n",
            " [[3834  165]\n",
            " [   0    0]]\n",
            "F1 Score: 0.0\n",
            "Accuracy: 0.9587396849212303\n",
            "Precision: 0.0\n",
            "Recall: 0.0\n",
            "ROC AUC: notdefined\n",
            "Epoch 10 | Test Loss 0.6446978970179482\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "100%|██████████| 1120/1120 [01:31<00:00, 12.29it/s]\n",
            "  0%|          | 0/1120 [00:00<?, ?it/s]"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            " Confusion matrix: \n",
            " [[30850 26127]\n",
            " [ 5000  9657]]\n",
            "F1 Score: 0.3829027973275708\n",
            "Accuracy: 0.565471703381076\n",
            "Precision: 0.2698692152917505\n",
            "Recall: 0.6588660708194037\n",
            "ROC AUC: 0.6001563097133683\n",
            "Epoch 11 | Train Loss 0.6751498057906117\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "100%|██████████| 1120/1120 [01:31<00:00, 12.30it/s]\n",
            "  0%|          | 0/1120 [00:00<?, ?it/s]"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            " Confusion matrix: \n",
            " [[30399 25549]\n",
            " [ 5451 10235]]\n",
            "F1 Score: 0.39770740237031277\n",
            "Accuracy: 0.5672446045174079\n",
            "Precision: 0.286021685669573\n",
            "Recall: 0.6524926686217009\n",
            "ROC AUC: 0.5979182439412214\n",
            "Epoch 12 | Train Loss 0.673660561548812\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "100%|██████████| 1120/1120 [01:31<00:00, 12.28it/s]\n",
            "  0%|          | 0/1120 [00:00<?, ?it/s]"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            " Confusion matrix: \n",
            " [[30192 25269]\n",
            " [ 5658 10515]]\n",
            "F1 Score: 0.40475778047231364\n",
            "Accuracy: 0.5682636736745121\n",
            "Precision: 0.29384641180415827\n",
            "Recall: 0.6501576701910592\n",
            "ROC AUC: 0.5972701046362879\n",
            "Epoch 13 | Train Loss 0.6735506797475475\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "100%|██████████| 1120/1120 [01:30<00:00, 12.40it/s]\n",
            "  0%|          | 0/1120 [00:00<?, ?it/s]"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            " Confusion matrix: \n",
            " [[30031 25189]\n",
            " [ 5819 10595]]\n",
            "F1 Score: 0.4059542511207326\n",
            "Accuracy: 0.5671329257056705\n",
            "Precision: 0.2960820478426112\n",
            "Recall: 0.6454855611063726\n",
            "ROC AUC: 0.5946641858411255\n",
            "Epoch 14 | Train Loss 0.6737265724156584\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "100%|██████████| 1120/1120 [01:30<00:00, 12.38it/s]\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            " Confusion matrix: \n",
            " [[29988 24995]\n",
            " [ 5862 10789]]\n",
            "F1 Score: 0.4115190235529704\n",
            "Accuracy: 0.5692408632772147\n",
            "Precision: 0.3015034652358596\n",
            "Recall: 0.6479490721278002\n",
            "ROC AUC: 0.5966770077369628\n",
            "Epoch 15 | Train Loss 0.6739416841417551\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "\r  0%|          | 0/1120 [00:00<?, ?it/s]"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "[[0.47819906]\n",
            " [0.47819906]\n",
            " [0.47819906]\n",
            " [0.47819906]\n",
            " [0.47819906]\n",
            " [0.47819906]\n",
            " [0.47819906]\n",
            " [0.47819906]\n",
            " [0.47819906]\n",
            " [0.47819906]]\n",
            "[0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\n",
            "[0 1 0 0 0 0 0 0 0 1]\n",
            "\n",
            " Confusion matrix: \n",
            " [[3834  165]\n",
            " [   0    0]]\n",
            "F1 Score: 0.0\n",
            "Accuracy: 0.9587396849212303\n",
            "Precision: 0.0\n",
            "Recall: 0.0\n",
            "ROC AUC: notdefined\n",
            "Epoch 15 | Test Loss 0.6541322271029154\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "100%|██████████| 1120/1120 [01:28<00:00, 12.62it/s]\n",
            "  0%|          | 0/1120 [00:00<?, ?it/s]"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            " Confusion matrix: \n",
            " [[29633 24571]\n",
            " [ 6217 11213]]\n",
            "F1 Score: 0.421430450633292\n",
            "Accuracy: 0.5702040930284502\n",
            "Precision: 0.3133523362396602\n",
            "Recall: 0.6433161216293747\n",
            "ROC AUC: 0.5950050462770149\n",
            "Epoch 16 | Train Loss 0.674131447502545\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "100%|██████████| 1120/1120 [01:29<00:00, 12.48it/s]\n",
            "  0%|          | 0/1120 [00:00<?, ?it/s]"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            " Confusion matrix: \n",
            " [[29698 24589]\n",
            " [ 6152 11195]]\n",
            "F1 Score: 0.42141122884944754\n",
            "Accuracy: 0.5708602060474076\n",
            "Precision: 0.31284931813100825\n",
            "Recall: 0.6453565458004266\n",
            "ROC AUC: 0.596206005138134\n",
            "Epoch 17 | Train Loss 0.6725170201488904\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "100%|██████████| 1120/1120 [01:30<00:00, 12.36it/s]\n",
            "  0%|          | 0/1120 [00:00<?, ?it/s]"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            " Confusion matrix: \n",
            " [[29770 24786]\n",
            " [ 6080 10998]]\n",
            "F1 Score: 0.416102304112595\n",
            "Accuracy: 0.5691152246140101\n",
            "Precision: 0.3073440643863179\n",
            "Recall: 0.643986415271109\n",
            "ROC AUC: 0.594832125444778\n",
            "Epoch 18 | Train Loss 0.6730312713022742\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "100%|██████████| 1120/1120 [01:29<00:00, 12.50it/s]\n",
            "  0%|          | 0/1120 [00:00<?, ?it/s]"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            " Confusion matrix: \n",
            " [[30003 24920]\n",
            " [ 5847 10864]]\n",
            "F1 Score: 0.4139060862939328\n",
            "Accuracy: 0.570497249909261\n",
            "Precision: 0.30359937402190923\n",
            "Recall: 0.650110705523308\n",
            "ROC AUC: 0.5981922899282327\n",
            "Epoch 19 | Train Loss 0.6722513219607728\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "100%|██████████| 1120/1120 [01:28<00:00, 12.68it/s]\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            " Confusion matrix: \n",
            " [[29992 24908]\n",
            " [ 5858 10876]]\n",
            "F1 Score: 0.41418180433375223\n",
            "Accuracy: 0.5705112097607281\n",
            "Precision: 0.3039347194276772\n",
            "Recall: 0.6499342655671089\n",
            "ROC AUC: 0.5981183167544106\n",
            "Epoch 20 | Train Loss 0.6718496401927301\n",
            "[[0.47220322]\n",
            " [0.47220322]\n",
            " [0.47220322]\n",
            " [0.47220322]\n",
            " [0.47220322]\n",
            " [0.47220322]\n",
            " [0.47220322]\n",
            " [0.47220322]\n",
            " [0.47220322]\n",
            " [0.47220322]]\n",
            "[0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\n",
            "[1 1 0 0 0 0 0 0 0 0]\n",
            "\n",
            " Confusion matrix: \n",
            " [[3833  164]\n",
            " [   1    1]]\n",
            "F1 Score: 0.011976047904191616\n",
            "Accuracy: 0.9587396849212303\n",
            "Precision: 0.006060606060606061\n",
            "Recall: 0.5\n",
            "ROC AUC: 0.7294846134600952\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "\r  0%|          | 0/1120 [00:00<?, ?it/s]"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "Epoch 20 | Test Loss 0.6436145892218937\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "100%|██████████| 1120/1120 [01:29<00:00, 12.46it/s]\n",
            "  0%|          | 0/1120 [00:00<?, ?it/s]"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            " Confusion matrix: \n",
            " [[29910 24792]\n",
            " [ 5940 10992]]\n",
            "F1 Score: 0.4170270885499658\n",
            "Accuracy: 0.5709858447106123\n",
            "Precision: 0.3071763916834339\n",
            "Recall: 0.6491849751948973\n",
            "ROC AUC: 0.5979828572365843\n",
            "Epoch 21 | Train Loss 0.6719448657440288\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "100%|██████████| 1120/1120 [01:28<00:00, 12.60it/s]\n",
            "  0%|          | 0/1120 [00:00<?, ?it/s]"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            " Confusion matrix: \n",
            " [[29960 24827]\n",
            " [ 5890 10957]]\n",
            "F1 Score: 0.41637058007638084\n",
            "Accuracy: 0.57119524248262\n",
            "Precision: 0.30619830091661077\n",
            "Recall: 0.6503828574820443\n",
            "ROC AUC: 0.5986139559828861\n",
            "Epoch 22 | Train Loss 0.6720612505184752\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "100%|██████████| 1120/1120 [01:30<00:00, 12.44it/s]\n",
            "  0%|          | 0/1120 [00:00<?, ?it/s]"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            " Confusion matrix: \n",
            " [[29729 24593]\n",
            " [ 6121 11191]]\n",
            "F1 Score: 0.4215383456380895\n",
            "Accuracy: 0.5712371220370215\n",
            "Precision: 0.31273753632908563\n",
            "Recall: 0.6464302218114603\n",
            "ROC AUC: 0.5968519431284024\n",
            "Epoch 23 | Train Loss 0.6723657856562308\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "100%|██████████| 1120/1120 [01:30<00:00, 12.36it/s]\n",
            "  0%|          | 0/1120 [00:00<?, ?it/s]"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            " Confusion matrix: \n",
            " [[29812 24755]\n",
            " [ 6038 11029]]\n",
            "F1 Score: 0.4173620177480086\n",
            "Accuracy: 0.5701342937711142\n",
            "Precision: 0.3082103733512184\n",
            "Recall: 0.6462178473076697\n",
            "ROC AUC: 0.5962776886583248\n",
            "Epoch 24 | Train Loss 0.6719877577785934\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "100%|██████████| 1120/1120 [01:30<00:00, 12.38it/s]\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            " Confusion matrix: \n",
            " [[29905 24774]\n",
            " [ 5945 11010]]\n",
            "F1 Score: 0.4175278257077305\n",
            "Accuracy: 0.5711673227796856\n",
            "Precision: 0.30767940979208586\n",
            "Recall: 0.6493659687407844\n",
            "ROC AUC: 0.5981426306697027\n",
            "Epoch 25 | Train Loss 0.6725003682609115\n",
            "[[0.4683882 ]\n",
            " [0.46903047]\n",
            " [0.46793297]\n",
            " [0.48098552]\n",
            " [0.47405916]\n",
            " [0.46759295]\n",
            " [0.46528715]\n",
            " [0.4683246 ]\n",
            " [0.4685504 ]\n",
            " [0.46848217]]\n",
            "[0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\n",
            "[0 0 0 0 0 0 0 0 0 0]\n",
            "\n",
            " Confusion matrix: \n",
            " [[3832  164]\n",
            " [   2    1]]\n",
            "F1 Score: 0.011904761904761906\n",
            "Accuracy: 0.9584896224056014\n",
            "Precision: 0.006060606060606061\n",
            "Recall: 0.3333333333333333\n",
            "ROC AUC: 0.6461461461461462\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "\r  0%|          | 0/1120 [00:00<?, ?it/s]"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "Epoch 25 | Test Loss 0.6389039754867554\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "100%|██████████| 1120/1120 [01:30<00:00, 12.43it/s]\n",
            "  0%|          | 0/1120 [00:00<?, ?it/s]"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            " Confusion matrix: \n",
            " [[29777 24616]\n",
            " [ 6073 11168]]\n",
            "F1 Score: 0.4212352663837812\n",
            "Accuracy: 0.571586118323701\n",
            "Precision: 0.3120947909680304\n",
            "Recall: 0.647758250681515\n",
            "ROC AUC: 0.5976000085426401\n",
            "Epoch 26 | Train Loss 0.6716503135859966\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "100%|██████████| 1120/1120 [01:31<00:00, 12.22it/s]\n",
            "  0%|          | 0/1120 [00:00<?, ?it/s]"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            " Confusion matrix: \n",
            " [[29777 24654]\n",
            " [ 6073 11130]]\n",
            "F1 Score: 0.420103044142903\n",
            "Accuracy: 0.5710556439679482\n",
            "Precision: 0.31103286384976525\n",
            "Recall: 0.6469801778759519\n",
            "ROC AUC: 0.5970198789473455\n",
            "Epoch 27 | Train Loss 0.6711692728634392\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "100%|██████████| 1120/1120 [01:31<00:00, 12.21it/s]\n",
            "  0%|          | 0/1120 [00:00<?, ?it/s]"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            " Confusion matrix: \n",
            " [[29791 24759]\n",
            " [ 6059 11025]]\n",
            "F1 Score: 0.41707649239615646\n",
            "Accuracy: 0.5697852974844347\n",
            "Precision: 0.30809859154929575\n",
            "Recall: 0.6453406696324046\n",
            "ROC AUC: 0.5957317463652398\n",
            "Epoch 28 | Train Loss 0.6725003506988287\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "100%|██████████| 1120/1120 [01:30<00:00, 12.42it/s]\n",
            "  0%|          | 0/1120 [00:00<?, ?it/s]"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            " Confusion matrix: \n",
            " [[29835 24724]\n",
            " [ 6015 11060]]\n",
            "F1 Score: 0.4184717834238257\n",
            "Accuracy: 0.570888125750342\n",
            "Precision: 0.30907668231611896\n",
            "Recall: 0.6477306002928258\n",
            "ROC AUC: 0.5972849009455478\n",
            "Epoch 29 | Train Loss 0.6719061224056142\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "100%|██████████| 1120/1120 [01:29<00:00, 12.47it/s]\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            " Confusion matrix: \n",
            " [[29911 24707]\n",
            " [ 5939 11077]]\n",
            "F1 Score: 0.4195833333333333\n",
            "Accuracy: 0.5721863919367898\n",
            "Precision: 0.30955175497429016\n",
            "Recall: 0.6509755524212506\n",
            "ROC AUC: 0.5993077622957987\n",
            "Epoch 30 | Train Loss 0.6711990811462913\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "\r  0%|          | 0/1120 [00:00<?, ?it/s]"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "[[0.47294205]\n",
            " [0.47294205]\n",
            " [0.47294205]\n",
            " [0.47294205]\n",
            " [0.47294205]\n",
            " [0.47294205]\n",
            " [0.47294205]\n",
            " [0.47294205]\n",
            " [0.47294205]\n",
            " [0.47294205]]\n",
            "[0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\n",
            "[0 0 0 0 0 0 0 0 0 0]\n",
            "\n",
            " Confusion matrix: \n",
            " [[3834  165]\n",
            " [   0    0]]\n",
            "F1 Score: 0.0\n",
            "Accuracy: 0.9587396849212303\n",
            "Precision: 0.0\n",
            "Recall: 0.0\n",
            "ROC AUC: notdefined\n",
            "Epoch 30 | Test Loss 0.6449354111202179\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "100%|██████████| 1120/1120 [01:31<00:00, 12.27it/s]\n",
            "  0%|          | 0/1120 [00:00<?, ?it/s]"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            " Confusion matrix: \n",
            " [[29770 24666]\n",
            " [ 6080 11118]]\n",
            "F1 Score: 0.4196897059378657\n",
            "Accuracy: 0.5707904067900718\n",
            "Precision: 0.31069751844399734\n",
            "Recall: 0.646470519827887\n",
            "ROC AUC: 0.5966756302570988\n",
            "Epoch 31 | Train Loss 0.6718522188386746\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "100%|██████████| 1120/1120 [01:31<00:00, 12.27it/s]\n",
            "  0%|          | 0/1120 [00:00<?, ?it/s]"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            " Confusion matrix: \n",
            " [[29863 24673]\n",
            " [ 5987 11111]]\n",
            "F1 Score: 0.4202185999016679\n",
            "Accuracy: 0.5719909540162492\n",
            "Precision: 0.3105019002906327\n",
            "Recall: 0.6498420867937771\n",
            "ROC AUC: 0.5987126672783614\n",
            "Epoch 32 | Train Loss 0.671368431566017\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "100%|██████████| 1120/1120 [01:30<00:00, 12.38it/s]\n",
            "  0%|          | 0/1120 [00:00<?, ?it/s]"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            " Confusion matrix: \n",
            " [[29876 24790]\n",
            " [ 5974 10994]]\n",
            "F1 Score: 0.41681831968456173\n",
            "Accuracy: 0.5705391294636625\n",
            "Precision: 0.3072322825843953\n",
            "Recall: 0.6479255068363979\n",
            "ROC AUC: 0.5972221834112477\n",
            "Epoch 33 | Train Loss 0.6721609222569636\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "100%|██████████| 1120/1120 [01:31<00:00, 12.27it/s]\n",
            "  0%|          | 0/1120 [00:00<?, ?it/s]"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            " Confusion matrix: \n",
            " [[29771 24657]\n",
            " [ 6079 11127]]\n",
            "F1 Score: 0.41996603132666543\n",
            "Accuracy: 0.5709300053047436\n",
            "Precision: 0.31094902749832326\n",
            "Recall: 0.6466930140648611\n",
            "ROC AUC: 0.5968362549562933\n",
            "Epoch 34 | Train Loss 0.672517712946449\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "100%|██████████| 1120/1120 [01:31<00:00, 12.29it/s]\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            " Confusion matrix: \n",
            " [[29811 24788]\n",
            " [ 6039 10996]]\n",
            "F1 Score: 0.41636532308449614\n",
            "Accuracy: 0.5696596588212302\n",
            "Precision: 0.3072881734853566\n",
            "Recall: 0.6454945700029351\n",
            "ROC AUC: 0.595746790486916\n",
            "Epoch 35 | Train Loss 0.6722480654184307\n",
            "[[0.46765247]\n",
            " [0.46648398]\n",
            " [0.4840832 ]\n",
            " [0.46885136]\n",
            " [0.46848541]\n",
            " [0.47215188]\n",
            " [0.4662457 ]\n",
            " [0.46821347]\n",
            " [0.46710292]\n",
            " [0.46753234]]\n",
            "[0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\n",
            "[0 0 1 0 0 0 0 0 0 0]\n",
            "\n",
            " Confusion matrix: \n",
            " [[3832  164]\n",
            " [   2    1]]\n",
            "F1 Score: 0.011904761904761906\n",
            "Accuracy: 0.9584896224056014\n",
            "Precision: 0.006060606060606061\n",
            "Recall: 0.3333333333333333\n",
            "ROC AUC: 0.6461461461461462\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "  0%|          | 2/1120 [00:00<01:32, 12.12it/s]"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "Epoch 35 | Test Loss 0.6396568237789093\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "100%|██████████| 1120/1120 [01:30<00:00, 12.39it/s]\n",
            "  0%|          | 0/1120 [00:00<?, ?it/s]"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            " Confusion matrix: \n",
            " [[29781 24744]\n",
            " [ 6069 11040]]\n",
            "F1 Score: 0.41744654302081563\n",
            "Accuracy: 0.5698550967417707\n",
            "Precision: 0.3085177733065057\n",
            "Recall: 0.6452744169735227\n",
            "ROC AUC: 0.5957321190782332\n",
            "Epoch 36 | Train Loss 0.6724205411438431\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "100%|██████████| 1120/1120 [01:33<00:00, 11.97it/s]\n",
            "  0%|          | 0/1120 [00:00<?, ?it/s]"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            " Confusion matrix: \n",
            " [[29782 24591]\n",
            " [ 6068 11193]]\n",
            "F1 Score: 0.4220190404373645\n",
            "Accuracy: 0.5720049138677165\n",
            "Precision: 0.31279342723004694\n",
            "Recall: 0.6484560570071259\n",
            "ROC AUC: 0.5980955730569258\n",
            "Epoch 37 | Train Loss 0.6707878532686404\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "100%|██████████| 1120/1120 [01:31<00:00, 12.26it/s]\n",
            "  0%|          | 0/1120 [00:00<?, ?it/s]"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            " Confusion matrix: \n",
            " [[29749 24619]\n",
            " [ 6101 11165]]\n",
            "F1 Score: 0.42092365692742695\n",
            "Accuracy: 0.5711533629282184\n",
            "Precision: 0.3120109546165884\n",
            "Recall: 0.6466465886713773\n",
            "ROC AUC: 0.5969125380084372\n",
            "Epoch 38 | Train Loss 0.6714823787233659\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "100%|██████████| 1120/1120 [01:31<00:00, 12.27it/s]\n",
            "  0%|          | 0/1120 [00:00<?, ?it/s]"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            " Confusion matrix: \n",
            " [[29774 24691]\n",
            " [ 6076 11093]]\n",
            "F1 Score: 0.4189753177345949\n",
            "Accuracy: 0.570497249909261\n",
            "Precision: 0.3099988821819808\n",
            "Recall: 0.6461063544760907\n",
            "ROC AUC: 0.5963846745298842\n",
            "Epoch 39 | Train Loss 0.6720724322433983\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "100%|██████████| 1120/1120 [01:32<00:00, 12.05it/s]\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            " Confusion matrix: \n",
            " [[29651 24699]\n",
            " [ 6199 11085]]\n",
            "F1 Score: 0.41776588527926434\n",
            "Accuracy: 0.5686685093670604\n",
            "Precision: 0.3097753185781355\n",
            "Recall: 0.6413445961582966\n",
            "ROC AUC: 0.5934505869475936\n",
            "Epoch 40 | Train Loss 0.67278720417193\n",
            "[[0.47299105]\n",
            " [0.47299105]\n",
            " [0.47299105]\n",
            " [0.47299105]\n",
            " [0.47299105]\n",
            " [0.47299105]\n",
            " [0.47299105]\n",
            " [0.47299105]\n",
            " [0.47299105]\n",
            " [0.47299105]]\n",
            "[0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\n",
            "[0 0 0 0 0 0 0 0 0 0]\n",
            "\n",
            " Confusion matrix: \n",
            " [[3834  165]\n",
            " [   0    0]]\n",
            "F1 Score: 0.0\n",
            "Accuracy: 0.9587396849212303\n",
            "Precision: 0.0\n",
            "Recall: 0.0\n",
            "ROC AUC: notdefined\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "  0%|          | 2/1120 [00:00<01:35, 11.73it/s]"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "Epoch 40 | Test Loss 0.6450160334980677\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "100%|██████████| 1120/1120 [01:34<00:00, 11.82it/s]\n",
            "  0%|          | 0/1120 [00:00<?, ?it/s]"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            " Confusion matrix: \n",
            " [[29733 24793]\n",
            " [ 6117 10991]]\n",
            "F1 Score: 0.4156016032670347\n",
            "Accuracy: 0.5685009911494542\n",
            "Precision: 0.3071484462329533\n",
            "Recall: 0.6424479775543606\n",
            "ROC AUC: 0.593873733852924\n",
            "Epoch 41 | Train Loss 0.673213447577187\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "100%|██████████| 1120/1120 [01:35<00:00, 11.77it/s]\n",
            "  0%|          | 0/1120 [00:00<?, ?it/s]"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            " Confusion matrix: \n",
            " [[29872 24656]\n",
            " [ 5978 11128]]\n",
            "F1 Score: 0.42079788239742866\n",
            "Accuracy: 0.572353910154396\n",
            "Precision: 0.31097697294880394\n",
            "Recall: 0.6505319770840641\n",
            "ROC AUC: 0.5991803077908583\n",
            "Epoch 42 | Train Loss 0.6715627514890262\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "100%|██████████| 1120/1120 [01:34<00:00, 11.81it/s]\n",
            "  0%|          | 0/1120 [00:00<?, ?it/s]"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            " Confusion matrix: \n",
            " [[29678 24536]\n",
            " [ 6172 11248]]\n",
            "F1 Score: 0.4228253514773326\n",
            "Accuracy: 0.5713208811458246\n",
            "Precision: 0.31433042700648334\n",
            "Recall: 0.6456946039035592\n",
            "ROC AUC: 0.596558889364625\n",
            "Epoch 43 | Train Loss 0.6717711401305029\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "100%|██████████| 1120/1120 [01:32<00:00, 12.05it/s]\n",
            "  0%|          | 0/1120 [00:00<?, ?it/s]"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            " Confusion matrix: \n",
            " [[29684 24705]\n",
            " [ 6166 11079]]\n",
            "F1 Score: 0.417846838522318\n",
            "Accuracy: 0.5690454253566742\n",
            "Precision: 0.3096076458752515\n",
            "Recall: 0.6424470861119165\n",
            "ROC AUC: 0.5941096045757508\n",
            "Epoch 44 | Train Loss 0.6726046882037605\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "100%|██████████| 1120/1120 [01:32<00:00, 12.13it/s]\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            " Confusion matrix: \n",
            " [[29728 24625]\n",
            " [ 6122 11159]]\n",
            "F1 Score: 0.4205785357580326\n",
            "Accuracy: 0.5707764469386045\n",
            "Precision: 0.3118432819137045\n",
            "Recall: 0.645738093860309\n",
            "ROC AUC: 0.5963406124371182\n",
            "Epoch 45 | Train Loss 0.6730188902999673\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "\r  0%|          | 0/1120 [00:00<?, ?it/s]"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "[[0.47299916]\n",
            " [0.47299916]\n",
            " [0.47299916]\n",
            " [0.47299916]\n",
            " [0.47299916]\n",
            " [0.47299916]\n",
            " [0.47299916]\n",
            " [0.47299916]\n",
            " [0.47299916]\n",
            " [0.47299916]]\n",
            "[0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\n",
            "[0 0 0 0 0 0 0 0 0 0]\n",
            "\n",
            " Confusion matrix: \n",
            " [[3834  165]\n",
            " [   0    0]]\n",
            "F1 Score: 0.0\n",
            "Accuracy: 0.9587396849212303\n",
            "Precision: 0.0\n",
            "Recall: 0.0\n",
            "ROC AUC: notdefined\n",
            "Epoch 45 | Test Loss 0.6450099396327186\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "100%|██████████| 1120/1120 [01:31<00:00, 12.29it/s]\n",
            "  0%|          | 0/1120 [00:00<?, ?it/s]"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            " Confusion matrix: \n",
            " [[29823 24763]\n",
            " [ 6027 11021]]\n",
            "F1 Score: 0.4172092671108419\n",
            "Accuracy: 0.5701761733255158\n",
            "Precision: 0.30798680974737314\n",
            "Recall: 0.6464687939934303\n",
            "ROC AUC: 0.5964088373294011\n",
            "Epoch 46 | Train Loss 0.6727358302367585\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "100%|██████████| 1120/1120 [01:33<00:00, 11.97it/s]\n",
            "  0%|          | 0/1120 [00:00<?, ?it/s]"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            " Confusion matrix: \n",
            " [[29838 24552]\n",
            " [ 6012 11232]]\n",
            "F1 Score: 0.42362525458248473\n",
            "Accuracy: 0.5733310997570986\n",
            "Precision: 0.31388329979879276\n",
            "Recall: 0.651356993736952\n",
            "ROC AUC: 0.5999752425937932\n",
            "Epoch 47 | Train Loss 0.6708144327891724\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "100%|██████████| 1120/1120 [01:31<00:00, 12.18it/s]\n",
            "  0%|          | 0/1120 [00:00<?, ?it/s]"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            " Confusion matrix: \n",
            " [[29864 24757]\n",
            " [ 5986 11027]]\n",
            "F1 Score: 0.417713127639828\n",
            "Accuracy: 0.5708322863444732\n",
            "Precision: 0.3081544824502571\n",
            "Recall: 0.648151413624875\n",
            "ROC AUC: 0.5974504161733061\n",
            "Epoch 48 | Train Loss 0.6719435320901019\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "100%|██████████| 1120/1120 [01:31<00:00, 12.27it/s]\n",
            "  0%|          | 0/1120 [00:00<?, ?it/s]"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            " Confusion matrix: \n",
            " [[29793 24664]\n",
            " [ 6057 11120]]\n",
            "F1 Score: 0.41993164781631764\n",
            "Accuracy: 0.5711394030767513\n",
            "Precision: 0.31075340934495865\n",
            "Recall: 0.6473773068638295\n",
            "ROC AUC: 0.5972347540250433\n",
            "Epoch 49 | Train Loss 0.6711974661797285\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "100%|██████████| 1120/1120 [01:30<00:00, 12.33it/s]\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            " Confusion matrix: \n",
            " [[29781 24715]\n",
            " [ 6069 11069]]\n",
            "F1 Score: 0.41831374475643396\n",
            "Accuracy: 0.5702599324343189\n",
            "Precision: 0.30932819137044487\n",
            "Recall: 0.6458746644882717\n",
            "ROC AUC: 0.5961775700597552\n",
            "Epoch 50 | Train Loss 0.6714208945631981\n",
            "[[0.46711698]\n",
            " [0.4702367 ]\n",
            " [0.46762004]\n",
            " [0.4675526 ]\n",
            " [0.46919376]\n",
            " [0.46489078]\n",
            " [0.47921243]\n",
            " [0.46743813]\n",
            " [0.468346  ]\n",
            " [0.46420503]]\n",
            "[0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\n",
            "[0 0 0 0 0 0 0 0 0 0]\n",
            "\n",
            " Confusion matrix: \n",
            " [[3832  164]\n",
            " [   2    1]]\n",
            "F1 Score: 0.011904761904761906\n",
            "Accuracy: 0.9584896224056014\n",
            "Precision: 0.006060606060606061\n",
            "Recall: 0.3333333333333333\n",
            "ROC AUC: 0.6461461461461462\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "\r  0%|          | 0/1120 [00:00<?, ?it/s]"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "Epoch 50 | Test Loss 0.6386317639123826\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "100%|██████████| 1120/1120 [01:32<00:00, 12.11it/s]\n",
            "  0%|          | 0/1120 [00:00<?, ?it/s]"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            " Confusion matrix: \n",
            " [[29783 24742]\n",
            " [ 6067 11042]]\n",
            "F1 Score: 0.4175221673945513\n",
            "Accuracy: 0.5699109361476394\n",
            "Precision: 0.308573664207467\n",
            "Recall: 0.6453913145128295\n",
            "ROC AUC: 0.595808908058799\n",
            "Epoch 51 | Train Loss 0.6722263347357511\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "100%|██████████| 1120/1120 [01:31<00:00, 12.20it/s]\n",
            "  0%|          | 0/1120 [00:00<?, ?it/s]"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            " Confusion matrix: \n",
            " [[29720 24773]\n",
            " [ 6130 11011]]\n",
            "F1 Score: 0.4160982522437411\n",
            "Accuracy: 0.5685987101097244\n",
            "Precision: 0.3077073552425665\n",
            "Recall: 0.6423779242751299\n",
            "ROC AUC: 0.5938845377160795\n",
            "Epoch 52 | Train Loss 0.6730709143515144\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "100%|██████████| 1120/1120 [01:32<00:00, 12.04it/s]\n",
            "  0%|          | 0/1120 [00:00<?, ?it/s]"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            " Confusion matrix: \n",
            " [[29708 24547]\n",
            " [ 6142 11237]]\n",
            "F1 Score: 0.4227376182683445\n",
            "Accuracy: 0.571586118323701\n",
            "Precision: 0.31402302705119606\n",
            "Recall: 0.6465849588583923\n",
            "ROC AUC: 0.5970736977500882\n",
            "Epoch 53 | Train Loss 0.6715085972100496\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "100%|██████████| 1120/1120 [01:31<00:00, 12.28it/s]\n",
            "  0%|          | 0/1120 [00:00<?, ?it/s]"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            " Confusion matrix: \n",
            " [[29692 24648]\n",
            " [ 6158 11136]]\n",
            "F1 Score: 0.4196088775010362\n",
            "Accuracy: 0.5699528157020409\n",
            "Precision: 0.31120053655264923\n",
            "Recall: 0.6439227477737944\n",
            "ROC AUC: 0.5951671155136914\n",
            "Epoch 54 | Train Loss 0.6719415285225425\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "100%|██████████| 1120/1120 [01:32<00:00, 12.10it/s]\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            " Confusion matrix: \n",
            " [[29680 24622]\n",
            " [ 6170 11162]]\n",
            "F1 Score: 0.4202876722644777\n",
            "Accuracy: 0.5701482536225815\n",
            "Precision: 0.3119271182651464\n",
            "Recall: 0.6440110777752135\n",
            "ROC AUC: 0.5952919740097017\n",
            "Epoch 55 | Train Loss 0.6724227599267448\n",
            "[[0.46883318]\n",
            " [0.47076368]\n",
            " [0.4688458 ]\n",
            " [0.46813726]\n",
            " [0.48835313]\n",
            " [0.4654169 ]\n",
            " [0.46462268]\n",
            " [0.4691986 ]\n",
            " [0.46796304]\n",
            " [0.46868116]]\n",
            "[0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\n",
            "[0 0 0 0 1 0 0 1 0 0]\n",
            "\n",
            " Confusion matrix: \n",
            " [[3831  164]\n",
            " [   3    1]]\n",
            "F1 Score: 0.01183431952662722\n",
            "Accuracy: 0.9582395598899724\n",
            "Precision: 0.006060606060606061\n",
            "Recall: 0.25\n",
            "ROC AUC: 0.6044743429286609\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "  0%|          | 2/1120 [00:00<01:38, 11.30it/s]"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "Epoch 55 | Test Loss 0.6396699500462365\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "100%|██████████| 1120/1120 [01:33<00:00, 11.97it/s]\n",
            "  0%|          | 0/1120 [00:00<?, ?it/s]"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            " Confusion matrix: \n",
            " [[29752 24718]\n",
            " [ 6098 11066]]\n",
            "F1 Score: 0.4179950139759765\n",
            "Accuracy: 0.5698132171873691\n",
            "Precision: 0.3092443550190029\n",
            "Recall: 0.6447215101374971\n",
            "ROC AUC: 0.5954652162400356\n",
            "Epoch 56 | Train Loss 0.6721919612692935\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "100%|██████████| 1120/1120 [01:33<00:00, 11.99it/s]\n",
            "  0%|          | 0/1120 [00:00<?, ?it/s]"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            " Confusion matrix: \n",
            " [[29696 24583]\n",
            " [ 6154 11201]]\n",
            "F1 Score: 0.4215736088372006\n",
            "Accuracy: 0.5709160454532763\n",
            "Precision: 0.31301699083389223\n",
            "Recall: 0.6454047824834341\n",
            "ROC AUC: 0.5962520144845919\n",
            "Epoch 57 | Train Loss 0.6716961771249771\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "100%|██████████| 1120/1120 [01:33<00:00, 11.96it/s]\n",
            "  0%|          | 0/1120 [00:00<?, ?it/s]"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            " Confusion matrix: \n",
            " [[29817 24727]\n",
            " [ 6033 11057]]\n",
            "F1 Score: 0.41823958845557363\n",
            "Accuracy: 0.5705949688695312\n",
            "Precision: 0.30899284596467697\n",
            "Recall: 0.6469865418373317\n",
            "ROC AUC: 0.5968230597130337\n",
            "Epoch 58 | Train Loss 0.6716554356472832\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "100%|██████████| 1120/1120 [01:33<00:00, 11.98it/s]\n",
            "  0%|          | 0/1120 [00:00<?, ?it/s]"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            " Confusion matrix: \n",
            " [[29788 24652]\n",
            " [ 6062 11132]]\n",
            "F1 Score: 0.42024991505908116\n",
            "Accuracy: 0.5712371220370215\n",
            "Precision: 0.31108875475072656\n",
            "Recall: 0.6474351517971385\n",
            "ROC AUC: 0.5973031747229631\n",
            "Epoch 59 | Train Loss 0.6717421378408159\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "100%|██████████| 1120/1120 [01:33<00:00, 11.94it/s]\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            " Confusion matrix: \n",
            " [[29719 24759]\n",
            " [ 6131 11025]]\n",
            "F1 Score: 0.4165092557612391\n",
            "Accuracy: 0.5687801881787978\n",
            "Precision: 0.30809859154929575\n",
            "Recall: 0.6426323152249942\n",
            "ROC AUC: 0.5940776393115316\n",
            "Epoch 60 | Train Loss 0.6727069887199573\n",
            "[[0.4692435 ]\n",
            " [0.4768463 ]\n",
            " [0.4677768 ]\n",
            " [0.46837136]\n",
            " [0.4717556 ]\n",
            " [0.47078717]\n",
            " [0.4698961 ]\n",
            " [0.46848604]\n",
            " [0.4680609 ]\n",
            " [0.46899763]]\n",
            "[0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\n",
            "[0 0 0 0 0 0 0 0 0 0]\n",
            "\n",
            " Confusion matrix: \n",
            " [[3832  164]\n",
            " [   2    1]]\n",
            "F1 Score: 0.011904761904761906\n",
            "Accuracy: 0.9584896224056014\n",
            "Precision: 0.006060606060606061\n",
            "Recall: 0.3333333333333333\n",
            "ROC AUC: 0.6461461461461462\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "\r  0%|          | 0/1120 [00:00<?, ?it/s]"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "Epoch 60 | Test Loss 0.6383652393780057\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "100%|██████████| 1120/1120 [01:46<00:00, 10.49it/s]\n",
            "  0%|          | 0/1120 [00:00<?, ?it/s]"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            " Confusion matrix: \n",
            " [[29716 24688]\n",
            " [ 6134 11096]]\n",
            "F1 Score: 0.4186064058550572\n",
            "Accuracy: 0.569729458078566\n",
            "Precision: 0.3100827185334228\n",
            "Recall: 0.6439930354033663\n",
            "ROC AUC: 0.595101436457657\n",
            "Epoch 61 | Train Loss 0.6722584141152246\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "100%|██████████| 1120/1120 [01:47<00:00, 10.39it/s]\n",
            "  0%|          | 0/1120 [00:00<?, ?it/s]"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            " Confusion matrix: \n",
            " [[29839 24669]\n",
            " [ 6011 11115]]\n",
            "F1 Score: 0.4201474201474202\n",
            "Accuracy: 0.5717117569869057\n",
            "Precision: 0.31061368209255535\n",
            "Recall: 0.6490131963097046\n",
            "ROC AUC: 0.5982187138076005\n",
            "Epoch 62 | Train Loss 0.6723119962428298\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "100%|██████████| 1120/1120 [01:41<00:00, 11.09it/s]\n",
            "  0%|          | 0/1120 [00:00<?, ?it/s]"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            " Confusion matrix: \n",
            " [[29819 24848]\n",
            " [ 6031 10936]]\n",
            "F1 Score: 0.4146272108585619\n",
            "Accuracy: 0.5689337465449368\n",
            "Precision: 0.3056114464565169\n",
            "Recall: 0.6445452938056226\n",
            "ROC AUC: 0.5950057399937071\n",
            "Epoch 63 | Train Loss 0.6723374557814428\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "100%|██████████| 1120/1120 [01:33<00:00, 11.93it/s]\n",
            "  0%|          | 0/1120 [00:00<?, ?it/s]"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            " Confusion matrix: \n",
            " [[29719 24741]\n",
            " [ 6131 11043]]\n",
            "F1 Score: 0.41704747158125305\n",
            "Accuracy: 0.569031465505207\n",
            "Precision: 0.3086016096579477\n",
            "Recall: 0.6430068708512868\n",
            "ROC AUC: 0.594355069652599\n",
            "Epoch 64 | Train Loss 0.6724436535899129\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "100%|██████████| 1120/1120 [01:33<00:00, 11.98it/s]\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            " Confusion matrix: \n",
            " [[29833 24781]\n",
            " [ 6017 11003]]\n",
            "F1 Score: 0.4167487311567305\n",
            "Accuracy: 0.5700644945137784\n",
            "Precision: 0.3074837916387212\n",
            "Recall: 0.6464747356051704\n",
            "ROC AUC: 0.5963633062066575\n",
            "Epoch 65 | Train Loss 0.6711700300020831\n",
            "[[0.4730029]\n",
            " [0.4730029]\n",
            " [0.4730029]\n",
            " [0.4730029]\n",
            " [0.4730029]\n",
            " [0.4730029]\n",
            " [0.4730029]\n",
            " [0.4730029]\n",
            " [0.4730029]\n",
            " [0.4730029]]\n",
            "[0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\n",
            "[0 0 0 0 0 0 0 1 0 0]\n",
            "\n",
            " Confusion matrix: \n",
            " [[3833  164]\n",
            " [   1    1]]\n",
            "F1 Score: 0.011976047904191616\n",
            "Accuracy: 0.9587396849212303\n",
            "Precision: 0.006060606060606061\n",
            "Recall: 0.5\n",
            "ROC AUC: 0.7294846134600952\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "  0%|          | 2/1120 [00:00<01:35, 11.72it/s]"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "Epoch 65 | Test Loss 0.6447942682674953\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "100%|██████████| 1120/1120 [01:34<00:00, 11.87it/s]\n",
            "  0%|          | 0/1120 [00:00<?, ?it/s]"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            " Confusion matrix: \n",
            " [[29751 24758]\n",
            " [ 6099 11026]]\n",
            "F1 Score: 0.41679109414277343\n",
            "Accuracy: 0.5692408632772147\n",
            "Precision: 0.30812653699977643\n",
            "Recall: 0.6438540145985402\n",
            "ROC AUC: 0.5948268953911449\n",
            "Epoch 66 | Train Loss 0.672918720596603\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "100%|██████████| 1120/1120 [01:34<00:00, 11.86it/s]\n",
            "  0%|          | 0/1120 [00:00<?, ?it/s]"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            " Confusion matrix: \n",
            " [[29768 24630]\n",
            " [ 6082 11154]]\n",
            "F1 Score: 0.4207468879668049\n",
            "Accuracy: 0.5712650417399558\n",
            "Precision: 0.3117035546613011\n",
            "Recall: 0.647133905778603\n",
            "ROC AUC: 0.5971799533672603\n",
            "Epoch 67 | Train Loss 0.6717709654676063\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "100%|██████████| 1120/1120 [01:34<00:00, 11.85it/s]\n",
            "  0%|          | 0/1120 [00:00<?, ?it/s]"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            " Confusion matrix: \n",
            " [[29788 24752]\n",
            " [ 6062 11032]]\n",
            "F1 Score: 0.4172623775483188\n",
            "Accuracy: 0.5698411368903035\n",
            "Precision: 0.3082942097026604\n",
            "Recall: 0.6453726453726454\n",
            "ROC AUC: 0.5957702977504957\n",
            "Epoch 68 | Train Loss 0.6726494747613158\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "100%|██████████| 1120/1120 [01:33<00:00, 11.99it/s]\n",
            "  0%|          | 0/1120 [00:00<?, ?it/s]"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            " Confusion matrix: \n",
            " [[29757 24765]\n",
            " [ 6093 11019]]\n",
            "F1 Score: 0.4166288566243194\n",
            "Accuracy: 0.5692269034257476\n",
            "Precision: 0.3079309188464118\n",
            "Recall: 0.6439340813464236\n",
            "ROC AUC: 0.5948568833055436\n",
            "Epoch 69 | Train Loss 0.6723446350012506\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "100%|██████████| 1120/1120 [01:31<00:00, 12.20it/s]\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            " Confusion matrix: \n",
            " [[29745 24702]\n",
            " [ 6105 11082]]\n",
            "F1 Score: 0.41841762473806426\n",
            "Accuracy: 0.5699388558505738\n",
            "Precision: 0.3096914822266935\n",
            "Recall: 0.6447896666084831\n",
            "ROC AUC: 0.5955503790643386\n",
            "Epoch 70 | Train Loss 0.6716119229793549\n",
            "[[0.4664925 ]\n",
            " [0.46831483]\n",
            " [0.47739536]\n",
            " [0.48047385]\n",
            " [0.46858987]\n",
            " [0.46867093]\n",
            " [0.46858412]\n",
            " [0.47149888]\n",
            " [0.46854648]\n",
            " [0.46536493]]\n",
            "[0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\n",
            "[0 0 0 0 0 0 0 0 0 0]\n",
            "\n",
            " Confusion matrix: \n",
            " [[3832  164]\n",
            " [   2    1]]\n",
            "F1 Score: 0.011904761904761906\n",
            "Accuracy: 0.9584896224056014\n",
            "Precision: 0.006060606060606061\n",
            "Recall: 0.3333333333333333\n",
            "ROC AUC: 0.6461461461461462\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "  0%|          | 2/1120 [00:00<01:32, 12.11it/s]"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "Epoch 70 | Test Loss 0.6393512799626305\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "100%|██████████| 1120/1120 [01:31<00:00, 12.30it/s]\n",
            "  0%|          | 0/1120 [00:00<?, ?it/s]"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            " Confusion matrix: \n",
            " [[29826 24730]\n",
            " [ 6024 11054]]\n",
            "F1 Score: 0.41822102833793656\n",
            "Accuracy: 0.5706787279783343\n",
            "Precision: 0.308909009613235\n",
            "Recall: 0.6472654877620331\n",
            "ROC AUC: 0.5969848957983125\n",
            "Epoch 71 | Train Loss 0.6718405913561583\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "100%|██████████| 1120/1120 [01:32<00:00, 12.05it/s]\n",
            "  0%|          | 0/1120 [00:00<?, ?it/s]"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            " Confusion matrix: \n",
            " [[29807 24810]\n",
            " [ 6043 10974]]\n",
            "F1 Score: 0.4156739455692127\n",
            "Accuracy: 0.5692967026830834\n",
            "Precision: 0.306673373574782\n",
            "Recall: 0.6448845272374684\n",
            "ROC AUC: 0.5953151786451911\n",
            "Epoch 72 | Train Loss 0.6731878070426839\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "100%|██████████| 1120/1120 [01:33<00:00, 11.98it/s]\n",
            "  0%|          | 0/1120 [00:00<?, ?it/s]"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            " Confusion matrix: \n",
            " [[29809 24605]\n",
            " [ 6041 11179]]\n",
            "F1 Score: 0.4218172213417855\n",
            "Accuracy: 0.5721863919367898\n",
            "Precision: 0.31240219092331767\n",
            "Recall: 0.6491869918699187\n",
            "ROC AUC: 0.5985027839858286\n",
            "Epoch 73 | Train Loss 0.671311376776014\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "100%|██████████| 1120/1120 [01:32<00:00, 12.16it/s]\n",
            "  0%|          | 0/1120 [00:00<?, ?it/s]"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            " Confusion matrix: \n",
            " [[29789 24592]\n",
            " [ 6061 11192]]\n",
            "F1 Score: 0.4220449874615835\n",
            "Accuracy: 0.5720886729765196\n",
            "Precision: 0.3127654817795663\n",
            "Recall: 0.6486987770242856\n",
            "ROC AUC: 0.5982410050693963\n",
            "Epoch 74 | Train Loss 0.6711395883666618\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "100%|██████████| 1120/1120 [01:32<00:00, 12.17it/s]\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            " Confusion matrix: \n",
            " [[29746 24673]\n",
            " [ 6104 11111]]\n",
            "F1 Score: 0.41929093001754747\n",
            "Accuracy: 0.5703576513945892\n",
            "Precision: 0.3105019002906327\n",
            "Recall: 0.6454255010165554\n",
            "ROC AUC: 0.5960180299143674\n",
            "Epoch 75 | Train Loss 0.67244447751769\n",
            "[[0.46866283]\n",
            " [0.4674811 ]\n",
            " [0.45762977]\n",
            " [0.47111365]\n",
            " [0.47044942]\n",
            " [0.4873604 ]\n",
            " [0.46787962]\n",
            " [0.46830308]\n",
            " [0.46788782]\n",
            " [0.4675998 ]]\n",
            "[0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\n",
            "[0 0 1 0 0 0 0 0 0 0]\n",
            "\n",
            " Confusion matrix: \n",
            " [[3832  164]\n",
            " [   2    1]]\n",
            "F1 Score: 0.011904761904761906\n",
            "Accuracy: 0.9584896224056014\n",
            "Precision: 0.006060606060606061\n",
            "Recall: 0.3333333333333333\n",
            "ROC AUC: 0.6461461461461462\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "\r  0%|          | 0/1120 [00:00<?, ?it/s]"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "Epoch 75 | Test Loss 0.6383512616157532\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "100%|██████████| 1120/1120 [01:32<00:00, 12.13it/s]\n",
            "  0%|          | 0/1120 [00:00<?, ?it/s]"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            " Confusion matrix: \n",
            " [[29753 24691]\n",
            " [ 6097 11093]]\n",
            "F1 Score: 0.41880922716804475\n",
            "Accuracy: 0.5702040930284502\n",
            "Precision: 0.3099988821819808\n",
            "Recall: 0.6453170447934846\n",
            "ROC AUC: 0.5959025896952509\n",
            "Epoch 76 | Train Loss 0.672192502447537\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "100%|██████████| 1120/1120 [01:33<00:00, 11.99it/s]\n",
            "  0%|          | 0/1120 [00:00<?, ?it/s]"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            " Confusion matrix: \n",
            " [[29798 24681]\n",
            " [ 6052 11103]]\n",
            "F1 Score: 0.419463911294131\n",
            "Accuracy: 0.5709718848591451\n",
            "Precision: 0.3102783366867874\n",
            "Recall: 0.6472165549402507\n",
            "ROC AUC: 0.5970898024614064\n",
            "Epoch 77 | Train Loss 0.6717768555240972\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "100%|██████████| 1120/1120 [01:34<00:00, 11.87it/s]\n",
            "  0%|          | 0/1120 [00:00<?, ?it/s]"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            " Confusion matrix: \n",
            " [[29810 24600]\n",
            " [ 6040 11184]]\n",
            "F1 Score: 0.4219740416540899\n",
            "Accuracy: 0.5722701510455929\n",
            "Precision: 0.31254191817572097\n",
            "Recall: 0.6493265211333024\n",
            "ROC AUC: 0.5986018747919775\n",
            "Epoch 78 | Train Loss 0.6711756942527635\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "100%|██████████| 1120/1120 [01:32<00:00, 12.12it/s]\n",
            "  0%|          | 0/1120 [00:00<?, ?it/s]"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            " Confusion matrix: \n",
            " [[29737 24739]\n",
            " [ 6113 11045]]\n",
            "F1 Score: 0.4172490650145442\n",
            "Accuracy: 0.5693106625345506\n",
            "Precision: 0.308657500558909\n",
            "Recall: 0.6437230446438978\n",
            "ROC AUC: 0.5947982283943478\n",
            "Epoch 79 | Train Loss 0.6719129757157394\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "100%|██████████| 1120/1120 [01:32<00:00, 12.07it/s]\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            " Confusion matrix: \n",
            " [[29891 24789]\n",
            " [ 5959 10995]]\n",
            "F1 Score: 0.4169668929424703\n",
            "Accuracy: 0.5707624870871374\n",
            "Precision: 0.3072602280348759\n",
            "Recall: 0.6485195234163029\n",
            "ROC AUC: 0.5975863893599438\n",
            "Epoch 80 | Train Loss 0.6717008717890297\n",
            "[[0.47092322]\n",
            " [0.47061676]\n",
            " [0.45839447]\n",
            " [0.46664104]\n",
            " [0.46110204]\n",
            " [0.47224516]\n",
            " [0.4703764 ]\n",
            " [0.46870294]\n",
            " [0.4710696 ]\n",
            " [0.4699362 ]]\n",
            "[0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\n",
            "[0 0 0 0 0 0 0 0 0 0]\n",
            "\n",
            " Confusion matrix: \n",
            " [[3832  164]\n",
            " [   2    1]]\n",
            "F1 Score: 0.011904761904761906\n",
            "Accuracy: 0.9584896224056014\n",
            "Precision: 0.006060606060606061\n",
            "Recall: 0.3333333333333333\n",
            "ROC AUC: 0.6461461461461462\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "  0%|          | 2/1120 [00:00<01:35, 11.65it/s]"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "Epoch 80 | Test Loss 0.640579000351921\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "100%|██████████| 1120/1120 [01:32<00:00, 12.06it/s]\n",
            "  0%|          | 0/1120 [00:00<?, ?it/s]"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            " Confusion matrix: \n",
            " [[29651 24624]\n",
            " [ 6199 11160]]\n",
            "F1 Score: 0.4199988709707769\n",
            "Accuracy: 0.5697154982270989\n",
            "Precision: 0.3118712273641851\n",
            "Recall: 0.6428941759317933\n",
            "ROC AUC: 0.594602315971424\n",
            "Epoch 81 | Train Loss 0.6716552119169916\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "100%|██████████| 1120/1120 [01:31<00:00, 12.22it/s]\n",
            "  0%|          | 0/1120 [00:00<?, ?it/s]"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            " Confusion matrix: \n",
            " [[29792 24579]\n",
            " [ 6058 11205]]\n",
            "F1 Score: 0.4224555582785077\n",
            "Accuracy: 0.5723120305999945\n",
            "Precision: 0.3131287726358149\n",
            "Recall: 0.6490760586224874\n",
            "ROC AUC: 0.5985076086825997\n",
            "Epoch 82 | Train Loss 0.6715312319674662\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "100%|██████████| 1120/1120 [01:31<00:00, 12.23it/s]\n",
            "  0%|          | 0/1120 [00:00<?, ?it/s]"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            " Confusion matrix: \n",
            " [[29733 24731]\n",
            " [ 6117 11053]]\n",
            "F1 Score: 0.41745666049779057\n",
            "Accuracy: 0.5693665019404194\n",
            "Precision: 0.3088810641627543\n",
            "Recall: 0.643739079790332\n",
            "ROC AUC: 0.5948296603416995\n",
            "Epoch 83 | Train Loss 0.6720768520342452\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "100%|██████████| 1120/1120 [01:31<00:00, 12.29it/s]\n",
            "  0%|          | 0/1120 [00:00<?, ?it/s]"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            " Confusion matrix: \n",
            " [[29697 24548]\n",
            " [ 6153 11236]]\n",
            "F1 Score: 0.4226205028868035\n",
            "Accuracy: 0.5714186001060949\n",
            "Precision: 0.31399508160071543\n",
            "Recall: 0.6461556156190695\n",
            "ROC AUC: 0.5968081055328273\n",
            "Epoch 84 | Train Loss 0.6715574799371617\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "100%|██████████| 1120/1120 [01:31<00:00, 12.22it/s]\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            " Confusion matrix: \n",
            " [[29747 24669]\n",
            " [ 6103 11115]]\n",
            "F1 Score: 0.41941813516471077\n",
            "Accuracy: 0.570427450651925\n",
            "Precision: 0.31061368209255535\n",
            "Recall: 0.6455453595074921\n",
            "ROC AUC: 0.5961022151845017\n",
            "Epoch 85 | Train Loss 0.6728772452367203\n",
            "[[0.4730029]\n",
            " [0.4730029]\n",
            " [0.4730029]\n",
            " [0.4730029]\n",
            " [0.4730029]\n",
            " [0.4730029]\n",
            " [0.4730029]\n",
            " [0.4730029]\n",
            " [0.4730029]\n",
            " [0.4730029]]\n",
            "[0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\n",
            "[0 0 0 0 0 0 0 0 0 0]\n",
            "\n",
            " Confusion matrix: \n",
            " [[3834  165]\n",
            " [   0    0]]\n",
            "F1 Score: 0.0\n",
            "Accuracy: 0.9587396849212303\n",
            "Precision: 0.0\n",
            "Recall: 0.0\n",
            "ROC AUC: notdefined\n",
            "Epoch 85 | Test Loss 0.6449800010711427"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "  0%|          | 2/1120 [00:00<01:31, 12.18it/s]"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "100%|██████████| 1120/1120 [01:32<00:00, 12.15it/s]\n",
            "  0%|          | 0/1120 [00:00<?, ?it/s]"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            " Confusion matrix: \n",
            " [[29762 24693]\n",
            " [ 6088 11091]]\n",
            "F1 Score: 0.4188206861393803\n",
            "Accuracy: 0.5703018119887204\n",
            "Precision: 0.30994299128101943\n",
            "Recall: 0.645613830839979\n",
            "ROC AUC: 0.5960784240050597\n",
            "Epoch 86 | Train Loss 0.6720119152218104\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "100%|██████████| 1120/1120 [01:32<00:00, 12.07it/s]\n",
            "  0%|          | 0/1120 [00:00<?, ?it/s]"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            " Confusion matrix: \n",
            " [[29797 24710]\n",
            " [ 6053 11074]]\n",
            "F1 Score: 0.4185897072442403\n",
            "Accuracy: 0.5705530893151297\n",
            "Precision: 0.3094679186228482\n",
            "Recall: 0.6465814211478952\n",
            "ROC AUC: 0.5966225762058848\n",
            "Epoch 87 | Train Loss 0.6721031408756971\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "100%|██████████| 1120/1120 [01:33<00:00, 12.01it/s]\n",
            "  0%|          | 0/1120 [00:00<?, ?it/s]"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            " Confusion matrix: \n",
            " [[29725 24694]\n",
            " [ 6125 11090]]\n",
            "F1 Score: 0.41849846223513654\n",
            "Accuracy: 0.5697713376329676\n",
            "Precision: 0.3099150458305388\n",
            "Recall: 0.6442056346209701\n",
            "ROC AUC: 0.5952151494003801\n",
            "Epoch 88 | Train Loss 0.6727408049362046\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "100%|██████████| 1120/1120 [01:32<00:00, 12.11it/s]\n",
            "  0%|          | 0/1120 [00:00<?, ?it/s]"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            " Confusion matrix: \n",
            " [[29865 24687]\n",
            " [ 5985 11097]]\n",
            "F1 Score: 0.41981613891726255\n",
            "Accuracy: 0.5718234357986431\n",
            "Precision: 0.3101106639839034\n",
            "Recall: 0.6496311907270811\n",
            "ROC AUC: 0.5985452478052475\n",
            "Epoch 89 | Train Loss 0.6724838057266814\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "100%|██████████| 1120/1120 [01:32<00:00, 12.11it/s]\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            " Confusion matrix: \n",
            " [[29723 24693]\n",
            " [ 6127 11091]]\n",
            "F1 Score: 0.418512508961926\n",
            "Accuracy: 0.5697573777815004\n",
            "Precision: 0.30994299128101943\n",
            "Recall: 0.6441514693924962\n",
            "ROC AUC: 0.5951847467515259\n",
            "Epoch 90 | Train Loss 0.6718447069504432\n",
            "[[0.4730029]\n",
            " [0.4730029]\n",
            " [0.4730029]\n",
            " [0.4730029]\n",
            " [0.4730029]\n",
            " [0.4730029]\n",
            " [0.4730029]\n",
            " [0.4730029]\n",
            " [0.4730029]\n",
            " [0.4730029]]\n",
            "[0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\n",
            "[0 0 0 0 0 0 1 0 0 0]\n",
            "\n",
            " Confusion matrix: \n",
            " [[3834  165]\n",
            " [   0    0]]\n",
            "F1 Score: 0.0\n",
            "Accuracy: 0.9587396849212303\n",
            "Precision: 0.0\n",
            "Recall: 0.0\n",
            "ROC AUC: notdefined\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "  0%|          | 2/1120 [00:00<01:28, 12.61it/s]"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "Epoch 90 | Test Loss 0.6449836700681656\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "100%|██████████| 1120/1120 [01:32<00:00, 12.07it/s]\n",
            "  0%|          | 0/1120 [00:00<?, ?it/s]"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            " Confusion matrix: \n",
            " [[29791 24711]\n",
            " [ 6059 11073]]\n",
            "F1 Score: 0.4185123592108247\n",
            "Accuracy: 0.5704553703548594\n",
            "Precision: 0.30943997317236754\n",
            "Recall: 0.6463343450852206\n",
            "ROC AUC: 0.5964690697206955\n",
            "Epoch 91 | Train Loss 0.672232363479478\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "100%|██████████| 1120/1120 [01:31<00:00, 12.22it/s]\n",
            "  0%|          | 0/1120 [00:00<?, ?it/s]"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            " Confusion matrix: \n",
            " [[29840 24717]\n",
            " [ 6010 11067]]\n",
            "F1 Score: 0.41872079605001794\n",
            "Accuracy: 0.5710556439679482\n",
            "Precision: 0.30927230046948356\n",
            "Recall: 0.6480646483574398\n",
            "ROC AUC: 0.5975077718756241\n",
            "Epoch 92 | Train Loss 0.6721652127270188\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "100%|██████████| 1120/1120 [01:32<00:00, 12.12it/s]\n",
            "  0%|          | 0/1120 [00:00<?, ?it/s]"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            " Confusion matrix: \n",
            " [[29776 24703]\n",
            " [ 6074 11081]]\n",
            "F1 Score: 0.4186327660137139\n",
            "Accuracy: 0.5703576513945892\n",
            "Precision: 0.30966353677621283\n",
            "Recall: 0.6459341299912562\n",
            "ROC AUC: 0.5962466773233139\n",
            "Epoch 93 | Train Loss 0.6706595717796258\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "100%|██████████| 1120/1120 [01:35<00:00, 11.72it/s]\n",
            "  0%|          | 0/1120 [00:00<?, ?it/s]"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            " Confusion matrix: \n",
            " [[29732 24720]\n",
            " [ 6118 11064]]\n",
            "F1 Score: 0.4177774421326889\n",
            "Accuracy: 0.5695061004550912\n",
            "Precision: 0.3091884641180416\n",
            "Recall: 0.6439296938656733\n",
            "ROC AUC: 0.5949759392710428\n",
            "Epoch 94 | Train Loss 0.6728225648403168\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "100%|██████████| 1120/1120 [01:36<00:00, 11.66it/s]\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            " Confusion matrix: \n",
            " [[29709 24572]\n",
            " [ 6141 11212]]\n",
            "F1 Score: 0.4220035003857952\n",
            "Accuracy: 0.5712510818884887\n",
            "Precision: 0.3133243907891795\n",
            "Recall: 0.6461130640235118\n",
            "ROC AUC: 0.5967158234765408\n",
            "Epoch 95 | Train Loss 0.671166334886636\n",
            "[[0.47221538]\n",
            " [0.45551   ]\n",
            " [0.47244954]\n",
            " [0.4720593 ]\n",
            " [0.47242448]\n",
            " [0.47209698]\n",
            " [0.47034803]\n",
            " [0.47219768]\n",
            " [0.46652296]\n",
            " [0.47155517]]\n",
            "[0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\n",
            "[0 0 0 0 0 0 0 0 0 0]\n",
            "\n",
            " Confusion matrix: \n",
            " [[3832  164]\n",
            " [   2    1]]\n",
            "F1 Score: 0.011904761904761906\n",
            "Accuracy: 0.9584896224056014\n",
            "Precision: 0.006060606060606061\n",
            "Recall: 0.3333333333333333\n",
            "ROC AUC: 0.6461461461461462\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "  0%|          | 2/1120 [00:00<01:34, 11.81it/s]"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "Epoch 95 | Test Loss 0.6430887125787281\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "100%|██████████| 1120/1120 [01:35<00:00, 11.75it/s]\n",
            "  0%|          | 0/1120 [00:00<?, ?it/s]"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            " Confusion matrix: \n",
            " [[29789 24785]\n",
            " [ 6061 10999]]\n",
            "F1 Score: 0.41628188630686547\n",
            "Accuracy: 0.5693944216433537\n",
            "Precision: 0.3073720098367986\n",
            "Recall: 0.6447245017584994\n",
            "ROC AUC: 0.5952852545073509\n",
            "Epoch 96 | Train Loss 0.6727778106395688\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "100%|██████████| 1120/1120 [01:36<00:00, 11.63it/s]\n",
            "  0%|          | 0/1120 [00:00<?, ?it/s]"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            " Confusion matrix: \n",
            " [[29835 24677]\n",
            " [ 6015 11107]]\n",
            "F1 Score: 0.4198767625600121\n",
            "Accuracy: 0.5715442387692995\n",
            "Precision: 0.31039011848871007\n",
            "Recall: 0.6486975820581707\n",
            "ROC AUC: 0.5980041329721437\n",
            "Epoch 97 | Train Loss 0.670932446579848\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "100%|██████████| 1120/1120 [01:35<00:00, 11.78it/s]\n",
            "  0%|          | 0/1120 [00:00<?, ?it/s]"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            " Confusion matrix: \n",
            " [[29712 24576]\n",
            " [ 6138 11208]]\n",
            "F1 Score: 0.42190852625635233\n",
            "Accuracy: 0.5712371220370215\n",
            "Precision: 0.3132126089872569\n",
            "Recall: 0.6461432030439295\n",
            "ROC AUC: 0.596723237242566\n",
            "Epoch 98 | Train Loss 0.671781902228083\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "100%|██████████| 1120/1120 [01:32<00:00, 12.16it/s]\n",
            "  0%|          | 0/1120 [00:00<?, ?it/s]"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            " Confusion matrix: \n",
            " [[29745 24665]\n",
            " [ 6105 11119]]\n",
            "F1 Score: 0.41952158164805314\n",
            "Accuracy: 0.5704553703548594\n",
            "Precision: 0.31072546389447797\n",
            "Recall: 0.645552717138876\n",
            "ROC AUC: 0.5961176561250344\n",
            "Epoch 99 | Train Loss 0.671690803819469\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "100%|██████████| 1120/1120 [01:31<00:00, 12.24it/s]\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            " Confusion matrix: \n",
            " [[29752 24778]\n",
            " [ 6098 11006]]\n",
            "F1 Score: 0.4162002722734836\n",
            "Accuracy: 0.5689756260993383\n",
            "Precision: 0.3075676279901632\n",
            "Recall: 0.6434752104770813\n",
            "ROC AUC: 0.5945415663608586\n",
            "Epoch 100 | Train Loss 0.6728384723620755\n",
            "[[0.46511132]\n",
            " [0.46845356]\n",
            " [0.46503562]\n",
            " [0.4688239 ]\n",
            " [0.48605537]\n",
            " [0.4781392 ]\n",
            " [0.46852157]\n",
            " [0.46834806]\n",
            " [0.46577978]\n",
            " [0.4685879 ]]\n",
            "[0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\n",
            "[0 0 0 0 1 0 0 0 0 0]\n",
            "\n",
            " Confusion matrix: \n",
            " [[3832  164]\n",
            " [   2    1]]\n",
            "F1 Score: 0.011904761904761906\n",
            "Accuracy: 0.9584896224056014\n",
            "Precision: 0.006060606060606061\n",
            "Recall: 0.3333333333333333\n",
            "ROC AUC: 0.6461461461461462\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "  0%|          | 2/1120 [00:00<01:35, 11.71it/s]"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "Epoch 100 | Test Loss 0.6393300152960277\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "100%|██████████| 1120/1120 [01:30<00:00, 12.33it/s]\n",
            "  0%|          | 0/1120 [00:00<?, ?it/s]"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            " Confusion matrix: \n",
            " [[29768 24592]\n",
            " [ 6082 11192]]\n",
            "F1 Score: 0.4218779448904972\n",
            "Accuracy: 0.5717955160957088\n",
            "Precision: 0.3127654817795663\n",
            "Recall: 0.6479101539886535\n",
            "ROC AUC: 0.5977593448383296\n",
            "Epoch 101 | Train Loss 0.6712437994245972\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "100%|██████████| 1120/1120 [01:29<00:00, 12.52it/s]\n",
            "  0%|          | 0/1120 [00:00<?, ?it/s]"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            " Confusion matrix: \n",
            " [[29844 24752]\n",
            " [ 6006 11032]]\n",
            "F1 Score: 0.41770474423535653\n",
            "Accuracy: 0.5706228885724656\n",
            "Precision: 0.3082942097026604\n",
            "Recall: 0.647493837304848\n",
            "ROC AUC: 0.597063645152534\n",
            "Epoch 102 | Train Loss 0.6721363122974123\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "100%|██████████| 1120/1120 [01:30<00:00, 12.35it/s]\n",
            "  0%|          | 0/1120 [00:00<?, ?it/s]"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            " Confusion matrix: \n",
            " [[29761 24695]\n",
            " [ 6089 11089]]\n",
            "F1 Score: 0.4187530682376043\n",
            "Accuracy: 0.5702599324343189\n",
            "Precision: 0.3098871003800581\n",
            "Recall: 0.6455349866107812\n",
            "ROC AUC: 0.5960248019582479\n",
            "Epoch 103 | Train Loss 0.6712553632046495\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "100%|██████████| 1120/1120 [01:30<00:00, 12.36it/s]\n",
            "  0%|          | 0/1120 [00:00<?, ?it/s]"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            " Confusion matrix: \n",
            " [[29822 24716]\n",
            " [ 6028 11068]]\n",
            "F1 Score: 0.41860816944024204\n",
            "Accuracy: 0.5708183264930061\n",
            "Precision: 0.30930024591996425\n",
            "Recall: 0.6474029012634535\n",
            "ROC AUC: 0.5971071494105599\n",
            "Epoch 104 | Train Loss 0.672295206412673\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "100%|██████████| 1120/1120 [01:29<00:00, 12.49it/s]\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            " Confusion matrix: \n",
            " [[29734 24621]\n",
            " [ 6116 11163]]\n",
            "F1 Score: 0.42074515198914497\n",
            "Accuracy: 0.5709160454532763\n",
            "Precision: 0.3119550637156271\n",
            "Recall: 0.6460443312691707\n",
            "ROC AUC: 0.5965388614307402\n",
            "Epoch 105 | Train Loss 0.6720178489706345\n",
            "[[0.47232637]\n",
            " [0.47242388]\n",
            " [0.4730029 ]\n",
            " [0.47272524]\n",
            " [0.4720821 ]\n",
            " [0.47286275]\n",
            " [0.4664093 ]\n",
            " [0.47279784]\n",
            " [0.47231537]\n",
            " [0.47256413]]\n",
            "[0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\n",
            "[0 0 0 0 0 0 0 0 0 0]\n",
            "\n",
            " Confusion matrix: \n",
            " [[3832  164]\n",
            " [   2    1]]\n",
            "F1 Score: 0.011904761904761906\n",
            "Accuracy: 0.9584896224056014\n",
            "Precision: 0.006060606060606061\n",
            "Recall: 0.3333333333333333\n",
            "ROC AUC: 0.6461461461461462\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "  0%|          | 2/1120 [00:00<01:27, 12.82it/s]"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "Epoch 105 | Test Loss 0.6437631675175258\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "100%|██████████| 1120/1120 [01:29<00:00, 12.49it/s]\n",
            "  0%|          | 0/1120 [00:00<?, ?it/s]"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            " Confusion matrix: \n",
            " [[29663 24636]\n",
            " [ 6187 11148]]\n",
            "F1 Score: 0.4197368173346637\n",
            "Accuracy: 0.5697154982270989\n",
            "Precision: 0.3115358819584172\n",
            "Recall: 0.643092010383617\n",
            "ROC AUC: 0.5946909986539348\n",
            "Epoch 106 | Train Loss 0.671237145311066\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "100%|██████████| 1120/1120 [01:29<00:00, 12.49it/s]\n",
            "  0%|          | 0/1120 [00:00<?, ?it/s]"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            " Confusion matrix: \n",
            " [[29788 24727]\n",
            " [ 6062 11057]]\n",
            "F1 Score: 0.4180103207757594\n",
            "Accuracy: 0.570190133176983\n",
            "Precision: 0.30899284596467697\n",
            "Recall: 0.6458905309889597\n",
            "ROC AUC: 0.5961544739692115\n",
            "Epoch 107 | Train Loss 0.6715471131993191\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "100%|██████████| 1120/1120 [01:31<00:00, 12.28it/s]\n",
            "  0%|          | 0/1120 [00:00<?, ?it/s]"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            " Confusion matrix: \n",
            " [[29771 24734]\n",
            " [ 6079 11050]]\n",
            "F1 Score: 0.41766673596280685\n",
            "Accuracy: 0.5698550967417707\n",
            "Precision: 0.3087972278113123\n",
            "Recall: 0.6451047930410415\n",
            "ROC AUC: 0.5956557815310703\n",
            "Epoch 108 | Train Loss 0.6720401390854801\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "100%|██████████| 1120/1120 [01:30<00:00, 12.44it/s]\n",
            "  0%|          | 0/1120 [00:00<?, ?it/s]"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            " Confusion matrix: \n",
            " [[29859 24692]\n",
            " [ 5991 11092]]\n",
            "F1 Score: 0.41961904401611594\n",
            "Accuracy: 0.5716698774325041\n",
            "Precision: 0.3099709367315001\n",
            "Recall: 0.6493004741555933\n",
            "ROC AUC: 0.5983299129774134\n",
            "Epoch 109 | Train Loss 0.6723793891923768\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "100%|██████████| 1120/1120 [01:28<00:00, 12.61it/s]\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            " Confusion matrix: \n",
            " [[29827 24718]\n",
            " [ 6023 11066]]\n",
            "F1 Score: 0.4185879371323738\n",
            "Accuracy: 0.5708602060474076\n",
            "Precision: 0.3092443550190029\n",
            "Recall: 0.647551056235005\n",
            "ROC AUC: 0.5971919732545452\n",
            "Epoch 110 | Train Loss 0.6716878958046436\n",
            "[[0.46529716]\n",
            " [0.48147604]\n",
            " [0.47497028]\n",
            " [0.46660277]\n",
            " [0.46851462]\n",
            " [0.4681147 ]\n",
            " [0.47137195]\n",
            " [0.46777406]\n",
            " [0.46552873]\n",
            " [0.46848688]]\n",
            "[0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\n",
            "[0 0 0 0 1 0 0 0 0 0]\n",
            "\n",
            " Confusion matrix: \n",
            " [[3832  164]\n",
            " [   2    1]]\n",
            "F1 Score: 0.011904761904761906\n",
            "Accuracy: 0.9584896224056014\n",
            "Precision: 0.006060606060606061\n",
            "Recall: 0.3333333333333333\n",
            "ROC AUC: 0.6461461461461462\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "  0%|          | 2/1120 [00:00<01:33, 11.90it/s]"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "Epoch 110 | Test Loss 0.6392952657881237\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "100%|██████████| 1120/1120 [01:30<00:00, 12.35it/s]\n",
            "  0%|          | 0/1120 [00:00<?, ?it/s]"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            " Confusion matrix: \n",
            " [[29731 24722]\n",
            " [ 6119 11062]]\n",
            "F1 Score: 0.41770980836401395\n",
            "Accuracy: 0.5694642209006896\n",
            "Precision: 0.30913257321708026\n",
            "Recall: 0.643850765380362\n",
            "ROC AUC: 0.594922279096256\n",
            "Epoch 111 | Train Loss 0.6728803627725158\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "100%|██████████| 1120/1120 [01:30<00:00, 12.31it/s]\n",
            "  0%|          | 0/1120 [00:00<?, ?it/s]"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            " Confusion matrix: \n",
            " [[29771 24743]\n",
            " [ 6079 11041]]\n",
            "F1 Score: 0.417397550279752\n",
            "Accuracy: 0.569729458078566\n",
            "Precision: 0.3085457187569864\n",
            "Recall: 0.6449182242990654\n",
            "ROC AUC: 0.5955174091007746\n",
            "Epoch 112 | Train Loss 0.6717621985822916\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "100%|██████████| 1120/1120 [01:32<00:00, 12.12it/s]\n",
            "  0%|          | 0/1120 [00:00<?, ?it/s]"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            " Confusion matrix: \n",
            " [[29849 24679]\n",
            " [ 6001 11105]]\n",
            "F1 Score: 0.41992815276989975\n",
            "Accuracy: 0.5717117569869057\n",
            "Precision: 0.3103342275877487\n",
            "Recall: 0.6491874196188472\n",
            "ROC AUC: 0.5982971282366536\n",
            "Epoch 113 | Train Loss 0.6712341709860734\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "100%|██████████| 1120/1120 [01:32<00:00, 12.14it/s]\n",
            "  0%|          | 0/1120 [00:00<?, ?it/s]"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            " Confusion matrix: \n",
            " [[29786 24701]\n",
            " [ 6064 11083]]\n",
            "F1 Score: 0.418771608320266\n",
            "Accuracy: 0.5705251696121953\n",
            "Precision: 0.30971942767717414\n",
            "Recall: 0.6463521315682044\n",
            "ROC AUC: 0.5965073191105837\n",
            "Epoch 114 | Train Loss 0.6719097362032959\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "100%|██████████| 1120/1120 [01:31<00:00, 12.18it/s]\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            " Confusion matrix: \n",
            " [[29861 24796]\n",
            " [ 5989 10988]]\n",
            "F1 Score: 0.41651977786622696\n",
            "Accuracy: 0.5702459725828517\n",
            "Precision: 0.3070646098815113\n",
            "Recall: 0.6472286034046062\n",
            "ROC AUC: 0.5967815080985561\n",
            "Epoch 115 | Train Loss 0.6717602757470948\n",
            "[[0.468746  ]\n",
            " [0.47237578]\n",
            " [0.46821952]\n",
            " [0.46560407]\n",
            " [0.46863523]\n",
            " [0.47201824]\n",
            " [0.46952334]\n",
            " [0.46637827]\n",
            " [0.46833622]\n",
            " [0.46850258]]\n",
            "[0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\n",
            "[0 0 0 0 0 0 0 0 0 0]\n",
            "\n",
            " Confusion matrix: \n",
            " [[3832  164]\n",
            " [   2    1]]\n",
            "F1 Score: 0.011904761904761906\n",
            "Accuracy: 0.9584896224056014\n",
            "Precision: 0.006060606060606061\n",
            "Recall: 0.3333333333333333\n",
            "ROC AUC: 0.6461461461461462\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "  0%|          | 2/1120 [00:00<01:34, 11.78it/s]"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "Epoch 115 | Test Loss 0.6396421913116698\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            " 35%|███▌      | 396/1120 [00:32<00:58, 12.48it/s]"
          ],
          "name": "stderr"
        }
      ]
    }
  ]
}