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

mlebench/competitions/siim-isic-melanoma-classification/prepare.py

@@ -0,0 +1,127 @@
+import shutil
+from pathlib import Path
+
+import pandas as pd
+from tqdm.auto import tqdm
+
+from mlebench.competitions.utils import get_ids_from_tf_records
+from mlebench.utils import get_logger
+
+logger = get_logger(__name__)
+
+
+def prepare(raw: Path, public: Path, private: Path):
+    # split on the TFRecord files.
+    # There's 33126 train samples; 16 TFRecord files with 2071 samples each
+    # so we take 2 arbitrary TF record files as our test set (4142 samples is ~ 10% of data)
+    DEV = False
+    if DEV:
+        cutoff_index = 10000
+    else:
+        cutoff_index = None
+
+    old_train = pd.read_csv(raw / "train.csv")[:cutoff_index]
+
+    test_tf_records = {"train00-2071.tfrec", "train06-2071.tfrec"}
+    # parse the IDs from the test tf records
+    test_ids = []
+    for tfrec in tqdm(test_tf_records, desc="Splitting test ids from train TFRecords"):
+        test_ids.extend(get_ids_from_tf_records(raw / "tfrecords" / tfrec))
+
+    old_train["split"] = "train"
+    old_train.loc[old_train["image_name"].isin(test_ids), "split"] = "test"
+
+    new_train = old_train[old_train["split"] == "train"].drop(columns=["split"])
+    new_test = old_train[old_train["split"] == "test"].drop(columns=["split"])
+    new_test_without_labels = new_test.copy()[
+        ["image_name", "patient_id", "sex", "age_approx", "anatom_site_general_challenge"]
+    ]
+
+    # match format of sample submission
+    new_test = new_test[["image_name", "target"]]
+
+    # sample submission
+    sample_submission = new_test.copy()
+    sample_submission["target"] = 0
+
+    # save the CSVs
+    new_train.to_csv(public / "train.csv", index=False)
+    new_test_without_labels.to_csv(public / "test.csv", index=False)
+    sample_submission.to_csv(public / "sample_submission.csv", index=False)
+    new_test.to_csv(private / "test.csv", index=False)
+
+    # split raw train files to into appropriate prepared/public/test/train directories
+    # the files themselves do not contain target metadata so we are free to move them around
+    # DICOMs and JPEGs
+    (public / "train").mkdir(parents=True, exist_ok=True)
+    (public / "jpeg" / "train").mkdir(parents=True, exist_ok=True)
+    for image_name in tqdm(new_train["image_name"], desc="Train Images", total=len(new_train)):
+        dcm_file = raw / "train" / f"{image_name}.dcm"
+        jpg_file = raw / "jpeg" / "train" / f"{image_name}.jpg"
+        shutil.copy(dcm_file, public / "train" / f"{image_name}.dcm")
+        shutil.copy(jpg_file, public / "jpeg" / "train" / f"{image_name}.jpg")
+    (public / "test").mkdir(parents=True, exist_ok=True)
+    (public / "jpeg" / "test").mkdir(parents=True, exist_ok=True)
+    for image_name in tqdm(new_test["image_name"], desc="Test Images", total=len(new_test)):
+        dcm_file = raw / "train" / f"{image_name}.dcm"
+        jpg_file = raw / "jpeg" / "train" / f"{image_name}.jpg"
+        shutil.copy(dcm_file, public / "test" / f"{image_name}.dcm")
+        shutil.copy(jpg_file, public / "jpeg" / "test" / f"{image_name}.jpg")
+
+    # TFRecords
+    train_count = 0
+    test_count = 0
+    tfrecords_dest_path = public / "tfrecords"
+    tfrecords_dest_path.mkdir(parents=True, exist_ok=True)
+    for file in tqdm(
+        sorted((raw / "tfrecords").glob("train*.tfrec")), desc="Copying TFRecord files"
+    ):
+        record_count = file.stem.split("-")[1]  # i.e. get 2071 from train00-2071
+        if file.name in test_tf_records:
+            shutil.copy(file, tfrecords_dest_path / f"test{test_count:02d}-{record_count}.tfrec")
+            test_count += 1
+        else:
+            shutil.copy(file, tfrecords_dest_path / f"train{train_count:02d}-{record_count}.tfrec")
+            train_count += 1
+
+    logger.info("Running asserts...")
+    assert len(list(public.glob("train/*.dcm"))) == len(new_train), "Train DICOM count mismatch"
+    assert len(list(public.glob("test/*.dcm"))) == len(new_test), "Test DICOM count mismatch"
+    assert len(list(public.glob("jpeg/train/*.jpg"))) == len(new_train), "Train JPEG count mismatch"
+    assert len(list(public.glob("jpeg/test/*.jpg"))) == len(new_test), "Test JPEG count mismatch"
+
+    assert not set(new_train["image_name"]).intersection(
+        new_test["image_name"]
+    ), "Train/Test overlap"
+
+    assert len(sample_submission) == len(new_test), "Sample submission length mismatch"
+    assert (
+        sample_submission["image_name"]
+        .sort_values()
+        .reset_index(drop=True)
+        .equals(new_test["image_name"].sort_values().reset_index(drop=True))
+    ), "Sample submission IDs mismatch"
+
+    # check columns
+    assert new_test_without_labels.columns.tolist() == [
+        "image_name",
+        "patient_id",
+        "sex",
+        "age_approx",
+        "anatom_site_general_challenge",
+    ], "new_test_without_labels columns mismatch"
+    assert new_train.columns.tolist() == [
+        "image_name",
+        "patient_id",
+        "sex",
+        "age_approx",
+        "anatom_site_general_challenge",
+        "diagnosis",
+        "benign_malignant",
+        "target",
+    ], "new_train columns mismatch"
+    assert new_test.columns.tolist() == ["image_name", "target"], "new_test columns mismatch"
+    assert sample_submission.columns.tolist() == [
+        "image_name",
+        "target",
+    ], "sample_submission columns mismatch"

mlebench/competitions/siim-isic-melanoma-classification/prepare_val.py

@@ -0,0 +1,158 @@
+import shutil
+from pathlib import Path
+from typing import Set, List
+
+import pandas as pd
+from tqdm.auto import tqdm
+
+from mlebench.competitions.utils import get_ids_from_tf_records
+from mlebench.utils import get_logger
+
+logger = get_logger(__name__)
+
+
+def _get_ids_from_tfrec_set(raw_path: Path, tfrec_set: Set[str]) -> List[str]:
+    """Helper function to parse image IDs from a given set of TFRecord files."""
+    ids = []
+    for tfrec_name in tqdm(tfrec_set, desc="Splitting IDs from TFRecords"):
+        ids.extend(get_ids_from_tf_records(raw_path / "tfrecords" / tfrec_name))
+    return ids
+
+
+def _create_dataset_files(
+    train_df: pd.DataFrame,
+    test_df: pd.DataFrame,
+    source_tfrec_files: List[Path],
+    test_tfrec_set: Set[str],
+    raw_path: Path,
+    public_path: Path,
+    private_path: Path,
+):
+    """
+    Core function to generate all files for a given train/test split.
+    This includes CSVs, image files (JPG, DCM), and TFRecords.
+    """
+    # Create destination directories
+    public_path.mkdir(parents=True, exist_ok=True)
+    private_path.mkdir(parents=True, exist_ok=True)
+
+    # Prepare dataframes for saving
+    test_df_without_labels = test_df.copy()[
+        ["image_name", "patient_id", "sex", "age_approx", "anatom_site_general_challenge"]
+    ]
+    test_df_with_labels = test_df[["image_name", "target"]]
+    sample_submission = test_df_with_labels.copy()
+    sample_submission["target"] = 0
+
+    # Save the CSVs
+    train_df.to_csv(public_path / "train.csv", index=False)
+    test_df_without_labels.to_csv(public_path / "test.csv", index=False)
+    sample_submission.to_csv(public_path / "sample_submission.csv", index=False)
+    test_df_with_labels.to_csv(private_path / "test.csv", index=False)
+
+    # Copy image files (DICOMs and JPEGs)
+    (public_path / "train").mkdir(parents=True, exist_ok=True)
+    (public_path / "jpeg" / "train").mkdir(parents=True, exist_ok=True)
+    for image_name in tqdm(train_df["image_name"], desc=f"Train Images -> {public_path.name}", total=len(train_df)):
+        shutil.copy(raw_path / "train" / f"{image_name}.dcm", public_path / "train" / f"{image_name}.dcm")
+        shutil.copy(raw_path / "jpeg" / "train" / f"{image_name}.jpg", public_path / "jpeg" / "train" / f"{image_name}.jpg")
+
+    (public_path / "test").mkdir(parents=True, exist_ok=True)
+    (public_path / "jpeg" / "test").mkdir(parents=True, exist_ok=True)
+    for image_name in tqdm(test_df["image_name"], desc=f"Test Images -> {public_path.name}", total=len(test_df)):
+        shutil.copy(raw_path / "train" / f"{image_name}.dcm", public_path / "test" / f"{image_name}.dcm")
+        shutil.copy(raw_path / "jpeg" / "train" / f"{image_name}.jpg", public_path / "jpeg" / "test" / f"{image_name}.jpg")
+
+    # Copy and rename TFRecords
+    train_count = 0
+    test_count = 0
+    tfrecords_dest_path = public_path / "tfrecords"
+    tfrecords_dest_path.mkdir(parents=True, exist_ok=True)
+    for file in tqdm(source_tfrec_files, desc=f"Copying TFRecords -> {public_path.name}"):
+        record_count = file.stem.split("-")[1]
+        if file.name in test_tfrec_set:
+            shutil.copy(file, tfrecords_dest_path / f"test{test_count:02d}-{record_count}.tfrec")
+            test_count += 1
+        else:
+            shutil.copy(file, tfrecords_dest_path / f"train{train_count:02d}-{record_count}.tfrec")
+            train_count += 1
+
+    # Assertions to ensure data integrity
+    logger.info(f"Running asserts for {public_path.name} split...")
+    assert len(list(public_path.glob("train/*.dcm"))) == len(train_df), "Train DICOM count mismatch"
+    assert len(list(public_path.glob("test/*.dcm"))) == len(test_df), "Test DICOM count mismatch"
+    assert len(list(public_path.glob("jpeg/train/*.jpg"))) == len(train_df), "Train JPEG count mismatch"
+    assert len(list(public_path.glob("jpeg/test/*.jpg"))) == len(test_df), "Test JPEG count mismatch"
+    assert not set(train_df["image_name"]).intersection(test_df["image_name"]), "Train/Test overlap"
+    assert len(sample_submission) == len(test_df), "Sample submission length mismatch"
+    assert (
+        sample_submission["image_name"].sort_values().reset_index(drop=True)
+        .equals(test_df["image_name"].sort_values().reset_index(drop=True))
+    ), "Sample submission IDs mismatch"
+
+
+def prepare(raw: Path, public: Path, private: Path):
+    # Common setup
+    DEV = False
+    cutoff_index = 10000 if DEV else None
+    all_data_df = pd.read_csv(raw / "train.csv")[:cutoff_index]
+    all_raw_tfrec_files = sorted((raw / "tfrecords").glob("train*.tfrec"))
+
+    # --- 1. Original Competition Split (train -> train/test) ---
+    logger.info("--- Creating original public/private split ---")
+
+    # The original split used 2 arbitrary TFRecord files as the test set
+    original_test_tfrec_set = {"train00-2071.tfrec", "train06-2071.tfrec"}
+    original_test_ids = _get_ids_from_tfrec_set(raw, original_test_tfrec_set)
+
+    # Split the main dataframe
+    all_data_df["split"] = "train"
+    all_data_df.loc[all_data_df["image_name"].isin(original_test_ids), "split"] = "test"
+    
+    # These are the final dataframes for the original competition
+    final_train_df = all_data_df[all_data_df["split"] == "train"].drop(columns=["split"])
+    final_test_df = all_data_df[all_data_df["split"] == "test"].drop(columns=["split"])
+
+    # Create all files for the original split
+    _create_dataset_files(
+        train_df=final_train_df,
+        test_df=final_test_df,
+        source_tfrec_files=all_raw_tfrec_files,
+        test_tfrec_set=original_test_tfrec_set,
+        raw_path=raw,
+        public_path=public,
+        private_path=private,
+    )
+
+    # --- 2. New Validation Split (train -> train_val/test_val) ---
+    logger.info("--- Creating new public_val/private_val split ---")
+
+    # Define new directories for the validation set
+    public_val = public.parent / "public_val"
+    private_val = private.parent / "private_val"
+
+    # The source for this new split is the *training* data from the *first* split.
+    # We replicate the split logic by taking 2 TFRecord files for the validation-test set.
+    val_source_tfrec_files = [f for f in all_raw_tfrec_files if f.name not in original_test_tfrec_set]
+    val_test_tfrec_set = {"train01-2071.tfrec", "train02-2071.tfrec"}
+    val_test_ids = _get_ids_from_tfrec_set(raw, val_test_tfrec_set)
+
+    # Split the *training dataframe* from the first split to create the new sets
+    final_train_df["split"] = "train_val"
+    final_train_df.loc[final_train_df["image_name"].isin(val_test_ids), "split"] = "test_val"
+    
+    train_val_df = final_train_df[final_train_df["split"] == "train_val"].drop(columns=["split"])
+    test_val_df = final_train_df[final_train_df["split"] == "test_val"].drop(columns=["split"])
+
+    # Create all files for the new validation split
+    _create_dataset_files(
+        train_df=train_val_df,
+        test_df=test_val_df,
+        source_tfrec_files=val_source_tfrec_files,
+        test_tfrec_set=val_test_tfrec_set,
+        raw_path=raw,
+        public_path=public_val,
+        private_path=private_val,
+    )
+
+    logger.info("--- Data preparation complete for all splits. ---")

mlebench/competitions/smartphone-decimeter-2022/grade.py

@@ -0,0 +1,55 @@
+import numpy as np
+from pandas import DataFrame
+
+from mlebench.grade_helpers import InvalidSubmissionError
+
+from .notebook import calc_score as get_score
+
+
+def grade(submission: DataFrame, answers: DataFrame) -> float:
+    assert "tripId" in answers.columns, "Answers DataFrame must have a 'tripId' column."
+    assert (
+        "UnixTimeMillis" in answers.columns
+    ), "Answers DataFrame must have a 'UnixTimeMillis' column."
+    assert (
+        "LatitudeDegrees" in answers.columns
+    ), "Answers DataFrame must have a 'LatitudeDegrees' column."
+    assert (
+        "LongitudeDegrees" in answers.columns
+    ), "Answers DataFrame must have a 'LongitudeDegrees' column."
+
+    if "tripId" not in submission.columns:
+        raise InvalidSubmissionError("Submission DataFrame must have a 'tripId' column.")
+
+    if "UnixTimeMillis" not in submission.columns:
+        raise InvalidSubmissionError("Submission DataFrame must have a 'UnixTimeMillis' column.")
+
+    if "LatitudeDegrees" not in submission.columns:
+        raise InvalidSubmissionError("Submission DataFrame must have a 'LatitudeDegrees' column.")
+
+    if "LongitudeDegrees" not in submission.columns:
+        raise InvalidSubmissionError("Submission DataFrame must have a 'LongitudeDegrees' column.")
+
+    if len(submission) != len(answers):
+        raise InvalidSubmissionError(
+            "Submission and answers DataFrames must have the same number of rows."
+        )
+
+    scores = []
+    trip_ids = answers["tripId"].unique()
+
+    for trip_id in trip_ids:
+        filtered_answers = answers[answers["tripId"] == trip_id]
+        filtered_submission = submission[submission["tripId"] == trip_id]
+
+        if len(filtered_submission) != len(filtered_answers):
+            raise InvalidSubmissionError(
+                "Submission and answers DataFrames must have the same number of rows for each 'tripId'."
+                f"Got {len(filtered_submission)} rows in the submission and {len(filtered_answers)} rows "
+                f"in the answers for tripId {trip_id}."
+            )
+
+        score = get_score(filtered_submission, filtered_answers)
+        scores.append(score)
+
+    return np.mean(scores)

mlebench/competitions/smartphone-decimeter-2022/notebook.py

@@ -0,0 +1,86 @@
+"""
+Helper functions from the Kaggle notebook `GSDC2 - baseline submission`.
+Adapted from https://www.kaggle.com/code/saitodevel01/gsdc2-baseline-submission.
+"""
+
+from dataclasses import dataclass
+
+import numpy as np
+
+WGS84_SEMI_MAJOR_AXIS = 6378137.0
+WGS84_SEMI_MINOR_AXIS = 6356752.314245
+WGS84_SQUARED_FIRST_ECCENTRICITY = 6.69437999013e-3
+WGS84_SQUARED_SECOND_ECCENTRICITY = 6.73949674226e-3
+
+HAVERSINE_RADIUS = 6_371_000
+
+
+@dataclass
+class ECEF:
+    x: np.array
+    y: np.array
+    z: np.array
+
+    def to_numpy(self):
+        return np.stack([self.x, self.y, self.z], axis=0)
+
+    @staticmethod
+    def from_numpy(pos):
+        x, y, z = [np.squeeze(w) for w in np.split(pos, 3, axis=-1)]
+        return ECEF(x=x, y=y, z=z)
+
+
+@dataclass
+class BLH:
+    lat: np.array
+    lng: np.array
+    hgt: np.array
+
+
+def ECEF_to_BLH(ecef):
+    a = WGS84_SEMI_MAJOR_AXIS
+    b = WGS84_SEMI_MINOR_AXIS
+    e2 = WGS84_SQUARED_FIRST_ECCENTRICITY
+    e2_ = WGS84_SQUARED_SECOND_ECCENTRICITY
+    x = ecef.x
+    y = ecef.y
+    z = ecef.z
+    r = np.sqrt(x**2 + y**2)
+    t = np.arctan2(z * (a / b), r)
+    B = np.arctan2(z + (e2_ * b) * np.sin(t) ** 3, r - (e2 * a) * np.cos(t) ** 3)
+    L = np.arctan2(y, x)
+    n = a / np.sqrt(1 - e2 * np.sin(B) ** 2)
+    H = (r / np.cos(B)) - n
+
+    return BLH(lat=B, lng=L, hgt=H)
+
+
+def haversine_distance(blh_1, blh_2):
+    dlat = blh_2.lat - blh_1.lat
+    dlng = blh_2.lng - blh_1.lng
+    a = np.sin(dlat / 2) ** 2 + np.cos(blh_1.lat) * np.cos(blh_2.lat) * np.sin(dlng / 2) ** 2
+    dist = 2 * HAVERSINE_RADIUS * np.arcsin(np.sqrt(a))
+
+    return dist
+
+
+def pandas_haversine_distance(df1, df2):
+    blh1 = BLH(
+        lat=np.deg2rad(df1["LatitudeDegrees"].to_numpy()),
+        lng=np.deg2rad(df1["LongitudeDegrees"].to_numpy()),
+        hgt=0,
+    )
+
+    blh2 = BLH(
+        lat=np.deg2rad(df2["LatitudeDegrees"].to_numpy()),
+        lng=np.deg2rad(df2["LongitudeDegrees"].to_numpy()),
+        hgt=0,
+    )
+
+    return haversine_distance(blh1, blh2)
+
+
+def calc_score(pred_df, gt_df):
+    d = pandas_haversine_distance(pred_df, gt_df)
+    score = np.mean([np.quantile(d, 0.50), np.quantile(d, 0.95)])
+    return score

mlebench/competitions/smartphone-decimeter-2022/prepare.py

@@ -0,0 +1,143 @@
+import shutil
+from pathlib import Path
+
+import pandas as pd
+from sklearn.model_selection import train_test_split
+
+
+def get_date(s: str) -> str:
+    """Gets date from string in the format YYYY-MM-DD-X where `X` is an arbitrary string."""
+
+    split = s.split("-")
+
+    assert (
+        len(split) >= 3
+    ), f"Expected the string to have at least 3 parts separated by `-`. Got {len(split)} parts."
+
+    year, month, day = split[:3]
+
+    assert (
+        isinstance(year, str) and year.isdigit()
+    ), f"Expected the year to be a string of digits. Got {year} instead."
+
+    assert (
+        isinstance(month, str) and month.isdigit()
+    ), f"Expected the month to be a string of digits. Got {month} instead."
+
+    assert (
+        isinstance(day, str) and day.isdigit()
+    ), f"Expected the day to be a string of digits. Got {day} instead."
+
+    date = f"{year}-{month.zfill(2)}-{day.zfill(2)}"
+
+    return date
+
+
+def prepare(raw: Path, public: Path, private: Path) -> None:
+    old_train_ids = sorted([folder.name for folder in (raw / "train").glob("*") if folder.is_dir()])
+    dates = sorted(set([get_date(s) for s in old_train_ids]))
+    new_train_dates, new_test_dates = train_test_split(dates, test_size=0.1, random_state=0)
+
+    assert (
+        len(new_train_dates) >= 1
+    ), "Expected the new train set to have at least one date. Got 0 dates."
+
+    assert (
+        len(new_test_dates) >= 1
+    ), "Expected the new test set to have at least one date. Got 0 dates."
+
+    new_train_ids = sorted([i for i in old_train_ids if get_date(i) in new_train_dates])
+    new_test_ids = sorted([i for i in old_train_ids if get_date(i) in new_test_dates])
+
+    assert len(set(new_train_ids).intersection(set(new_test_ids))) == 0, (
+        f"Expected the new train and test instances to be disjoint. Got an intersection of "
+        f"{set(new_train_ids).intersection(set(new_test_ids))}."
+    )
+
+    assert len(new_train_ids) + len(new_test_ids) == len(old_train_ids), (
+        f"Expected the number of new train and test instances to sum up to the number of old train "
+        f"instances. Got {len(new_train_ids)} new train instances and {len(new_test_ids)} new test "
+        f"instances which sum to {len(new_train_ids) + len(new_test_ids)} instead of "
+        f"{len(old_train_ids)}."
+    )
+
+    assert set(new_train_ids).intersection(new_test_ids) == set(), (
+        f"Expected the new train and test instances to be disjoint. Got an intersection of "
+        f"{set(new_train_ids).intersection(new_test_ids)}."
+    )
+
+    for new_train_id in new_train_ids:
+        shutil.copytree(
+            src=raw / "train" / new_train_id,
+            dst=public / "train" / new_train_id,
+        )
+
+    for new_test_id in new_test_ids:
+        shutil.copytree(
+            src=raw / "train" / new_test_id,
+            dst=public / "test" / new_test_id,
+        )
+
+    # Construct test set by concatenating all ground truth csvs for the test journeys
+    dfs = []
+
+    for fpath in sorted((public / "test").rglob("ground_truth.csv")):
+        drive_id = fpath.parent.parent.name
+        phone_id = fpath.parent.name
+
+        assert (
+            drive_id in new_test_ids
+        ), f"Expected the drive {drive_id} to be one of the new test instances. Got {drive_id} instead."
+
+        raw_df = pd.read_csv(fpath)
+        df = raw_df.copy()
+        df.loc[:, "tripId"] = f"{drive_id}-{phone_id}"
+        df = df[["tripId", "UnixTimeMillis", "LatitudeDegrees", "LongitudeDegrees"]]
+        dfs.append(df)
+
+    new_test = pd.concat(dfs, ignore_index=True)
+    new_test.to_csv(private / "test.csv", index=False)
+
+    for fpath in (public / "test").rglob("ground_truth.csv"):
+        fpath.unlink()  # don't include ground truth in public test data
+
+    shutil.copytree(
+        src=raw / "metadata",
+        dst=public / "metadata",
+    )
+
+    actual_journey_ids = set(["-".join(s.split("-")[:-1]) for s in new_test["tripId"]])
+
+    assert len(actual_journey_ids) == len(new_test_ids), (
+        f"Expected the new test instances to have {len(new_test_ids)} unique trip IDs. Got "
+        f"{len(new_test['tripId'].unique())} unique trip IDs."
+    )
+
+    sample_submission = new_test.copy()
+    sample_submission.loc[:, "LatitudeDegrees"] = 37.904611315634504
+    sample_submission.loc[:, "LongitudeDegrees"] = -86.48107806249548
+
+    assert len(sample_submission) == len(new_test), (
+        f"Expected the sample submission to have the same number of instances as the new test "
+        f"instances. Got {len(sample_submission)} instances in the sample submission and "
+        f"{len(new_test)} new test instances."
+    )
+
+    sample_submission.to_csv(public / "sample_submission.csv", index=False)
+
+    assert sorted(list(public.glob("train/*"))) == sorted(
+        set([public / "train" / drive_id for drive_id in new_train_ids])
+    ), "Expected the public train directory to contain the new train instances."
+
+    assert sorted(list(public.glob("test/*"))) == sorted(
+        set([public / "test" / drive_id for drive_id in new_test_ids])
+    ), "Expected the public test directory to contain the new test instances."
+
+    assert (
+        len(list((public / "test").rglob("ground_truth.csv"))) == 0
+    ), "Expected the public test directory to not contain any ground truth files."
+
+    assert len(list((public / "train").rglob("ground_truth.csv"))) >= len(new_train_ids), (
+        "Expected the public train directory to contain at least one ground truth file per new "
+        "train instance."
+    )