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

dslighting/registry/smartphone-decimeter-2022/grade.py

@@ -0,0 +1,55 @@
+import numpy as np
+from pandas import DataFrame
+
+from mlebench.grade_helpers import InvalidSubmissionError
+
+from .notebook import calc_score as get_score
+
+
+def grade(submission: DataFrame, answers: DataFrame) -> float:
+    assert "tripId" in answers.columns, "Answers DataFrame must have a 'tripId' column."
+    assert (
+        "UnixTimeMillis" in answers.columns
+    ), "Answers DataFrame must have a 'UnixTimeMillis' column."
+    assert (
+        "LatitudeDegrees" in answers.columns
+    ), "Answers DataFrame must have a 'LatitudeDegrees' column."
+    assert (
+        "LongitudeDegrees" in answers.columns
+    ), "Answers DataFrame must have a 'LongitudeDegrees' column."
+
+    if "tripId" not in submission.columns:
+        raise InvalidSubmissionError("Submission DataFrame must have a 'tripId' column.")
+
+    if "UnixTimeMillis" not in submission.columns:
+        raise InvalidSubmissionError("Submission DataFrame must have a 'UnixTimeMillis' column.")
+
+    if "LatitudeDegrees" not in submission.columns:
+        raise InvalidSubmissionError("Submission DataFrame must have a 'LatitudeDegrees' column.")
+
+    if "LongitudeDegrees" not in submission.columns:
+        raise InvalidSubmissionError("Submission DataFrame must have a 'LongitudeDegrees' column.")
+
+    if len(submission) != len(answers):
+        raise InvalidSubmissionError(
+            "Submission and answers DataFrames must have the same number of rows."
+        )
+
+    scores = []
+    trip_ids = answers["tripId"].unique()
+
+    for trip_id in trip_ids:
+        filtered_answers = answers[answers["tripId"] == trip_id]
+        filtered_submission = submission[submission["tripId"] == trip_id]
+
+        if len(filtered_submission) != len(filtered_answers):
+            raise InvalidSubmissionError(
+                "Submission and answers DataFrames must have the same number of rows for each 'tripId'."
+                f"Got {len(filtered_submission)} rows in the submission and {len(filtered_answers)} rows "
+                f"in the answers for tripId {trip_id}."
+            )
+
+        score = get_score(filtered_submission, filtered_answers)
+        scores.append(score)
+
+    return np.mean(scores)

dslighting/registry/smartphone-decimeter-2022/notebook.py

@@ -0,0 +1,86 @@
+"""
+Helper functions from the Kaggle notebook `GSDC2 - baseline submission`.
+Adapted from https://www.kaggle.com/code/saitodevel01/gsdc2-baseline-submission.
+"""
+
+from dataclasses import dataclass
+
+import numpy as np
+
+WGS84_SEMI_MAJOR_AXIS = 6378137.0
+WGS84_SEMI_MINOR_AXIS = 6356752.314245
+WGS84_SQUARED_FIRST_ECCENTRICITY = 6.69437999013e-3
+WGS84_SQUARED_SECOND_ECCENTRICITY = 6.73949674226e-3
+
+HAVERSINE_RADIUS = 6_371_000
+
+
+@dataclass
+class ECEF:
+    x: np.array
+    y: np.array
+    z: np.array
+
+    def to_numpy(self):
+        return np.stack([self.x, self.y, self.z], axis=0)
+
+    @staticmethod
+    def from_numpy(pos):
+        x, y, z = [np.squeeze(w) for w in np.split(pos, 3, axis=-1)]
+        return ECEF(x=x, y=y, z=z)
+
+
+@dataclass
+class BLH:
+    lat: np.array
+    lng: np.array
+    hgt: np.array
+
+
+def ECEF_to_BLH(ecef):
+    a = WGS84_SEMI_MAJOR_AXIS
+    b = WGS84_SEMI_MINOR_AXIS
+    e2 = WGS84_SQUARED_FIRST_ECCENTRICITY
+    e2_ = WGS84_SQUARED_SECOND_ECCENTRICITY
+    x = ecef.x
+    y = ecef.y
+    z = ecef.z
+    r = np.sqrt(x**2 + y**2)
+    t = np.arctan2(z * (a / b), r)
+    B = np.arctan2(z + (e2_ * b) * np.sin(t) ** 3, r - (e2 * a) * np.cos(t) ** 3)
+    L = np.arctan2(y, x)
+    n = a / np.sqrt(1 - e2 * np.sin(B) ** 2)
+    H = (r / np.cos(B)) - n
+
+    return BLH(lat=B, lng=L, hgt=H)
+
+
+def haversine_distance(blh_1, blh_2):
+    dlat = blh_2.lat - blh_1.lat
+    dlng = blh_2.lng - blh_1.lng
+    a = np.sin(dlat / 2) ** 2 + np.cos(blh_1.lat) * np.cos(blh_2.lat) * np.sin(dlng / 2) ** 2
+    dist = 2 * HAVERSINE_RADIUS * np.arcsin(np.sqrt(a))
+
+    return dist
+
+
+def pandas_haversine_distance(df1, df2):
+    blh1 = BLH(
+        lat=np.deg2rad(df1["LatitudeDegrees"].to_numpy()),
+        lng=np.deg2rad(df1["LongitudeDegrees"].to_numpy()),
+        hgt=0,
+    )
+
+    blh2 = BLH(
+        lat=np.deg2rad(df2["LatitudeDegrees"].to_numpy()),
+        lng=np.deg2rad(df2["LongitudeDegrees"].to_numpy()),
+        hgt=0,
+    )
+
+    return haversine_distance(blh1, blh2)
+
+
+def calc_score(pred_df, gt_df):
+    d = pandas_haversine_distance(pred_df, gt_df)
+    score = np.mean([np.quantile(d, 0.50), np.quantile(d, 0.95)])
+    return score

dslighting/registry/smartphone-decimeter-2022/prepare.py

@@ -0,0 +1,143 @@
+import shutil
+from pathlib import Path
+
+import pandas as pd
+from sklearn.model_selection import train_test_split
+
+
+def get_date(s: str) -> str:
+    """Gets date from string in the format YYYY-MM-DD-X where `X` is an arbitrary string."""
+
+    split = s.split("-")
+
+    assert (
+        len(split) >= 3
+    ), f"Expected the string to have at least 3 parts separated by `-`. Got {len(split)} parts."
+
+    year, month, day = split[:3]
+
+    assert (
+        isinstance(year, str) and year.isdigit()
+    ), f"Expected the year to be a string of digits. Got {year} instead."
+
+    assert (
+        isinstance(month, str) and month.isdigit()
+    ), f"Expected the month to be a string of digits. Got {month} instead."
+
+    assert (
+        isinstance(day, str) and day.isdigit()
+    ), f"Expected the day to be a string of digits. Got {day} instead."
+
+    date = f"{year}-{month.zfill(2)}-{day.zfill(2)}"
+
+    return date
+
+
+def prepare(raw: Path, public: Path, private: Path) -> None:
+    old_train_ids = sorted([folder.name for folder in (raw / "train").glob("*") if folder.is_dir()])
+    dates = sorted(set([get_date(s) for s in old_train_ids]))
+    new_train_dates, new_test_dates = train_test_split(dates, test_size=0.1, random_state=0)
+
+    assert (
+        len(new_train_dates) >= 1
+    ), "Expected the new train set to have at least one date. Got 0 dates."
+
+    assert (
+        len(new_test_dates) >= 1
+    ), "Expected the new test set to have at least one date. Got 0 dates."
+
+    new_train_ids = sorted([i for i in old_train_ids if get_date(i) in new_train_dates])
+    new_test_ids = sorted([i for i in old_train_ids if get_date(i) in new_test_dates])
+
+    assert len(set(new_train_ids).intersection(set(new_test_ids))) == 0, (
+        f"Expected the new train and test instances to be disjoint. Got an intersection of "
+        f"{set(new_train_ids).intersection(set(new_test_ids))}."
+    )
+
+    assert len(new_train_ids) + len(new_test_ids) == len(old_train_ids), (
+        f"Expected the number of new train and test instances to sum up to the number of old train "
+        f"instances. Got {len(new_train_ids)} new train instances and {len(new_test_ids)} new test "
+        f"instances which sum to {len(new_train_ids) + len(new_test_ids)} instead of "
+        f"{len(old_train_ids)}."
+    )
+
+    assert set(new_train_ids).intersection(new_test_ids) == set(), (
+        f"Expected the new train and test instances to be disjoint. Got an intersection of "
+        f"{set(new_train_ids).intersection(new_test_ids)}."
+    )
+
+    for new_train_id in new_train_ids:
+        shutil.copytree(
+            src=raw / "train" / new_train_id,
+            dst=public / "train" / new_train_id,
+        )
+
+    for new_test_id in new_test_ids:
+        shutil.copytree(
+            src=raw / "train" / new_test_id,
+            dst=public / "test" / new_test_id,
+        )
+
+    # Construct test set by concatenating all ground truth csvs for the test journeys
+    dfs = []
+
+    for fpath in sorted((public / "test").rglob("ground_truth.csv")):
+        drive_id = fpath.parent.parent.name
+        phone_id = fpath.parent.name
+
+        assert (
+            drive_id in new_test_ids
+        ), f"Expected the drive {drive_id} to be one of the new test instances. Got {drive_id} instead."
+
+        raw_df = pd.read_csv(fpath)
+        df = raw_df.copy()
+        df.loc[:, "tripId"] = f"{drive_id}-{phone_id}"
+        df = df[["tripId", "UnixTimeMillis", "LatitudeDegrees", "LongitudeDegrees"]]
+        dfs.append(df)
+
+    new_test = pd.concat(dfs, ignore_index=True)
+    new_test.to_csv(private / "test.csv", index=False)
+
+    for fpath in (public / "test").rglob("ground_truth.csv"):
+        fpath.unlink()  # don't include ground truth in public test data
+
+    shutil.copytree(
+        src=raw / "metadata",
+        dst=public / "metadata",
+    )
+
+    actual_journey_ids = set(["-".join(s.split("-")[:-1]) for s in new_test["tripId"]])
+
+    assert len(actual_journey_ids) == len(new_test_ids), (
+        f"Expected the new test instances to have {len(new_test_ids)} unique trip IDs. Got "
+        f"{len(new_test['tripId'].unique())} unique trip IDs."
+    )
+
+    sample_submission = new_test.copy()
+    sample_submission.loc[:, "LatitudeDegrees"] = 37.904611315634504
+    sample_submission.loc[:, "LongitudeDegrees"] = -86.48107806249548
+
+    assert len(sample_submission) == len(new_test), (
+        f"Expected the sample submission to have the same number of instances as the new test "
+        f"instances. Got {len(sample_submission)} instances in the sample submission and "
+        f"{len(new_test)} new test instances."
+    )
+
+    sample_submission.to_csv(public / "sample_submission.csv", index=False)
+
+    assert sorted(list(public.glob("train/*"))) == sorted(
+        set([public / "train" / drive_id for drive_id in new_train_ids])
+    ), "Expected the public train directory to contain the new train instances."
+
+    assert sorted(list(public.glob("test/*"))) == sorted(
+        set([public / "test" / drive_id for drive_id in new_test_ids])
+    ), "Expected the public test directory to contain the new test instances."
+
+    assert (
+        len(list((public / "test").rglob("ground_truth.csv"))) == 0
+    ), "Expected the public test directory to not contain any ground truth files."
+
+    assert len(list((public / "train").rglob("ground_truth.csv"))) >= len(new_train_ids), (
+        "Expected the public train directory to contain at least one ground truth file per new "
+        "train instance."
+    )

dslighting/registry/smartphone-decimeter-2022/prepare_val.py

@@ -0,0 +1,199 @@
+import shutil
+from pathlib import Path
+
+import pandas as pd
+from sklearn.model_selection import train_test_split
+
+
+def get_date(s: str) -> str:
+    """Gets date from string in the format YYYY-MM-DD-X where `X` is an arbitrary string."""
+
+    split = s.split("-")
+
+    assert (
+        len(split) >= 3
+    ), f"Expected the string to have at least 3 parts separated by `-`. Got {len(split)} parts."
+
+    year, month, day = split[:3]
+
+    assert (
+        isinstance(year, str) and year.isdigit()
+    ), f"Expected the year to be a string of digits. Got {year} instead."
+
+    assert (
+        isinstance(month, str) and month.isdigit()
+    ), f"Expected the month to be a string of digits. Got {month} instead."
+
+    assert (
+        isinstance(day, str) and day.isdigit()
+    ), f"Expected the day to be a string of digits. Got {day} instead."
+
+    date = f"{year}-{month.zfill(2)}-{day.zfill(2)}"
+
+    return date
+
+
+def _process_split(
+    raw_data_path: Path,
+    train_ids: list,
+    test_ids: list,
+    public_path: Path,
+    private_path: Path,
+) -> None:
+    """
+    Helper function to process a single data split.
+
+    It populates the public and private directories with the provided train/test IDs,
+    creating the necessary file structure and artifacts (like the sample submission).
+    """
+    # Clean and create output directories
+    shutil.rmtree(public_path, ignore_errors=True)
+    shutil.rmtree(private_path, ignore_errors=True)
+    public_path.mkdir(parents=True)
+    private_path.mkdir(parents=True)
+    (public_path / "train").mkdir()
+    (public_path / "test").mkdir()
+
+    for train_id in train_ids:
+        shutil.copytree(
+            src=raw_data_path / "train" / train_id,
+            dst=public_path / "train" / train_id,
+        )
+
+    for test_id in test_ids:
+        shutil.copytree(
+            src=raw_data_path / "train" / test_id,
+            dst=public_path / "test" / test_id,
+        )
+
+    # Construct test set by concatenating all ground truth csvs for the test journeys
+    dfs = []
+    for fpath in sorted((public_path / "test").rglob("ground_truth.csv")):
+        drive_id = fpath.parent.parent.name
+        phone_id = fpath.parent.name
+
+        assert (
+            drive_id in test_ids
+        ), f"Expected the drive {drive_id} to be one of the new test instances. Got {drive_id} instead."
+
+        raw_df = pd.read_csv(fpath)
+        df = raw_df.copy()
+        df.loc[:, "tripId"] = f"{drive_id}-{phone_id}"
+        df = df[["tripId", "UnixTimeMillis", "LatitudeDegrees", "LongitudeDegrees"]]
+        dfs.append(df)
+
+    new_test_labels = pd.concat(dfs, ignore_index=True)
+    # The output filename is 'test.csv' to match the competition structure.
+    new_test_labels.to_csv(private_path / "test.csv", index=False)
+
+    for fpath in (public_path / "test").rglob("ground_truth.csv"):
+        fpath.unlink()  # don't include ground truth in public test data
+
+    shutil.copytree(
+        src=raw_data_path / "metadata",
+        dst=public_path / "metadata",
+    )
+
+    actual_journey_ids = set(["-".join(s.split("-")[:-1]) for s in new_test_labels["tripId"]])
+    assert len(actual_journey_ids) == len(test_ids), (
+        f"Expected the new test instances to have {len(test_ids)} unique trip IDs. Got "
+        f"{len(new_test_labels['tripId'].unique())} unique trip IDs."
+    )
+
+    sample_submission = new_test_labels.copy()
+    sample_submission.loc[:, "LatitudeDegrees"] = 37.904611315634504
+    sample_submission.loc[:, "LongitudeDegrees"] = -86.48107806249548
+
+    assert len(sample_submission) == len(new_test_labels), (
+        f"Expected the sample submission to have the same number of instances as the new test "
+        f"instances. Got {len(sample_submission)} instances in the sample submission and "
+        f"{len(new_test_labels)} new test instances."
+    )
+
+    sample_submission.to_csv(public_path / "sample_submission.csv", index=False)
+
+    assert sorted(list(public_path.glob("train/*"))) == sorted(
+        set([public_path / "train" / drive_id for drive_id in train_ids])
+    ), "Expected the public train directory to contain the new train instances."
+
+    assert sorted(list(public_path.glob("test/*"))) == sorted(
+        set([public_path / "test" / drive_id for drive_id in test_ids])
+    ), "Expected the public test directory to contain the new test instances."
+
+    assert (
+        len(list((public_path / "test").rglob("ground_truth.csv"))) == 0
+    ), "Expected the public test directory to not contain any ground truth files."
+
+    assert len(list((public_path / "train").rglob("ground_truth.csv"))) >= len(train_ids), (
+        "Expected the public train directory to contain at least one ground truth file per new "
+        "train instance."
+    )
+
+
+def prepare(raw: Path, public: Path, private: Path) -> None:
+    # --- Stage 1: Original Split (Train / Test) ---
+    # This section creates the primary competition data in `public` and `private`.
+    # Its logic and outputs are identical to the original script.
+
+    old_train_ids = sorted([folder.name for folder in (raw / "train").glob("*") if folder.is_dir()])
+    dates = sorted(set([get_date(s) for s in old_train_ids]))
+    new_train_dates, new_test_dates = train_test_split(dates, test_size=0.1, random_state=0)
+
+    assert (
+        len(new_train_dates) >= 1
+    ), "Expected the new train set to have at least one date. Got 0 dates."
+
+    assert (
+        len(new_test_dates) >= 1
+    ), "Expected the new test set to have at least one date. Got 0 dates."
+
+    new_train_ids = sorted([i for i in old_train_ids if get_date(i) in new_train_dates])
+    new_test_ids = sorted([i for i in old_train_ids if get_date(i) in new_test_dates])
+
+    assert len(set(new_train_ids).intersection(set(new_test_ids))) == 0, (
+        f"Expected the new train and test instances to be disjoint. Got an intersection of "
+        f"{set(new_train_ids).intersection(set(new_test_ids))}."
+    )
+
+    assert len(new_train_ids) + len(new_test_ids) == len(old_train_ids), (
+        f"Expected the number of new train and test instances to sum up to the number of old train "
+        f"instances. Got {len(new_train_ids)} new train instances and {len(new_test_ids)} new test "
+        f"instances which sum to {len(new_train_ids) + len(new_test_ids)} instead of "
+        f"{len(old_train_ids)}."
+    )
+
+    _process_split(
+        raw_data_path=raw,
+        train_ids=new_train_ids,
+        test_ids=new_test_ids,
+        public_path=public,
+        private_path=private,
+    )
+
+    # --- Stage 2: Validation Split (Train_val / Test_val) ---
+    # This section creates a new validation dataset in parallel directories.
+    # It takes the `new_train_ids` from the first split and splits them again
+    # using the exact same methodology.
+
+    public_val = public.parent / "public_val"
+    private_val = private.parent / "private_val"
+
+    # The input for this split is the training set from the *first* split.
+    val_split_input_dates = sorted(set([get_date(s) for s in new_train_ids]))
+
+    # We replicate the splitting logic and parameters to get a test set of a
+    # similar proportional size to the original test set.
+    train_val_dates, test_val_dates = train_test_split(
+        val_split_input_dates, test_size=0.1, random_state=0
+    )
+
+    train_val_ids = sorted([i for i in new_train_ids if get_date(i) in train_val_dates])
+    test_val_ids = sorted([i for i in new_train_ids if get_date(i) in test_val_dates])
+
+    _process_split(
+        raw_data_path=raw,
+        train_ids=train_val_ids,
+        test_ids=test_val_ids,
+        public_path=public_val,
+        private_path=private_val,
+    )

dslighting/registry/spaceship-titanic/checksums.yaml

@@ -0,0 +1,7 @@
+private:
+  test.csv: 1cb99c65efecaba968128577722a83ef
+public:
+  sample_submission.csv: 5414b5da6ebcff454de1c9ed39b73774
+  test.csv: 8186bd4048aece25f1ed45708f8f34e1
+  train.csv: 564a1614ecef9d9611cec4efdce4c412
+zip: 67c177886736583aff9b947e121395a9

dslighting/registry/spaceship-titanic/config.yaml

@@ -0,0 +1,16 @@
+id: spaceship-titanic
+name: Spaceship Titanic
+competition_type: simple
+awards_medals: false
+prizes: null
+description: mlebench/competitions/spaceship-titanic/description.md
+
+dataset:
+  answers: spaceship-titanic/prepared/private/test.csv
+  sample_submission: spaceship-titanic/prepared/public/sample_submission.csv
+
+grader:
+  name: accuracy
+  grade_fn: mlebench.competitions.spaceship-titanic.grade:grade
+
+preparer: mlebench.competitions.spaceship-titanic.prepare:prepare

dslighting/registry/spaceship-titanic/description.md

@@ -0,0 +1,93 @@
+# Overview
+
+## Description
+Welcome to the year 2912, where your data science skills are needed to solve a cosmic mystery. We've received a transmission from four lightyears away and things aren't looking good.
+
+The *Spaceship Titanic* was an interstellar passenger liner launched a month ago. With almost 13,000 passengers on board, the vessel set out on its maiden voyage transporting emigrants from our solar system to three newly habitable exoplanets orbiting nearby stars.
+
+While rounding Alpha Centauri en route to its first destination—the torrid 55 Cancri E—the unwary *Spaceship Titanic* collided with a spacetime anomaly hidden within a dust cloud. Sadly, it met a similar fate as its namesake from 1000 years before. Though the ship stayed intact, almost half of the passengers were transported to an alternate dimension!
+
+![joel-filipe-QwoNAhbmLLo-unsplash.jpg](https://storage.googleapis.com/kaggle-media/competitions/Spaceship%20Titanic/joel-filipe-QwoNAhbmLLo-unsplash.jpg)
+
+To help rescue crews and retrieve the lost passengers, you are challenged to predict which passengers were transported by the anomaly using records recovered from the spaceship’s damaged computer system.
+
+Help save them and change history!
+
+### Acknowledgments
+
+Photos by [Joel Filipe](https://unsplash.com/@joelfilip?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText), [Richard Gatley](https://unsplash.com/@uncle_rickie?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText) and [ActionVance](https://unsplash.com/@actionvance?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText) on Unsplash.
+
+## Evaluation
+
+### Metric
+
+Submissions are evaluated based on their [classification accuracy](https://developers.google.com/machine-learning/crash-course/classification/accuracy), the percentage of predicted labels that are correct.
+
+### Submission Format
+
+The submission format for the competition is a csv file with the following format:
+
+```
+PassengerId,Transported
+0013_01,False
+0018_01,False
+0019_01,False
+0021_01,False
+etc.
+```
+
+## Frequently Asked Questions
+
+### What is a Getting Started competition?
+
+Getting Started competitions were created by Kaggle data scientists for people who have little to no machine learning background. They are a great place to begin if you are new to data science or just finished a MOOC and want to get involved in Kaggle.
+
+Getting Started competitions are a non-competitive way to get familiar with Kaggle’s platform, learn basic machine learning concepts, and start meeting people in the community. They have no cash prize and are on a rolling timeline.
+
+### How do I create and manage a team?
+
+When you accept the competition rules, a team will be created for you. You can invite others to your team, accept a merger with another team, and update basic information like team name by going to the [Team](https://www.kaggle.com/c/spaceship-titanic/team) page.
+
+We've heard from many Kagglers that teaming up is the best way to learn new skills AND have fun. If you don't have a teammate already, consider asking if anyone wants to team up in the [discussion forum](https://www.kaggle.com/c/spaceship-titanic/discussion).
+
+### What are Notebooks?
+
+Kaggle Notebooks is a cloud computational environment that enables reproducible and collaborative analysis. Notebooks support scripts in Python and R, Jupyter Notebooks, and RMarkdown reports. You can visit the [Notebooks](https://www.kaggle.com/c/spaceship-titanic/notebooks) tab to view all of the publicly shared code for the Spaceship Titanic competition. For more on how to use Notebooks to learn data science, check out our [Courses](https://www.kaggle.com/learn/overview)!
+
+### Why did my team disappear from the leaderboard?
+
+To keep with the spirit of getting-started competitions, we have implemented a two month rolling window on submissions. Once a submission is more than two months old, it will be invalidated and no longer count towards the leaderboard.
+
+If your team has no submissions in the previous two months, the team will also drop from the leaderboard. This will keep the leaderboard at a manageable size, freshen it up, and prevent newcomers from getting lost in a sea of abandoned scores.
+
+*"I worked so hard to get that score! Give it back!"* Read more about our decision to implement a rolling leaderboard [here](https://www.kaggle.com/c/titanic/discussion/6240).
+
+### How do I contact Support?
+
+Kaggle does not have a dedicated support team so you’ll typically find that you receive a response more quickly by asking your question in the appropriate forum. (For this competition, you’ll want to use the [Spaceship Titanic discussion forum](https://www.kaggle.com/c/spaceship-titanic/discussion)).
+
+Support is only able to help with issues that are being experienced by all participants. Before contacting support, please check the discussion forum for information on your problem. If you can’t find it, you can post your problem in the forum so a fellow participant or a Kaggle team member can provide help. The forums are full of useful information on the data, metric, and different approaches. We encourage you to use the forums often. If you share your knowledge, you'll find that others will share a lot in turn!
+
+If your problem persists or it seems to be effective all participants then please [contact us](https://www.kaggle.com/contact).
+
+# Dataset Description
+
+In this competition your task is to predict whether a passenger was transported to an alternate dimension during the Spaceship Titanic's collision with the spacetime anomaly. To help you make these predictions, you're given a set of personal records recovered from the ship's damaged computer system.
+
+## File and Data Field Descriptions
+
+- **train.csv** - Personal records for about two-thirds (~8700) of the passengers, to be used as training data.
+    - `PassengerId` - A unique Id for each passenger. Each Id takes the form `gggg_pp` where `gggg` indicates a group the passenger is travelling with and `pp` is their number within the group. People in a group are often family members, but not always.
+    - `HomePlanet` - The planet the passenger departed from, typically their planet of permanent residence.
+    - `CryoSleep` - Indicates whether the passenger elected to be put into suspended animation for the duration of the voyage. Passengers in cryosleep are confined to their cabins.
+    - `Cabin` - The cabin number where the passenger is staying. Takes the form `deck/num/side`, where `side` can be either `P` for *Port* or `S` for *Starboard*.
+    - `Destination` - The planet the passenger will be debarking to.
+    - `Age` - The age of the passenger.
+    - `VIP` - Whether the passenger has paid for special VIP service during the voyage.
+    - `RoomService`, `FoodCourt`, `ShoppingMall`, `Spa`, `VRDeck` - Amount the passenger has billed at each of the *Spaceship Titanic*'s many luxury amenities.
+    - `Name` - The first and last names of the passenger.
+    - `Transported` - Whether the passenger was transported to another dimension. This is the target, the column you are trying to predict.
+- **test.csv** - Personal records for the remaining one-third (~4300) of the passengers, to be used as test data. Your task is to predict the value of `Transported` for the passengers in this set.
+- **sample_submission.csv** - A submission file in the correct format.
+    - `PassengerId` - Id for each passenger in the test set.
+    - `Transported` - The target. For each passenger, predict either `True` or `False`.

dslighting/registry/spaceship-titanic/description_obfuscated.md

@@ -0,0 +1,38 @@
+# Task
+
+Predict a class based on tabular data.
+
+# Metric
+
+Classification accuracy.
+
+# Submission Format
+
+The submission format for the competition is a csv file with the following format:
+
+```
+PassengerId,Transported
+0013_01,False
+0018_01,False
+0019_01,False
+0021_01,False
+etc.
+```
+
+# Dataset 
+
+- **train.csv** - Personal records for about two-thirds (~8700) of the passengers, to be used as training data.
+    - `PassengerId` - A unique Id for each passenger. Each Id takes the form `gggg_pp` where `gggg` indicates a group the passenger is travelling with and `pp` is their number within the group. People in a group are often family members, but not always.
+    - `HomePlanet` - The planet the passenger departed from, typically their planet of permanent residence.
+    - `CryoSleep` - Indicates whether the passenger elected to be put into suspended animation for the duration of the voyage. Passengers in cryosleep are confined to their cabins.
+    - `Cabin` - The cabin number where the passenger is staying. Takes the form `deck/num/side`, where `side` can be either `P` for *Port* or `S` for *Starboard*.
+    - `Destination` - The planet the passenger will be debarking to.
+    - `Age` - The age of the passenger.
+    - `VIP` - Whether the passenger has paid for special VIP service during the voyage.
+    - `RoomService`, `FoodCourt`, `ShoppingMall`, `Spa`, `VRDeck` - Amount the passenger has billed at each of the *Spaceship Titanic*'s many luxury amenities.
+    - `Name` - The first and last names of the passenger.
+    - `Transported` - Whether the passenger was transported to another dimension. This is the target, the column you are trying to predict.
+- **test.csv** - Personal records for the remaining one-third (~4300) of the passengers, to be used as test data. Your task is to predict the value of `Transported` for the passengers in this set.
+- **sample_submission.csv** - A submission file in the correct format.
+    - `PassengerId` - Id for each passenger in the test set.
+    - `Transported` - The target. For each passenger, predict either `True` or `False`.

dslighting/registry/spaceship-titanic/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="Transported", id_column="PassengerId"
+    )
+    return accuracy_score(**accuracy_inputs)