{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Monotonic Health Score" ] }, { "cell_type": "markdown", "metadata": { "id": "eX2YY8tp5yyk", "tags": [ "hide-cell" ] }, "source": [ "## Prerequisites" ] }, { "cell_type": "markdown", "metadata": { "id": "qEcvoHx-KoFS", "tags": [ "hide-cell" ] }, "source": [ "Add the Congrads package to the current Colab notebook environment and install it." ] }, { "cell_type": "code", "execution_count": 23, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "executionInfo": { "elapsed": 6127, "status": "ok", "timestamp": 1769501894569, "user": { "displayName": "Wout Rombouts", "userId": "06394371526548571555" }, "user_tz": -60 }, "id": "8KHH-VPLoPbu", "tags": [ "hide-cell" ], "outputId": "77e194aa-a093-4388-f92e-b35edaf26363" }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Requirement already satisfied: congrads==0.3.0 in /usr/local/lib/python3.12/dist-packages (from congrads[examples]==0.3.0) (0.3.0)\n", "Requirement already satisfied: numpy>=1.24.0 in /usr/local/lib/python3.12/dist-packages (from congrads==0.3.0->congrads[examples]==0.3.0) (2.0.2)\n", "Requirement already satisfied: pandas>=1.5.0 in /usr/local/lib/python3.12/dist-packages (from congrads==0.3.0->congrads[examples]==0.3.0) (2.2.2)\n", "Requirement already satisfied: torch>=2.0.0 in /usr/local/lib/python3.12/dist-packages (from congrads==0.3.0->congrads[examples]==0.3.0) (2.9.0+cpu)\n", "Requirement already satisfied: torchvision>=0.15.1 in /usr/local/lib/python3.12/dist-packages (from congrads==0.3.0->congrads[examples]==0.3.0) (0.24.0+cpu)\n", "Requirement already satisfied: tqdm>=4.65.0 in /usr/local/lib/python3.12/dist-packages (from congrads==0.3.0->congrads[examples]==0.3.0) (4.67.1)\n", "Requirement already satisfied: matplotlib>=3.7.0 in /usr/local/lib/python3.12/dist-packages (from congrads[examples]==0.3.0) (3.10.0)\n", "Requirement already satisfied: tensorboard>=2.18.0 in /usr/local/lib/python3.12/dist-packages (from congrads[examples]==0.3.0) (2.19.0)\n", "Requirement already satisfied: contourpy>=1.0.1 in /usr/local/lib/python3.12/dist-packages (from matplotlib>=3.7.0->congrads[examples]==0.3.0) (1.3.3)\n", "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.12/dist-packages (from matplotlib>=3.7.0->congrads[examples]==0.3.0) (0.12.1)\n", "Requirement already satisfied: fonttools>=4.22.0 in /usr/local/lib/python3.12/dist-packages (from matplotlib>=3.7.0->congrads[examples]==0.3.0) (4.61.1)\n", "Requirement already satisfied: kiwisolver>=1.3.1 in /usr/local/lib/python3.12/dist-packages (from matplotlib>=3.7.0->congrads[examples]==0.3.0) (1.4.9)\n", "Requirement already satisfied: packaging>=20.0 in /usr/local/lib/python3.12/dist-packages (from matplotlib>=3.7.0->congrads[examples]==0.3.0) (25.0)\n", "Requirement already satisfied: pillow>=8 in /usr/local/lib/python3.12/dist-packages (from matplotlib>=3.7.0->congrads[examples]==0.3.0) (11.3.0)\n", "Requirement already satisfied: pyparsing>=2.3.1 in /usr/local/lib/python3.12/dist-packages (from matplotlib>=3.7.0->congrads[examples]==0.3.0) (3.3.1)\n", "Requirement already satisfied: python-dateutil>=2.7 in /usr/local/lib/python3.12/dist-packages (from matplotlib>=3.7.0->congrads[examples]==0.3.0) (2.9.0.post0)\n", "Requirement already satisfied: pytz>=2020.1 in /usr/local/lib/python3.12/dist-packages (from pandas>=1.5.0->congrads==0.3.0->congrads[examples]==0.3.0) (2025.2)\n", "Requirement already satisfied: tzdata>=2022.7 in /usr/local/lib/python3.12/dist-packages (from pandas>=1.5.0->congrads==0.3.0->congrads[examples]==0.3.0) (2025.3)\n", "Requirement already satisfied: absl-py>=0.4 in /usr/local/lib/python3.12/dist-packages (from tensorboard>=2.18.0->congrads[examples]==0.3.0) (1.4.0)\n", "Requirement already satisfied: grpcio>=1.48.2 in /usr/local/lib/python3.12/dist-packages (from tensorboard>=2.18.0->congrads[examples]==0.3.0) (1.76.0)\n", "Requirement already satisfied: markdown>=2.6.8 in /usr/local/lib/python3.12/dist-packages (from tensorboard>=2.18.0->congrads[examples]==0.3.0) (3.10)\n", "Requirement already satisfied: protobuf!=4.24.0,>=3.19.6 in /usr/local/lib/python3.12/dist-packages (from tensorboard>=2.18.0->congrads[examples]==0.3.0) (5.29.5)\n", "Requirement already satisfied: setuptools>=41.0.0 in /usr/local/lib/python3.12/dist-packages (from tensorboard>=2.18.0->congrads[examples]==0.3.0) (75.2.0)\n", "Requirement already satisfied: six>1.9 in /usr/local/lib/python3.12/dist-packages (from tensorboard>=2.18.0->congrads[examples]==0.3.0) (1.17.0)\n", "Requirement already satisfied: tensorboard-data-server<0.8.0,>=0.7.0 in /usr/local/lib/python3.12/dist-packages (from tensorboard>=2.18.0->congrads[examples]==0.3.0) (0.7.2)\n", "Requirement already satisfied: werkzeug>=1.0.1 in /usr/local/lib/python3.12/dist-packages (from tensorboard>=2.18.0->congrads[examples]==0.3.0) (3.1.5)\n", "Requirement already satisfied: filelock in /usr/local/lib/python3.12/dist-packages (from torch>=2.0.0->congrads==0.3.0->congrads[examples]==0.3.0) (3.20.3)\n", "Requirement already satisfied: typing-extensions>=4.10.0 in /usr/local/lib/python3.12/dist-packages (from torch>=2.0.0->congrads==0.3.0->congrads[examples]==0.3.0) (4.15.0)\n", "Requirement already satisfied: sympy>=1.13.3 in /usr/local/lib/python3.12/dist-packages (from torch>=2.0.0->congrads==0.3.0->congrads[examples]==0.3.0) (1.14.0)\n", "Requirement already satisfied: networkx>=2.5.1 in /usr/local/lib/python3.12/dist-packages (from torch>=2.0.0->congrads==0.3.0->congrads[examples]==0.3.0) (3.6.1)\n", "Requirement already satisfied: jinja2 in /usr/local/lib/python3.12/dist-packages (from torch>=2.0.0->congrads==0.3.0->congrads[examples]==0.3.0) (3.1.6)\n", "Requirement already satisfied: fsspec>=0.8.5 in /usr/local/lib/python3.12/dist-packages (from torch>=2.0.0->congrads==0.3.0->congrads[examples]==0.3.0) (2025.3.0)\n", "Requirement already satisfied: mpmath<1.4,>=1.1.0 in /usr/local/lib/python3.12/dist-packages (from sympy>=1.13.3->torch>=2.0.0->congrads==0.3.0->congrads[examples]==0.3.0) (1.3.0)\n", "Requirement already satisfied: markupsafe>=2.1.1 in /usr/local/lib/python3.12/dist-packages (from werkzeug>=1.0.1->tensorboard>=2.18.0->congrads[examples]==0.3.0) (3.0.3)\n" ] } ], "source": [ "!pip install \"congrads[examples]==0.3.0\"" ] }, { "cell_type": "markdown", "metadata": { "id": "LY7X9YeGKtHJ", "tags": [ "hide-cell" ] }, "source": [ "Import the necesary functions and classes." ] }, { "cell_type": "code", "execution_count": 24, "metadata": { "executionInfo": { "elapsed": 16, "status": "ok", "timestamp": 1769501894587, "user": { "displayName": "Wout Rombouts", "userId": "06394371526548571555" }, "user_tz": -60 }, "id": "SZG3La4arXFL", "tags": [ "hide-cell" ] }, "outputs": [], "source": [ "import torch\n", "import random\n", "from collections import defaultdict\n", "from matplotlib import pyplot as plt\n", "from torch.nn import MSELoss, Module\n", "from torch.optim import Adam\n", "from torch.utils.data import DataLoader, Dataset, Subset\n", "from IPython.display import clear_output\n", "\n", "from congrads.callbacks.base import Callback, CallbackManager\n", "from congrads.constraints.base import Constraint\n", "from congrads.constraints.registry import (\n", " BinaryConstraint,\n", " PerGroupMonotonicityConstraint,\n", " RankedMonotonicityConstraint,\n", " ImplicationConstraint,\n", " ScalarConstraint,\n", ")\n", "from congrads.core.congradscore import CongradsCore\n", "from congrads.datasets.registry import SectionedGaussians\n", "from congrads.descriptor import Descriptor\n", "from congrads.metrics import MetricManager\n", "from congrads.networks.registry import MLPNetwork\n", "from congrads.utils.utility import (\n", " CSVLogger,\n", " Seeder,\n", " ZeroLoss,\n", ")" ] }, { "cell_type": "markdown", "metadata": { "id": "hD3WtPpIKw3H", "tags": [ "hide-cell" ] }, "source": [ "Define utility functions for plotting and other." ] }, { "cell_type": "code", "execution_count": 25, "metadata": { "executionInfo": { "elapsed": 28, "status": "ok", "timestamp": 1769501894627, "user": { "displayName": "Wout Rombouts", "userId": "06394371526548571555" }, "user_tz": -60 }, "id": "JWNIkGIUKdYj", "tags": [ "hide-cell" ] }, "outputs": [], "source": [ "def get_all_data(subset):\n", " \"\"\"Extract and stack all data from a PyTorch Dataset or Subset that returns dictionaries of tensors (with matching shapes).\n", "\n", " Args:\n", " subset (torch.utils.data.Subset or Dataset): Dataset or subset to extract from.\n", "\n", " Returns:\n", " dict[str, torch.Tensor]: Dictionary with each key stacked along dimension 0.\n", " \"\"\"\n", " if isinstance(subset, Subset):\n", " dataset, indices = subset.dataset, subset.indices\n", " samples = [dataset[i] for i in indices]\n", " else:\n", " samples = [subset[i] for i in range(len(subset))]\n", "\n", " return {key: torch.stack([s[key] for s in samples]) for key in samples[0].keys()}\n", "\n", "\n", "def plot_regression_epoch(\n", " descriptor: Descriptor,\n", " network: Module,\n", " loaders: tuple[DataLoader, DataLoader, DataLoader],\n", " device: torch.device,\n", "):\n", " \"\"\"Plot model predictions versus signal for training and test waveforms.\n", "\n", " Args:\n", " descriptor (Descriptor): Descriptor for selecting fields from datasets.\n", " network (Module): Neural network model.\n", " loaders (tuple): Tuple of (train_loader, val_loader, test_loader).\n", " device (torch.device): Device to run the model on (e.g., torch.device(\"cuda\")).\n", " \"\"\"\n", " train_loader, _, test_loader = loaders\n", " train_data = get_all_data(train_loader.dataset)\n", " test_data = get_all_data(test_loader.dataset)\n", "\n", " fig, ax_pred = plt.subplots(figsize=(6, 4))\n", " ax_signal = ax_pred.twinx()\n", "\n", " # Ensure prediction axis overlays signal axis\n", " ax_pred.set_zorder(ax_signal.get_zorder() + 1)\n", " ax_pred.patch.set_visible(False)\n", "\n", " network.eval()\n", "\n", " # Extract identifiers\n", " run_ids = descriptor.select(\"run_id\", train_data)\n", " unique_ids = torch.unique(run_ids).cpu().numpy()\n", " run_ids_np = run_ids.cpu().numpy().flatten()\n", "\n", " cmap = plt.get_cmap(\"tab10\")\n", "\n", " # Plot training signals (faint background)\n", " for i, waveform_id in enumerate(unique_ids):\n", " mask = run_ids_np == waveform_id\n", " time = descriptor.select(\"time\", train_data)[mask].cpu().numpy()\n", " signal = descriptor.select(\"signal\", train_data)[mask].cpu().numpy().flatten()\n", "\n", " ax_signal.scatter(\n", " time,\n", " signal,\n", " color=cmap(i % 10),\n", " alpha=0.2,\n", " s=5,\n", " label=f\"Training signal {int(waveform_id)}\",\n", " )\n", "\n", " # Prepare test waveform\n", " time_test = descriptor.select(\"time\", test_data).cpu().numpy()\n", " signal_test = descriptor.select(\"signal\", test_data)\n", " signal_test_np = signal_test.cpu().numpy().flatten()\n", "\n", " # Forward pass\n", " with torch.no_grad():\n", " preds = network({\"input\": signal_test.to(device)})[\"output\"].cpu().numpy().flatten()\n", "\n", " # Plot test signal and prediction\n", " ax_signal.scatter(\n", " time_test,\n", " signal_test_np,\n", " color=\"black\",\n", " alpha=0.4,\n", " s=10,\n", " label=\"Test signal\",\n", " )\n", "\n", " ax_pred.plot(\n", " time_test,\n", " preds,\n", " color=\"red\",\n", " linewidth=2,\n", " alpha=0.8,\n", " label=\"Test prediction\",\n", " )\n", "\n", " # Titles and labels\n", " ax_pred.set_title(\"Model Predictions and Signal\")\n", " ax_pred.set_xlabel(\"x\")\n", " ax_pred.set_ylabel(\"Prediction\", color=\"red\")\n", " ax_signal.set_ylabel(\"Signal\", color=\"gray\")\n", " ax_pred.set_ylim(-0.1, 1.1)\n", "\n", " ax_pred.tick_params(axis=\"y\", labelcolor=\"red\")\n", " ax_signal.tick_params(axis=\"y\", labelcolor=\"gray\")\n", "\n", " # Merge legends and reorder so test entries appear together at the end\n", " lines_pred, labels_pred = ax_pred.get_legend_handles_labels()\n", " lines_sig, labels_sig = ax_signal.get_legend_handles_labels()\n", "\n", " # Combine\n", " lines = lines_pred + lines_sig\n", " labels = labels_pred + labels_sig\n", "\n", " # Sort so test set entries appear last\n", " sorted_pairs = sorted(\n", " zip(lines, labels, strict=False), key=lambda x: (\"test\" not in x[1].lower(), x[1].lower())\n", " )\n", " lines, labels = zip(*sorted_pairs, strict=False)\n", "\n", " ax_pred.legend(lines, labels, loc=\"best\")\n", "\n", " fig.tight_layout()\n", " return ax_pred\n", "\n", "def split_dataset(\n", " dataset: Dataset,\n", " loader_args: dict = None,\n", " train_loader_args: dict = None,\n", " valid_loader_args: dict = None,\n", " test_loader_args: dict = None,\n", " seed: int = 42,\n", " train_valid_split: float = 0.9,\n", ") -> tuple[DataLoader, DataLoader, DataLoader]:\n", " \"\"\"Split dataset into train, validation, and test DataLoaders.\n", "\n", " One waveform (run) is randomly selected for testing, based on a seed.\n", " Validation samples come from the same runs as training (not unseen).\n", " \"\"\"\n", " # Set default arguments for each loader\n", " train_loader_args = dict(loader_args or {}, **(train_loader_args or {}))\n", " valid_loader_args = dict(loader_args or {}, **(valid_loader_args or {}))\n", " test_loader_args = dict(loader_args or {}, **(test_loader_args or {}))\n", "\n", " # Group indices by run_identifier\n", " run_to_indices = defaultdict(list)\n", " for idx, sample in enumerate(dataset):\n", " run_id = int(sample[\"context\"][-1].item())\n", " run_to_indices[run_id].append(idx)\n", "\n", " all_runs = list(run_to_indices.keys())\n", "\n", " # Pick a random run for testing\n", " random.seed(seed)\n", " test_run = random.choice(all_runs)\n", " test_runs = [test_run]\n", " train_runs = [r for r in all_runs if r not in test_runs]\n", "\n", " # Collect indices\n", " train_indices = [i for r in train_runs for i in run_to_indices[r]]\n", " test_indices = [i for r in test_runs for i in run_to_indices[r]]\n", "\n", " # Split train_indices into train/validation\n", " # (same runs, just different random shuffle)\n", " random.shuffle(train_indices)\n", " split_point = int(train_valid_split * len(train_indices))\n", " valid_indices = train_indices[split_point:]\n", " train_indices = train_indices[:split_point]\n", "\n", " # Create subsets\n", " train_data = Subset(dataset, train_indices)\n", " valid_data = Subset(dataset, valid_indices)\n", " test_data = Subset(dataset, test_indices)\n", "\n", " # Create DataLoaders\n", " train_loader = DataLoader(train_data, **train_loader_args)\n", " valid_loader = DataLoader(valid_data, **valid_loader_args)\n", " test_loader = DataLoader(test_data, **test_loader_args)\n", "\n", " return train_loader, valid_loader, test_loader\n" ] }, { "cell_type": "markdown", "metadata": { "id": "wCx-6Ljroecz", "tags": [ "hide-cell" ] }, "source": [ "Before starting with the general training procedure, we fix the randomizer seeds and get the device on which we are training our model:\n", "\n", "\n", "\n", "* We have a built-in [Seeder class](https://congrads.readthedocs.io/en/latest/api.html#congrads.utils.Seeder) that will pseudo-randomly fix the seeds of random number generators, Numpy and PyTorch.\n", "* If there is a GPU available, use it. Otherwise fall back to CPU.\n", "\n" ] }, { "cell_type": "code", "execution_count": 26, "metadata": { "executionInfo": { "elapsed": 8, "status": "ok", "timestamp": 1769501894642, "user": { "displayName": "Wout Rombouts", "userId": "06394371526548571555" }, "user_tz": -60 }, "id": "mROd-Y0iobFq", "tags": [ "hide-cell" ] }, "outputs": [], "source": [ "# Set seed for reproducibility\n", "seeder = Seeder(base_seed=42)\n", "seeder.set_reproducible()\n", "\n", "# CUDA for PyTorch\n", "use_cuda = torch.cuda.is_available()\n", "device = torch.device(\"cuda:0\" if use_cuda else \"cpu\")" ] }, { "cell_type": "markdown", "metadata": { "id": "bn3SwXqi-kWK" }, "source": [ "## Problem description\n", "\n", "In this last example, the goal is to predict a \"health score\". This is a monotonically decreasing function that starts near 1 and ends near 0.\n", "\n", "This problem is a simplification of a Remaining Useful Life (RUL) prediction, using synthetically generating data as shown on the figure below. An assumption we make here is that a difference in RUL must be a consequence of a change in input.\n", "\n", "Mathematically:\n", "\n", "* $x \\in [0, 1]$, then $f(x) \\ge 0$ `RUL is non-negative`\n", "* $x \\in [0, 1]$, then $f(x) \\le 1$ `RUL is relative as it should work for runs of different length`\n", "* $x \\in [0, 0.1]$, then $f(x) \\ge 0.9$ `RUL is large near the beginning`\n", "* $x \\in [0.9, 1]$, then $f(x) \\le 0.1$ `RUL is small near the end`\n", "* $x_1 \\le x_2 \\in [0, 1]$, then $f(x_1) \\ge f(x_2)$ `RUL decays over time`\n", "\n", "\n", "![image.png](data:image/png;base64,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)" ] }, { "cell_type": "markdown", "metadata": { "id": "xFnObGpwofNX" }, "source": [ "## Dataset\n", "\n", "For this example we will use the built-in [SectionedGaussians dataset](https://congrads.readthedocs.io/en/latest/api.html#congrads.datasets.SectionedGaussians) with preconfigured settings, and we will split the dataset into training, validation and test sets such that 1 unseen full waveform is reserved to test the model." ] }, { "cell_type": "code", "execution_count": 27, "metadata": { "executionInfo": { "elapsed": 1209, "status": "ok", "timestamp": 1769501895859, "user": { "displayName": "Wout Rombouts", "userId": "06394371526548571555" }, "user_tz": -60 }, "id": "sdqTRHEcobTk" }, "outputs": [], "source": [ "# Load and preprocess data\n", "sections = [\n", " {\n", " \"range\": (0.0, 0.40),\n", " \"add_mean\": 0.2,\n", " \"std\": 0.01,\n", " \"max_splits\": 1,\n", " \"split_prob\": 0.7,\n", " \"mean_var\": 0.6,\n", " \"std_var\": 0.0,\n", " \"range_var\": 0.9,\n", " },\n", " {\n", " \"range\": (0.40, 0.75),\n", " \"add_mean\": 1.8,\n", " \"std\": 0.01,\n", " \"max_splits\": 1,\n", " \"split_prob\": 0.4,\n", " \"mean_var\": 0.3,\n", " \"std_var\": 0.0,\n", " \"range_var\": 0.9,\n", " },\n", " {\n", " \"range\": (0.75, 1.0),\n", " \"add_mean\": 1.8,\n", " \"std\": 0.01,\n", " \"max_splits\": 0,\n", " \"split_prob\": 0.0,\n", " \"mean_var\": 0.4,\n", " \"std_var\": 0.0,\n", " \"range_var\": 0.9,\n", " },\n", "]\n", "dataset = SectionedGaussians(\n", " sections,\n", " n_samples=600,\n", " n_runs=10,\n", " seed=seeder.roll_seed(),\n", " blend_k=50,\n", ")\n", "loaders = split_dataset(\n", " dataset,\n", " loader_args={\"batch_size\": 100, \"shuffle\": True},\n", " valid_loader_args={\"shuffle\": False},\n", " test_loader_args={\"shuffle\": False},\n", " seed=seeder.roll_seed(),\n", " train_valid_split=0.8,\n", ")" ] }, { "cell_type": "markdown", "metadata": { "id": "foEdZFE2raw2" }, "source": [ "## Network\n", "\n", "For this example we can again use the MLPNetwork, please configure it and push it to the current device." ] }, { "cell_type": "code", "execution_count": 28, "metadata": { "executionInfo": { "elapsed": 14, "status": "ok", "timestamp": 1769501895874, "user": { "displayName": "Wout Rombouts", "userId": "06394371526548571555" }, "user_tz": -60 }, "id": "cP1XYA8Pra81" }, "outputs": [], "source": [ "# Instantiate an MLPNetworkWithSoftmax, configure the parameters\n", "network = MLPNetwork(n_inputs=1, n_outputs=1, n_hidden_layers=4, hidden_dim=500)\n", "\n", "# Push the network to the current device\n", "network = network.to(device)" ] }, { "cell_type": "markdown", "metadata": { "id": "b_78GkB1rm40" }, "source": [ "## Descriptor\n", "\n", "The current descriptor setup is a little more complicated as the dataset and the problem are also more complex.\n", "\n", "Our SectionedGaussians dataset returns a dictionary containing the required `input` and `target` keys, as well as an additional `context` key.\n", "\n", "Each key contains data:\n", "\n", "* `input` holds the actual signal data to train the model on\n", "* `context` holds the time information, a precomputed energy derived from the signal as well as the run_ids which indicate the waveform identifier\n", "* `target` holds a linear decreasing target score from 1 to 0\n", "\n", "\n", "When training using constraints we do not use a loss, and as such the `target` data is not used. The constaints take over the responsability of guiding the network to a compliant solution.\n", "\n", "When training without constraints we use an MSE loss between the predictions and this target output. The context data is not used in this case.\n", "\n", "Please set up the descriptor and assign tags to the data:\n", "\n", "* `input` holds in column 0 the signal data\n", "* `context` holds in column 0, 1, 2 the time, energy and run_id data respectively\n", "* `target` holds in column 0 the target data\n", "\n" ] }, { "cell_type": "code", "execution_count": 29, "metadata": { "executionInfo": { "elapsed": 20, "status": "ok", "timestamp": 1769501895890, "user": { "displayName": "Wout Rombouts", "userId": "06394371526548571555" }, "user_tz": -60 }, "id": "UZ3wkjP_rnC2" }, "outputs": [], "source": [ "# Instantiate descriptor\n", "descriptor = Descriptor()\n", "descriptor.add(\"input\", \"signal\", 0, constant=True)\n", "descriptor.add(\"context\", \"time\", 0, constant=True)\n", "descriptor.add(\"context\", \"energy\", 1, constant=True)\n", "descriptor.add(\"context\", \"run_id\", 2, constant=True)\n", "descriptor.add(\"output\", \"score\", 0)\n" ] }, { "cell_type": "markdown", "metadata": { "id": "0XqypUaYpFNo" }, "source": [ "## Constraints\n", "\n", "With the help of the descriptor, we can easily reference certain parts of the neural network, and so we can now define our constraints.\n", "\n", "We have [numerous pre-defined constraints](https://congrads.readthedocs.io/en/latest/api.html#module-congrads.constraints) available that allow a variety of options.\n", "\n", "In this example, we want to build a network that can predict a health score between 1 and 0, indicating the remaining useful life (RUL) on a synthetic dataset.\n", "\n", "The objectives:\n", "\n", "* $x \\in [0, 1]$, then $f(x) \\ge 0$ `RUL is non-negative`\n", "* $x \\in [0, 1]$, then $f(x) \\le 1$ `RUL is relative as it should work for runs of different length`\n", "* $x \\in [0, 0.1]$, then $f(x) \\ge 0.9$ `RUL is large near the beginning`\n", "* $x \\in [0.9, 1]$, then $f(x) \\le 0.1$ `RUL is small near the end`\n", "* $x_1 \\le x_2 \\in [0, 1]$, then $f(x_1) \\ge f(x_2)$ `RUL decays over time`\n" ] }, { "cell_type": "code", "execution_count": 30, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "executionInfo": { "elapsed": 26, "status": "ok", "timestamp": 1769501895917, "user": { "displayName": "Wout Rombouts", "userId": "06394371526548571555" }, "user_tz": -60 }, "id": "OebxVdwT5r3h", "outputId": "0232973c-83ae-4e3f-d022-3d921e36f714" }, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "/usr/local/lib/python3.12/dist-packages/congrads/constraints/base.py:216: UserWarning: Rescale factor for constraint score monotonically (ranked) descending by time is <= 1. The network will favor general loss over the constraint-adjusted loss. Is this intended behavior? Normally, the rescale factor should always be larger than 1.\n", " super().__init__({tag_prediction}, name, enforce, 1.0)\n", "/usr/local/lib/python3.12/dist-packages/congrads/constraints/registry.py:895: UserWarning: Rescale factor for constraint score for each run_id monotonically (ranked) descending by time is <= 1. The network will favor general loss over the constraint-adjusted loss. Is this intended behavior? Normally, the rescale factor should always be larger than 1.\n", " super().__init__(base.tags, name, base.enforce, base.rescale_factor)\n" ] } ], "source": [ "# Constraints definition\n", "Constraint.descriptor = descriptor\n", "Constraint.device = device\n", "constraints = [\n", " ScalarConstraint(\"score\", \"<=\", 1.05, rescale_factor=2.5),\n", " ScalarConstraint(\"score\", \">=\", -0.05, rescale_factor=2.5),\n", " ImplicationConstraint(\n", " head=ScalarConstraint(\"time\", \"<=\", 0.1),\n", " body=ScalarConstraint(\"score\", \">=\", 0.95, rescale_factor=2.0),\n", " ),\n", " ImplicationConstraint(\n", " head=ScalarConstraint(\"time\", \">=\", 0.9),\n", " body=ScalarConstraint(\"score\", \"<=\", 0.05, rescale_factor=2.0),\n", " ),\n", " PerGroupMonotonicityConstraint(\n", " base=RankedMonotonicityConstraint(\n", " \"score\",\n", " \"time\",\n", " direction=\"descending\",\n", " rescale_factor_lower=1.50,\n", " rescale_factor_upper=1.75,\n", " ),\n", " tag_group=\"run_id\"\n", " ),\n", " ImplicationConstraint(\n", " head=ScalarConstraint(\"time\", \"<=\", 0.9),\n", " body=BinaryConstraint(\"score\", \">=\", \"energy\", rescale_factor=1.25),\n", " ),\n", "]" ] }, { "cell_type": "markdown", "metadata": { "id": "9NDRG60yrh7s" }, "source": [ "## Loss and optimizer\n", "\n", "For this example, we do not need to use a loss function. The constraints will guide the network to a compliant solution. We therefore use the built-in [ZeroLoss](https://congrads.readthedocs.io/en/latest/api.html#congrads.utils.ZeroLoss) function as criterion, which returns 0 as loss effectively disabling it.\n", "\n", "We will stick to the Adam optimizer for this example." ] }, { "cell_type": "code", "execution_count": 31, "metadata": { "executionInfo": { "elapsed": 8, "status": "ok", "timestamp": 1769501895926, "user": { "displayName": "Wout Rombouts", "userId": "06394371526548571555" }, "user_tz": -60 }, "id": "Lx8FHOHfriLl" }, "outputs": [], "source": [ "# Instantiate loss criterion\n", "criterion = ZeroLoss()\n", "\n", "# Instantiate optimizer\n", "optimizer = Adam(network.parameters(), lr=0.001)" ] }, { "cell_type": "markdown", "metadata": { "id": "mWZVjzpQruk3" }, "source": [ "## Metric manager\n", "\n", "To allow keeping track of constraint satisfaction rates for each individual constraints, as well as the losses and possibly other metrics, we instantiate a metric manager." ] }, { "cell_type": "code", "execution_count": 32, "metadata": { "executionInfo": { "elapsed": 44, "status": "ok", "timestamp": 1769501895971, "user": { "displayName": "Wout Rombouts", "userId": "06394371526548571555" }, "user_tz": -60 }, "id": "Ke7tTBTJru6m" }, "outputs": [], "source": [ "# Initialize metric manager\n", "metric_manager = MetricManager()" ] }, { "cell_type": "markdown", "metadata": { "id": "YDJt1358r0I7" }, "source": [ "## Core\n", "\n", "The [CongradsCore](https://congrads.readthedocs.io/en/latest/api.html#congrads.core.CongradsCore) is the brain of the toolbox. It orchestrates the functionality of all previously created objects, integrating descriptors, constraints, and optimization strategies to perform constraint-guided gradient descent. Essentially, it manages the full training or evaluation pipeline: preparing input and output tensors, applying constraints, computing gradients, updating model parameters, and generating predictions in a coordinated manner." ] }, { "cell_type": "markdown", "metadata": { "id": "bUp1Fyfor8FE" }, "source": [ "First, we define callback that handles plotting per epoch.\n", "\n", "Refer to the [Congrads documentation](https://congrads.readthedocs.io/en/latest/) for more info." ] }, { "cell_type": "code", "execution_count": 42, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "executionInfo": { "elapsed": 10, "status": "ok", "timestamp": 1769502112785, "user": { "displayName": "Wout Rombouts", "userId": "06394371526548571555" }, "user_tz": -60 }, "id": "l0279nibsClA", "outputId": "d18a7ee5-c510-4ac8-e99c-73361af8b534" }, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": 42, "metadata": {}, "output_type": "execute_result" } ], "source": [ "callback_manager = CallbackManager()\n", "\n", "class PlottingCallback(Callback):\n", " def on_epoch_end(self, data, ctx):\n", " epoch = data[\"epoch\"]\n", " if epoch % 10 == 0:\n", " clear_output(wait=True)\n", " print(f\"Epoch: {epoch}\")\n", " plot_regression_epoch(descriptor, network, loaders, device)\n", " plt.show()\n", " plt.close()\n", "\n", "callback_manager.add(PlottingCallback())" ] }, { "cell_type": "code", "execution_count": 43, "metadata": { "executionInfo": { "elapsed": 10, "status": "ok", "timestamp": 1769502113619, "user": { "displayName": "Wout Rombouts", "userId": "06394371526548571555" }, "user_tz": -60 }, "id": "FDGlm9oGr0WE" }, "outputs": [], "source": [ "# Instantiate core\n", "core = CongradsCore(\n", " descriptor=descriptor,\n", " constraints=constraints,\n", " dataloader_train=loaders[0],\n", " dataloader_valid=loaders[1],\n", " dataloader_test=loaders[2],\n", " network=network,\n", " criterion=criterion,\n", " optimizer=optimizer,\n", " metric_manager=metric_manager,\n", " callback_manager=callback_manager,\n", " device=device,\n", " enforce_all=True,\n", " disable_progress_bar_batch=True,\n", " disable_progress_bar_epoch=True\n", ")" ] }, { "cell_type": "markdown", "metadata": { "id": "HoxB8KH3sCGz" }, "source": [ "Finally, we can start training by running the `core.fit(...)` function. This function allows setting the maximum epochs and callback functions and will start the training process." ] }, { "cell_type": "code", "execution_count": 44, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 425 }, "executionInfo": { "elapsed": 204655, "status": "ok", "timestamp": 1769502319540, "user": { "displayName": "Wout Rombouts", "userId": "06394371526548571555" }, "user_tz": -60 }, "id": "oJcIDbRqr8ai", "outputId": "9729c348-23a0-4e40-85a7-aad3c5e53e42" }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Epoch: 90\n" ] }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# Start training\n", "core.fit(max_epochs=100)" ] } ], "metadata": { "colab": { "collapsed_sections": [ "eX2YY8tp5yyk" ], "provenance": [], "toc_visible": true }, "kernelspec": { "display_name": "congrads (3.13.7)", "language": "python", "name": "python3" }, "language_info": { "name": "python", "version": "3.13.7" } }, "nbformat": 4, "nbformat_minor": 0 }