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

dslighting/registry/hotel-id-2021-fgvc8/prepare.py

@@ -0,0 +1,63 @@
+import shutil
+from pathlib import Path
+
+from sklearn.model_selection import train_test_split
+from tqdm.auto import tqdm
+
+from mlebench.utils import read_csv
+
+
+def prepare(raw: Path, public: Path, private: Path):
+    old_train = read_csv(raw / "train.csv")
+    # drop image ce27d36c9147cc19.jpg: it appears twice and may occur across train and test when split
+    old_train = old_train[old_train["image"] != "ce27d36c9147cc19.jpg"]
+
+    new_train, new_test = train_test_split(old_train, test_size=0.1, random_state=0)
+    sample_submission = new_test.copy()[["image", "hotel_id"]]
+    sample_submission["hotel_id"] = "36363 53586 18807 64314 60181"
+
+    # save public files
+    new_train.to_csv(public / "train.csv", index=False)
+    sample_submission.to_csv(public / "sample_submission.csv", index=False)
+
+    # copy images from raw to prepared/public accordingly
+    (public / "train_images").mkdir(exist_ok=True, parents=True)
+    for image, chain in tqdm(
+        zip(new_train["image"], new_train["chain"]), total=len(new_train), desc="Train images"
+    ):
+        chain = str(chain)
+        (public / "train_images" / chain).mkdir(exist_ok=True, parents=True)
+        shutil.copy(raw / "train_images" / chain / image, public / "train_images" / chain / image)
+
+    (public / "test_images").mkdir(exist_ok=True, parents=True)
+    for image, chain in tqdm(
+        zip(new_test["image"], new_test["chain"]), total=len(new_test), desc="Test images"
+    ):
+        chain = str(chain)
+        (public / "test_images").mkdir(exist_ok=True, parents=True)
+        shutil.copy(raw / "train_images" / chain / image, public / "test_images" / image)
+
+    # save private files
+    new_test.to_csv(private / "test.csv", index=False)
+
+    # checks
+    assert len(new_train) + len(new_test) == len(
+        old_train
+    ), "Length of new_train and new_test should equal length of old_train"
+    assert sample_submission.columns.to_list() == [
+        "image",
+        "hotel_id",
+    ], "Sample submission columns should only be `image` and `hotel_id`"
+    assert len(sample_submission) == len(new_test), "Sample submission length should match test set"
+    for image, chain in zip(new_train["image"], new_train["chain"]):
+        chain = str(chain)
+        assert (
+            public / "train_images" / chain / image
+        ).exists(), f"Image {image} not found in train_images folder"
+    for image in new_test["image"]:
+        assert (
+            public / "test_images" / image
+        ).exists(), f"Image {image} not found in test_images folder"
+    assert not set(new_train["image"]).intersection(
+        set(new_test["image"])
+    ), "Train and test ids overlap"

dslighting/registry/hotel-id-2021-fgvc8/prepare_val.py

@@ -0,0 +1,132 @@
+import shutil
+from pathlib import Path
+
+from sklearn.model_selection import train_test_split
+from tqdm.auto import tqdm
+
+from mlebench.utils import read_csv
+
+
+def _create_split(
+    df_to_split,
+    raw_images_base_path: Path,
+    public_path: Path,
+    private_path: Path,
+    test_size: float,
+    random_state: int,
+):
+    """
+    Helper function to perform a data split, create corresponding files, and copy images.
+
+    Args:
+        df_to_split: The DataFrame to be split into train and test sets.
+        raw_images_base_path: Path to the directory containing the original images.
+        public_path: The public output directory for this split.
+        private_path: The private output directory for this split.
+        test_size: The proportion of the dataset to allocate to the test split.
+        random_state: The seed used by the random number generator.
+    """
+    # Create output directories
+    public_path.mkdir(exist_ok=True, parents=True)
+    private_path.mkdir(exist_ok=True, parents=True)
+
+    # Perform the split
+    new_train, new_test = train_test_split(
+        df_to_split, test_size=test_size, random_state=random_state
+    )
+    sample_submission = new_test.copy()[["image", "hotel_id"]]
+    sample_submission["hotel_id"] = "36363 53586 18807 64314 60181"
+
+    # Save public files
+    new_train.to_csv(public_path / "train.csv", index=False)
+    sample_submission.to_csv(public_path / "sample_submission.csv", index=False)
+
+    # Copy images from raw to prepared/public accordingly
+    (public_path / "train_images").mkdir(exist_ok=True, parents=True)
+    for image, chain in tqdm(
+        zip(new_train["image"], new_train["chain"]),
+        total=len(new_train),
+        desc=f"Train images for {public_path.name}",
+    ):
+        chain = str(chain)
+        (public_path / "train_images" / chain).mkdir(exist_ok=True, parents=True)
+        shutil.copy(
+            raw_images_base_path / chain / image,
+            public_path / "train_images" / chain / image,
+        )
+
+    (public_path / "test_images").mkdir(exist_ok=True, parents=True)
+    for image, chain in tqdm(
+        zip(new_test["image"], new_test["chain"]),
+        total=len(new_test),
+        desc=f"Test images for {public_path.name}",
+    ):
+        chain = str(chain)
+        # Note: Test images are copied to a flat directory structure
+        shutil.copy(raw_images_base_path / chain / image, public_path / "test_images" / image)
+
+    # Save private files
+    new_test.to_csv(private_path / "test.csv", index=False)
+
+    # Checks
+    assert len(new_train) + len(new_test) == len(
+        df_to_split
+    ), "Length of new_train and new_test should equal length of input dataframe"
+    assert sample_submission.columns.to_list() == [
+        "image",
+        "hotel_id",
+    ], "Sample submission columns should only be `image` and `hotel_id`"
+    assert len(sample_submission) == len(new_test), "Sample submission length should match test set"
+    for image, chain in zip(new_train["image"], new_train["chain"]):
+        chain = str(chain)
+        assert (
+            public_path / "train_images" / chain / image
+        ).exists(), f"Image {image} not found in train_images folder"
+    for image in new_test["image"]:
+        assert (
+            public_path / "test_images" / image
+        ).exists(), f"Image {image} not found in test_images folder"
+    assert not set(new_train["image"]).intersection(
+        set(new_test["image"])
+    ), "Train and test ids overlap"
+
+    return new_train, new_test
+
+
+def prepare(raw: Path, public: Path, private: Path):
+    old_train = read_csv(raw / "train.csv")
+    # drop image ce27d36c9147cc19.jpg: it appears twice and may occur across train and test when split
+    old_train = old_train[old_train["image"] != "ce27d36c9147cc19.jpg"]
+
+    # --- First Split (Original Public/Private) ---
+    # This split produces the main benchmark data. The outputs in `public` and `private`
+    # will be identical to the original script's output.
+    original_train_df, _ = _create_split(
+        df_to_split=old_train,
+        raw_images_base_path=raw / "train_images",
+        public_path=public,
+        private_path=private,
+        test_size=0.1,
+        random_state=0,
+    )
+
+    # --- Second Split (New Validation Set) ---
+    # This split takes the training data from the first split (`original_train_df`) and
+    # splits it again to create a new, smaller training set and a validation set.
+    # The results are saved in parallel `public_val` and `private_val` directories.
+    public_val = public.parent / "public_val"
+    private_val = private.parent / "private_val"
+
+    # The test size is 1/9 because we want the new validation set to be roughly the
+    # same size as the original test set (10% of the total data).
+    # original_train_df is 90% of the total, so 1/9 of it is 10% of the total.
+    test_size_for_val_split = 1 / 9
+
+    _create_split(
+        df_to_split=original_train_df,
+        raw_images_base_path=raw / "train_images",
+        public_path=public_val,
+        private_path=private_val,
+        test_size=test_size_for_val_split,
+        random_state=0,  # Use same random state for consistency and determinism
+    )

dslighting/registry/hubmap-kidney-segmentation/checksums.yaml

@@ -0,0 +1,8 @@
+private:
+  gold_submission.csv: 04e4a0b5efa7d41491a1cdd01990b507
+  test.csv: 17d0985b7ced8c4e23fee515af8e381f
+public:
+  HuBMAP-20-dataset_information.csv: 6a19818d50bb232dbe51fbc375bc89cb
+  sample_submission.csv: 135a2b41c9aa16f03880908a7171dc28
+  train.csv: a5760de09c0fcc1f78a32bb8f6459f45
+zip: 3c3cba984d64b78ccf2f747d02f7178b

dslighting/registry/hubmap-kidney-segmentation/config.yaml

@@ -0,0 +1,29 @@
+id: hubmap-kidney-segmentation
+name: HuBMAP - Hacking the Kidney
+competition_type: code
+awards_medals: true
+prizes:
+  - position: Accuracy Prize 1
+    value: 18000
+  - position: Accuracy Prize 2
+    value: 10000
+  - position: Accuracy Prize 3
+    value: 4000
+  - position: Scientific Prize
+    value: 15000
+  - position: Innovation Prize
+    value: 10000
+  - position: Diversity Prize
+    value: 3000
+description: mlebench/competitions/hubmap-kidney-segmentation/description.md
+
+dataset:
+  answers: hubmap-kidney-segmentation/prepared/private/test.csv
+  gold_submission: hubmap-kidney-segmentation/prepared/private/gold_submission.csv
+  sample_submission: hubmap-kidney-segmentation/prepared/public/sample_submission.csv
+
+grader:
+  name: dice-coefficient
+  grade_fn: mlebench.competitions.hubmap-kidney-segmentation.grade:grade
+
+preparer: mlebench.competitions.hubmap-kidney-segmentation.prepare:prepare

dslighting/registry/hubmap-kidney-segmentation/description.md

@@ -0,0 +1,211 @@
+# Overview
+
+## Overview
+
+Start
+
+Nov 16, 2020
+
+Close
+
+May 11, 2021
+
+### Description
+
+Our best estimates show there are over 7 billion people on the planet and 300 billion stars in the Milky Way galaxy. By comparison, the adult human body contains 37 *trillion* cells. To determine the function and relationship among these cells is a monumental undertaking. Many areas of human health would be impacted if we better understand cellular activity. A problem with this much data is a great match for the Kaggle community.
+
+Just as the Human Genome Project mapped the entirety of human DNA, the [Human BioMolecular Atlas Program](https://hubmapconsortium.org/) (HuBMAP) is a major endeavor. Sponsored by the National Institutes of Health (NIH), HuBMAP is working to catalyze the development of a framework for mapping the human body at a level of glomeruli functional tissue units for the first time in history. Hoping to become one of the world's largest collaborative biological projects, HuBMAP aims to be an open map of the human body at the cellular level.
+
+This competition, "Hacking the Kidney," starts by mapping the human kidney at single cell resolution.
+
+Your challenge is to detect functional tissue units (FTUs) across different tissue preparation pipelines. An FTU is defined as a "three-dimensional block of cells centered around a capillary, such that each cell in this block is within diffusion distance from any other cell in the same block" ([de Bono, 2013](https://www.ncbi.nlm.nih.gov/pubmed/24103658)). The goal of this competition is the implementation of a successful and robust glomeruli FTU detector.
+
+You will also have the opportunity to present your findings to a panel of judges for additional consideration. Successful submissions will construct the tools, resources, and cell atlases needed to determine how the relationships between cells can affect the health of an individual.
+
+Advancements in HuBMAP will accelerate the world's understanding of the relationships between cell and tissue organization and function and human health. These datasets and insights can be used by researchers in cell and tissue anatomy, pharmaceutical companies to develop therapies, or even parents to show their children the magnitude of the human body.
+
+> This is a Code Competition. Refer to [Code Requirements](https://www.kaggle.com/c/hubmap-kidney-segmentation/overview/code-requirements) for details.
+
+### Supervised ML Evaluation
+
+This competition is evaluated on the mean [Dice coefficient](https://en.wikipedia.org/wiki/S%C3%B8rensen%E2%80%93Dice_coefficient). The Dice coefficient can be used to compare the pixel-wise agreement between a predicted segmentation and its corresponding ground truth. The formula is given by:
+
+$$
+\frac{2 *|X \cap Y|}{|X|+|Y|},
+$$
+
+where $X$ is the predicted set of pixels and $Y$ is the ground truth. The Dice coefficient is defined to be 1 when both $X$ and $Y$ are empty. The leaderboard score is the mean of the Dice coefficients for each image in the test set.
+
+#### Submission File
+
+In order to reduce the submission file size, our metric uses run-length encoding on the pixel values.  Instead of submitting an exhaustive list of indices for your segmentation, you will submit pairs of values that contain a start position and a run length. E.g. '1 3' implies starting at pixel 1 and running a total of 3 pixels (1,2,3).
+
+Note that, at the time of encoding, the mask should be binary, meaning the masks for all objects in an image are joined into a single large mask. A value of 0 should indicate pixels that are not masked, and a value of 1 will indicate pixels that are masked.
+
+The competition format requires a space delimited list of pairs. For example, '1 3 10 5' implies pixels 1,2,3,10,11,12,13,14 are to be included in the mask. The metric checks that the pairs are sorted, positive, and the decoded pixel values are not duplicated. The pixels are numbered from top to bottom, then left to right: 1 is pixel (1,1), 2 is pixel (2,1), etc.
+
+The file should contain a header and have the following format:
+
+```
+img,pixels\
+1,1 1 5 1\
+2,1 1\
+3,1 1\
+etc.
+```
+
+### Judges Prize
+
+Participants in this challenge will also have the opportunity to win prize money through the presentation of their submission. After entering the competition, participants can also elect to submit a presentation of their results for review by judges drawn from industry, academia, and government. Top selected submissions will have the opportunity to make a presentation to the judges panel to be evaluated on the below criteria.
+
+Methodology (50 points) [Scientific Prize]
+
+-   Are the statistical and modeling methods used to identify glomeruli in the PAS stained microscopy data appropriate for the task?
+-   Are confidence scores and other metrics provided that help interpret the results achieved by the modeling methods?
+-   Did the team validate their methods and algorithm implementations and provide information on algorithm performance and limitations?
+-   Did the team provide any evidence that their method generalizes beyond this immediate task, for example to other FTUs such as alveoli in lungs or crypts in colon?
+-   Did the team document their method and code appropriately?
+
+Innovation and Applications (30 points) [Innovation Prize]
+
+-   Did the team develop a creative or novel method to segment glomeruli?
+-   Is the presented characterization of glomeruli useful for understanding individual differences, e.g., the impact of donor sex, age, or weight on the size, shape, or spatial distribution of glomeruli?
+-   Did the team provide insights that would be useful for generating reference glomeruli for inclusion into a Human Reference Atlas?
+
+Diversity and Presentation (30 points) [Diversity Prize]
+
+-   Does the team embrace diversity and equity, welcoming team members of different ages, genders, ethnicities, and with multiple backgrounds and perspectives?
+-   Did the authors effectively communicate the details of their method for segmenting glomeruli, and the quality and limitations of their results? For example, did they use data visualizations to present algorithm setup, run, results and/or to provide insight into the comparative performance of different methods? Were these visualizations effective at communicating insights about their approach and results?
+-   Are the important results easily understood by the average person?
+
+### Submission Instructions
+
+You can make as many submissions as you like, but we will only consider your latest submission before the deadline of May 10.
+
+All team members must be listed as collaborators on the submitted Notebook, and all team members must accept the competition rules before the submission deadline.
+
+A valid submission will include:
+
+*Notebook Analysis*: At least one notebook containing the analysis to support your proposal. All notebooks submitted must be made public on or before the submission deadline to be eligible. If submitting as a team, all team members must be listed as collaborators on all notebooks submitted.
+
+Click [here](https://www.kaggle.com/hacking-the-kidney-judges-prize) to go to the Submission form
+
+### Prizes
+
+Accuracy Prize:
+
+\$32,000 will be awarded to the three teams with the highest scores on the Kaggle Leaderboard at the conclusion of the competition:
+
+-   First Place: \$18,000
+-   Second Place: \$10,000
+-   Third Place: \$4,000
+
+Judges Prize:
+
+\$28,000 will be awarded to teams that advance science and/or technology, are most innovative, and/or diverse as identified by the panel of judges through a presentation of their findings.
+
+-   Scientific Prize: \$15,000
+-   Innovation Prize: \$10,000
+-   Diversity Prize: \$3,000
+
+Teams can enter and win in multiple categories. Winning teams will receive cash prizes. If desired, teams can choose to have their winnings donated to a charity foundation.
+
+### Timeline
+
+*Updated March 9, 2021:*
+
+-   May 3, 2021 - Entry deadline. You must accept the competition rules before this date in order to compete.
+
+-   May 3, 2021 - Team Merger deadline. This is the last day participants may join or merge teams.
+
+-   May 10, 2021 - Final submission deadline.
+
+-   May 17, 2021 -- Selected teams present their solutions to Judges.
+
+-   May 21, 2021  -- Judges announce winning teams at event with sponsors, participants, judges, organizers.
+
+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.
+
+### Organizers & Sponsors
+
+The HuBMAP MC-IU team works in close collaboration with the HuBMAP HIVE teams and TMC-VU.
+
+![Organizers](https://storage.googleapis.com/kaggle-media/competitions/InnovDigi/Screen%20Shot%202020-11-16%20at%203.57.12%20PM.png)
+
+![Judges](https://storage.googleapis.com/kaggle-media/competitions/InnovDigi/Screen%20Shot%202020-11-05%20at%2012.08.58%20AM.png)
+
+![Support](https://storage.googleapis.com/kaggle-media/competitions/InnovDigi/Screen%20Shot%202020-11-05%20at%2012.09.04%20AM.png)
+
+#### Innovation Sponsors
+
+![Google](https://storage.googleapis.com/kaggle-media/competitions/InnovDigi/Google.png)
+
+![Roche](https://storage.googleapis.com/kaggle-media/competitions/InnovDigi/Roche.png)
+
+![Deloitte](https://storage.googleapis.com/kaggle-media/competitions/InnovDigi/Deloitte.png)
+
+![Deerfield](https://storage.googleapis.com/kaggle-media/competitions/InnovDigi/deerfield-logo-white.png)
+
+#### Cyber Sponsors
+
+![Pistoia](https://storage.googleapis.com/kaggle-media/competitions/InnovDigi/Pistoia.png)
+
+![CAS](https://storage.googleapis.com/kaggle-media/competitions/InnovDigi/CAS.png)
+
+![Mavenware](https://storage.googleapis.com/kaggle-media/competitions/InnovDigi/Mavenware.png)
+
+### Code Requirements
+
+![Kerneler](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. Please note that for this competition training is not required in Notebooks.
+
+In order for the "Submit to Competition" 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
+-   [TPUs](https://www.kaggle.com/docs/tpu) will not be available for making submissions to this competition. You are still welcome to use them for training models. A walk-through for how to train on TPUs and run inference/submit on GPUs, see our [TPU Docs](https://www.kaggle.com/docs/tpu#tpu6).
+-   No internet access enabled on submission
+-   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#kernels-only-FAQ) for more information on how to submit.
+
+### Citation
+
+Addison Howard, Andy Lawrence, Bud Sims, Eddie Tinsley, Jarek Kazmierczak, Katy Borner, Leah Godwin, Marcos Novaes, Phil Culliton, Richard Holland, Rick Watson, Yingnan Ju. (2020). HuBMAP - Hacking the Kidney. Kaggle. https://kaggle.com/competitions/hubmap-kidney-segmentation
+
+# Data
+
+## Dataset Description
+
+The HuBMAP data used in this hackathon includes 11 fresh frozen and 9 Formalin Fixed Paraffin Embedded (FFPE) PAS kidney images. Glomeruli FTU annotations exist for all 20 tissue samples; some of these will be shared for training, and others will be used to judge submissions.
+
+There are over 600,000 glomeruli in each human kidney ([Nyengaard, 1992](https://onlinelibrary.wiley.com/doi/abs/10.1002/ar.1092320205)). Normal glomeruli typically range from 100-350μm in diameter with a roughly spherical shape ([Kannan, 2019](https://www.kireports.org/article/S2468-0249(19)30155-X/abstract)).
+
+Teams are invited to develop segmentation algorithms that identify glomeruli in the PAS stained microscopy data. They are welcome to use other external data and/or pre-trained machine learning models in support of FTU segmentation. All data and all code used must be released under [Attribution 4.0 International (CC BY 4.0)](https://creativecommons.org/licenses/by/4.0/).
+
+### The Dataset
+
+The dataset is comprised of very large (>500MB - 5GB) TIFF files. The training set has 8, and the public test set has 5. The private test set is larger than the public test set.
+
+The training set includes annotations in both RLE-encoded and unencoded (JSON) forms. The annotations denote segmentations of glomeruli.
+
+Both the training and public test sets also include anatomical structure segmentations. They are intended to help you identify the various parts of the tissue.
+
+### File structure
+
+The JSON files are structured as follows, with each feature having:
+
+-   A `type` (`Feature`) and object type `id` (`PathAnnotationObject`). Note that these fields are the same between all files and do not offer signal.
+-   A `geometry` containing a `Polygon` with `coordinates` for the feature's enclosing volume
+-   Additional `properties`, including the name and color of the feature in the image.
+-   The `IsLocked` field is the same across file types (locked for glomerulus, unlocked for anatomical structure) and is not signal-bearing.
+
+Note that the objects themselves do NOT have unique IDs. The expected prediction for a given image is an RLE-encoded mask containing ALL objects in the image. The mask, as mentioned in the Evaluation page, should be binary when encoded - with `0` indicating the lack of a masked pixel, and `1` indicating a masked pixel.
+
+`train.csv` contains the unique IDs for each image, as well as an RLE-encoded representation of the mask for the objects in the image. See the evaluation tab for details of the RLE encoding scheme.
+
+`HuBMAP-20-dataset_information.csv` contains additional information (including anonymized patient data) about each image.

dslighting/registry/hubmap-kidney-segmentation/description_obfuscated.md

@@ -0,0 +1,46 @@
+# Task
+
+Detect functional tissue units (FTUs) across different tissue preparation pipelines. An FTU is defined as a "three-dimensional block of cells centered around a capillary, such that each cell in this block is within diffusion distance from any other cell in the same block".
+
+# Metric
+
+Dice coefficient.
+
+# Submission Format
+
+Use run-length encoding on the pixel values. Submit pairs of values that contain a start position and a run length. E.g. '1 3' implies starting at pixel 1 and running a total of 3 pixels (1,2,3).
+
+Note that, at the time of encoding, the mask should be binary, meaning the masks for all objects in an image are joined into a single large mask. A value of 0 should indicate pixels that are not masked, and a value of 1 will indicate pixels that are masked.
+
+The pixels are numbered from top to bottom, then left to right: 1 is pixel (1,1), 2 is pixel (2,1), etc.
+
+The file should contain a header and have the following format:
+
+```
+img,pixels\
+1,1 1 5 1\
+2,1 1\
+3,1 1\
+etc.
+```
+
+# Dataset
+
+The training set includes annotations in both RLE-encoded and unencoded (JSON) forms. The annotations denote segmentations of glomeruli.
+
+Both the training and public test sets also include anatomical structure segmentations. They are intended to help you identify the various parts of the tissue.
+
+## File structure
+
+The JSON files are structured as follows, with each feature having:
+
+-   A `type` (`Feature`) and object type `id` (`PathAnnotationObject`). Note that these fields are the same between all files and do not offer signal.
+-   A `geometry` containing a `Polygon` with `coordinates` for the feature's enclosing volume
+-   Additional `properties`, including the name and color of the feature in the image.
+-   The `IsLocked` field is the same across file types (locked for glomerulus, unlocked for anatomical structure) and is not signal-bearing.
+
+Note that the objects themselves do NOT have unique IDs. The expected prediction for a given image is an RLE-encoded mask containing ALL objects in the image. The mask, as mentioned in the Evaluation page, should be binary when encoded - with `0` indicating the lack of a masked pixel, and `1` indicating a masked pixel.
+
+`train.csv` contains the unique IDs for each image, as well as an RLE-encoded representation of the mask for the objects in the image.
+
+`HuBMAP-20-dataset_information.csv` contains additional information (including anonymized patient data) about each image.

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

@@ -0,0 +1,62 @@
+import numpy as np
+import pandas as pd
+from tqdm.auto import tqdm
+
+from mlebench.competitions.utils import rles_to_masks
+from mlebench.grade_helpers import InvalidSubmissionError
+from mlebench.metrics import dice_coefficient
+
+
+def prepare_for_metric(
+    submission: pd.DataFrame, answers: pd.DataFrame
+) -> tuple[list[np.ndarray], list[np.ndarray]]:
+    id_col = "id"
+
+    if id_col not in submission.columns:
+        raise InvalidSubmissionError(f"Submission is missing the '{id_col}' column")
+    if "predicted" not in submission.columns:
+        raise InvalidSubmissionError("Submission is missing the 'predicted' column")
+
+    assert id_col in answers.columns, f"Answers is missing the '{id_col}' column"
+    assert "encoding" in answers.columns, "Answers is missing the 'encoded' column"
+    assert "width_pixels" in answers.columns, "Answers is missing the 'width_pixels' column"
+    assert "height_pixels" in answers.columns, "Answers is missing the 'height_pixels' column"
+
+    if len(submission) != len(answers):
+        raise InvalidSubmissionError(
+            f"Submission has {len(submission)} rows while answers has {len(answers)} rows"
+        )
+
+    if set(submission[id_col]) != set(answers[id_col]):
+        raise InvalidSubmissionError(f"Submission and answers have different {id_col} values")
+
+    submission = submission.sort_values(id_col).reset_index(drop=True)
+    answers = answers.sort_values(id_col).reset_index(drop=True)
+
+    # pandas reads empty cells as nan, we mark them as empty RLE strings
+    submission["predicted"] = submission["predicted"].fillna("")
+    submission["answers"] = submission["predicted"].fillna("")
+
+    image_heights = answers["height_pixels"].tolist()
+    image_widths = answers["width_pixels"].tolist()
+
+    prediced_masks = rles_to_masks(submission["predicted"].to_list(), image_heights, image_widths)
+    true_masks = rles_to_masks(answers["encoding"], image_heights, image_widths)
+
+    return prediced_masks, true_masks
+
+
+def grade(submission: pd.DataFrame, answers: pd.DataFrame) -> float:
+    """
+    Computes the mean dice coefficient for the submission and answers.
+    """
+    predicted_masks, true_masks = prepare_for_metric(submission, answers)
+
+    return np.mean(
+        [
+            dice_coefficient(predicted_mask, true_mask, both_empty_value=1.0)
+            for predicted_mask, true_mask in tqdm(
+                zip(predicted_masks, true_masks), total=len(predicted_masks)
+            )
+        ]
+    )

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

@@ -0,0 +1,108 @@
+import shutil
+from pathlib import Path
+
+from sklearn.model_selection import train_test_split
+from tqdm.auto import tqdm
+
+from mlebench.utils import read_csv
+
+
+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")
+
+    new_train, new_test = train_test_split(old_train, train_size=12, test_size=3, random_state=0)
+    # dataset info doesnt have an id column, so quickly add it so that we can filter out old test
+    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"])]
+    # put height and width in new_test, for grading
+    new_test = new_test.merge(dataset_info[["id", "width_pixels", "height_pixels"]], on="id")
+    dataset_info = dataset_info.drop(columns=["id"], inplace=False)
+
+    dataset_info.to_csv(public / "HuBMAP-20-dataset_information.csv", index=False)
+    new_train.to_csv(public / "train.csv", index=False)
+    new_test.to_csv(private / "test.csv", index=False)
+
+    sample_submission = new_test[["id"]].copy()
+    sample_submission["predicted"] = ""
+    sample_submission.to_csv(public / "sample_submission.csv", index=False)
+
+    # basically the same as new_test but with a different column name
+    gold_submission = sample_submission.copy()
+    gold_submission["predicted"] = new_test["encoding"]
+    gold_submission.to_csv(private / "gold_submission.csv", index=False)
+
+    (public / "train").mkdir(parents=True, exist_ok=True)
+    for image_id in tqdm(new_train["id"], desc="Copying train images"):
+        shutil.copy(raw / "train" / f"{image_id}.tiff", public / "train" / f"{image_id}.tiff")
+        shutil.copy(raw / "train" / f"{image_id}.json", public / "train" / f"{image_id}.json")
+        shutil.copy(
+            raw / "train" / f"{image_id}-anatomical-structure.json",
+            public / "train" / f"{image_id}-anatomical-structure.json",
+        )
+
+    (public / "test").mkdir(parents=True, exist_ok=True)
+    for image_id in tqdm(new_test["id"], desc="Copying test images"):
+        shutil.copy(raw / "train" / f"{image_id}.tiff", public / "test" / f"{image_id}.tiff")
+        shutil.copy(raw / "train" / f"{image_id}.json", public / "test" / f"{image_id}.json")
+        shutil.copy(
+            raw / "train" / f"{image_id}-anatomical-structure.json",
+            public / "test" / f"{image_id}-anatomical-structure.json",
+        )
+
+    # for some reason sample_submission.csv is also in test/
+    shutil.copy(public / "sample_submission.csv", public / "test" / "sample_submission.csv")
+
+    # Checks
+    assert len(new_train) + len(new_test) == len(
+        old_train
+    ), "Length of new_train and new_test should equal length of old_train"
+
+    assert new_train.columns.to_list() == [
+        "id",
+        "encoding",
+    ], "Public train set should have 2 columns, called 'id' and 'encoding'"
+    assert new_test.columns.to_list() == [
+        "id",
+        "encoding",
+        "width_pixels",
+        "height_pixels",
+    ], "Private test set should have 2 columns called 'id' and 'encoding'"
+
+    assert len(sample_submission) == len(new_test), "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(new_test), "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(
+        new_test["encoding"]
+    ), "Gold submission should match private test set"
+
+    # assert no overlap in ids between train and test
+    assert set(new_train["id"]).isdisjoint(
+        set(new_test["id"])
+    ), "Train and test ids should not overlap"
+
+    # check that the images are copied correctly
+    assert len(list((public / "train").glob("*.tiff"))) == len(
+        new_train
+    ), "Missing train tiff files"
+    assert len(list((public / "train").glob("*-anatomical-structure.json"))) == len(
+        new_train
+    ), "Missing train structure json files"
+    assert (
+        len(list((public / "train").glob("*.json"))) == len(new_train) * 2
+    ), "Missing train json files"
+
+    assert len(list((public / "test").glob("*.tiff"))) == len(new_test), "Missing test tiff files"
+    assert len(list((public / "test").glob("*-anatomical-structure.json"))) == len(
+        new_test
+    ), "Missing test structure json files"