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

dslighting/registry/hubmap-kidney-segmentation/prepare_val.py

@@ -0,0 +1,153 @@
+import shutil
+from pathlib import Path
+import pandas as pd
+
+from sklearn.model_selection import train_test_split
+from tqdm.auto import tqdm
+
+from mlebench.utils import read_csv
+
+
+def _create_split_files(
+    train_df: pd.DataFrame,
+    test_df: pd.DataFrame,
+    full_dataset_info: pd.DataFrame,
+    raw_path: Path,
+    public_path: Path,
+    private_path: Path,
+):
+    """
+    Helper function to generate all required files for a given train/test split.
+
+    This function encapsulates the logic of creating CSVs, sample submissions,
+    and copying image files to ensure that the process is identical for both
+    the main split (public/private) and the validation split (public_val/private_val).
+    """
+    # Create output directories
+    public_path.mkdir(parents=True, exist_ok=True)
+    private_path.mkdir(parents=True, exist_ok=True)
+    (public_path / "train").mkdir(parents=True, exist_ok=True)
+    (public_path / "test").mkdir(parents=True, exist_ok=True)
+
+    # Process and save data files
+    dataset_info = full_dataset_info.drop(columns=["id"], inplace=False)
+    dataset_info.to_csv(public_path / "HuBMAP-20-dataset_information.csv", index=False)
+
+    train_df.to_csv(public_path / "train.csv", index=False)
+
+    # Put height and width in test_df, for grading
+    private_test_df = test_df.merge(full_dataset_info[["id", "width_pixels", "height_pixels"]], on="id")
+    private_test_df.to_csv(private_path / "test.csv", index=False)
+
+    sample_submission = private_test_df[["id"]].copy()
+    sample_submission["predicted"] = ""
+    sample_submission.to_csv(public_path / "sample_submission.csv", index=False)
+    # for some reason sample_submission.csv is also in test/
+    shutil.copy(public_path / "sample_submission.csv", public_path / "test" / "sample_submission.csv")
+
+    # basically the same as private_test_df but with a different column name
+    gold_submission = sample_submission.copy()
+    gold_submission["predicted"] = private_test_df["encoding"]
+    gold_submission.to_csv(private_path / "gold_submission.csv", index=False)
+
+    # Copy image files
+    for image_id in tqdm(train_df["id"], desc=f"Copying train images to {public_path.name}"):
+        shutil.copy(raw_path / "train" / f"{image_id}.tiff", public_path / "train" / f"{image_id}.tiff")
+        shutil.copy(raw_path / "train" / f"{image_id}.json", public_path / "train" / f"{image_id}.json")
+        shutil.copy(
+            raw_path / "train" / f"{image_id}-anatomical-structure.json",
+            public_path / "train" / f"{image_id}-anatomical-structure.json",
+        )
+
+    for image_id in tqdm(private_test_df["id"], desc=f"Copying test images to {public_path.name}"):
+        shutil.copy(raw_path / "train" / f"{image_id}.tiff", public_path / "test" / f"{image_id}.tiff")
+        shutil.copy(raw_path / "train" / f"{image_id}.json", public_path / "test" / f"{image_id}.json")
+        shutil.copy(
+            raw_path / "train" / f"{image_id}-anatomical-structure.json",
+            public_path / "test" / f"{image_id}-anatomical-structure.json",
+        )
+
+    # Checks
+    assert train_df.columns.to_list() == [
+        "id",
+        "encoding",
+    ], f"Public train set in {public_path.name} should have 2 columns, called 'id' and 'encoding'"
+    assert private_test_df.columns.to_list() == [
+        "id",
+        "encoding",
+        "width_pixels",
+        "height_pixels",
+    ], f"Private test set in {private_path.name} should have 4 columns"
+
+    assert len(sample_submission) == len(private_test_df), "Sample submission length should match test set"
+    assert sample_submission.columns.to_list() == [
+        "id",
+        "predicted",
+    ], "Sample submissions should have two columns, 'id' and 'predicted'"
+
+    assert len(gold_submission) == len(private_test_df), "Gold submission length should match test set"
+    assert gold_submission.columns.to_list() == [
+        "id",
+        "predicted",
+    ], "Gold submissions should have two columns, 'id' and 'predicted'"
+
+    assert gold_submission["predicted"].equals(
+        private_test_df["encoding"]
+    ), "Gold submission should match private test set"
+
+    assert set(train_df["id"]).isdisjoint(
+        set(private_test_df["id"])
+    ), "Train and test ids should not overlap"
+
+    assert len(list((public_path / "train").glob("*.tiff"))) == len(
+        train_df
+    ), f"Missing train tiff files in {public_path.name}"
+    assert len(list((public_path / "train").glob("*-anatomical-structure.json"))) == len(
+        train_df
+    ), f"Missing train structure json files in {public_path.name}"
+    assert (
+        len(list((public_path / "train").glob("*.json"))) == len(train_df) * 2
+    ), f"Missing train json files in {public_path.name}"
+
+    assert len(list((public_path / "test").glob("*.tiff"))) == len(private_test_df), f"Missing test tiff files in {public_path.name}"
+    assert len(list((public_path / "test").glob("*-anatomical-structure.json"))) == len(
+        private_test_df
+    ), f"Missing test structure json files in {public_path.name}"
+
+
+def prepare(raw: Path, public: Path, private: Path):
+
+    old_train = read_csv(raw / "train.csv")
+    old_dataset_info = read_csv(raw / "HuBMAP-20-dataset_information.csv")
+
+    # --- First Split: Create the main train and test sets ---
+    # This split is identical to the original script to ensure public/private are not changed.
+    new_train, new_test = train_test_split(old_train, train_size=12, test_size=3, random_state=0)
+    
+    # Process dataset_info once. This info is based on the full original train set
+    # and will be used for both the main and validation splits.
+    old_dataset_info["id"] = old_dataset_info["image_file"].str.replace(".tiff", "")
+    dataset_info = old_dataset_info[old_dataset_info["id"].isin(old_train["id"])]
+    
+    # Create the original public and private directories and their contents.
+    # The results of this call will be IDENTICAL to the original script's output.
+    _create_split_files(new_train, new_test, dataset_info, raw, public, private)
+    
+    # --- Second Split: Create a validation set from the main train set ---
+    # This creates a new, smaller training set and a validation set.
+    # The outputs are saved to parallel 'public_val' and 'private_val' directories.
+    public_val = public.parent / "public_val"
+    private_val = private.parent / "private_val"
+
+    # Split new_train (12 samples) into train_val (9) and test_val (3).
+    # This replicates the test set size (3) and random_state (0) from the first split.
+    train_val, test_val = train_test_split(new_train, train_size=9, test_size=3, random_state=0)
+
+    # Create the new validation directories and their contents.
+    # The file structure and names inside these directories will mirror the original ones.
+    _create_split_files(train_val, test_val, dataset_info, raw, public_val, private_val)
+
+    # Final check from original script
+    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/icecube-neutrinos-in-deep-ice/checksums.yaml

@@ -0,0 +1,8 @@
+private:
+  test.csv: 6b3eef7a836409e5c99557763d1d2c7d
+public:
+  sample_submission.csv: df2a0e29adf304f4fa521a43ba9031f1
+  sensor_geometry.csv: acad541886071600c427b405a70841e8
+  test_meta.parquet: 855451176da14ba1114640544462ebbb
+  train_meta.parquet: 9d8bd35236ee452f8baed612b9f5fd0c
+zip: 8663264342ff575230df4d29f20eff7c

dslighting/registry/icecube-neutrinos-in-deep-ice/config.yaml

@@ -0,0 +1,34 @@
+id: icecube-neutrinos-in-deep-ice
+name: IceCube - Neutrinos in Deep Ice
+competition_type: code
+awards_medals: true
+prizes:
+  - position: 1
+    value: 18000
+  - position: 2
+    value: 12000
+  - position: 3
+    value: 10000
+  - position: Most Interesting Solution Writeup 1
+    value: 1000
+  - position: Most Interesting Solution Writeup 2
+    value: 1000
+  - position: Most Interesting Solution Writeup 3
+    value: 1000
+  - position: Most Interesting Solution Writeup 4
+    value: 1000
+  - position: Most Interesting Solution Writeup 5
+    value: 1000
+  - position: Early Sharing Prize
+    value: 5000
+description: mlebench/competitions/icecube-neutrinos-in-deep-ice/description.md
+
+dataset:
+  answers: icecube-neutrinos-in-deep-ice/prepared/private/test.csv
+  sample_submission: icecube-neutrinos-in-deep-ice/prepared/public/sample_submission.csv
+
+grader:
+  name: mean-angular-error
+  grade_fn: mlebench.competitions.icecube-neutrinos-in-deep-ice.grade:grade
+
+preparer: mlebench.competitions.icecube-neutrinos-in-deep-ice.prepare:prepare

dslighting/registry/icecube-neutrinos-in-deep-ice/description.md

@@ -0,0 +1,231 @@
+# Overview
+
+## Description
+
+## Goal of the Competition
+
+The goal of this competition is to predict a neutrino particle's direction. You will develop a model based on data from the "IceCube" detector, which observes the cosmos from deep within the South Pole ice.
+
+Your work could help scientists better understand exploding stars, gamma-ray bursts, and cataclysmic phenomena involving black holes, neutron stars and the fundamental properties of the neutrino itself.
+
+## Context
+
+One of the most abundant particles in the universe is the neutrino. While similar to an electron, the nearly massless and electrically neutral neutrinos have fundamental properties that make them difficult to detect. Yet, to gather enough information to probe the most violent astrophysical sources, scientists must estimate the direction of neutrino events. If algorithms could be made considerably faster and more accurate, it would allow for more neutrino events to be analyzed, possibly even in real-time and dramatically increase the chance to identify cosmic neutrino sources. Rapid detection could enable networks of telescopes worldwide to search for more transient phenomena.
+
+Researchers have developed multiple approaches over the past ten years to reconstruct neutrino events. However, problems arise as existing solutions are far from perfect. They're either fast but inaccurate or more accurate at the price of huge computational costs.
+
+The IceCube Neutrino Observatory is the first detector of its kind, encompassing a cubic kilometer of ice and designed to search for the nearly massless neutrinos. An international group of scientists is responsible for the scientific research that makes up the IceCube Collaboration.
+
+By making the process faster and more precise, you'll help improve the reconstruction of neutrinos. As a result, we could gain a clearer image of our universe.
+
+![IceCube South Pole Neutrino Observatory](https://storage.googleapis.com/kaggle-media/competitions/IceCube/icecube_detector.jpg)
+
+> This is a Code Competition. Refer to [Code Requirements](https://www.kaggle.com/c/icecube-neutrinos-in-deep-ice/overview/code-requirements) for details.
+
+## Evaluation
+
+Submissions are evaluated using the mean angular error between the predicted and true event origins. See [this notebook](https://www.kaggle.com/code/sohier/mean-angular-error) for a python copy of the metric.
+
+Submission File
+---------------
+
+For each `event_id` in the test set, you must predict the `azimuth` and `zenith`. The file should contain a header and have the following format:
+
+```
+event_id,azimuth,zenith
+730,1,1
+769,1,1
+774,1,1
+etc.
+```
+
+## Timeline
+
+- January 19, 2023 - Start Date.
+
+- April 12, 2023 - Entry Deadline. You must accept the competition rules before this date in order to compete.
+
+- April 12, 2023 - Team Merger Deadline. This is the last day participants may join or merge teams.
+
+- April 19, 2023 - 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
+
+Leaderboard Prizes
+------------------
+
+\$40,000 will be awarded to the Top 3 teams with the highest scores on the Kaggle Leaderboard at the conclusion of the competition:
+
+- 1st Place - \$18,000
+- 2nd Place - \$12,000
+- 3rd Place - \$10,000
+
+"Most Interesting Solution Writeup" Prizes
+------------------------------------------
+
+\$5,000 will be awarded to 5 teams (\$1,000 each) for the "most interesting solution writeup" from the top 30 final leaderboard finishers at the conclusion of the competition. Please see ["Writeup Scoring Rubrics"](https://www.kaggle.com/competitions/icecube-neutrinos-in-deep-ice/overview/writeup-scoring-rubrics) for the details of the evaluation criteria.
+
+As a condition to being awarded a Prize, a Prize winner must provide a detailed write-up on their solution in the competition forums within 14 days of the conclusion of the competition, i.e. May 3, 2023 11:59PM UTC.
+
+Early Sharing Prize
+-------------------
+
+\$5,000 will be awarded to the team with the highest private leaderboard score as of February 2, 2023 11:59PM UTC (2 weeks from the start of the competition) among submission notebooks published by February 4, 2023 11:59PM UTC. Please see ["Early Sharing Prize"](https://www.kaggle.com/competitions/icecube-neutrinos-in-deep-ice/overview/early-sharing-prize) for the details on how the Early Sharing Prize will be awarded at the conclusion of the competition.
+
+## Code Requirements
+
+![](https://storage.googleapis.com/kaggle-media/competitions/general/Kerneler-white-desc2_transparent.png)
+
+## This is a Code Competition
+
+Submissions to this competition must be made through Notebooks. In order for the "Submit" button to be active after a commit, the following conditions must be met:
+
+- CPU Notebook `<= 9` hours run-time
+- GPU Notebook `<= 9` hours run-time
+- Internet access disabled
+- Freely & publicly available external data is allowed, including pre-trained models
+- Submission file must be named `submission.csv`
+
+Please see the [Code Competition FAQ](https://www.kaggle.com/docs/competitions#notebooks-only-FAQ) for more information on how to submit. And review the [code debugging doc](https://www.kaggle.com/code-competition-debugging) if you are encountering submission errors.
+
+## Writeup Scoring Rubrics
+
+| Criterion | Description | Weight |
+| --- | --- | --- |
+| Technical Details & Reproducibility | Is the code well documented and the description well written? Is the documentation sufficient for training and deploying the model from scratch? | 30% |
+| Innovation | Is the full model, or certain parts of the approach particularly innovative? Are certain non-standard methods used or new methods invented? What goes beyond standard ML toolchains? | 20% |
+| Generalness | Is the method general enough such that it could be applied to other neutrino telescopes that feature a similar detector concept but a different arrangement of a different number of modules? For example, the detectors of <https://www.km3net.org/> that are currently under construction. | 20% |
+| Lessons Learned | What were the exploratory steps taken on the way from the first try to the final model? What approaches did not work well? | 10% |
+| Robustness | How robust is the method to perturbations in the data? For example, change an event by adding random numbers taken from a normal distribution with standard deviation 5 ns to each pulse time. Are the predicted neutrino angles stable under such changes? | 10% |
+| Explanation | Can the method be visualized in some way and can the parts of the model be motivated/explained as why these are necessary and what exactly they do? | 10% |
+
+## Early Sharing Prize
+
+
+We are awarding a \$5,000 cash prize to encourage participants to share information earlier and help the community make more progress over the course of the competition.
+
+To be eligible for the Early Sharing Prize, you will need to:
+
+-   Submit one or more notebooks before February 2, 2023 11:59PM UTC and publish them before February 4, 2023 11:59PM UTC. The delayed publication date is intended to allow you to participate in the early sharing prize without being concerned that someone else might re-submit your work.
+-   Keep the notebooks and any datasets it uses publicly available until the prize is awarded at the end of the competition.
+
+To avoid creating a disincentive for teaming up, the prize will be awarded to the members of the team as it exists at 2 weeks from the start of the competition.
+
+This is an experimental prize and we would appreciate feedback on the concept.
+
+## Additional Resources
+
+Here are a few introductory videos:
+
+- [Neutrino, measuring the unexpected--IceCube](https://www.youtube.com/watch?v=iv-Rz3-s4BM)
+- [Chasing the Ghost Particle: From the South Pole to the Edge of the Universe](https://www.youtube.com/watch?v=xuyTgAlPOGY)
+- [Uncharted Cosmos: Mapping the Universe with IceCube](https://www.youtube.com/watch?v=GBPNe_0WY4Y)
+
+Below is a collection of useful references on the topic:
+
+## Scientific Results (selected highlights):
+
+- [Evidence for neutrino emission from the nearby active galaxy NGC 1068](https://icecube.wisc.edu/news/press-releases/2022/11/icecube-neutrinos-give-us-first-glimpse-into-the-inner-depths-of-an-active-galaxy/)
+- [Multi-messenger observations of a flaring blazar coincident with high-energy neutrino IceCube-170922A](https://arxiv.org/abs/1807.08816)
+- [Neutrino emission from the direction of the blazar TXS 0506+056 prior to the IceCube-170922A alert](https://arxiv.org/abs/1807.08794)
+- [Observation of High-Energy Astrophysical Neutrinos in Three Years of IceCube Data](https://arxiv.org/abs/1405.5303)
+- [Detection of a particle shower at the Glashow resonance with IceCube](https://arxiv.org/abs/2110.15051)
+- [Measurement of Atmospheric Neutrino Oscillations at 6--56 GeV with IceCube DeepCore](https://arxiv.org/abs/1707.07081)
+- [Time-integrated Neutrino Source Searches with 10 years of IceCube Data](https://arxiv.org/abs/1910.08488)
+- [Measurement of the multi-TeV neutrino cross section with IceCube using Earth absorption](https://arxiv.org/abs/1711.08119)
+- [An eV-scale sterile neutrino search using eight years of atmospheric muon neutrino data from the IceCube Neutrino Observatory](https://arxiv.org/abs/2005.12942)
+
+## Detector & Ice:
+
+- [The IceCube Neutrino Observatory: Instrumentation and Online Systems](https://arxiv.org/abs/1612.05093)
+- [First Year Performance of The IceCube Neutrino Telescope](https://arxiv.org/abs/astro-ph/0604450)
+- [The IceCube Data Acquisition System: Signal Capture, Digitization, and Timestamping](https://arxiv.org/abs/0810.4930)
+- [The Design and Performance of IceCube DeepCore](https://arxiv.org/abs/1109.6096)
+- [Measurement of South Pole ice transparency with the IceCube LED calibration system](https://arxiv.org/abs/1301.5361)
+
+## Event Reconstruction:
+
+- [Energy Reconstruction Methods in the IceCube Neutrino Telescope](https://arxiv.org/abs/1311.4767)
+- [Low Energy Event Reconstruction in IceCube DeepCore](https://arxiv.org/abs/2203.02303)
+- [A flexible event reconstruction based on machine learning and likelihood principles](https://arxiv.org/abs/2208.10166)
+- [Graph Neural Networks for Low-Energy Event Classification & Reconstruction in IceCube](https://arxiv.org/abs/2209.03042)
+- [A Fast Algorithm for Muon Track Reconstruction and its Application to the ANTARES Neutrino Telescope](https://arxiv.org/abs/1105.4116)
+- [An algorithm for the reconstruction of neutrino-induced showers in the ANTARES neutrino telescope](https://arxiv.org/abs/1708.03649)
+- [Muon Track Reconstruction and Data Selection Techniques in AMANDA](https://arxiv.org/abs/astro-ph/0407044)
+- [A Convolutional Neural Network based Cascade Reconstruction for the IceCube Neutrino Observatory](https://arxiv.org/abs/2101.11589)
+- [Event reconstruction for KM3NeT/ORCA using convolutional neural networks](https://arxiv.org/abs/2004.08254)
+- [An improved method for measuring muon energy using the truncated mean of dE/dx](https://arxiv.org/abs/1208.3430)
+- [A muon-track reconstruction exploiting stochastic losses for large-scale Cherenkov detectors](https://arxiv.org/abs/2103.16931)
+- [Improvement in Fast Particle Track Reconstruction with Robust Statistics](https://arxiv.org/abs/1308.5501)
+
+## Other Neutrino Telescopes (past, present & future):
+
+- [The AMANDA Neutrino Telescope: Principle of Operation and First Results](https://arxiv.org/abs/astro-ph/9906203)
+- [ANTARES: the first undersea neutrino telescope](https://arxiv.org/abs/1104.1607)
+- [Letter of Intent for KM3NeT 2.0](https://arxiv.org/abs/1601.07459)
+- [IceCube-Gen2: The Window to the Extreme Universe](https://arxiv.org/abs/2008.04323)
+- [Letter of Intent: The Precision IceCube Next Generation Upgrade (PINGU)](https://arxiv.org/abs/1401.2046)
+- [Baikal-GVD: status and prospects](https://arxiv.org/abs/1808.10353)
+- [The Pacific Ocean Neutrino Experiment](https://arxiv.org/abs/2005.09493)
+
+## Acknowledgements
+
+
+|  |  |
+| --- | --- |
+| ![](https://storage.googleapis.com/kaggle-media/competitions/IceCube/icecube_logo_large1.png) | The [IceCube Neutrino Observatory](https://icecube.wisc.edu/) is the world's largest neutrino detector and is providing the data for this challenge as well as helping with the organization. |
+| ![](https://storage.googleapis.com/kaggle-media/competitions/IceCube/TUM_Logo_blau_rgb_p1.png) | The [Technical University of Munich](https://www.tum.de/), or short TUM, is one of the top universities in Europe, a member of the IceCube collaboration, and the home of the competition organizers. |
+| ![](https://storage.googleapis.com/kaggle-media/competitions/IceCube/MDSI.png) | The [Munich Data Science Institute](https://www.mdsi.tum.de/en/mdsi/home/) is TUM's central data science infrastructure and competence center. The MDSI is helping with the organization of this kaggle challenge, and supporting its realization. |
+| ![](https://storage.googleapis.com/kaggle-media/competitions/IceCube/sfb_logo_farbe_trans.png) | The [Collaborative Research Center SFB 1258](https://www.sfb1258.de/) is a reserach collaboration focused on neutrinos and dark matter in astro- and particle physics, and a partner supporting this kaggle challenge. |
+| ![](https://storage.googleapis.com/kaggle-media/competitions/IceCube/Logo_Origins_RGB.jpg) | The [Excellence Cluster ORIGINS](https://www.origins-cluster.de/) investigates the development of the Universe from the Big Bang to the emergence of life. The cluster and in particular its data science laboratory ODSL support this ML challenge. |
+| ![](https://storage.googleapis.com/kaggle-media/competitions/IceCube/PUNCH4NFDI-Logo_RGB.png) | [PUNCH4NFDI](https://www.punch4nfdi.de/) is a large German research consortium under the [NFDI](https://www.nfdi.de/) infrastructure, focused on particle, astro-, astroparticle, hadron and nuclear physics, and is supporting this ML challenge. |
+
+## Citation
+
+Ashley Chow, Lukas Heinrich, Philipp Eller, Rasmus Ørsøe, Sohier Dane. (2023). IceCube - Neutrinos in Deep Ice. Kaggle. https://kaggle.com/competitions/icecube-neutrinos-in-deep-ice
+
+# Dataset Description
+
+The goal of this competition is to identify which direction neutrinos detected by the [IceCube neutrino observatory](https://icecube.wisc.edu/science/icecube/) came from. When detection events can be localized quickly enough, traditional telescopes are recruited to investigate short-lived neutrino sources such as supernovae or gamma ray bursts. Because the sky is huge better localization will not only associate neutrinos with sources but also to help partner observatories limit their search space. With an average of three thousand events per second to process, it's difficult to keep up with the stream of data using traditional methods. Your challenge in this competition is to quickly and accurately process a large number of events.
+
+This competition uses a hidden test set. When your submitted notebook is scored the actual test data (including a full length sample submission) will be made available to your notebook. Expect to see roughly one million events in the hidden test set, split between multiple batches.
+
+Files
+-----
+
+[train/test]_meta.parquet
+
+-   `batch_id` (`int`): the ID of the batch the event was placed into.
+-   `event_id` (`int`): the event ID.
+-   `[first/last]_pulse_index` (`int`): index of the first/last row in the features dataframe belonging to this event.
+-   `[azimuth/zenith]` (`float32`): the [azimuth/zenith] angle in radians of the neutrino. A value between 0 and 2*pi for the azimuth and 0 and pi for zenith. The target columns. Not provided for the test set. The direction vector represented by zenith and azimuth points to where the neutrino came from.
+-   NB: Other quantities regarding the event, such as the interaction point in `x, y, z` (vertex position), the neutrino energy, or the interaction type and kinematics are not included in the dataset.
+
+[train/test]/batch_[n].parquet Each batch contains tens of thousands of events. Each event may contain thousands of pulses, each of which is the digitized output from a photomultiplier tube and occupies one row.
+
+-   `event_id` (`int`): the event ID. Saved as the index column in parquet.
+-   `time` (`int`): the time of the pulse in nanoseconds in the current event time window. The absolute time of a pulse has no relevance, and only the relative time with respect to other pulses within an event is of relevance.
+-   `sensor_id` (`int`): the ID of which of the 5160 IceCube photomultiplier sensors recorded this pulse.
+-   `charge` (`float32`): An estimate of the amount of light in the pulse, in units of photoelectrons (p.e.). A physical photon does not exactly result in a measurement of 1 p.e. but rather can take values spread around 1 p.e. As an example, a pulse with charge 2.7 p.e. could quite likely be the result of two or three photons hitting the photomultiplier tube around the same time. This data has `float16` precision but is stored as `float32` due to limitations of the version of pyarrow the data was prepared with.
+-   `auxiliary` (`bool`): If `True`, the pulse was not fully digitized, is of lower quality, and was more likely to originate from noise. If `False`, then this pulse was contributed to the trigger decision and the pulse was fully digitized.
+
+sample_submission.parquet An example submission with the correct columns and properly ordered event IDs. The sample submission is provided in the parquet format so it can be read quickly but *your final submission must be a csv*.
+
+`sensor_geometry.csv` The `x`, `y`, and `z` positions for each of the 5160 IceCube sensors. The row index corresponds to the `sensor_idx` feature of pulses. The `x`, `y`, and `z` coordinates are in units of meters, with the origin at the center of the IceCube detector. The coordinate system is right-handed, and the z-axis points upwards when standing at the South Pole. You can convert from these coordinates to `azimuth` and `zenith` with the following formulas (here the vector (x,y,z) is normalized):
+
+```
+x = cos(azimuth) * sin(zenith)
+y = sin(azimuth) * sin(zenith)
+z = cos(zenith)
+
+```
+
+Example Event
+-------------
+
+The following image shows a visual representation of the features of an IceCube event in the dataset. The colorful dots represent sensors that logged at least one pulse in the event. The size of the dots corresponds to the total charge of all pulses while the color indicates the time of the first pulse.\
+The left panel shows only pulses with `auxiliary==False`, and the right panel with `auxiliary==True`. The small, gray points indicate the positions of all 5160 IceCube sensors. The red arrow shows the true neutrino direction of that event, i.e. the regression target.
+
+![](https://www.googleapis.com/download/storage/v1/b/kaggle-forum-message-attachments/o/inbox%2F1132983%2F6891ec67d9d40315637b1b292c3a486b%2FExample_event.png?generation=1666631264548536&alt=media)

dslighting/registry/icecube-neutrinos-in-deep-ice/description_obfuscated.md

@@ -0,0 +1,48 @@
+# Task
+
+Predict a neutrino particle's direction. 
+
+# Metric
+
+Mean angular error between the predicted and true event origins.
+
+# Submission Format
+
+For each `event_id` in the test set, you must predict the `azimuth` and `zenith`. The file should contain a header and have the following format:
+
+```
+event_id,azimuth,zenith
+730,1,1
+769,1,1
+774,1,1
+etc.
+```
+
+# Dataset 
+
+[train/test]_meta.parquet
+
+-   `batch_id` (`int`): the ID of the batch the event was placed into.
+-   `event_id` (`int`): the event ID.
+-   `[first/last]_pulse_index` (`int`): index of the first/last row in the features dataframe belonging to this event.
+-   `[azimuth/zenith]` (`float32`): the [azimuth/zenith] angle in radians of the neutrino. A value between 0 and 2*pi for the azimuth and 0 and pi for zenith. The target columns. Not provided for the test set. The direction vector represented by zenith and azimuth points to where the neutrino came from.
+-   NB: Other quantities regarding the event, such as the interaction point in `x, y, z` (vertex position), the neutrino energy, or the interaction type and kinematics are not included in the dataset.
+
+[train/test]/batch_[n].parquet Each batch contains tens of thousands of events. Each event may contain thousands of pulses, each of which is the digitized output from a photomultiplier tube and occupies one row.
+
+-   `event_id` (`int`): the event ID. Saved as the index column in parquet.
+-   `time` (`int`): the time of the pulse in nanoseconds in the current event time window. The absolute time of a pulse has no relevance, and only the relative time with respect to other pulses within an event is of relevance.
+-   `sensor_id` (`int`): the ID of which of the 5160 IceCube photomultiplier sensors recorded this pulse.
+-   `charge` (`float32`): An estimate of the amount of light in the pulse, in units of photoelectrons (p.e.). A physical photon does not exactly result in a measurement of 1 p.e. but rather can take values spread around 1 p.e. As an example, a pulse with charge 2.7 p.e. could quite likely be the result of two or three photons hitting the photomultiplier tube around the same time. This data has `float16` precision but is stored as `float32` due to limitations of the version of pyarrow the data was prepared with.
+-   `auxiliary` (`bool`): If `True`, the pulse was not fully digitized, is of lower quality, and was more likely to originate from noise. If `False`, then this pulse was contributed to the trigger decision and the pulse was fully digitized.
+
+sample_submission.parquet An example submission with the correct columns and properly ordered event IDs. The sample submission is provided in the parquet format so it can be read quickly but *your final submission must be a csv*.
+
+`sensor_geometry.csv` The `x`, `y`, and `z` positions for each of the 5160 IceCube sensors. The row index corresponds to the `sensor_idx` feature of pulses. The `x`, `y`, and `z` coordinates are in units of meters, with the origin at the center of the IceCube detector. The coordinate system is right-handed, and the z-axis points upwards when standing at the South Pole. You can convert from these coordinates to `azimuth` and `zenith` with the following formulas (here the vector (x,y,z) is normalized):
+
+```
+x = cos(azimuth) * sin(zenith)
+y = sin(azimuth) * sin(zenith)
+z = cos(zenith)
+
+```

dslighting/registry/icecube-neutrinos-in-deep-ice/grade.py

@@ -0,0 +1,111 @@
+import numpy as np
+import pandas as pd
+
+from mlebench.grade_helpers import InvalidSubmissionError
+
+
+def prepare_for_metric(submission: pd.DataFrame, answers: pd.DataFrame) -> dict:
+    # submission
+    if set(submission.columns) != {"azimuth", "zenith", "event_id"}:
+        raise InvalidSubmissionError(
+            "Submission must contain columns 'azimuth','zenith' and 'event_id'"
+        )
+
+    if not np.issubdtype(submission["azimuth"].dtype, np.number):
+        raise InvalidSubmissionError("Azimuth must be a number")
+    if not np.issubdtype(submission["zenith"].dtype, np.number):
+        raise InvalidSubmissionError("Zenith must be a number")
+    if not np.all(np.isfinite(submission["azimuth"])):
+        raise InvalidSubmissionError("Azimuth must not be infinite")
+    if not np.all(np.isfinite(submission["zenith"])):
+        raise InvalidSubmissionError("Zenith must not be infinite")
+    if submission["azimuth"].isnull().any():
+        raise InvalidSubmissionError("Azimuth must not be NaN")
+    if submission["zenith"].isnull().any():
+        raise InvalidSubmissionError("Zenith must not be NaN")
+
+    # answers
+    assert set(answers.columns) == {
+        "azimuth",
+        "zenith",
+        "event_id",
+    }, "Answers must contain columns 'azimuth','zenith' and 'event_id'"
+    assert np.issubdtype(answers["azimuth"].dtype, np.number), "Azimuth must be a number"
+    assert np.issubdtype(answers["zenith"].dtype, np.number), "Zenith must be a number"
+    assert np.all(np.isfinite(answers["azimuth"])), "Azimuth must not be infinite"
+    assert np.all(np.isfinite(answers["zenith"])), "Zenith must not be infinite"
+    assert not answers["azimuth"].isnull().any(), "Azimuth must not be NaN"
+    assert not answers["zenith"].isnull().any(), "Zenith must not be NaN"
+
+    # both
+    if len(submission) != len(answers):
+        raise InvalidSubmissionError("Submission and answers must have the same length")
+    if set(submission["event_id"]) != set(answers["event_id"]):
+        raise InvalidSubmissionError("Submission and answers must have the same event_ids")
+
+    # sort values by id so that the order is correct
+    submission = submission.sort_values("event_id")
+    answers = answers.sort_values("event_id")
+
+    return {
+        "az_true": answers["azimuth"].to_numpy(),
+        "zen_true": answers["zenith"].to_numpy(),
+        "az_pred": submission["azimuth"].to_numpy(),
+        "zen_pred": submission["zenith"].to_numpy(),
+    }
+
+
+# courtesy of notebook from competition host: https://www.kaggle.com/code/sohier/mean-angular-error
+def angular_dist_score(az_true, zen_true, az_pred, zen_pred):
+    """
+    calculate the MAE of the angular distance between two directions.
+    The two vectors are first converted to cartesian unit vectors,
+    and then their scalar product is computed, which is equal to
+    the cosine of the angle between the two vectors. The inverse
+    cosine (arccos) thereof is then the angle between the two input vectors
+
+    Parameters:
+    -----------
+
+    az_true : float (or array thereof)
+        true azimuth value(s) in radian
+    zen_true : float (or array thereof)
+        true zenith value(s) in radian
+    az_pred : float (or array thereof)
+        predicted azimuth value(s) in radian
+    zen_pred : float (or array thereof)
+        predicted zenith value(s) in radian
+
+    Returns:
+    --------
+
+    dist : float
+        mean over the angular distance(s) in radian
+    """
+
+    # pre-compute all sine and cosine values
+    sa1 = np.sin(az_true)
+    ca1 = np.cos(az_true)
+    sz1 = np.sin(zen_true)
+    cz1 = np.cos(zen_true)
+
+    sa2 = np.sin(az_pred)
+    ca2 = np.cos(az_pred)
+    sz2 = np.sin(zen_pred)
+    cz2 = np.cos(zen_pred)
+
+    # scalar product of the two cartesian vectors (x = sz*ca, y = sz*sa, z = cz)
+    scalar_prod = sz1 * sz2 * (ca1 * ca2 + sa1 * sa2) + (cz1 * cz2)
+
+    # scalar product of two unit vectors is always between -1 and 1, this is against nummerical instability
+    # that might otherwise occure from the finite precision of the sine and cosine functions
+    scalar_prod = np.clip(scalar_prod, -1, 1)
+
+    # convert back to an angle (in radian)
+    return np.average(np.abs(np.arccos(scalar_prod)))
+
+
+def grade(submission: pd.DataFrame, answers: pd.DataFrame) -> float:
+    ang_dist_score_inputs = prepare_for_metric(submission, answers)
+    score = angular_dist_score(**ang_dist_score_inputs)
+    return score