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

dslighting/registry/playground-series-s3e11/prepare.py

@@ -0,0 +1,25 @@
+from pathlib import Path
+import pandas as pd
+
+
+def prepare(raw: Path, public: Path, private: Path):
+    """
+    Prepare playground-series-s3e11 dataset.
+    """
+    # Read data
+    train = pd.read_csv(raw / "train.csv")
+    test = pd.read_csv(raw / "test.csv")
+    sample_submission = pd.read_csv(raw / "sample_submission.csv")
+    test_answer = pd.read_csv(raw / "test_answer.csv")
+
+    # Public files (visible to agents)
+    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)
+
+    # Private files (for grading)
+    test_answer.to_csv(private / "test.csv", index=False)
+
+    # Validation checks
+    assert len(test_answer) == len(sample_submission), \
+        f"Test answer ({len(test_answer)}) and sample submission ({len(sample_submission)}) must have same length"

dslighting/registry/playground-series-s3e18/checksums.yaml

@@ -0,0 +1,7 @@
+private:
+  test.csv: f744297d99692b67dc82c54f672a4745
+public:
+  sample_submission.csv: 9bb782a52ccbfd6873f9a1e9cc3e97d3
+  test.csv: 1a77aa7922b712e3085a771b8fe73c5f
+  train.csv: e19b27b614d5a3bb74b930c52d659799
+zip: 7e5aa885e5138b6b5668f426347c7602

dslighting/registry/playground-series-s3e18/config.yaml

@@ -0,0 +1,16 @@
+id: playground-series-s3e18
+name: Explore Multi-Label Classification with an Enzyme Substrate Dataset
+competition_type: simple
+awards_medals: false
+prizes: null
+description: mlebench/competitions/playground-series-s3e18/description.md
+
+dataset:
+  answers: playground-series-s3e18/prepared/private/test.csv
+  sample_submission: playground-series-s3e18/prepared/public/sample_submission.csv
+
+grader:
+  name: auroc-multi-label
+  grade_fn: mlebench.competitions.playground-series-s3e18.grade:grade
+
+preparer: mlebench.competitions.playground-series-s3e18.prepare:prepare

dslighting/registry/playground-series-s3e18/description.md

@@ -0,0 +1,56 @@
+# Overview
+
+## Description
+
+### Welcome to the 2023 edition of Kaggle's Playground Series!
+
+Thank you to everyone who participated in and contributed to Season 3 Playground Series so far!
+
+With the same goal to give the Kaggle community a variety of fairly light-weight challenges that can be used to learn and sharpen skills in different aspects of machine learning and data science, we will continue launching the Tabular Tuesday in June every Tuesday 00:00 UTC, with each competition running for 2 weeks. Again, these will be fairly light-weight datasets that are synthetically generated from real-world data, and will provide an opportunity to quickly iterate through various model and feature engineering ideas, create visualizations, etc.
+
+### Synthetically-Generated Datasets
+
+Using synthetic data for Playground competitions allows us to strike a balance between having real-world data (with named features) and ensuring test labels are not publicly available. This allows us to host competitions with more interesting datasets than in the past. While there are still challenges with synthetic data generation, the state-of-the-art is much better now than when we started the Tabular Playground Series two years ago, and that goal is to produce datasets that have far fewer artifacts. Please feel free to give us feedback on the datasets for the different competitions so that we can continue to improve!
+
+## Evaluation
+
+Submissions are evaluated on [area under the ROC curve](http://en.wikipedia.org/wiki/Receiver_operating_characteristic) between the predicted probability and the ground truth for each target, and the final score is the average of the individual AUCs of each predicted column.
+
+### Submission File
+For each `id` in the test set, you must predict the value for the targets `EC1` and `EC2`. The file should contain a header and have the following format:
+
+```
+id,EC1,EC2
+14838,0.22,0.71
+14839,0.78,0.43
+14840,0.53,0.11
+etc.
+```
+
+## Timeline
+- **Start Date** - June 27, 2023
+- **Entry Deadline** - Same as the Final Submission Deadline
+- **Team Merger Deadline** - Same as the Final Submission Deadline
+- **Final Submission Deadline** - July 10, 2023
+
+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 - Choice of Kaggle merchandise
+- 2nd Place - Choice of Kaggle merchandise
+- 3rd Place - Choice of Kaggle merchandise
+
+**Please note**: In order to encourage more participation from beginners, Kaggle merchandise will only be awarded once per person in this series. If a person has previously won, we'll skip to the next team.
+
+## Citation
+Walter Reade, Ashley Chow. (2023). Explore Multi-Label Classification with an Enzyme Substrate Dataset. Kaggle. https://kaggle.com/competitions/playground-series-s3e18
+
+## Dataset Description
+The dataset for this competition (both train and test) was generated from a deep learning model trained on a portion of the [Multi-label Classification of enzyme substrates](https://www.kaggle.com/datasets/gopalns/ec-mixed-class). This dataset only uses a subset of features from the original (the features that had the most signal). Feature distributions are close to, but not exactly the same, as the original. Feel free to use the original dataset as part of this competition, both to explore differences as well as to see whether incorporating the original in training improves model performance.
+
+**Note:** For this challenge, you are given 6 features in the training data, but only asked to predict the first two features (`EC1` and `EC2`).
+
+### Files
+- **train.csv** - the training dataset; `[EC1 - EC6]` are the (binary) targets, although you are only asked to predict `EC1` and `EC2`.
+- **test.csv** - the test dataset; your objective is to predict the probability of the two targets `EC1` and `EC2`
+- **sample_submission.csv** - a sample submission file in the correct format

dslighting/registry/playground-series-s3e18/description_obfuscated.md

@@ -0,0 +1,27 @@
+# Task
+
+Predict values for synthetic data.
+
+## Description
+
+# Metric
+
+Area under the ROC curve for each target, with the final score being the average of the individual AUCs of each predicted column.
+
+# Submission Format
+
+For each `id` in the test set, you must predict the value for the targets `EC1` and `EC2`. The file should contain a header and have the following format:
+
+```
+id,EC1,EC2
+14838,0.22,0.71
+14839,0.78,0.43
+14840,0.53,0.11
+etc.
+```
+
+# Dataset 
+
+- **train.csv** - the training dataset; `[EC1 - EC6]` are the (binary) targets, although you are only asked to predict `EC1` and `EC2`.
+- **test.csv** - the test dataset; your objective is to predict the probability of the two targets `EC1` and `EC2`
+- **sample_submission.csv** - a sample submission file in the correct format

dslighting/registry/playground-series-s3e18/grade.py

@@ -0,0 +1,39 @@
+import pandas as pd
+from sklearn.metrics import roc_auc_score
+
+from mlebench.grade_helpers import InvalidSubmissionError
+
+
+def prepare_for_metric(submission: pd.DataFrame, answers: pd.DataFrame) -> dict:
+
+    if "id" not in submission.columns or "id" not in answers.columns:
+        raise InvalidSubmissionError(
+            "Both submission and answers DataFrames must contain an 'id' column."
+        )
+
+    if "EC1" not in submission.columns or "EC2" not in submission.columns:
+        raise InvalidSubmissionError("Submission DataFrame must contain 'EC1' and 'EC2' columns.")
+
+    assert (
+        "EC1" in answers.columns and "EC2" in answers.columns
+    ), "Answers DataFrame must contain 'EC1' and 'EC2' columns."
+
+    if len(submission) != len(answers):
+        raise InvalidSubmissionError("Submission must be the same length as the answers.")
+
+    answers_sorted = answers.sort_values("id")
+    submission_sorted = submission.sort_values("id")
+
+    if (submission_sorted["id"].values != answers_sorted["id"].values).any():
+        raise InvalidSubmissionError("Submission and answers have mismatched 'id' columns")
+
+    y_true = answers_sorted[["EC1", "EC2"]].to_numpy()
+    y_score = submission_sorted[["EC1", "EC2"]].to_numpy()
+
+    return {"y_true": y_true, "y_score": y_score}
+
+
+def grade(submission: pd.DataFrame, answers: pd.DataFrame) -> float:
+    roc_auc_inputs = prepare_for_metric(submission, answers)
+    # macro average: calc metric for each class, and then average, as outlined in comp description
+    return roc_auc_score(**roc_auc_inputs, average="macro")

dslighting/registry/playground-series-s3e18/prepare.py

@@ -0,0 +1,36 @@
+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 and test splits from train set
+    old_train = read_csv(raw / "train.csv")
+    new_train, new_test = train_test_split(old_train, test_size=0.1, random_state=0)
+
+    # Create sample submission
+    sample_submission = new_test.copy()
+    sample_submission["EC1"] = 0.5
+    sample_submission["EC2"] = 0.5
+    sample_submission.drop(
+        sample_submission.columns.difference(["id", "EC1", "EC2"]), axis=1, inplace=True
+    )
+    sample_submission.to_csv(public / "sample_submission.csv", index=False)
+
+    # Create private files
+    new_test.to_csv(private / "test.csv", index=False)
+
+    # Create public files visible to agents
+    new_train.to_csv(public / "train.csv", index=False)
+    new_test.drop(["EC1", "EC2", "EC3", "EC4", "EC5", "EC6"], axis=1, inplace=True)
+    new_test.to_csv(public / "test.csv", index=False)
+
+    # Checks
+    assert new_test.shape[1] == 32, "Public test set should have 32 columns"
+    assert new_train.shape[1] == 38, "Public train set should have 38 columns"
+    assert len(new_train) + len(new_test) == len(
+        old_train
+    ), "Length of new_train and new_test should equal length of old_train"

dslighting/registry/playground-series-s3e18/prepare_val.py

@@ -0,0 +1,89 @@
+from pathlib import Path
+import pandas as pd
+
+from sklearn.model_selection import train_test_split
+
+from mlebench.utils import read_csv
+
+
+def _save_split_files(train_df: pd.DataFrame, test_df: pd.DataFrame, public_dir: Path, private_dir: Path):
+    """
+    Saves the train/test splits to the specified public and private directories,
+    ensuring a consistent file structure and content format.
+
+    - Creates a sample submission file in public_dir.
+    - Saves the full test set (with labels) to private_dir.
+    - Saves the train set to public_dir.
+    - Saves the test set (without labels) to public_dir.
+    """
+    # Ensure output directories exist
+    public_dir.mkdir(parents=True, exist_ok=True)
+    private_dir.mkdir(parents=True, exist_ok=True)
+
+    # Create sample submission from a copy of the full test set
+    sample_submission = test_df.copy()
+    sample_submission["EC1"] = 0.5
+    sample_submission["EC2"] = 0.5
+    sample_submission.drop(
+        sample_submission.columns.difference(["id", "EC1", "EC2"]), axis=1, inplace=True
+    )
+    sample_submission.to_csv(public_dir / "sample_submission.csv", index=False)
+
+    # Create private files (full test set with labels)
+    test_df.to_csv(private_dir / "test.csv", index=False)
+
+    # Create public files visible to agents
+    train_df.to_csv(public_dir / "train.csv", index=False)
+
+    # Create public test set (without labels) from a new copy
+    public_test_df = test_df.copy()
+    public_test_df.drop(["EC1", "EC2", "EC3", "EC4", "EC5", "EC6"], axis=1, inplace=True)
+    public_test_df.to_csv(public_dir / "test.csv", index=False)
+
+
+def prepare(raw: Path, public: Path, private: Path):
+    # Read the raw data
+    old_train = read_csv(raw / "train.csv")
+
+    # --- Step 1: Create the original train/test split ---
+    # This split is used for the main competition leaderboard. Its outputs
+    # in `public/` and `private/` must remain identical to the original script.
+    original_test_size = 0.1
+    new_train, new_test = train_test_split(
+        old_train, test_size=original_test_size, random_state=0
+    )
+
+    # Save the files for the original split, ensuring original outputs are unchanged
+    _save_split_files(new_train, new_test, public, private)
+
+    # --- Step 2: Create the new validation split ---
+    # This second split is derived from the *training data* of the first split.
+    # It creates a smaller training set and a validation set for users,
+    # saved to parallel `public_val/` and `private_val/` directories.
+
+    # Define paths for the new validation split outputs
+    public_val = public.parent / "public_val"
+    private_val = private.parent / "private_val"
+
+    # To keep the new validation set size (`test_val`) the same as the original
+    # test set size (`new_test`), we adjust the split ratio.
+    # test_val_size = original_test_size / (1 - original_test_size)
+    val_split_test_size = original_test_size / (1.0 - original_test_size)
+
+    # Create the new training and validation sets from the first-pass training data
+    train_val, test_val = train_test_split(
+        new_train, test_size=val_split_test_size, random_state=0
+    )
+
+    # Save the files for the new validation split using the same helper.
+    # This guarantees the file/directory structure is mirrored.
+    _save_split_files(train_val, test_val, public_val, private_val)
+
+    # Original checks (adapted slightly for clarity after refactoring)
+    public_test_df = read_csv(public / "test.csv")
+    public_train_df = read_csv(public / "train.csv")
+    assert public_test_df.shape[1] == 32, "Public test set should have 32 columns"
+    assert public_train_df.shape[1] == 38, "Public train set should have 38 columns"
+    assert len(public_train_df) + len(public_test_df) == len(
+        old_train
+    ), "Length of new_train and new_test should equal length of old_train"

dslighting/registry/playground_series_s3e1/grade.py

@@ -0,0 +1,52 @@
+import numpy as np
+import pandas as pd
+from sklearn.metrics import mean_squared_error
+
+from mlebench.grade_helpers import InvalidSubmissionError
+
+
+def prepare_for_metric(submission: pd.DataFrame, answers: pd.DataFrame):
+    """Prepare submission and answers for RMSE calculation."""
+    if len(submission) != len(answers):
+        raise InvalidSubmissionError(
+            f"Submission length ({len(submission)}) != answers length ({len(answers)})"
+        )
+
+    if "id" not in submission.columns:
+        raise InvalidSubmissionError("Submission must have an 'id' column")
+
+    if "MedHouseVal" not in submission.columns:
+        raise InvalidSubmissionError("Submission must have a 'MedHouseVal' column")
+
+    # Sort by id
+    submission = submission.sort_values("id").reset_index(drop=True)
+    answers = answers.sort_values("id").reset_index(drop=True)
+
+    # Check id alignment
+    if not (submission["id"] == answers["id"]).all():
+        raise InvalidSubmissionError("Submission and answers id mismatch")
+
+    # Extract predictions and true values
+    y_pred = submission["MedHouseVal"].values
+    y_true = answers["MedHouseVal"].values
+
+    # Validate predictions
+    try:
+        y_pred = y_pred.astype(float)
+    except (ValueError, TypeError):
+        raise InvalidSubmissionError("Predictions must be numeric")
+
+    if np.any(np.isnan(y_pred)):
+        raise InvalidSubmissionError("Predictions cannot contain NaN values")
+
+    return y_true, y_pred
+
+
+def grade(submission: pd.DataFrame, answers: pd.DataFrame) -> float:
+    """Calculate RMSE score."""
+    y_true, y_pred = prepare_for_metric(submission, answers)
+
+    # RMSE
+    rmse = np.sqrt(mean_squared_error(y_true, y_pred))
+
+    return rmse

dslighting/registry/playground_series_s3e1/prepare.py

@@ -0,0 +1,25 @@
+from pathlib import Path
+import pandas as pd
+
+
+def prepare(raw: Path, public: Path, private: Path):
+    """
+    Prepare playground-series-s3e1 dataset.
+    """
+    # Read data
+    train = pd.read_csv(raw / "train.csv")
+    test = pd.read_csv(raw / "test.csv")
+    sample_submission = pd.read_csv(raw / "sample_submission.csv")
+    test_answer = pd.read_csv(raw / "test_answer.csv")
+
+    # Public files (visible to agents)
+    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)
+
+    # Private files (for grading)
+    test_answer.to_csv(private / "test.csv", index=False)
+
+    # Validation checks
+    assert len(test_answer) == len(sample_submission), \
+        f"Test answer ({len(test_answer)}) and sample submission ({len(sample_submission)}) must have same length"

dslighting/registry/playground_series_s3e11/grade.py

@@ -0,0 +1,55 @@
+import numpy as np
+import pandas as pd
+from sklearn.metrics import mean_squared_log_error
+
+from mlebench.grade_helpers import InvalidSubmissionError
+
+
+def prepare_for_metric(submission: pd.DataFrame, answers: pd.DataFrame):
+    """Prepare submission and answers for RMSLE calculation."""
+    if len(submission) != len(answers):
+        raise InvalidSubmissionError(
+            f"Submission length ({len(submission)}) != answers length ({len(answers)})"
+        )
+
+    if "id" not in submission.columns:
+        raise InvalidSubmissionError("Submission must have an 'id' column")
+
+    if "cost" not in submission.columns:
+        raise InvalidSubmissionError("Submission must have a 'cost' column")
+
+    # Sort by id
+    submission = submission.sort_values("id").reset_index(drop=True)
+    answers = answers.sort_values("id").reset_index(drop=True)
+
+    # Check id alignment
+    if not (submission["id"] == answers["id"]).all():
+        raise InvalidSubmissionError("Submission and answers id mismatch")
+
+    # Extract predictions and true values
+    y_pred = submission["cost"].values
+    y_true = answers["cost"].values
+
+    # Validate predictions
+    try:
+        y_pred = y_pred.astype(float)
+    except (ValueError, TypeError):
+        raise InvalidSubmissionError("Predictions must be numeric")
+
+    if np.any(np.isnan(y_pred)):
+        raise InvalidSubmissionError("Predictions cannot contain NaN values")
+
+    if np.any(y_pred < 0):
+        raise InvalidSubmissionError("Predictions cannot be negative")
+
+    return y_true, y_pred
+
+
+def grade(submission: pd.DataFrame, answers: pd.DataFrame) -> float:
+    """Calculate RMSLE score."""
+    y_true, y_pred = prepare_for_metric(submission, answers)
+
+    # RMSLE
+    rmsle = np.sqrt(mean_squared_log_error(y_true, y_pred))
+
+    return rmsle

dslighting/registry/playground_series_s3e11/prepare.py

@@ -0,0 +1,25 @@
+from pathlib import Path
+import pandas as pd
+
+
+def prepare(raw: Path, public: Path, private: Path):
+    """
+    Prepare playground-series-s3e11 dataset.
+    """
+    # Read data
+    train = pd.read_csv(raw / "train.csv")
+    test = pd.read_csv(raw / "test.csv")
+    sample_submission = pd.read_csv(raw / "sample_submission.csv")
+    test_answer = pd.read_csv(raw / "test_answer.csv")
+
+    # Public files (visible to agents)
+    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)
+
+    # Private files (for grading)
+    test_answer.to_csv(private / "test.csv", index=False)
+
+    # Validation checks
+    assert len(test_answer) == len(sample_submission), \
+        f"Test answer ({len(test_answer)}) and sample submission ({len(sample_submission)}) must have same length"

dslighting/registry/predict-volcanic-eruptions-ingv-oe/checksums.yaml

@@ -0,0 +1,6 @@
+private:
+  test.csv: 1034df7a3f38ccd7bf9e5d6357db86f3
+public:
+  sample_submission.csv: 99631b72e1d2019b0b498f0dd6eec1cb
+  train.csv: b7c10ca530487fb7e3d1f1669a6e5059
+zip: eb45476258edbdbf2b57a30e77484904

dslighting/registry/predict-volcanic-eruptions-ingv-oe/config.yaml

@@ -0,0 +1,16 @@
+id: predict-volcanic-eruptions-ingv-oe
+name: INGV - Volcanic Eruption Prediction
+competition_type: simple
+awards_medals: false
+prizes: null
+description: mlebench/competitions/predict-volcanic-eruptions-ingv-oe/description.md
+
+dataset:
+  answers: predict-volcanic-eruptions-ingv-oe/prepared/private/test.csv
+  sample_submission: predict-volcanic-eruptions-ingv-oe/prepared/public/sample_submission.csv
+
+grader:
+  name: mean-absolute-error
+  grade_fn: mlebench.competitions.predict-volcanic-eruptions-ingv-oe.grade:grade
+
+preparer: mlebench.competitions.predict-volcanic-eruptions-ingv-oe.prepare:prepare

dslighting/registry/predict-volcanic-eruptions-ingv-oe/description.md

@@ -0,0 +1,70 @@
+# Overview
+
+## Description
+
+What if scientists could anticipate volcanic eruptions as they predict the weather? While determining rain or shine days in advance is more difficult, weather reports become more accurate on shorter time scales. A similar approach with volcanoes could make a big impact. Just one unforeseen eruption can result in tens of thousands of lives lost. If scientists could reliably predict when a volcano will next erupt, evacuations could be more timely and the damage mitigated.
+
+Currently, scientists often identify “time to eruption” by surveying volcanic tremors from seismic signals. In some volcanoes, this intensifies as volcanoes awaken and prepare to erupt. Unfortunately, patterns of seismicity are difficult to interpret. In very active volcanoes, current approaches predict eruptions some minutes in advance, but they usually fail at longer-term predictions.
+
+Enter Italy's Istituto Nazionale di Geofisica e Vulcanologia (INGV), with its focus on geophysics and volcanology. The INGV's main objective is to contribute to the understanding of the Earth's system while mitigating the associated risks. Tasked with the 24-hour monitoring of seismicity and active volcano activity across the country, the INGV seeks to find the earliest detectable precursors that provide information about the timing of future volcanic eruptions.
+
+In this competition, using your data science skills, you’ll predict when a volcano's next eruption will occur. You'll analyze a large geophysical dataset collected by sensors deployed on active volcanoes. If successful, your algorithms will identify signatures in seismic waveforms that characterize the development of an eruption.
+
+With enough notice, areas around a volcano can be safely evacuated prior to their destruction. Seismic activity is a good indicator of an impending eruption, but earlier precursors must be identified to improve longer-term predictability. The impact of your participation could be felt worldwide with tens of thousands of lives saved by more predictable volcanic ruptures and earlier evacuations.
+
+## Evaluation
+
+Submissions are evaluated on the [mean absolute error (MAE)](https://www.kaggle.com/wiki/MeanAbsoluteError) between the predicted loss and the actual loss.
+
+### Submission File
+
+For every id in the test set, you should predict the time until the next eruption. The file should contain a header and have the following format:
+
+```
+segment_id,time_to_eruption
+1,1
+2,2
+3,3
+etc.
+```
+
+## Timeline
+
+- Entry deadline: Same as the Final Submission Deadline
+- Team Merger deadline: Same as the Final Submission Deadline
+- **Final submission deadline: Jan 6, 2021**
+
+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** – Kaggle Swag Prize
+- **2nd Place** – Kaggle Swag Prize
+- **3rd Place** – Kaggle Swag Prize
+
+**Kaggle Swag Prizes** include the winner's choice of:
+
+- Kaggle t-shirt
+- Kaggle coffee mug
+- Kaggle water bottle
+
+## Citation
+
+Andrea Cannata, ConcettoSpampinato, Flavio Cannavo, IsaakKavasidis, Maggie, Sohier Dane. (2020). INGV - Volcanic Eruption Prediction. Kaggle. https://kaggle.com/competitions/predict-volcanic-eruptions-ingv-oe
+
+# Data
+
+## Dataset Description
+
+Detecting volcanic eruptions before they happen is an important problem that has historically proven to be a very difficult. This competition provides you with readings from several seismic sensors around a volcano and challenges you to estimate how long it will be until the next eruption. The data represent a classic signal processing setup that has resisted traditional methods.
+
+Identifying the exact sensors may be possible but would not be in the spirit of the competition nor further the scientific objectives. Please respect the importance of the problem and the time invested by the researchers at INGV in making this problem available by not seeking more metadata or information that would be unavailable in a real prediction context.
+
+### Files
+
+**train.csv** Metadata for the train files.
+
+- `segment_id`: ID code for the data segment. Matches the name of the associated data file.
+- `time_to_eruption`: The target value, the time until the next eruption.
+
+**[train|test]/*.csv**: the data files. Each file contains ten minutes of logs from ten different sensors arrayed around a volcano. The readings have been normalized within each segment, in part to ensure that the readings fall within the range of int16 values. If you are using the Pandas library you may find that you still need to load the data as float32 due to the presence of some nulls.

dslighting/registry/predict-volcanic-eruptions-ingv-oe/description_obfuscated.md

@@ -0,0 +1,33 @@
+# Overview
+
+Given readings from several seismic sensors around a volcano, estimate how long it will be until the next eruption.
+
+# Metric
+
+Mean absolute error (MAE) between the predicted loss and the actual loss.
+
+# Submission Format
+
+For every id in the test set, you should predict the time until the next eruption. The file should contain a header and have the following format:
+
+```
+segment_id,time_to_eruption
+1,1
+2,2
+3,3
+etc.
+```
+
+# Data
+
+## Dataset Description
+
+
+### Files
+
+**train.csv** Metadata for the train files.
+
+- `segment_id`: ID code for the data segment. Matches the name of the associated data file.
+- `time_to_eruption`: The target value, the time until the next eruption.
+
+**[train|test]/*.csv**: the data files. Each file contains ten minutes of logs from ten different sensors arrayed around a volcano. The readings have been normalized within each segment, in part to ensure that the readings fall within the range of int16 values. If you are using the Pandas library you may find that you still need to load the data as float32 due to the presence of some nulls.

dslighting/registry/predict-volcanic-eruptions-ingv-oe/grade.py

@@ -0,0 +1,44 @@
+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 'segment_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 "segment_id" in answers.columns, "Segment ID 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 submissions DataFrame."
+        )
+    if "segment_id" not in submission.columns:
+        raise InvalidSubmissionError("Segment ID column not found in submission DataFrame.")
+    if not set(submission["segment_id"]) == set(answers["segment_id"]):
+        raise InvalidSubmissionError(
+            f"Submission is missing the following segment_ids: {set(answers['segment_id']) - set(submission['segment_id'])}"
+        )
+
+    merged = answers.merge(
+        submission[["segment_id", target_column]], on="segment_id", suffixes=("_true", "_pred")
+    )
+    return merged
+
+
+def grade(submission: DataFrame, answers: DataFrame) -> float:
+    merged = prepare_for_grading(submission, answers, "time_to_eruption")
+    score = mean_absolute_error(
+        y_true=merged["time_to_eruption_true"], y_pred=merged["time_to_eruption_pred"]
+    )
+    rounded_score = int(round(score))
+    return rounded_score