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

dslighting/registry/google-quest-challenge/prepare.py

@@ -0,0 +1,58 @@
+from pathlib import Path
+
+import numpy as np
+from sklearn.model_selection import train_test_split
+
+from mlebench.utils import read_csv
+
+from .classes import CLASSES
+
+
+def prepare(raw: Path, public: Path, private: Path):
+
+    # Create train and test splits from train set
+    old_train = read_csv(raw / "train.csv")
+    new_train, new_test = train_test_split(old_train, test_size=0.1, random_state=0)
+
+    # question_type_spelling is almost always 0; if entirely 0 in test set, swap one row
+    if new_test["question_type_spelling"].nunique() == 1:
+        # need to do this swapping because spearmanr needs variation in the data to work
+        suitable_train_row_index = new_train[new_train["question_type_spelling"] != 0].index[0]
+        suitable_test_row_index = 0
+        temp = new_test.iloc[suitable_test_row_index].copy()
+        new_test.iloc[suitable_test_row_index] = new_train.loc[suitable_train_row_index].copy()
+        new_train.loc[suitable_train_row_index] = temp
+
+    new_test_without_labels = new_test.drop(CLASSES, axis=1, inplace=False)
+
+    # Create sample submission; private test will match this format
+    cols_to_keep = ["qa_id"] + CLASSES
+    new_test = new_test[cols_to_keep]
+    sample_submission = new_test.copy()
+    # spearmanr needs variation in the data to work; make each column increasing from 0 to 1
+    n, M = len(sample_submission), len(CLASSES)
+    sample_submission[CLASSES] = np.tile(np.linspace(0, 1, n)[:, None], (1, M))
+
+    # Create private files
+    new_test.to_csv(private / "test.csv", index=False)
+
+    # Create public files visible to agents
+    new_train.to_csv(public / "train.csv", index=False)
+    new_test_without_labels.to_csv(public / "test.csv", index=False)
+    sample_submission.to_csv(public / "sample_submission.csv", index=False)
+
+    # Checks
+    assert new_test_without_labels.shape[1] == 11, "Public test set should have 11 columns"
+    assert new_train.shape[1] == 41, "Public train set should have 41 columns"
+    # each private test set target column should not be constant
+    for column in CLASSES:
+        assert (
+            new_test[column].nunique() > 1
+        ), f"Column {column} should not be constant in the private test set"
+    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() == new_test.columns.to_list()
+    ), "Sample submission columns should match test set"
+    assert len(sample_submission) == len(new_test), "Sample submission length should match test set"

dslighting/registry/google-quest-challenge/prepare_val.py

@@ -0,0 +1,120 @@
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+from sklearn.model_selection import train_test_split
+
+from mlebench.utils import read_csv
+
+from .classes import CLASSES
+
+
+def _create_split_and_write_files(
+    source_df: pd.DataFrame,
+    public_dir: Path,
+    private_dir: Path,
+    test_size: float,
+    random_state: int,
+):
+    """
+    Splits a dataframe into train and test sets, and writes them to public and private directories.
+
+    This function encapsulates the core data preparation logic:
+    1. Splits the data.
+    2. Handles a special case for 'question_type_spelling' to ensure variability.
+    3. Creates public-facing test set (without labels) and a sample submission.
+    4. Creates private-facing test set (with labels).
+    5. Writes all files to the specified directories.
+    6. Performs assertions to validate the output.
+    """
+    # Create output directories if they don't exist
+    public_dir.mkdir(parents=True, exist_ok=True)
+    private_dir.mkdir(parents=True, exist_ok=True)
+
+    # Create train and test splits from the source dataframe
+    train_df, test_df = train_test_split(
+        source_df, test_size=test_size, random_state=random_state
+    )
+
+    # question_type_spelling is almost always 0; if entirely 0 in test set, swap one row
+    if test_df["question_type_spelling"].nunique() == 1:
+        # need to do this swapping because spearmanr needs variation in the data to work
+        suitable_train_row_index = train_df[train_df["question_type_spelling"] != 0].index[0]
+        suitable_test_row_index = test_df.index[0]
+        temp = test_df.loc[suitable_test_row_index].copy()
+        test_df.loc[suitable_test_row_index] = train_df.loc[suitable_train_row_index].copy()
+        train_df.loc[suitable_train_row_index] = temp
+
+    test_df_without_labels = test_df.drop(CLASSES, axis=1, inplace=False)
+
+    # Create sample submission; private test will match this format
+    cols_to_keep = ["qa_id"] + CLASSES
+    test_labels = test_df[cols_to_keep]
+    sample_submission = test_labels.copy()
+    # spearmanr needs variation in the data to work; make each column increasing from 0 to 1
+    n, M = len(sample_submission), len(CLASSES)
+    sample_submission[CLASSES] = np.tile(np.linspace(0, 1, n)[:, None], (1, M))
+
+    # Create private files
+    test_labels.to_csv(private_dir / "test.csv", index=False)
+
+    # Create public files visible to agents
+    train_df.to_csv(public_dir / "train.csv", index=False)
+    test_df_without_labels.to_csv(public_dir / "test.csv", index=False)
+    sample_submission.to_csv(public_dir / "sample_submission.csv", index=False)
+
+    # Checks
+    assert test_df_without_labels.shape[1] == 11, "Public test set should have 11 columns"
+    assert train_df.shape[1] == 41, "Public train set should have 41 columns"
+    # each private test set target column should not be constant
+    for column in CLASSES:
+        assert (
+            test_labels[column].nunique() > 1
+        ), f"Column {column} should not be constant in the private test set"
+    assert len(train_df) + len(test_df) == len(
+        source_df
+    ), "Length of new_train and new_test should equal length of source_df"
+    assert (
+        sample_submission.columns.to_list() == test_labels.columns.to_list()
+    ), "Sample submission columns should match test set"
+    assert len(sample_submission) == len(test_labels), "Sample submission length should match test set"
+
+    return train_df, test_df
+
+
+def prepare(raw: Path, public: Path, private: Path):
+
+    # Load the raw data from the competition
+    source_data = read_csv(raw / "train.csv")
+
+    # ---- 1. Create the Original Main Split (train/test) ----
+    # This first call generates the primary train and test sets.
+    # The output files are saved to the `public` and `private` directories,
+    # remaining identical to the original script's output.
+    main_train, main_test = _create_split_and_write_files(
+        source_df=source_data,
+        public_dir=public,
+        private_dir=private,
+        test_size=0.1,
+        random_state=0,
+    )
+
+    # ---- 2. Create the New Validation Split (train_val/test_val) ----
+    # This second call takes the `main_train` set from the first split and
+    # splits it again to create a new, smaller training set and a validation set.
+    # The outputs are saved to new, parallel `public_val` and `private_val` dirs.
+    public_val_dir = public.parent / "public_val"
+    private_val_dir = private.parent / "private_val"
+
+    # To make the new validation set (`test_val`) have the same number of samples
+    # as the original test set (`main_test`), we calculate the required `test_size`
+    # relative to the size of the `main_train` dataframe.
+    validation_test_size = len(main_test) / len(main_train)
+
+    _create_split_and_write_files(
+        source_df=main_train,
+        public_dir=public_val_dir,
+        private_dir=private_val_dir,
+        test_size=validation_test_size,
+        random_state=0,  # Use the same random state for consistency
+    )

dslighting/registry/google-research-identify-contrails-reduce-global-warming/checksums.yaml

@@ -0,0 +1,7 @@
+private:
+  answers.csv: 19bcf4d920a7b6edb1ce5bbda2299437
+public:
+  sample_submission.csv: 76f1e9892ad523bd23909fd41bc47734
+  train_metadata.json: c1904919eceebb2ff92e05e384e52eba
+  validation_metadata.json: fbba4a0196aecfea9749f347a407519d
+zip: 55480a1ef98fd61becf36d8608ffeb74

dslighting/registry/google-research-identify-contrails-reduce-global-warming/config.yaml

@@ -0,0 +1,28 @@
+id: google-research-identify-contrails-reduce-global-warming
+name: Google Research - Identify Contrails to Reduce Global Warming
+competition_type: code
+awards_medals: true
+prizes:
+  - position: 1
+    value: 15000
+  - position: 2
+    value: 10000
+  - position: 3
+    value: 8000
+  - position: 4
+    value: 7000
+  - position: 5
+    value: 5000
+  - position: 6
+    value: 5000
+description: mlebench/competitions/google-research-identify-contrails-reduce-global-warming/description.md
+
+dataset:
+  answers: google-research-identify-contrails-reduce-global-warming/prepared/private/answers.csv
+  sample_submission: google-research-identify-contrails-reduce-global-warming/prepared/public/sample_submission.csv
+
+grader:
+  name: global-dice
+  grade_fn: mlebench.competitions.google-research-identify-contrails-reduce-global-warming.grade:grade
+
+preparer: mlebench.competitions.google-research-identify-contrails-reduce-global-warming.prepare:prepare

dslighting/registry/google-research-identify-contrails-reduce-global-warming/description.md

@@ -0,0 +1,129 @@
+# Overview
+
+## Description
+
+### Goal of the Competition
+
+Contrails are clouds of ice crystals that form in aircraft engine exhaust. They can contribute to global warming by trapping heat in the atmosphere. Researchers have developed models to predict when contrails will form and how much warming they will cause. However, they need to validate these models with satellite imagery.  
+
+Your work will help researchers improve the accuracy of their contrail models. This will help airlines avoid creating contrails and reduce their impact on climate change.
+
+### Context
+
+Contrail avoidance is potentially one of the most scalable, cost-effective sustainability solutions available to airlines today. Contrails, short for ‘condensation trails’, are line-shaped clouds of ice crystals that form in aircraft engine exhaust, and are created by airplanes flying through super humid regions in the atmosphere. Persistent contrails contribute as much to global warming as the fuel they burn for flights. This phenomenon was first figured out 75 years ago by military airplanes with the goal to avoid leaving a visible trail. About 30 years ago, climate scientists in Europe began to understand that the contrails blocked heat that normally is released from the earth overnight. They have built powerful models, based on weather data, to identify when contrails will form and how warming they will be. Their research has been validated by other labs as well and it is now well accepted that contrails contribute approximately 1% of all human caused global warming. The motivation behind the use of satellite imagery is to empirically confirm the predictions from these models. With reliable verification, pilots can have confidence in the models and the airline industry can have a trusted way to measure successful contrail avoidance.  
+
+![](https://storage.googleapis.com/kaggle-media/competitions/Google-Contrails/waterdroplets.png)  
+
+_Image courtesy of Imperial College_  
+
+Your work will quantifiably improve the confidence in prediction of contrail forming regions and the techniques to avoid creating them.  
+
+Google Research applies ML to opportunities to mitigate climate change and adapt to the changes we already see. We have run research projects in fusion energy plasma modeling, wildfire early detection, optimal car routing, and forecasts for climate disasters.
+
+### Acknowledgments
+
+MIT Laboratory for Aviation and the Environment led by MIT Professor Steven Barrett  
+Satellite images are from NOAA GOES-16, see more in [https://www.goes-r.gov/](https://www.goes-r.gov/).  
+
+
+> **This is a Code Competition. Refer to [Code Requirements](https://www.kaggle.com/c/google-research-identify-contrails-reduce-global-warming/overview/code-requirements) for details.**
+## Evaluation
+
+This competition is evaluated on the **global** [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 \cdot |X \cap Y|}{|X| + |Y|}
+$$
+
+where X is the entire set of predicted contrail pixels for **all** observations in the test data and Y is the ground truth set of **all** contrail pixels in the test data.
+
+### 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.
+
+**IMPORTANT:** Empty predictions must be marked with '-' in the submission file. Code to correctly encode and decode run-lengh encoding can be found in this [notebook](https://www.kaggle.com/code/inversion/contrails-rle-submission).
+
+The file should contain a header and have the following format:
+
+```
+record_id,encoded_pixels  
+1000834164244036115,1 1 5 1  
+1002653297254493116,-  
+etc.
+```
+
+## Timeline
+
+- **May 10, 2023** - Start Date.
+
+- **August 2, 2023** - Entry Deadline. You must accept the competition rules before this date in order to compete.
+
+- **August 2, 2023** - Team Merger Deadline. This is the last day participants may join or merge teams.
+
+- **August 9, 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
+
+- 1st Place - $15,000
+- 2nd Place - $10,000
+- 3rd Place - $8,000
+- 4th Place - $7,000
+- 5th Place - $5,000
+- 6th Place - $5,000
+
+## 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.
+
+## Citation
+
+Joe Ng, Carl Elkin, Aaron Sarna, Walter Reade, Maggie Demkin. (2023). Google Research - Identify Contrails to Reduce Global Warming. Kaggle. https://kaggle.com/competitions/google-research-identify-contrails-reduce-global-warming
+
+# Data
+
+## Dataset Description
+
+In this competition you will be using geostationary satellite images to identify aviation contrails. The original satellite images were obtained from the [GOES-16 Advanced Baseline Imager (ABI)](https://www.goes-r.gov/spacesegment/abi.html), which is publicly available on [Google Cloud Storage](https://console.cloud.google.com/storage/browser/gcp-public-data-goes-16/). The original full-disk images were reprojected using bilinear resampling to generate a local scene image. Because contrails are easier to identify with temporal context, a sequence of images at 10-minute intervals are provided. Each example (`record_id`) contains exactly one labeled frame.
+
+Learn more about the dataset from the preprint: [OpenContrails: Benchmarking Contrail Detection on GOES-16 ABI](https://arxiv.org/abs/2304.02122). Labeling instructions can be found at in this [supplementary material](https://storage.googleapis.com/goes_contrails_dataset/20230419/Contrail_Detection_Dataset_Instruction.pdf). Some key labeling guidance:
+
+- Contrails must contain at least 10 pixels
+- At some time in their life, Contrails must be at least 3x longer than they are wide
+- Contrails must either appear suddenly or enter from the sides of the image
+- Contrails should be visible in at least two image
+
+Ground truth was determined by (generally) 4+ different labelers annotating each image. Pixels were considered a contrail when >50% of the labelers annotated it as such. Individual annotations (`human_individual_masks.npy`) as well as the aggregated ground truth annotations (`human_pixel_masks.npy`) are included in the training data. The validation data only includes the aggregated ground truth annotations.
+
+This is an example of labeled contrails. Code to produce images like this can be found in this [notebook](https://www.kaggle.com/code/inversion/visualizing-contrails).
+
+![](https://www.googleapis.com/download/storage/v1/b/kaggle-user-content/o/inbox%2F59561%2F590a0bc76044a4ceb71368cf3b62412e%2Fcontrails_600.png?generation=1683669162469942&alt=media)
+
+## Files
+
+- **train/** - the training set; each folder represents a `record_id` and contains the following data:
+    - **band_{08-16}.npy**: array with size of `H x W x T`, where `T = n_times_before + n_times_after + 1`, representing the number of images in the sequence. There are `n_times_before` and `n_times_after` images before and after the labeled frame respectively. In our dataset all examples have `n_times_before=4` and `n_times_after=3`. Each band represents an infrared channel at different wavelengths and is converted to brightness temperatures based on the calibration parameters. The number in the filename corresponds to the GOES-16 ABI band number. Details of the ABI bands can be found [here](https://www.goes-r.gov/mission/ABI-bands-quick-info.html).
+    - **human_individual_masks.npy**: array with size of `H x W x 1 x R`. Each example is labeled by `R` individual human labelers. `R` is not the same for all samples. The labeled masks have value either 0 or 1 and correspond to the `(n_times_before+1)`-th image in `band_{08-16}.npy`. They are available only in the training set.
+    - **human_pixel_masks.npy**: array with size of `H x W x 1` containing the binary ground truth. A pixel is regarded as contrail pixel in evaluation if it is labeled as contrail by more than half of the labelers.
+- **validation/** - the same as the training set, without the individual label annotations; it is permitted to use this as training data if desired
+- **test/** - the test set; your objective is to identify contrails found in these records. **Note:** Since this is a Code competition, you do not have access to the actual test set that your notebook is rerun against. The records shown here are copies of the first two records of the validation data (without the labels). The hidden test set is approximately the same size (± 5%) as the validation set. **IMPORTANT:** Submissions should use run-length encoding with empty predictions (e.g., no contrails) should be marked by `'-'` in the submission. (See this [notebook](https://www.kaggle.com/code/inversion/contrails-rle-submission) for details.)
+- **{train|validation}_metadata.json** - metadata information for each record; contains the timestamps and the projection parameters to reproduce the satellite images.
+- **sample_submission.csv** - a sample submission file in the correct format

dslighting/registry/google-research-identify-contrails-reduce-global-warming/description_obfuscated.md

@@ -0,0 +1,51 @@
+# Task
+
+Identify contrails in satellite imagery.
+
+# Metric
+
+Global Dice coefficient. The Dice coefficient formula is given by:
+
+$$
+\frac{2 \cdot |X \cap Y|}{|X| + |Y|}
+$$
+
+where X is the entire set of predicted contrail pixels for all observations in the test data and Y is the ground truth set of all contrail pixels in the test data.
+
+# Submission Format
+
+Use run-length encoding. For example, '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.
+
+Use 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.
+
+Empty predictions must be marked with '-' in the submission file.
+
+The file should contain a header and have the following format:
+
+```
+record_id,encoded_pixels  
+1000834164244036115,1 1 5 1  
+1002653297254493116,-  
+etc.
+```
+
+# Dataset 
+
+Some key labeling guidance:
+- Contrails must contain at least 10 pixels
+- At some time in their life, Contrails must be at least 3x longer than they are wide
+- Contrails must either appear suddenly or enter from the sides of the image
+- Contrails should be visible in at least two image
+
+A sequence of images at 10-minute intervals are provided. Each example (`record_id`) contains exactly one labeled frame.
+
+- **train/** - the training set; each folder represents a `record_id` and contains the following data:
+    - **band_{08-16}.npy**: array with size of `H x W x T`, where `T = n_times_before + n_times_after + 1`, representing the number of images in the sequence. There are `n_times_before` and `n_times_after` images before and after the labeled frame respectively. In our dataset all examples have `n_times_before=4` and `n_times_after=3`. Each band represents an infrared channel at different wavelengths and is converted to brightness temperatures based on the calibration parameters. The number in the filename corresponds to the GOES-16 ABI band number. Details of the ABI bands can be found [here](https://www.goes-r.gov/mission/ABI-bands-quick-info.html).
+    - **human_individual_masks.npy**: array with size of `H x W x 1 x R`. Each example is labeled by `R` individual human labelers. `R` is not the same for all samples. The labeled masks have value either 0 or 1 and correspond to the `(n_times_before+1)`-th image in `band_{08-16}.npy`. They are available only in the training set.
+    - **human_pixel_masks.npy**: array with size of `H x W x 1` containing the binary ground truth. A pixel is regarded as contrail pixel in evaluation if it is labeled as contrail by more than half of the labelers.
+- **validation/** - the same as the training set, without the individual label annotations; it is permitted to use this as training data if desired
+- **test/** - the test set; your objective is to identify contrails found in these records.
+- **{train|validation}_metadata.json** - metadata information for each record; contains the timestamps and the projection parameters to reproduce the satellite images.
+- **sample_submission.csv** - a sample submission file in the correct format

dslighting/registry/google-research-identify-contrails-reduce-global-warming/grade.py

@@ -0,0 +1,77 @@
+import numpy as np
+from pandas import DataFrame
+
+from mlebench.competitions.utils import rle_decode
+from mlebench.grade_helpers import InvalidSubmissionError
+from mlebench.metrics import dice_coefficient
+
+
+def grade(submission: DataFrame, answers: DataFrame) -> float:
+    expected_answer_columns = ["record_id", "encoded_pixels", "height", "width"]
+    expected_submission_columns = ["record_id", "encoded_pixels"]
+
+    assert set(answers.columns) == set(
+        expected_answer_columns
+    ), f"Expected answers to have columns {expected_answer_columns}, but got {answers.columns} instead!"
+
+    if not set(expected_submission_columns).issubset(set(submission.columns)):
+        raise InvalidSubmissionError(
+            f"Expected submission to have columns {expected_submission_columns}, but got {submission.columns} instead!"
+        )
+
+    if len(submission) != len(answers):
+        raise InvalidSubmissionError(
+            f"Expected submission to have {len(answers)} rows, but got {len(submission)} instead!"
+        )
+
+    submission = submission.sort_values(by="record_id")
+    answers = answers.sort_values(by="record_id")
+
+    if (submission["record_id"].values != answers["record_id"].values).any():
+        raise InvalidSubmissionError(
+            f"Expected submission to have the same record_id's as answers, but got a different set of record_id's!"
+        )
+
+    # Replace "-" in "encoded_pixels" with ""
+    submission["encoded_pixels"] = submission["encoded_pixels"].replace("-", "")
+    answers["encoded_pixels"] = answers["encoded_pixels"].replace("-", "")
+
+    y_preds_rle = submission["encoded_pixels"].values
+    y_trues_rle, y_true_height, y_true_width = (
+        answers["encoded_pixels"].values,
+        answers["height"].values,
+        answers["width"].values,
+    )
+
+    try:
+        y_preds = np.array(
+            [
+                rle_decode(rle, height=int(height), width=int(width))
+                for (rle, height, width) in zip(y_trues_rle, y_true_height, y_true_width)
+            ]
+        )
+    except AssertionError as e:
+        raise InvalidSubmissionError(f"Error decoding RLE masks: {e}")
+
+    y_trues = np.array(
+        [
+            rle_decode(rle, height=int(height), width=int(width))
+            for (rle, height, width) in zip(y_preds_rle, y_true_height, y_true_width)
+        ]
+    )
+
+    # Flatten from [3D array (list of 2D masks)] into [1D array] then compute a global dice coefficient
+    """
+    This competition is evaluated on the **global** Dice 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 \cdot |X \cap Y|}{|X| + |Y|}
+    $$
+    where X is the entire set of predicted contrail pixels for **all** observations in the test data and Y is the
+    ground truth set of **all** contrail pixels in the test data.
+    """
+    y_preds_flat = y_preds.ravel()
+    y_trues_flat = y_trues.ravel()
+    score = dice_coefficient(y_trues_flat, y_preds_flat)
+
+    return score

dslighting/registry/google-research-identify-contrails-reduce-global-warming/prepare.py

@@ -0,0 +1,155 @@
+import json
+import random
+import shutil
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+from sklearn.model_selection import train_test_split
+from tqdm import tqdm
+
+from mlebench.competitions.utils import get_logger, rle_encode
+
+logger = get_logger(__name__)
+
+
+def prepare(raw: Path, public: Path, private: Path):
+    """
+    We make train/test split from old train set, using same train/test proportion as the original
+    competition. Concretely, the new split has 18673 train samples and 1856 test samples. We also
+    copy over the validation set as-is.
+
+    `sample_submission` is created with random predictions, either "1 3 10 5" or "-" (empty)
+    """
+    DEV = False
+
+    with open(raw / "train_metadata.json", "r") as f:
+        train_metadata = json.load(f)
+    train_metadata = train_metadata[:100] if DEV else train_metadata
+    with open(raw / "validation_metadata.json", "r") as f:
+        validation_metadata = json.load(f)
+
+    if DEV:
+        new_train, new_test = train_metadata[:90], train_metadata[90:]
+    else:
+        new_train, new_test = train_test_split(
+            train_metadata, test_size=len(validation_metadata), random_state=0
+        )
+    logger.info(
+        f"Created new split with {len(new_train)} train samples and {len(new_test)} test samples"
+    )
+
+    # Create answers csv containing ground truth masks, heights, widths
+    test_answers = []
+    for sample in tqdm(new_test):
+        record_id = sample["record_id"]
+        mask = np.load(raw / "train" / record_id / "human_pixel_masks.npy")
+        rle = rle_encode(mask)
+        rle = " ".join([str(i) for i in rle]) if rle else "-"
+
+        band = np.load(raw / "train" / record_id / "band_08.npy")
+        height, width, _ = band.shape
+        test_answers.append(
+            {
+                "record_id": record_id,
+                "encoded_pixels": rle,
+                "height": height,
+                "width": width,
+            }
+        )
+    test_answers = pd.DataFrame(test_answers)
+
+    for sample in tqdm(new_train):
+        record_id = sample["record_id"]
+        (public / "train" / record_id).mkdir(exist_ok=True, parents=True)
+        # Copy bands
+        for band_idx in range(8, 17):
+            file_name = f"band_{band_idx:02}.npy"
+            shutil.copyfile(
+                src=raw / "train" / record_id / file_name,
+                dst=public / "train" / record_id / file_name,
+            )
+        # Copy human individual masks
+        shutil.copyfile(
+            src=raw / "train" / record_id / "human_individual_masks.npy",
+            dst=public / "train" / record_id / "human_individual_masks.npy",
+        )
+        # Copy human pixel masks
+        shutil.copyfile(
+            src=raw / "train" / record_id / "human_pixel_masks.npy",
+            dst=public / "train" / record_id / "human_pixel_masks.npy",
+        )
+
+    for sample in tqdm(new_test):
+        record_id = sample["record_id"]
+        (public / "test" / record_id).mkdir(exist_ok=True, parents=True)
+        # Copy bands
+        for band_idx in range(8, 17):
+            file_name = f"band_{band_idx:02}.npy"
+            shutil.copyfile(
+                src=raw / "train" / record_id / file_name,
+                dst=public / "test" / record_id / file_name,
+            )
+
+    # Copy over existing validation data
+    (raw / "validation").mkdir(exist_ok=True, parents=True)
+    shutil.copytree(raw / "validation", public / "validation", dirs_exist_ok=True)
+    shutil.copyfile(raw / "validation_metadata.json", public / "validation_metadata.json")
+
+    # Write other files
+    with open(public / "train_metadata.json", "w") as f:
+        f.write(json.dumps(new_train))
+    test_answers.to_csv(private / "answers.csv", index=False)
+
+    submission_df = test_answers.copy()
+    random.seed(0)
+    submission_df["encoded_pixels"] = [
+        random.choice(["1 3 10 5", "-"]) for _ in range(len(submission_df))
+    ]
+    submission_df.to_csv(public / "sample_submission.csv", index=False)
+
+    # Sanity checks
+    assert (public / "train_metadata.json").exists(), "`train_metadata.json` doesn't exist!"
+    assert (public / "sample_submission.csv").exists(), "`sample_submission.csv` doesn't exist!"
+    assert (
+        public / "validation_metadata.json"
+    ).exists(), "`validation_metadata.json` doesn't exist!"
+    assert (public / "train").exists(), "`train` directory doesn't exist!"
+    assert (public / "test").exists(), "`test` directory doesn't exist!"
+    assert (public / "validation").exists(), "`public` directory doesn't exist!"
+    assert (private / "answers.csv").exists(), "`answers.csv` doesn't exist!"
+
+    new_train_bands = list(img.stem for img in (public / "train").rglob("band*.npy"))
+    assert (
+        len(new_train_bands) == len(new_train) * 9
+    ), f"Expected {len(new_train) * 9} bands in the train set, but got {len(new_train_bands)}!"
+    new_test_bands = list(img.stem for img in (public / "test").rglob("band*.npy"))
+    assert (
+        len(new_test_bands) == len(new_test) * 9
+    ), f"Expected {len(new_test) * 9} in the test set, but got {len(new_test_bands)}!"
+
+    new_train_individual_masks = list(
+        img.stem for img in (public / "train").rglob("human_individual_masks.npy")
+    )
+    assert len(new_train_individual_masks) == len(
+        new_train
+    ), f"Expected 1 human individual mask per sample in the train set, but got {len(new_train_individual_masks)}!"
+    new_test_individual_masks = list(
+        img.stem for img in (public / "test").rglob("human_individual_masks.npy")
+    )
+    assert (
+        len(new_test_individual_masks) == 0
+    ), f"Expected 0 human individual masks per sample in the test set, but got {len(new_test_individual_masks)}!"
+
+    new_train_pixel_masks = list(
+        img.stem for img in (public / "train").rglob("human_pixel_masks.npy")
+    )
+    assert len(new_train_pixel_masks) == len(
+        new_train
+    ), f"Expected 1 human pixel mask per sample in the train set, but got {len(new_train_pixel_masks)}!"
+    new_test_pixel_masks = list(
+        img.stem for img in (public / "test").rglob("human_pixel_masks.npy")
+    )
+    assert (
+        len(new_test_pixel_masks) == 0
+    ), f"Expected 0 human pixel masks per sample in the test set, but got {len(new_test_pixel_masks)}!"