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

mlebench/competitions/cassava-leaf-disease-classification/prepare_val.py

@@ -0,0 +1,186 @@
+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.competitions.utils import get_ids_from_tf_records
+from mlebench.utils import read_csv
+
+
+def _process_and_save_split(
+    train_df: pd.DataFrame,
+    test_df: pd.DataFrame,
+    train_tfrecords: list,
+    test_tfrecords: list,
+    public_dir: Path,
+    private_dir: Path,
+    raw_dir: Path,
+):
+    """
+    Helper function to process a single data split (train/test) and save all
+    associated files to the specified public and private directories.
+    """
+    # Create output directories
+    public_dir.mkdir(parents=True, exist_ok=True)
+    private_dir.mkdir(parents=True, exist_ok=True)
+
+    # --- Create and save CSV files ---
+    sample_submission = test_df.copy()
+    sample_submission["label"] = 4  # Default label for submission template
+
+    train_df.to_csv(public_dir / "train.csv", index=False)
+    test_df.to_csv(private_dir / "test.csv", index=False)  # Ground truth
+    sample_submission.to_csv(public_dir / "sample_submission.csv", index=False)
+
+    # --- Copy and rename TFRecord files ---
+    (public_dir / "train_tfrecords").mkdir(exist_ok=True)
+    for i, path in tqdm(
+        enumerate(train_tfrecords),
+        desc=f"Copying Train TFRecords to {public_dir.name}",
+        total=len(train_tfrecords),
+    ):
+        length = path.stem.split("-")[1]
+        new_name = f"ld_train{i:02d}-{length}.tfrec"
+        shutil.copy(path, public_dir / "train_tfrecords" / new_name)
+
+    (public_dir / "test_tfrecords").mkdir(exist_ok=True)
+    for i, path in tqdm(
+        enumerate(test_tfrecords),
+        desc=f"Copying Test TFRecords to {public_dir.name}",
+        total=len(test_tfrecords),
+    ):
+        length = path.stem.split("-")[1]
+        new_name = f"ld_test{i:02d}-{length}.tfrec"
+        shutil.copy(path, public_dir / "test_tfrecords" / new_name)
+
+    # --- Copy image files ---
+    (public_dir / "train_images").mkdir(exist_ok=True)
+    for image_id in tqdm(
+        train_df["image_id"],
+        desc=f"Copying Train Images to {public_dir.name}",
+        total=len(train_df),
+    ):
+        shutil.copy(raw_dir / "train_images" / image_id, public_dir / "train_images")
+
+    (public_dir / "test_images").mkdir(exist_ok=True)
+    for image_id in tqdm(
+        test_df["image_id"],
+        desc=f"Copying Test Images to {public_dir.name}",
+        total=len(test_df),
+    ):
+        shutil.copy(raw_dir / "train_images" / image_id, public_dir / "test_images")
+
+    # --- Copy auxiliary files ---
+    shutil.copy(raw_dir / "label_num_to_disease_map.json", public_dir)
+
+    # --- Perform checks for this split ---
+    assert len(train_df) + len(test_df) == len(train_df) + len(
+        test_df
+    ), f"Length check failed for {public_dir.name}"
+    assert len(sample_submission) == len(
+        test_df
+    ), f"Sample submission length mismatch for {public_dir.name}"
+
+    assert len(train_df) == sum(
+        1 for _ in (public_dir / "train_images").iterdir()
+    ), f"Train image count mismatch in {public_dir.name}"
+    assert len(test_df) == sum(
+        1 for _ in (public_dir / "test_images").iterdir()
+    ), f"Test image count mismatch in {public_dir.name}"
+
+    assert len(train_tfrecords) == sum(
+        1 for _ in (public_dir / "train_tfrecords").iterdir()
+    ), f"Train TFRecord count mismatch in {public_dir.name}"
+    assert len(test_tfrecords) == sum(
+        1 for _ in (public_dir / "test_tfrecords").iterdir()
+    ), f"Test TFRecord count mismatch in {public_dir.name}"
+
+    assert train_df.columns.tolist() == [
+        "image_id",
+        "label",
+    ], f"Train columns mismatch for {public_dir.name}"
+    assert test_df.columns.tolist() == [
+        "image_id",
+        "label",
+    ], f"Test columns mismatch for {public_dir.name}"
+    assert sample_submission.columns.tolist() == [
+        "image_id",
+        "label",
+    ], f"Sample submission columns mismatch for {public_dir.name}"
+
+    assert set(train_df["image_id"]).isdisjoint(
+        test_df["image_id"]
+    ), f"Train and test image IDs are not disjoint for {public_dir.name}"
+
+
+def prepare(raw: Path, public: Path, private: Path):
+    # Define paths for the new validation split
+    public_val = public.parent / "public_val"
+    private_val = private.parent / "private_val"
+
+    # need to split based on the TFRecord files, since not mentioned in the CSVs
+    tfrecord_files = [
+        path
+        for path in sorted((raw / "train_tfrecords").iterdir())
+        if path.is_file() and path.suffix == ".tfrec"
+    ]
+
+    # --- FIRST SPLIT: Create original train and test sets ---
+    # In the original there are 21397 train samples and they say test has ~15000 test samples, which is ~ 0.4/0.6 test/train split
+    # We use 0.1 ratio to avoid removing too many samples from train
+    train_tfrecords, test_tfrecords = train_test_split(
+        tfrecord_files, test_size=0.1, random_state=0
+    )
+
+    # parse the IDs from the test tf records
+    test_ids = []
+    for path in test_tfrecords:
+        test_ids.extend(get_ids_from_tf_records(path))
+
+    # Create dataframes for the first split
+    full_train_df = read_csv(raw / "train.csv")
+    train_df = full_train_df[~full_train_df["image_id"].isin(test_ids)].copy()
+    test_df = full_train_df[full_train_df["image_id"].isin(test_ids)].copy()
+
+    # Process and save the original split to 'public' and 'private'
+    # This ensures the original outputs are untouched
+    _process_and_save_split(
+        train_df=train_df,
+        test_df=test_df,
+        train_tfrecords=train_tfrecords,
+        test_tfrecords=test_tfrecords,
+        public_dir=public,
+        private_dir=private,
+        raw_dir=raw,
+    )
+
+    # --- SECOND SPLIT: Create new training and validation sets from the original train set ---
+    # The new training set from the first split becomes the source for this second split.
+    # A test_size of 1/9 on the train_tfrecords (which is 90% of the original data)
+    # results in a validation set that is 10% of the original total, matching the
+    # original test set size. (1/9 * 0.9 = 0.1)
+    train_val_tfrecords, test_val_tfrecords = train_test_split(
+        train_tfrecords, test_size=1 / 9, random_state=0
+    )
+
+    # Parse IDs for the validation set
+    test_val_ids = []
+    for path in test_val_tfrecords:
+        test_val_ids.extend(get_ids_from_tf_records(path))
+
+    # Create dataframes for the validation split using the original train_df
+    train_val_df = train_df[~train_df["image_id"].isin(test_val_ids)].copy()
+    test_val_df = train_df[train_df["image_id"].isin(test_val_ids)].copy()
+
+    # Process and save the validation split to 'public_val' and 'private_val'
+    _process_and_save_split(
+        train_df=train_val_df,
+        test_df=test_val_df,
+        train_tfrecords=train_val_tfrecords,
+        test_tfrecords=test_val_tfrecords,
+        public_dir=public_val,
+        private_dir=private_val,
+        raw_dir=raw,
+    )

mlebench/competitions/cdiscount-image-classification-challenge/grade.py

@@ -0,0 +1,11 @@
+import pandas as pd
+from sklearn.metrics import accuracy_score
+
+from mlebench.competitions.utils import prepare_for_accuracy_metric
+
+
+def grade(submission: pd.DataFrame, answers: pd.DataFrame) -> float:
+    accuracy_inputs = prepare_for_accuracy_metric(
+        submission=submission, answers=answers, target_column="category_id", id_column="_id"
+    )
+    return accuracy_score(**accuracy_inputs)

mlebench/competitions/cdiscount-image-classification-challenge/prepare.py

@@ -0,0 +1,144 @@
+import shutil
+from itertools import islice
+from pathlib import Path
+
+import bson
+import pandas as pd
+from sklearn.model_selection import train_test_split
+from tqdm import tqdm
+
+
+def prepare(raw: Path, public: Path, private: Path):
+    """
+    Splits the data in raw into public and private datasets with appropriate test/train splits.
+    """
+
+    dev_mode = False
+
+    def read_ids_and_category_ids(file_path: Path) -> pd.DataFrame:
+        data = bson.decode_file_iter(open(file_path, "rb"))
+
+        records = []
+
+        for c, d in enumerate(tqdm(data, desc="Reading BSON data")):
+            records.append({"_id": d["_id"], "category_id": d["category_id"]})
+
+        return pd.DataFrame(records)
+
+    def filter_bson_by_ids(
+        bson_file_path: Path,
+        ids: set,
+        write_path: Path,
+        exclude_cols: list = [],
+        chunk_size=1000,
+        max_rows=None,
+    ):
+        """
+        Filters a BSON file by a set of IDs and writes the filtered data to a new BSON file.
+        The original _id is replaced with a new _id starting from 0 and incrementing by 1.
+
+        Args:
+            bson_file_path (Path): Path to the input BSON file.
+            ids (set): Set of IDs to filter by.
+            write_path (Path): Path to the output BSON file.
+            exclude_cols (list): List of columns to exclude from the output.
+            max_rows (int, optional): Maximum number of rows to write to the output file.
+        """
+        data = bson.decode_file_iter(open(bson_file_path, "rb"))
+        num_written_rows = 0
+
+        with open(write_path, "wb") as f:
+            for record in tqdm(data, desc="Filtering BSON data"):
+                if record["_id"] in ids:
+                    for col in exclude_cols:
+                        if col in record:
+                            del record[col]
+                    num_written_rows += 1
+                    f.write(bson.BSON.encode(record))
+
+                if num_written_rows % chunk_size == 0:
+                    f.flush()
+
+                if max_rows is not None and num_written_rows >= max_rows:
+                    break
+
+    # Create train, test from train split. Original train.bson contains 7,069,896 rows. Original test.bson contains 1,768,182 rows.
+    old_train = read_ids_and_category_ids(raw / "train.bson")
+
+    # Ensure rows in train_example remain in new_train
+    new_train, answers = train_test_split(old_train, test_size=0.1, random_state=0)
+    answers = answers.sort_values(by="_id")
+
+    # Create sample submission
+    sample_submission = answers[["_id"]]
+    sample_submission["category_id"] = 1000010653
+
+    # Checks
+    assert len(new_train) + len(answers) == len(
+        old_train
+    ), f"The length of new_train and answers combined should be equal to the original length of old_train. Got {len(new_train) + len(answers)} and {len(old_train)}"
+    assert set(new_train["_id"]).isdisjoint(
+        set(answers["_id"])
+    ), "new_train and answers should not have any _ids in common"
+    assert sample_submission.columns.tolist() == [
+        "_id",
+        "category_id",
+    ], f"sample_submission should have columns _id and category_id. Got {sample_submission.columns.tolist()}"
+
+    # Write new files
+    answers.to_csv(private / "answers.csv", index=False)
+    sample_submission.to_csv(public / "sample_submission.csv", index=False)
+
+    filter_bson_by_ids(
+        bson_file_path=(
+            raw / "train_example.bson" if dev_mode else raw / "train.bson"
+        ),  # train_example.bson is the first 100 rows of train.bson
+        ids=set(new_train["_id"]),
+        write_path=public / "train.bson",
+    )
+    filter_bson_by_ids(
+        bson_file_path=raw / "train_example.bson" if dev_mode else raw / "train.bson",
+        ids=set(answers["_id"]),
+        write_path=public / "test.bson",
+        exclude_cols=["category_id"],  # removes category_id for test.bson
+    )
+
+    # Write new train_example.bson which is the first 100 rows of the new train.bson
+    filter_bson_by_ids(
+        bson_file_path=(
+            raw / "train_example.bson" if dev_mode else raw / "train.bson"
+        ),  # train_example.bson is the first 100 rows of train.bson
+        ids=set(new_train["_id"]),
+        write_path=public / "train_example.bson",
+        max_rows=100,
+    )
+
+    def is_valid_bson_file(file_path: Path, chunk_size: int = 10000):
+        try:
+            with open(file_path, "rb") as f:
+                data_iter = bson.decode_file_iter(f)
+                for chunk in tqdm(
+                    iter(lambda: list(islice(data_iter, chunk_size)), []),
+                    desc=f"Validating {file_path.name}",
+                ):
+                    pd.DataFrame(chunk)  # Attempt to create a DataFrame from the chunk
+        except Exception as e:
+            return False
+
+        return True
+
+    # Check train.bson
+    assert is_valid_bson_file(public / "train.bson"), f"Couldn't parse `train.bson` as a bson file!"
+
+    # Check test.bson
+    assert is_valid_bson_file(public / "test.bson"), f"Couldn't parse `test.bson` as a bson file!"
+
+    # Copy over other files
+    shutil.copy(raw / "category_names.csv", public / "category_names.csv")
+
+    actual_new_train = read_ids_and_category_ids(public / "train.bson")
+    actual_new_train_example = read_ids_and_category_ids(public / "train_example.bson")
+
+    assert actual_new_train.iloc[:100].equals(
+        actual_new_train_example
+    ), f"The first 100 rows of `train.bson` should be the same as `train_example.bson`"

mlebench/competitions/cdiscount-image-classification-challenge/prepare_val.py

@@ -0,0 +1,205 @@
+import shutil
+from itertools import islice
+from pathlib import Path
+
+import bson
+import pandas as pd
+from sklearn.model_selection import train_test_split
+from tqdm import tqdm
+
+
+def prepare(raw: Path, public: Path, private: Path):
+    """
+    Splits the data in raw into public and private datasets with appropriate test/train splits.
+    Also creates a secondary validation split in public_val/private_val directories.
+    """
+
+    dev_mode = False
+
+    def read_ids_and_category_ids(file_path: Path) -> pd.DataFrame:
+        data = bson.decode_file_iter(open(file_path, "rb"))
+
+        records = []
+
+        for c, d in enumerate(tqdm(data, desc="Reading BSON data")):
+            records.append({"_id": d["_id"], "category_id": d["category_id"]})
+
+        return pd.DataFrame(records)
+
+    def filter_bson_by_ids(
+        bson_file_path: Path,
+        ids: set,
+        write_path: Path,
+        exclude_cols: list = [],
+        chunk_size=1000,
+        max_rows=None,
+    ):
+        """
+        Filters a BSON file by a set of IDs and writes the filtered data to a new BSON file.
+        The original _id is replaced with a new _id starting from 0 and incrementing by 1.
+
+        Args:
+            bson_file_path (Path): Path to the input BSON file.
+            ids (set): Set of IDs to filter by.
+            write_path (Path): Path to the output BSON file.
+            exclude_cols (list): List of columns to exclude from the output.
+            max_rows (int, optional): Maximum number of rows to write to the output file.
+        """
+        data = bson.decode_file_iter(open(bson_file_path, "rb"))
+        num_written_rows = 0
+
+        with open(write_path, "wb") as f:
+            for record in tqdm(data, desc=f"Filtering BSON data for {write_path.name}"):
+                if record["_id"] in ids:
+                    for col in exclude_cols:
+                        if col in record:
+                            del record[col]
+                    num_written_rows += 1
+                    f.write(bson.BSON.encode(record))
+
+                if num_written_rows % chunk_size == 0:
+                    f.flush()
+
+                if max_rows is not None and num_written_rows >= max_rows:
+                    break
+
+    def is_valid_bson_file(file_path: Path, chunk_size: int = 10000):
+        try:
+            with open(file_path, "rb") as f:
+                data_iter = bson.decode_file_iter(f)
+                for chunk in tqdm(
+                    iter(lambda: list(islice(data_iter, chunk_size)), []),
+                    desc=f"Validating {file_path.name}",
+                ):
+                    pd.DataFrame(chunk)  # Attempt to create a DataFrame from the chunk
+        except Exception as e:
+            print(f"BSON validation failed for {file_path}: {e}")
+            return False
+
+        return True
+
+    def _process_and_write_split(
+        train_df: pd.DataFrame,
+        test_df: pd.DataFrame,
+        target_public_path: Path,
+        target_private_path: Path,
+    ):
+        """
+        Helper function to process a given train/test split and write all associated files
+        to the specified public and private directories.
+        """
+        # Create output directories
+        target_public_path.mkdir(exist_ok=True)
+        target_private_path.mkdir(exist_ok=True)
+        
+        # Sort test dataframe for consistency
+        answers = test_df.sort_values(by="_id")
+
+        # Create sample submission
+        sample_submission = answers[["_id"]]
+        sample_submission["category_id"] = 1000010653
+
+        # Basic integrity checks
+        assert set(train_df["_id"]).isdisjoint(
+            set(answers["_id"])
+        ), "Train and test sets should not have any _ids in common"
+        assert sample_submission.columns.tolist() == [
+            "_id",
+            "category_id",
+        ], f"sample_submission should have columns _id and category_id. Got {sample_submission.columns.tolist()}"
+
+        # Write new files
+        answers.to_csv(target_private_path / "answers.csv", index=False)
+        sample_submission.to_csv(target_public_path / "sample_submission.csv", index=False)
+
+        # Determine raw data source based on dev_mode
+        raw_bson_source = raw / "train_example.bson" if dev_mode else raw / "train.bson"
+
+        filter_bson_by_ids(
+            bson_file_path=raw_bson_source,
+            ids=set(train_df["_id"]),
+            write_path=target_public_path / "train.bson",
+        )
+        filter_bson_by_ids(
+            bson_file_path=raw_bson_source,
+            ids=set(answers["_id"]),
+            write_path=target_public_path / "test.bson",
+            exclude_cols=["category_id"],
+        )
+        filter_bson_by_ids(
+            bson_file_path=raw_bson_source,
+            ids=set(train_df["_id"]),
+            write_path=target_public_path / "train_example.bson",
+            max_rows=100,
+        )
+
+        # Validate generated BSON files
+        assert is_valid_bson_file(target_public_path / "train.bson")
+        assert is_valid_bson_file(target_public_path / "test.bson")
+        
+        # Copy over other files
+        shutil.copy(raw / "category_names.csv", target_public_path / "category_names.csv")
+
+        # Final check on train_example.bson content
+        actual_new_train = read_ids_and_category_ids(target_public_path / "train.bson")
+        actual_new_train_example = read_ids_and_category_ids(target_public_path / "train_example.bson")
+
+        assert actual_new_train.iloc[:100].equals(
+            actual_new_train_example
+        ), f"The first 100 rows of `train.bson` should be the same as `train_example.bson` in {target_public_path}"
+
+
+    # --- Main Script Logic ---
+
+    # Read the complete dataset IDs and categories
+    # Original train.bson contains 7,069,896 rows. Original test.bson contains 1,768,182 rows.
+    old_train = read_ids_and_category_ids(raw / "train.bson")
+
+    # === 1. Original Split: (train -> new_train + test) ===
+    # This split creates the primary competition data in `public` and `private`.
+    # This block is functionally identical to the original script to ensure outputs do not change.
+    print("--- Processing Original Split (public/private) ---")
+    new_train, answers = train_test_split(old_train, test_size=0.1, random_state=0)
+    
+    assert len(new_train) + len(answers) == len(
+        old_train
+    ), f"The length of new_train and answers combined should be equal to the original length of old_train. Got {len(new_train) + len(answers)} and {len(old_train)}"
+
+    _process_and_write_split(
+        train_df=new_train,
+        test_df=answers,
+        target_public_path=public,
+        target_private_path=private,
+    )
+    print("--- Original Split processing complete. ---")
+
+
+    # === 2. New Validation Split: (new_train -> train_val + test_val) ===
+    # This second split takes the `new_train` set from above and splits it again.
+    # The outputs are saved to new, parallel directories `public_val` and `private_val`.
+    print("\n--- Processing Validation Split (public_val/private_val) ---")
+    
+    # Define paths for the new validation set
+    public_val = public.parent / "public_val"
+    private_val = private.parent / "private_val"
+
+    # To make the new `test_val` set have a similar size to the original `test` set (10% of total),
+    # we must take a fraction of `new_train`. Since `new_train` is 90% of the total,
+    # we take 1/9 of it to get our new test set. (1/9) * 0.9 = 0.1
+    test_val_size_fraction = 1 / 9.0
+    
+    train_val, answers_val = train_test_split(
+        new_train, test_size=test_val_size_fraction, random_state=0
+    )
+
+    assert len(train_val) + len(answers_val) == len(
+        new_train
+    ), "The validation split did not partition the new_train set correctly."
+    
+    _process_and_write_split(
+        train_df=train_val,
+        test_df=answers_val,
+        target_public_path=public_val,
+        target_private_path=private_val,
+    )
+    print("--- Validation Split processing complete. ---")

mlebench/competitions/chaii-hindi-and-tamil-question-answering/grade.py

@@ -0,0 +1,67 @@
+from pandas import DataFrame
+from scipy.sparse import spmatrix
+from sklearn.metrics import jaccard_score
+from sklearn.preprocessing import MultiLabelBinarizer
+
+from mlebench.grade_helpers import InvalidSubmissionError
+
+
+def binarize_sentences(y_true: list[set[str]], y_pred: list[set[str]]) -> tuple[spmatrix, spmatrix]:
+    """
+    Binarizes lists of sentence sets so we can pass them as inputs to scipy.jaccard_score
+    """
+    all_words = list(set.union(*y_true, *y_pred))
+
+    mlb = MultiLabelBinarizer(classes=all_words, sparse_output=True)
+    y_true_bin = mlb.fit_transform(y_true)
+    y_pred_bin = mlb.transform(y_pred)
+
+    return y_true_bin, y_pred_bin
+
+
+def prepare_for_grading(
+    submission: DataFrame, answers: DataFrame, target_column: str
+) -> dict[str, spmatrix]:
+    """
+    Extracts the sentences from the dataframe
+    Splits them into sets of lowercased words
+    Binarizes these sets so we can pass them as inputs to scipy.jaccard_score
+    """
+
+    if len(submission) != len(answers):
+        raise InvalidSubmissionError("Submission should be the same length as the answers")
+    if target_column not in submission.columns:
+        raise InvalidSubmissionError(f"Submission must have a `{target_column}` column")
+    if "id" not in submission.columns:
+        raise InvalidSubmissionError("Submission must have an `id` column")
+    assert target_column in answers.columns, f"Answers must have a `{target_column}` column"
+    assert "id" in answers.columns, "Answers must have an `id` column"
+
+    submission = submission.sort_values("id")
+    answers = answers.sort_values("id")
+
+    if (submission["id"].values != answers["id"].values).any():
+        raise InvalidSubmissionError("Submission does not contain same IDs as test")
+
+    # pandas reads empty cells as NaNs, which are float. We fill with empty string to match type
+    submission[target_column] = submission[target_column].fillna("")
+    answers[target_column] = answers[target_column].fillna("")
+
+    y_pred = submission[target_column].tolist()
+    y_true = answers[target_column].tolist()
+
+    # split into sets of words
+    y_pred_sentence_sets = [set(sentence.lower().split()) for sentence in y_pred]
+    y_true_sentence_sets = [set(sentence.lower().split()) for sentence in y_true]
+
+    # binarize for jaccard_score
+    y_true_bin, y_pred_bin = binarize_sentences(y_true_sentence_sets, y_pred_sentence_sets)
+
+    return {"y_pred": y_pred_bin, "y_true": y_true_bin}
+
+
+def grade(submission: DataFrame, answers: DataFrame) -> float:
+    grading_input = prepare_for_grading(submission, answers, "PredictionString")
+
+    # we use average=`samples` to match what the competition description suggests
+    return jaccard_score(**grading_input, average="samples")

mlebench/competitions/chaii-hindi-and-tamil-question-answering/prepare.py

@@ -0,0 +1,31 @@
+from pathlib import Path
+
+from sklearn.model_selection import train_test_split
+
+from mlebench.utils import read_csv
+
+
+def prepare(raw: Path, public: Path, private: Path):
+
+    # Create train, test from train split
+    old_train = read_csv(raw / "train.csv")
+    new_train, new_test = train_test_split(old_train, test_size=0.1, random_state=0)
+    new_test_without_labels = new_test.drop(columns=["answer_start", "answer_text"])
+
+    # make private test match submission format
+    new_test = new_test[["id", "answer_text"]]
+    new_test.columns = ["id", "PredictionString"]
+
+    # Copy over files
+    new_train.to_csv(public / "train.csv", index=False)
+    new_test_without_labels.to_csv(public / "test.csv", index=False)
+    new_test.to_csv(private / "test.csv", index=False)
+
+    # Create sample submission
+    sample_submission = new_test.copy()
+    sample_submission["PredictionString"] = "dummy text"
+    sample_submission.to_csv(public / "sample_submission.csv", index=False)
+
+    assert len(sample_submission) == len(
+        new_test
+    ), "Sample submission length does not match test length."