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

mlebench/competitions/petfinder-pawpularity-score/prepare.py

@@ -0,0 +1,76 @@
+import shutil
+from pathlib import Path
+
+import numpy as np
+from sklearn.model_selection import train_test_split
+from tqdm.auto import tqdm
+
+from mlebench.utils import read_csv
+
+
+def prepare(raw: Path, public: Path, private: Path):
+
+    old_train = read_csv(raw / "train.csv")
+
+    np_rng = np.random.default_rng(0)
+
+    # Original ratio: 6800/(9912 + 6800) = ~ 0.41 test_size
+    # We use 0.1 ratio to avoid taking out too many samples from train
+    new_train, new_test = train_test_split(old_train, test_size=0.1, random_state=0)
+
+    new_test_without_labels = new_test.drop(columns=["Pawpularity"])
+
+    # random floats between 1 and 100 inclusive, with 2 decimal places
+    sample_submission = new_test[["Id", "Pawpularity"]].copy()
+    sample_submission["Pawpularity"] = np_rng.uniform(1, 100, len(sample_submission)).round(2)
+
+    new_train.to_csv(public / "train.csv", index=False)
+    new_test.to_csv(private / "test.csv", index=False)
+    new_test_without_labels.to_csv(public / "test.csv", index=False)
+    sample_submission.to_csv(public / "sample_submission.csv", index=False)
+
+    (public / "train").mkdir(exist_ok=True)
+    for img_id in tqdm(new_train["Id"], desc="Copying train images", total=len(new_train)):
+        shutil.copy(raw / "train" / f"{img_id}.jpg", public / "train" / f"{img_id}.jpg")
+
+    (public / "test").mkdir(exist_ok=True)
+    for img_id in tqdm(
+        new_test_without_labels["Id"],
+        desc="Copying test images",
+        total=len(new_test_without_labels),
+    ):
+        shutil.copy(raw / "train" / f"{img_id}.jpg", public / "test" / f"{img_id}.jpg")
+
+    # checks
+    assert len(new_train) + len(new_test) == len(
+        old_train
+    ), "Train and test length should sum to the original train length"
+    assert len(sample_submission) == len(
+        new_test
+    ), "Sample submission should have the same length as the test set"
+
+    assert (
+        new_train.columns.tolist() == old_train.columns.tolist()
+    ), "Old and new train columns should match"
+    assert (
+        new_test_without_labels.columns.tolist() == new_train.columns.tolist()[:-1]
+    ), "Public test columns should match train columns, minus the target column"
+    assert (
+        new_test.columns.tolist() == new_train.columns.tolist()
+    ), "Private test columns should match train columns"
+    assert sample_submission.columns.tolist() == [
+        "Id",
+        "Pawpularity",
+    ], "Sample submission columns should be Id, Pawpularity"
+
+    assert set(new_train["Id"]).isdisjoint(
+        set(new_test["Id"])
+    ), "Train and test ids should not overlap"
+
+    # check copy was successful
+    assert len(list((public / "train").glob("*.jpg"))) == len(
+        new_train
+    ), "Train images should match the train set"
+    assert len(list((public / "test").glob("*.jpg"))) == len(
+        new_test
+    ), "Test images should match the test set"

mlebench/competitions/petfinder-pawpularity-score/prepare_val.py

@@ -0,0 +1,154 @@
+import shutil
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+from sklearn.model_selection import train_test_split
+from tqdm.auto import tqdm
+
+from mlebench.utils import read_csv
+
+
+def _process_split(
+    source_df: pd.DataFrame,
+    public_dir: Path,
+    private_dir: Path,
+    raw_images_dir: Path,
+    test_size: float,
+    random_state: int,
+):
+    """
+    Processes a single data split, creating train/test sets and associated files.
+
+    This helper function encapsulates the logic for:
+    1. Splitting a dataframe into train and test sets.
+    2. Creating public and private directories.
+    3. Saving train.csv, test.csv (public), test.csv (private), and sample_submission.csv.
+    4. Copying the corresponding images.
+    5. Running assertions to verify the split.
+
+    Args:
+        source_df (pd.DataFrame): The dataframe to be split.
+        public_dir (Path): The public output directory.
+        private_dir (Path): The private output directory.
+        raw_images_dir (Path): The directory containing the source raw images.
+        test_size (float): The proportion of the dataset to allocate to the test split.
+        random_state (int): The random state for reproducibility.
+
+    Returns:
+        pd.DataFrame: The train portion of the split dataframe.
+    """
+    # Create output directories
+    public_dir.mkdir(exist_ok=True, parents=True)
+    private_dir.mkdir(exist_ok=True, parents=True)
+
+    # Perform the split
+    train_df, test_df = train_test_split(
+        source_df, test_size=test_size, random_state=random_state
+    )
+
+    test_df_without_labels = test_df.drop(columns=["Pawpularity"])
+
+    # Create a sample submission file
+    np_rng = np.random.default_rng(random_state)
+    sample_submission = test_df[["Id", "Pawpularity"]].copy()
+    sample_submission["Pawpularity"] = np_rng.uniform(1, 100, len(sample_submission)).round(2)
+
+    # Save CSV files
+    train_df.to_csv(public_dir / "train.csv", index=False)
+    test_df.to_csv(private_dir / "test.csv", index=False)
+    test_df_without_labels.to_csv(public_dir / "test.csv", index=False)
+    sample_submission.to_csv(public_dir / "sample_submission.csv", index=False)
+
+    # Copy train images
+    (public_dir / "train").mkdir(exist_ok=True)
+    for img_id in tqdm(
+        train_df["Id"], desc=f"Copying train images to {public_dir.name}", total=len(train_df)
+    ):
+        shutil.copy(raw_images_dir / f"{img_id}.jpg", public_dir / "train" / f"{img_id}.jpg")
+
+    # Copy test images
+    (public_dir / "test").mkdir(exist_ok=True)
+    for img_id in tqdm(
+        test_df_without_labels["Id"],
+        desc=f"Copying test images to {public_dir.name}",
+        total=len(test_df_without_labels),
+    ):
+        shutil.copy(raw_images_dir / f"{img_id}.jpg", public_dir / "test" / f"{img_id}.jpg")
+
+    # checks
+    assert len(train_df) + len(test_df) == len(
+        source_df
+    ), "Train and test length should sum to the source df length"
+    assert len(sample_submission) == len(
+        test_df
+    ), "Sample submission should have the same length as the test set"
+    assert (
+        train_df.columns.tolist() == source_df.columns.tolist()
+    ), "Train columns should match source columns"
+    assert (
+        test_df_without_labels.columns.tolist() == train_df.columns.tolist()[:-1]
+    ), "Public test columns should match train columns, minus the target column"
+    assert (
+        test_df.columns.tolist() == train_df.columns.tolist()
+    ), "Private test columns should match train columns"
+    assert sample_submission.columns.tolist() == [
+        "Id",
+        "Pawpularity",
+    ], "Sample submission columns should be Id, Pawpularity"
+    assert set(train_df["Id"]).isdisjoint(
+        set(test_df["Id"])
+    ), "Train and test ids should not overlap"
+    assert len(list((public_dir / "train").glob("*.jpg"))) == len(
+        train_df
+    ), "Train images should match the train set"
+    assert len(list((public_dir / "test").glob("*.jpg"))) == len(
+        test_df
+    ), "Test images should match the test set"
+
+    return train_df
+
+
+def prepare(raw: Path, public: Path, private: Path):
+
+    old_train = read_csv(raw / "train.csv")
+    raw_images_dir = raw / "train"
+
+    # --- First Split: Create the original train/test sets ---
+    # This split creates the main `public` and `private` directories.
+    # Its outputs must remain identical to the original script.
+    # Original ratio: 6800/(9912 + 6800) = ~ 0.41 test_size
+    # We use 0.1 ratio to avoid taking out too many samples from train
+    original_test_size = 0.1
+    train_from_first_split = _process_split(
+        source_df=old_train,
+        public_dir=public,
+        private_dir=private,
+        raw_images_dir=raw_images_dir,
+        test_size=original_test_size,
+        random_state=0,
+    )
+
+    # --- Second Split: Create the new validation sets from the first split's train set ---
+    # Define new paths for the validation set outputs.
+    public_val = public.parent / "public_val"
+    private_val = private.parent / "private_val"
+
+    # Calculate the test size for the second split to make the new test_val set
+    # have approximately the same size as the original test set.
+    # size(test_val) = size(test_original)
+    # test_size_val * size(train_from_first_split) = original_test_size * size(old_train)
+    # test_size_val * (1 - original_test_size) * size(old_train) = original_test_size * size(old_train)
+    # test_size_val = original_test_size / (1 - original_test_size)
+    val_test_size = original_test_size / (1 - original_test_size)
+
+    # This split creates `public_val` and `private_val` directories.
+    # The random_state is kept the same for consistency.
+    _process_split(
+        source_df=train_from_first_split,
+        public_dir=public_val,
+        private_dir=private_val,
+        raw_images_dir=raw_images_dir,
+        test_size=val_test_size,
+        random_state=0,
+    )

mlebench/competitions/plant-pathology-2020-fgvc7/grade.py

@@ -0,0 +1,41 @@
+import numpy as np
+import pandas as pd
+from sklearn.metrics import roc_auc_score
+
+from mlebench.grade_helpers import InvalidSubmissionError
+
+
+def grade(submission: pd.DataFrame, answers: pd.DataFrame) -> float:
+    expected_answers_columns = ["image_id", "healthy", "multiple_diseases", "rust", "scab"]
+    expected_sample_submission_columns = expected_answers_columns
+
+    assert set(answers.columns) == set(
+        expected_answers_columns
+    ), f"Expected `answers` to have columns {expected_answers_columns} but got {answers.columns}"
+
+    if len(submission) != len(answers):
+        raise InvalidSubmissionError(
+            f"Expected submission to have {len(answers)} rows but got {len(submission)}"
+        )
+
+    if set(submission.columns) != set(expected_sample_submission_columns):
+        raise InvalidSubmissionError(
+            f"Expected submission to have columns {expected_sample_submission_columns} but got {submission.columns}"
+        )
+
+    submission_sorted = submission.sort_values(by="image_id").reset_index(drop=True)
+    answers_sorted = answers.sort_values(by="image_id").reset_index(drop=True)
+
+    if not all(submission_sorted["image_id"] == answers_sorted["image_id"]):
+        raise InvalidSubmissionError(
+            "Submission and answers DataFrames must have matching 'image_id' columns."
+        )
+
+    class_columns = ["healthy", "multiple_diseases", "rust", "scab"]
+    scores = []
+
+    for cls in class_columns:
+        score = roc_auc_score(y_true=answers_sorted[cls], y_score=submission_sorted[cls])
+        scores.append(score)
+
+    return np.mean(scores)

mlebench/competitions/plant-pathology-2020-fgvc7/prepare.py

@@ -0,0 +1,74 @@
+import shutil
+from pathlib import Path
+
+from sklearn.model_selection import train_test_split
+from tqdm.auto import tqdm
+
+from mlebench.utils import read_csv
+
+
+def prepare(raw: Path, public: Path, private: Path) -> None:
+    expected_train_columns = ["image_id", "healthy", "multiple_diseases", "rust", "scab"]
+    expected_test_columns = ["image_id"]
+    expected_answers_columns = expected_train_columns
+    expected_sample_submission_columns = expected_train_columns
+
+    old_train = read_csv(raw / "train.csv")
+    new_train, answers = train_test_split(old_train, test_size=0.1, random_state=0)
+
+    assert set(new_train.columns) == set(
+        expected_train_columns
+    ), f"Expected `new_train` to have columns {expected_train_columns} but got {new_train.columns}"
+
+    assert set(answers.columns) == set(
+        expected_answers_columns
+    ), f"Expected `answers` to have columns {expected_answers_columns} but got {answers.columns}"
+
+    new_train_image_ids = new_train["image_id"].unique()
+    new_test_image_ids = answers["image_id"].unique()
+    to_new_image_id = {
+        **{old_id: f"Train_{i}" for i, old_id in enumerate(new_train_image_ids)},
+        **{old_id: f"Test_{i}" for i, old_id in enumerate(new_test_image_ids)},
+    }
+
+    new_train["image_id"] = new_train["image_id"].replace(to_new_image_id)
+    answers["image_id"] = answers["image_id"].replace(to_new_image_id)
+
+    new_test = answers[["image_id"]].copy()
+
+    assert set(new_test.columns) == set(
+        expected_test_columns
+    ), f"Expected `new_test` to have columns {expected_test_columns} but got {new_test.columns}"
+
+    sample_submission = answers[["image_id"]].copy()
+    sample_submission[["healthy", "multiple_diseases", "rust", "scab"]] = 0.25
+
+    assert set(sample_submission.columns) == set(
+        expected_sample_submission_columns
+    ), f"Expected `sample_submission` to have columns {expected_sample_submission_columns} but got {sample_submission.columns}"
+
+    private.mkdir(exist_ok=True, parents=True)
+    public.mkdir(exist_ok=True, parents=True)
+    (public / "images").mkdir(exist_ok=True)
+
+    for old_image_id in tqdm(old_train["image_id"], desc="Copying over train & test images"):
+        assert old_image_id.startswith(
+            "Train_"
+        ), f"Expected train image id `{old_image_id}` to start with `Train_`."
+
+        new_image_id = to_new_image_id.get(old_image_id, old_image_id)
+
+        assert (
+            raw / "images" / f"{old_image_id}.jpg"
+        ).exists(), f"Image `{old_image_id}.jpg` does not exist in `{raw / 'images'}`."
+
+        shutil.copyfile(
+            src=raw / "images" / f"{old_image_id}.jpg",
+            dst=public / "images" / f"{new_image_id}.jpg",
+        )
+
+    answers.to_csv(private / "test.csv", index=False)
+
+    sample_submission.to_csv(public / "sample_submission.csv", index=False)
+    new_test.to_csv(public / "test.csv", index=False)
+    new_train.to_csv(public / "train.csv", index=False)

mlebench/competitions/plant-pathology-2020-fgvc7/prepare_val.py

@@ -0,0 +1,160 @@
+import shutil
+from pathlib import Path
+
+from sklearn.model_selection import train_test_split
+from tqdm.auto import tqdm
+
+from mlebench.utils import read_csv
+
+
+def prepare(raw: Path, public: Path, private: Path) -> None:
+    # --- Expected Column Definitions (used for both splits) ---
+    expected_train_columns = ["image_id", "healthy", "multiple_diseases", "rust", "scab"]
+    expected_test_columns = ["image_id"]
+    expected_answers_columns = expected_train_columns
+    expected_sample_submission_columns = expected_train_columns
+
+    # =================================================================
+    # == STAGE 1: Create the original train/test split.              ==
+    # == This section is preserved to ensure the original `public`   ==
+    # == and `private` directories are identical to the original script. ==
+    # =================================================================
+
+    old_train = read_csv(raw / "train.csv")
+    new_train, answers = train_test_split(old_train, test_size=0.1, random_state=0)
+
+    assert set(new_train.columns) == set(
+        expected_train_columns
+    ), f"Expected `new_train` to have columns {expected_train_columns} but got {new_train.columns}"
+
+    assert set(answers.columns) == set(
+        expected_answers_columns
+    ), f"Expected `answers` to have columns {expected_answers_columns} but got {answers.columns}"
+
+    new_train_image_ids = new_train["image_id"].unique()
+    new_test_image_ids = answers["image_id"].unique()
+    to_new_image_id = {
+        **{old_id: f"Train_{i}" for i, old_id in enumerate(new_train_image_ids)},
+        **{old_id: f"Test_{i}" for i, old_id in enumerate(new_test_image_ids)},
+    }
+
+    # IMPORTANT: The `new_train` DataFrame is modified here and will be used
+    # as the input for the second split. We make a copy to preserve it
+    # before its image_ids are changed in-place for the first split's output.
+    train_for_val_split = new_train.copy()
+    new_train["image_id"] = new_train["image_id"].replace(to_new_image_id)
+    answers["image_id"] = answers["image_id"].replace(to_new_image_id)
+
+    new_test = answers[["image_id"]].copy()
+
+    assert set(new_test.columns) == set(
+        expected_test_columns
+    ), f"Expected `new_test` to have columns {expected_test_columns} but got {new_test.columns}"
+
+    sample_submission = answers[["image_id"]].copy()
+    sample_submission[["healthy", "multiple_diseases", "rust", "scab"]] = 0.25
+
+    assert set(sample_submission.columns) == set(
+        expected_sample_submission_columns
+    ), f"Expected `sample_submission` to have columns {expected_sample_submission_columns} but got {sample_submission.columns}"
+
+    private.mkdir(exist_ok=True, parents=True)
+    public.mkdir(exist_ok=True, parents=True)
+    (public / "images").mkdir(exist_ok=True)
+
+    # Note: This loop copies ALL images defined in the original raw train set.
+    for old_image_id in tqdm(old_train["image_id"], desc="Copying over train & test images"):
+        assert old_image_id.startswith(
+            "Train_"
+        ), f"Expected train image id `{old_image_id}` to start with `Train_`."
+
+        new_image_id = to_new_image_id.get(old_image_id, old_image_id)
+
+        assert (
+            raw / "images" / f"{old_image_id}.jpg"
+        ).exists(), f"Image `{old_image_id}.jpg` does not exist in `{raw / 'images'}`."
+
+        shutil.copyfile(
+            src=raw / "images" / f"{old_image_id}.jpg",
+            dst=public / "images" / f"{new_image_id}.jpg",
+        )
+
+    answers.to_csv(private / "test.csv", index=False)
+    sample_submission.to_csv(public / "sample_submission.csv", index=False)
+    new_test.to_csv(public / "test.csv", index=False)
+    new_train.to_csv(public / "train.csv", index=False)
+
+    # =================================================================
+    # == STAGE 2: Create the new validation split.                   ==
+    # == This section splits the `new_train` set from STAGE 1 to     ==
+    # == create a smaller training set and a validation set.         ==
+    # =================================================================
+    print("\nStarting second split to create validation set...")
+
+    # Define paths for the new validation set directories
+    public_val = public.parent / "public_val"
+    private_val = private.parent / "private_val"
+
+    # To get a validation test set of roughly the same size as the original
+    # test set (10% of total), we must take 1/9th of the training set (90% of total).
+    # (0.1 * total) / (0.9 * total) = 1/9
+    val_test_size = 1 / 9.0
+
+    # Perform the second split on the original training data
+    train_val, answers_val = train_test_split(
+        train_for_val_split, test_size=val_test_size, random_state=0
+    )
+
+    # --- Replicate the ID renaming and file creation logic for the new split ---
+
+    train_val_image_ids = train_val["image_id"].unique()
+    test_val_image_ids = answers_val["image_id"].unique()
+    to_new_val_image_id = {
+        **{old_id: f"Train_{i}" for i, old_id in enumerate(train_val_image_ids)},
+        **{old_id: f"Test_{i}" for i, old_id in enumerate(test_val_image_ids)},
+    }
+
+    # The original image IDs from this split are keys in `to_new_image_id`.
+    # We need to map them to find the source file in `public/images`.
+    # e.g., raw 'Train_123' -> 1st split 'Train_45' -> 2nd split 'Test_6'
+    id_mapper_raw_to_val = {
+        raw_id: val_id
+        for raw_id, val_id in to_new_val_image_id.items()
+    }
+    
+    # Get the intermediate filenames from the first split's mapping
+    source_to_dest_val_map = {
+        to_new_image_id[raw_id]: val_id
+        for raw_id, val_id in id_mapper_raw_to_val.items()
+    }
+
+
+    train_val["image_id"] = train_val["image_id"].replace(to_new_val_image_id)
+    answers_val["image_id"] = answers_val["image_id"].replace(to_new_val_image_id)
+
+    test_val = answers_val[["image_id"]].copy()
+    sample_submission_val = answers_val[["image_id"]].copy()
+    sample_submission_val[["healthy", "multiple_diseases", "rust", "scab"]] = 0.25
+
+    # Create the new directories
+    private_val.mkdir(exist_ok=True, parents=True)
+    public_val.mkdir(exist_ok=True, parents=True)
+    (public_val / "images").mkdir(exist_ok=True)
+
+    # Copy images for the validation split. The source is the `public/images`
+    # directory created in the first stage.
+    for source_filename_stem, dest_filename_stem in tqdm(
+        source_to_dest_val_map.items(), desc="Copying over validation images"
+    ):
+        shutil.copyfile(
+            src=public / "images" / f"{source_filename_stem}.jpg",
+            dst=public_val / "images" / f"{dest_filename_stem}.jpg",
+        )
+
+    # Save all files for the validation split into the new directories
+    answers_val.to_csv(private_val / "test.csv", index=False)
+    sample_submission_val.to_csv(public_val / "sample_submission.csv", index=False)
+    test_val.to_csv(public_val / "test.csv", index=False)
+    train_val.to_csv(public_val / "train.csv", index=False)
+
+    print("\nValidation set created successfully.")

mlebench/competitions/plant-pathology-2021-fgvc8/grade.py

@@ -0,0 +1,54 @@
+import pandas as pd
+from scipy.sparse import csr_matrix
+from sklearn.metrics import f1_score
+from sklearn.preprocessing import MultiLabelBinarizer
+
+from mlebench.grade_helpers import InvalidSubmissionError
+
+
+def prepare_for_metric(
+    submission: pd.DataFrame, answers: pd.DataFrame
+) -> tuple[csr_matrix, csr_matrix]:
+    """Transforms the submission and answers DataFrames into the required format for grading as sparse matrices."""
+
+    # Answers checks
+    assert (
+        "image" in answers.columns and "labels" in answers.columns
+    ), "Answers DataFrame must have 'image' and 'labels' columns"
+
+    # Submission checks
+    if "image" not in submission.columns:
+        raise InvalidSubmissionError("Submission DataFrame must have an 'image' column.")
+    if "labels" not in submission.columns:
+        raise InvalidSubmissionError("Submission DataFrame must have a 'labels' column.")
+    if len(submission) != len(answers):
+        raise InvalidSubmissionError(
+            "Submission and answers DataFrames must have the same number of rows."
+        )
+
+    # Match order
+    submission = submission.sort_values(by="image").reset_index(drop=True)
+    answers = answers.sort_values(by="image").reset_index(drop=True)
+    if not all(submission["image"] == answers["image"]):
+        raise InvalidSubmissionError(
+            "Submission and answers DataFrames must have matching 'image' columns."
+        )
+
+    # Get classes
+    classes = set(answers["labels"].str.split().explode().unique())
+
+    # fillna with empty string
+    answers["labels"] = answers["labels"].fillna("")
+    submission["labels"] = submission["labels"].fillna("")
+
+    # Convert to sparse matrices using MultiLabelBinarizer
+    mlb = MultiLabelBinarizer(classes=sorted(classes), sparse_output=True)
+    y_true = mlb.fit_transform(answers["labels"].str.split())
+    y_pred = mlb.transform(submission["labels"].str.split())
+
+    return y_true, y_pred
+
+
+def grade(submission: pd.DataFrame, answers: pd.DataFrame) -> float:
+    y_true, y_pred = prepare_for_metric(submission, answers)
+    return f1_score(y_true=y_true, y_pred=y_pred, average="micro")

mlebench/competitions/plant-pathology-2021-fgvc8/prepare.py

@@ -0,0 +1,65 @@
+import shutil
+from pathlib import Path
+
+from sklearn.model_selection import train_test_split
+from tqdm.auto import tqdm
+
+from mlebench.utils import extract, read_csv
+
+
+def prepare(raw: Path, public: Path, private: Path):
+    """
+    Splits the data in raw into public and private datasets with appropriate test/train splits.
+    """
+
+    # Create train, test from train split
+    old_train = read_csv(raw / "train.csv")
+    new_train, answers = train_test_split(old_train, test_size=0.2, random_state=0)
+
+    # Create a sample submission file
+    submission_df = answers.copy()
+    submission_df["labels"] = "healthy"
+
+    # Checks
+    assert len(answers) == len(submission_df), "Answers and submission should have the same length"
+    assert not set(new_train["image"]).intersection(
+        set(answers["image"])
+    ), "new_train and answers should not share any image"
+    assert (
+        "image" in new_train.columns and "labels" in new_train.columns
+    ), "Train DataFrame must have 'image' and 'labels' columns"
+    assert (
+        "image" in submission_df.columns and "labels" in submission_df.columns
+    ), "Sample submission DataFrame must have 'image' and 'labels' columns"
+    assert len(new_train) + len(answers) == len(
+        old_train
+    ), "The combined length of new_train and answers should equal the length of old_train"
+
+    # Write CSVs
+    answers.to_csv(private / "answers.csv", index=False)
+    new_train.to_csv(public / "train.csv", index=False)
+    submission_df.to_csv(public / "sample_submission.csv", index=False)
+
+    # Copy files
+    (public / "test_images").mkdir(exist_ok=True)
+    (public / "train_images").mkdir(exist_ok=True)
+
+    for file_id in tqdm(new_train["image"], desc="Copying Train Images"):
+        shutil.copyfile(
+            src=raw / "train_images" / f"{file_id}",
+            dst=public / "train_images" / f"{file_id}",
+        )
+
+    for file_id in tqdm(answers["image"], desc="Copying Test Images"):
+        shutil.copyfile(
+            src=raw / "train_images" / f"{file_id}",
+            dst=public / "test_images" / f"{file_id}",
+        )
+
+    # Checks
+    assert len(list(public.glob("train_images/*.jpg"))) == len(
+        new_train
+    ), "Public train images should have the same number of images as the train DataFrame"
+    assert len(list(public.glob("test_images/*.jpg"))) == len(
+        answers
+    ), "Public test images should have the same number of images as the answers DataFrame"