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

dslighting/registry/denoising-dirty-documents/prepare_val.py

@@ -0,0 +1,178 @@
+import shutil
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+from pandas import DataFrame, read_csv
+from PIL import Image
+from sklearn.model_selection import train_test_split
+
+from mlebench.utils import extract
+
+
+def _generate_split_artifacts(
+    train_fpaths: list[Path],
+    test_fpaths: list[Path],
+    source_data_dir: Path,
+    public_dest: Path,
+    private_dest: Path,
+) -> None:
+    """
+    Helper function to generate all required files for a given train/test split.
+
+    This function copies the necessary image files, creates the ground-truth
+    `answers.csv` for the test set, and a `sampleSubmission.csv` for the public.
+    """
+    public_dest.mkdir(exist_ok=True, parents=True)
+    private_dest.mkdir(exist_ok=True, parents=True)
+
+    test_img_names = {fpath.name for fpath in test_fpaths}
+
+    # Create public train/test directories and copy images
+    (public_dest / "train").mkdir(exist_ok=True)
+    (public_dest / "test").mkdir(exist_ok=True)
+
+    for fpath in train_fpaths:
+        shutil.copy(fpath, public_dest / "train" / fpath.name)
+
+    for fpath in test_fpaths:
+        shutil.copy(fpath, public_dest / "test" / fpath.name)
+
+    # Prepare ground-truth labels for the test set
+    temp_private_cleaned_dir = private_dest / "train_cleaned"
+    temp_private_cleaned_dir.mkdir(exist_ok=True)
+
+    source_cleaned_dir = source_data_dir / "train_cleaned"
+    for fpath in source_cleaned_dir.glob("*.png"):
+        if fpath.name in test_img_names:
+            shutil.copy(fpath, temp_private_cleaned_dir / fpath.name)
+
+    # Write `answers.csv` for the test set
+    dfs = []
+    for fpath in sorted(temp_private_cleaned_dir.glob("*.png")):
+        df = to_df(fpath)
+        dfs.append(df)
+
+    answers = DataFrame(pd.concat(dfs))
+    answers.to_csv(private_dest / "answers.csv", index=False)
+
+    shutil.rmtree(temp_private_cleaned_dir)
+
+    # Write `sampleSubmission.csv`
+    sample_submission = answers.copy()
+    sample_submission["value"] = 1
+    sample_submission.to_csv(public_dest / "sampleSubmission.csv", index=False)
+
+    # Sanity checks
+    assert len(list((public_dest / "train").glob("*.png"))) == len(train_fpaths), (
+        f"Expected the number of images in `{public_dest}/train` to be "
+        f"{len(train_fpaths)}, but got "
+        f"{len(list((public_dest / 'train').glob('*.png')))}."
+    )
+
+    assert len(list((public_dest / "test").glob("*.png"))) == len(test_fpaths), (
+        f"Expected {len(test_fpaths)} in the `{public_dest}/test` directory, but got "
+        f"{len(list((public_dest / 'test').glob('*.png')))}."
+    )
+
+    assert read_csv(private_dest / "answers.csv").drop_duplicates().shape[0] == len(
+        read_csv(private_dest / "answers.csv")
+    ), (
+        f"Expected `{private_dest}/answers.csv` to have unique rows, but got "
+        f"{read_csv(private_dest / 'answers.csv').drop_duplicates().shape[0]} unique rows and "
+        f"{len(read_csv(private_dest / 'answers.csv'))} rows in total."
+    )
+
+    assert len(read_csv(private_dest / "answers.csv")) == len(
+        read_csv(public_dest / "sampleSubmission.csv")
+    ), (
+        f"Expected `answers.csv` and `sampleSubmission.csv` to have the same number of rows, but "
+        f"got {len(read_csv(private_dest / 'answers.csv'))} rows in `answers.csv` and "
+        f"{len(read_csv(public_dest / 'sampleSubmission.csv'))} rows in `sampleSubmission.csv`."
+    )
+
+    assert "id" in read_csv(private_dest / "answers.csv").columns, (
+        f"Expected `answers.csv` to have an 'id' column, but got "
+        f"{read_csv(private_dest / 'answers.csv').columns}."
+    )
+
+    assert "value" in read_csv(private_dest / "answers.csv").columns, (
+        f"Expected `answers.csv` to have a 'value' column, but got "
+        f"{read_csv(private_dest / 'answers.csv').columns}."
+    )
+
+    assert "id" in read_csv(public_dest / "sampleSubmission.csv").columns, (
+        f"Expected `sampleSubmission.csv` to have an 'id' column, but got "
+        f"{read_csv(public_dest / 'sampleSubmission.csv').columns}."
+    )
+
+    assert "value" in read_csv(public_dest / "sampleSubmission.csv").columns, (
+        f"Expected `sampleSubmission.csv` to have a 'value' column, but got "
+        f"{read_csv(public_dest / 'sampleSubmission.csv').columns}."
+    )
+
+
+def prepare(raw: Path, public: Path, private: Path) -> None:
+    # Define paths for the new validation split
+    public_val = public.parent / "public_val"
+    private_val = private.parent / "private_val"
+
+    # Use a temporary directory to extract raw data to avoid side-effects
+    temp_source_dir = public.parent / "temp_data_source"
+    if temp_source_dir.exists():
+        shutil.rmtree(temp_source_dir)
+    temp_source_dir.mkdir(parents=True)
+
+    # Extract all necessary data once
+    extract(raw / "train.zip", temp_source_dir)
+    extract(raw / "train_cleaned.zip", temp_source_dir)
+    all_img_fpaths = sorted((temp_source_dir / "train").glob("*.png"))
+
+    # --- First Split: The Original Train/Test Split ---
+    # We set new test ratio to 0.2 to keep it number of train samples at same OOM while having enough samples for new test
+    orig_train_fpaths, orig_test_fpaths = train_test_split(
+        all_img_fpaths,
+        test_size=0.2,
+        random_state=0,
+    )
+    # Generate artifacts for the original public/private directories
+    _generate_split_artifacts(orig_train_fpaths, orig_test_fpaths, temp_source_dir, public, private)
+
+    # --- Second Split: Create Train/Validation Split from the Original Train Set ---
+    # To keep the new validation set size similar to the original test set size,
+    # we use test_size=0.25 (since 0.25 * 0.8 = 0.2).
+    new_train_fpaths, val_fpaths = train_test_split(
+        orig_train_fpaths, # Split the original training data again
+        test_size=0.25,
+        random_state=0,
+    )
+    # Generate artifacts for the new validation directories (public_val/private_val)
+    _generate_split_artifacts(new_train_fpaths, val_fpaths, temp_source_dir, public_val, private_val)
+
+    # Clean up the temporary source directory
+    shutil.rmtree(temp_source_dir)
+
+
+def to_df(img: Path) -> DataFrame:
+    """Converts an image to a DataFrame, where each row corresponds to a pixel."""
+
+    image = Image.open(img).convert("L")
+    image_array = np.array(image) / 255.0
+
+    rows, cols = image_array.shape
+    data = {"id": [], "value": []}
+
+    for row in range(rows):
+        for col in range(cols):
+            pixel_id = f"{img.stem}_{row+1}_{col+1}"
+            pixel_value = image_array[row, col]
+            data["id"].append(pixel_id)
+            data["value"].append(pixel_value)
+
+    df = DataFrame(data)
+
+    assert (
+        len(df) == rows * cols
+    ), f"Expected the DataFrame to have {rows * cols} rows, but got {len(df)} rows."
+
+    return DataFrame(data)

dslighting/registry/detecting-insults-in-social-commentary/checksums.yaml

@@ -0,0 +1,8 @@
+private:
+  gold_submission.csv: 937dc9172f07ab3f72f123c79e37652c
+  test.csv: 76d6e15e475a2fd634bdd8cdfb4746c0
+public:
+  sample_submission_null.csv: a0dcbebb9f3aa642325ec3b83dacafa1
+  test.csv: 6dd3e4189309b7b513fcf124be21c790
+  train.csv: 60f8ff55967759d144efd4f055f37673
+zip: 719b313286d397ddc6d8e454135249de

dslighting/registry/detecting-insults-in-social-commentary/config.yaml

@@ -0,0 +1,23 @@
+id: detecting-insults-in-social-commentary
+name: Detecting Insults in Social Commentary
+competition_type: simple
+awards_medals: true
+prizes:
+  - position: 1
+    value: 7000
+  - position: 2
+    value: 2500
+  - position: Visualization Prospect
+    value: 500
+description: mlebench/competitions/detecting-insults-in-social-commentary/description.md
+
+dataset:
+  answers: detecting-insults-in-social-commentary/prepared/private/test.csv
+  gold_submission: detecting-insults-in-social-commentary/prepared/private/gold_submission.csv
+  sample_submission: detecting-insults-in-social-commentary/prepared/public/sample_submission_null.csv
+
+grader:
+  name: auc-roc
+  grade_fn: mlebench.competitions.detecting-insults-in-social-commentary.grade:grade
+
+preparer: mlebench.competitions.detecting-insults-in-social-commentary.prepare:prepare

dslighting/registry/detecting-insults-in-social-commentary/description.md

@@ -0,0 +1,164 @@
+# Overview
+
+## Overview
+
+### Prizes
+
+#### How Does the Prize Work?
+
+The \$10,000 prize pool will be split between the top two finishers for the classification challenge and the top visualization submission as follows:
+
+**First place**: \$7,000
+
+**Second place**:  \$2,500
+
+**Visualization Prospect**: \$500
+
+But wait, there's more...
+
+**Recruiting Competition**
+
+Do you want a chance to build a crucial component of Web 2.0 infrastructure: the defense against spam and abuse? Do you live and breathe machine learning and data-mining?\
+We're looking for someone whose passion lies in the invention and application of cutting-edge machine learning and data-mining techniques. Impermium is an engineering-driven startup dedicated to helping consumer web sites protect themselves from "social spam," account hacking, bot attacks, and more.
+
+Impermium will review the top entries and offer interviews to the creators of those submissions which are exceptional.
+
+**Please note: You must compete as an individual in recruiting competitions.  You may only use the data provided to make your predictions.  Impermium will review the code of the top participants before deciding whether to offer an interview.**
+
+**Due to visa issuance delays, Impermium is not able to sponsor new H1B applicants but are happy to support H1B transfers, permanent residents and US citizens.**
+
+### Description
+
+#### [Visualization Track now open >>](https://www.kaggle.com/c/detecting-insults-in-social-commentary/prospector)
+
+#### Do you think you can take on the crudest, meanest trolls on the internet? Okay then, game on!
+
+The challenge is to detect when a comment from a conversation would be considered insulting to another participant in the conversation. Samples could be drawn from conversation streams like news commenting sites, magazine comments, message boards, blogs, text messages, etc.
+
+The idea is to create a generalizable single-class classifier which could operate in a near real-time mode, scrubbing the filth of the internet away in one pass.
+
+#### _Prizes you say?_
+
+Besides the prize money, eternal fame and glory, monuments in your honor, and the admiration of friend and foe alike, you get a chance for an interview at Impermium for the Principal Data Engineer role.
+
+In addition, there will be a Visualization prospect attached to the contest.  Slice and dice the data to show us the most amazing, informative and thought-provoking infographics, diagrams or plots! Submission open 1 week before the contest ends. 
+
+*(Please note that referenced fame, glory, monuments and admiration are to be bestowed only in the imagination of the contestants)*
+
+### About The Sponsor
+
+#### What are social spam and abuse?
+
+Impermium defines social spam as any unwanted content that someone experiences on social network or in user-generated content sites on the Internet. Social web abuse involves malicious efforts to take advantage of social channels, including password hacking, malware placement, fake follower and friending schemes, account takeovers, bogus registrations, and more.
+
+Five years ago, social spam and abuse practically didn't exist. But this year, 90% of social network users have experienced it -- and victims are beginning to lose hundreds of thousands of dollars. Because social networks are relatively new to users, and cybercriminals are already inside them, we can expect the damages to mount for many years to come.
+
+#### Who is Impermium?
+
+Impermium is an engineering-driven startup dedicated to helping consumer web sites protect themselves from "social spam," account hacking, bot attacks, and more. We are funded by some of the most experienced and influential investors in the Valley, and already receiving strong enthusiasm and rapid uptake.
+
+Impermium provides a subscription-based service that protects against the biggest threats today, allowing social application developers to remain focused on their core business. Built by the former leaders of the Yahoo! anti-spam and security teams, the company's RESTful Web Services-based solution enables site operators to prevent and mitigate most types of suspicious and abusive transactions, with real-time and batch monitoring of Web transactions, and hosted mitigation solutions to manage suspicious users.
+
+Backed by some of the most prominent technology investors in Silicon Valley including Accel Partners, Charles River Ventures, Greylock Partners, Highland Capital Partners, and the Social+Capital Partnership, Impermium provides the essential anti-abuse and security services for many of the Internet's most popular consumer web sites and social media engagement platforms.
+
+### Job Description
+
+#### Principal Data Engineer at Impermium in Redwood City, CA
+
+**As Impermium continues to build out its Internet-scale user-generated content classification system, we're looking for someone whose passion lies in the invention and application of cutting-edge machine learning and data-mining techniques. Our system already classifies tens of millions of "social transactions" every day, looking for spam, abuse, fraud, and other bad behavior -- as Data Engineer, you'll join our team to help guide and shape our algorithm and classifier development. Read on if the following excites you:**
+
+- Locality Sensitive Hashing!
+- Random Forest Ensemble Classifiers!
+- Stochastic Gradient Boosting Distributed Decision Trees!
+
+**Most large-scale abuse classification systems break down due to non-I.I.D. document distributions, an over-reliance on exhaustive "ground truth" training corpora, and an adversary who continually adapts to specific weaknesses in the classifier.  The Impermium Data Engineer will help in our pioneering work to overcome these historical limitations.\
+The ideal candidate is a highly knowledgeable, all-star computer engineer, with a strong background in machine learning, data mining, and distributed computing. This candidate must have previous, hands-on experience turning conversations into prototypes and prototypes into products -- ideally in a startup environment.**
+
+**You'll fit right in if:**
+
+- You are a self-managed, high-energy individual
+- You possess exceptional communication skills with the ability to clearly articulate your engineering and product ideas with both team-members and customers
+- You are absolutely confident in your ability to design scalable, principled, practical classification and clustering algorithms that operate within the near-real-time constraints of the abuse domain
+
+**Requirements:**
+
+- 5+ years experience creating prototypes that are shipped to market (production systems)
+- 5+ years experience in software product development - with the core focus being on mathematical and / or statistical algorithms
+- Well-versed in a modern general purpose programming language such as Java/C++/Scala/Python
+- Well-versed with unix command line tools and one or more scripting language such as awk/perl/shell
+- Proven ability to develop and execute sophisticated data mining & modeling
+- Experience working with "Big Data" systems and platforms
+- NLP (natural language processing) experience is a plus
+- Publications and/or patents are a plus
+- MS/PH.D in Computer Science recommended
+
+**Impermium offers you:**
+
+- A chance to build a crucial component of Web 2.0 infrastructure: the defense against spam and abuse
+- A dynamic, technology-driven work environment in our brand new office, convenient to 101 and Caltrain
+- A highly influential and visible role with direct impact on foundational product and engineering direction
+- The opportunity to work alongside a highly talented, experienced founding team
+
+Due to visa issuance delays, Impermium is not able to sponsor new H1B applicants but are happy to support H1B transfers, permanent residents and US citizens.
+
+### Evaluation
+
+This is a single-class classification problems.  Your predictions should be a number in the range [0,1]  where 0 indicates 0% probability of comment being an insult, and 1 represents 100% insult.
+
+ All predictions should be in the first column of your submission file. Please see 'sample_submissions_null.csv" for the correct format.
+
+The evaluation metric for this competition is the Area under the Receiver Operating Curve (AUC).   This evaluation metric penalizes wrong predictions made with high probability.  For more about this metric, check out the [AUC](https://www.kaggle.com/wiki/AreaUnderCurve) page on the Kaggle Wiki.
+
+**Please note, winners for the competition will be determined by their performance on an additional verification set that will be released at the end of the competition.  See Timeline tab for details.**
+
+### Timeline
+
+Tuesday, August 7th: Competition launches
+
+Monday September 10th:  Full test set released. The public leaderboard will be locked and continue to reflect its state before the release of new data.  Daily model submission limits will be removed.  Visualization Prospect opens.
+
+Monday, September 17th:  Up to five (5) final models must be submitted and locked-in (self-contained code).  Please see Rules for exact details on model submission.  Impermium will release the **verification set**
+
+Thursday September 20th:  Deadline to submit up to five (5) solution on the verification set.  Solution must be generated with same code that was locked in on 9-17.
+
+**The overall winners of the competition will be determined by their performance on the verification set.**  Winning entries will be checked to confirm that they were generated with the locked code.
+
+Friday, September 21st:  Visualization prospect closes
+
+### Winners
+
+This challenge focused on using natural language processing to flag insulting comments posted in online forums.
+
+- **First Place**: [Vivek Sharma](https://www.kaggle.com/users/5048/vivek-sharma), New Delhi, India
+- **Second Place**: [Dmitry S](https://www.kaggle.com/users/45651/tuzzeg)., USA
+- **Visualization Prize**: [Charlie Turner](https://www.kaggle.com/users/5940/charlie-turner), Davis, USA
+
+### Citation
+
+Cory O'Connor, Glider, parag. (2012). Detecting Insults in Social Commentary. Kaggle. https://kaggle.com/competitions/detecting-insults-in-social-commentary
+
+# Data
+
+## Dataset Description
+
+### Data
+
+The data consists of a label column followed by two attribute fields. 
+
+This is a single-class classification problem. The label is either 0 meaning a **neutral** comment, or 1 meaning an **insulting** comment (neutral can be considered as not belonging to the insult class.  Your predictions must be a real number in the range [0,1] where 1 indicates 100% confident prediction that comment is an insult.
+
+The first attribute is the time at which the comment was made. It is sometimes blank, meaning an accurate timestamp is not possible. It is in the form "YYYYMMDDhhmmss" and then the Z character. It is on a 24 hour clock and corresponds to the localtime at which the comment was originally made.
+
+The second attribute is the unicode-escaped text of the content, surrounded by double-quotes. The content is mostly english language comments, with some occasional formatting.
+
+### Guidelines
+
+- We are looking for comments that are intended to be insulting to a person who is a part of the larger blog/forum conversation. 
+- We are NOT looking for insults directed to non-participants (such as celebrities, public figures etc.). 
+- Insults could contain profanity, racial slurs, or other offensive language. But often times, they do not. 
+- Comments which contain profanity or racial slurs, but are not necessarily insulting to another person are considered not insulting.
+- The insulting nature of the comment should be obvious, and not subtle. 
+
+There may be a small amount of noise in the labels as they have not been meticulously cleaned. However, contenstants can be confident the error in the training and testing data is `< 1%`. 
+
+Contestants should also be warned that this problem tends to strongly overfit. The provided data is generally representative of the full test set, but not exhaustive by any measure. Impermium will be conducting final evaluations based on an unpublished set of data drawn from a wide sample.

dslighting/registry/detecting-insults-in-social-commentary/description_obfuscated.md

@@ -0,0 +1,31 @@
+# Task
+
+Detect if a comment is insulting.
+
+# Metric
+
+Area under the Receiver Operating Curve (AUC).
+
+# Submission Format
+
+Your predictions should be a number in the range [0,1].
+
+See 'sample_submissions_null.csv" for the correct format.
+
+# Dataset
+
+The label is either 0 meaning a **neutral** comment, or 1 meaning an **insulting** comment.
+
+The first attribute is the time at which the comment was made. It is sometimes blank, meaning an accurate timestamp is not possible. It is in the form "YYYYMMDDhhmmss" and then the Z character.
+
+The second attribute is the unicode-escaped text of the content, surrounded by double-quotes. The content is mostly english language comments, with some occasional formatting.
+
+## Guidelines
+
+- We are looking for comments that are intended to be insulting to a person who is a part of the larger blog/forum conversation. 
+- We are NOT looking for insults directed to non-participants (such as celebrities, public figures etc.). 
+- Insults could contain profanity, racial slurs, or other offensive language. But often times, they do not. 
+- Comments which contain profanity or racial slurs, but are not necessarily insulting to another person are considered not insulting.
+- The insulting nature of the comment should be obvious, and not subtle. 
+
+There may be a small amount of noise in the labels as they have not been meticulously cleaned. However, contenstants can be confident the error in the training and testing data is `< 1%`.

dslighting/registry/detecting-insults-in-social-commentary/grade.py

@@ -0,0 +1,11 @@
+import pandas as pd
+from sklearn.metrics import roc_auc_score
+
+from mlebench.competitions.utils import prepare_for_auroc_metric
+
+
+def grade(submission: pd.DataFrame, answers: pd.DataFrame) -> float:
+    roc_auc_inputs = prepare_for_auroc_metric(
+        submission=submission, answers=answers, id_col="Comment", target_col="Insult"
+    )
+    return roc_auc_score(y_true=roc_auc_inputs["y_true"], y_score=roc_auc_inputs["y_score"])

dslighting/registry/detecting-insults-in-social-commentary/prepare.py

@@ -0,0 +1,72 @@
+import shutil
+from pathlib import Path
+
+from mlebench.utils import read_csv
+
+
+def prepare(raw: Path, public: Path, private: Path):
+    # the test set labels are provided so we can just copy things without doing the split ourselves
+    shutil.copy(raw / "train.csv", public / "train.csv")
+    shutil.copy(raw / "test_with_solutions.csv", private / "test.csv")
+
+    # the public test currently online is for the verification stage, which we are ignoring
+    # (we are ignoring because there is some train/test leakage and unclear how this factors in leaderboard)
+    # we can recover the original public test set by removing the labels from the private test set
+    # can make the gold submission while we're at it
+    gold_submission = read_csv(private / "test.csv")
+    gold_submission = gold_submission[["Insult", "Date", "Comment"]]
+    gold_submission.to_csv(private / "gold_submission.csv", index=False)
+
+    public_test = gold_submission.drop(columns=["Insult"]).copy()
+    public_test.to_csv(public / "test.csv", index=False)
+
+    # finally, we also make our own sample_submission, same reasons as public test
+    # but match the format of what's online
+    sample_submission = gold_submission.copy()
+    sample_submission["Insult"] = 0
+    sample_submission.to_csv(public / "sample_submission_null.csv", index=False)
+
+    # checks
+    public_train = read_csv(public / "train.csv")
+    public_test = read_csv(public / "test.csv")
+    private_test = read_csv(private / "test.csv")
+
+    # no `Id` column in train, so we check comment content instead
+    assert public_train.columns.to_list() == [
+        "Insult",
+        "Date",
+        "Comment",
+    ], "Train columns should be Insult, Date, Comment"
+    assert public_test.columns.to_list() == [
+        "Date",
+        "Comment",
+    ], "Test columns should be Date, Comment"
+    assert sample_submission.columns.to_list() == [
+        "Insult",
+        "Date",
+        "Comment",
+    ], "Sample submission columns should be Insult, Date, Comment"
+    assert gold_submission.columns.to_list() == [
+        "Insult",
+        "Date",
+        "Comment",
+    ], "Gold submission columns should be Insult, Date, Comment"
+    assert private_test.columns.to_list() == [
+        "Insult",
+        "Date",
+        "Comment",
+        "Usage",
+    ], "Private test columns should be Insult, Date, Comment, Usage"
+
+    assert set(public_train["Comment"]).isdisjoint(
+        set(public_test["Comment"])
+    ), "None of the test comments should be in the train comments"
+    assert public_test.equals(
+        private_test.drop(columns=["Insult", "Usage"])
+    ), "Public test should be identical to private test, modulo the Insult and Usage columns"
+    assert set(public_test["Comment"]) == set(
+        sample_submission["Comment"]
+    ), "Public test and sample submission should have the same Comments"
+    assert set(public_test["Comment"]) == set(
+        gold_submission["Comment"]
+    ), "Public test and gold submission should have the same Comments"

dslighting/registry/detecting-insults-in-social-commentary/prepare_val.py

@@ -0,0 +1,128 @@
+import shutil
+from pathlib import Path
+
+import pandas as pd
+from sklearn.model_selection import train_test_split
+
+from mlebench.utils import read_csv
+
+
+def _create_split_files(
+    train_df: pd.DataFrame,
+    test_df_with_solutions: pd.DataFrame,
+    public_dir: Path,
+    private_dir: Path,
+):
+    """
+    Helper function to create the standard file structure for a given data split.
+
+    This function encapsulates the logic for generating:
+    - public/train.csv
+    - public/test.csv (unlabeled)
+    - public/sample_submission_null.csv
+    - private/test.csv (labeled, ground truth)
+    - private/gold_submission.csv
+    """
+    # Create directories if they don't exist
+    public_dir.mkdir(exist_ok=True)
+    private_dir.mkdir(exist_ok=True)
+
+    # Save the training data
+    train_df.to_csv(public_dir / "train.csv", index=False)
+
+    # Save the full test set with solutions to the private directory
+    test_df_with_solutions.to_csv(private_dir / "test.csv", index=False)
+
+    # Create the gold submission from the private test set
+    gold_submission = test_df_with_solutions[["Insult", "Date", "Comment"]].copy()
+    gold_submission.to_csv(private_dir / "gold_submission.csv", index=False)
+
+    # Create the public test set by dropping the label
+    public_test = gold_submission.drop(columns=["Insult"]).copy()
+    public_test.to_csv(public_dir / "test.csv", index=False)
+
+    # Create a sample submission with null labels
+    sample_submission = gold_submission.copy()
+    sample_submission["Insult"] = 0
+    sample_submission.to_csv(public_dir / "sample_submission_null.csv", index=False)
+
+
+def prepare(raw: Path, public: Path, private: Path):
+    # Load the original, pre-split data from the raw directory
+    original_train_df = read_csv(raw / "train.csv")
+    original_test_df = read_csv(raw / "test_with_solutions.csv")
+
+    # --- Part 1: Generate the original public/private split ---
+    # This block uses the original data to create the competition's primary
+    # train/test split, ensuring the output is identical to the original script.
+    _create_split_files(original_train_df, original_test_df, public, private)
+
+    # --- Part 2: Generate the new validation split ---
+    # This block creates a new split for local validation. It takes the original
+    # training data and splits it again, creating a new, smaller training set
+    # and a validation set. The outputs are saved to parallel directories.
+
+    # Define paths for the new validation set directories
+    public_val = public.parent / "public_val"
+    private_val = private.parent / "private_val"
+
+    # Split the original training data to create a new train and validation set.
+    # The size of the validation set is chosen to be the same as the original test set.
+    # We stratify on the 'Insult' column to maintain label distribution.
+    train_val_df, test_val_df = train_test_split(
+        original_train_df,
+        test_size=len(original_test_df),
+        random_state=42,
+        stratify=original_train_df["Insult"],
+    )
+
+    # Use the same helper function to create the files for the validation split,
+    # ensuring an identical directory structure and naming convention.
+    _create_split_files(train_val_df, test_val_df, public_val, private_val)
+
+    # --- Final Checks ---
+    # checks for the original split
+    public_train = read_csv(public / "train.csv")
+    public_test = read_csv(public / "test.csv")
+    private_test = read_csv(private / "test.csv")
+    sample_submission = read_csv(public / "sample_submission_null.csv")
+    gold_submission = read_csv(private / "gold_submission.csv")
+
+    assert public_train.columns.to_list() == [
+        "Insult",
+        "Date",
+        "Comment",
+    ], "Train columns should be Insult, Date, Comment"
+    assert public_test.columns.to_list() == [
+        "Date",
+        "Comment",
+    ], "Test columns should be Date, Comment"
+    assert sample_submission.columns.to_list() == [
+        "Insult",
+        "Date",
+        "Comment",
+    ], "Sample submission columns should be Insult, Date, Comment"
+    assert gold_submission.columns.to_list() == [
+        "Insult",
+        "Date",
+        "Comment",
+    ], "Gold submission columns should be Insult, Date, Comment"
+    assert private_test.columns.to_list() == [
+        "Insult",
+        "Date",
+        "Comment",
+        "Usage",
+    ], "Private test columns should be Insult, Date, Comment, Usage"
+
+    assert set(public_train["Comment"]).isdisjoint(
+        set(public_test["Comment"])
+    ), "None of the test comments should be in the train comments"
+    assert public_test.equals(
+        private_test.drop(columns=["Insult", "Usage"])
+    ), "Public test should be identical to private test, modulo the Insult and Usage columns"
+    assert set(public_test["Comment"]) == set(
+        sample_submission["Comment"]
+    ), "Public test and sample submission should have the same Comments"
+    assert set(public_test["Comment"]) == set(
+        gold_submission["Comment"]
+    ), "Public test and gold submission should have the same Comments"

dslighting/registry/dog-breed-identification/checksums.yaml

@@ -0,0 +1,6 @@
+private:
+  test.csv: 83d0c48056db066d07102ee13aaecc08
+public:
+  labels.csv: 0ab1a234cd6b80e9efd617e305a4eda5
+  sample_submission.csv: 30c85225fcd6e22dc51a7d94a333575f
+zip: e01b86f22c3573af92b0682a13d5b8d2

dslighting/registry/dog-breed-identification/config.yaml

@@ -0,0 +1,16 @@
+id: dog-breed-identification
+name: Dog Breed Identification
+competition_type: simple
+awards_medals: false
+prizes: null
+description: mlebench/competitions/dog-breed-identification/description.md
+
+dataset:
+  answers: dog-breed-identification/prepared/private/test.csv
+  sample_submission: dog-breed-identification/prepared/public/sample_submission.csv
+
+grader:
+  name: multi-class-log-loss
+  grade_fn: mlebench.competitions.dog-breed-identification.grade:grade
+
+preparer: mlebench.competitions.dog-breed-identification.prepare:prepare