diff --git a/privacy_guard/shadow_model_training/__init__.py b/privacy_guard/shadow_model_training/__init__.py
index aa5e817..71c0b7b 100644
--- a/privacy_guard/shadow_model_training/__init__.py
+++ b/privacy_guard/shadow_model_training/__init__.py
@@ -1,9 +1,6 @@
 # pyre-strict
-"""
-Shadow model training package for privacy attacks.
-
-This package provides utilities for training shadow models and performing privacy attacks.
-"""
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# Shadow model training package for privacy attacks.
 
 from privacy_guard.shadow_model_training.dataset import (
     create_shadow_datasets,
@@ -11,11 +8,8 @@
 )
 from privacy_guard.shadow_model_training.model import create_model
 from privacy_guard.shadow_model_training.training import (
-    evaluate_model,
-    get_softmax_scores,
     get_transformed_logits,
     prepare_lira_data,
-    prepare_rmia_data,
     train_model,
 )
 from privacy_guard.shadow_model_training.visualization import (
@@ -28,13 +22,10 @@
     "analyze_attack",
     "create_model",
     "create_shadow_datasets",
-    "evaluate_model",
-    "get_softmax_scores",
     "get_transformed_logits",
     "load_cifar10",
     "plot_roc_curve",
     "plot_score_distributions",
-    "prepare_rmia_data",
     "prepare_lira_data",
     "train_model",
 ]
diff --git a/privacy_guard/shadow_model_training/dataset.py b/privacy_guard/shadow_model_training/dataset.py
index 978af74..6fcbbce 100644
--- a/privacy_guard/shadow_model_training/dataset.py
+++ b/privacy_guard/shadow_model_training/dataset.py
@@ -18,9 +18,10 @@
 """
 
 from pathlib import Path
-from typing import cast, List, Optional, Protocol, Sequence, Tuple, TypeVar
+from typing import cast, List, Optional, Protocol, Sequence, Tuple, TypeVar, Union
 
 import numpy as np
+import torch
 from torch.utils.data import Dataset, Subset
 from torchvision import transforms
 from torchvision.datasets import CIFAR10
@@ -38,6 +39,81 @@ def __getitem__(self, index: int) -> object: ...
 DatasetT: TypeVar = TypeVar("DatasetT", bound=Dataset)
 
 
+class CustomDataset(Dataset):
+    """A general-purpose dataset wrapper for user-provided data.
+
+    Wraps numpy arrays or PyTorch tensors into a PyTorch Dataset that is
+    compatible with the PrivacyGuard pipeline (shadow model training,
+    membership inference attacks, etc.).
+
+    Args:
+        data: Feature data as a numpy array or PyTorch tensor.
+              Shape should be (n_samples, ...) where ... represents
+              any feature dimensions (e.g., (n, d) for tabular data
+              or (n, c, h, w) for images).
+        targets: Labels as a numpy array or PyTorch tensor.
+                 Shape should be (n_samples,).
+        transform: Optional callable applied to each data sample
+                   when __getitem__ is called.
+
+    Example:
+        >>> import numpy as np
+        >>> X = np.random.randn(1000, 10).astype(np.float32)
+        >>> y = np.random.randint(0, 3, size=1000)
+        >>> dataset = CustomDataset(X, y)
+        >>> data, label = dataset[0]
+    """
+
+    def __init__(
+        self,
+        data: Union[np.ndarray, torch.Tensor],
+        targets: Union[np.ndarray, torch.Tensor],
+        transform: Optional[object] = None,
+    ) -> None:
+        if isinstance(data, np.ndarray):
+            self.data: torch.Tensor = torch.from_numpy(data)
+        else:
+            self.data = data
+
+        if isinstance(targets, np.ndarray):
+            self.targets: torch.Tensor = torch.from_numpy(targets).long()
+        else:
+            self.targets = targets.long()
+
+        if len(self.data) != len(self.targets):
+            raise ValueError(
+                f"data and targets must have the same length, "
+                f"got {len(self.data)} and {len(self.targets)}"
+            )
+
+        if len(self.data) == 0:
+            raise ValueError("data must not be empty")
+
+        self.transform = transform
+
+    def __len__(self) -> int:
+        return len(self.data)
+
+    def __getitem__(self, index: int) -> Tuple[torch.Tensor, torch.Tensor]:
+        sample = self.data[index]
+        target = self.targets[index]
+
+        if self.transform is not None and callable(self.transform):
+            sample = self.transform(sample)
+
+        return cast(torch.Tensor, sample), target
+
+    @property
+    def num_classes(self) -> int:
+        """Return the number of unique classes in the dataset."""
+        return int(self.targets.unique().numel())
+
+    @property
+    def input_shape(self) -> torch.Size:
+        """Return the shape of a single data sample (excluding batch dim)."""
+        return self.data.shape[1:]
+
+
 def get_cifar10_transforms() -> Tuple[transforms.Compose, transforms.Compose]:
     """
     Get transforms for CIFAR-10 dataset.
diff --git a/privacy_guard/shadow_model_training/model.py b/privacy_guard/shadow_model_training/model.py
index 55eef71..2a3fd7f 100644
--- a/privacy_guard/shadow_model_training/model.py
+++ b/privacy_guard/shadow_model_training/model.py
@@ -16,6 +16,8 @@
 This module provides neural network model definitions for privacy attack experiments.
 """
 
+from typing import List, Optional
+
 import torch
 import torch.nn as nn
 
@@ -92,12 +94,14 @@ class DeepCNN(nn.Module):
     Architecture inspired by ResNet.
     """
 
-    def __init__(self, num_classes: int = 10) -> None:
+    def __init__(self, num_classes: int = 10, input_channels: int = 3) -> None:
         super().__init__()
 
         # Initial feature extraction
         self.input_block: nn.Sequential = nn.Sequential(
-            nn.Conv2d(3, 64, kernel_size=3, stride=1, padding=1, bias=False),
+            nn.Conv2d(
+                input_channels, 64, kernel_size=3, stride=1, padding=1, bias=False
+            ),
             nn.BatchNorm2d(64),
             nn.ReLU(inplace=True),
         )
@@ -176,6 +180,92 @@ def forward(self, x: torch.Tensor) -> torch.Tensor:
         return x
 
 
-def create_model() -> DeepCNN:
-    """Create a deep CNN model for CIFAR-10 classification."""
-    return DeepCNN(num_classes=10)
+class SimpleMLP(nn.Module):
+    """A simple multi-layer perceptron for tabular/flat data.
+
+    Suitable for use with CustomDataset when the data is not image-like
+    (e.g., tabular features, embeddings).
+
+    Args:
+        input_dim: Number of input features.
+        num_classes: Number of output classes.
+        hidden_dims: List of hidden layer sizes. Defaults to [256, 128].
+    """
+
+    def __init__(
+        self,
+        input_dim: int,
+        num_classes: int,
+        hidden_dims: Optional[List[int]] = None,
+    ) -> None:
+        super().__init__()
+
+        if hidden_dims is None:
+            hidden_dims = [256, 128]
+
+        layers: List[nn.Module] = []
+        prev_dim = input_dim
+        for hidden_dim in hidden_dims:
+            layers.extend(
+                [
+                    nn.Linear(prev_dim, hidden_dim),
+                    nn.ReLU(inplace=True),
+                    nn.BatchNorm1d(hidden_dim),
+                ]
+            )
+            prev_dim = hidden_dim
+
+        layers.append(nn.Linear(prev_dim, num_classes))
+        self.network: nn.Sequential = nn.Sequential(*layers)
+
+        self._initialize_weights()
+
+    def _initialize_weights(self) -> None:
+        """Initialize model weights."""
+        for m in self.modules():
+            if isinstance(m, nn.Linear):
+                nn.init.kaiming_normal_(m.weight, nonlinearity="relu")
+                if m.bias is not None:
+                    nn.init.constant_(m.bias, 0)
+            elif isinstance(m, nn.BatchNorm1d):
+                nn.init.constant_(m.weight, 1)
+                nn.init.constant_(m.bias, 0)
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        x = torch.flatten(x, 1)
+        return self.network(x)
+
+
+def create_model(num_classes: int = 10, input_channels: int = 3) -> DeepCNN:
+    """Create a deep CNN model for image classification.
+
+    Args:
+        num_classes: Number of output classes.
+        input_channels: Number of input channels (e.g., 3 for RGB, 1 for grayscale).
+
+    Returns:
+        A DeepCNN model instance.
+    """
+    return DeepCNN(num_classes=num_classes, input_channels=input_channels)
+
+
+def create_mlp_model(
+    input_dim: int,
+    num_classes: int,
+    hidden_dims: Optional[List[int]] = None,
+) -> SimpleMLP:
+    """Create an MLP model for tabular/flat data classification.
+
+    Args:
+        input_dim: Number of input features.
+        num_classes: Number of output classes.
+        hidden_dims: List of hidden layer sizes. Defaults to [256, 128].
+
+    Returns:
+        A SimpleMLP model instance.
+    """
+    return SimpleMLP(
+        input_dim=input_dim,
+        num_classes=num_classes,
+        hidden_dims=hidden_dims,
+    )
diff --git a/privacy_guard/shadow_model_training/tests/test_dataset.py b/privacy_guard/shadow_model_training/tests/test_dataset.py
index 519293f..bd2571d 100644
--- a/privacy_guard/shadow_model_training/tests/test_dataset.py
+++ b/privacy_guard/shadow_model_training/tests/test_dataset.py
@@ -16,10 +16,12 @@
 
 import unittest
 
+import numpy as np
 import torch
 from privacy_guard.shadow_model_training.dataset import (
     create_rmia_datasets,
     create_shadow_datasets,
+    CustomDataset,
     get_cifar10_transforms,
 )
 from torch.utils.data import Dataset
@@ -146,5 +148,58 @@ def test_create_rmia_datasets_minimum_references(self) -> None:
             create_rmia_datasets(train_dataset, test_dataset, num_references=2)
 
 
+class TestCustomDataset(unittest.TestCase):
+    """Test cases for the CustomDataset class."""
+
+    def test_construction_and_properties(self) -> None:
+        """Test creation from numpy/tensors and num_classes/input_shape."""
+        # From numpy arrays
+        data_np = np.random.randn(100, 10).astype(np.float32)
+        targets_np = np.array([0, 1, 2, 3, 4] * 20)
+        ds = CustomDataset(data_np, targets_np)
+        self.assertEqual(len(ds), 100)
+        self.assertEqual(ds.num_classes, 5)
+        self.assertEqual(ds.input_shape, torch.Size([10]))
+        sample, label = ds[0]
+        self.assertIsInstance(sample, torch.Tensor)
+        self.assertIsInstance(label, torch.Tensor)
+
+        # From torch tensors with image-like shape
+        ds2 = CustomDataset(torch.randn(50, 3, 32, 32), torch.randint(0, 5, (50,)))
+        self.assertEqual(len(ds2), 50)
+        self.assertEqual(ds2.input_shape, torch.Size([3, 32, 32]))
+
+    def test_validation_errors(self) -> None:
+        """Test that invalid inputs raise ValueError."""
+        with self.assertRaises(ValueError):
+            CustomDataset(
+                np.zeros((100, 10), dtype=np.float32), np.zeros(50, dtype=np.int64)
+            )
+        with self.assertRaises(ValueError):
+            CustomDataset(
+                np.zeros((0, 10), dtype=np.float32), np.array([], dtype=np.int64)
+            )
+
+    def test_transform_and_shadow_integration(self) -> None:
+        """Test transforms and compatibility with create_shadow_datasets."""
+        data = np.random.randn(200, 10).astype(np.float32)
+        targets = np.random.randint(0, 3, size=200)
+        transform_called: list[bool] = [False]
+
+        def my_transform(x: torch.Tensor) -> torch.Tensor:
+            transform_called[0] = True
+            return x * 2.0
+
+        dataset = CustomDataset(data, targets, transform=my_transform)
+        dataset[0]
+        self.assertTrue(transform_called[0])
+
+        shadow_datasets, target_dataset = create_shadow_datasets(
+            dataset, n_shadows=4, pkeep=0.5, seed=42
+        )
+        self.assertEqual(len(shadow_datasets), 3)
+        self.assertIsInstance(target_dataset, tuple)
+
+
 if __name__ == "__main__":
     unittest.main()
diff --git a/privacy_guard/shadow_model_training/tests/test_model.py b/privacy_guard/shadow_model_training/tests/test_model.py
index 5ebbaaa..4ec30c5 100644
--- a/privacy_guard/shadow_model_training/tests/test_model.py
+++ b/privacy_guard/shadow_model_training/tests/test_model.py
@@ -18,9 +18,11 @@
 
 import torch
 from privacy_guard.shadow_model_training.model import (
+    create_mlp_model,
     create_model,
     DeepCNN,
     ResidualUnit,
+    SimpleMLP,
 )
 
 
@@ -54,6 +56,41 @@ def test_create_model(self) -> None:
         self.assertIsInstance(model, DeepCNN)
         self.assertEqual(model.classifier.out_features, 10)
 
+    def test_create_model_custom_classes(self) -> None:
+        """Test that create_model accepts custom num_classes."""
+        model = create_model(num_classes=5)
+        self.assertIsInstance(model, DeepCNN)
+        self.assertEqual(model.classifier.out_features, 5)
+
+    def test_deep_cnn_custom_input_channels(self) -> None:
+        """Test DeepCNN with custom input channels."""
+        model = DeepCNN(num_classes=3, input_channels=1)
+        x = torch.randn(2, 1, 32, 32)
+        y = model(x)
+        self.assertEqual(y.shape, (2, 3))
+
+    def test_simple_mlp(self) -> None:
+        """Test that SimpleMLP forward pass works."""
+        model = SimpleMLP(input_dim=20, num_classes=5)
+        x = torch.randn(4, 20)
+        y = model(x)
+        self.assertEqual(y.shape, (4, 5))
+
+    def test_simple_mlp_custom_hidden(self) -> None:
+        """Test SimpleMLP with custom hidden dimensions."""
+        model = SimpleMLP(input_dim=50, num_classes=3, hidden_dims=[64, 32, 16])
+        x = torch.randn(4, 50)
+        y = model(x)
+        self.assertEqual(y.shape, (4, 3))
+
+    def test_create_mlp_model(self) -> None:
+        """Test that create_mlp_model returns a SimpleMLP instance."""
+        model = create_mlp_model(input_dim=10, num_classes=4)
+        self.assertIsInstance(model, SimpleMLP)
+        x = torch.randn(2, 10)
+        y = model(x)
+        self.assertEqual(y.shape, (2, 4))
+
 
 if __name__ == "__main__":
     unittest.main()
diff --git a/tutorial_notebooks/custom_dataset_tutorial.ipynb b/tutorial_notebooks/custom_dataset_tutorial.ipynb
new file mode 100644
index 0000000..690d71f
--- /dev/null
+++ b/tutorial_notebooks/custom_dataset_tutorial.ipynb
@@ -0,0 +1,1603 @@
+{
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "# Using Custom Datasets with PrivacyGuard\n",
+        "\n",
+        "## Introduction\n",
+        "\n",
+        "PrivacyGuard provides built-in support for CIFAR-10, but many real-world privacy auditing\n",
+        "scenarios involve custom datasets — tabular data, domain-specific images, embeddings, etc.\n",
+        "\n",
+        "This tutorial demonstrates how to use the `CustomDataset` class to plug **any** data\n",
+        "into the PrivacyGuard pipeline. We will:\n",
+        "\n",
+        "1. Create a synthetic tabular dataset and wrap it with `CustomDataset`\n",
+        "2. Train a target model and shadow models using `SimpleMLP`\n",
+        "3. Run a **Likelihood Ratio Attack** (LiRA) with shadow models — both online and offline variants\n",
+        "4. Analyze and compare the results\n",
+        "\n",
+        "### Why Custom Datasets?\n",
+        "\n",
+        "Privacy risks are not limited to image classifiers. Any model trained on sensitive data\n",
+        "(medical records, financial data, user behavior logs) can leak information about its\n",
+        "training set. `CustomDataset` makes it easy to audit these models with PrivacyGuard."
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Environment Set-Up"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "# Optionally create a conda environment for installing packages.\n",
+        "# If executing from Google Colab, skip this step.\n",
+        "!conda create -n privacy_guard python=3.12\n",
+        "!conda activate privacy_guard"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "output": {
+          "id": 1901007027224324,
+          "loadingStatus": "loaded"
+        }
+      },
+      "outputs": [],
+      "source": [
+        "%cd /content\n",
+        "!git clone https://github.com/facebookresearch/PrivacyGuard.git"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "%cd /content/PrivacyGuard\n",
+        "!ls\n",
+        "!pip install -e ."
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Setup and Imports"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "from typing import Any, Dict, List, Tuple\n",
+        "\n",
+        "import matplotlib.pyplot as plt\n",
+        "import numpy as np\n",
+        "import torch\n",
+        "import torch.nn as nn\n",
+        "from numpy.typing import NDArray\n",
+        "\n",
+        "# PrivacyGuard imports\n",
+        "from privacy_guard.shadow_model_training.dataset import (\n",
+        "    CustomDataset,\n",
+        "    create_shadow_datasets,\n",
+        ")\n",
+        "from privacy_guard.shadow_model_training.model import create_mlp_model\n",
+        "from privacy_guard.shadow_model_training.training import (\n",
+        "    get_transformed_logits,\n",
+        "    prepare_lira_data,\n",
+        "    train_model,\n",
+        ")\n",
+        "from privacy_guard.attacks.lira_attack import LiraAttack\n",
+        "from privacy_guard.analysis.mia.aggregate_analysis_input import AggregationType\n",
+        "from privacy_guard.analysis.mia.analysis_node import AnalysisNode\n",
+        "from torch.utils.data import DataLoader, Subset\n",
+        "\n",
+        "# Reproducibility\n",
+        "np.random.seed(42)\n",
+        "torch.manual_seed(42)\n",
+        "\n",
+        "DEVICE = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
+        "print(f\"Using device: {DEVICE}\")"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Step 1: Create a Custom Dataset\n",
+        "\n",
+        "We generate a synthetic tabular classification dataset using Gaussian clusters.\n",
+        "Each class has its own cluster center in a high-dimensional feature space.\n",
+        "\n",
+        "This simulates a realistic scenario: imagine predicting disease risk from patient\n",
+        "features, classifying user behavior from activity logs, or categorizing transactions\n",
+        "from financial records.\n",
+        "\n",
+        "The `CustomDataset` class accepts:\n",
+        "- **data**: A numpy array or PyTorch tensor of shape `(n_samples, ...)`\n",
+        "- **targets**: A numpy array or PyTorch tensor of shape `(n_samples,)`\n",
+        "- **transform** (optional): A callable applied to each sample on access"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 13,
+      "metadata": {
+        "output": {
+          "id": 1605228283978402,
+          "loadingStatus": "loaded"
+        }
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Train dataset: 4000 samples\n",
+            "Test dataset:  1000 samples\n",
+            "Number of classes: 5\n",
+            "Input shape: torch.Size([100])\n"
+          ]
+        }
+      ],
+      "source": [
+        "# Dataset parameters\n",
+        "NUM_CLASSES = 5\n",
+        "NUM_FEATURES = 100\n",
+        "SAMPLES_PER_CLASS = 1000\n",
+        "NOISE_STD = 3.0\n",
+        "\n",
+        "n_total = NUM_CLASSES * SAMPLES_PER_CLASS\n",
+        "\n",
+        "# Generate class centers\n",
+        "class_centers = np.random.randn(NUM_CLASSES, NUM_FEATURES).astype(np.float32)\n",
+        "\n",
+        "# Generate data: each sample = class_center + Gaussian noise\n",
+        "all_labels = np.repeat(np.arange(NUM_CLASSES), SAMPLES_PER_CLASS)\n",
+        "all_features = (\n",
+        "    class_centers[all_labels] + NOISE_STD * np.random.randn(n_total, NUM_FEATURES)\n",
+        ").astype(np.float32)\n",
+        "\n",
+        "# Shuffle\n",
+        "perm = np.random.permutation(n_total)\n",
+        "all_features = all_features[perm]\n",
+        "all_labels = all_labels[perm]\n",
+        "\n",
+        "# Split into train (80%) and test (20%)\n",
+        "split = int(0.8 * n_total)\n",
+        "train_features, test_features = all_features[:split], all_features[split:]\n",
+        "train_labels, test_labels = all_labels[:split], all_labels[split:]\n",
+        "\n",
+        "# Create CustomDataset instances\n",
+        "train_dataset = CustomDataset(train_features, train_labels)\n",
+        "test_dataset = CustomDataset(test_features, test_labels)\n",
+        "\n",
+        "print(f\"Train dataset: {len(train_dataset)} samples\")\n",
+        "print(f\"Test dataset:  {len(test_dataset)} samples\")\n",
+        "print(f\"Number of classes: {train_dataset.num_classes}\")\n",
+        "print(f\"Input shape: {train_dataset.input_shape}\")"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### Visualize the Data\n",
+        "\n",
+        "Let's project the first two dimensions to get a sense of the class separation."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 14,
+      "metadata": {
+        "output": {
+          "id": 2288884158267481,
+          "loadingStatus": "loaded"
+        }
+      },
+      "outputs": [
+        {
+          "data": {
+            "image/png": "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",
+            "text/plain": [
+              "<Figure size 1000x600 with 1 Axes>"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        }
+      ],
+      "source": [
+        "plt.figure(figsize=(10, 6))\n",
+        "for c in range(NUM_CLASSES):\n",
+        "    mask = train_labels == c\n",
+        "    plt.scatter(\n",
+        "        train_features[mask, 0],\n",
+        "        train_features[mask, 1],\n",
+        "        alpha=0.4,\n",
+        "        label=f\"Class {c}\",\n",
+        "        s=10,\n",
+        "    )\n",
+        "plt.xlabel(\"Feature 0\")\n",
+        "plt.ylabel(\"Feature 1\")\n",
+        "plt.title(\"Custom Dataset — First Two Dimensions\")\n",
+        "plt.legend()\n",
+        "plt.grid(True, alpha=0.3)\n",
+        "plt.show()"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Step 2: Train a Target Model\n",
+        "\n",
+        "We use `create_mlp_model` to build a simple feedforward network.\n",
+        "This model automatically adapts to the input dimension and number of classes\n",
+        "of our custom dataset."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 15,
+      "metadata": {
+        "output": {
+          "id": 1570860790693291,
+          "loadingStatus": "loaded"
+        }
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "SimpleMLP(\n",
+            "  (network): Sequential(\n",
+            "    (0): Linear(in_features=100, out_features=256, bias=True)\n",
+            "    (1): ReLU(inplace=True)\n",
+            "    (2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+            "    (3): Linear(in_features=256, out_features=128, bias=True)\n",
+            "    (4): ReLU(inplace=True)\n",
+            "    (5): BatchNorm1d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+            "    (6): Linear(in_features=128, out_features=5, bias=True)\n",
+            "  )\n",
+            ")\n",
+            "Epoch 1/30\n",
+            "Training - Loss: 0.6406, Acc: 76.86%\n",
+            "Testing - Acc: 90.70%\n",
+            "Epoch 2/30\n",
+            "Training - Loss: 0.1758, Acc: 94.05%\n",
+            "Testing - Acc: 92.20%\n",
+            "Epoch 3/30\n",
+            "Training - Loss: 0.1164, Acc: 96.60%\n",
+            "Testing - Acc: 92.50%\n",
+            "Epoch 4/30\n",
+            "Training - Loss: 0.0853, Acc: 97.93%\n",
+            "Testing - Acc: 92.70%\n",
+            "Epoch 5/30\n",
+            "Training - Loss: 0.0663, Acc: 98.51%\n",
+            "Testing - Acc: 92.60%\n",
+            "Epoch 6/30\n",
+            "Training - Loss: 0.0533, Acc: 98.84%\n",
+            "Testing - Acc: 92.70%\n",
+            "Epoch 7/30\n",
+            "Training - Loss: 0.0410, Acc: 99.27%\n",
+            "Testing - Acc: 92.70%\n",
+            "Epoch 8/30\n",
+            "Training - Loss: 0.0389, Acc: 99.32%\n",
+            "Testing - Acc: 91.80%\n",
+            "Epoch 9/30\n",
+            "Training - Loss: 0.0318, Acc: 99.50%\n",
+            "Testing - Acc: 92.00%\n",
+            "Epoch 10/30\n",
+            "Training - Loss: 0.0279, Acc: 99.77%\n",
+            "Testing - Acc: 92.10%\n",
+            "Epoch 11/30\n",
+            "Training - Loss: 0.0239, Acc: 99.77%\n",
+            "Testing - Acc: 92.00%\n",
+            "Epoch 12/30\n",
+            "Training - Loss: 0.0205, Acc: 99.82%\n",
+            "Testing - Acc: 91.60%\n",
+            "Epoch 13/30\n",
+            "Training - Loss: 0.0194, Acc: 99.90%\n",
+            "Testing - Acc: 92.20%\n",
+            "Epoch 14/30\n",
+            "Training - Loss: 0.0149, Acc: 99.97%\n",
+            "Testing - Acc: 91.90%\n",
+            "Epoch 15/30\n",
+            "Training - Loss: 0.0178, Acc: 99.87%\n",
+            "Testing - Acc: 92.70%\n",
+            "Epoch 16/30\n",
+            "Training - Loss: 0.0176, Acc: 99.80%\n",
+            "Testing - Acc: 92.40%\n",
+            "Epoch 17/30\n",
+            "Training - Loss: 0.0175, Acc: 99.77%\n",
+            "Testing - Acc: 92.20%\n",
+            "Epoch 18/30\n",
+            "Training - Loss: 0.0180, Acc: 99.77%\n",
+            "Testing - Acc: 92.20%\n",
+            "Epoch 19/30\n",
+            "Training - Loss: 0.0145, Acc: 99.95%\n",
+            "Testing - Acc: 91.80%\n",
+            "Epoch 20/30\n",
+            "Training - Loss: 0.0163, Acc: 99.82%\n",
+            "Testing - Acc: 91.80%\n",
+            "Epoch 21/30\n",
+            "Training - Loss: 0.0132, Acc: 99.97%\n",
+            "Testing - Acc: 92.20%\n",
+            "Epoch 22/30\n",
+            "Training - Loss: 0.0132, Acc: 99.90%\n",
+            "Testing - Acc: 92.10%\n",
+            "Epoch 23/30\n",
+            "Training - Loss: 0.0135, Acc: 99.92%\n",
+            "Testing - Acc: 92.30%\n",
+            "Epoch 24/30\n",
+            "Training - Loss: 0.0142, Acc: 99.92%\n",
+            "Testing - Acc: 92.50%\n",
+            "Epoch 25/30\n",
+            "Training - Loss: 0.0124, Acc: 100.00%\n",
+            "Testing - Acc: 92.50%\n",
+            "Epoch 26/30\n",
+            "Training - Loss: 0.0123, Acc: 100.00%\n",
+            "Testing - Acc: 92.50%\n",
+            "Epoch 27/30\n",
+            "Training - Loss: 0.0147, Acc: 99.82%\n",
+            "Testing - Acc: 92.20%\n",
+            "Epoch 28/30\n",
+            "Training - Loss: 0.0113, Acc: 99.97%\n",
+            "Testing - Acc: 92.10%\n",
+            "Epoch 29/30\n",
+            "Training - Loss: 0.0111, Acc: 99.97%\n",
+            "Testing - Acc: 91.80%\n",
+            "Epoch 30/30\n",
+            "Training - Loss: 0.0124, Acc: 99.97%\n",
+            "Testing - Acc: 91.80%\n"
+          ]
+        }
+      ],
+      "source": [
+        "# Create the model\n",
+        "input_dim = train_dataset.input_shape[0]  # number of features\n",
+        "num_classes = train_dataset.num_classes\n",
+        "\n",
+        "target_model = create_mlp_model(\n",
+        "    input_dim=input_dim,\n",
+        "    num_classes=num_classes,\n",
+        "    hidden_dims=[256, 128],\n",
+        ").to(DEVICE)\n",
+        "\n",
+        "print(target_model)\n",
+        "\n",
+        "# Create data loaders\n",
+        "BATCH_SIZE = 64\n",
+        "train_loader = DataLoader(train_dataset, batch_size=BATCH_SIZE, shuffle=True, drop_last=True)\n",
+        "test_loader = DataLoader(test_dataset, batch_size=BATCH_SIZE, shuffle=False)\n",
+        "\n",
+        "# Train the model\n",
+        "EPOCHS = 30\n",
+        "target_model = train_model(\n",
+        "    target_model, train_loader, test_loader, epochs=EPOCHS, device=DEVICE\n",
+        ")"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Step 3: LiRA with Shadow Models on Custom Data\n",
+        "\n",
+        "For a powerful privacy audit, we use the **Likelihood Ratio Attack (LiRA)**. This requires\n",
+        "training multiple shadow models on random subsets of the training data.\n",
+        "\n",
+        "The key advantage of `CustomDataset` is that it integrates seamlessly with\n",
+        "`create_shadow_datasets` — the same function used for CIFAR-10."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 16,
+      "metadata": {
+        "output": {
+          "id": 1663276478180701,
+          "loadingStatus": "loaded"
+        }
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Number of shadow datasets: 7\n",
+            "  Shadow 0: 2034 samples\n",
+            "  Shadow 1: 2041 samples\n",
+            "  Shadow 2: 2019 samples\n",
+            "  Shadow 3: 1960 samples\n",
+            "  Shadow 4: 2033 samples\n",
+            "  Shadow 5: 1965 samples\n",
+            "  Shadow 6: 2000 samples\n",
+            "  Target: 1948 samples\n"
+          ]
+        }
+      ],
+      "source": [
+        "# Create shadow datasets\n",
+        "NUM_SHADOWS = 8  # Using fewer for tutorial speed\n",
+        "\n",
+        "shadow_datasets, target_shadow_dataset = create_shadow_datasets(\n",
+        "    train_dataset, n_shadows=NUM_SHADOWS, pkeep=0.5, seed=42\n",
+        ")\n",
+        "\n",
+        "print(f\"Number of shadow datasets: {len(shadow_datasets)}\")\n",
+        "for i, (subset, _) in enumerate(shadow_datasets):\n",
+        "    print(f\"  Shadow {i}: {len(subset)} samples\")\n",
+        "print(f\"  Target: {len(target_shadow_dataset[0])} samples\")"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 17,
+      "metadata": {
+        "output": {
+          "id": 1416582879737549,
+          "loadingStatus": "loaded"
+        }
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Training target model for LiRA...\n",
+            "Epoch 1/30\n",
+            "Training - Loss: 1.0301, Acc: 61.88%\n",
+            "Testing - Acc: 85.80%\n",
+            "Epoch 2/30\n",
+            "Training - Loss: 0.2345, Acc: 92.71%\n",
+            "Testing - Acc: 88.90%\n",
+            "Epoch 3/30\n",
+            "Training - Loss: 0.1427, Acc: 96.25%\n",
+            "Testing - Acc: 89.20%\n",
+            "Epoch 4/30\n",
+            "Training - Loss: 0.0982, Acc: 97.81%\n",
+            "Testing - Acc: 89.90%\n",
+            "Epoch 5/30\n",
+            "Training - Loss: 0.0744, Acc: 98.70%\n",
+            "Testing - Acc: 90.50%\n",
+            "Epoch 6/30\n",
+            "Training - Loss: 0.0555, Acc: 99.38%\n",
+            "Testing - Acc: 90.60%\n",
+            "Epoch 7/30\n",
+            "Training - Loss: 0.0505, Acc: 99.32%\n",
+            "Testing - Acc: 90.60%\n",
+            "Epoch 8/30\n",
+            "Training - Loss: 0.0413, Acc: 99.58%\n",
+            "Testing - Acc: 90.80%\n",
+            "Epoch 9/30\n",
+            "Training - Loss: 0.0378, Acc: 99.69%\n",
+            "Testing - Acc: 91.20%\n",
+            "Epoch 10/30\n",
+            "Training - Loss: 0.0327, Acc: 99.79%\n",
+            "Testing - Acc: 90.90%\n",
+            "Epoch 11/30\n",
+            "Training - Loss: 0.0233, Acc: 99.90%\n",
+            "Testing - Acc: 91.00%\n",
+            "Epoch 12/30\n",
+            "Training - Loss: 0.0270, Acc: 99.90%\n",
+            "Testing - Acc: 91.30%\n",
+            "Epoch 13/30\n",
+            "Training - Loss: 0.0228, Acc: 99.90%\n",
+            "Testing - Acc: 91.00%\n",
+            "Epoch 14/30\n",
+            "Training - Loss: 0.0202, Acc: 99.95%\n",
+            "Testing - Acc: 91.30%\n",
+            "Epoch 15/30\n",
+            "Training - Loss: 0.0205, Acc: 99.84%\n",
+            "Testing - Acc: 91.20%\n",
+            "Epoch 16/30\n",
+            "Training - Loss: 0.0161, Acc: 99.95%\n",
+            "Testing - Acc: 91.30%\n",
+            "Epoch 17/30\n",
+            "Training - Loss: 0.0169, Acc: 100.00%\n",
+            "Testing - Acc: 91.20%\n",
+            "Epoch 18/30\n",
+            "Training - Loss: 0.0161, Acc: 100.00%\n",
+            "Testing - Acc: 91.30%\n",
+            "Epoch 19/30\n",
+            "Training - Loss: 0.0153, Acc: 100.00%\n",
+            "Testing - Acc: 91.30%\n",
+            "Epoch 20/30\n",
+            "Training - Loss: 0.0162, Acc: 99.95%\n",
+            "Testing - Acc: 91.60%\n",
+            "Epoch 21/30\n",
+            "Training - Loss: 0.0166, Acc: 99.84%\n",
+            "Testing - Acc: 91.50%\n",
+            "Epoch 22/30\n",
+            "Training - Loss: 0.0148, Acc: 99.95%\n",
+            "Testing - Acc: 91.30%\n",
+            "Epoch 23/30\n",
+            "Training - Loss: 0.0166, Acc: 99.95%\n",
+            "Testing - Acc: 91.30%\n",
+            "Epoch 24/30\n",
+            "Training - Loss: 0.0135, Acc: 100.00%\n",
+            "Testing - Acc: 91.40%\n",
+            "Epoch 25/30\n",
+            "Training - Loss: 0.0130, Acc: 100.00%\n",
+            "Testing - Acc: 91.40%\n",
+            "Epoch 26/30\n",
+            "Training - Loss: 0.0154, Acc: 99.95%\n",
+            "Testing - Acc: 91.90%\n",
+            "Epoch 27/30\n",
+            "Training - Loss: 0.0136, Acc: 99.95%\n",
+            "Testing - Acc: 91.10%\n",
+            "Epoch 28/30\n",
+            "Training - Loss: 0.0120, Acc: 100.00%\n",
+            "Testing - Acc: 91.50%\n",
+            "Epoch 29/30\n",
+            "Training - Loss: 0.0139, Acc: 99.95%\n",
+            "Testing - Acc: 91.40%\n",
+            "Epoch 30/30\n",
+            "Training - Loss: 0.0128, Acc: 100.00%\n",
+            "Testing - Acc: 91.60%\n",
+            "\n",
+            "Training shadow model 1/7...\n",
+            "Epoch 1/30\n",
+            "Training - Loss: 1.0069, Acc: 61.95%\n",
+            "Testing - Acc: 88.40%\n",
+            "Epoch 2/30\n",
+            "Training - Loss: 0.2218, Acc: 93.60%\n",
+            "Testing - Acc: 89.70%\n",
+            "Epoch 3/30\n",
+            "Training - Loss: 0.1317, Acc: 96.47%\n",
+            "Testing - Acc: 90.80%\n",
+            "Epoch 4/30\n",
+            "Training - Loss: 0.0941, Acc: 98.24%\n",
+            "Testing - Acc: 91.30%\n",
+            "Epoch 5/30\n",
+            "Training - Loss: 0.0728, Acc: 98.54%\n",
+            "Testing - Acc: 90.70%\n",
+            "Epoch 6/30\n",
+            "Training - Loss: 0.0657, Acc: 98.89%\n",
+            "Testing - Acc: 90.80%\n",
+            "Epoch 7/30\n",
+            "Training - Loss: 0.0528, Acc: 98.94%\n",
+            "Testing - Acc: 91.20%\n",
+            "Epoch 8/30\n",
+            "Training - Loss: 0.0411, Acc: 99.60%\n",
+            "Testing - Acc: 91.50%\n",
+            "Epoch 9/30\n",
+            "Training - Loss: 0.0360, Acc: 99.75%\n",
+            "Testing - Acc: 91.30%\n",
+            "Epoch 10/30\n",
+            "Training - Loss: 0.0292, Acc: 99.80%\n",
+            "Testing - Acc: 91.30%\n",
+            "Epoch 11/30\n",
+            "Training - Loss: 0.0287, Acc: 99.85%\n",
+            "Testing - Acc: 91.10%\n",
+            "Epoch 12/30\n",
+            "Training - Loss: 0.0228, Acc: 99.95%\n",
+            "Testing - Acc: 91.60%\n",
+            "Epoch 13/30\n",
+            "Training - Loss: 0.0213, Acc: 99.80%\n",
+            "Testing - Acc: 91.30%\n",
+            "Epoch 14/30\n",
+            "Training - Loss: 0.0217, Acc: 99.95%\n",
+            "Testing - Acc: 91.40%\n",
+            "Epoch 15/30\n",
+            "Training - Loss: 0.0206, Acc: 99.85%\n",
+            "Testing - Acc: 91.10%\n",
+            "Epoch 16/30\n",
+            "Training - Loss: 0.0171, Acc: 100.00%\n",
+            "Testing - Acc: 91.30%\n",
+            "Epoch 17/30\n",
+            "Training - Loss: 0.0183, Acc: 99.85%\n",
+            "Testing - Acc: 91.20%\n",
+            "Epoch 18/30\n",
+            "Training - Loss: 0.0153, Acc: 100.00%\n",
+            "Testing - Acc: 91.30%\n",
+            "Epoch 19/30\n",
+            "Training - Loss: 0.0177, Acc: 99.95%\n",
+            "Testing - Acc: 91.40%\n",
+            "Epoch 20/30\n",
+            "Training - Loss: 0.0161, Acc: 100.00%\n",
+            "Testing - Acc: 91.40%\n",
+            "Epoch 21/30\n",
+            "Training - Loss: 0.0151, Acc: 99.95%\n",
+            "Testing - Acc: 91.30%\n",
+            "Epoch 22/30\n",
+            "Training - Loss: 0.0139, Acc: 100.00%\n",
+            "Testing - Acc: 91.40%\n",
+            "Epoch 23/30\n",
+            "Training - Loss: 0.0155, Acc: 100.00%\n",
+            "Testing - Acc: 91.50%\n",
+            "Epoch 24/30\n",
+            "Training - Loss: 0.0138, Acc: 100.00%\n",
+            "Testing - Acc: 91.40%\n",
+            "Epoch 25/30\n",
+            "Training - Loss: 0.0165, Acc: 99.90%\n",
+            "Testing - Acc: 91.30%\n",
+            "Epoch 26/30\n",
+            "Training - Loss: 0.0115, Acc: 100.00%\n",
+            "Testing - Acc: 91.50%\n",
+            "Epoch 27/30\n",
+            "Training - Loss: 0.0160, Acc: 99.90%\n",
+            "Testing - Acc: 91.50%\n",
+            "Epoch 28/30\n",
+            "Training - Loss: 0.0143, Acc: 100.00%\n",
+            "Testing - Acc: 91.20%\n",
+            "Epoch 29/30\n",
+            "Training - Loss: 0.0135, Acc: 100.00%\n",
+            "Testing - Acc: 91.10%\n",
+            "Epoch 30/30\n",
+            "Training - Loss: 0.0155, Acc: 100.00%\n",
+            "Testing - Acc: 91.30%\n",
+            "\n",
+            "Training shadow model 2/7...\n",
+            "Epoch 1/30\n",
+            "Training - Loss: 1.0057, Acc: 63.71%\n",
+            "Testing - Acc: 87.10%\n",
+            "Epoch 2/30\n",
+            "Training - Loss: 0.2103, Acc: 93.40%\n",
+            "Testing - Acc: 90.30%\n",
+            "Epoch 3/30\n",
+            "Training - Loss: 0.1348, Acc: 96.17%\n",
+            "Testing - Acc: 90.80%\n",
+            "Epoch 4/30\n",
+            "Training - Loss: 0.0953, Acc: 97.83%\n",
+            "Testing - Acc: 91.40%\n",
+            "Epoch 5/30\n",
+            "Training - Loss: 0.0750, Acc: 98.34%\n",
+            "Testing - Acc: 91.90%\n",
+            "Epoch 6/30\n",
+            "Training - Loss: 0.0554, Acc: 99.14%\n",
+            "Testing - Acc: 91.80%\n",
+            "Epoch 7/30\n",
+            "Training - Loss: 0.0507, Acc: 99.29%\n",
+            "Testing - Acc: 92.20%\n",
+            "Epoch 8/30\n",
+            "Training - Loss: 0.0410, Acc: 99.55%\n",
+            "Testing - Acc: 91.70%\n",
+            "Epoch 9/30\n",
+            "Training - Loss: 0.0308, Acc: 99.80%\n",
+            "Testing - Acc: 92.00%\n",
+            "Epoch 10/30\n",
+            "Training - Loss: 0.0276, Acc: 99.85%\n",
+            "Testing - Acc: 91.80%\n",
+            "Epoch 11/30\n",
+            "Training - Loss: 0.0256, Acc: 99.85%\n",
+            "Testing - Acc: 91.90%\n",
+            "Epoch 12/30\n",
+            "Training - Loss: 0.0237, Acc: 99.90%\n",
+            "Testing - Acc: 91.80%\n",
+            "Epoch 13/30\n",
+            "Training - Loss: 0.0212, Acc: 99.85%\n",
+            "Testing - Acc: 92.00%\n",
+            "Epoch 14/30\n",
+            "Training - Loss: 0.0222, Acc: 99.95%\n",
+            "Testing - Acc: 92.10%\n",
+            "Epoch 15/30\n",
+            "Training - Loss: 0.0174, Acc: 99.95%\n",
+            "Testing - Acc: 91.90%\n",
+            "Epoch 16/30\n",
+            "Training - Loss: 0.0196, Acc: 99.85%\n",
+            "Testing - Acc: 92.20%\n",
+            "Epoch 17/30\n",
+            "Training - Loss: 0.0162, Acc: 99.95%\n",
+            "Testing - Acc: 92.20%\n",
+            "Epoch 18/30\n",
+            "Training - Loss: 0.0159, Acc: 99.95%\n",
+            "Testing - Acc: 92.00%\n",
+            "Epoch 19/30\n",
+            "Training - Loss: 0.0173, Acc: 99.95%\n",
+            "Testing - Acc: 92.20%\n",
+            "Epoch 20/30\n",
+            "Training - Loss: 0.0146, Acc: 100.00%\n",
+            "Testing - Acc: 92.40%\n",
+            "Epoch 21/30\n",
+            "Training - Loss: 0.0179, Acc: 100.00%\n",
+            "Testing - Acc: 91.70%\n",
+            "Epoch 22/30\n",
+            "Training - Loss: 0.0145, Acc: 100.00%\n",
+            "Testing - Acc: 91.90%\n",
+            "Epoch 23/30\n",
+            "Training - Loss: 0.0138, Acc: 99.95%\n",
+            "Testing - Acc: 92.10%\n",
+            "Epoch 24/30\n",
+            "Training - Loss: 0.0150, Acc: 100.00%\n",
+            "Testing - Acc: 92.20%\n",
+            "Epoch 25/30\n",
+            "Training - Loss: 0.0146, Acc: 99.90%\n",
+            "Testing - Acc: 92.20%\n",
+            "Epoch 26/30\n",
+            "Training - Loss: 0.0148, Acc: 100.00%\n",
+            "Testing - Acc: 92.40%\n",
+            "Epoch 27/30\n",
+            "Training - Loss: 0.0139, Acc: 100.00%\n",
+            "Testing - Acc: 92.40%\n",
+            "Epoch 28/30\n",
+            "Training - Loss: 0.0129, Acc: 100.00%\n",
+            "Testing - Acc: 92.00%\n",
+            "Epoch 29/30\n",
+            "Training - Loss: 0.0135, Acc: 100.00%\n",
+            "Testing - Acc: 92.30%\n",
+            "Epoch 30/30\n",
+            "Training - Loss: 0.0161, Acc: 99.95%\n",
+            "Testing - Acc: 92.50%\n",
+            "\n",
+            "Training shadow model 3/7...\n",
+            "Epoch 1/30\n",
+            "Training - Loss: 1.0247, Acc: 62.60%\n",
+            "Testing - Acc: 85.60%\n",
+            "Epoch 2/30\n",
+            "Training - Loss: 0.2160, Acc: 93.09%\n",
+            "Testing - Acc: 89.80%\n",
+            "Epoch 3/30\n",
+            "Training - Loss: 0.1247, Acc: 96.93%\n",
+            "Testing - Acc: 90.40%\n",
+            "Epoch 4/30\n",
+            "Training - Loss: 0.0890, Acc: 98.19%\n",
+            "Testing - Acc: 90.30%\n",
+            "Epoch 5/30\n",
+            "Training - Loss: 0.0685, Acc: 98.54%\n",
+            "Testing - Acc: 90.20%\n",
+            "Epoch 6/30\n",
+            "Training - Loss: 0.0540, Acc: 99.14%\n",
+            "Testing - Acc: 90.30%\n",
+            "Epoch 7/30\n",
+            "Training - Loss: 0.0449, Acc: 99.34%\n",
+            "Testing - Acc: 89.80%\n",
+            "Epoch 8/30\n",
+            "Training - Loss: 0.0399, Acc: 99.65%\n",
+            "Testing - Acc: 89.80%\n",
+            "Epoch 9/30\n",
+            "Training - Loss: 0.0310, Acc: 99.90%\n",
+            "Testing - Acc: 90.40%\n",
+            "Epoch 10/30\n",
+            "Training - Loss: 0.0262, Acc: 99.95%\n",
+            "Testing - Acc: 89.90%\n",
+            "Epoch 11/30\n",
+            "Training - Loss: 0.0220, Acc: 99.90%\n",
+            "Testing - Acc: 90.30%\n",
+            "Epoch 12/30\n",
+            "Training - Loss: 0.0200, Acc: 99.95%\n",
+            "Testing - Acc: 90.30%\n",
+            "Epoch 13/30\n",
+            "Training - Loss: 0.0188, Acc: 99.95%\n",
+            "Testing - Acc: 90.10%\n",
+            "Epoch 14/30\n",
+            "Training - Loss: 0.0166, Acc: 100.00%\n",
+            "Testing - Acc: 90.00%\n",
+            "Epoch 15/30\n",
+            "Training - Loss: 0.0146, Acc: 100.00%\n",
+            "Testing - Acc: 90.20%\n",
+            "Epoch 16/30\n",
+            "Training - Loss: 0.0166, Acc: 100.00%\n",
+            "Testing - Acc: 90.40%\n",
+            "Epoch 17/30\n",
+            "Training - Loss: 0.0155, Acc: 100.00%\n",
+            "Testing - Acc: 90.40%\n",
+            "Epoch 18/30\n",
+            "Training - Loss: 0.0143, Acc: 100.00%\n",
+            "Testing - Acc: 90.30%\n",
+            "Epoch 19/30\n",
+            "Training - Loss: 0.0147, Acc: 99.95%\n",
+            "Testing - Acc: 90.40%\n",
+            "Epoch 20/30\n",
+            "Training - Loss: 0.0152, Acc: 100.00%\n",
+            "Testing - Acc: 90.40%\n",
+            "Epoch 21/30\n",
+            "Training - Loss: 0.0126, Acc: 100.00%\n",
+            "Testing - Acc: 90.40%\n",
+            "Epoch 22/30\n",
+            "Training - Loss: 0.0141, Acc: 100.00%\n",
+            "Testing - Acc: 90.60%\n",
+            "Epoch 23/30\n",
+            "Training - Loss: 0.0147, Acc: 99.95%\n",
+            "Testing - Acc: 90.10%\n",
+            "Epoch 24/30\n",
+            "Training - Loss: 0.0139, Acc: 100.00%\n",
+            "Testing - Acc: 90.20%\n",
+            "Epoch 25/30\n",
+            "Training - Loss: 0.0156, Acc: 99.85%\n",
+            "Testing - Acc: 90.50%\n",
+            "Epoch 26/30\n",
+            "Training - Loss: 0.0143, Acc: 100.00%\n",
+            "Testing - Acc: 90.40%\n",
+            "Epoch 27/30\n",
+            "Training - Loss: 0.0123, Acc: 100.00%\n",
+            "Testing - Acc: 90.80%\n",
+            "Epoch 28/30\n",
+            "Training - Loss: 0.0126, Acc: 100.00%\n",
+            "Testing - Acc: 90.50%\n",
+            "Epoch 29/30\n",
+            "Training - Loss: 0.0121, Acc: 100.00%\n",
+            "Testing - Acc: 90.40%\n",
+            "Epoch 30/30\n",
+            "Training - Loss: 0.0147, Acc: 99.90%\n",
+            "Testing - Acc: 90.60%\n",
+            "\n",
+            "Training shadow model 4/7...\n",
+            "Epoch 1/30\n",
+            "Training - Loss: 1.0055, Acc: 61.09%\n",
+            "Testing - Acc: 85.40%\n",
+            "Epoch 2/30\n",
+            "Training - Loss: 0.2217, Acc: 93.23%\n",
+            "Testing - Acc: 90.40%\n",
+            "Epoch 3/30\n",
+            "Training - Loss: 0.1201, Acc: 97.19%\n",
+            "Testing - Acc: 90.90%\n",
+            "Epoch 4/30\n",
+            "Training - Loss: 0.0900, Acc: 98.65%\n",
+            "Testing - Acc: 91.80%\n",
+            "Epoch 5/30\n",
+            "Training - Loss: 0.0702, Acc: 98.91%\n",
+            "Testing - Acc: 91.80%\n",
+            "Epoch 6/30\n",
+            "Training - Loss: 0.0523, Acc: 99.69%\n",
+            "Testing - Acc: 92.10%\n",
+            "Epoch 7/30\n",
+            "Training - Loss: 0.0431, Acc: 99.74%\n",
+            "Testing - Acc: 92.20%\n",
+            "Epoch 8/30\n",
+            "Training - Loss: 0.0383, Acc: 99.64%\n",
+            "Testing - Acc: 92.00%\n",
+            "Epoch 9/30\n",
+            "Training - Loss: 0.0296, Acc: 99.74%\n",
+            "Testing - Acc: 92.20%\n",
+            "Epoch 10/30\n",
+            "Training - Loss: 0.0322, Acc: 99.74%\n",
+            "Testing - Acc: 92.00%\n",
+            "Epoch 11/30\n",
+            "Training - Loss: 0.0255, Acc: 99.95%\n",
+            "Testing - Acc: 92.50%\n",
+            "Epoch 12/30\n",
+            "Training - Loss: 0.0223, Acc: 99.90%\n",
+            "Testing - Acc: 92.70%\n",
+            "Epoch 13/30\n",
+            "Training - Loss: 0.0194, Acc: 99.95%\n",
+            "Testing - Acc: 92.20%\n",
+            "Epoch 14/30\n",
+            "Training - Loss: 0.0196, Acc: 100.00%\n",
+            "Testing - Acc: 92.30%\n",
+            "Epoch 15/30\n",
+            "Training - Loss: 0.0183, Acc: 99.95%\n",
+            "Testing - Acc: 92.40%\n",
+            "Epoch 16/30\n",
+            "Training - Loss: 0.0192, Acc: 99.84%\n",
+            "Testing - Acc: 92.30%\n",
+            "Epoch 17/30\n",
+            "Training - Loss: 0.0165, Acc: 99.95%\n",
+            "Testing - Acc: 92.00%\n",
+            "Epoch 18/30\n",
+            "Training - Loss: 0.0159, Acc: 99.95%\n",
+            "Testing - Acc: 91.70%\n",
+            "Epoch 19/30\n",
+            "Training - Loss: 0.0146, Acc: 99.95%\n",
+            "Testing - Acc: 92.20%\n",
+            "Epoch 20/30\n",
+            "Training - Loss: 0.0140, Acc: 100.00%\n",
+            "Testing - Acc: 92.00%\n",
+            "Epoch 21/30\n",
+            "Training - Loss: 0.0142, Acc: 100.00%\n",
+            "Testing - Acc: 92.30%\n",
+            "Epoch 22/30\n",
+            "Training - Loss: 0.0140, Acc: 100.00%\n",
+            "Testing - Acc: 92.00%\n",
+            "Epoch 23/30\n",
+            "Training - Loss: 0.0129, Acc: 100.00%\n",
+            "Testing - Acc: 92.20%\n",
+            "Epoch 24/30\n",
+            "Training - Loss: 0.0139, Acc: 100.00%\n",
+            "Testing - Acc: 91.90%\n",
+            "Epoch 25/30\n",
+            "Training - Loss: 0.0120, Acc: 100.00%\n",
+            "Testing - Acc: 92.50%\n",
+            "Epoch 26/30\n",
+            "Training - Loss: 0.0148, Acc: 99.95%\n",
+            "Testing - Acc: 92.10%\n",
+            "Epoch 27/30\n",
+            "Training - Loss: 0.0144, Acc: 100.00%\n",
+            "Testing - Acc: 92.30%\n",
+            "Epoch 28/30\n",
+            "Training - Loss: 0.0135, Acc: 100.00%\n",
+            "Testing - Acc: 92.20%\n",
+            "Epoch 29/30\n",
+            "Training - Loss: 0.0160, Acc: 99.90%\n",
+            "Testing - Acc: 92.10%\n",
+            "Epoch 30/30\n",
+            "Training - Loss: 0.0128, Acc: 99.95%\n",
+            "Testing - Acc: 92.30%\n",
+            "\n",
+            "Training shadow model 5/7...\n",
+            "Epoch 1/30\n",
+            "Training - Loss: 1.0068, Acc: 62.90%\n",
+            "Testing - Acc: 87.10%\n",
+            "Epoch 2/30\n",
+            "Training - Loss: 0.2232, Acc: 92.94%\n",
+            "Testing - Acc: 89.90%\n",
+            "Epoch 3/30\n",
+            "Training - Loss: 0.1343, Acc: 96.52%\n",
+            "Testing - Acc: 90.50%\n",
+            "Epoch 4/30\n",
+            "Training - Loss: 0.0954, Acc: 97.98%\n",
+            "Testing - Acc: 90.70%\n",
+            "Epoch 5/30\n",
+            "Training - Loss: 0.0700, Acc: 99.09%\n",
+            "Testing - Acc: 90.80%\n",
+            "Epoch 6/30\n",
+            "Training - Loss: 0.0562, Acc: 99.29%\n",
+            "Testing - Acc: 91.00%\n",
+            "Epoch 7/30\n",
+            "Training - Loss: 0.0493, Acc: 99.09%\n",
+            "Testing - Acc: 90.80%\n",
+            "Epoch 8/30\n",
+            "Training - Loss: 0.0372, Acc: 99.65%\n",
+            "Testing - Acc: 90.90%\n",
+            "Epoch 9/30\n",
+            "Training - Loss: 0.0310, Acc: 99.80%\n",
+            "Testing - Acc: 90.90%\n",
+            "Epoch 10/30\n",
+            "Training - Loss: 0.0291, Acc: 99.85%\n",
+            "Testing - Acc: 91.40%\n",
+            "Epoch 11/30\n",
+            "Training - Loss: 0.0271, Acc: 99.95%\n",
+            "Testing - Acc: 91.50%\n",
+            "Epoch 12/30\n",
+            "Training - Loss: 0.0226, Acc: 99.95%\n",
+            "Testing - Acc: 91.60%\n",
+            "Epoch 13/30\n",
+            "Training - Loss: 0.0211, Acc: 99.80%\n",
+            "Testing - Acc: 91.50%\n",
+            "Epoch 14/30\n",
+            "Training - Loss: 0.0196, Acc: 99.90%\n",
+            "Testing - Acc: 91.30%\n",
+            "Epoch 15/30\n",
+            "Training - Loss: 0.0191, Acc: 100.00%\n",
+            "Testing - Acc: 91.20%\n",
+            "Epoch 16/30\n",
+            "Training - Loss: 0.0149, Acc: 100.00%\n",
+            "Testing - Acc: 91.30%\n",
+            "Epoch 17/30\n",
+            "Training - Loss: 0.0164, Acc: 99.90%\n",
+            "Testing - Acc: 91.60%\n",
+            "Epoch 18/30\n",
+            "Training - Loss: 0.0155, Acc: 100.00%\n",
+            "Testing - Acc: 91.10%\n",
+            "Epoch 19/30\n",
+            "Training - Loss: 0.0168, Acc: 99.90%\n",
+            "Testing - Acc: 91.30%\n",
+            "Epoch 20/30\n",
+            "Training - Loss: 0.0156, Acc: 100.00%\n",
+            "Testing - Acc: 91.80%\n",
+            "Epoch 21/30\n",
+            "Training - Loss: 0.0151, Acc: 100.00%\n",
+            "Testing - Acc: 91.60%\n",
+            "Epoch 22/30\n",
+            "Training - Loss: 0.0130, Acc: 100.00%\n",
+            "Testing - Acc: 91.70%\n",
+            "Epoch 23/30\n",
+            "Training - Loss: 0.0130, Acc: 100.00%\n",
+            "Testing - Acc: 91.40%\n",
+            "Epoch 24/30\n",
+            "Training - Loss: 0.0132, Acc: 100.00%\n",
+            "Testing - Acc: 91.30%\n",
+            "Epoch 25/30\n",
+            "Training - Loss: 0.0123, Acc: 100.00%\n",
+            "Testing - Acc: 91.20%\n",
+            "Epoch 26/30\n",
+            "Training - Loss: 0.0134, Acc: 100.00%\n",
+            "Testing - Acc: 91.70%\n",
+            "Epoch 27/30\n",
+            "Training - Loss: 0.0130, Acc: 100.00%\n",
+            "Testing - Acc: 91.10%\n",
+            "Epoch 28/30\n",
+            "Training - Loss: 0.0149, Acc: 99.95%\n",
+            "Testing - Acc: 91.70%\n",
+            "Epoch 29/30\n",
+            "Training - Loss: 0.0145, Acc: 100.00%\n",
+            "Testing - Acc: 91.50%\n",
+            "Epoch 30/30\n",
+            "Training - Loss: 0.0148, Acc: 100.00%\n",
+            "Testing - Acc: 91.40%\n",
+            "\n",
+            "Training shadow model 6/7...\n",
+            "Epoch 1/30\n",
+            "Training - Loss: 0.9519, Acc: 65.47%\n",
+            "Testing - Acc: 86.80%\n",
+            "Epoch 2/30\n",
+            "Training - Loss: 0.2201, Acc: 93.39%\n",
+            "Testing - Acc: 88.80%\n",
+            "Epoch 3/30\n",
+            "Training - Loss: 0.1337, Acc: 96.67%\n",
+            "Testing - Acc: 89.50%\n",
+            "Epoch 4/30\n",
+            "Training - Loss: 0.0925, Acc: 98.18%\n",
+            "Testing - Acc: 89.20%\n",
+            "Epoch 5/30\n",
+            "Training - Loss: 0.0663, Acc: 99.27%\n",
+            "Testing - Acc: 89.40%\n",
+            "Epoch 6/30\n",
+            "Training - Loss: 0.0551, Acc: 99.22%\n",
+            "Testing - Acc: 89.60%\n",
+            "Epoch 7/30\n",
+            "Training - Loss: 0.0456, Acc: 99.69%\n",
+            "Testing - Acc: 89.80%\n",
+            "Epoch 8/30\n",
+            "Training - Loss: 0.0391, Acc: 99.69%\n",
+            "Testing - Acc: 89.60%\n",
+            "Epoch 9/30\n",
+            "Training - Loss: 0.0315, Acc: 99.84%\n",
+            "Testing - Acc: 89.80%\n",
+            "Epoch 10/30\n",
+            "Training - Loss: 0.0287, Acc: 99.84%\n",
+            "Testing - Acc: 89.80%\n",
+            "Epoch 11/30\n",
+            "Training - Loss: 0.0252, Acc: 99.84%\n",
+            "Testing - Acc: 90.20%\n",
+            "Epoch 12/30\n",
+            "Training - Loss: 0.0204, Acc: 99.95%\n",
+            "Testing - Acc: 90.10%\n",
+            "Epoch 13/30\n",
+            "Training - Loss: 0.0217, Acc: 99.84%\n",
+            "Testing - Acc: 89.90%\n",
+            "Epoch 14/30\n",
+            "Training - Loss: 0.0229, Acc: 99.84%\n",
+            "Testing - Acc: 89.90%\n",
+            "Epoch 15/30\n",
+            "Training - Loss: 0.0207, Acc: 99.90%\n",
+            "Testing - Acc: 89.70%\n",
+            "Epoch 16/30\n",
+            "Training - Loss: 0.0175, Acc: 99.90%\n",
+            "Testing - Acc: 89.90%\n",
+            "Epoch 17/30\n",
+            "Training - Loss: 0.0161, Acc: 100.00%\n",
+            "Testing - Acc: 89.50%\n",
+            "Epoch 18/30\n",
+            "Training - Loss: 0.0170, Acc: 99.95%\n",
+            "Testing - Acc: 90.20%\n",
+            "Epoch 19/30\n",
+            "Training - Loss: 0.0131, Acc: 100.00%\n",
+            "Testing - Acc: 89.60%\n",
+            "Epoch 20/30\n",
+            "Training - Loss: 0.0126, Acc: 100.00%\n",
+            "Testing - Acc: 90.00%\n",
+            "Epoch 21/30\n",
+            "Training - Loss: 0.0133, Acc: 100.00%\n",
+            "Testing - Acc: 89.90%\n",
+            "Epoch 22/30\n",
+            "Training - Loss: 0.0137, Acc: 99.95%\n",
+            "Testing - Acc: 89.90%\n",
+            "Epoch 23/30\n",
+            "Training - Loss: 0.0132, Acc: 100.00%\n",
+            "Testing - Acc: 89.90%\n",
+            "Epoch 24/30\n",
+            "Training - Loss: 0.0146, Acc: 99.90%\n",
+            "Testing - Acc: 89.90%\n",
+            "Epoch 25/30\n",
+            "Training - Loss: 0.0128, Acc: 100.00%\n",
+            "Testing - Acc: 89.80%\n",
+            "Epoch 26/30\n",
+            "Training - Loss: 0.0127, Acc: 100.00%\n",
+            "Testing - Acc: 90.00%\n",
+            "Epoch 27/30\n",
+            "Training - Loss: 0.0127, Acc: 100.00%\n",
+            "Testing - Acc: 90.00%\n",
+            "Epoch 28/30\n",
+            "Training - Loss: 0.0134, Acc: 100.00%\n",
+            "Testing - Acc: 90.10%\n",
+            "Epoch 29/30\n",
+            "Training - Loss: 0.0144, Acc: 99.90%\n",
+            "Testing - Acc: 89.70%\n",
+            "Epoch 30/30\n",
+            "Training - Loss: 0.0121, Acc: 100.00%\n",
+            "Testing - Acc: 89.60%\n",
+            "\n",
+            "Training shadow model 7/7...\n",
+            "Epoch 1/30\n",
+            "Training - Loss: 0.9365, Acc: 65.27%\n",
+            "Testing - Acc: 87.90%\n",
+            "Epoch 2/30\n",
+            "Training - Loss: 0.1983, Acc: 93.95%\n",
+            "Testing - Acc: 91.10%\n",
+            "Epoch 3/30\n",
+            "Training - Loss: 0.1216, Acc: 96.52%\n",
+            "Testing - Acc: 91.50%\n",
+            "Epoch 4/30\n",
+            "Training - Loss: 0.0871, Acc: 98.49%\n",
+            "Testing - Acc: 91.20%\n",
+            "Epoch 5/30\n",
+            "Training - Loss: 0.0710, Acc: 98.59%\n",
+            "Testing - Acc: 91.70%\n",
+            "Epoch 6/30\n",
+            "Training - Loss: 0.0498, Acc: 99.34%\n",
+            "Testing - Acc: 91.40%\n",
+            "Epoch 7/30\n",
+            "Training - Loss: 0.0412, Acc: 99.45%\n",
+            "Testing - Acc: 91.30%\n",
+            "Epoch 8/30\n",
+            "Training - Loss: 0.0391, Acc: 99.40%\n",
+            "Testing - Acc: 91.50%\n",
+            "Epoch 9/30\n",
+            "Training - Loss: 0.0280, Acc: 99.90%\n",
+            "Testing - Acc: 91.10%\n",
+            "Epoch 10/30\n",
+            "Training - Loss: 0.0273, Acc: 99.90%\n",
+            "Testing - Acc: 91.40%\n",
+            "Epoch 11/30\n",
+            "Training - Loss: 0.0252, Acc: 99.75%\n",
+            "Testing - Acc: 92.00%\n",
+            "Epoch 12/30\n",
+            "Training - Loss: 0.0225, Acc: 99.90%\n",
+            "Testing - Acc: 91.80%\n",
+            "Epoch 13/30\n",
+            "Training - Loss: 0.0195, Acc: 100.00%\n",
+            "Testing - Acc: 91.90%\n",
+            "Epoch 14/30\n",
+            "Training - Loss: 0.0175, Acc: 100.00%\n",
+            "Testing - Acc: 91.80%\n",
+            "Epoch 15/30\n",
+            "Training - Loss: 0.0166, Acc: 99.95%\n",
+            "Testing - Acc: 91.90%\n",
+            "Epoch 16/30\n",
+            "Training - Loss: 0.0167, Acc: 99.90%\n",
+            "Testing - Acc: 91.80%\n",
+            "Epoch 17/30\n",
+            "Training - Loss: 0.0166, Acc: 99.95%\n",
+            "Testing - Acc: 92.10%\n",
+            "Epoch 18/30\n",
+            "Training - Loss: 0.0156, Acc: 99.95%\n",
+            "Testing - Acc: 92.00%\n",
+            "Epoch 19/30\n",
+            "Training - Loss: 0.0162, Acc: 99.95%\n",
+            "Testing - Acc: 92.00%\n",
+            "Epoch 20/30\n",
+            "Training - Loss: 0.0166, Acc: 99.95%\n",
+            "Testing - Acc: 91.50%\n",
+            "Epoch 21/30\n",
+            "Training - Loss: 0.0137, Acc: 100.00%\n",
+            "Testing - Acc: 92.30%\n",
+            "Epoch 22/30\n",
+            "Training - Loss: 0.0145, Acc: 99.95%\n",
+            "Testing - Acc: 92.30%\n",
+            "Epoch 23/30\n",
+            "Training - Loss: 0.0152, Acc: 100.00%\n",
+            "Testing - Acc: 91.90%\n",
+            "Epoch 24/30\n",
+            "Training - Loss: 0.0135, Acc: 100.00%\n",
+            "Testing - Acc: 92.30%\n",
+            "Epoch 25/30\n",
+            "Training - Loss: 0.0116, Acc: 100.00%\n",
+            "Testing - Acc: 91.80%\n",
+            "Epoch 26/30\n",
+            "Training - Loss: 0.0148, Acc: 99.95%\n",
+            "Testing - Acc: 92.00%\n",
+            "Epoch 27/30\n",
+            "Training - Loss: 0.0117, Acc: 100.00%\n",
+            "Testing - Acc: 92.10%\n",
+            "Epoch 28/30\n",
+            "Training - Loss: 0.0120, Acc: 99.95%\n",
+            "Testing - Acc: 92.00%\n",
+            "Epoch 29/30\n",
+            "Training - Loss: 0.0144, Acc: 99.95%\n",
+            "Testing - Acc: 92.30%\n",
+            "Epoch 30/30\n",
+            "Training - Loss: 0.0126, Acc: 100.00%\n",
+            "Testing - Acc: 92.40%\n"
+          ]
+        }
+      ],
+      "source": [
+        "# Train the target model (on target shadow subset)\n",
+        "target_lira_model = create_mlp_model(\n",
+        "    input_dim=input_dim, num_classes=num_classes, hidden_dims=[256, 128]\n",
+        ").to(DEVICE)\n",
+        "\n",
+        "target_subset = target_shadow_dataset[0]\n",
+        "target_train_loader = DataLoader(target_subset, batch_size=BATCH_SIZE, shuffle=True, drop_last=True)\n",
+        "\n",
+        "print(\"Training target model for LiRA...\")\n",
+        "target_lira_model = train_model(\n",
+        "    target_lira_model, target_train_loader, test_loader, epochs=EPOCHS, device=DEVICE\n",
+        ")\n",
+        "\n",
+        "# Train shadow models\n",
+        "shadow_models = []\n",
+        "for i, (shadow_subset, _) in enumerate(shadow_datasets):\n",
+        "    print(f\"\\nTraining shadow model {i + 1}/{len(shadow_datasets)}...\")\n",
+        "    shadow_model = create_mlp_model(\n",
+        "        input_dim=input_dim, num_classes=num_classes, hidden_dims=[256, 128]\n",
+        "    ).to(DEVICE)\n",
+        "    shadow_loader = DataLoader(shadow_subset, batch_size=BATCH_SIZE, shuffle=True, drop_last=True)\n",
+        "    shadow_model = train_model(\n",
+        "        shadow_model, shadow_loader, test_loader, epochs=EPOCHS, device=DEVICE\n",
+        "    )\n",
+        "    shadow_models.append(shadow_model)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 18,
+      "metadata": {
+        "output": {
+          "id": 1237778381338283,
+          "loadingStatus": "loaded"
+        }
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Extracting target model logits...\n",
+            "Model accuracy: 0.9575\n",
+            "Extracting shadow model 1/7 logits...\n",
+            "Model accuracy: 0.9653\n",
+            "Extracting shadow model 2/7 logits...\n",
+            "Model accuracy: 0.9633\n",
+            "Extracting shadow model 3/7 logits...\n",
+            "Model accuracy: 0.9647\n",
+            "Extracting shadow model 4/7 logits...\n",
+            "Model accuracy: 0.9610\n",
+            "Extracting shadow model 5/7 logits...\n",
+            "Model accuracy: 0.9605\n",
+            "Extracting shadow model 6/7 logits...\n",
+            "Model accuracy: 0.9603\n",
+            "Extracting shadow model 7/7 logits...\n",
+            "Model accuracy: 0.9615\n",
+            "\n",
+            "Target logits shape: (4000, 1)\n",
+            "Shadow logits shape: (7, 4000, 1)\n"
+          ]
+        }
+      ],
+      "source": [
+        "# Extract logits from all models over the full training dataset\n",
+        "full_train_loader = DataLoader(train_dataset, batch_size=BATCH_SIZE, shuffle=False)\n",
+        "\n",
+        "print(\"Extracting target model logits...\")\n",
+        "target_logits = get_transformed_logits(target_lira_model, full_train_loader, DEVICE)\n",
+        "\n",
+        "shadow_logits_list = []\n",
+        "for i, shadow_model in enumerate(shadow_models):\n",
+        "    print(f\"Extracting shadow model {i + 1}/{len(shadow_models)} logits...\")\n",
+        "    shadow_logits_list.append(\n",
+        "        get_transformed_logits(shadow_model, full_train_loader, DEVICE)\n",
+        "    )\n",
+        "\n",
+        "shadow_logits = np.array(shadow_logits_list)\n",
+        "print(f\"\\nTarget logits shape: {target_logits.shape}\")\n",
+        "print(f\"Shadow logits shape: {shadow_logits.shape}\")"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 19,
+      "metadata": {
+        "output": {
+          "id": 3667155636759066,
+          "loadingStatus": "loaded"
+        }
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "4000\n",
+            "Online train shape: (1948, 6)\n",
+            "Online test shape:  (2052, 6)\n"
+          ]
+        }
+      ],
+      "source": [
+        "# Prepare data for LiRA\n",
+        "df_train_online, df_test_online, df_train_offline, df_test_offline = prepare_lira_data(\n",
+        "    target_logits, shadow_logits, target_shadow_dataset, shadow_datasets\n",
+        ")\n",
+        "\n",
+        "print(f\"Online train shape: {df_train_online.shape}\")\n",
+        "print(f\"Online test shape:  {df_test_online.shape}\")"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 20,
+      "metadata": {
+        "output": {
+          "id": 1621409969186056,
+          "loadingStatus": "loaded"
+        }
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "LiRA attacks completed.\n"
+          ]
+        }
+      ],
+      "source": [
+        "# Run Online LiRA attack\n",
+        "online_lira = LiraAttack(\n",
+        "    df_train_merge=df_train_online,\n",
+        "    df_test_merge=df_test_online,\n",
+        "    row_aggregation=AggregationType.NONE,\n",
+        "    use_fixed_variance=True,\n",
+        "    std_dev_type=\"mix\",\n",
+        "    online_attack=True,\n",
+        ")\n",
+        "online_results = online_lira.run_attack()\n",
+        "\n",
+        "# Run Offline LiRA attack\n",
+        "offline_lira = LiraAttack(\n",
+        "    df_train_merge=df_train_offline,\n",
+        "    df_test_merge=df_test_offline,\n",
+        "    row_aggregation=AggregationType.NONE,\n",
+        "    use_fixed_variance=True,\n",
+        "    std_dev_type=\"shadows_out\",\n",
+        "    online_attack=False,\n",
+        ")\n",
+        "offline_results = offline_lira.run_attack()\n",
+        "\n",
+        "print(\"LiRA attacks completed.\")"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Step 4: Analyze and Compare Results"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 21,
+      "metadata": {
+        "output": {
+          "id": 1984407222150620,
+          "loadingStatus": "loaded"
+        }
+      },
+      "outputs": [
+        {
+          "name": "stderr",
+          "output_type": "stream",
+          "text": [
+            "I0303 113453.075 analysis_node.py:303] Train/Test unique users: 1948/2052\n",
+            "I0303 113453.363 mia_results.py:193] TNR: 0.04517, FNR: 0.0, emp eps: 2.16682, tnr@fnr0.001: 0.04517, eps@fnr0.001: 0.02977, auc 0.65352 accuracy 0.61345, \n",
+            "I0303 113453.363 analysis_node.py:310] Epsilon CP: 2.1668151955334354\n",
+            "I0303 113454.733 analysis_node.py:303] Train/Test unique users: 1948/2052\n"
+          ]
+        },
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "\n",
+            "=== Online LiRA ===\n",
+            "Accuracy: 0.6235 (95% CI: [0.6093, 0.6386])\n",
+            "AUC:      0.6667 (95% CI: [0.6497, 0.6830])\n",
+            "Epsilon (TPR=1%, UB): 7.5746\n",
+            "Epsilon (TPR=1%, LB): 1.8961\n"
+          ]
+        },
+        {
+          "name": "stderr",
+          "output_type": "stream",
+          "text": [
+            "I0303 113455.023 mia_results.py:193] TNR: 1.0, FNR: 0.99487, emp eps: -0.00213, tnr@fnr0.001: 0.0, eps@fnr0.001: -0.0038, auc 0.5157 accuracy 0.52002, \n"
+          ]
+        },
+        {
+          "name": "stderr",
+          "output_type": "stream",
+          "text": [
+            "I0303 113455.023 analysis_node.py:310] Epsilon CP: -0.0021271328306005184\n"
+          ]
+        },
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "\n",
+            "=== Offline LiRA ===\n",
+            "Accuracy: 0.5125 (95% CI: [0.5033, 0.5241])\n",
+            "AUC:      0.4998 (95% CI: [0.4824, 0.5171])\n",
+            "Epsilon (TPR=1%, UB): 1.0977\n",
+            "Epsilon (TPR=1%, LB): -0.3576\n"
+          ]
+        }
+      ],
+      "source": [
+        "def run_analysis(attack_results: Any, name: str) -> Dict[str, Any]:\n",
+        "    \"\"\"Run AnalysisNode and print results.\"\"\"\n",
+        "    node = AnalysisNode(\n",
+        "        analysis_input=attack_results,\n",
+        "        delta=1e-5,\n",
+        "        n_users_for_eval=min(\n",
+        "            len(attack_results.df_train_user), len(attack_results.df_test_user)\n",
+        "        ),\n",
+        "        num_bootstrap_resampling_times=1000,\n",
+        "        show_progress=False,\n",
+        "    )\n",
+        "    results = node.compute_outputs()\n",
+        "\n",
+        "    print(f\"\\n=== {name} ===\")\n",
+        "    print(\n",
+        "        f\"Accuracy: {results['accuracy']:.4f} \"\n",
+        "        f\"(95% CI: [{results['accuracy_ci'][0]:.4f}, {results['accuracy_ci'][1]:.4f}])\"\n",
+        "    )\n",
+        "    print(\n",
+        "        f\"AUC:      {results['auc']:.4f} \"\n",
+        "        f\"(95% CI: [{results['auc_ci'][0]:.4f}, {results['auc_ci'][1]:.4f}])\"\n",
+        "    )\n",
+        "    print(f\"Epsilon (TPR=1%, UB): {results['eps_tpr_ub'][0]:.4f}\")\n",
+        "    print(f\"Epsilon (TPR=1%, LB): {results['eps_tpr_lb'][0]:.4f}\")\n",
+        "    return results\n",
+        "\n",
+        "\n",
+        "online_analysis = run_analysis(online_results, \"Online LiRA\")\n",
+        "offline_analysis = run_analysis(offline_results, \"Offline LiRA\")"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 22,
+      "metadata": {
+        "output": {
+          "id": 1180934943908438,
+          "loadingStatus": "loaded"
+        }
+      },
+      "outputs": [
+        {
+          "data": {
+            "image/png": "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",
+            "text/plain": [
+              "<Figure size 1400x500 with 2 Axes>"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        }
+      ],
+      "source": [
+        "# Compare score distributions for Online vs Offline LiRA\n",
+        "fig, axes = plt.subplots(1, 2, figsize=(14, 5))\n",
+        "\n",
+        "attack_data = [\n",
+        "    (online_results, \"Online LiRA\"),\n",
+        "    (offline_results, \"Offline LiRA\"),\n",
+        "]\n",
+        "\n",
+        "for ax, (results, title) in zip(axes, attack_data):\n",
+        "    ax.hist(\n",
+        "        results.df_train_user[\"score\"],\n",
+        "        bins=40,\n",
+        "        alpha=0.5,\n",
+        "        label=\"Members\",\n",
+        "        color=\"tab:orange\",\n",
+        "    )\n",
+        "    ax.hist(\n",
+        "        results.df_test_user[\"score\"],\n",
+        "        bins=40,\n",
+        "        alpha=0.5,\n",
+        "        label=\"Non-members\",\n",
+        "        color=\"tab:blue\",\n",
+        "    )\n",
+        "    ax.set_xlabel(\"Score\")\n",
+        "    ax.set_ylabel(\"Frequency\")\n",
+        "    ax.set_title(title)\n",
+        "    ax.legend()\n",
+        "    ax.grid(True, alpha=0.3)\n",
+        "\n",
+        "plt.tight_layout()\n",
+        "plt.show()"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Bringing Your Own Data\n",
+        "\n",
+        "To use `CustomDataset` with your own data, you only need:\n",
+        "\n",
+        "```python\n",
+        "import numpy as np\n",
+        "from privacy_guard.shadow_model_training.dataset import CustomDataset\n",
+        "\n",
+        "# Load your data (any source: CSV, database, API, etc.)\n",
+        "X_train = np.load(\"my_train_features.npy\")  # shape: (n_samples, n_features)\n",
+        "y_train = np.load(\"my_train_labels.npy\")    # shape: (n_samples,)\n",
+        "X_test = np.load(\"my_test_features.npy\")\n",
+        "y_test = np.load(\"my_test_labels.npy\")\n",
+        "\n",
+        "train_dataset = CustomDataset(X_train, y_train)\n",
+        "test_dataset = CustomDataset(X_test, y_test)\n",
+        "\n",
+        "# Now use these with any PrivacyGuard attack:\n",
+        "# - LossAttack\n",
+        "# - LiRA (via create_shadow_datasets)\n",
+        "# - RMIA (via create_rmia_datasets)\n",
+        "```\n",
+        "\n",
+        "### Supported data types\n",
+        "\n",
+        "| Data Type | data shape | Model |\n",
+        "|-----------|------------|-------|\n",
+        "| Tabular (flat features) | `(n, d)` | `create_mlp_model(input_dim=d, ...)` |\n",
+        "| Images (grayscale) | `(n, 1, h, w)` | `create_model(num_classes=k, input_channels=1)` |\n",
+        "| Images (RGB) | `(n, 3, h, w)` | `create_model(num_classes=k, input_channels=3)` |\n",
+        "| Embeddings | `(n, embed_dim)` | `create_mlp_model(input_dim=embed_dim, ...)` |\n",
+        "\n",
+        "### Key properties\n",
+        "\n",
+        "- `dataset.num_classes` — number of unique labels\n",
+        "- `dataset.input_shape` — shape of a single sample (e.g., `(100,)` or `(3, 32, 32)`)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Conclusion\n",
+        "\n",
+        "In this tutorial we showed how to:\n",
+        "\n",
+        "1. **Wrap any data** in `CustomDataset` for use with PrivacyGuard\n",
+        "2. **Choose the right model**: `create_mlp_model` for tabular data, `create_model` for images\n",
+        "3. **Run LiRA** (online and offline) on custom data — no pipeline changes needed\n",
+        "4. **Analyze results** using `AnalysisNode` to measure accuracy, AUC, and epsilon\n",
+        "\n",
+        "### Key Takeaways\n",
+        "\n",
+        "- `CustomDataset` makes PrivacyGuard **dataset-agnostic** — you are not limited to CIFAR-10\n",
+        "- The same `create_shadow_datasets` and `create_rmia_datasets` functions work with any dataset\n",
+        "- Privacy risks exist for **all** types of models and data — not just image classifiers\n",
+        "\n",
+        "### Mitigating Privacy Risks\n",
+        "\n",
+        "If your audit reveals high epsilon or AUC values, consider:\n",
+        "\n",
+        "1. **Differential Privacy (DP-SGD)**: Train with provable privacy guarantees\n",
+        "2. **Regularization**: Stronger weight decay, dropout, or early stopping\n",
+        "3. **Reduce model capacity**: Smaller models memorize less\n",
+        "4. **More training data**: Larger datasets dilute individual influence"
+      ]
+    }
+  ],
+  "metadata": {
+    "fileHeader": "",
+    "fileUid": "7c8d43a8-ec1b-4d62-888e-d932f350b817",
+    "isAdHoc": false,
+    "kernelspec": {
+      "display_name": "PrivacyGuard",
+      "language": "python",
+      "name": "bento_kernel_privacy_guard"
+    },
+    "language_info": {
+      "name": "python",
+      "version": "3.12.0"
+    }
+  },
+  "nbformat": 4,
+  "nbformat_minor": 2
+}
diff --git a/tutorial_notebooks/loss_attack_tutorial.ipynb b/tutorial_notebooks/loss_attack_tutorial.ipynb
index d3a4cc3..89258ab 100644
--- a/tutorial_notebooks/loss_attack_tutorial.ipynb
+++ b/tutorial_notebooks/loss_attack_tutorial.ipynb
@@ -1,33 +1,14 @@
 {
-  "metadata": {
-    "kernelspec": {
-      "name": "python3",
-      "display_name": "python3",
-      "language": "python"
-    },
-    "language_info": {
-      "codemirror_mode": {
-        "name": "ipython",
-        "version": 3
-      },
-      "file_extension": ".py",
-      "mimetype": "text/x-python",
-      "name": "python",
-      "nbconvert_exporter": "python",
-      "pygments_lexer": "ipython3",
-      "version": "3.8.10"
-    }
-  },
   "cells": [
     {
       "cell_type": "markdown",
       "metadata": {
-        "originalKey": "4fdd2989-e840-4838-a27b-072e475d6e44",
-        "showInput": false,
-        "outputsInitialized": false,
         "bentoAICellStatus": "none",
+        "isCommentPanelOpen": false,
         "language": "markdown",
-        "isCommentPanelOpen": false
+        "originalKey": "4fdd2989-e840-4838-a27b-072e475d6e44",
+        "outputsInitialized": false,
+        "showInput": false
       },
       "source": [
         "# Loss-Based Membership Inference Attack with PrivacyGuard\n",
@@ -59,11 +40,11 @@
     {
       "cell_type": "markdown",
       "metadata": {
-        "originalKey": "057680be-3173-4e6a-8083-3a9e9e39fd79",
-        "outputsInitialized": false,
         "bentoAICellStatus": "none",
+        "isCommentPanelOpen": false,
         "language": "markdown",
-        "isCommentPanelOpen": false
+        "originalKey": "057680be-3173-4e6a-8083-3a9e9e39fd79",
+        "outputsInitialized": false
       },
       "source": [
         "## Environment Set-Up\n"
@@ -71,48 +52,45 @@
     },
     {
       "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
       "source": [
         "# Optionally create a conda environment for installing packages.\n",
         "# If executing from Google Colab, skip this step.\n",
         "!conda create -n privacy_guard python=3.12\n",
         "!conda activate privacy_guard\n"
-      ],
-      "metadata": {
-      },
-      "execution_count": null,
-      "outputs": []
+      ]
     },
     {
       "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
       "source": [
         "%cd /content\n",
         "!git clone https://github.com/facebookresearch/PrivacyGuard.git"
-      ],
-      "metadata": {
-      },
-      "execution_count": null,
-      "outputs": []
+      ]
     },
     {
       "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
       "source": [
         "%cd /content/PrivacyGuard\n",
         "!ls\n",
         "!pip install -e ."
-      ],
-      "metadata": {
-      },
-      "execution_count": null,
-      "outputs": []
+      ]
     },
     {
       "cell_type": "markdown",
       "metadata": {
-        "originalKey": "057680be-3173-4e6a-8083-3a9e9e39fd79",
-        "outputsInitialized": false,
         "bentoAICellStatus": "none",
+        "isCommentPanelOpen": false,
         "language": "markdown",
-        "isCommentPanelOpen": false
+        "originalKey": "057680be-3173-4e6a-8083-3a9e9e39fd79",
+        "outputsInitialized": false
       },
       "source": [
         "## Setup and Imports\n",
@@ -122,75 +100,71 @@
     },
     {
       "cell_type": "code",
+      "execution_count": null,
       "metadata": {
-        "originalKey": "7fcb0c99-deff-4f77-9342-07271c587fac",
-        "outputsInitialized": true,
         "bentoAICellStatus": "none",
-        "language": "python",
         "collapsed": false,
         "executionStartTime": 1758725193287,
         "executionStopTime": 1758725193411,
-        "serverExecutionDuration": 8.0242333933711,
+        "isCommentPanelOpen": false,
+        "language": "python",
+        "originalKey": "7fcb0c99-deff-4f77-9342-07271c587fac",
+        "outputsInitialized": true,
         "requestMsgId": "92419be1-5501-4eaf-9d15-cfde99bb0fb8",
-        "isCommentPanelOpen": false
+        "serverExecutionDuration": 8.0242333933711
       },
+      "outputs": [],
       "source": [
         "import numpy as np\n",
         "import torch\n",
         "import torch.nn as nn\n",
         "import torch.optim as optim\n",
-        "from torch.utils.data import DataLoader, TensorDataset\n",
+        "from torch.utils.data import DataLoader\n",
         "import matplotlib.pyplot as plt\n",
         "\n",
         "# Import Privacy Guard components\n",
         "from privacy_guard.attacks.loss_attack import LossAttack\n",
         "from privacy_guard.analysis.mia.analysis_node import AnalysisNode\n",
+        "from privacy_guard.shadow_model_training.dataset import CustomDataset\n",
         "\n",
         "# Set random seeds for reproducibility\n",
         "np.random.seed(42)\n",
         "torch.manual_seed(42)"
-      ],
-      "execution_count": 56,
-      "outputs": [
-        {
-          "output_type": "execute_result",
-          "data": {
-            "text/plain": "<torch._C.Generator at 0x7fa3846b3570>"
-          },
-          "metadata": {},
-          "execution_count": 56
-        }
       ]
     },
     {
       "cell_type": "markdown",
       "metadata": {
-        "originalKey": "36d14925-ea7a-4d6e-8026-dc1084e43c72",
-        "outputsInitialized": false,
         "bentoAICellStatus": "none",
+        "isCommentPanelOpen": false,
         "language": "markdown",
-        "isCommentPanelOpen": false
+        "originalKey": "36d14925-ea7a-4d6e-8026-dc1084e43c72",
+        "outputsInitialized": false
       },
       "source": [
         "## Generating Synthetic Data\n",
         "\n",
-        "We'll create a synthetic dataset for a binary classification problem using Gaussian distributions. This will serve as our example dataset for demonstrating the membership inference attack."
+        "We'll create a synthetic dataset for a classification problem using Gaussian distributions. This will serve as our example dataset for demonstrating the membership inference attack.\n",
+        "\n",
+        "We use `CustomDataset` to wrap our numpy arrays into a PyTorch-compatible dataset. `CustomDataset` accepts numpy arrays or PyTorch tensors and provides useful properties like `num_classes` and `input_shape`."
       ]
     },
     {
       "cell_type": "code",
+      "execution_count": 3,
       "metadata": {
-        "originalKey": "009e85dd-8e8e-4ec2-960d-6b28953a32fe",
-        "outputsInitialized": true,
         "bentoAICellStatus": "none",
-        "language": "python",
         "collapsed": false,
         "executionStartTime": 1758725513528,
         "executionStopTime": 1758725513896,
-        "serverExecutionDuration": 2.1753357723355,
+        "isCommentPanelOpen": false,
+        "language": "python",
+        "originalKey": "009e85dd-8e8e-4ec2-960d-6b28953a32fe",
+        "outputsInitialized": true,
         "requestMsgId": "af91b381-3d95-439b-97ac-bfae48e39d4c",
-        "isCommentPanelOpen": false
+        "serverExecutionDuration": 2.1753357723355
       },
+      "outputs": [],
       "source": [
         "# Define parameters for the Gaussian mixture\n",
         "n_class = 10  # Number of classes\n",
@@ -198,62 +172,65 @@
         "n_test = 50 * n_class   # Number of test samples\n",
         "sigma = 10  # Standard deviation of the Gaussian distributions\n",
         "d = 1000    # Dimensionality of the feature space"
-      ],
-      "execution_count": 77,
-      "outputs": []
+      ]
     },
     {
       "cell_type": "code",
+      "execution_count": 4,
       "metadata": {
-        "originalKey": "678bfe2d-b42b-4422-a60b-1a652ee85e20",
-        "showInput": true,
-        "customInput": null,
-        "language": "python",
-        "collapsed": false,
-        "outputsInitialized": true,
         "bentoAICellStatus": "none",
+        "collapsed": false,
+        "customInput": null,
         "executionStartTime": 1758725514962,
         "executionStopTime": 1758725515184,
-        "serverExecutionDuration": 13.965449295938,
+        "isCommentPanelOpen": false,
+        "language": "python",
+        "originalKey": "678bfe2d-b42b-4422-a60b-1a652ee85e20",
+        "output": {
+          "id": 1621776215409497,
+          "loadingStatus": "loaded"
+        },
+        "outputsInitialized": true,
         "requestMsgId": "485e41db-eda5-4352-bfe3-9d8882133bba",
-        "isCommentPanelOpen": false
+        "serverExecutionDuration": 13.965449295938,
+        "showInput": true
       },
-      "source": [
-        "# Generate training data\n",
-        "train_y = torch.arange(0, n_class).repeat_interleave(n_train // n_class)\n",
-        "class_centers = torch.randn(n_class, d)  # Random centers for each class\n",
-        "train_x = class_centers[train_y] + sigma * torch.randn(n_train, d)\n",
-        "\n",
-        "# Generate test data\n",
-        "test_y = torch.arange(0, n_class).repeat_interleave(n_test // n_class)\n",
-        "test_x = class_centers[test_y] + sigma * torch.randn(n_test, d)\n",
-        "\n",
-        "# Create datasets\n",
-        "trainset = TensorDataset(train_x, train_y)\n",
-        "testset = TensorDataset(test_x, test_y)\n",
-        "\n",
-        "print(f\"Training set shape: {train_x.shape}, {train_y.shape}\")\n",
-        "print(f\"Testing set shape: {test_x.shape}, {test_y.shape}\")"
-      ],
-      "execution_count": 78,
       "outputs": [
         {
-          "output_type": "stream",
           "name": "stdout",
+          "output_type": "stream",
           "text": [
-            "Training set shape: torch.Size([500, 1000]), torch.Size([500])\nTesting set shape: torch.Size([500, 1000]), torch.Size([500])\n"
+            "Training set: 500 samples, input_shape=torch.Size([1000])\n",
+            "Testing set:  500 samples, num_classes=10\n"
           ]
         }
+      ],
+      "source": [
+        "# Generate training data\n",
+        "train_y = np.arange(0, n_class).repeat(n_train // n_class)\n",
+        "class_centers = np.random.randn(n_class, d).astype(np.float32)\n",
+        "train_x = (class_centers[train_y] + sigma * np.random.randn(n_train, d)).astype(np.float32)\n",
+        "\n",
+        "# Generate test data\n",
+        "test_y = np.arange(0, n_class).repeat(n_test // n_class)\n",
+        "test_x = (class_centers[test_y] + sigma * np.random.randn(n_test, d)).astype(np.float32)\n",
+        "\n",
+        "# Create datasets using CustomDataset\n",
+        "trainset = CustomDataset(train_x, train_y)\n",
+        "testset = CustomDataset(test_x, test_y)\n",
+        "\n",
+        "print(f\"Training set: {len(trainset)} samples, input_shape={trainset.input_shape}\")\n",
+        "print(f\"Testing set:  {len(testset)} samples, num_classes={testset.num_classes}\")"
       ]
     },
     {
       "cell_type": "markdown",
       "metadata": {
-        "originalKey": "9127f8c4-17a9-4f70-b16c-d304d1b9287b",
-        "outputsInitialized": true,
         "bentoAICellStatus": "none",
+        "isCommentPanelOpen": false,
         "language": "markdown",
-        "isCommentPanelOpen": false
+        "originalKey": "9127f8c4-17a9-4f70-b16c-d304d1b9287b",
+        "outputsInitialized": true
       },
       "source": [
         "Let's visualize the first two dimensions of our data to get a sense of the separation between classes:"
@@ -261,18 +238,35 @@
     },
     {
       "cell_type": "code",
+      "execution_count": 5,
       "metadata": {
-        "originalKey": "1ceb3249-2997-4403-80f9-8e133ef18c52",
-        "outputsInitialized": true,
         "bentoAICellStatus": "none",
-        "language": "python",
         "collapsed": false,
         "executionStartTime": 1758725516476,
         "executionStopTime": 1758725516860,
-        "serverExecutionDuration": 176.33953783661,
+        "isCommentPanelOpen": false,
+        "language": "python",
+        "originalKey": "1ceb3249-2997-4403-80f9-8e133ef18c52",
+        "output": {
+          "id": 1607630650385320,
+          "loadingStatus": "loaded"
+        },
+        "outputsInitialized": true,
         "requestMsgId": "35dc9a57-0ec3-47aa-a481-26810657c01f",
-        "isCommentPanelOpen": false
+        "serverExecutionDuration": 176.33953783661
       },
+      "outputs": [
+        {
+          "data": {
+            "image/png": "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",
+            "text/plain": [
+              "<Figure size 1000x600 with 1 Axes>"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        }
+      ],
       "source": [
         "plt.figure(figsize=(10, 6))\n",
         "plt.scatter(train_x[train_y == 0, 0], train_x[train_y == 0, 1], alpha=0.5, label='Class 0 (Train)')\n",
@@ -283,51 +277,40 @@
         "plt.legend()\n",
         "plt.grid(True)\n",
         "plt.show()"
-      ],
-      "execution_count": 79,
-      "outputs": [
-        {
-          "output_type": "display_data",
-          "data": {
-            "text/plain": "<Figure size 1000x600 with 1 Axes>",
-            "image/png": "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"
-          },
-          "metadata": {}
-        }
       ]
     },
     {
       "cell_type": "code",
+      "execution_count": 6,
       "metadata": {
-        "originalKey": "0c41cc65-76b4-4ffa-92b6-a3607f1d6c71",
-        "showInput": true,
-        "customInput": null,
-        "language": "python",
-        "collapsed": false,
-        "outputsInitialized": true,
         "bentoAICellStatus": "none",
+        "collapsed": false,
+        "customInput": null,
         "executionStartTime": 1758725518351,
         "executionStopTime": 1758725518564,
-        "serverExecutionDuration": 1.9487915560603,
+        "isCommentPanelOpen": false,
+        "language": "python",
+        "originalKey": "0c41cc65-76b4-4ffa-92b6-a3607f1d6c71",
+        "outputsInitialized": true,
         "requestMsgId": "09e61618-9f0a-4851-8de3-76a20245220d",
-        "isCommentPanelOpen": false
+        "serverExecutionDuration": 1.9487915560603,
+        "showInput": true
       },
+      "outputs": [],
       "source": [
         "# Create data loaders\n",
         "train_loader = DataLoader(trainset, batch_size=64)\n",
         "test_loader = DataLoader(testset, batch_size=n_test)"
-      ],
-      "execution_count": 80,
-      "outputs": []
+      ]
     },
     {
       "cell_type": "markdown",
       "metadata": {
-        "originalKey": "78c4613d-c579-478b-a883-d10b4c2d923d",
-        "outputsInitialized": false,
         "bentoAICellStatus": "none",
+        "isCommentPanelOpen": false,
         "language": "markdown",
-        "isCommentPanelOpen": false
+        "originalKey": "78c4613d-c579-478b-a883-d10b4c2d923d",
+        "outputsInitialized": false
       },
       "source": [
         "## Training the Model\n",
@@ -337,18 +320,32 @@
     },
     {
       "cell_type": "code",
+      "execution_count": 7,
       "metadata": {
-        "originalKey": "e150cd7e-203b-426f-80b9-7dde2ca56ab5",
-        "outputsInitialized": true,
         "bentoAICellStatus": "none",
-        "language": "python",
         "collapsed": false,
         "executionStartTime": 1758725519645,
         "executionStopTime": 1758725519868,
-        "serverExecutionDuration": 20.54350450635,
+        "isCommentPanelOpen": false,
+        "language": "python",
+        "originalKey": "e150cd7e-203b-426f-80b9-7dde2ca56ab5",
+        "output": {
+          "id": 941399035069619,
+          "loadingStatus": "loaded"
+        },
+        "outputsInitialized": true,
         "requestMsgId": "025590c4-cb04-4fee-bbfd-6afa3916638d",
-        "isCommentPanelOpen": false
+        "serverExecutionDuration": 20.54350450635
       },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Linear(in_features=1000, out_features=10, bias=True)\n"
+          ]
+        }
+      ],
       "source": [
         "# Create a linear model\n",
         "model = nn.Linear(d, n_class)\n",
@@ -368,27 +365,17 @@
         "        loss.backward()\n",
         "        losses.append(loss.item())\n",
         "        optimizer.step()"
-      ],
-      "execution_count": 81,
-      "outputs": [
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "Linear(in_features=1000, out_features=10, bias=True)\n"
-          ]
-        }
       ]
     },
     {
       "cell_type": "markdown",
       "metadata": {
-        "originalKey": "a8a5cfc9-6ce4-4eff-a5c3-36af9ebd91ec",
-        "showInput": false,
-        "outputsInitialized": false,
         "bentoAICellStatus": "none",
+        "isCommentPanelOpen": false,
         "language": "markdown",
-        "isCommentPanelOpen": false
+        "originalKey": "a8a5cfc9-6ce4-4eff-a5c3-36af9ebd91ec",
+        "outputsInitialized": false,
+        "showInput": false
       },
       "source": [
         "Let's visualize the training loss over timesteps:"
@@ -396,46 +383,52 @@
     },
     {
       "cell_type": "code",
+      "execution_count": 8,
       "metadata": {
-        "originalKey": "9e278421-0819-4d64-9cc5-9e1f752ef570",
-        "outputsInitialized": true,
         "bentoAICellStatus": "none",
-        "language": "python",
         "collapsed": false,
         "executionStartTime": 1758725521483,
         "executionStopTime": 1758725521983,
-        "serverExecutionDuration": 207.32539240271,
+        "isCommentPanelOpen": false,
+        "language": "python",
+        "originalKey": "9e278421-0819-4d64-9cc5-9e1f752ef570",
+        "output": {
+          "id": 1476584064041336,
+          "loadingStatus": "loaded"
+        },
+        "outputsInitialized": true,
         "requestMsgId": "92fe24e1-5938-4602-967d-8923e5d1423c",
-        "isCommentPanelOpen": false
+        "serverExecutionDuration": 207.32539240271
       },
+      "outputs": [
+        {
+          "data": {
+            "image/png": "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",
+            "text/plain": [
+              "<Figure size 1500x1000 with 1 Axes>"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        }
+      ],
       "source": [
         "plt.plot(losses)\n",
         "plt.ylabel(\"Loss\")\n",
         "plt.xlabel(\"Step\")\n",
         "plt.title(\"Training Loss\")\n",
         "plt.show()"
-      ],
-      "execution_count": 82,
-      "outputs": [
-        {
-          "output_type": "display_data",
-          "data": {
-            "text/plain": "<Figure size 1500x1000 with 1 Axes>",
-            "image/png": "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"
-          },
-          "metadata": {}
-        }
       ]
     },
     {
       "cell_type": "markdown",
       "metadata": {
-        "originalKey": "14d13665-ce68-43da-87f0-5f32d314301d",
-        "outputsInitialized": false,
         "bentoAICellStatus": "none",
+        "isCommentPanelOpen": false,
         "language": "markdown",
-        "showInput": false,
-        "isCommentPanelOpen": false
+        "originalKey": "14d13665-ce68-43da-87f0-5f32d314301d",
+        "outputsInitialized": false,
+        "showInput": false
       },
       "source": [
         "## Performing a Loss-Based Membership Inference Attack\n",
@@ -453,20 +446,22 @@
     },
     {
       "cell_type": "code",
+      "execution_count": 9,
       "metadata": {
-        "originalKey": "3374066b-6487-4375-9f2d-5f56c08cb1f1",
-        "showInput": true,
+        "bentoAICellStatus": "none",
+        "collapsed": false,
         "customInput": null,
-        "language": "python",
         "executionStartTime": 1758725524133,
         "executionStopTime": 1758725524345,
-        "serverExecutionDuration": 2.3245392367244,
-        "collapsed": false,
-        "requestMsgId": "c909ed9f-e9d2-4ccb-8cfb-54f1797c876d",
+        "isCommentPanelOpen": false,
+        "language": "python",
+        "originalKey": "3374066b-6487-4375-9f2d-5f56c08cb1f1",
         "outputsInitialized": true,
-        "bentoAICellStatus": "none",
-        "isCommentPanelOpen": false
+        "requestMsgId": "c909ed9f-e9d2-4ccb-8cfb-54f1797c876d",
+        "serverExecutionDuration": 2.3245392367244,
+        "showInput": true
       },
+      "outputs": [],
       "source": [
         "# define the loss computation function\n",
         "@torch.no_grad()\n",
@@ -486,24 +481,36 @@
         "        losses += batch_losses.tolist()\n",
         "\n",
         "    return torch.Tensor(losses)"
-      ],
-      "execution_count": 83,
-      "outputs": []
+      ]
     },
     {
       "cell_type": "code",
+      "execution_count": 10,
       "metadata": {
-        "originalKey": "ec8d985c-9185-497d-97b4-74eda744d745",
-        "outputsInitialized": true,
         "bentoAICellStatus": "none",
-        "language": "python",
         "collapsed": false,
         "executionStartTime": 1758725525109,
         "executionStopTime": 1758725525335,
-        "serverExecutionDuration": 15.467686578631,
+        "isCommentPanelOpen": false,
+        "language": "python",
+        "originalKey": "ec8d985c-9185-497d-97b4-74eda744d745",
+        "output": {
+          "id": 2456498724781870,
+          "loadingStatus": "loaded"
+        },
+        "outputsInitialized": true,
         "requestMsgId": "5eecc7e9-627f-4f3b-949b-364cb2686da2",
-        "isCommentPanelOpen": false
+        "serverExecutionDuration": 15.467686578631
       },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Attack results shape - Train: (500, 2), Test: (500, 2)\n"
+          ]
+        }
+      ],
       "source": [
         "# Perform the loss-based membership inference attack\n",
         "loss_attack = LossAttack(\n",
@@ -517,26 +524,16 @@
         "attack_results = loss_attack.run_attack()\n",
         "\n",
         "print(f\"Attack results shape - Train: {attack_results.df_train_user.shape}, Test: {attack_results.df_test_user.shape}\")"
-      ],
-      "execution_count": 84,
-      "outputs": [
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "Attack results shape - Train: (500, 2), Test: (500, 2)\n"
-          ]
-        }
       ]
     },
     {
       "cell_type": "markdown",
       "metadata": {
-        "originalKey": "9f3dbfbb-7355-4062-bcb0-1d31fdb7254b",
-        "outputsInitialized": false,
         "bentoAICellStatus": "none",
+        "isCommentPanelOpen": false,
         "language": "markdown",
-        "isCommentPanelOpen": false
+        "originalKey": "9f3dbfbb-7355-4062-bcb0-1d31fdb7254b",
+        "outputsInitialized": false
       },
       "source": [
         "Let's visualize the distribution of scores (negative loss values) for the training and testing data:"
@@ -544,18 +541,35 @@
     },
     {
       "cell_type": "code",
+      "execution_count": 11,
       "metadata": {
-        "originalKey": "0dc1831e-792f-4ecc-bb78-3d169bea9379",
-        "outputsInitialized": true,
         "bentoAICellStatus": "none",
-        "language": "python",
         "collapsed": false,
         "executionStartTime": 1758725526254,
         "executionStopTime": 1758725526795,
-        "serverExecutionDuration": 315.22748433053,
+        "isCommentPanelOpen": false,
+        "language": "python",
+        "originalKey": "0dc1831e-792f-4ecc-bb78-3d169bea9379",
+        "output": {
+          "id": 1426400592500552,
+          "loadingStatus": "loaded"
+        },
+        "outputsInitialized": true,
         "requestMsgId": "d995ad47-d57a-4e8a-aaf9-bb566cdbaaa3",
-        "isCommentPanelOpen": false
+        "serverExecutionDuration": 315.22748433053
       },
+      "outputs": [
+        {
+          "data": {
+            "image/png": "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",
+            "text/plain": [
+              "<Figure size 1000x600 with 1 Axes>"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        }
+      ],
       "source": [
         "plt.figure(figsize=(10, 6))\n",
         "\n",
@@ -573,29 +587,18 @@
         "plt.legend()\n",
         "plt.grid(True)\n",
         "plt.show()"
-      ],
-      "execution_count": 85,
-      "outputs": [
-        {
-          "output_type": "display_data",
-          "data": {
-            "text/plain": "<Figure size 1000x600 with 1 Axes>",
-            "image/png": "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"
-          },
-          "metadata": {}
-        }
       ]
     },
     {
       "cell_type": "markdown",
       "metadata": {
-        "originalKey": "2d36bd91-65a4-40f2-9728-5386b28009a6",
-        "showInput": false,
+        "bentoAICellStatus": "none",
         "customInput": null,
+        "isCommentPanelOpen": false,
         "language": "markdown",
+        "originalKey": "2d36bd91-65a4-40f2-9728-5386b28009a6",
         "outputsInitialized": false,
-        "bentoAICellStatus": "none",
-        "isCommentPanelOpen": false
+        "showInput": false
       },
       "source": [
         "We see that it is easy to separate the members from non-members using a threshold."
@@ -604,12 +607,12 @@
     {
       "cell_type": "markdown",
       "metadata": {
-        "originalKey": "d6e0b2ae-36e5-419d-951e-817947a66f68",
-        "outputsInitialized": false,
         "bentoAICellStatus": "none",
+        "isCommentPanelOpen": false,
         "language": "markdown",
-        "showInput": false,
-        "isCommentPanelOpen": false
+        "originalKey": "d6e0b2ae-36e5-419d-951e-817947a66f68",
+        "outputsInitialized": false,
+        "showInput": false
       },
       "source": [
         "## Analyzing the Attack Results with AnalysisNode\n",
@@ -619,18 +622,46 @@
     },
     {
       "cell_type": "code",
+      "execution_count": 12,
       "metadata": {
-        "originalKey": "212cfdcc-22da-4299-a2c0-c4e33cc45d87",
-        "outputsInitialized": true,
         "bentoAICellStatus": "none",
-        "language": "python",
         "collapsed": false,
         "executionStartTime": 1758725661493,
         "executionStopTime": 1758725674847,
-        "serverExecutionDuration": 13203.19633279,
+        "isCommentPanelOpen": false,
+        "language": "python",
+        "originalKey": "212cfdcc-22da-4299-a2c0-c4e33cc45d87",
+        "output": {
+          "id": 25930715883221710,
+          "loadingStatus": "loaded"
+        },
+        "outputsInitialized": true,
         "requestMsgId": "c3c417f3-4eec-426a-b0ed-7ab66e764791",
-        "isCommentPanelOpen": false
+        "serverExecutionDuration": 13203.19633279
       },
+      "outputs": [
+        {
+          "name": "stderr",
+          "output_type": "stream",
+          "text": [
+            "I0303 113642.598 analysis_node.py:303] Train/Test unique users: 500/500\n",
+            "I0303 113642.612 mia_results.py:193] TNR: 0.38, FNR: 0.004, emp eps: 2.67212, tnr@fnr0.001: 0.248, eps@fnr0.001: 0.20307, auc 0.79067 accuracy 0.778, \n",
+            "I0303 113642.612 analysis_node.py:310] Epsilon CP: 2.67211924951516\n",
+            "\r  0%|          | 0/10000 [00:00<?, ?it/s]\r  1%|          | 110/10000 [00:00<00:08, 1099.36it/s]\r  2%|▏         | 222/10000 [00:00<00:08, 1108.73it/s]\r  3%|▎         | 336/10000 [00:00<00:08, 1120.36it/s]\r  4%|▍         | 449/10000 [00:00<00:08, 1117.44it/s]\r  6%|▌         | 561/10000 [00:00<00:08, 1116.75it/s]\r  7%|▋         | 673/10000 [00:00<00:08, 1111.49it/s]\r  8%|▊         | 785/10000 [00:00<00:08, 1109.52it/s]\r  9%|▉         | 897/10000 [00:00<00:08, 1111.68it/s]\r 10%|█         | 1009/10000 [00:00<00:08, 1110.43it/s]\r 11%|█         | 1121/10000 [00:01<00:07, 1112.23it/s]\r 12%|█▏        | 1233/10000 [00:01<00:07, 1113.72it/s]\r 13%|█▎        | 1346/10000 [00:01<00:07, 1117.22it/s]\r 15%|█▍        | 1458/10000 [00:01<00:07, 1116.40it/s]\r 16%|█▌        | 1571/10000 [00:01<00:07, 1117.60it/s]\r 17%|█▋        | 1683/10000 [00:01<00:07, 1114.17it/s]\r 18%|█▊        | 1795/10000 [00:01<00:07, 1108.68it/s]\r 19%|█▉        | 1907/10000 [00:01<00:07, 1111.24it/s]\r 20%|██        | 2020/10000 [00:01<00:07, 1114.74it/s]\r 21%|██▏       | 2132/10000 [00:01<00:07, 1111.09it/s]\r 22%|██▏       | 2245/10000 [00:02<00:06, 1114.68it/s]\r 24%|██▎       | 2358/10000 [00:02<00:06, 1117.17it/s]\r 25%|██▍       | 2470/10000 [00:02<00:06, 1115.06it/s]\r 26%|██▌       | 2582/10000 [00:02<00:06, 1114.86it/s]\r 27%|██▋       | 2694/10000 [00:02<00:06, 1113.35it/s]\r 28%|██▊       | 2806/10000 [00:02<00:06, 1110.84it/s]\r 29%|██▉       | 2918/10000 [00:02<00:06, 1111.05it/s]\r 30%|███       | 3030/10000 [00:02<00:06, 1112.77it/s]\r 31%|███▏      | 3142/10000 [00:02<00:06, 1113.00it/s]\r 33%|███▎      | 3254/10000 [00:02<00:06, 1112.55it/s]\r 34%|███▎      | 3366/10000 [00:03<00:05, 1114.31it/s]\r 35%|███▍      | 3478/10000 [00:03<00:05, 1113.27it/s]\r 36%|███▌      | 3590/10000 [00:03<00:05, 1103.49it/s]\r 37%|███▋      | 3702/10000 [00:03<00:05, 1105.96it/s]\r 38%|███▊      | 3813/10000 [00:03<00:05, 1106.44it/s]\r 39%|███▉      | 3925/10000 [00:03<00:05, 1109.82it/s]\r 40%|████      | 4036/10000 [00:03<00:05, 1108.76it/s]\r 41%|████▏     | 4148/10000 [00:03<00:05, 1110.40it/s]\r 43%|████▎     | 4260/10000 [00:03<00:05, 1109.55it/s]\r 44%|████▎     | 4371/10000 [00:03<00:05, 1105.54it/s]\r 45%|████▍     | 4483/10000 [00:04<00:04, 1107.77it/s]\r 46%|████▌     | 4595/10000 [00:04<00:04, 1109.50it/s]\r 47%|████▋     | 4707/10000 [00:04<00:04, 1112.17it/s]\r 48%|████▊     | 4819/10000 [00:04<00:04, 1113.70it/s]\r 49%|████▉     | 4931/10000 [00:04<00:04, 1107.95it/s]\r 50%|█████     | 5043/10000 [00:04<00:04, 1109.79it/s]\r 52%|█████▏    | 5155/10000 [00:04<00:04, 1110.59it/s]\r 53%|█████▎    | 5267/10000 [00:04<00:04, 1111.47it/s]\r 54%|█████▍    | 5379/10000 [00:04<00:04, 1112.95it/s]\r 55%|█████▍    | 5491/10000 [00:04<00:04, 1112.83it/s]\r 56%|█████▌    | 5603/10000 [00:05<00:03, 1112.07it/s]\r 57%|█████▋    | 5715/10000 [00:05<00:03, 1113.37it/s]\r 58%|█████▊    | 5827/10000 [00:05<00:03, 1113.38it/s]\r 59%|█████▉    | 5939/10000 [00:05<00:03, 1112.71it/s]\r 61%|██████    | 6051/10000 [00:05<00:03, 1110.57it/s]\r 62%|██████▏   | 6163/10000 [00:05<00:03, 1109.69it/s]\r 63%|██████▎   | 6274/10000 [00:05<00:03, 1106.81it/s]\r 64%|██████▍   | 6385/10000 [00:05<00:03, 1107.46it/s]\r 65%|██████▍   | 6496/10000 [00:05<00:03, 1103.77it/s]\r 66%|██████▌   | 6608/10000 [00:05<00:03, 1107.29it/s]\r 67%|██████▋   | 6719/10000 [00:06<00:02, 1099.38it/s]\r 68%|██████▊   | 6829/10000 [00:06<00:02, 1097.14it/s]\r 69%|██████▉   | 6941/10000 [00:06<00:02, 1103.93it/s]\r 71%|███████   | 7052/10000 [00:06<00:02, 1105.25it/s]\r 72%|███████▏  | 7163/10000 [00:06<00:02, 1104.80it/s]\r 73%|███████▎  | 7275/10000 [00:06<00:02, 1106.48it/s]\r 74%|███████▍  | 7386/10000 [00:06<00:02, 1106.04it/s]\r 75%|███████▍  | 7497/10000 [00:06<00:02, 1106.13it/s]\r 76%|███████▌  | 7609/10000 [00:06<00:02, 1110.25it/s]\r 77%|███████▋  | 7721/10000 [00:06<00:02, 1105.70it/s]\r 78%|███████▊  | 7833/10000 [00:07<00:01, 1107.57it/s]\r 79%|███████▉  | 7945/10000 [00:07<00:01, 1110.37it/s]\r 81%|████████  | 8057/10000 [00:07<00:01, 1104.92it/s]\r 82%|████████▏ | 8168/10000 [00:07<00:01, 1103.31it/s]\r 83%|████████▎ | 8279/10000 [00:07<00:01, 1092.69it/s]\r 84%|████████▍ | 8389/10000 [00:07<00:01, 1091.40it/s]\r 85%|████████▍ | 8499/10000 [00:07<00:01, 1088.86it/s]\r 86%|████████▌ | 8608/10000 [00:07<00:01, 1083.20it/s]\r 87%|████████▋ | 8718/10000 [00:07<00:01, 1086.06it/s]\r 88%|████████▊ | 8828/10000 [00:07<00:01, 1088.61it/s]\r 89%|████████▉ | 8938/10000 [00:08<00:00, 1091.65it/s]\r 90%|█████████ | 9049/10000 [00:08<00:00, 1095.38it/s]\r 92%|█████████▏| 9160/10000 [00:08<00:00, 1096.66it/s]\r 93%|█████████▎| 9271/10000 [00:08<00:00, 1099.29it/s]\r 94%|█████████▍| 9381/10000 [00:08<00:00, 1098.41it/s]\r 95%|█████████▍| 9492/10000 [00:08<00:00, 1101.01it/s]\r 96%|█████████▌| 9603/10000 [00:08<00:00, 1101.96it/s]\r 97%|█████████▋| 9716/10000 [00:08<00:00, 1108.46it/s]\r 98%|█████████▊| 9829/10000 [00:08<00:00, 1113.25it/s]\r 99%|█████████▉| 9943/10000 [00:08<00:00, 1118.77it/s]\r100%|██████████| 10000/10000 [00:09<00:00, 1108.06it/s]\n"
+          ]
+        },
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Attack Accuracy: 0.7341 (95% CI: [0.7110, 0.7570])\n",
+            "Attack AUC: 0.7385 (95% CI: [0.7152, 0.7617])\n",
+            "Privacy Leakage (Epsilon): 0.7538\n",
+            "Epsilon at 1% TPR (Upper Bound): 0.753762\n",
+            "Epsilon at 1% TPR (Lower Bound): 0.573534\n"
+          ]
+        }
+      ],
       "source": [
         "# Create a AnalysisNode\n",
         "analysis_node = AnalysisNode(\n",
@@ -651,68 +682,15 @@
         "print(f\"Privacy Leakage (Epsilon): {analysis_results.eps:.4f}\")\n",
         "print(f\"Epsilon at 1% TPR (Upper Bound): {analysis_results.eps_tpr_ub[0]:.6f}\")\n",
         "print(f\"Epsilon at 1% TPR (Lower Bound): {analysis_results.eps_tpr_lb[0]:.6f}\")"
-      ],
-      "execution_count": 96,
-      "outputs": [
-        {
-          "output_type": "stream",
-          "name": "stderr",
-          "text": [
-            "I0924 075421.657 analysis_node.py:217] Train/Test unique users: 500/500\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stderr",
-          "text": [
-            "I0924 075421.673 mia_results.py:187] TNR: 0.284, FNR: 0.0, emp eps: 2.74927, tnr@fnr0.001: 0.284, eps@fnr0.001: 0.24525, auc 0.78407 accuracy 0.776, \n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stderr",
-          "text": [
-            "I0924 075421.673 analysis_node.py:224] Epsilon CP: 2.7492718213052085\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stderr",
-          "text": [
-            "\r  0%|          | 0/10000 [00:00<?, ?it/s]",
-            "\r  1%|          | 79/10000 [00:00<00:12, 783.37it/s]",
-            "\r  2%|▏         | 158/10000 [00:00<00:12, 780.74it/s]",
-            "\r  2%|▏         | 237/10000 [00:00<00:12, 773.47it/s]",
-            "\r  3%|▎         | 315/10000 [00:00<00:12, 771.88it/s]",
-            "\r  4%|▍         | 394/10000 [00:00<00:12, 776.97it/s]",
-            "\r  5%|▍         | 472/10000 [00:00<00:12, 777.42it/s]",
-            "\r  ......",
-            "\r  ......",
-            "\r 96%|█████████▋| 9627/10000 [00:12<00:00, 783.18it/s]",
-            "\r 97%|█████████▋| 9706/10000 [00:12<00:00, 784.50it/s]",
-            "\r 98%|█████████▊| 9785/10000 [00:12<00:00, 782.78it/s]",
-            "\r 99%|█████████▊| 9864/10000 [00:12<00:00, 782.54it/s]",
-            "\r 99%|█████████▉| 9943/10000 [00:12<00:00, 776.47it/s]",
-            "\r100%|██████████| 10000/10000 [00:12<00:00, 779.72it/s]",
-            "\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "Attack Accuracy: 0.7650 (95% CI: [0.7420, 0.7880])\nAttack AUC: 0.7688 (95% CI: [0.7455, 0.7917])\nPrivacy Leakage (Epsilon): 0.8990\nEpsilon at 1% TPR (Upper Bound): 0.899047\nEpsilon at 1% TPR (Lower Bound): 0.695227\n"
-          ]
-        }
       ]
     },
     {
       "cell_type": "markdown",
       "metadata": {
-        "originalKey": "98dec467-57a3-4f30-a812-48f823fe96f5",
-        "showInput": false,
         "customInput": null,
-        "language": "markdown"
+        "language": "markdown",
+        "originalKey": "98dec467-57a3-4f30-a812-48f823fe96f5",
+        "showInput": false
       },
       "source": [
         "In the above, we set the adversary's error rate to be 1% TPR, and find a score threshold that corresonds to a 1% TPR. Using that score threshold, the adversary outputs its \"member\" versus \"non-member\" guesses. We iterate over error thresholds [1%, 2%, ..., 100%]. We can additionally compute score thresholds using TNR, FNR, and TPR errors. The eps_max entry in the output gives the maximum epsilon over all such error types at different error thresholds. When considering all error types, we obtain an even higher epsilon. Epsilon values are capped at $ln(n)$. We obtain empirical epsilon of $\\ln(n)$ due to the strong separation between scores.  "
@@ -720,42 +698,47 @@
     },
     {
       "cell_type": "code",
+      "execution_count": 13,
       "metadata": {
-        "originalKey": "b8bf2c7c-6206-4457-9e3d-038fb9024243",
-        "showInput": true,
+        "collapsed": false,
         "customInput": null,
-        "language": "python",
         "executionStartTime": 1758725867542,
         "executionStopTime": 1758725867685,
-        "serverExecutionDuration": 2.1838694810867,
-        "collapsed": false,
+        "language": "python",
+        "originalKey": "b8bf2c7c-6206-4457-9e3d-038fb9024243",
+        "output": {
+          "id": 1121519690077898,
+          "loadingStatus": "loaded"
+        },
+        "outputsInitialized": true,
         "requestMsgId": "7a663f9f-7a47-44e8-bc29-b45ab5cf14fd",
-        "outputsInitialized": true
+        "serverExecutionDuration": 2.1838694810867,
+        "showInput": true
       },
-      "source": [
-        "print(f\"Epsilon at 1% error rate (Upper Bound): {analysis_results.eps_max_ub[0]:.6f}\")\n",
-        "print(f\"Epsilon at 1% error rate (Lower Bound): {analysis_results.eps_max_lb[0]:.6f}\")"
-      ],
-      "execution_count": 98,
       "outputs": [
         {
-          "output_type": "stream",
           "name": "stdout",
+          "output_type": "stream",
           "text": [
-            "Epsilon at 1% error rate (Upper Bound): 6.214608\nEpsilon at 1% error rate (Lower Bound): 6.214608\n"
+            "Epsilon at 1% error rate (Upper Bound): 6.214608\n",
+            "Epsilon at 1% error rate (Lower Bound): 6.214608\n"
           ]
         }
+      ],
+      "source": [
+        "print(f\"Epsilon at 1% error rate (Upper Bound): {analysis_results.eps_max_ub[0]:.6f}\")\n",
+        "print(f\"Epsilon at 1% error rate (Lower Bound): {analysis_results.eps_max_lb[0]:.6f}\")"
       ]
     },
     {
       "cell_type": "markdown",
       "metadata": {
-        "originalKey": "2934b671-fe7a-4037-a73c-e11e88c97fbd",
-        "outputsInitialized": false,
         "bentoAICellStatus": "none",
+        "isCommentPanelOpen": false,
         "language": "markdown",
-        "showInput": false,
-        "isCommentPanelOpen": false
+        "originalKey": "2934b671-fe7a-4037-a73c-e11e88c97fbd",
+        "outputsInitialized": false,
+        "showInput": false
       },
       "source": [
         "## Interpreting the Results\n",
@@ -791,6 +774,28 @@
       ]
     }
   ],
+  "metadata": {
+    "fileHeader": "",
+    "fileUid": "40b909a3-9539-4f01-adf1-1a06524d01f3",
+    "isAdHoc": false,
+    "kernelspec": {
+      "display_name": "PrivacyGuard",
+      "language": "python",
+      "name": "bento_kernel_privacy_guard"
+    },
+    "language_info": {
+      "codemirror_mode": {
+        "name": "ipython",
+        "version": 3
+      },
+      "file_extension": ".py",
+      "mimetype": "text/x-python",
+      "name": "python",
+      "nbconvert_exporter": "python",
+      "pygments_lexer": "ipython3",
+      "version": "3.8.10"
+    }
+  },
   "nbformat": 4,
-  "nbformat_minor": 5
+  "nbformat_minor": 2
 }