unif_nonunif_gudhi_trained_unif_nonunif_gudhi_val_test.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Pacakge & Data Import"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import torch\n",
    "import matplotlib.pyplot as plt\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "import torch.optim as optim\n",
    "from tqdm.notebook import tqdm\n",
    "import time\n",
    "from torchsummary import summary\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.metrics import precision_score, recall_score, f1_score, confusion_matrix\n",
    "import pandas as pd\n",
    "import seaborn as sns\n",
    "import os"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2000\n"
     ]
    }
   ],
   "source": [
    "# import labels for gudhi shapes\n",
    "gudhi_shape_labels_unif = np.genfromtxt('Gudhi Shape Dataset Uniform/shape_labels.csv', delimiter=',', skip_header=1)\n",
    "gudhi_shape_labels_unif = gudhi_shape_labels_unif.astype(int)[:,2]\n",
    "print(len(gudhi_shape_labels_unif))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3157\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/var/folders/d3/99lvl9fd1673ngz9966pvq100000gn/T/ipykernel_56357/2240478565.py:3: RuntimeWarning: invalid value encountered in cast\n",
      "  gudhi_shape_labels_nonunif = gudhi_shape_labels_nonunif.astype(int)[:,2]\n"
     ]
    }
   ],
   "source": [
    "# import labels for gudhi shapes\n",
    "gudhi_shape_labels_nonunif = np.genfromtxt('Gudhi Shape Dataset Nonuniform/shape_labels.csv', delimiter=',', skip_header=1)\n",
    "gudhi_shape_labels_nonunif = gudhi_shape_labels_nonunif.astype(int)[:,2]\n",
    "print(len(gudhi_shape_labels_nonunif))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "gudhi_shapes_nonunif = np.array([])\n",
    "\n",
    "base = 'Gudhi Shape Dataset Nonuniform'\n",
    "\n",
    "# Check if the required files exist for each shape\n",
    "for i in range(1000, 4769):\n",
    "    points_file = f'{base}/shape_{i}_points.csv'\n",
    "    laplacian_file = f'{base}/shape_{i}_laplacian.csv'\n",
    "    vr_persistence_image_file = f'{base}/shape_{i}_vr_persistence_image.csv'\n",
    "    abstract_persistence_image_file = f'{base}/shape_{i}_abstract_persistence_image.csv'\n",
    "\n",
    "    if (os.path.exists(points_file) and\n",
    "        os.path.exists(laplacian_file) and\n",
    "        os.path.exists(vr_persistence_image_file) and\n",
    "        os.path.exists(abstract_persistence_image_file)):\n",
    "        gudhi_shapes_nonunif = np.append(gudhi_shapes_nonunif, i)\n",
    "    \n",
    "\n",
    "gudhi_shapes_nonunif = gudhi_shapes_nonunif.astype(int)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Randomly selected 1000 samples.\n",
      "Shape of laplacians: (1000, 1000, 1000)\n",
      "Shape of VR persistence images: (1000, 100, 100)\n",
      "Shape of abstract persistence images: (1000, 100, 100)\n",
      "Shape of selected labels: (1000,)\n"
     ]
    }
   ],
   "source": [
    "# Uniform\n",
    "\n",
    "seed_value = 221\n",
    "np.random.seed(seed_value)\n",
    "\n",
    "num_samples_unif = len(gudhi_shape_labels_unif) # currently set to full dataset\n",
    "num_samples_unif = 1000\n",
    "\n",
    "# Generate random indices\n",
    "random_indices_unif = np.random.choice(len(gudhi_shape_labels_unif), size=num_samples_unif, replace=False)\n",
    "base = 'Gudhi Shape Dataset Uniform'\n",
    "# Select the corresponding data and labels\n",
    "gudhi_laplacians_unif = []\n",
    "gudhi_vr_persistence_images_unif = []\n",
    "gudhi_abstract_persistence_images_unif = []\n",
    "gudhi_selected_labels_unif = []\n",
    "\n",
    "for i in random_indices_unif:\n",
    "    gudhi_laplacians_unif.append(np.genfromtxt(f'{base}/shape_{i}_laplacian.csv', delimiter=',', skip_header=0))\n",
    "    gudhi_vr_persistence_images_unif.append(np.genfromtxt(f'{base}/shape_{i}_vr_persistence_image.csv', delimiter=',', skip_header=0))\n",
    "    gudhi_abstract_persistence_images_unif.append(np.genfromtxt(f'{base}/shape_{i}_abstract_persistence_image.csv', delimiter=',', skip_header=0))\n",
    "    gudhi_selected_labels_unif.append(gudhi_shape_labels_unif[i])\n",
    "\n",
    "# Convert selected labels to NumPy array\n",
    "gudhi_selected_labels_unif = np.array(gudhi_selected_labels_unif)\n",
    "\n",
    "# Print summary\n",
    "print(f\"Randomly selected {num_samples_unif} samples.\")\n",
    "print(f\"Shape of laplacians: {np.array(gudhi_laplacians_unif).shape}\")\n",
    "print(f\"Shape of VR persistence images: {np.array(gudhi_vr_persistence_images_unif).shape}\")\n",
    "print(f\"Shape of abstract persistence images: {np.array(gudhi_abstract_persistence_images_unif).shape}\")\n",
    "print(f\"Shape of selected labels: {gudhi_selected_labels_unif.shape}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Randomly selected 1000 samples.\n",
      "Shape of laplacians: (1000, 1000, 1000)\n",
      "Shape of VR persistence images: (1000, 100, 100)\n",
      "Shape of abstract persistence images: (1000, 100, 100)\n",
      "Shape of selected labels: (1000,)\n"
     ]
    }
   ],
   "source": [
    "# Non-uniform\n",
    "\n",
    "seed_value = 221\n",
    "np.random.seed(seed_value)\n",
    "\n",
    "num_samples_nonunif = len(gudhi_shapes_nonunif) # currently set to full dataset\n",
    "num_samples_nonunif = 1000\n",
    "\n",
    "# Generate random indices\n",
    "random_indices_nonunif = np.random.choice(len(gudhi_shapes_nonunif), size=num_samples_nonunif, replace=False)\n",
    "base = 'Gudhi Shape Dataset Nonuniform'\n",
    "# Select the corresponding data and labels\n",
    "gudhi_laplacians_nonunif = []\n",
    "gudhi_vr_persistence_images_nonunif = []\n",
    "gudhi_abstract_persistence_images_nonunif = []\n",
    "gudhi_selected_labels_nonunif = []\n",
    "\n",
    "for i in random_indices_nonunif:\n",
    "    gudhi_laplacians_nonunif.append(np.genfromtxt(f'{base}/shape_{gudhi_shapes_nonunif[i]}_laplacian.csv', delimiter=',', skip_header=0))\n",
    "    gudhi_vr_persistence_images_nonunif.append(np.genfromtxt(f'{base}/shape_{gudhi_shapes_nonunif[i]}_vr_persistence_image.csv', delimiter=',', skip_header=0))\n",
    "    gudhi_abstract_persistence_images_nonunif.append(np.genfromtxt(f'{base}/shape_{gudhi_shapes_nonunif[i]}_abstract_persistence_image.csv', delimiter=',', skip_header=0))\n",
    "    gudhi_selected_labels_nonunif.append(gudhi_shape_labels_nonunif[i])\n",
    "\n",
    "# Convert selected labels to NumPy array\n",
    "gudhi_selected_labels_nonunif = np.array(gudhi_selected_labels_nonunif)\n",
    "\n",
    "# Print summary\n",
    "print(f\"Randomly selected {num_samples_nonunif} samples.\")\n",
    "print(f\"Shape of laplacians: {np.array(gudhi_laplacians_nonunif).shape}\")\n",
    "print(f\"Shape of VR persistence images: {np.array(gudhi_vr_persistence_images_nonunif).shape}\")\n",
    "print(f\"Shape of abstract persistence images: {np.array(gudhi_abstract_persistence_images_nonunif).shape}\")\n",
    "print(f\"Shape of selected labels: {gudhi_selected_labels_nonunif.shape}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "gudhi_laplacians = np.concatenate((gudhi_laplacians_nonunif, gudhi_laplacians_unif), axis=0)\n",
    "gudhi_vr_persistence_images = np.concatenate((gudhi_vr_persistence_images_nonunif, gudhi_vr_persistence_images_unif), axis=0)\n",
    "gudhi_abstract_persistence_images = np.concatenate((gudhi_abstract_persistence_images_nonunif, gudhi_abstract_persistence_images_unif), axis=0)\n",
    "gudhi_selected_labels = np.concatenate((gudhi_selected_labels_nonunif, gudhi_selected_labels_unif), axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Shape of combined laplacians: (2000, 1000, 1000)\n",
      "Shape of combined VR persistence images: (2000, 100, 100)\n",
      "Shape of combined abstract persistence images: (2000, 100, 100)\n",
      "Shape of combined selected labels: (2000,)\n"
     ]
    }
   ],
   "source": [
    "print(f\"Shape of combined laplacians: {gudhi_laplacians.shape}\")\n",
    "print(f\"Shape of combined VR persistence images: {gudhi_vr_persistence_images.shape}\")\n",
    "print(f\"Shape of combined abstract persistence images: {gudhi_abstract_persistence_images.shape}\")\n",
    "print(f\"Shape of combined selected labels: {gudhi_selected_labels.shape}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "162\n"
     ]
    }
   ],
   "source": [
    "# import labels for medical shapes\n",
    "medical_shape_labels = np.genfromtxt('Medical Dataset/shape_labels.csv', delimiter=',', skip_header=1)\n",
    "medical_shape_labels = medical_shape_labels.astype(int)[:,2]\n",
    "print(len(medical_shape_labels))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Randomly selected 162 samples.\n",
      "Shape of laplacians: (162, 1000, 1000)\n",
      "Shape of VR persistence images: (162, 100, 100)\n",
      "Shape of abstract persistence images: (162, 100, 100)\n",
      "Shape of selected labels: (162,)\n"
     ]
    }
   ],
   "source": [
    "seed_value = 221\n",
    "np.random.seed(seed_value)\n",
    "\n",
    "num_samples = 162 # currently set to full dataset\n",
    "\n",
    "# Generate random indices\n",
    "random_indices = np.random.choice(len(medical_shape_labels), size=num_samples, replace=False)\n",
    "base = 'Medical Dataset/'\n",
    "# Select the corresponding data and labels\n",
    "medical_laplacians = []\n",
    "medical_vr_persistence_images = []\n",
    "medical_abstract_persistence_images = []\n",
    "medical_selected_labels = []\n",
    "\n",
    "for i in random_indices:\n",
    "    medical_laplacians.append(np.genfromtxt(f'{base}/shape_{i}_laplacian.csv', delimiter=',', skip_header=0))\n",
    "    medical_vr_persistence_images.append(np.genfromtxt(f'{base}/shape_{i}_vr_persistence_image.csv', delimiter=',', skip_header=0))\n",
    "    medical_abstract_persistence_images.append(np.genfromtxt(f'{base}/shape_{i}_abstract_persistence_image.csv', delimiter=',', skip_header=0))\n",
    "    medical_selected_labels.append(medical_shape_labels[i])\n",
    "\n",
    "# Convert selected labels to NumPy array\n",
    "medical_selected_labels = np.array(medical_selected_labels)\n",
    "\n",
    "# Print summary\n",
    "print(f\"Randomly selected {num_samples} samples.\")\n",
    "print(f\"Shape of laplacians: {np.array(medical_laplacians).shape}\")\n",
    "print(f\"Shape of VR persistence images: {np.array(medical_vr_persistence_images).shape}\")\n",
    "print(f\"Shape of abstract persistence images: {np.array(medical_abstract_persistence_images).shape}\")\n",
    "print(f\"Shape of selected labels: {medical_selected_labels.shape}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Define data class"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ShapeDataset(torch.utils.data.Dataset):\n",
    "    def __init__(self, data, labels):\n",
    "        self.data = [torch.tensor(d, dtype=torch.float32).unsqueeze(0) for d in data]\n",
    "        self.labels = torch.tensor(labels, dtype=torch.long)\n",
    "\n",
    "    def __len__(self):\n",
    "        return len(self.labels)\n",
    "\n",
    "    def __getitem__(self, idx):\n",
    "        return self.data[idx], self.labels[idx]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Data Splitting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Laplacians Train data size: 1600\n",
      "Laplacians Validation data size: 200\n",
      "Laplacians Test data size: 200\n"
     ]
    }
   ],
   "source": [
    "train_ratio = 0.8\n",
    "valid_ratio = 0.1\n",
    "test_ratio = 0.1\n",
    "\n",
    "# Split Gudhi Laplacians\n",
    "train_data_gudhi_laplacians, test_data_gudhi_laplacians, train_labels_gudhi, test_labels_gudhi = train_test_split(\n",
    "    gudhi_laplacians, gudhi_selected_labels, test_size=(1 - train_ratio), random_state=42\n",
    ")\n",
    "valid_data_gudhi_laplacians, test_data_gudhi_laplacians, valid_labels_gudhi, test_labels_gudhi = train_test_split(\n",
    "    test_data_gudhi_laplacians, test_labels_gudhi, test_size=(test_ratio / (valid_ratio + test_ratio)), random_state=42\n",
    ")\n",
    "\n",
    "# Split Medical Laplacians (valid/test split only, since all are used for validation/testing)\n",
    "valid_data_medical_laplacians, test_data_medical_laplacians, valid_labels_medical, test_labels_medical = train_test_split(\n",
    "    medical_laplacians, medical_selected_labels, test_size=0.5, random_state=42\n",
    ")\n",
    "\n",
    "# Combine validation sets for Laplacians and labels\n",
    "valid_laplacians = valid_data_gudhi_laplacians\n",
    "valid_labels = valid_labels_gudhi\n",
    "\n",
    "# Combine test sets for completeness\n",
    "test_laplacians = test_data_gudhi_laplacians\n",
    "test_labels = test_labels_gudhi\n",
    "\n",
    "# Print a summary\n",
    "print(f\"Laplacians Train data size: {len(train_data_gudhi_laplacians)}\")\n",
    "print(f\"Laplacians Validation data size: {len(valid_laplacians)}\")\n",
    "print(f\"Laplacians Test data size: {len(test_laplacians)}\")\n",
    "\n",
    "\n",
    "# Split VR Persistence Images\n",
    "train_data_gudhi_vr_persistence_images, test_data_gudhi_vr_persistence_images, train_labels_gudhi_check, test_labels_gudhi_check = train_test_split(\n",
    "    gudhi_vr_persistence_images, gudhi_selected_labels, test_size=(1 - train_ratio), random_state=42\n",
    ")\n",
    "valid_data_gudhi_vr_persistence_images, test_data_gudhi_vr_persistence_images, valid_labels_gudhi_check, test_labels_gudhi_check = train_test_split(\n",
    "    test_data_gudhi_vr_persistence_images, test_labels_gudhi_check, test_size=(test_ratio / (valid_ratio + test_ratio)), random_state=42\n",
    ")\n",
    "\n",
    "# Split Medical VR Persistence Images (valid/test split only, since all are used for validation/testing)\n",
    "valid_data_medical_vr_persistence_images, test_data_medical_vr_persistence_images, valid_labels_medical_check, test_labels_medical_check = train_test_split(\n",
    "    medical_vr_persistence_images, medical_selected_labels, test_size=0.5, random_state=42\n",
    ")\n",
    "\n",
    "# Combine validation sets for VR Persistence Images and labels\n",
    "valid_vr_persistence_images = valid_data_gudhi_vr_persistence_images\n",
    "valid_vr_labels = valid_labels_gudhi\n",
    "\n",
    "# Combine test sets for VR Persistence Images and labels\n",
    "test_vr_persistence_images = test_data_gudhi_vr_persistence_images\n",
    "test_vr_labels = test_labels_gudhi\n",
    "\n",
    "\n",
    "# Split Abstract Persistence Images\n",
    "train_data_gudhi_abstract_persistence_images, test_data_gudhi_abstract_persistence_images, train_labels_gudhi_check, test_labels_gudhi_check = train_test_split(\n",
    "    gudhi_abstract_persistence_images, gudhi_selected_labels, test_size=(1 - train_ratio), random_state=42\n",
    ")\n",
    "valid_data_gudhi_abstract_persistence_images, test_data_gudhi_abstract_persistence_images, valid_labels_gudhi_check, test_labels_gudhi_check = train_test_split(\n",
    "    test_data_gudhi_abstract_persistence_images, test_labels_gudhi_check, test_size=(test_ratio / (valid_ratio + test_ratio)), random_state=42\n",
    ")\n",
    "\n",
    "# Split Medical Abstract Persistence Images (valid/test split only, since all are used for validation/testing)\n",
    "valid_data_medical_abstract_persistence_images, test_data_medical_abstract_persistence_images, valid_labels_medical_check, test_labels_medical_check = train_test_split(\n",
    "    medical_abstract_persistence_images, medical_selected_labels, test_size=0.5, random_state=42\n",
    ")\n",
    "\n",
    "# Combine validation sets for Abstract Persistence Images and labels\n",
    "valid_abstract_persistence_images = valid_data_gudhi_abstract_persistence_images\n",
    "valid_abstract_labels = valid_labels_gudhi\n",
    "\n",
    "# Combine test sets for Abstract Persistence Images and labels\n",
    "test_abstract_persistence_images = test_data_gudhi_abstract_persistence_images\n",
    "test_abstract_labels = test_labels_gudhi\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## CNN Definitions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "class CNN(nn.Module):\n",
    "    def __init__(self, input_shape, num_classes=2):\n",
    "        super(CNN, self).__init__()\n",
    "        # Convolutional Layers\n",
    "        self.conv1 = nn.Conv2d(1, 16, kernel_size=3, stride=1, padding=1)\n",
    "        self.conv2 = nn.Conv2d(16, 32, kernel_size=3, stride=1, padding=1)\n",
    "        \n",
    "        # Pooling Layer\n",
    "        self.pool = nn.MaxPool2d(kernel_size=2, stride=2)\n",
    "        \n",
    "        # Adaptive Pooling to resize to 100x100\n",
    "        self.adaptive_pool = nn.AdaptiveAvgPool2d((100, 100))\n",
    "        \n",
    "        # Dynamically calculate input size to fc1\n",
    "        self.feature_size = self._get_feature_size(input_shape)\n",
    "        \n",
    "        # Fully Connected Layers\n",
    "        self.fc1 = nn.Linear(self.feature_size, 128)\n",
    "        self.dropout = nn.Dropout(0.5)\n",
    "        self.fc2 = nn.Linear(128, num_classes)\n",
    "\n",
    "    def _get_feature_size(self, input_shape):\n",
    "        # Create a dummy input to calculate size after conv and pooling\n",
    "        dummy_input = torch.zeros(1, 1, *input_shape)\n",
    "        x = self.pool(F.relu(self.conv1(dummy_input)))\n",
    "        x = self.pool(F.relu(self.conv2(x)))\n",
    "        \n",
    "        # Apply adaptive pooling to get 100x100 size\n",
    "        x = self.adaptive_pool(x)\n",
    "        return x.numel()  # Number of elements after flattening\n",
    "\n",
    "    def forward(self, x):\n",
    "        # Apply convolutional layers with pooling\n",
    "        x = self.pool(F.relu(self.conv1(x)))\n",
    "        x = self.pool(F.relu(self.conv2(x)))\n",
    "        \n",
    "        # Apply adaptive pooling to resize to 100x100\n",
    "        x = self.adaptive_pool(x)\n",
    "        \n",
    "        # Flatten and pass through fully connected layers\n",
    "        x = torch.flatten(x, start_dim=1)\n",
    "        x = F.relu(self.fc1(x))\n",
    "        x = self.dropout(x)\n",
    "        x = self.fc2(x)\n",
    "        return F.log_softmax(x, dim=1)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "class DualInputCNN(nn.Module):\n",
    "    def __init__(self, input_shape1, input_shape2, num_classes=2):\n",
    "        super(DualInputCNN, self).__init__()\n",
    "\n",
    "        # Laplacian input path with additional pooling to reduce to 100x100\n",
    "        self.conv1_lap = nn.Conv2d(1, 16, kernel_size=3, stride=1, padding=1)\n",
    "        self.conv2_lap = nn.Conv2d(16, 32, kernel_size=3, stride=1, padding=1)\n",
    "        self.pool_lap = nn.MaxPool2d(2, 2)  # Reduce spatial dimensions\n",
    "        self.adaptive_pool_lap = nn.AdaptiveAvgPool2d((100, 100))  # Resize to 100x100\n",
    "        \n",
    "        # Persistence image input path (no pooling)\n",
    "        self.conv1_pers = nn.Conv2d(1, 16, kernel_size=3, stride=1, padding=1)\n",
    "        self.conv2_pers = nn.Conv2d(16, 32, kernel_size=3, stride=1, padding=1)\n",
    "        self.adaptive_pool_pers = nn.AdaptiveAvgPool2d((100, 100))  # Resize to 100x100\n",
    "        \n",
    "        # Fully connected layers\n",
    "        self.fc1 = nn.Linear(32 * 100 * 100 + 32 * 100 * 100, 128)  # Adjusted for 100x100 input\n",
    "        self.dropout = nn.Dropout(0.5)\n",
    "        self.fc2 = nn.Linear(128, num_classes)\n",
    "\n",
    "    def forward(self, x1, x2):\n",
    "        # Laplacians path (downsampling to 100x100)\n",
    "        x1 = F.relu(self.conv1_lap(x1))\n",
    "        x1 = self.pool_lap(x1)  # First pool: 250x250 -> 125x125\n",
    "        x1 = F.relu(self.conv2_lap(x1))\n",
    "        x1 = self.pool_lap(x1)  # Second pool: 125x125 -> 62x62\n",
    "        x1 = self.adaptive_pool_lap(x1)  # Resize to 100x100\n",
    "        \n",
    "        # Persistence images path (no pooling)\n",
    "        x2 = F.relu(self.conv1_pers(x2))\n",
    "        x2 = F.relu(self.conv2_pers(x2))\n",
    "        x2 = self.adaptive_pool_pers(x2)  # Ensure persistence images are 100x100\n",
    "        \n",
    "        # Concatenate along dim=1 (channels)\n",
    "        x = torch.cat((x1, x2), dim=1)  # Concatenates the outputs along the channel axis\n",
    "\n",
    "        # Flatten for fully connected layer\n",
    "        x = torch.flatten(x, start_dim=1)\n",
    "        \n",
    "        # Fully connected layers\n",
    "        x = F.relu(self.fc1(x))\n",
    "        x = self.dropout(x)\n",
    "        x = self.fc2(x)\n",
    "        \n",
    "        return F.log_softmax(x, dim=1)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training on cpu\n"
     ]
    }
   ],
   "source": [
    "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
    "print(f\"Training on {device}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Data Preparation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Convert data to PyTorch Datasets\n",
    "train_dataset_laplacians = ShapeDataset(train_data_gudhi_laplacians, train_labels_gudhi)\n",
    "valid_dataset_laplacians = ShapeDataset(valid_laplacians, valid_labels)\n",
    "test_dataset_laplacians = ShapeDataset(test_laplacians, test_labels)\n",
    "\n",
    "train_dataset_vr = ShapeDataset(train_data_gudhi_vr_persistence_images, train_labels_gudhi)\n",
    "valid_dataset_vr = ShapeDataset(valid_vr_persistence_images, valid_vr_labels)\n",
    "test_dataset_vr = ShapeDataset(test_vr_persistence_images, test_vr_labels)\n",
    "\n",
    "train_dataset_abstract = ShapeDataset(train_data_gudhi_abstract_persistence_images, train_labels_gudhi)\n",
    "valid_dataset_abstract = ShapeDataset(valid_abstract_persistence_images, valid_abstract_labels)\n",
    "test_dataset_abstract = ShapeDataset(test_abstract_persistence_images, test_abstract_labels)\n",
    "\n",
    "# Define DataLoaders\n",
    "batch_size = 32\n",
    "\n",
    "train_loader_laplacians = torch.utils.data.DataLoader(train_dataset_laplacians, batch_size=batch_size, shuffle=False)\n",
    "valid_loader_laplacians = torch.utils.data.DataLoader(valid_dataset_laplacians, batch_size=batch_size, shuffle=False)\n",
    "test_loader_laplacians = torch.utils.data.DataLoader(test_dataset_laplacians, batch_size=batch_size, shuffle=False)\n",
    "\n",
    "train_loader_vr = torch.utils.data.DataLoader(train_dataset_vr, batch_size=batch_size, shuffle=False)\n",
    "valid_loader_vr = torch.utils.data.DataLoader(valid_dataset_vr, batch_size=batch_size, shuffle=False)\n",
    "test_loader_vr = torch.utils.data.DataLoader(test_dataset_vr, batch_size=batch_size, shuffle=False)\n",
    "\n",
    "train_loader_abstract = torch.utils.data.DataLoader(train_dataset_abstract, batch_size=batch_size, shuffle=False)\n",
    "valid_loader_abstract = torch.utils.data.DataLoader(valid_dataset_abstract, batch_size=batch_size, shuffle=False)\n",
    "test_loader_abstract = torch.utils.data.DataLoader(test_dataset_abstract, batch_size=batch_size, shuffle=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Model Instantiation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "# For single-input CNN (Laplacians)\n",
    "input_shape = train_data_gudhi_laplacians[0].shape\n",
    "num_classes = 2 # binary classification\n",
    "\n",
    "model_single_laplacians = CNN(input_shape, num_classes)\n",
    "\n",
    "# For dual-input CNNs (Laplacians + VR Persistence Images, Laplacians + Abstract Persistence Images)\n",
    "input_shape1 = train_data_gudhi_laplacians[0].shape\n",
    "input_shape2 = train_data_gudhi_vr_persistence_images[0].shape\n",
    "input_shape3 = train_data_gudhi_abstract_persistence_images[0].shape\n",
    "\n",
    "model_dual_lap_vr = DualInputCNN(input_shape1, input_shape2, num_classes)\n",
    "model_dual_lap_abstract = DualInputCNN(input_shape1, input_shape3, num_classes)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Training, Validation, and Testing Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train_single_input(model, dataloader, optimizer, criterion, device):\n",
    "    model.train()\n",
    "    total_loss = 0\n",
    "    correct = 0\n",
    "    progress_bar = tqdm(dataloader, desc=\"Training\", leave=False)\n",
    "    \n",
    "    for inputs, labels in progress_bar:\n",
    "        inputs, labels = inputs.to(device), labels.to(device)\n",
    "        optimizer.zero_grad()\n",
    "        outputs = model(inputs)\n",
    "        loss = criterion(outputs, labels)\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "        total_loss += loss.item()\n",
    "        preds = torch.argmax(outputs, dim=1)\n",
    "        correct += (preds == labels).sum().item()\n",
    "        \n",
    "        progress_bar.set_postfix(loss=loss.item())\n",
    "    \n",
    "    accuracy = correct / len(dataloader.dataset)\n",
    "    return total_loss / len(dataloader.dataset), accuracy\n",
    "\n",
    "\n",
    "def validate_single_input(model, dataloader, criterion, device):\n",
    "    model.eval()\n",
    "    total_loss = 0\n",
    "    correct = 0\n",
    "    progress_bar = tqdm(dataloader, desc=\"Validating\", leave=False)\n",
    "    \n",
    "    with torch.no_grad():\n",
    "        for inputs, labels in progress_bar:\n",
    "            inputs, labels = inputs.to(device), labels.to(device)\n",
    "            outputs = model(inputs)\n",
    "            loss = criterion(outputs, labels)\n",
    "            total_loss += loss.item()\n",
    "            preds = torch.argmax(outputs, dim=1)\n",
    "            correct += (preds == labels).sum().item()\n",
    "            \n",
    "            progress_bar.set_postfix(loss=loss.item())\n",
    "    \n",
    "    accuracy = correct / len(dataloader.dataset)\n",
    "    return total_loss / len(dataloader.dataset), accuracy\n",
    "\n",
    "\n",
    "def train_dual_input(model, dataloader1, dataloader2, optimizer, criterion, device):\n",
    "    model.train()\n",
    "    total_loss = 0\n",
    "    correct = 0\n",
    "    progress_bar = tqdm(zip(dataloader1, dataloader2), desc=\"Training (Dual Input)\", leave=False, total=min(len(dataloader1), len(dataloader2)))\n",
    "    \n",
    "    for (inputs1, labels1), (inputs2, labels2) in progress_bar:\n",
    "        inputs1, labels1 = inputs1.to(device), labels1.to(device)\n",
    "        inputs2, labels2 = inputs2.to(device), labels2.to(device)\n",
    "        \n",
    "        if not torch.equal(labels1, labels2):\n",
    "            print(\"Labels mismatch in dual-input training! Skipping batch.\")\n",
    "            continue\n",
    "        \n",
    "        optimizer.zero_grad()\n",
    "        outputs = model(inputs1, inputs2)\n",
    "        loss = criterion(outputs, labels1)\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "        total_loss += loss.item()\n",
    "        preds = torch.argmax(outputs, dim=1)\n",
    "        correct += (preds == labels1).sum().item()\n",
    "        \n",
    "        progress_bar.set_postfix(loss=loss.item())\n",
    "    \n",
    "    accuracy = correct / len(dataloader1.dataset)\n",
    "    return total_loss / len(dataloader1.dataset), accuracy\n",
    "\n",
    "\n",
    "def validate_dual_input(model, valid_loader_laplacians, valid_loader_vr, criterion, device='cuda'):\n",
    "    model.eval()\n",
    "    running_loss = 0.0\n",
    "    correct = 0\n",
    "    total = 0\n",
    "    \n",
    "    with torch.no_grad():\n",
    "        for (inputs1, _), (inputs2, targets) in zip(valid_loader_laplacians, valid_loader_vr):\n",
    "            inputs1, inputs2, targets = inputs1.to(device), inputs2.to(device), targets.to(device)\n",
    "            \n",
    "            outputs = model(inputs1, inputs2)\n",
    "            loss = criterion(outputs, targets)\n",
    "            running_loss += loss.item()\n",
    "            \n",
    "            if outputs.shape[-1] > 1:\n",
    "                _, predicted = torch.max(outputs, 1)\n",
    "            else:  # Binary classification\n",
    "                predicted = (outputs > 0.5).float()\n",
    "            \n",
    "            total += targets.size(0)\n",
    "            correct += (predicted == targets).sum().item()\n",
    "\n",
    "    avg_loss = running_loss / len(valid_loader_laplacians)\n",
    "    accuracy = correct / total\n",
    "\n",
    "    return avg_loss, accuracy\n",
    "\n",
    "def test_single_input(model, dataloader, criterion, device):\n",
    "    model.eval()\n",
    "    total_loss = 0\n",
    "    correct = 0\n",
    "    total = 0\n",
    "    all_preds = []\n",
    "    all_labels = []\n",
    "    progress_bar = tqdm(dataloader, desc=\"Testing\", leave=False)\n",
    "\n",
    "    with torch.no_grad():\n",
    "        for inputs, labels in progress_bar:\n",
    "            inputs, labels = inputs.to(device), labels.to(device)\n",
    "            outputs = model(inputs)\n",
    "            loss = criterion(outputs, labels)\n",
    "            total_loss += loss.item()\n",
    "            preds = torch.argmax(outputs, dim=1)\n",
    "            correct += (preds == labels).sum().item()\n",
    "            total += labels.size(0)\n",
    "            \n",
    "            all_preds.extend(preds.cpu().numpy())\n",
    "            all_labels.extend(labels.cpu().numpy())\n",
    "\n",
    "            progress_bar.set_postfix(loss=loss.item())\n",
    "\n",
    "    avg_loss = total_loss / len(dataloader.dataset)\n",
    "    accuracy = correct / total\n",
    "    precision = precision_score(all_labels, all_preds, average='binary')\n",
    "    recall = recall_score(all_labels, all_preds, average='binary')\n",
    "    f1 = f1_score(all_labels, all_preds, average='binary')\n",
    "\n",
    "    metrics_df = pd.DataFrame({\n",
    "        'Loss': [avg_loss],\n",
    "        'Accuracy': [accuracy],\n",
    "        'Precision': [precision],\n",
    "        'Recall': [recall],\n",
    "        'F1 Score': [f1]\n",
    "    })\n",
    "\n",
    "    cm = confusion_matrix(all_labels, all_preds)\n",
    "\n",
    "    print(f\"Test Loss: {avg_loss:.4f}, Test Accuracy: {accuracy:.4f}, Precision: {precision:.4f}, Recall: {recall:.4f}, F1 Score: {f1:.4f}\")\n",
    "    return metrics_df, cm\n",
    "\n",
    "\n",
    "def test_dual_input(model, dataloader1, dataloader2, criterion, device='cuda'):\n",
    "    model.eval()\n",
    "    running_loss = 0.0\n",
    "    correct = 0\n",
    "    total = 0\n",
    "    all_preds = []\n",
    "    all_labels = []\n",
    "    progress_bar = tqdm(zip(dataloader1, dataloader2), desc=\"Testing (Dual Input)\", leave=False, total=min(len(dataloader1), len(dataloader2)))\n",
    "\n",
    "    with torch.no_grad():\n",
    "        for (inputs1, _), (inputs2, targets) in progress_bar:\n",
    "            inputs1, inputs2, targets = inputs1.to(device), inputs2.to(device), targets.to(device)\n",
    "\n",
    "            outputs = model(inputs1, inputs2)\n",
    "            loss = criterion(outputs, targets)\n",
    "            running_loss += loss.item()\n",
    "\n",
    "            if outputs.shape[-1] > 1:\n",
    "                _, predicted = torch.max(outputs, 1)\n",
    "            else:  # Binary classification\n",
    "                predicted = (outputs > 0.5).float()\n",
    "\n",
    "            total += targets.size(0)\n",
    "            correct += (predicted == targets).sum().item()\n",
    "\n",
    "            all_preds.extend(predicted.cpu().numpy())\n",
    "            all_labels.extend(targets.cpu().numpy())\n",
    "\n",
    "    avg_loss = running_loss / len(dataloader1.dataset)\n",
    "    accuracy = correct / total\n",
    "    precision = precision_score(all_labels, all_preds, average='binary')\n",
    "    recall = recall_score(all_labels, all_preds, average='binary')\n",
    "    f1 = f1_score(all_labels, all_preds, average='binary')\n",
    "\n",
    "    metrics_df = pd.DataFrame({\n",
    "        'Loss': [avg_loss],\n",
    "        'Accuracy': [accuracy],\n",
    "        'Precision': [precision],\n",
    "        'Recall': [recall],\n",
    "        'F1 Score': [f1]\n",
    "    })\n",
    "\n",
    "    cm = confusion_matrix(all_labels, all_preds)\n",
    "\n",
    "    print(f\"Test Loss: {avg_loss:.4f}, Test Accuracy: {accuracy:.4f}, Precision: {precision:.4f}, Recall: {recall:.4f}, F1 Score: {f1:.4f}\")\n",
    "    return metrics_df, cm"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Training Loops"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "DualInputCNN(\n",
       "  (conv1_lap): Conv2d(1, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "  (conv2_lap): Conv2d(16, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "  (pool_lap): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
       "  (adaptive_pool_lap): AdaptiveAvgPool2d(output_size=(100, 100))\n",
       "  (conv1_pers): Conv2d(1, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "  (conv2_pers): Conv2d(16, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "  (adaptive_pool_pers): AdaptiveAvgPool2d(output_size=(100, 100))\n",
       "  (fc1): Linear(in_features=640000, out_features=128, bias=True)\n",
       "  (dropout): Dropout(p=0.5, inplace=False)\n",
       "  (fc2): Linear(in_features=128, out_features=2, bias=True)\n",
       ")"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
    "model_single_laplacians.to(device)\n",
    "model_dual_lap_vr.to(device)\n",
    "model_dual_lap_abstract.to(device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "criterion = nn.CrossEntropyLoss()\n",
    "optimizer_single = optim.Adam(model_single_laplacians.parameters(), lr=0.001)\n",
    "optimizer_dual_vr = optim.Adam(model_dual_lap_vr.parameters(), lr=0.001)\n",
    "optimizer_dual_abstract = optim.Adam(model_dual_lap_abstract.parameters(), lr=0.001)\n",
    "\n",
    "num_epochs = 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "0b1e9457f70a46cf9ce3462608e6ebcd",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Training:   0%|          | 0/50 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "7567c6261df340a99fd00a6591b310e3",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating:   0%|          | 0/7 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "3b8fd9d232d044e896deea2974927d33",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Testing:   0%|          | 0/7 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test Loss: 0.0195, Test Accuracy: 0.9150, Precision: 0.8780, Recall: 0.9818, F1 Score: 0.9270\n",
      "single-input model (Laplacians) Epoch 1/10, Train Loss: 0.1323, Train Acc: 0.7044, Valid Loss: 0.0190, Valid Acc: 0.8900\n",
      "single-input model (Laplacians)Training time: 287.1641049385071\n",
      "single-input model (Laplacians)Validation time: 7.847338914871216\n",
      "single-input model (Laplacians)Testing time: 8.122156858444214\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "3254f3c91e6647d681f2d44c065e9bc0",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Training:   0%|          | 0/50 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "1b5a3a3d5b66435189c6855b8c9fe666",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating:   0%|          | 0/7 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "d09014346caa47d1822944f6fafbb76b",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Testing:   0%|          | 0/7 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test Loss: 0.0176, Test Accuracy: 0.9200, Precision: 0.8852, Recall: 0.9818, F1 Score: 0.9310\n",
      "single-input model (Laplacians) Epoch 2/10, Train Loss: 0.0088, Train Acc: 0.9231, Valid Loss: 0.0159, Valid Acc: 0.9050\n",
      "single-input model (Laplacians)Training time: 288.6765601634979\n",
      "single-input model (Laplacians)Validation time: 7.496362924575806\n",
      "single-input model (Laplacians)Testing time: 8.115027904510498\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "7ff0e3fe4dd74c3faf506431a8ee47be",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Training:   0%|          | 0/50 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "7c21ce75cf3c40d181d1fd03d06ff8bc",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating:   0%|          | 0/7 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "fd5158aafc7245b4b01acaf84b972e91",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Testing:   0%|          | 0/7 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test Loss: 0.0098, Test Accuracy: 0.9200, Precision: 0.8917, Recall: 0.9727, F1 Score: 0.9304\n",
      "single-input model (Laplacians) Epoch 3/10, Train Loss: 0.0088, Train Acc: 0.9187, Valid Loss: 0.0095, Valid Acc: 0.9000\n",
      "single-input model (Laplacians)Training time: 287.908194065094\n",
      "single-input model (Laplacians)Validation time: 7.540946960449219\n",
      "single-input model (Laplacians)Testing time: 8.272831916809082\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "7c8dc5a68e134034a9aacd522f7a2743",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Training:   0%|          | 0/50 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "9b7e1cf83b21453f8ee7f6f761a19139",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating:   0%|          | 0/7 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "6a54cadbbee0463d943c9a347f75204f",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Testing:   0%|          | 0/7 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test Loss: 0.0094, Test Accuracy: 0.9250, Precision: 0.8992, Recall: 0.9727, F1 Score: 0.9345\n",
      "single-input model (Laplacians) Epoch 4/10, Train Loss: 0.0077, Train Acc: 0.9275, Valid Loss: 0.0093, Valid Acc: 0.9000\n",
      "single-input model (Laplacians)Training time: 289.10678935050964\n",
      "single-input model (Laplacians)Validation time: 7.772883892059326\n",
      "single-input model (Laplacians)Testing time: 8.269337177276611\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "6bf65780e30f43478764e0de20b863d5",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Training:   0%|          | 0/50 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "773a8a2045144163870b815c08404c0c",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating:   0%|          | 0/7 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "85a5eec1d16144bebebc2a9b320eb324",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Testing:   0%|          | 0/7 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test Loss: 0.0091, Test Accuracy: 0.9550, Precision: 0.9391, Recall: 0.9818, F1 Score: 0.9600\n",
      "single-input model (Laplacians) Epoch 5/10, Train Loss: 0.0069, Train Acc: 0.9319, Valid Loss: 0.0083, Valid Acc: 0.9300\n",
      "single-input model (Laplacians)Training time: 288.22981119155884\n",
      "single-input model (Laplacians)Validation time: 7.918018102645874\n",
      "single-input model (Laplacians)Testing time: 8.83225703239441\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "e184a8c8295c4550bf11e71c4f907fe8",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Training:   0%|          | 0/50 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "66b9a32480a648d7afe882f6ab23ced2",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating:   0%|          | 0/7 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "ad8c69fcea9641c6bc4a5c0e21e165e3",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Testing:   0%|          | 0/7 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test Loss: 0.0086, Test Accuracy: 0.9550, Precision: 0.9469, Recall: 0.9727, F1 Score: 0.9596\n",
      "single-input model (Laplacians) Epoch 6/10, Train Loss: 0.0071, Train Acc: 0.9337, Valid Loss: 0.0081, Valid Acc: 0.9400\n",
      "single-input model (Laplacians)Training time: 285.63087606430054\n",
      "single-input model (Laplacians)Validation time: 7.2804930210113525\n",
      "single-input model (Laplacians)Testing time: 7.694826126098633\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "20a6c689974844e393e06970df4a09f7",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Training:   0%|          | 0/50 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "fb7c7d9ab7994aeabba57a33983d72ef",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating:   0%|          | 0/7 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "4c392f235e2c43d69e14e7c4c4ec836a",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Testing:   0%|          | 0/7 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test Loss: 0.0087, Test Accuracy: 0.9550, Precision: 0.9391, Recall: 0.9818, F1 Score: 0.9600\n",
      "single-input model (Laplacians) Epoch 7/10, Train Loss: 0.0067, Train Acc: 0.9350, Valid Loss: 0.0087, Valid Acc: 0.9300\n",
      "single-input model (Laplacians)Training time: 280.7118399143219\n",
      "single-input model (Laplacians)Validation time: 7.368743181228638\n",
      "single-input model (Laplacians)Testing time: 7.837591171264648\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "c697f5c298884b21b9d807d51eda607c",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Training:   0%|          | 0/50 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "5a7c217b717641a9ab3195cdbf965d98",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating:   0%|          | 0/7 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "a632ccd880184b58bb33ed35fa6aeffb",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Testing:   0%|          | 0/7 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test Loss: 0.0097, Test Accuracy: 0.9600, Precision: 0.9474, Recall: 0.9818, F1 Score: 0.9643\n",
      "single-input model (Laplacians) Epoch 8/10, Train Loss: 0.0063, Train Acc: 0.9400, Valid Loss: 0.0075, Valid Acc: 0.9450\n",
      "single-input model (Laplacians)Training time: 281.7472460269928\n",
      "single-input model (Laplacians)Validation time: 7.42725682258606\n",
      "single-input model (Laplacians)Testing time: 7.905781984329224\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "6d65bcd99f09444c8743a7ffc82e631e",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Training:   0%|          | 0/50 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "125f057e5f694f9297a5ce134ad8fda5",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating:   0%|          | 0/7 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "c2d9a0d3a7704f528d47226dd2458234",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Testing:   0%|          | 0/7 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test Loss: 0.0099, Test Accuracy: 0.9600, Precision: 0.9474, Recall: 0.9818, F1 Score: 0.9643\n",
      "single-input model (Laplacians) Epoch 9/10, Train Loss: 0.0065, Train Acc: 0.9363, Valid Loss: 0.0081, Valid Acc: 0.9500\n",
      "single-input model (Laplacians)Training time: 285.84686493873596\n",
      "single-input model (Laplacians)Validation time: 7.3766961097717285\n",
      "single-input model (Laplacians)Testing time: 7.9563891887664795\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "4933a8afcd984a8091fb75a7cf27c16e",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Training:   0%|          | 0/50 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "a39037186d4f47499954efd58637c03c",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validating:   0%|          | 0/7 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "653c965029f04ab684754568fe4a993b",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Testing:   0%|          | 0/7 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test Loss: 0.0107, Test Accuracy: 0.9600, Precision: 0.9554, Recall: 0.9727, F1 Score: 0.9640\n",
      "single-input model (Laplacians) Epoch 10/10, Train Loss: 0.0068, Train Acc: 0.9413, Valid Loss: 0.0070, Valid Acc: 0.9450\n",
      "single-input model (Laplacians)Training time: 281.99568796157837\n",
      "single-input model (Laplacians)Validation time: 7.451887130737305\n",
      "single-input model (Laplacians)Testing time: 8.060375213623047\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "97976c658d9a4bc3862767a64069868a",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Training (Dual Input):   0%|          | 0/50 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "6a1018a0c7c14b57a40ec1f34bb94b51",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Testing (Dual Input):   0%|          | 0/7 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test Loss: 0.0388, Test Accuracy: 0.9450, Precision: 0.9714, Recall: 0.9273, F1 Score: 0.9488\n",
      "dual-input model (Laplacians + VR Persistence Images) Epoch 1/10, Train Loss: 1.1730, Train Acc: 0.8269, Valid Loss: 0.4500, Valid Acc: 0.9550\n",
      "dual-input model (Laplacians + VR Persistence Images) Training time: 302.6748218536377\n",
      "dual-input model (Laplacians + VR Persistence Images) Validation time: 9.34693717956543\n",
      "dual-input model (Laplacians + VR Persistence Images) Testing time: 9.425879001617432\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "050e503bb52446cb8a284f32907b9336",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Training (Dual Input):   0%|          | 0/50 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "fea2baecfd5c42e5bbebbcb04bea9444",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Testing (Dual Input):   0%|          | 0/7 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test Loss: 0.0177, Test Accuracy: 0.9750, Precision: 0.9730, Recall: 0.9818, F1 Score: 0.9774\n",
      "dual-input model (Laplacians + VR Persistence Images) Epoch 2/10, Train Loss: 0.0093, Train Acc: 0.9519, Valid Loss: 0.1957, Valid Acc: 0.9550\n",
      "dual-input model (Laplacians + VR Persistence Images) Training time: 325.8942987918854\n",
      "dual-input model (Laplacians + VR Persistence Images) Validation time: 8.299315929412842\n",
      "dual-input model (Laplacians + VR Persistence Images) Testing time: 8.945971965789795\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "454a99daac0b49ff91d98e5424d35fb2",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Training (Dual Input):   0%|          | 0/50 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "0172f3ffd49d4180bdc46dc7d4c3ad7f",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Testing (Dual Input):   0%|          | 0/7 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test Loss: 0.0155, Test Accuracy: 0.9650, Precision: 0.9725, Recall: 0.9636, F1 Score: 0.9680\n",
      "dual-input model (Laplacians + VR Persistence Images) Epoch 3/10, Train Loss: 0.0044, Train Acc: 0.9637, Valid Loss: 0.0754, Valid Acc: 0.9750\n",
      "dual-input model (Laplacians + VR Persistence Images) Training time: 300.4663619995117\n",
      "dual-input model (Laplacians + VR Persistence Images) Validation time: 7.996729135513306\n",
      "dual-input model (Laplacians + VR Persistence Images) Testing time: 8.733016014099121\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "ada7dcf08a284d21aeba433e835852cb",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Training (Dual Input):   0%|          | 0/50 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "58eed64c1cec436f93eb3a2e52d78813",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Testing (Dual Input):   0%|          | 0/7 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test Loss: 0.0144, Test Accuracy: 0.9750, Precision: 0.9730, Recall: 0.9818, F1 Score: 0.9774\n",
      "dual-input model (Laplacians + VR Persistence Images) Epoch 4/10, Train Loss: 0.0034, Train Acc: 0.9744, Valid Loss: 0.0596, Valid Acc: 0.9700\n",
      "dual-input model (Laplacians + VR Persistence Images) Training time: 299.4001750946045\n",
      "dual-input model (Laplacians + VR Persistence Images) Validation time: 8.256419897079468\n",
      "dual-input model (Laplacians + VR Persistence Images) Testing time: 8.94095492362976\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "132a3a4ac2da4e88a5d4e7a97c44ee24",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Training (Dual Input):   0%|          | 0/50 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "1be2a9c28f4b451f864c562aed1c3212",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Testing (Dual Input):   0%|          | 0/7 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test Loss: 0.0123, Test Accuracy: 0.9750, Precision: 0.9730, Recall: 0.9818, F1 Score: 0.9774\n",
      "dual-input model (Laplacians + VR Persistence Images) Epoch 5/10, Train Loss: 0.0020, Train Acc: 0.9825, Valid Loss: 0.0483, Valid Acc: 0.9750\n",
      "dual-input model (Laplacians + VR Persistence Images) Training time: 303.0889301300049\n",
      "dual-input model (Laplacians + VR Persistence Images) Validation time: 7.961091041564941\n",
      "dual-input model (Laplacians + VR Persistence Images) Testing time: 8.796152830123901\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "8398a28bd57b48b497aad22477562185",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Training (Dual Input):   0%|          | 0/50 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "9efc6ce5c0fe41918a96aadae46d2b0a",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Testing (Dual Input):   0%|          | 0/7 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test Loss: 0.0120, Test Accuracy: 0.9700, Precision: 0.9727, Recall: 0.9727, F1 Score: 0.9727\n",
      "dual-input model (Laplacians + VR Persistence Images) Epoch 6/10, Train Loss: 0.0025, Train Acc: 0.9762, Valid Loss: 0.0328, Valid Acc: 0.9750\n",
      "dual-input model (Laplacians + VR Persistence Images) Training time: 307.939236164093\n",
      "dual-input model (Laplacians + VR Persistence Images) Validation time: 7.883969783782959\n",
      "dual-input model (Laplacians + VR Persistence Images) Testing time: 8.75177526473999\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "e8396bd69d854630a849c15c168d76dc",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Training (Dual Input):   0%|          | 0/50 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "23da7fada06341a48be9482288e9884f",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Testing (Dual Input):   0%|          | 0/7 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test Loss: 0.0095, Test Accuracy: 0.9750, Precision: 0.9730, Recall: 0.9818, F1 Score: 0.9774\n",
      "dual-input model (Laplacians + VR Persistence Images) Epoch 7/10, Train Loss: 0.0026, Train Acc: 0.9781, Valid Loss: 0.0402, Valid Acc: 0.9750\n",
      "dual-input model (Laplacians + VR Persistence Images) Training time: 304.96395087242126\n",
      "dual-input model (Laplacians + VR Persistence Images) Validation time: 7.917470932006836\n",
      "dual-input model (Laplacians + VR Persistence Images) Testing time: 8.607108116149902\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "d28729bcd861427984fbdf788fc9a644",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Training (Dual Input):   0%|          | 0/50 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "9d3bf7201fb94e53a3cd6e923c8011e7",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Testing (Dual Input):   0%|          | 0/7 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test Loss: 0.0093, Test Accuracy: 0.9750, Precision: 0.9730, Recall: 0.9818, F1 Score: 0.9774\n",
      "dual-input model (Laplacians + VR Persistence Images) Epoch 8/10, Train Loss: 0.0027, Train Acc: 0.9769, Valid Loss: 0.0446, Valid Acc: 0.9750\n",
      "dual-input model (Laplacians + VR Persistence Images) Training time: 292.8094000816345\n",
      "dual-input model (Laplacians + VR Persistence Images) Validation time: 7.739908695220947\n",
      "dual-input model (Laplacians + VR Persistence Images) Testing time: 8.233162879943848\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "24dd27f71e46432f94b992db09c85c70",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Training (Dual Input):   0%|          | 0/50 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "1847fb159124437d9ea45041576a109a",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Testing (Dual Input):   0%|          | 0/7 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test Loss: 0.0078, Test Accuracy: 0.9750, Precision: 0.9730, Recall: 0.9818, F1 Score: 0.9774\n",
      "dual-input model (Laplacians + VR Persistence Images) Epoch 9/10, Train Loss: 0.0024, Train Acc: 0.9788, Valid Loss: 0.0438, Valid Acc: 0.9800\n",
      "dual-input model (Laplacians + VR Persistence Images) Training time: 295.4119460582733\n",
      "dual-input model (Laplacians + VR Persistence Images) Validation time: 7.783113956451416\n",
      "dual-input model (Laplacians + VR Persistence Images) Testing time: 8.4843270778656\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "bf6fd41df8d14fd0b9fb364ee31a5e31",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Training (Dual Input):   0%|          | 0/50 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "bbb4077afa654451b124b91055bfd285",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Testing (Dual Input):   0%|          | 0/7 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test Loss: 0.0077, Test Accuracy: 0.9800, Precision: 0.9818, Recall: 0.9818, F1 Score: 0.9818\n",
      "dual-input model (Laplacians + VR Persistence Images) Epoch 10/10, Train Loss: 0.0022, Train Acc: 0.9844, Valid Loss: 0.0204, Valid Acc: 0.9900\n",
      "dual-input model (Laplacians + VR Persistence Images) Training time: 294.1680109500885\n",
      "dual-input model (Laplacians + VR Persistence Images) Validation time: 7.789797067642212\n",
      "dual-input model (Laplacians + VR Persistence Images) Testing time: 8.553939819335938\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "303ccb520c7848099def31d5390df1b4",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Training (Dual Input):   0%|          | 0/50 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "befd0738510a4021b859f54f90a6ad05",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Testing (Dual Input):   0%|          | 0/7 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test Loss: 0.0192, Test Accuracy: 0.8550, Precision: 0.8000, Recall: 0.9818, F1 Score: 0.8816\n",
      "dual-input model (Laplacians + Abstract Persistence Images) Epoch 1/10, Train Loss: 0.7843, Train Acc: 0.7731, Valid Loss: 0.3330, Valid Acc: 0.8650\n",
      "dual-input model (Laplacians + Abstract Persistence Images) Training time: 304.3186218738556\n",
      "dual-input model (Laplacians + Abstract Persistence Images) Validation time: 9.048195123672485\n",
      "dual-input model (Laplacians + Abstract Persistence Images) Testing time: 8.830291986465454\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "a424437c0d04480788e3f89d2434678a",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Training (Dual Input):   0%|          | 0/50 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "d355d35d8ba040b198016fb4b997a54e",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Testing (Dual Input):   0%|          | 0/7 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test Loss: 0.0105, Test Accuracy: 0.9400, Precision: 0.9298, Recall: 0.9636, F1 Score: 0.9464\n",
      "dual-input model (Laplacians + Abstract Persistence Images) Epoch 2/10, Train Loss: 0.0072, Train Acc: 0.9200, Valid Loss: 0.1486, Valid Acc: 0.9500\n",
      "dual-input model (Laplacians + Abstract Persistence Images) Training time: 302.5840120315552\n",
      "dual-input model (Laplacians + Abstract Persistence Images) Validation time: 8.303115129470825\n",
      "dual-input model (Laplacians + Abstract Persistence Images) Testing time: 8.874329090118408\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "7ad491e5b4e4454f985ea14d09fb784e",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Training (Dual Input):   0%|          | 0/50 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "af180902b4844839917130cb8eab320a",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Testing (Dual Input):   0%|          | 0/7 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test Loss: 0.0098, Test Accuracy: 0.9350, Precision: 0.9145, Recall: 0.9727, F1 Score: 0.9427\n",
      "dual-input model (Laplacians + Abstract Persistence Images) Epoch 3/10, Train Loss: 0.0058, Train Acc: 0.9306, Valid Loss: 0.1385, Valid Acc: 0.9500\n",
      "dual-input model (Laplacians + Abstract Persistence Images) Training time: 306.56239223480225\n",
      "dual-input model (Laplacians + Abstract Persistence Images) Validation time: 8.488325834274292\n",
      "dual-input model (Laplacians + Abstract Persistence Images) Testing time: 8.84989309310913\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "73febf14dc0746b5a25109b327851bcf",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Training (Dual Input):   0%|          | 0/50 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "98af9bbc3bb7484e93c44541c973e8da",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Testing (Dual Input):   0%|          | 0/7 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test Loss: 0.0092, Test Accuracy: 0.9500, Precision: 0.9386, Recall: 0.9727, F1 Score: 0.9554\n",
      "dual-input model (Laplacians + Abstract Persistence Images) Epoch 4/10, Train Loss: 0.0054, Train Acc: 0.9387, Valid Loss: 0.1089, Valid Acc: 0.9600\n",
      "dual-input model (Laplacians + Abstract Persistence Images) Training time: 304.1348431110382\n",
      "dual-input model (Laplacians + Abstract Persistence Images) Validation time: 8.331712007522583\n",
      "dual-input model (Laplacians + Abstract Persistence Images) Testing time: 9.005676031112671\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "2c760fd08f3242459579dd6d23b77ac8",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Training (Dual Input):   0%|          | 0/50 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "6ead74c70c124a64b3f034828b7cf9c3",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Testing (Dual Input):   0%|          | 0/7 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test Loss: 0.0102, Test Accuracy: 0.9450, Precision: 0.9381, Recall: 0.9636, F1 Score: 0.9507\n",
      "dual-input model (Laplacians + Abstract Persistence Images) Epoch 5/10, Train Loss: 0.0044, Train Acc: 0.9481, Valid Loss: 0.1068, Valid Acc: 0.9600\n",
      "dual-input model (Laplacians + Abstract Persistence Images) Training time: 304.63568210601807\n",
      "dual-input model (Laplacians + Abstract Persistence Images) Validation time: 8.375730752944946\n",
      "dual-input model (Laplacians + Abstract Persistence Images) Testing time: 8.882433891296387\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "7c2f151a8f804160b328fd7d762a3145",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Training (Dual Input):   0%|          | 0/50 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "f1f2f58c69524bf3bbab3db073d43b9d",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Testing (Dual Input):   0%|          | 0/7 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test Loss: 0.0087, Test Accuracy: 0.9500, Precision: 0.9464, Recall: 0.9636, F1 Score: 0.9550\n",
      "dual-input model (Laplacians + Abstract Persistence Images) Epoch 6/10, Train Loss: 0.0045, Train Acc: 0.9494, Valid Loss: 0.0962, Valid Acc: 0.9550\n",
      "dual-input model (Laplacians + Abstract Persistence Images) Training time: 305.1122148036957\n",
      "dual-input model (Laplacians + Abstract Persistence Images) Validation time: 8.395184993743896\n",
      "dual-input model (Laplacians + Abstract Persistence Images) Testing time: 8.887040853500366\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "44e88e3a7cf94fa5af894f978eedd062",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Training (Dual Input):   0%|          | 0/50 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "ef5eeb4dbd9844559c6b37a599037cd9",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Testing (Dual Input):   0%|          | 0/7 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test Loss: 0.0105, Test Accuracy: 0.9450, Precision: 0.9459, Recall: 0.9545, F1 Score: 0.9502\n",
      "dual-input model (Laplacians + Abstract Persistence Images) Epoch 7/10, Train Loss: 0.0042, Train Acc: 0.9550, Valid Loss: 0.1064, Valid Acc: 0.9450\n",
      "dual-input model (Laplacians + Abstract Persistence Images) Training time: 304.2602770328522\n",
      "dual-input model (Laplacians + Abstract Persistence Images) Validation time: 8.374145030975342\n",
      "dual-input model (Laplacians + Abstract Persistence Images) Testing time: 8.833470106124878\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "c896de63e362434c88f4a14e30c3132f",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Training (Dual Input):   0%|          | 0/50 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "6ccf187540894de29dd551a5eb0a296e",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Testing (Dual Input):   0%|          | 0/7 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test Loss: 0.0099, Test Accuracy: 0.9400, Precision: 0.9375, Recall: 0.9545, F1 Score: 0.9459\n",
      "dual-input model (Laplacians + Abstract Persistence Images) Epoch 8/10, Train Loss: 0.0044, Train Acc: 0.9569, Valid Loss: 0.0961, Valid Acc: 0.9650\n",
      "dual-input model (Laplacians + Abstract Persistence Images) Training time: 304.3857388496399\n",
      "dual-input model (Laplacians + Abstract Persistence Images) Validation time: 8.430147171020508\n",
      "dual-input model (Laplacians + Abstract Persistence Images) Testing time: 8.917414903640747\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "7afb080a677b47f684934b28ff6a32db",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Training (Dual Input):   0%|          | 0/50 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "54169698253a40669757004457db6d3a",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Testing (Dual Input):   0%|          | 0/7 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test Loss: 0.0090, Test Accuracy: 0.9450, Precision: 0.9231, Recall: 0.9818, F1 Score: 0.9515\n",
      "dual-input model (Laplacians + Abstract Persistence Images) Epoch 9/10, Train Loss: 0.0044, Train Acc: 0.9544, Valid Loss: 0.1261, Valid Acc: 0.9350\n",
      "dual-input model (Laplacians + Abstract Persistence Images) Training time: 301.1787431240082\n",
      "dual-input model (Laplacians + Abstract Persistence Images) Validation time: 8.272717952728271\n",
      "dual-input model (Laplacians + Abstract Persistence Images) Testing time: 8.785783052444458\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "b1531125af354b29a692544b43815e48",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Training (Dual Input):   0%|          | 0/50 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "4abc9afc00dc4e3c834b2981ac871db4",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Testing (Dual Input):   0%|          | 0/7 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test Loss: 0.0077, Test Accuracy: 0.9600, Precision: 0.9811, Recall: 0.9455, F1 Score: 0.9630\n",
      "dual-input model (Laplacians + Abstract Persistence Images) Epoch 10/10, Train Loss: 0.0046, Train Acc: 0.9544, Valid Loss: 0.1123, Valid Acc: 0.9400\n",
      "dual-input model (Laplacians + Abstract Persistence Images) Training time: 296.88099694252014\n",
      "dual-input model (Laplacians + Abstract Persistence Images) Validation time: 8.111831903457642\n",
      "dual-input model (Laplacians + Abstract Persistence Images) Testing time: 8.635580062866211\n"
     ]
    }
   ],
   "source": [
    "# Initialize empty lists to store all metrics for each epoch\n",
    "test_metrics_single_list = []\n",
    "test_metrics_dual_vr_list = []\n",
    "test_metrics_dual_abstract_list = []\n",
    "\n",
    "# Initialize empty lists to store all confusion matrices for each epoch\n",
    "cm_single_list = []\n",
    "cm_dual_vr_list = []\n",
    "cm_dual_abstract_list = []\n",
    "\n",
    "# Training loop for single-input model (Laplacians)\n",
    "for epoch in range(num_epochs):\n",
    "\n",
    "      train_time_start = time.time()\n",
    "      model_single_laplacians.train()  # Ensure the model is in training mode\n",
    "\n",
    "      train_loss, train_acc = train_single_input(model_single_laplacians, train_loader_laplacians, optimizer_single, criterion, device)\n",
    "\n",
    "      train_time_end = time.time()\n",
    "\n",
    "      valid_time_start = time.time()\n",
    "\n",
    "      model_single_laplacians.eval()  # Switch model to evaluation mode after training\n",
    "\n",
    "\n",
    "\n",
    "      valid_loss, valid_acc = validate_single_input(model_single_laplacians, valid_loader_laplacians, criterion, device)\n",
    "\n",
    "      valid_time_end = time.time()\n",
    "\n",
    "      # Test the model after each epoch\n",
    "\n",
    "      test_time_start = time.time()\n",
    "      test_metrics_single, cm_single = test_single_input(model_single_laplacians, test_loader_laplacians, criterion, device)\n",
    "      test_time_end = time.time()\n",
    "\n",
    "      # Combine train, valid, and test metrics for this epoch\n",
    "      metrics = test_metrics_single.copy()\n",
    "      metrics['Train Loss'] = train_loss\n",
    "      metrics['Train Accuracy'] = train_acc\n",
    "      metrics['Valid Loss'] = valid_loss\n",
    "      metrics['Valid Accuracy'] = valid_acc\n",
    "\n",
    "      # Append to the list\n",
    "      test_metrics_single_list.append(metrics)\n",
    "      cm_single_list.append(cm_single)\n",
    "\n",
    "      print(f\"single-input model (Laplacians) Epoch {epoch+1}/{num_epochs}, \"\n",
    "            f\"Train Loss: {train_loss:.4f}, Train Acc: {train_acc:.4f}, \"\n",
    "            f\"Valid Loss: {valid_loss:.4f}, Valid Acc: {valid_acc:.4f}\")\n",
    "\n",
    "      torch.save(model_single_laplacians.state_dict(), \"Trained CNNs/model_single_h0_lap_unif_nonunif_gudhi_epoch_{}.pth\".format(epoch+1))\n",
    "\n",
    "      print(f\"single-input model (Laplacians)Training time: {train_time_end - train_time_start}\")\n",
    "      print(f\"single-input model (Laplacians)Validation time: {valid_time_end - valid_time_start}\")\n",
    "      print(f\"single-input model (Laplacians)Testing time: {test_time_end - test_time_start}\")\n",
    "\n",
    "\n",
    "# Training loop for dual-input model (Laplacians + VR Persistence Images)\n",
    "for epoch in range(num_epochs):\n",
    "\n",
    "      train_time_start = time.time()\n",
    "      model_dual_lap_vr.train()  # Ensure the model is in training mode\n",
    "      train_loss, train_acc = train_dual_input(model_dual_lap_vr, train_loader_laplacians, train_loader_vr, optimizer_dual_vr, criterion, device)\n",
    "      train_time_end = time.time()\n",
    "      valid_time_start = time.time()\n",
    "      model_dual_lap_vr.eval()  # Switch model to evaluation mode after training\n",
    "\n",
    "\n",
    "      valid_loss, valid_acc = validate_dual_input(model_dual_lap_vr, valid_loader_laplacians, valid_loader_vr, criterion, device)\n",
    "      valid_time_end = time.time()\n",
    "\n",
    "      # Test the model after each epoch\n",
    "      test_time_start = time.time()\n",
    "      test_metrics_dual_vr, cm_dual_vr = test_dual_input(model_dual_lap_vr, test_loader_laplacians, test_loader_vr, criterion, device)\n",
    "      test_time_end = time.time()\n",
    "\n",
    "      # Combine train, valid, and test metrics for this epoch\n",
    "      metrics = test_metrics_dual_vr.copy()\n",
    "      metrics['Train Loss'] = train_loss\n",
    "      metrics['Train Accuracy'] = train_acc\n",
    "      metrics['Valid Loss'] = valid_loss\n",
    "      metrics['Valid Accuracy'] = valid_acc\n",
    "\n",
    "      # Append to the list\n",
    "      test_metrics_dual_vr_list.append(metrics)\n",
    "      cm_dual_vr_list.append(cm_dual_vr)\n",
    "\n",
    "      print(f\"dual-input model (Laplacians + VR Persistence Images) Epoch {epoch+1}/{num_epochs}, \"\n",
    "            f\"Train Loss: {train_loss:.4f}, Train Acc: {train_acc:.4f}, \"\n",
    "            f\"Valid Loss: {valid_loss:.4f}, Valid Acc: {valid_acc:.4f}\")\n",
    "\n",
    "      torch.save(model_dual_lap_vr.state_dict(), \"Trained CNNs/model_dual_h0_lap_vr_unif_nonunif_gudhi_epoch_{}.pth\".format(epoch+1))\n",
    "\n",
    "      print(f\"dual-input model (Laplacians + VR Persistence Images) Training time: {train_time_end - train_time_start}\")\n",
    "      print(f\"dual-input model (Laplacians + VR Persistence Images) Validation time: {valid_time_end - valid_time_start}\")\n",
    "      print(f\"dual-input model (Laplacians + VR Persistence Images) Testing time: {test_time_end - test_time_start}\")\n",
    "\n",
    "\n",
    "# Training loop for dual-input model (Laplacians + Abstract Persistence Images)\n",
    "for epoch in range(num_epochs):\n",
    "\n",
    "      train_time_start = time.time()\n",
    "      model_dual_lap_abstract.train()  # Ensure the model is in training mode\n",
    "      train_loss, train_acc = train_dual_input(model_dual_lap_abstract, train_loader_laplacians, train_loader_abstract, optimizer_dual_abstract, criterion, device)\n",
    "      train_time_end = time.time()\n",
    "\n",
    "      valid_time_start = time.time()\n",
    "      model_dual_lap_abstract.eval()  # Switch model to evaluation mode after training\n",
    "      valid_loss, valid_acc = validate_dual_input(model_dual_lap_abstract, valid_loader_laplacians, valid_loader_abstract, criterion, device)\n",
    "      valid_time_end = time.time()\n",
    "\n",
    "      # Test the model after each epoch\n",
    "      test_time_start = time.time()\n",
    "      test_metrics_dual_abstract, cm_dual_abstract = test_dual_input(model_dual_lap_abstract, test_loader_laplacians, test_loader_abstract, criterion, device)\n",
    "      test_time_end = time.time()\n",
    "\n",
    "      # Combine train, valid, and test metrics for this epoch\n",
    "      metrics = test_metrics_dual_abstract.copy()\n",
    "      metrics['Train Loss'] = train_loss\n",
    "      metrics['Train Accuracy'] = train_acc\n",
    "      metrics['Valid Loss'] = valid_loss\n",
    "      metrics['Valid Accuracy'] = valid_acc\n",
    "\n",
    "      # Append to the list\n",
    "      test_metrics_dual_abstract_list.append(metrics)\n",
    "      cm_dual_abstract_list.append(cm_dual_abstract)\n",
    "\n",
    "      print(f\"dual-input model (Laplacians + Abstract Persistence Images) Epoch {epoch+1}/{num_epochs}, \"\n",
    "            f\"Train Loss: {train_loss:.4f}, Train Acc: {train_acc:.4f}, \"\n",
    "            f\"Valid Loss: {valid_loss:.4f}, Valid Acc: {valid_acc:.4f}\")\n",
    "\n",
    "      torch.save(model_dual_lap_abstract.state_dict(), \"Trained CNNs/model_dual_h0_lap_abstract_unif_nonunif_gudhi_epoch_{}.pth\".format(epoch+1))\n",
    "\n",
    "      print(f\"dual-input model (Laplacians + Abstract Persistence Images) Training time: {train_time_end - train_time_start}\")\n",
    "      print(f\"dual-input model (Laplacians + Abstract Persistence Images) Validation time: {valid_time_end - valid_time_start}\")\n",
    "      print(f\"dual-input model (Laplacians + Abstract Persistence Images) Testing time: {test_time_end - test_time_start}\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Single-input model (Laplacians) Test Metrics:\n",
      "       Test Loss  Test Accuracy  Precision    Recall  F1 Score  Train Loss  \\\n",
      "Epoch                                                                        \n",
      "1       0.019460          0.915   0.878049  0.981818  0.927039    0.132254   \n",
      "2       0.017648          0.920   0.885246  0.981818  0.931034    0.008779   \n",
      "3       0.009772          0.920   0.891667  0.972727  0.930435    0.008842   \n",
      "4       0.009433          0.925   0.899160  0.972727  0.934498    0.007720   \n",
      "5       0.009147          0.955   0.939130  0.981818  0.960000    0.006881   \n",
      "6       0.008610          0.955   0.946903  0.972727  0.959641    0.007117   \n",
      "7       0.008665          0.955   0.939130  0.981818  0.960000    0.006727   \n",
      "8       0.009747          0.960   0.947368  0.981818  0.964286    0.006273   \n",
      "9       0.009948          0.960   0.947368  0.981818  0.964286    0.006491   \n",
      "10      0.010678          0.960   0.955357  0.972727  0.963964    0.006763   \n",
      "\n",
      "       Train Accuracy  Valid Loss  Valid Accuracy  \n",
      "Epoch                                              \n",
      "1            0.704375    0.019021           0.890  \n",
      "2            0.923125    0.015873           0.905  \n",
      "3            0.918750    0.009494           0.900  \n",
      "4            0.927500    0.009336           0.900  \n",
      "5            0.931875    0.008273           0.930  \n",
      "6            0.933750    0.008074           0.940  \n",
      "7            0.935000    0.008693           0.930  \n",
      "8            0.940000    0.007529           0.945  \n",
      "9            0.936250    0.008110           0.950  \n",
      "10           0.941250    0.007017           0.945  \n",
      "\n",
      "Dual-input model (Laplacians + VR Persistence Images) Test Metrics:\n",
      "       Test Loss  Test Accuracy  Precision    Recall  F1 Score  Train Loss  \\\n",
      "Epoch                                                                        \n",
      "1       0.038834          0.945   0.971429  0.927273  0.948837    1.172985   \n",
      "2       0.017744          0.975   0.972973  0.981818  0.977376    0.009281   \n",
      "3       0.015468          0.965   0.972477  0.963636  0.968037    0.004367   \n",
      "4       0.014426          0.975   0.972973  0.981818  0.977376    0.003389   \n",
      "5       0.012256          0.975   0.972973  0.981818  0.977376    0.002047   \n",
      "6       0.012032          0.970   0.972727  0.972727  0.972727    0.002496   \n",
      "7       0.009483          0.975   0.972973  0.981818  0.977376    0.002592   \n",
      "8       0.009318          0.975   0.972973  0.981818  0.977376    0.002701   \n",
      "9       0.007828          0.975   0.972973  0.981818  0.977376    0.002371   \n",
      "10      0.007743          0.980   0.981818  0.981818  0.981818    0.002172   \n",
      "\n",
      "       Train Accuracy  Valid Loss  Valid Accuracy  \n",
      "Epoch                                              \n",
      "1            0.826875    0.450040           0.955  \n",
      "2            0.951875    0.195684           0.955  \n",
      "3            0.963750    0.075362           0.975  \n",
      "4            0.974375    0.059637           0.970  \n",
      "5            0.982500    0.048344           0.975  \n",
      "6            0.976250    0.032807           0.975  \n",
      "7            0.978125    0.040248           0.975  \n",
      "8            0.976875    0.044581           0.975  \n",
      "9            0.978750    0.043753           0.980  \n",
      "10           0.984375    0.020356           0.990  \n",
      "\n",
      "Dual-input model (Laplacians + Abstract Persistence Images) Test Metrics:\n",
      "       Test Loss  Test Accuracy  Precision    Recall  F1 Score  Train Loss  \\\n",
      "Epoch                                                                        \n",
      "1       0.019180          0.855   0.800000  0.981818  0.881633    0.784256   \n",
      "2       0.010463          0.940   0.929825  0.963636  0.946429    0.007150   \n",
      "3       0.009754          0.935   0.914530  0.972727  0.942731    0.005784   \n",
      "4       0.009234          0.950   0.938596  0.972727  0.955357    0.005357   \n",
      "5       0.010206          0.945   0.938053  0.963636  0.950673    0.004448   \n",
      "6       0.008655          0.950   0.946429  0.963636  0.954955    0.004508   \n",
      "7       0.010462          0.945   0.945946  0.954545  0.950226    0.004190   \n",
      "8       0.009874          0.940   0.937500  0.954545  0.945946    0.004362   \n",
      "9       0.008982          0.945   0.923077  0.981818  0.951542    0.004388   \n",
      "10      0.007674          0.960   0.981132  0.945455  0.962963    0.004593   \n",
      "\n",
      "       Train Accuracy  Valid Loss  Valid Accuracy  \n",
      "Epoch                                              \n",
      "1            0.773125    0.332995           0.865  \n",
      "2            0.920000    0.148575           0.950  \n",
      "3            0.930625    0.138456           0.950  \n",
      "4            0.938750    0.108899           0.960  \n",
      "5            0.948125    0.106837           0.960  \n",
      "6            0.949375    0.096222           0.955  \n",
      "7            0.955000    0.106377           0.945  \n",
      "8            0.956875    0.096077           0.965  \n",
      "9            0.954375    0.126139           0.935  \n",
      "10           0.954375    0.112306           0.940  \n"
     ]
    }
   ],
   "source": [
    "# Convert the lists of metrics into DataFrames with epoch as the index\n",
    "test_metrics_single_df = pd.concat(test_metrics_single_list, ignore_index=True)\n",
    "test_metrics_dual_vr_df = pd.concat(test_metrics_dual_vr_list, ignore_index=True)\n",
    "test_metrics_dual_abstract_df = pd.concat(test_metrics_dual_abstract_list, ignore_index=True)\n",
    "\n",
    "# Add 'Epoch' as new column\n",
    "epochs = list(range(1, num_epochs + 1))\n",
    "\n",
    "test_metrics_single_df['Epoch'] = epochs\n",
    "test_metrics_dual_vr_df['Epoch'] = epochs\n",
    "test_metrics_dual_abstract_df['Epoch'] = epochs\n",
    "\n",
    "# Set 'Epoch' as index\n",
    "test_metrics_single_df.set_index('Epoch', inplace=True)\n",
    "test_metrics_dual_vr_df.set_index('Epoch', inplace=True)\n",
    "test_metrics_dual_abstract_df.set_index('Epoch', inplace=True)\n",
    "\n",
    "# Rename first two columns to 'Test Loss' and 'Test Accuracy'\n",
    "test_metrics_single_df.rename(columns={'Loss': 'Test Loss', 'Accuracy': 'Test Accuracy'}, inplace=True)\n",
    "test_metrics_dual_vr_df.rename(columns={'Loss': 'Test Loss', 'Accuracy': 'Test Accuracy'}, inplace=True)\n",
    "test_metrics_dual_abstract_df.rename(columns={'Loss': 'Test Loss', 'Accuracy': 'Test Accuracy'}, inplace=True)\n",
    "\n",
    "# Print final test metrics for all models\n",
    "print(\"\\nSingle-input model (Laplacians) Test Metrics:\")\n",
    "print(test_metrics_single_df)\n",
    "\n",
    "print(\"\\nDual-input model (Laplacians + VR Persistence Images) Test Metrics:\")\n",
    "print(test_metrics_dual_vr_df)\n",
    "\n",
    "print(\"\\nDual-input model (Laplacians + Abstract Persistence Images) Test Metrics:\")\n",
    "print(test_metrics_dual_abstract_df)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Export test metrics to CSV files\n",
    "\n",
    "test_metrics_single_df.to_csv('test_metrics_single_h0_lap_unif_nonunif_gudhi.csv')\n",
    "test_metrics_dual_vr_df.to_csv('test_metrics_dual_h0_lap_vr_unif_nonunif_gudhi.csv')\n",
    "test_metrics_dual_abstract_df.to_csv('test_metrics_dual_h0_lap_abstract_unif_nonunif_gudhi.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "ename": "",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31mThe Kernel crashed while executing code in the current cell or a previous cell. \n",
      "\u001b[1;31mPlease review the code in the cell(s) to identify a possible cause of the failure. \n",
      "\u001b[1;31mClick <a href='https://aka.ms/vscodeJupyterKernelCrash'>here</a> for more info. \n",
      "\u001b[1;31mView Jupyter <a href='command:jupyter.viewOutput'>log</a> for further details."
     ]
    }
   ],
   "source": [
    "# Visualize and export confusion matrices to \"Confusion\\ Matrices/\" folder\n",
    "\n",
    "# Single-input model (Laplacians)\n",
    "for i, cm in enumerate(cm_single_list):\n",
    "    plt.figure(figsize=(6, 5))\n",
    "    sns.heatmap(cm, annot=True, fmt='d', cmap='Blues', cbar=False, annot_kws={'size': 14})\n",
    "    plt.title(f\"Confusion Matrix - Single-input Model (Laplacians), Epoch {i+1}\")\n",
    "    plt.xlabel('Predicted')\n",
    "    plt.ylabel('Actual')\n",
    "    plt.savefig(f\"Confusion Matrices/single_h0_lap_unif_nonunif_gudhi_cm_epoch_{i+1}.png\")\n",
    "    plt.close()\n",
    "\n",
    "# Dual-input model (Laplacians + VR Persistence Images)\n",
    "for i, cm in enumerate(cm_dual_vr_list):\n",
    "    plt.figure(figsize=(6, 5))\n",
    "    sns.heatmap(cm, annot=True, fmt='d', cmap='Blues', cbar=False, annot_kws={'size': 14})\n",
    "    plt.title(f\"Confusion Matrix - Dual-input Model (Laplacians + VR Persistence Images), Epoch {i+1}\")\n",
    "    plt.xlabel('Predicted')\n",
    "    plt.ylabel('Actual')\n",
    "    plt.savefig(f\"Confusion Matrices/dual_h0_lap_vr_unif_nonunif_gudhi_cm_epoch_{i+1}.png\")\n",
    "    plt.close()\n",
    "\n",
    "# Dual-input model (Laplacians + Abstract Persistence Images)\n",
    "for i, cm in enumerate(cm_dual_abstract_list):\n",
    "    plt.figure(figsize=(6, 5))\n",
    "    sns.heatmap(cm, annot=True, fmt='d', cmap='Blues', cbar=False, annot_kws={'size': 14})\n",
    "    plt.title(f\"Confusion Matrix - Dual-input Model (Laplacians + Abstract Persistence Images), Epoch {i+1}\")\n",
    "    plt.xlabel('Predicted')\n",
    "    plt.ylabel('Actual')\n",
    "    plt.savefig(f\"Confusion Matrices/dual_h0_lap_abstract_unif_nonunif_gudhi_cm_epoch_{i+1}.png\")\n",
    "    plt.close()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "FiltrationsForGNNsLargeData",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.15"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}