dslighting 1.3.9__py3-none-any.whl → 1.7.6__py3-none-any.whl

dslighting/registry/uw-madison-gi-tract-image-segmentation/grade.py

@@ -0,0 +1,158 @@
+import numpy as np
+from pandas import DataFrame
+from scipy.spatial.distance import directed_hausdorff
+from tqdm.auto import tqdm
+
+from mlebench.competitions.utils import rles_to_masks
+from mlebench.grade_helpers import InvalidSubmissionError
+from mlebench.metrics import dice_coefficient
+
+UNIT_CUBE_DIAGONAL = np.sqrt(3)
+
+
+def group_masks_by_day(masks: list[np.ndarray], cases_days_slices: list[str]) -> list[np.ndarray]:
+    """
+    Groups the 2D masks into 3D masks based on the case days
+    - We first join masks of the same slice into a single mask with an OR operation
+    - We then stack them with all the other slices from the same day in the same case into a 3D image
+    """
+    case_day_slice_to_masks = {}
+    unique_slices = []  # list to keep ordering consistent
+    for mask, case_day_slice in sorted(zip(masks, cases_days_slices), key=lambda x: x[1]):
+        if case_day_slice not in case_day_slice_to_masks:
+            case_day_slice_to_masks[case_day_slice] = []
+            unique_slices.append(case_day_slice)
+        case_day_slice_to_masks[case_day_slice].append(mask)
+
+    case_day_to_masks = {}
+    case_days = []  # list to keep ordering consistent
+    for case_day_slice in unique_slices:
+        # go from e.g. "case123_day2_slice_0001" to "case123_day2"
+        case_day = case_day_slice.split("_slice_")[0]
+        if case_day not in case_day_to_masks:
+            case_day_to_masks[case_day] = []
+            case_days.append(case_day)
+        # OR on the masks from the same case_day_slice
+        joined_mask = np.logical_or.reduce(case_day_slice_to_masks[case_day_slice]).astype(np.uint8)
+        # add the joined slice to its relevant case_day
+        case_day_to_masks[case_day].append(joined_mask)
+
+    # now we stack the joined masks for each case_day to make a 3d image
+    for case_day in case_day_to_masks:
+        # make into 3d image
+        case_day_to_masks[case_day] = np.stack(case_day_to_masks[case_day], axis=0)
+
+    # keep the order of the cases consistent
+    case_day_masks = [case_day_to_masks[case_day] for case_day in case_days]
+    return case_day_masks
+
+
+def prepare_for_metric(submission: DataFrame, answers: DataFrame):
+    """
+    Answers dataframe contains image_height and image_width columns necessary for RLE decoding
+    """
+
+    assert "image_height" in answers.columns, "image_height column not found in answers"
+    assert "image_width" in answers.columns, "image_width column not found in answers"
+    if not {"id", "class", "predicted"}.issubset(set(submission.columns)):
+        raise InvalidSubmissionError("Submission must have columns: id, class, predicted")
+
+    # prepare appropriate types
+    submission["predicted"] = submission["predicted"].fillna("")
+    answers["predicted"] = answers["predicted"].fillna("")
+    answers["image_height"] = answers["image_height"].astype(int)
+    answers["image_width"] = answers["image_width"].astype(int)
+
+    image_heights = answers["image_height"].tolist()
+    image_widths = answers["image_width"].tolist()
+
+    # extract masked images from RLE in the dataframes
+    submission_masks = rles_to_masks(submission["predicted"].to_list(), image_heights, image_widths)
+    answer_masks = rles_to_masks(answers["predicted"].to_list(), image_heights, image_widths)
+
+    # group 2d slice masks into 3d case_day masks
+    submission_masks_by_day = group_masks_by_day(submission_masks, submission["id"])
+    answer_masks_by_day = group_masks_by_day(answer_masks, answers["id"])
+
+    return submission_masks, answer_masks, submission_masks_by_day, answer_masks_by_day
+
+
+def hausdorff_distance(predicted_mask: np.ndarray, true_mask: np.ndarray) -> float:
+    """
+    Computes the hausdorff distance between two 3-dimensional binary masks (H, W, C)
+
+    Args:
+        predicted_mask: A 3D binary numpy array indicating where the segmentation is predicted
+        true_mask: A 3D binary numpy array indicating where the segmentation is
+    """
+    # if both empty, return nan, if identical return 0, if only one is empty, return 1
+    if np.sum(predicted_mask) == 0 and np.sum(true_mask) == 0:
+        return np.nan
+    elif np.array_equal(predicted_mask, true_mask):
+        return 0
+    elif (np.sum(predicted_mask) == 0 and np.sum(true_mask) > 0) or (
+        np.sum(predicted_mask) > 0 and np.sum(true_mask) == 0
+    ):
+        return 1
+
+    # if the pred mask is > 1 OOM larger than the true mask, return 1 to avoid unnecess heavy computation
+    if predicted_mask.sum() > 10 * true_mask.sum():
+        return 1
+
+    true_coordinates = np.argwhere(true_mask)
+    predicted_coordinates = np.argwhere(predicted_mask)
+
+    # normalize so that the coordinates are in the range [0, 1], to get a unit cube
+    normalization_constants = true_mask.shape
+    true_coordinates = true_coordinates / normalization_constants
+    predicted_coordinates = predicted_coordinates / normalization_constants
+
+    # Symmetrize Hausdorff distance
+    hausdorff_distance1, _, _ = directed_hausdorff(true_coordinates, predicted_coordinates)
+    hausdorff_distance2, _, _ = directed_hausdorff(predicted_coordinates, true_coordinates)
+    hausdorff_distance = max(hausdorff_distance1, hausdorff_distance2)
+
+    # normalize by the maximum distance possible in a unit cube, which is the diagonal
+    hausdorff_distance = hausdorff_distance / UNIT_CUBE_DIAGONAL
+
+    return hausdorff_distance
+
+
+def grade(submission: DataFrame, answers: DataFrame) -> float:
+    """
+    Computes dice_weight * dice + hausdorff_weight * (1 - hausdorff)
+    """
+    dice_weight = 0.4
+    hausdorff_weight = 0.6
+
+    (
+        submission_masks,
+        answer_masks,
+        submission_masks_by_day,
+        answer_masks_by_day,
+    ) = prepare_for_metric(submission, answers)
+
+    # we skip cases where both masks are empty, so we use nanmean
+    # https://www.kaggle.com/competitions/uw-madison-gi-tract-image-segmentation/discussion/324934#1795540
+    dice_coeff = np.nanmean(
+        [
+            dice_coefficient(submission_mask, answer_mask, np.nan)
+            for submission_mask, answer_mask in tqdm(
+                zip(submission_masks, answer_masks),
+                total=len(submission_masks),
+            )
+        ]
+    )
+
+    # skip cases where both masks are empty, to match behaviour of dice
+    hausdorff_dis = np.nanmean(
+        [
+            hausdorff_distance(submission_mask_by_day, answer_mask_by_day)
+            for submission_mask_by_day, answer_mask_by_day in tqdm(
+                zip(submission_masks_by_day, answer_masks_by_day),
+                total=len(submission_masks_by_day),
+            )
+        ]
+    )
+
+    return dice_weight * dice_coeff + hausdorff_weight * (1 - hausdorff_dis)

dslighting/registry/uw-madison-gi-tract-image-segmentation/prepare.py

@@ -0,0 +1,139 @@
+import shutil
+from pathlib import Path
+
+import pandas as pd
+from sklearn.model_selection import train_test_split
+from tqdm.auto import tqdm
+
+from mlebench.utils import read_csv
+
+
+def verify_directory_sync(df: pd.DataFrame, expected_dir: Path, unexpected_dir: Path):
+    """
+    Checks that the dataframe contents match the directory structure.
+    """
+    for _, row in tqdm(
+        df.iterrows(), desc=f"Verifying directory sync for {expected_dir.name}", total=len(df)
+    ):
+        case_day_path = expected_dir / row["case"] / f"{row['case']}_{row['day']}"
+        assert (
+            case_day_path.exists()
+        ), f"Directory {case_day_path} does not exist but is listed in the dataframe."
+        non_existent_path = unexpected_dir / row["case"] / f"{row['case']}_{row['day']}"
+        assert (
+            not non_existent_path.exists()
+        ), f"Directory {non_existent_path} exists but is not listed in the dataframe."
+
+
+def prepare(raw: Path, public: Path, private: Path):
+    old_train = read_csv(raw / "train.csv")
+
+    # ----------------------- Splitting
+    # Extract case and day from 'id'
+    old_train["case"] = old_train["id"].apply(lambda x: x.split("_")[0])
+    old_train["day"] = old_train["id"].apply(lambda x: x.split("_")[1])
+    old_train["slice"] = old_train["id"].apply(lambda x: x.split("_")[-1])
+
+    # Split cases into train and test
+    unique_cases = old_train["case"].unique()
+    train_cases, test_cases = train_test_split(unique_cases, test_size=0.1, random_state=42)
+
+    # Initially assign entire cases to train or test set
+    old_train["set"] = old_train["case"].apply(lambda x: "test" if x in test_cases else "train")
+
+    # Then mark some days from train to be test, to match competition test description
+    days_df = old_train[old_train["set"] == "train"].groupby("case")["day"].apply(set).reset_index()
+    for _, row in days_df.iterrows():
+        # if theres more than 4 days, we will move any days past the 4th to the test set
+        days = row["day"]
+        if len(days) > 4:
+            days = sorted(days, key=lambda x: int(x[len("day") :]))
+            days_to_move = days[4:]
+            # change their set to "test"
+            old_train.loc[
+                old_train["case"].eq(row["case"]) & old_train["day"].isin(days_to_move), "set"
+            ] = "test"
+
+    # ----------------------- Move the files to the correct new locations
+    old_train_dir = raw / "train"
+    new_train_dir = public / "train"
+    new_test_dir = public / "test"
+
+    # Create new directories if they don't exist
+    new_train_dir.mkdir(parents=True, exist_ok=True)
+    new_test_dir.mkdir(parents=True, exist_ok=True)
+
+    # Move directories based on the set assignment
+    for case in tqdm(unique_cases, desc="Splitting by case"):
+        original_path = old_train_dir / case
+        if case in train_cases:
+            new_path = new_train_dir / case
+        else:
+            new_path = new_test_dir / case
+        # new_path.mkdir(parents=True, exist_ok=True)
+        shutil.copytree(original_path, new_path, dirs_exist_ok=True)
+
+    # Move specific days from public/train/ to public/test/ for marked case-days
+    for _, row in tqdm(
+        old_train.iterrows(), desc="Handling additional day-based splits", total=len(old_train)
+    ):
+        if row["set"] == "test":
+            source_day_path = new_train_dir / row["case"] / f"{row['case']}_{row['day']}"
+            target_day_path = new_test_dir / row["case"] / f"{row['case']}_{row['day']}"
+            if source_day_path.exists():
+                target_day_path.parent.mkdir(parents=True, exist_ok=True)
+                shutil.move(source_day_path.as_posix(), target_day_path.as_posix())
+
+    # ------------------------ Saving splits
+    new_train = old_train[old_train["set"] == "train"].copy()
+    new_test = old_train[old_train["set"] == "test"].copy()
+    # some asserts before we drop columns
+    verify_directory_sync(new_train, expected_dir=new_train_dir, unexpected_dir=new_test_dir)
+    verify_directory_sync(new_test, expected_dir=new_test_dir, unexpected_dir=new_train_dir)
+
+    # get image height and image width for the test set, since this is needed for the metric
+    for _, row in tqdm(
+        new_test.iterrows(), desc="Getting image dimensions for test set", total=len(new_test)
+    ):
+        case, day, day_slice = row["case"], row["day"], row["slice"]
+        image_paths = list(
+            (old_train_dir / case / f"{case}_{day}" / "scans").glob(f"slice_{day_slice}_*.png")
+        )
+        assert len(image_paths) == 1, f"Expected 1 image, found {len(image_paths)}"
+        image_path = image_paths[0]
+        width, height = (int(length) for length in image_path.stem.split("_")[2:4])
+        new_test.loc[row.name, "image_width"] = width
+        new_test.loc[row.name, "image_height"] = height
+
+    # dont need these anymore, and werent part of the original data
+    new_train.drop(columns=["set", "case", "day", "slice"], inplace=True)
+    new_test.drop(columns=["set", "case", "day", "slice"], inplace=True)
+
+    # create sample submission
+    sample_submission = new_test.copy()
+    sample_submission["segmentation"] = "1 1 5 2"
+    # these are just metadata for the private test set necessary for the metric
+    sample_submission.drop(columns=["image_height", "image_width"], inplace=True)
+    # rename 'segmentation' to 'predicted' to match kaggle.com
+    sample_submission.rename(columns={"segmentation": "predicted"}, inplace=True)
+    sample_submission.to_csv(public / "sample_submission.csv", index=False, na_rep="")
+
+    # create private files
+    # rename 'segmentation' to 'predicted' to match sample_submission format
+    new_test.rename(columns={"segmentation": "predicted"}, inplace=True)
+    new_test.to_csv(private / "test.csv", index=False, na_rep="")
+
+    # create public files
+    new_train.to_csv(public / "train.csv", index=False, na_rep="")
+    # including this because we are converting this from code to csv competition
+    # and we need to point the model to the ids it needs to produce labels for
+    new_test_without_labels = new_test.drop(columns=["predicted", "image_width", "image_height"])
+    new_test_without_labels.to_csv(public / "test.csv", index=False, na_rep="")
+
+    # ------------------------ checks
+
+    assert new_test_without_labels.shape[1] == 2, "Public test should have 2 columns."
+    assert new_train.shape[1] == 3, "Public train should have 3 columns."
+    assert len(new_train) + len(new_test) == len(
+        old_train
+    ), "Train and test should sum up to the original data."

dslighting/registry/uw-madison-gi-tract-image-segmentation/prepare_val.py

@@ -0,0 +1,193 @@
+import shutil
+from pathlib import Path
+
+import pandas as pd
+from sklearn.model_selection import train_test_split
+from tqdm.auto import tqdm
+
+from mlebench.utils import read_csv
+
+
+def verify_directory_sync(df: pd.DataFrame, expected_dir: Path, unexpected_dir: Path):
+    """
+    Checks that the dataframe contents match the directory structure.
+    """
+    for _, row in tqdm(
+        df.iterrows(), desc=f"Verifying directory sync for {expected_dir.name}", total=len(df)
+    ):
+        case_day_path = expected_dir / row["case"] / f"{row['case']}_{row['day']}"
+        assert (
+            case_day_path.exists()
+        ), f"Directory {case_day_path} does not exist but is listed in the dataframe."
+        non_existent_path = unexpected_dir / row["case"] / f"{row['case']}_{row['day']}"
+        assert (
+            not non_existent_path.exists()
+        ), f"Directory {non_existent_path} exists but is not listed in the dataframe."
+
+
+def _create_split(
+    input_df: pd.DataFrame,
+    raw_images_dir: Path,
+    output_public_path: Path,
+    output_private_path: Path,
+) -> tuple[pd.DataFrame, pd.DataFrame]:
+    """
+    Helper function to perform a train/test split on a dataframe, move image files accordingly,
+    and save the resulting CSVs and submission files.
+
+    Args:
+        input_df: The dataframe to be split.
+        raw_images_dir: The source directory of all raw image data.
+        output_public_path: The destination directory for public files (e.g., public/ or public_val/).
+        output_private_path: The destination directory for private files (e.g., private/ or private_val/).
+
+    Returns:
+        A tuple containing the created training and testing dataframes.
+    """
+    # ----------------------- Splitting
+    # Extract case and day from 'id'
+    df_to_split = input_df.copy()
+    df_to_split["case"] = df_to_split["id"].apply(lambda x: x.split("_")[0])
+    df_to_split["day"] = df_to_split["id"].apply(lambda x: x.split("_")[1])
+    df_to_split["slice"] = df_to_split["id"].apply(lambda x: x.split("_")[-1])
+
+    # Split cases into train and test
+    unique_cases = df_to_split["case"].unique()
+    train_cases, test_cases = train_test_split(unique_cases, test_size=0.1, random_state=42)
+
+    # Initially assign entire cases to train or test set
+    df_to_split["set"] = df_to_split["case"].apply(lambda x: "test" if x in test_cases else "train")
+
+    # Then mark some days from train to be test, to match competition test description
+    days_df = df_to_split[df_to_split["set"] == "train"].groupby("case")["day"].apply(set).reset_index()
+    for _, row in days_df.iterrows():
+        # if theres more than 4 days, we will move any days past the 4th to the test set
+        days = row["day"]
+        if len(days) > 4:
+            days = sorted(days, key=lambda x: int(x[len("day") :]))
+            days_to_move = days[4:]
+            # change their set to "test"
+            df_to_split.loc[
+                df_to_split["case"].eq(row["case"]) & df_to_split["day"].isin(days_to_move), "set"
+            ] = "test"
+
+    # ----------------------- Move the files to the correct new locations
+    new_train_dir = output_public_path / "train"
+    new_test_dir = output_public_path / "test"
+
+    # Create new directories if they don't exist
+    new_train_dir.mkdir(parents=True, exist_ok=True)
+    new_test_dir.mkdir(parents=True, exist_ok=True)
+    output_private_path.mkdir(parents=True, exist_ok=True)
+
+    # Move directories based on the set assignment
+    for case in tqdm(unique_cases, desc=f"Splitting by case for {output_public_path.name}"):
+        original_path = raw_images_dir / case
+        if case in train_cases:
+            new_path = new_train_dir / case
+        else:
+            new_path = new_test_dir / case
+        shutil.copytree(original_path, new_path, dirs_exist_ok=True)
+
+    # Move specific days from public/train/ to public/test/ for marked case-days
+    for _, row in tqdm(
+        df_to_split.iterrows(),
+        desc=f"Handling day-based splits for {output_public_path.name}",
+        total=len(df_to_split),
+    ):
+        if row["set"] == "test":
+            source_day_path = new_train_dir / row["case"] / f"{row['case']}_{row['day']}"
+            target_day_path = new_test_dir / row["case"] / f"{row['case']}_{row['day']}"
+            if source_day_path.exists():
+                target_day_path.parent.mkdir(parents=True, exist_ok=True)
+                shutil.move(source_day_path.as_posix(), target_day_path.as_posix())
+
+    # ------------------------ Saving splits
+    new_train = df_to_split[df_to_split["set"] == "train"].copy()
+    new_test = df_to_split[df_to_split["set"] == "test"].copy()
+    # some asserts before we drop columns
+    verify_directory_sync(new_train, expected_dir=new_train_dir, unexpected_dir=new_test_dir)
+    verify_directory_sync(new_test, expected_dir=new_test_dir, unexpected_dir=new_train_dir)
+
+    # get image height and image width for the test set, since this is needed for the metric
+    for _, row in tqdm(
+        new_test.iterrows(),
+        desc=f"Getting image dimensions for {output_public_path.name} test set",
+        total=len(new_test),
+    ):
+        case, day, day_slice = row["case"], row["day"], row["slice"]
+        image_paths = list(
+            (raw_images_dir / case / f"{case}_{day}" / "scans").glob(f"slice_{day_slice}_*.png")
+        )
+        assert len(image_paths) == 1, f"Expected 1 image, found {len(image_paths)}"
+        image_path = image_paths[0]
+        width, height = (int(length) for length in image_path.stem.split("_")[2:4])
+        new_test.loc[row.name, "image_width"] = width
+        new_test.loc[row.name, "image_height"] = height
+
+    # dont need these anymore, and werent part of the original data
+    new_train.drop(columns=["set", "case", "day", "slice"], inplace=True)
+    new_test.drop(columns=["set", "case", "day", "slice"], inplace=True)
+
+    # create sample submission
+    sample_submission = new_test.copy()
+    sample_submission["segmentation"] = "1 1 5 2"
+    sample_submission.drop(columns=["image_height", "image_width"], inplace=True)
+    sample_submission.rename(columns={"segmentation": "predicted"}, inplace=True)
+    sample_submission.to_csv(output_public_path / "sample_submission.csv", index=False, na_rep="")
+
+    # create private files
+    new_test.rename(columns={"segmentation": "predicted"}, inplace=True)
+    new_test.to_csv(output_private_path / "test.csv", index=False, na_rep="")
+
+    # create public files
+    new_train.to_csv(output_public_path / "train.csv", index=False, na_rep="")
+    new_test_without_labels = new_test.drop(columns=["predicted", "image_width", "image_height"])
+    new_test_without_labels.to_csv(output_public_path / "test.csv", index=False, na_rep="")
+
+    # ------------------------ checks
+    assert new_test_without_labels.shape[1] == 2, "Public test should have 2 columns."
+    assert new_train.shape[1] == 3, "Public train should have 3 columns."
+    assert len(new_train) + len(new_test) == len(
+        input_df
+    ), "Train and test should sum up to the original data."
+
+    return new_train, new_test
+
+
+def prepare(raw: Path, public: Path, private: Path):
+    """
+    Prepares the raw data by creating two sets of splits:
+    1. A main train/test split for the final competition (`public`/`private`).
+    2. A validation split from the main training data (`public_val`/`private_val`).
+    """
+    initial_train_df = read_csv(raw / "train.csv")
+    raw_images_dir = raw / "train"
+
+    # --- 1. Create the original train/test split ---
+    # This generates the primary competition files in public/ and private/.
+    # The output of this step will remain identical to the original script.
+    print("--- Generating main train/test split for 'public' and 'private' directories ---")
+    main_train_df, _ = _create_split(
+        input_df=initial_train_df,
+        raw_images_dir=raw_images_dir,
+        output_public_path=public,
+        output_private_path=private,
+    )
+
+    # --- 2. Create the validation split from the main training set ---
+    # This takes the training data from the first split and splits it again,
+    # creating a smaller training set and a validation set.
+    # The outputs are saved in parallel directories to avoid conflicts.
+    print("\n--- Generating validation split for 'public_val' and 'private_val' directories ---")
+    public_val = public.parent / "public_val"
+    private_val = private.parent / "private_val"
+
+    _create_split(
+        input_df=main_train_df,  # Use the training set from the first split as input
+        raw_images_dir=raw_images_dir,  # Image sources are the same
+        output_public_path=public_val,
+        output_private_path=private_val,
+    )
+
+    print("\nData preparation complete.")

dslighting/registry/ventilator-pressure-prediction/checksums.yaml

@@ -0,0 +1,7 @@
+private:
+  test.csv: ef4ebee21345154a7cdfbec0606db01a
+public:
+  sample_submission.csv: 6ab5162be2a03922cfc6068befc31c22
+  test.csv: 39c126e1ac7b2e6641ec54f698b1ebdf
+  train.csv: 4b0aaa1c637a452d5d1109aa585bca9f
+zip: dd04f45fe8aaa3608c7cfb17adeaa98a

dslighting/registry/ventilator-pressure-prediction/config.yaml

@@ -0,0 +1,15 @@
+id: ventilator-pressure-prediction
+name: Ventilator Pressure Prediction
+competition_type: simple
+awards_medals: false
+description: mlebench/competitions/ventilator-pressure-prediction/description.md
+
+dataset:
+  answers: ventilator-pressure-prediction/prepared/private/test.csv
+  sample_submission: ventilator-pressure-prediction/prepared/public/sample_submission.csv
+
+grader:
+  name: mae
+  grade_fn: mlebench.competitions.ventilator_pressure_prediction.grade:grade
+
+preparer: mlebench.competitions.ventilator_pressure_prediction.prepare:prepare

dslighting/registry/ventilator-pressure-prediction/description.md

@@ -0,0 +1,48 @@
+# Ventilator Pressure Prediction
+
+## Description
+
+Mechanical ventilation is a clinician-intensive procedure that was prominently on display during the early days of the COVID-19 pandemic. Current simulators are trained as an ensemble, where each model simulates a single lung setting. However, lungs form a continuous space, so a parametric approach must be explored.
+
+In this competition, you'll simulate a ventilator connected to a sedated patient's lung. The best submissions will take lung attributes compliance and resistance into account. If successful, you'll help overcome the cost barrier of developing new methods for controlling mechanical ventilators.
+
+## Evaluation
+
+The competition is scored as the **mean absolute error (MAE)** between the predicted and actual pressures during the inspiratory phase of each breath. The expiratory phase is not scored.
+
+$$\text{MAE} = \frac{1}{n}\sum_{i=1}^{n}|X_i - Y_i|$$
+
+where $X$ is the vector of predicted pressure and $Y$ is the vector of actual pressures.
+
+## Submission Format
+
+For each id in the test set, you must predict a value for the pressure variable:
+
+```
+id,pressure
+1,20
+2,23
+3,24
+...
+```
+
+## Dataset Description
+
+The ventilator data was produced using a modified open-source ventilator connected to an artificial bellows test lung via a respiratory circuit. Each time series represents an approximately 3-second breath.
+
+## Columns
+
+- `id`: globally-unique time step identifier
+- `breath_id`: globally-unique breath identifier
+- `R`: lung resistance (cmH2O/L/S)
+- `C`: lung compliance (mL/cmH2O)
+- `time_step`: actual time stamp
+- `u_in`: inspiratory solenoid valve control (0-100)
+- `u_out`: exploratory solenoid valve control (0 or 1)
+- `pressure`: airway pressure (cmH2O) - target variable
+
+## Files
+
+- `train.csv`: Training set
+- `test.csv`: Test set
+- `sample_submission.csv`: Sample submission in correct format

dslighting/registry/ventilator-pressure-prediction/description_obfuscated.md

@@ -0,0 +1,46 @@
+# Task
+
+Given time series of breaths, predict the airway pressure in the respiratory circuit during the breath, given the time series of control inputs.
+
+The best submissions will take lung attributes compliance and resistance into account.
+
+# Metric
+
+Mean absolute error between the predicted and actual pressures during the inspiratory phase of each breath. The expiratory phase is not scored.
+
+# Submission Format
+
+For each `id` in the test set, you must predict a value for the `pressure` variable. The file should contain a header and have the following format:
+
+```
+id,pressure
+1,20
+2,23
+3,24
+etc.
+```
+
+# Dataset
+
+The ventilator data used in this competition was produced using a modified [open-source ventilator](https://pvp.readthedocs.io/) connected to an [artificial bellows test lung](https://www.ingmarmed.com/product/quicklung/) via a respiratory circuit. The diagram below illustrates the setup, with the two control inputs highlighted in green and the state variable (airway pressure) to predict in blue. The first control input is a continuous variable from 0 to 100 representing the percentage the inspiratory solenoid valve is open to let air into the lung (i.e., 0 is completely closed and no air is let in and 100 is completely open). The second control input is a binary variable representing whether the exploratory valve is open (1) or closed (0) to let air out.
+
+![Ventilator diagram](https://raw.githubusercontent.com/google/deluca-lung/main/assets/2020-10-02%20Ventilator%20diagram.svg)
+
+Each time series represents an approximately 3-second breath. The files are organized such that each row is a time step in a breath and gives the two control signals, the resulting airway pressure, and relevant attributes of the lung, described below.
+
+## Files
+
+- **train.csv** - the training set
+- **test.csv** - the test set
+- **sample_submission.csv** - a sample submission file in the correct format
+
+## Columns
+
+- `id` - globally-unique time step identifier across an entire file
+- `breath_id` - globally-unique time step for breaths
+- `R` - lung attribute indicating how restricted the airway is (in cmH2O/L/S). Physically, this is the change in pressure per change in flow (air volume per time). Intuitively, one can imagine blowing up a balloon through a straw. We can change `R` by changing the diameter of the straw, with higher `R` being harder to blow.
+- `C` - lung attribute indicating how compliant the lung is (in mL/cmH2O). Physically, this is the change in volume per change in pressure. Intuitively, one can imagine the same balloon example. We can change `C` by changing the thickness of the balloon’s latex, with higher `C` having thinner latex and easier to blow.
+- `time_step` - the actual time stamp.
+- `u_in` - the control input for the inspiratory solenoid valve. Ranges from 0 to 100.
+- `u_out` - the control input for the exploratory solenoid valve. Either 0 or 1.
+- `pressure` - the airway pressure measured in the respiratory circuit, measured in cmH2O.

dslighting/registry/ventilator-pressure-prediction/grade.py

@@ -0,0 +1,52 @@
+import numpy as np
+import pandas as pd
+from sklearn.metrics import mean_absolute_error
+
+from mlebench.grade_helpers import InvalidSubmissionError
+
+
+def prepare_for_metric(submission: pd.DataFrame, answers: pd.DataFrame):
+    """Prepare submission and answers for MAE calculation."""
+    if len(submission) != len(answers):
+        raise InvalidSubmissionError(
+            f"Submission length ({len(submission)}) != answers length ({len(answers)})"
+        )
+
+    if "id" not in submission.columns:
+        raise InvalidSubmissionError("Submission must have an 'id' column")
+
+    if "pressure" not in submission.columns:
+        raise InvalidSubmissionError("Submission must have a 'pressure' column")
+
+    # Sort by id
+    submission = submission.sort_values("id").reset_index(drop=True)
+    answers = answers.sort_values("id").reset_index(drop=True)
+
+    # Check id alignment
+    if not (submission["id"] == answers["id"]).all():
+        raise InvalidSubmissionError("Submission and answers id mismatch")
+
+    # Extract predictions and true values
+    y_pred = submission["pressure"].values
+    y_true = answers["pressure"].values
+
+    # Validate predictions
+    try:
+        y_pred = y_pred.astype(float)
+    except (ValueError, TypeError):
+        raise InvalidSubmissionError("Predictions must be numeric")
+
+    if np.any(np.isnan(y_pred)):
+        raise InvalidSubmissionError("Predictions cannot contain NaN values")
+
+    return y_true, y_pred
+
+
+def grade(submission: pd.DataFrame, answers: pd.DataFrame) -> float:
+    """Calculate MAE score."""
+    y_true, y_pred = prepare_for_metric(submission, answers)
+
+    # MAE
+    mae = mean_absolute_error(y_true, y_pred)
+
+    return mae