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

dslighting/registry/statoil-iceberg-classifier-challenge/prepare.py

@@ -0,0 +1,105 @@
+import json
+import shutil
+from pathlib import Path
+
+import pandas as pd
+import py7zr
+from sklearn.model_selection import train_test_split
+
+from mlebench.utils import extract
+
+
+def prepare(raw: Path, public: Path, private: Path):
+    """
+    Splits the data in raw into public and private datasets with appropriate test/train splits.
+    """
+    extract(raw / "train.json.7z", raw)
+    extract(raw / "test.json.7z", raw)
+    old_train = json.load((raw / "data/processed/train.json").open())
+    old_test = json.load((raw / "data/processed/test.json").open())
+
+    all_fields = list([key for key in old_train[0].keys()])
+    assert all(
+        set(all_fields) == set([key for key in sample.keys()]) for sample in old_train
+    ), "Inconsistent fields in train set"
+    test_fields = list([key for key in old_test[0].keys()])
+    assert all(
+        set(test_fields) == set([key for key in sample.keys()]) for sample in old_test
+    ), "Inconsistent fields in test set"
+
+    # Old ratio is Train set - 1,604 samples; Test set - 8,424 samples (~84% ratio)
+    # We do a 20% ratio to avoid removing too many samples from train
+    new_train, new_test = train_test_split(old_train, test_size=0.2, random_state=0)
+    new_test_without_labels = []
+    for sample in new_test:
+        # Keep only the fields in the test set
+        sample = {key: sample[key] for key in test_fields}
+        new_test_without_labels.append(sample)
+
+    # Write new train and test splits, compress, then remove the uncompressed files
+    (private / "tmp_data").mkdir(exist_ok=True)
+    with open(private / "tmp_data" / "train.json", "w") as f:
+        json.dump(new_train, f)
+    with open(private / "tmp_data" / "test.json", "w") as f:
+        json.dump(new_test_without_labels, f)
+
+    with py7zr.SevenZipFile(public / "train.json.7z", "w") as archive:
+        archive.write(
+            private / "tmp_data" / "train.json",
+            arcname=(private / "tmp_data" / "train.json").relative_to(private / "tmp_data"),
+        )
+
+    with py7zr.SevenZipFile(public / "test.json.7z", "w") as archive:
+        archive.write(
+            private / "tmp_data" / "test.json",
+            arcname=(private / "tmp_data" / "test.json").relative_to(private / "tmp_data"),
+        )
+
+    # Make answers as csv from json
+    answer_rows = []
+    for sample in new_test:
+        answer_rows.append(
+            {
+                "id": sample["id"],
+                "is_iceberg": int(sample["is_iceberg"]),
+            }
+        )
+    answers = pd.DataFrame(answer_rows)
+    answers.to_csv(private / "test.csv", index=False)
+
+    # Make sample submission
+    sample_submission = answers.copy()
+    sample_submission["is_iceberg"] = 0.5
+    sample_submission.to_csv(private / "sample_submission.csv", index=False)
+    with py7zr.SevenZipFile(public / "sample_submission.csv.7z", "w") as archive:
+        archive.write(
+            private / "sample_submission.csv",
+            arcname=(private / "sample_submission.csv").relative_to(private),
+        )
+
+    # Remove uncompressed files
+    shutil.rmtree(private / "tmp_data")
+
+    # Checks
+    assert len(new_train) + len(new_test) == len(
+        old_train
+    ), f"Expected {len(old_train)} total samples in new_train ({len(new_train)}) and new_test ({len(new_test)})"
+    assert len(new_test) == len(
+        new_test_without_labels
+    ), f"Expected new_test ({len(new_test)}) to have the same length as new_test_without_labels ({len(new_test_without_labels)})"
+    assert len(answers) == len(
+        new_test
+    ), f"Expected answers ({len(answers)}) to have the same length as new_test ({len(new_test)})"
+    assert len(sample_submission) == len(
+        new_test
+    ), f"Expected sample_submission ({len(sample_submission)}) to have the same length as new_test ({len(new_test)})"
+    assert set(answers.columns) == set(
+        ["id", "is_iceberg"]
+    ), "Answers must have 'id' and 'is_iceberg' columns"
+    assert set(sample_submission.columns) == set(
+        ["id", "is_iceberg"]
+    ), "Sample submission must have 'id' and 'is_iceberg' columns"
+
+    new_train_ids = set([sample["id"] for sample in new_train])
+    new_test_ids = set([sample["id"] for sample in new_test])
+    assert new_train_ids.isdisjoint(new_test_ids), "Train and test ids should not overlap"

dslighting/registry/statoil-iceberg-classifier-challenge/prepare_val.py

@@ -0,0 +1,157 @@
+import json
+import shutil
+from pathlib import Path
+from typing import List, Dict
+
+import pandas as pd
+import py7zr
+from sklearn.model_selection import train_test_split
+
+from mlebench.utils import extract
+
+
+def _create_split_files(
+    train_set: List[Dict],
+    test_set: List[Dict],
+    test_fields: List[str],
+    public_dir: Path,
+    private_dir: Path,
+):
+    """
+    Helper function to generate all files for a given train/test split.
+
+    This function creates:
+    - public/{train.json.7z, test.json.7z, sample_submission.csv.7z}
+    - private/{test.csv, sample_submission.csv}
+    """
+    # Ensure output directories exist
+    public_dir.mkdir(exist_ok=True, parents=True)
+    private_dir.mkdir(exist_ok=True, parents=True)
+
+    # Create test set without labels
+    test_set_without_labels = []
+    for sample in test_set:
+        sample_copy = {key: sample[key] for key in test_fields}
+        test_set_without_labels.append(sample_copy)
+
+    # Write new train and test splits to a temporary directory
+    tmp_data_dir = private_dir / "tmp_data"
+    tmp_data_dir.mkdir(exist_ok=True)
+    try:
+        with open(tmp_data_dir / "train.json", "w") as f:
+            json.dump(train_set, f)
+        with open(tmp_data_dir / "test.json", "w") as f:
+            json.dump(test_set_without_labels, f)
+
+        # Compress the JSON files into the public directory
+        with py7zr.SevenZipFile(public_dir / "train.json.7z", "w") as archive:
+            archive.write(
+                tmp_data_dir / "train.json",
+                arcname="train.json",
+            )
+        with py7zr.SevenZipFile(public_dir / "test.json.7z", "w") as archive:
+            archive.write(
+                tmp_data_dir / "test.json",
+                arcname="test.json",
+            )
+
+        # Make answers as csv from the labeled test set
+        answer_rows = [
+            {"id": sample["id"], "is_iceberg": int(sample["is_iceberg"])}
+            for sample in test_set
+        ]
+        answers = pd.DataFrame(answer_rows)
+        answers.to_csv(private_dir / "test.csv", index=False)
+
+        # Make a sample submission file
+        sample_submission = answers.copy()
+        sample_submission["is_iceberg"] = 0.5
+        sample_submission.to_csv(private_dir / "sample_submission.csv", index=False)
+        with py7zr.SevenZipFile(public_dir / "sample_submission.csv.7z", "w") as archive:
+            archive.write(
+                private_dir / "sample_submission.csv",
+                arcname="sample_submission.csv",
+            )
+    finally:
+        # Ensure temporary files are removed
+        shutil.rmtree(tmp_data_dir)
+
+    # --- Final checks for this split ---
+    assert len(test_set) == len(
+        test_set_without_labels
+    ), f"Expected test_set ({len(test_set)}) to have the same length as test_set_without_labels ({len(test_set_without_labels)})"
+    assert len(answers) == len(
+        test_set
+    ), f"Expected answers ({len(answers)}) to have the same length as test_set ({len(test_set)})"
+    assert len(sample_submission) == len(
+        test_set
+    ), f"Expected sample_submission ({len(sample_submission)}) to have the same length as test_set ({len(test_set)})"
+    assert set(answers.columns) == set(
+        ["id", "is_iceberg"]
+    ), "Answers must have 'id' and 'is_iceberg' columns"
+    assert set(sample_submission.columns) == set(
+        ["id", "is_iceberg"]
+    ), "Sample submission must have 'id' and 'is_iceberg' columns"
+    train_ids = set([sample["id"] for sample in train_set])
+    test_ids = set([sample["id"] for sample in test_set])
+    assert train_ids.isdisjoint(test_ids), "Train and test ids should not overlap"
+
+
+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 (public_val, private_val) for model development.
+    """
+    extract(raw / "train.json.7z", raw)
+    extract(raw / "test.json.7z", raw)
+    old_train = json.load((raw / "data/processed/train.json").open())
+    old_test = json.load((raw / "data/processed/test.json").open())
+
+    all_fields = list([key for key in old_train[0].keys()])
+    assert all(
+        set(all_fields) == set([key for key in sample.keys()]) for sample in old_train
+    ), "Inconsistent fields in train set"
+    test_fields = list([key for key in old_test[0].keys()])
+    assert all(
+        set(test_fields) == set([key for key in sample.keys()]) for sample in old_test
+    ), "Inconsistent fields in test set"
+
+    # --- First Split: Create the main train/test sets for the competition ---
+    # Old ratio is Train set - 1,604 samples; Test set - 8,424 samples (~84% ratio)
+    # We do a 20% ratio to avoid removing too many samples from train
+    new_train, new_test = train_test_split(old_train, test_size=0.2, random_state=0)
+
+    # Generate the original public and private directory files
+    _create_split_files(
+        train_set=new_train,
+        test_set=new_test,
+        test_fields=test_fields,
+        public_dir=public,
+        private_dir=private,
+    )
+
+    # Check that the total number of samples is conserved in the first split
+    assert len(new_train) + len(new_test) == len(
+        old_train
+    ), f"Expected {len(old_train)} total samples in new_train ({len(new_train)}) and new_test ({len(new_test)})"
+
+    # --- Second Split: Create a validation set from the main training set ---
+    # Define paths for the new validation split
+    public_val = public.parent / "public_val"
+    private_val = private.parent / "private_val"
+
+    # The goal is for the new validation set (test_val) to have the same size as the original test set (new_test).
+    # test_size = len(new_test) / len(new_train) = (0.2 * N) / (0.8 * N) = 0.25
+    test_size_for_val_split = len(new_test) / len(new_train)
+    train_val, test_val = train_test_split(
+        new_train, test_size=test_size_for_val_split, random_state=0
+    )
+
+    # Generate the validation public_val and private_val directory files
+    _create_split_files(
+        train_set=train_val,
+        test_set=test_val,
+        test_fields=test_fields,
+        public_dir=public_val,
+        private_dir=private_val,
+    )

dslighting/registry/tabular-playground-series-dec-2021/checksums.yaml

@@ -0,0 +1,7 @@
+private:
+  test.csv: 0819faab160bc678ff4e04b799caf748
+public:
+  sample_submission.csv: d7b1e1f35677df7cce6942a8c053633f
+  test.csv: 3427fd7ec4244230795e37dac986916a
+  train.csv: f5b8080079184e0eb10ef7b6b2f1fec7
+zip: c7f38370ee2609e5602814a55cb26555

dslighting/registry/tabular-playground-series-dec-2021/config.yaml

@@ -0,0 +1,16 @@
+id: tabular-playground-series-dec-2021
+name: Tabular Playground Series - Dec 2021
+competition_type: simple
+awards_medals: false
+prizes: null
+description: mlebench/competitions/tabular-playground-series-dec-2021/description.md
+
+dataset:
+  answers: tabular-playground-series-dec-2021/prepared/private/test.csv
+  sample_submission: tabular-playground-series-dec-2021/prepared/public/sample_submission.csv
+
+grader:
+  name: multi-class-classification-accuracy
+  grade_fn: mlebench.competitions.tabular-playground-series-dec-2021.grade:grade
+
+preparer: mlebench.competitions.tabular-playground-series-dec-2021.prepare:prepare

dslighting/registry/tabular-playground-series-dec-2021/description.md

@@ -0,0 +1,59 @@
+# Overview
+Start
+
+Dec 1, 2021
+Close
+Dec 31, 2021
+## Description
+Kaggle competitions are incredibly fun and rewarding, but they can also be intimidating for people who are relatively new in their data science journey. In the past, we've launched many Playground competitions that are more approachable than our Featured competitions and thus, more beginner-friendly.
+
+In order to have a more consistent offering of these competitions for our community, we're trying a new experiment in 2021. We'll be launching month-long tabular Playground competitions on the 1st of every month and continue the experiment as long as there's sufficient interest and participation.
+
+The goal of these competitions is to provide a fun, and approachable for anyone, tabular dataset. These competitions will be great for people looking for something in between the Titanic Getting Started competition and a Featured competition. If you're an established competitions master or grandmaster, these probably won't be much of a challenge for you. We encourage you to avoid saturating the leaderboard.
+
+For each monthly competition, we'll be offering Kaggle Merchandise for the top three teams. And finally, because we want these competitions to be more about learning, we're limiting team sizes to 3 individuals.
+
+The dataset is used for this competition is synthetic, but based on a real dataset and generated using a [CTGAN](https://github.com/sdv-dev/CTGAN). This dataset is based off of the original [Forest Cover Type Prediction](https://www.kaggle.com/c/forest-cover-type-prediction/overview) competition.
+
+Good luck and have fun!
+
+For ideas on how to improve your score, check out the [Intro to Machine Learning](https://www.kaggle.com/learn/intro-to-machine-learning) and [Intermediate Machine Learning](https://www.kaggle.com/learn/intermediate-machine-learning) courses on Kaggle Learn.
+
+## Evaluation
+Submissions are evaluated on multi-class classification accuracy.
+
+## Submission File
+For each `Id` in the test set, you must predict the `Cover_Type` class. The file should contain a header and have the following format:
+```
+Id,Cover_Type
+4000000,2
+4000001,1
+4000001,3
+etc.
+```
+## Timeline
+- Start Date - December 1, 2021
+- Entry deadline - Same as the Final Submission Deadline
+- Team Merger deadline - Same as the Final Submission Deadline
+- Final submission deadline - December 31, 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 - 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. (2021). Tabular Playground Series - Dec 2021. Kaggle. https://kaggle.com/competitions/tabular-playground-series-dec-2021
+
+# Dataset Description
+For this competition, you will be predicting a categorical target based on a number of feature columns given in the data.
+The data is synthetically generated by a GAN that was trained on a the data from the [Forest Cover Type Prediction](https://www.kaggle.com/c/forest-cover-type-prediction/overview). This dataset is (a) much larger, and (b) may or may not have the same relationship to the target as the original data.
+
+Please refer to this [data page](https://www.kaggle.com/c/forest-cover-type-prediction/data) for a detailed explanation of the features.
+
+## Files
+- train.csv - the training data with the target `Cover_Type` column
+- test.csv - the test set; you will be predicting the `Cover_Type` for each row in this file (the target integer class)
+- sample_submission.csv - a sample submission file in the correct format

dslighting/registry/tabular-playground-series-dec-2021/description_obfuscated.md

@@ -0,0 +1,22 @@
+# Task
+
+Predict the class of a given image from a synthetic dataset.
+
+# Metric
+Multi-class classification accuracy.
+
+# Submission Format
+For each `Id` in the test set, you must predict the `Cover_Type` class. The file should contain a header and have the following format:
+```
+Id,Cover_Type
+4000000,2
+4000001,1
+4000001,3
+etc.
+```
+
+# Dataset 
+
+- train.csv - the training data with the target `Cover_Type` column
+- test.csv - the test set; you will be predicting the `Cover_Type` for each row in this file (the target integer class)
+- sample_submission.csv - a sample submission file in the correct format

dslighting/registry/tabular-playground-series-dec-2021/grade.py

@@ -0,0 +1,11 @@
+import pandas as pd
+from sklearn.metrics import accuracy_score
+
+from mlebench.competitions.utils import prepare_for_accuracy_metric
+
+
+def grade(submission: pd.DataFrame, answers: pd.DataFrame) -> float:
+    accuracy_inputs = prepare_for_accuracy_metric(
+        submission=submission, answers=answers, target_column="Cover_Type", id_column="Id"
+    )
+    return accuracy_score(**accuracy_inputs)

dslighting/registry/tabular-playground-series-dec-2021/prepare.py

@@ -0,0 +1,39 @@
+from pathlib import Path
+
+import pandas as pd
+from sklearn.model_selection import train_test_split
+
+from mlebench.utils import read_csv
+
+
+def prepare(raw: Path, public: Path, private: Path):
+    """
+    Splits the data in raw into public and private datasets with appropriate test/train splits.
+    """
+    # Create train, test from train split
+    old_train = read_csv(raw / "train.csv")
+    new_train, new_test = train_test_split(old_train, test_size=0.1, random_state=0)
+    new_test_without_labels = new_test.drop(columns=["Cover_Type"])
+
+    new_train.to_csv(public / "train.csv", index=False)
+    new_test.to_csv(private / "test.csv", index=False)
+    new_test_without_labels.to_csv(public / "test.csv", index=False)
+
+    # Create a sample submission file
+    submission_df = pd.DataFrame(
+        {
+            "Id": new_test["Id"].values,
+            "Cover_Type": 2,
+        }
+    )
+    submission_df.to_csv(public / "sample_submission.csv", index=False)
+
+    assert len(new_train) + len(new_test) == len(
+        old_train
+    ), "train and test splits lengths do not add up to original data."
+    assert set(new_train["Id"]).isdisjoint(
+        set(new_test["Id"])
+    ), f"there are Ids in both train and test sets: {set(new_train['Id']).intersection(set(new_test['Id']))}"
+    assert len(new_test_without_labels) == len(
+        new_test
+    ), "public and Private tests should have equal length"

dslighting/registry/tabular-playground-series-dec-2021/prepare_val.py

@@ -0,0 +1,99 @@
+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(
+    df: pd.DataFrame,
+    test_size: float,
+    public_path: Path,
+    private_path: Path,
+    random_state: int,
+):
+    """
+    Helper function to perform a data split, save files, and run assertions.
+
+    Args:
+        df (pd.DataFrame): The dataframe to split.
+        test_size (float): The proportion of the dataset to allocate to the test split.
+        public_path (Path): The directory for public-facing files (train set, unlabeled test set).
+        private_path (Path): The directory for private-facing files (labeled test set).
+        random_state (int): The seed for the random number generator.
+
+    Returns:
+        Tuple[pd.DataFrame, pd.DataFrame]: The resulting train and test dataframes.
+    """
+    # Ensure output directories exist
+    public_path.mkdir(parents=True, exist_ok=True)
+    private_path.mkdir(parents=True, exist_ok=True)
+
+    # Perform the split
+    train_df, test_df = train_test_split(
+        df, test_size=test_size, random_state=random_state
+    )
+    test_df_without_labels = test_df.drop(columns=["Cover_Type"])
+
+    # Save the split data using standard filenames
+    train_df.to_csv(public_path / "train.csv", index=False)
+    test_df.to_csv(private_path / "test.csv", index=False)
+    test_df_without_labels.to_csv(public_path / "test.csv", index=False)
+
+    # Create a sample submission file
+    submission_df = pd.DataFrame(
+        {"Id": test_df["Id"].values, "Cover_Type": 2}
+    )
+    submission_df.to_csv(public_path / "sample_submission.csv", index=False)
+
+    # Assertions
+    assert len(train_df) + len(test_df) == len(
+        df
+    ), "train and test splits lengths do not add up to original data."
+    assert set(train_df["Id"]).isdisjoint(
+        set(test_df["Id"])
+    ), f"there are Ids in both train and test sets: {set(train_df['Id']).intersection(set(test_df['Id']))}"
+    assert len(test_df_without_labels) == len(
+        test_df
+    ), "public and Private tests should have equal length"
+
+    return train_df, test_df
+
+
+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.
+    """
+    # Create train, test from train split
+    old_train = read_csv(raw / "train.csv")
+
+    # --- First Split: Create the original train and test sets ---
+    # This call produces the original outputs, which must remain unchanged.
+    new_train, new_test = _split_and_save(
+        df=old_train,
+        test_size=0.1,
+        public_path=public,
+        private_path=private,
+        random_state=0,
+    )
+
+    # --- Second Split: Create a new train and validation set ---
+    # Define paths for the new validation set outputs
+    public_val = public.parent / "public_val"
+    private_val = private.parent / "private_val"
+
+    # Calculate the test size for the second split to make the new validation
+    # set (`test_val`) have the same number of samples as the original test set.
+    test_val_size = len(new_test) / len(new_train)
+
+    # This call takes the `new_train` data and splits it again, saving the
+    # results to the new `_val` directories with identical structure and filenames.
+    _split_and_save(
+        df=new_train,
+        test_size=test_val_size,
+        public_path=public_val,
+        private_path=private_val,
+        random_state=0,  # Use the same random state for consistency
+    )

dslighting/registry/tabular-playground-series-may-2022/checksums.yaml

@@ -0,0 +1,8 @@
+private:
+  gold_submission.csv: fd2e8a542de49e4f4b46ea1a174db71a
+  test.csv: 0ad7146d50d6a3043b98e9471835db59
+public:
+  sample_submission.csv: 353457517aa847e701141e00a7a774eb
+  test.csv: a15b39583b2c38e02f986251d0292851
+  train.csv: 40ef2671fc5bde862789ff7cfcc48c20
+zip: 2cad1cd0e611cc4e7a1e780e81d3e2ea

dslighting/registry/tabular-playground-series-may-2022/config.yaml

@@ -0,0 +1,17 @@
+id: tabular-playground-series-may-2022
+name: Tabular Playground Series - May 2022
+competition_type: simple
+awards_medals: false
+prizes: null
+description: mlebench/competitions/tabular-playground-series-may-2022/description.md
+
+dataset:
+  answers: tabular-playground-series-may-2022/prepared/private/test.csv
+  gold_submission: tabular-playground-series-may-2022/prepared/private/gold_submission.csv
+  sample_submission: tabular-playground-series-may-2022/prepared/public/sample_submission.csv
+
+grader:
+  name: auc-roc
+  grade_fn: mlebench.competitions.tabular-playground-series-may-2022.grade:grade
+
+preparer: mlebench.competitions.tabular-playground-series-may-2022.prepare:prepare

dslighting/registry/tabular-playground-series-may-2022/description.md

@@ -0,0 +1,79 @@
+# Overview
+
+## Overview
+
+### Description
+
+The May edition of the 2022 Tabular Playground series binary classification problem that includes a number of different feature interactions. This competition is an opportunity to explore various methods for identifying and exploiting these feature interactions.
+
+![clarisse-croset--tikpxRBcsA-unsplash](https://storage.googleapis.com/kaggle-media/competitions/Tabular%20Playground/clarisse-croset--tikpxRBcsA-unsplash.jpg)
+
+#### About the Tabular Playground Series
+
+Kaggle competitions are incredibly fun and rewarding, but they can also be intimidating for people who are relatively new in their data science journey. In the past, we've launched many Playground competitions that are more approachable than our Featured competitions and thus, more beginner-friendly.
+
+The goal of these competitions is to provide a fun and approachable-for-anyone tabular dataset to model. These competitions are a great choice for people looking for something in between the Titanic Getting Started competition and the Featured competitions. If you're an established competitions master or grandmaster, these probably won't be much of a challenge for you; thus, we encourage you to avoid saturating the leaderboard.
+
+For each monthly competition, we'll be offering Kaggle Merchandise for the top three teams. And finally, because we want these competitions to be more about learning, we're limiting team sizes to 3 individuals.
+
+#### Getting Started
+
+For ideas on how to improve your score, check out the [Intro to Machine Learning](https://www.kaggle.com/learn/intro-to-machine-learning) and [Intermediate Machine Learning](https://www.kaggle.com/learn/intermediate-machine-learning) courses on Kaggle Learn.
+
+We've also built a [starter notebook](https://www.kaggle.com/code/paultimothymooney/getting-started-with-tensorflow-decision-forests) for you that uses TensorFlow Decision Forests, a TensorFlow library that matches the power of XGBoost with a friendly, straightforward user interface.
+
+*Good luck and have fun!*
+
+#### Acknowledgments
+
+Photo by [Clarisse Croset](https://unsplash.com/@herfrenchness?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText) on [Unsplash.](https://unsplash.com/s/photos/feature-interactions-machine-learning?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText)
+
+### Evaluation
+
+Submissions are evaluated on [area under the ROC curve](http://en.wikipedia.org/wiki/Receiver_operating_characteristic) between the predicted probability and the observed target.
+
+#### Submission File
+
+For each `id` in the test set, you must predict a probability for the `target` variable. The file should contain a header and have the following format:
+
+```
+id,target
+900000,0.65
+900001,0.97
+900002,0.02
+etc.
+```
+
+### Timeline
+
+- Start Date - May 1, 2022
+- Entry deadline - Same as the Final Submission Deadline
+- Team Merger deadline - Same as the Final Submission Deadline
+- Final submission deadline - May 31, 2022
+
+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. (2022). Tabular Playground Series - May 2022. Kaggle. https://kaggle.com/competitions/tabular-playground-series-may-2022
+
+# Data
+
+## Dataset Description
+
+For this challenge, you are given (simulated) manufacturing control data and are tasked to predict whether the machine is in state `0` or state `1`. The data has various feature interactions that may be important in determining the machine state.
+
+Good luck!
+
+### Files
+- **train.csv** - the training data, which includes normalized continuous data and categorical data
+- **test.csv** - the test set; your task is to predict binary `target` variable which represents the state of a manufacturing process
+- **sample_submission.csv** - a sample submission file in the correct format

dslighting/registry/tabular-playground-series-may-2022/description_obfuscated.md

@@ -0,0 +1,25 @@
+# Task
+
+Given simulated manufacturing control data, predict whether the machine is in state `0` or state `1`.
+
+# Metric
+
+Area under the ROC curve.
+
+# Submission Format
+
+For each `id` in the test set, you must predict a probability for the `target` variable. The file should contain a header and have the following format:
+
+```
+id,target
+900000,0.65
+900001,0.97
+900002,0.02
+etc.
+```
+
+# Dataset
+
+- **train.csv** - the training data, which includes normalized continuous data and categorical data
+- **test.csv** - the test set; your task is to predict binary `target` variable which represents the state of a manufacturing process
+- **sample_submission.csv** - a sample submission file in the correct format

dslighting/registry/tabular-playground-series-may-2022/grade.py

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