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

dslighting/registry/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. ---")

dslighting/registry/chaii-hindi-and-tamil-question-answering/checksums.yaml

@@ -0,0 +1,7 @@
+private:
+  test.csv: 3ae8b59f0ae28791170f45313fdf0432
+public:
+  sample_submission.csv: 772a81a2f11029153ebe965572fd9410
+  test.csv: f0fe24d3f56320b3d1dae5a66aef0fac
+  train.csv: b032f44429b21d64a103a3e7f8d61ad0
+zip: 2766e34372404b2563fae09ddcc95161

dslighting/registry/chaii-hindi-and-tamil-question-answering/config.yaml

@@ -0,0 +1,26 @@
+id: chaii-hindi-and-tamil-question-answering
+name: Hindi and Tamil Question Answering
+competition_type: code
+awards_medals: true
+prizes:
+  - position: 1
+    value: 2000
+  - position: 2
+    value: 2000
+  - position: 3
+    value: 2000
+  - position: 4
+    value: 2000
+  - position: 5
+    value: 2000
+description: mlebench/competitions/chaii-hindi-and-tamil-question-answering/description.md
+
+dataset:
+  answers: chaii-hindi-and-tamil-question-answering/prepared/private/test.csv
+  sample_submission: chaii-hindi-and-tamil-question-answering/prepared/public/sample_submission.csv
+
+grader:
+  name: word-level-jaccard-score
+  grade_fn: mlebench.competitions.chaii-hindi-and-tamil-question-answering.grade:grade
+
+preparer: mlebench.competitions.chaii-hindi-and-tamil-question-answering.prepare:prepare

dslighting/registry/chaii-hindi-and-tamil-question-answering/description.md

@@ -0,0 +1,138 @@
+# Overview
+
+## Description
+
+With nearly 1.4 billion people, India is the second-most populated country in the world. Yet Indian languages, like Hindi and Tamil, are underrepresented on the web. Popular Natural Language Understanding (NLU) models perform worse with Indian languages compared to English, the effects of which lead to subpar experiences in downstream web applications for Indian users. With more attention from the Kaggle community and your novel machine learning solutions, we can help Indian users make the most of the web.
+
+Predicting answers to questions is a common NLU task, but not for Hindi and Tamil. Current progress on multilingual modeling requires a concentrated effort to generate high-quality datasets and modelling improvements. Additionally, for languages that are typically underrepresented in public datasets, it can be difficult to build trustworthy evaluations. We hope the dataset provided for this competition—and [additional datasets generated by participants](https://www.kaggle.com/c/chaii-hindi-and-tamil-question-answering/overview/sharing-datasets)—will enable future machine learning for Indian languages.
+
+In this competition, your goal is to predict answers to real questions about Wikipedia articles. You will use chaii-1, a new question answering dataset with question-answer pairs. The dataset covers Hindi and Tamil, collected without the use of translation. It provides a realistic information-seeking task with questions written by native-speaking expert data annotators. You will be provided with a [baseline model](https://www.kaggle.com/deeplearning10/chaii-1-starter-notebook) and [inference code](https://www.kaggle.com/deeplearning10/chaii-1-inference) to build upon.
+
+If successful, you'll improve upon the baseline performance of NLU models in Indian languages. The results could improve the web experience for many of the nearly 1.4 billion people of India. Additionally, you’ll contribute to multilingual NLP, which could be applied beyond the languages in this competition.
+
+### Acknowledgments
+
+**Google Research India** contributes fundamental advances in computer science and applies their research to big problems impacting India, Google, and communities around the world. The Natural Language Understanding group at Google Research India works specifically with ML to address the unique challenges in the Indian context (such as code mixing in Search, diversity of languages, dialects and accents in Assistant), learning from limited resources and advancing multilingual models.
+
+**chaii ([Challenge in AI for India](https://events.withgoogle.com/chaii2021))** is a [Google Research India](https://research.google/teams/india-research-lab/) initiative created with the purpose of sparking AI applications to address some of the pressing problems in India and to find unique ways to address them. Starting with a focus on NLU, chaii hopes to make progress towards multilingual modelling, as language diversity is significantly underserved on the web. Google Research India is working on transformational approaches to healthcare, agriculture and education, and also improving apps and services such as search, assistant and payments, e.g., to deal with challenges arising out of the diversity of languages in India. We also acknowledge the support from the [AI4Bharat](https://indicnlp.ai4bharat.org/home/) Team at the Indian Institute of Technology Madras.
+
+## Evaluation
+
+The metric in this competition is the [word-level Jaccard score](https://en.wikipedia.org/wiki/Jaccard_index). A good description of Jaccard similarity for strings is [here](https://towardsdatascience.com/overview-of-text-similarity-metrics-3397c4601f50).
+
+A Python implementation based on the links above, and matched with the output of the C# implementation on the back end, is provided below.
+
+```python
+def jaccard(str1, str2): 
+    a = set(str1.lower().split()) 
+    b = set(str2.lower().split())
+    c = a.intersection(b)
+    return float(len(c)) / (len(a) + len(b) - len(c))
+```
+
+The formula for the overall metric, then, is:
+\text{score} = \frac{1}{n} \sum_{i=1}^n \text{jaccard}(gt_i, dt_i)
+
+where:
+$n$ = number of documents
+
+$\text{jaccard}$ = the function provided above
+
+$gt_i$ = the ith ground truth
+
+$dt_i$ = the ith prediction
+
+### Submission File
+
+For each ID in the test set, you must predict the string that best answers the provided question based on the context. Note that the selected text needs to be quoted and complete to work correctly. Include punctuation, etc. - the above code splits ONLY on whitespace. The file should contain a header and have the following format:
+
+```
+id,PredictionString
+8c8ee6504,"1"
+3163c22d0,"2 string"
+66aae423b,"4 word 6"
+722085a7b,"1"
+etc.
+```
+
+## Timeline
+
+    August 11, 2021 - Start Date.
+
+    November 8, 2021 - Entry Deadline. You must accept the competition rules before this date in order to compete.
+
+    November 8, 2021 - Team Merger Deadline. This is the last day participants may join or merge teams.
+
+    November 15, 2021 - Final Submission Deadline.
+
+All deadlines are at 11:59 PM UTC on the corresponding day unless otherwise noted. The competition organizers reserve the right to update the contest timeline if they deem it necessary.
+
+## Prizes
+
+    1st Place - USD$2,000
+    2nd Place - USD$2,000
+    3rd Place - USD$2,000
+    4th Place - USD$2,000
+    5th Place - USD$2,000
+
+## Code Requirements
+
+This is a Code Competition
+
+Submissions to this competition must be made through Notebooks. In order for the "Submit" button to be active after a commit, the following conditions must be met:
+
+- CPU Notebook <= 5 hours run-time
+- GPU Notebook <= 5 hours run-time
+- Internet access disabled
+- Freely & publicly available external data is allowed, including pre-trained models
+- Submission file must be named `submission.csv`
+
+Please see the [Code Competition FAQ](https://www.kaggle.com/docs/competitions#notebooks-only-FAQ) for more information on how to submit. And review the [code debugging doc](https://www.kaggle.com/code-competition-debugging) if you are encountering submission errors.
+
+## Sharing Datasets
+
+Participants are highly encouraged to supplement the dataset by creating their own additional datasets and we expect this will help towards NLU model improvements.
+
+- To be compliant with the competition rules on external data use, please ensure that any datasets you create, source or use are publicly and freely available to all participants in the competition. You may share your datasets on [this forum thread](https://www.kaggle.com/c/chaii-hindi-and-tamil-question-answering/discussion/264581), in order to ensure it is made available for all participants to use.
+- Please submit your data using [this form](https://forms.gle/P4ZdoDzyJ2iatzYo6) for Google to be able to release the dataset at the end of the contest
+- Data and baseline model provided by Google as well as data contributed by participants will be released as an open-source dataset at the end of the contest.
+- Please be mindful to not violate the rights of a third party and ensure the data does not contain lewd, obscene, pornographic, racist, sexist, or otherwise inappropriate data to the contest.
+- We highly encourage you to create datasets from Wikipedia text.
+- Participants may find tools such as [cdQA-Annotator](https://github.com/cdqa-suite/cdQA-annotator) to annotate your data for ease and data consistency.
+
+## Citation
+
+Addison Howard, Deepak Nathani, divy thakkar, Julia Elliott, Partha Talukdar, Phil Culliton. (2021). chaii - Hindi and Tamil Question Answering. Kaggle. https://kaggle.com/competitions/chaii-hindi-and-tamil-question-answering
+
+# Dataset Description
+
+In this competition, you will be predicting the answers to questions in Hindi and Tamil. The answers are drawn directly (see the Evaluation page for details) from a limited context. We have provided a small number of samples to check your code with. There is also a hidden test set.
+
+**All files should be encoded as UTF-8.**
+
+## Files
+
+- **train.csv** - the training set, containing context, questions, and answers. Also includes the start character of the answer for disambiguation.
+- **test.csv** - the test set, containing context and questions.
+- **sample_submission.csv** - a sample submission file in the correct format
+
+## Columns
+
+- `id` - a unique identifier
+- `context` - the text of the Hindi/Tamil sample from which answers should be derived
+- `question` - the question, in Hindi/Tamil
+- `answer_text` (train only) - the answer to the question (manual annotation) (note: for test, this is what you are attempting to predict)
+- `answer_start` (train only) - the starting character in `context` for the answer (determined using substring match during data preparation)
+- `language` - whether the text in question is in Tamil or Hindi
+
+## Data Annotation Details
+
+chaii 2021 dataset was prepared following the two step process as in [TydiQA](https://arxiv.org/pdf/2003.05002.pdf).
+
+- In the **question elicitation** step, the annotators were shown snippets of Wikipedia text and asked to come up with interesting questions that they may be genuinely interested in knowing answers about. They were also asked to make sure the elicited question was **not** answerable from the snippet of wiki text shown. Annotators were asked to elicit questions which were likely to have precise, unambiguous answers.
+- In the **answer labelling** step, for each question elicited in the previous step, the first Wikipedia page in the Google search results for that question was selected. For Hindi questions, the selection was restricted to Hindi Wikipedia documents, and similarly for Tamil. Annotators were then asked to select the answer for the question in the document. Annotators were asked to select the first valid answer in the document as the correct answer.
+- Questions which were not answerable from the selected document were marked as non-answerable. These question-document pairs were not included in the chaii 2021 dataset.
+- With (question, wiki_document, answer) now in place, the first substring occurrence of the answer in the wiki_document was automatically calculated and provided as `answer_start` in the dataset. Since this part was done automatically, some amount of inaccuracy is possible. This was included only for convenience, and participants may consider ignoring this offset during model development (or come up with their own mechanism for offset selection). Please note that during test, the model is only required to predict the answer string, and not its span offset.
+- Answers in the training data were produced by **one** annotator, while those in the test were produced by **three** annotators. Majority voting was then used to come up with the final answer. In test data with minor disagreements, a separate annotator pass was done to select the final answer. For both train and test answer labelling, sampling based quality checks were carried out and the answer accuracy were routinely observed to be quite high.
+- In spite of all these multi-step checks, some amount of noise in the training data is likely. This is expected and meant to reflect real-world settings where slight noise in the training data may be unavoidable to achieve larger volumes of it. Moreover, this may also result in development of more robust methods which are more noise tolerant during training.
+- Update: we ran a few random sampling based quality checks on the datasets. Based on these checks, we found the Hindi train and test datasets to be 93.8% and 97.8%, respectively. No issues were identified in the sampled Tamil train and test instances.

dslighting/registry/chaii-hindi-and-tamil-question-answering/description_obfuscated.md

@@ -0,0 +1,59 @@
+# Task
+
+Predicting the answers to questions in Hindi and Tamil.
+
+# Metric
+
+Word-level Jaccard score.
+
+A Python implementation is provided below.
+
+```
+def jaccard(str1, str2): 
+    a = set(str1.lower().split()) 
+    b = set(str2.lower().split())
+    c = a.intersection(b)
+    return float(len(c)) / (len(a) + len(b) - len(c))
+```
+
+The formula for the overall metric is:
+\text{score} = \frac{1}{n} \sum_{i=1}^n \text{jaccard}(gt_i, dt_i)
+
+where:
+$n$ = number of documents
+
+$\text{jaccard}$ = the function provided above
+
+$gt_i$ = the ith ground truth
+
+$dt_i$ = the ith prediction
+
+# Submission Format
+
+For each ID in the test set, you must predict the string that best answers the provided question based on the context. Note that the selected text needs to be quoted and complete to work correctly. Include punctuation, etc. The file should contain a header and have the following format:
+
+```
+id,PredictionString
+8c8ee6504,"1"
+3163c22d0,"2 string"
+66aae423b,"4 word 6"
+722085a7b,"1"
+etc.
+```
+
+# Dataset 
+
+**All files should be encoded as UTF-8.**
+
+- **train.csv** - the training set, containing context, questions, and answers. Also includes the start character of the answer for disambiguation.
+- **test.csv** - the test set, containing context and questions.
+- **sample_submission.csv** - a sample submission file in the correct format
+
+## Columns
+
+- `id` - a unique identifier
+- `context` - the text of the Hindi/Tamil sample from which answers should be derived
+- `question` - the question, in Hindi/Tamil
+- `answer_text` (train only) - the answer to the question (manual annotation) (note: for test, this is what you are attempting to predict)
+- `answer_start` (train only) - the starting character in `context` for the answer (determined using substring match during data preparation)
+- `language` - whether the text in question is in Tamil or Hindi

dslighting/registry/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")

dslighting/registry/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."

dslighting/registry/chaii-hindi-and-tamil-question-answering/prepare_val.py

@@ -0,0 +1,94 @@
+from pathlib import Path
+import pandas as pd
+
+from sklearn.model_selection import train_test_split
+
+from mlebench.utils import read_csv
+
+
+def _split_and_save(
+    source_df: pd.DataFrame,
+    public_dir: Path,
+    private_dir: Path,
+    test_size: float,
+    random_state: int,
+) -> pd.DataFrame:
+    """
+    Splits a dataframe into train and test sets and saves them to the specified
+    public and private directories, mimicking the competition data format.
+
+    Args:
+        source_df: The dataframe to be split.
+        public_dir: The directory for public-facing files (train set, unlabeled test set).
+        private_dir: The directory for private-facing files (test set labels).
+        test_size: The proportion of the dataset to allocate to the test split.
+        random_state: The seed used by the random number generator.
+
+    Returns:
+        The training set dataframe resulting from the split.
+    """
+    # Create train, test split
+    new_train, new_test = train_test_split(
+        source_df, test_size=test_size, random_state=random_state
+    )
+    new_test_without_labels = new_test.drop(columns=["answer_start", "answer_text"])
+
+    # make private test match submission format
+    new_test_labels = new_test[["id", "answer_text"]]
+    new_test_labels.columns = ["id", "PredictionString"]
+
+    # Ensure output directories exist
+    public_dir.mkdir(exist_ok=True)
+    private_dir.mkdir(exist_ok=True)
+    
+    # Copy over files
+    new_train.to_csv(public_dir / "train.csv", index=False)
+    new_test_without_labels.to_csv(public_dir / "test.csv", index=False)
+    new_test_labels.to_csv(private_dir / "test.csv", index=False)
+
+    # Create sample submission
+    sample_submission = new_test_labels.copy()
+    sample_submission["PredictionString"] = "dummy text"
+    sample_submission.to_csv(public_dir / "sample_submission.csv", index=False)
+
+    assert len(sample_submission) == len(
+        new_test_labels
+    ), "Sample submission length does not match test length."
+
+    return new_train
+
+
+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"
+
+    # Load the initial raw training data
+    original_train_df = read_csv(raw / "train.csv")
+
+    # --- First Split: Create original train/test sets ---
+    # This split generates the main competition files in `public` and `private`.
+    # The outputs of this step must remain identical to the original script.
+    main_train_set = _split_and_save(
+        source_df=original_train_df,
+        public_dir=public,
+        private_dir=private,
+        test_size=0.1,
+        random_state=0,
+    )
+
+    # --- Second Split: Create validation train/test sets from the main train set ---
+    # This split uses the *training data* from the first split as its source.
+    # The new `test_val` set will have approx. the same size as the original `test` set.
+    # test_size for 2nd split = (size of original test) / (size of new train)
+    # = (0.1 * total) / (0.9 * total) = 0.1 / 0.9
+    validation_test_size = 0.1 / (1.0 - 0.1)
+
+    _split_and_save(
+        source_df=main_train_set,
+        public_dir=public_val,
+        private_dir=private_val,
+        test_size=validation_test_size,
+        random_state=0,  # Use the same random state for consistency
+    )

dslighting/registry/champs-scalar-coupling/checksums.yaml

@@ -0,0 +1,13 @@
+private:
+  answers.csv: d41126a1d909d1e5c33d0a4828f2694d
+public:
+  dipole_moments.csv: e9227539164f9d43b1150121ae727940
+  magnetic_shielding_tensors.csv: 9a495d3d556092a7bf96f087187ee181
+  mulliken_charges.csv: 3bdc6ff0f3f451796923d4659eb6766d
+  potential_energy.csv: b30f3b3b2889e433487c3abdab6b6814
+  sample_submission.csv: fbb4313c3052857027152c871900a0c4
+  scalar_coupling_contributions.csv: 233037169b2a8f8ee1519c19c6eb7b6e
+  structures.csv: 6082e6a941b90bcabb7325f3bee64622
+  test.csv: 2c8b2fd3060697f3be78489290f40768
+  train.csv: bc4222feab583532854367a124d93aaa
+zip: 2e7bb40d8e2b3488250f15430b8cf947