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

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

@@ -0,0 +1,26 @@
+id: champs-scalar-coupling
+name: Predicting Molecular Properties
+competition_type: simple
+awards_medals: true
+prizes:
+  - position: 1
+    value: 12500
+  - position: 2
+    value: 7500
+  - position: 3
+    value: 5000
+  - position: 4
+    value: 3000
+  - position: 5
+    value: 2000
+description: mlebench/competitions/champs-scalar-coupling/description.md
+
+dataset:
+  answers: champs-scalar-coupling/prepared/private/answers.csv
+  sample_submission: champs-scalar-coupling/prepared/public/sample_submission.csv
+
+grader:
+  name: log-mean-absolute-error
+  grade_fn: mlebench.competitions.champs-scalar-coupling.grade:grade
+
+preparer: mlebench.competitions.champs-scalar-coupling.prepare:prepare

dslighting/registry/champs-scalar-coupling/description.md

@@ -0,0 +1,111 @@
+# Overview
+
+## Description
+
+![thumb76_76](https://storage.googleapis.com/kaggle-media/competitions/kaggle/14313/logos/thumb76_76.png?t=2019-05-16-16-56-19)
+
+Think you can use your data science smarts to make big predictions at a molecular level?
+
+This challenge aims to predict interactions between atoms. Imaging technologies like MRI enable us to see and understand the molecular composition of tissues. Nuclear Magnetic Resonance (NMR) is a closely related technology which uses the same principles to understand the structure and dynamics of proteins and molecules.
+
+Researchers around the world conduct NMR experiments to further understanding of the structure and dynamics of molecules, across areas like environmental science, pharmaceutical science, and materials science.
+
+This competition is hosted by members of the CHemistry and Mathematics in Phase Space (CHAMPS) at the University of Bristol, Cardiff University, Imperial College and the University of Leeds. Winning teams will have an opportunity to partner with this multi-university research program on an academic publication
+
+### Your Challenge
+
+In this competition, you will develop an algorithm that can predict the magnetic interaction between two atoms in a molecule (i.e., the scalar coupling constant).
+
+Once the competition finishes, CHAMPS would like to invite the top teams to present their work, discuss the details of their models, and work with them to write a joint research publication which discusses an open-source implementation of the solution.
+
+### About Scalar Coupling
+
+Using NMR to gain insight into a molecule’s structure and dynamics depends on the ability to accurately predict so-called “scalar couplings”. These are effectively the magnetic interactions between a pair of atoms. The strength of this magnetic interaction depends on intervening electrons and chemical bonds that make up a molecule’s three-dimensional structure.
+
+Using state-of-the-art methods from quantum mechanics, it is possible to accurately calculate scalar coupling constants given only a 3D molecular structure as input. However, these quantum mechanics calculations are extremely expensive (days or weeks per molecule), and therefore have limited applicability in day-to-day workflows.
+
+A fast and reliable method to predict these interactions will allow medicinal chemists to gain structural insights faster and cheaper, enabling scientists to understand how the 3D chemical structure of a molecule affects its properties and behavior.
+
+Ultimately, such tools will enable researchers to make progress in a range of important problems, like designing molecules to carry out specific cellular tasks, or designing better drug molecules to fight disease.
+
+Join the CHAMPS Scalar Coupling challenge to apply predictive analytics to chemistry and chemical biology.
+
+## Evaluation
+
+Submissions are evaluated on the Log of the Mean Absolute Error, calculated for each scalar coupling type, and then averaged across types, so that a 1% decrease in MAE for one type provides the same improvement in score as a 1% decrease for another type.
+
+$$
+\text { score }=\frac{1}{T} \sum_{t=1}^T \log \left(\frac{1}{n_t} \sum_{i=1}^{n_t}\left|y_i-\hat{y}_i\right|\right)
+$$
+
+Where:
+
+- $T$ is the number of scalar coupling types
+- $n_t$ is the number of observations of type $t$
+- $y_i$ is the actual scalar coupling constant for the observation
+- $\hat{y}_i$ is the predicted scalar coupling constant for the observation
+
+For this metric, the MAE for any group has a floor of `1e-9`, so that the minimum (best) possible score for perfect predictions is approximately -20.7232.
+
+### Submission File
+
+For each `id` in the test set, you must predict the `scalar_coupling_constant` variable. The file should contain a header and have the following format:
+
+```
+id,scalar_coupling_constant
+2324604,0.0
+2324605,0.0
+2324606,0.0
+etc.
+```
+
+## Timeline
+
+- **August 21, 2019** - Entry deadline. You must accept the competition rules before this date in order to compete.
+- **August 21, 2019** - Pre-trained model and external data disclosure deadline. Participants must disclose any external data or pre-trained models used in the official forum thread in adherence with [competition rules](https://www.kaggle.com/c/champs-scalar-coupling/rules).
+- **August 21, 2019** - Team merger deadline. This is the last day participants may join or merge teams.
+- **August 28, 2019** - 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
+
+The following prizes will be awarded to the winners of the competition:
+
+- 1st Place - $12,500
+- 2nd Place - $7,500
+- 3rd Place - $5,000
+- 4th Place - $3,000
+- 5th Place - $2,000
+
+## Citation
+
+Addison Howard, inversion, Lars Bratholm. (2019). Predicting Molecular Properties. Kaggle. https://kaggle.com/competitions/champs-scalar-coupling
+
+# Data
+
+## Dataset Description
+
+In this competition, you will be predicting the `scalar_coupling_constant` between atom pairs in molecules, given the two atom types (e.g., C and H), the coupling type (e.g., `2JHC`), and any features you are able to create from the molecule structure (`xyz`) files.
+
+For this competition, you will not be predicting *all* the atom pairs in each molecule rather, you will only need to predict the pairs that are explicitly listed in the train and test files. For example, some molecules contain Fluorine (F), but you will not be predicting the scalar coupling constant for any pair that includes F.
+
+The training and test splits are by *molecule*, so that no molecule in the training data is found in the test data.
+
+### Files
+
+- **train.csv** - the training set, where the first column (`molecule_name`) is the name of the molecule where the coupling constant originates (the corresponding XYZ file is located at ./structures/.xyz), the second (`atom_index_0`) and third column (`atom_index_1`) is the atom indices of the atom-pair creating the coupling and the fourth column (`scalar_coupling_constant`) is the scalar coupling constant that we want to be able to predict
+- **test.csv** - the test set; same info as train, without the target variable
+- **sample_submission.csv** - a sample submission file in the correct format
+- **structures.zip** - folder containing molecular structure (xyz) files, where the first line is the number of atoms in the molecule, followed by a blank line, and then a line for every atom, where the first column contains the atomic element (H for hydrogen, C for carbon etc.) and the remaining columns contain the X, Y and Z cartesian coordinates (a standard format for chemists and molecular visualization programs)
+- **structures.csv** - this file contains the **same** information as the individual xyz structure files, but in a single file
+
+### Additional Data
+
+*NOTE: additional data is provided for the molecules in Train only!*
+
+- **dipole_moments.csv** - contains the molecular electric dipole moments. These are three dimensional vectors that indicate the charge distribution in the molecule. The first column (`molecule_name`) are the names of the molecule, the second to fourth column are the `X`, `Y` and `Z` components respectively of the dipole moment.
+- **magnetic_shielding_tensors.csv** - contains the magnetic shielding tensors for all atoms in the molecules. The first column (`molecule_name`) contains the molecule name, the second column (`atom_index`) contains the index of the atom in the molecule, the third to eleventh columns contain the `XX`, `YX`, `ZX`, `XY`, `YY`, `ZY`, `XZ`, `YZ` and `ZZ` elements of the tensor/matrix respectively.
+- **mulliken_charges.csv** - contains the mulliken charges for all atoms in the molecules. The first column (`molecule_name`) contains the name of the molecule, the second column (`atom_index`) contains the index of the atom in the molecule, the third column (`mulliken_charge`) contains the mulliken charge of the atom.
+- **potential_energy.csv** - contains the potential energy of the molecules. The first column (`molecule_name`) contains the name of the molecule, the second column (`potential_energy`) contains the potential energy of the molecule.
+- **scalar_coupling_contributions.csv** - The scalar coupling constants in `train.csv` (or corresponding files) are a sum of four terms. `scalar_coupling_contributions.csv` contain all these terms. The first column (`molecule_name`) are the name of the molecule, the second (`atom_index_0`) and third column (`atom_index_1`) are the atom indices of the atom-pair, the fourth column indicates the type of coupling, the fifth column (`fc`) is the Fermi Contact contribution, the sixth column (`sd`) is the Spin-dipolar contribution, the seventh column (`pso`) is the Paramagnetic spin-orbit contribution and the eighth column (`dso`) is the Diamagnetic spin-orbit contribution.

dslighting/registry/champs-scalar-coupling/description_obfuscated.md

@@ -0,0 +1,32 @@
+# Task
+
+Predict the `scalar_coupling_constant` between atom pairs in molecules, given the two atom types (e.g., C and H), the coupling type (e.g., `2JHC`), and any features you are able to create from the molecule structure (`xyz`) files.
+
+# Metric
+
+Log of the Mean Absolute Error, calculated for each scalar coupling type, and then averaged across types.
+
+# Submission Format
+
+```
+id,scalar_coupling_constant
+2324604,0.0
+2324605,0.0
+2324606,0.0
+etc.
+```
+
+# Dataset
+
+The training and test splits are by *molecule*, so that no molecule in the training data is found in the test data.
+
+- **train.csv** - the training set, where the first column (`molecule_name`) is the name of the molecule where the coupling constant originates (the corresponding XYZ file is located at ./structures/.xyz), the second (`atom_index_0`) and third column (`atom_index_1`) is the atom indices of the atom-pair creating the coupling and the fourth column (`scalar_coupling_constant`) is the scalar coupling constant that we want to be able to predict
+- **test.csv** - the test set; same info as train, without the target variable
+- **sample_submission.csv** - a sample submission file in the correct format
+- **structures.zip** - folder containing molecular structure (xyz) files, where the first line is the number of atoms in the molecule, followed by a blank line, and then a line for every atom, where the first column contains the atomic element (H for hydrogen, C for carbon etc.) and the remaining columns contain the X, Y and Z cartesian coordinates (a standard format for chemists and molecular visualization programs)
+- **structures.csv** - this file contains the **same** information as the individual xyz structure files, but in a single file
+- **dipole_moments.csv** - contains the molecular electric dipole moments. These are three dimensional vectors that indicate the charge distribution in the molecule. The first column (`molecule_name`) are the names of the molecule, the second to fourth column are the `X`, `Y` and `Z` components respectively of the dipole moment.
+- **magnetic_shielding_tensors.csv** - contains the magnetic shielding tensors for all atoms in the molecules. The first column (`molecule_name`) contains the molecule name, the second column (`atom_index`) contains the index of the atom in the molecule, the third to eleventh columns contain the `XX`, `YX`, `ZX`, `XY`, `YY`, `ZY`, `XZ`, `YZ` and `ZZ` elements of the tensor/matrix respectively.
+- **mulliken_charges.csv** - contains the mulliken charges for all atoms in the molecules. The first column (`molecule_name`) contains the name of the molecule, the second column (`atom_index`) contains the index of the atom in the molecule, the third column (`mulliken_charge`) contains the mulliken charge of the atom.
+- **potential_energy.csv** - contains the potential energy of the molecules. The first column (`molecule_name`) contains the name of the molecule, the second column (`potential_energy`) contains the potential energy of the molecule.
+- **scalar_coupling_contributions.csv** - The scalar coupling constants in `train.csv` (or corresponding files) are a sum of four terms. `scalar_coupling_contributions.csv` contain all these terms. The first column (`molecule_name`) are the name of the molecule, the second (`atom_index_0`) and third column (`atom_index_1`) are the atom indices of the atom-pair, the fourth column indicates the type of coupling, the fifth column (`fc`) is the Fermi Contact contribution, the sixth column (`sd`) is the Spin-dipolar contribution, the seventh column (`pso`) is the Paramagnetic spin-orbit contribution and the eighth column (`dso`) is the Diamagnetic spin-orbit contribution.

dslighting/registry/champs-scalar-coupling/grade.py

@@ -0,0 +1,60 @@
+import numpy as np
+from pandas import DataFrame
+from sklearn.metrics import mean_absolute_error
+
+from mlebench.grade_helpers import InvalidSubmissionError
+
+
+def prepare_for_grading(submission: DataFrame, answers: DataFrame, target_column: str) -> DataFrame:
+    """
+    Merge the submission's target_column into the answers DataFrame, matching on 'id'.
+    target_column from the submission DataFrame will have the suffix '_pred',
+    and target_column from the answers DataFrame will have the suffix '_true'.
+    """
+
+    # Answers checks
+    assert (
+        target_column in answers.columns
+    ), f"Target column {target_column} not found in answers DataFrame."
+    assert "id" in answers.columns, "ID column not found in answers DataFrame."
+    assert "type" in answers.columns, "Type column not found in answers DataFrame."
+
+    # Submission checks
+    if target_column not in submission.columns:
+        raise InvalidSubmissionError(
+            f"Target column {target_column} not found in submission DataFrame."
+        )
+    if "id" not in submission.columns:
+        raise InvalidSubmissionError("ID column not found in submission DataFrame.")
+    if not set(submission["id"]) == set(answers["id"]):
+        raise InvalidSubmissionError(
+            f"Submission is missing the following ids: {set(answers['id']) - set(submission['id'])}"
+        )
+
+    merged = answers.merge(submission[["id", target_column]], on="id", suffixes=("_true", "_pred"))
+    return merged
+
+
+def log_mae(y_true, y_pred):
+    mae = mean_absolute_error(y_true, y_pred)
+    return np.log(mae)
+
+
+def grade(submission: DataFrame, answers: DataFrame) -> float:
+    """
+    Submissions are evaluated on the Log of the Mean Absolute Error, calculated for each scalar coupling type, and then averaged across types, so that a 1% decrease in MAE for one type provides the same improvement in score as a 1% decrease for another type. https://www.kaggle.com/c/champs-scalar-coupling/overview
+    """
+    merged = prepare_for_grading(submission, answers, "scalar_coupling_constant")
+
+    # Group by scalar coupling type
+    grouped = merged.groupby("type")
+
+    log_maes = []
+    for name, group in grouped:
+        y_true = group["scalar_coupling_constant_true"]
+        y_pred = group["scalar_coupling_constant_pred"]
+        log_maes.append(log_mae(y_true, y_pred))
+
+    # Average the log MAEs
+    score = np.mean(log_maes)
+    return score

dslighting/registry/champs-scalar-coupling/prepare.py

@@ -0,0 +1,116 @@
+import shutil
+from pathlib import Path
+
+import pandas as pd
+from sklearn.model_selection import train_test_split
+from tqdm import tqdm
+
+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")
+    grouped_by_molecule = list(old_train.groupby("molecule_name"))
+    train_groups, test_groups = train_test_split(grouped_by_molecule, test_size=0.1, random_state=0)
+    new_train = pd.concat([group for _, group in train_groups])
+    answers = pd.concat([group for _, group in test_groups])
+    new_test = answers.drop(columns=["scalar_coupling_constant"])
+
+    # Create sample submission
+    sample_submission = new_test[["id"]].copy()
+    sample_submission["scalar_coupling_constant"] = 0
+
+    # Molecule structure data in CSV format
+    structures = read_csv(raw / "structures.csv")
+    structures = structures[structures["molecule_name"].isin(new_train["molecule_name"])]
+
+    # Additional data CSVs
+    dipole_moments = read_csv(raw / "dipole_moments.csv")
+    dipole_moments = dipole_moments[
+        dipole_moments["molecule_name"].isin(new_train["molecule_name"])
+    ]
+
+    magnetic_shielding_tensors = read_csv(raw / "magnetic_shielding_tensors.csv")
+    magnetic_shielding_tensors = magnetic_shielding_tensors[
+        magnetic_shielding_tensors["molecule_name"].isin(new_train["molecule_name"])
+    ]
+
+    mulliken_charges = read_csv(raw / "mulliken_charges.csv")
+    mulliken_charges = mulliken_charges[
+        mulliken_charges["molecule_name"].isin(new_train["molecule_name"])
+    ]
+
+    potential_energy = read_csv(raw / "potential_energy.csv")
+    potential_energy = potential_energy[
+        potential_energy["molecule_name"].isin(new_train["molecule_name"])
+    ]
+
+    scalar_coupling_contributions = read_csv(raw / "scalar_coupling_contributions.csv")
+    scalar_coupling_contributions = scalar_coupling_contributions[
+        scalar_coupling_contributions["molecule_name"].isin(new_train["molecule_name"])
+    ]
+
+    # Checks before writing
+    data_csvs = {
+        "structures": structures,
+        "dipole_moments": dipole_moments,
+        "magnetic_shielding_tensors": magnetic_shielding_tensors,
+        "mulliken_charges": mulliken_charges,
+        "potential_energy": potential_energy,
+        "scalar_coupling_contributions": scalar_coupling_contributions,
+    }
+    for name, dataset in data_csvs.items():
+        assert set(dataset["molecule_name"]) == set(
+            new_train["molecule_name"]
+        ), f"Filtered {name} should exactly match the molecule names present in the new_train set."
+
+    assert set(new_train["molecule_name"]).isdisjoint(
+        set(new_test["molecule_name"])
+    ), "Train and test sets should not share any samples with the same molecule name."
+
+    assert set(new_train["id"]).isdisjoint(
+        set(new_test["id"])
+    ), "Train and test sets should not share any samples with the same id."
+
+    assert len(sample_submission) == len(
+        new_test
+    ), "Sample submission length does not match test length."
+
+    assert (
+        sample_submission.shape[1] == 2
+    ), f"Sample submission should have 2 columns, but has {sample_submission.shape[1]}"
+
+    assert new_test.shape[1] == 5, f"new_test should have 5 columns, but has {new_test.shape[1]}"
+
+    assert answers.shape[1] == 6, f"answers should have 6 columns, but has {answers.shape[1]}"
+
+    assert new_train.shape[1] == 6, f"new_train should have 6 columns, but has {new_train.shape[1]}"
+
+    # Copy over molecule structure data individual files
+    for molecule_name in tqdm(
+        new_train["molecule_name"].unique(), desc="Copying molecule structure files"
+    ):
+        src_file = raw / "structures" / f"{molecule_name}.xyz"
+        dst_file = public / "structures" / f"{molecule_name}.xyz"
+        dst_file.parent.mkdir(parents=True, exist_ok=True)
+        shutil.copyfile(src=src_file, dst=dst_file)
+
+    # Write CSVs
+    answers.to_csv(private / "answers.csv", index=False)
+
+    new_train.to_csv(public / "train.csv", index=False)
+    new_test.to_csv(public / "test.csv", index=False)
+    sample_submission.to_csv(public / "sample_submission.csv", index=False)
+    structures.to_csv(public / "structures.csv", index=False)
+    dipole_moments.to_csv(public / "dipole_moments.csv", index=False)
+    magnetic_shielding_tensors.to_csv(public / "magnetic_shielding_tensors.csv", index=False)
+    mulliken_charges.to_csv(public / "mulliken_charges.csv", index=False)
+    potential_energy.to_csv(public / "potential_energy.csv", index=False)
+    scalar_coupling_contributions.to_csv(public / "scalar_coupling_contributions.csv", index=False)
+
+    # Checks after writing
+    assert len(list((public / "structures").glob("*.xyz"))) == len(
+        new_train["molecule_name"].unique()
+    ), "The number of files in public/structures should match the number of unique molecule names in the train set."

dslighting/registry/champs-scalar-coupling/prepare_val.py

@@ -0,0 +1,155 @@
+import shutil
+from pathlib import Path
+from typing import Dict
+
+import pandas as pd
+from sklearn.model_selection import train_test_split
+from tqdm import tqdm
+
+from mlebench.utils import read_csv
+
+
+def _process_and_save_split(
+    train_df: pd.DataFrame,
+    test_df: pd.DataFrame,
+    answers_df: pd.DataFrame,
+    public_path: Path,
+    private_path: Path,
+    raw_path: Path,
+    raw_supplementary_data: Dict[str, pd.DataFrame],
+):
+    """
+    Helper function to process and save a single data split (e.g., train/test or train_val/test_val).
+
+    This function takes a pair of train/test sets, filters the supplementary data accordingly,
+    performs checks, and writes all the necessary files to the specified public and private directories.
+    """
+    public_path.mkdir(exist_ok=True)
+    private_path.mkdir(exist_ok=True)
+
+    # Create sample submission for the current test set
+    sample_submission = test_df[["id"]].copy()
+    sample_submission["scalar_coupling_constant"] = 0
+
+    # Filter supplementary data to only include molecules present in the training set
+    train_molecules = set(train_df["molecule_name"])
+    filtered_supplementary_data = {}
+    for name, df in raw_supplementary_data.items():
+        filtered_supplementary_data[name] = df[df["molecule_name"].isin(train_molecules)]
+
+    # Checks before writing
+    for name, dataset in filtered_supplementary_data.items():
+        assert set(dataset["molecule_name"]) == train_molecules, (
+            f"[{public_path.name}] Filtered {name} should exactly match the molecule names "
+            "present in the train set."
+        )
+
+    assert set(train_df["molecule_name"]).isdisjoint(
+        set(test_df["molecule_name"])
+    ), f"[{public_path.name}] Train and test sets should not share any molecule names."
+
+    assert set(train_df["id"]).isdisjoint(
+        set(test_df["id"])
+    ), f"[{public_path.name}] Train and test sets should not share any sample ids."
+
+    assert len(sample_submission) == len(
+        test_df
+    ), f"[{public_path.name}] Sample submission length does not match test length."
+
+    # Write CSVs to public and private directories
+    answers_df.to_csv(private_path / "answers.csv", index=False)
+
+    train_df.to_csv(public_path / "train.csv", index=False)
+    test_df.to_csv(public_path / "test.csv", index=False)
+    sample_submission.to_csv(public_path / "sample_submission.csv", index=False)
+
+    for name, df in filtered_supplementary_data.items():
+        df.to_csv(public_path / f"{name}.csv", index=False)
+
+    # Copy over molecule structure .xyz files for the training set
+    structures_xyz_path = public_path / "structures"
+    structures_xyz_path.mkdir(parents=True, exist_ok=True)
+    for molecule_name in tqdm(
+        train_df["molecule_name"].unique(),
+        desc=f"Copying .xyz files to {public_path.name}",
+    ):
+        src_file = raw_path / "structures" / f"{molecule_name}.xyz"
+        dst_file = structures_xyz_path / f"{molecule_name}.xyz"
+        shutil.copyfile(src=src_file, dst=dst_file)
+
+    # Checks after writing
+    assert len(list(structures_xyz_path.glob("*.xyz"))) == len(
+        train_df["molecule_name"].unique()
+    ), (
+        f"[{public_path.name}] The number of files in {structures_xyz_path} should match the number "
+        "of unique molecule names in the train set."
+    )
+
+
+def prepare(raw: Path, public: Path, private: Path):
+    """
+    Prepares the data by performing two splits:
+    1. A main split of the raw data into a definitive train/test set.
+       Outputs are saved to `public/` and `private/`.
+    2. A validation split of the main training set into a smaller train/validation set.
+       Outputs are saved to `public_val/` and `private_val/`, mirroring the main output structure.
+    """
+    # Load all data from raw directory first
+    old_train = read_csv(raw / "train.csv")
+
+    # Load all supplementary data into a dictionary for easy filtering later
+    raw_supplementary_data = {
+        "structures": read_csv(raw / "structures.csv"),
+        "dipole_moments": read_csv(raw / "dipole_moments.csv"),
+        "magnetic_shielding_tensors": read_csv(raw / "magnetic_shielding_tensors.csv"),
+        "mulliken_charges": read_csv(raw / "mulliken_charges.csv"),
+        "potential_energy": read_csv(raw / "potential_energy.csv"),
+        "scalar_coupling_contributions": read_csv(raw / "scalar_coupling_contributions.csv"),
+    }
+
+    # --- Create main Train/Test Split (Original Logic) ---
+    # The outputs of this split are final and must not be changed.
+    grouped_by_molecule = list(old_train.groupby("molecule_name"))
+    train_groups, test_groups = train_test_split(grouped_by_molecule, test_size=0.1, random_state=0)
+    new_train = pd.concat([group for _, group in train_groups])
+    answers = pd.concat([group for _, group in test_groups])
+    new_test = answers.drop(columns=["scalar_coupling_constant"])
+
+    # Process and save the main split to `public` and `private` directories
+    _process_and_save_split(
+        train_df=new_train,
+        test_df=new_test,
+        answers_df=answers,
+        public_path=public,
+        private_path=private,
+        raw_path=raw,
+        raw_supplementary_data=raw_supplementary_data,
+    )
+
+    # --- Create Validation Split (New Logic) ---
+    # This second split uses the `new_train` set from above to create a smaller
+    # training set and a new validation set.
+    public_val = public.parent / "public_val"
+    private_val = private.parent / "private_val"
+
+    # Split the `new_train` set by molecule groups again.
+    # The original test set was 10% of the total. The new train set is 90% of the total.
+    # To get a validation set of a similar size (10% of total), the test_size for this
+    # second split should be (10% / 90%) = 1/9.
+    train_val_groups, test_val_groups = train_test_split(
+        train_groups, test_size=1 / 9, random_state=0
+    )
+    train_val = pd.concat([group for _, group in train_val_groups])
+    answers_val = pd.concat([group for _, group in test_val_groups])
+    test_val = answers_val.drop(columns=["scalar_coupling_constant"])
+
+    # Process and save the validation split to `public_val` and `private_val` directories
+    _process_and_save_split(
+        train_df=train_val,
+        test_df=test_val,
+        answers_df=answers_val,
+        public_path=public_val,
+        private_path=private_val,
+        raw_path=raw,
+        raw_supplementary_data=raw_supplementary_data,
+    )

dslighting/registry/conways-reverse-game-of-life-2020/checksums.yaml

@@ -0,0 +1,9 @@
+private:
+  gold_submission.csv: 5b7dcbd44c4c4b334b55bbdc70e47e22
+  test.csv: e99e76c60cdcd7814405c1778786a608
+public:
+  description.md: b2e525b29a8c2e35acd72310980f3a16
+  sample_submission.csv: ed674e21fc89116dd36c3c3b953669f7
+  test.csv: 10d13d3f9f0fdc22ac7530a35bce7f5f
+  train.csv: 96dce4ba39398304cbc0132ad72a5d21
+zip: ""

dslighting/registry/conways-reverse-game-of-life-2020/config.yaml

@@ -0,0 +1,17 @@
+id: conways-reverse-game-of-life-2020
+name: Conway's Reverse Game of Life 2020
+competition_type: simple
+awards_medals: false
+prizes: null
+description: mlebench/competitions/conways-reverse-game-of-life-2020/description.md
+
+dataset:
+  answers: conways-reverse-game-of-life-2020/prepared/private/test.csv
+  gold_submission: conways-reverse-game-of-life-2020/prepared/private/gold_submission.csv
+  sample_submission: conways-reverse-game-of-life-2020/prepared/public/sample_submission.csv
+
+grader:
+  name: accuracy
+  grade_fn: mlebench.competitions.conways-reverse-game-of-life-2020.grade:grade
+
+preparer: mlebench.competitions.conways-reverse-game-of-life-2020.prepare:prepare

dslighting/registry/conways-reverse-game-of-life-2020/description.md

@@ -0,0 +1,27 @@
+# Conway's Reverse Game of Life 2020
+
+## Task
+
+Given the final state of a 25×25 Conway’s Game of Life board and the number of steps `delta` taken to reach it, recover a valid starting state that evolves into the supplied ending configuration. The grid wraps on both axes, so neighbors include cells across opposite edges. Any starting board that reproduces the published final board after `delta` steps is considered correct.
+
+## Data
+
+- `train.csv` – 50 000 examples with `id`, `delta`, starting board cells (`start_0` … `start_624`), and final board cells (`stop_0` … `stop_624`).
+- `test.csv` – held-out games with `id`, `delta`, and final board cells only.
+- `sample_submission.csv` – template showing the expected column order (`id`, `start_0` … `start_624`).
+
+All grids are flattened row-wise (25 × 25 = 625 cells).
+
+## Submission Format
+
+Produce a CSV with one row per `id` containing binary predictions (`0` = dead, `1` = alive) for every `start_*` column:
+
+```
+id,start_0,start_1,...,start_624
+50000,0,0,...,0
+50001,1,0,...,0
+```
+
+## Evaluation
+
+Submissions are rolled forward `delta` steps under the Game of Life rules and compared to the provided final boards. Because the simulator enforces binary states, this is equivalent to computing the mean absolute error (MAE) between the predicted and true starting grids. We report accuracy as `1 - MAE`, so higher scores are better and a perfect reconstruction scores `1.0`.

dslighting/registry/conways-reverse-game-of-life-2020/grade.py

@@ -0,0 +1,40 @@
+import numpy as np
+import pandas as pd
+
+from mlebench.grade_helpers import InvalidSubmissionError
+
+
+def grade(submission: pd.DataFrame, answers: pd.DataFrame) -> float:
+    """Return accuracy between predicted and true starting boards."""
+    if "id" not in submission.columns:
+        raise InvalidSubmissionError("Submission is missing required column 'id'.")
+
+    start_cols = [col for col in answers.columns if col.startswith("start_")]
+    if not start_cols:
+        raise ValueError("Answers DataFrame does not contain any start_* columns.")
+
+    missing_cols = [col for col in start_cols if col not in submission.columns]
+    if missing_cols:
+        raise InvalidSubmissionError(
+            f"Submission is missing required start columns: {missing_cols[:5]}"
+        )
+
+    merged = answers[["id", *start_cols]].merge(
+        submission[["id", *start_cols]],
+        on="id",
+        how="left",
+        suffixes=("_true", "_pred"),
+    )
+
+    pred_cols = [f"{col}_pred" for col in start_cols]
+    if merged[pred_cols].isna().any().any():
+        raise InvalidSubmissionError("Submission contains missing predictions for some ids.")
+
+    preds = merged[pred_cols].to_numpy(dtype=float)
+    truths = merged[[f"{col}_true" for col in start_cols]].to_numpy(dtype=float)
+
+    if not np.isin(preds, [0, 1]).all():
+        raise InvalidSubmissionError("Predictions must be binary (0 or 1).")
+
+    mae = np.abs(preds - truths).mean()
+    return float(1.0 - mae)

dslighting/registry/conways-reverse-game-of-life-2020/prepare.py

@@ -0,0 +1,41 @@
+from pathlib import Path
+
+import pandas as pd
+
+from mlebench.utils import read_csv
+
+
+def prepare(raw: Path, public: Path, private: Path) -> None:
+    """Prepare Reverse Game of Life tables for MLE-Bench."""
+    public.mkdir(parents=True, exist_ok=True)
+    private.mkdir(parents=True, exist_ok=True)
+
+    train = read_csv(raw / "train.csv")
+    test = read_csv(raw / "test.csv")
+    answers = read_csv(raw / "test_answer.csv")
+
+    sample_path = raw / "sample_submission.csv"
+    if sample_path.exists():
+        sample_submission = read_csv(sample_path)
+    else:
+        start_cols = [col for col in answers.columns if col.startswith("start_")]
+        sample_submission = answers[["id", *start_cols]].copy()
+        sample_submission[start_cols] = 0
+
+    merged_private = test.merge(answers, on="id", how="left", validate="one_to_one")
+    start_cols = [col for col in answers.columns if col.startswith("start_")]
+    if merged_private[start_cols].isna().any().any():
+        missing_ids = merged_private.loc[merged_private[start_cols].isna().any(axis=1), "id"].tolist()
+        raise ValueError(f"Missing start cells for ids: {missing_ids[:5]}")
+
+    train.to_csv(public / "train.csv", index=False)
+    test.to_csv(public / "test.csv", index=False)
+    sample_submission.to_csv(public / "sample_submission.csv", index=False)
+
+    merged_private.to_csv(private / "test.csv", index=False)
+    answers.to_csv(private / "gold_submission.csv", index=False)
+
+    assert len(test) == len(answers) == len(merged_private), "Public test and answers row counts differ."
+    assert sample_submission.columns.tolist()[0] == "id", "Sample submission must start with 'id'."
+    for col in start_cols:
+        assert col in sample_submission.columns, f"Sample submission missing column {col}."

dslighting/registry/dabench-0-mean-fare-paid/checksums.yaml

@@ -0,0 +1,2 @@
+# Checksums for dabench-0-mean-fare-paid dataset
+zip: ""