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

dslighting/registry/see-click-predict-fix/description.md

@@ -0,0 +1,47 @@
+# See Click Predict Fix
+
+## Description
+
+This competition aims to quantify and predict how people will react to specific 311 issues. What makes an issue urgent? What do citizens really care about? The data set contains several hundred thousand 311 issues from four cities.
+
+311 is a mechanism where citizens can express their desire to solve a problem by submitting a description of what needs to be done. Citizens can vote and comment on issues so government officials understand priorities.
+
+## Evaluation
+
+Your model should predict, for each issue, the number of views, votes, and comments. We use the **Root Mean Squared Logarithmic Error (RMSLE)** across all three targets:
+
+$$\text{RMSLE} = \sqrt{\frac{1}{n} \sum_{i=1}^n (\log(p_i + 1) - \log(a_i + 1))^2}$$
+
+where n is three times the total number of issues (summing over views, votes, and comments).
+
+## Submission Format
+
+```
+id,num_views,num_votes,num_comments
+343272,0,0,0
+274860,0,0,0
+...
+```
+
+## Dataset Description
+
+You are provided with 311 issues from four cities since 2012. The goal is to predict the number of views, votes, and comments each issue has received.
+
+## Data Fields
+
+- `id`: randomly assigned id
+- `latitude`, `longitude`: location of the issue
+- `summary`: short text title
+- `description`: longer text explanation
+- `num_votes`: number of user-generated votes (target)
+- `num_comments`: number of user-generated comments (target)
+- `num_views`: number of views (target)
+- `source`: categorical variable indicating where the issue was created
+- `created_time`: when the issue originated
+- `tag_type`: categorical variable of issue type
+
+## Files
+
+- `train.csv`: Training data with target variables
+- `test.csv`: Test data without target variables
+- `sample_submission.csv`: Sample submission in correct format

dslighting/registry/see-click-predict-fix/grade.py

@@ -0,0 +1,66 @@
+import numpy as np
+import pandas as pd
+from sklearn.metrics import mean_squared_log_error
+
+from mlebench.grade_helpers import InvalidSubmissionError
+
+
+TARGET_COLUMNS = ['num_views', 'num_votes', 'num_comments']
+
+
+def prepare_for_metric(submission: pd.DataFrame, answers: pd.DataFrame):
+    """Prepare submission and answers for RMSLE calculation."""
+    if len(submission) != len(answers):
+        raise InvalidSubmissionError(
+            f"Submission length ({len(submission)}) != answers length ({len(answers)})"
+        )
+
+    if "id" not in submission.columns:
+        raise InvalidSubmissionError("Submission must have an 'id' column")
+
+    for col in TARGET_COLUMNS:
+        if col not in submission.columns:
+            raise InvalidSubmissionError(f"Submission must have a '{col}' column")
+
+    # Sort by id
+    submission = submission.sort_values("id").reset_index(drop=True)
+    answers = answers.sort_values("id").reset_index(drop=True)
+
+    # Check id alignment
+    if not (submission["id"] == answers["id"]).all():
+        raise InvalidSubmissionError("Submission and answers id mismatch")
+
+    # Validate predictions
+    for col in TARGET_COLUMNS:
+        try:
+            submission[col] = submission[col].astype(float)
+        except (ValueError, TypeError):
+            raise InvalidSubmissionError(f"'{col}' predictions must be numeric")
+
+        if submission[col].isnull().any():
+            raise InvalidSubmissionError(f"'{col}' predictions cannot contain NaN values")
+
+        if (submission[col] < 0).any():
+            raise InvalidSubmissionError(f"'{col}' predictions cannot be negative")
+
+    return submission, answers
+
+
+def grade(submission: pd.DataFrame, answers: pd.DataFrame) -> float:
+    """Calculate RMSLE score across all target columns."""
+    submission, answers = prepare_for_metric(submission, answers)
+
+    # Concatenate all predictions and true values
+    all_pred = []
+    all_true = []
+    for col in TARGET_COLUMNS:
+        all_pred.extend(submission[col].values)
+        all_true.extend(answers[col].values)
+
+    all_pred = np.array(all_pred)
+    all_true = np.array(all_true)
+
+    # RMSLE
+    rmsle = np.sqrt(mean_squared_log_error(all_true, all_pred))
+
+    return rmsle

dslighting/registry/see-click-predict-fix/prepare.py

@@ -0,0 +1,25 @@
+from pathlib import Path
+import pandas as pd
+
+
+def prepare(raw: Path, public: Path, private: Path):
+    """
+    Prepare see-click-predict-fix dataset.
+    """
+    # Read data
+    train = pd.read_csv(raw / "train.csv")
+    test = pd.read_csv(raw / "test.csv")
+    sample_submission = pd.read_csv(raw / "sample_submission.csv")
+    test_answer = pd.read_csv(raw / "test_answer.csv")
+
+    # Public files (visible to agents)
+    train.to_csv(public / "train.csv", index=False)
+    test.to_csv(public / "test.csv", index=False)
+    sample_submission.to_csv(public / "sample_submission.csv", index=False)
+
+    # Private files (for grading)
+    test_answer.to_csv(private / "test.csv", index=False)
+
+    # Validation checks
+    assert len(test_answer) == len(sample_submission), \
+        f"Test answer ({len(test_answer)}) and sample submission ({len(sample_submission)}) must have same length"

dslighting/registry/see_click_predict_fix/grade.py

@@ -0,0 +1,66 @@
+import numpy as np
+import pandas as pd
+from sklearn.metrics import mean_squared_log_error
+
+from mlebench.grade_helpers import InvalidSubmissionError
+
+
+TARGET_COLUMNS = ['num_views', 'num_votes', 'num_comments']
+
+
+def prepare_for_metric(submission: pd.DataFrame, answers: pd.DataFrame):
+    """Prepare submission and answers for RMSLE calculation."""
+    if len(submission) != len(answers):
+        raise InvalidSubmissionError(
+            f"Submission length ({len(submission)}) != answers length ({len(answers)})"
+        )
+
+    if "id" not in submission.columns:
+        raise InvalidSubmissionError("Submission must have an 'id' column")
+
+    for col in TARGET_COLUMNS:
+        if col not in submission.columns:
+            raise InvalidSubmissionError(f"Submission must have a '{col}' column")
+
+    # Sort by id
+    submission = submission.sort_values("id").reset_index(drop=True)
+    answers = answers.sort_values("id").reset_index(drop=True)
+
+    # Check id alignment
+    if not (submission["id"] == answers["id"]).all():
+        raise InvalidSubmissionError("Submission and answers id mismatch")
+
+    # Validate predictions
+    for col in TARGET_COLUMNS:
+        try:
+            submission[col] = submission[col].astype(float)
+        except (ValueError, TypeError):
+            raise InvalidSubmissionError(f"'{col}' predictions must be numeric")
+
+        if submission[col].isnull().any():
+            raise InvalidSubmissionError(f"'{col}' predictions cannot contain NaN values")
+
+        if (submission[col] < 0).any():
+            raise InvalidSubmissionError(f"'{col}' predictions cannot be negative")
+
+    return submission, answers
+
+
+def grade(submission: pd.DataFrame, answers: pd.DataFrame) -> float:
+    """Calculate RMSLE score across all target columns."""
+    submission, answers = prepare_for_metric(submission, answers)
+
+    # Concatenate all predictions and true values
+    all_pred = []
+    all_true = []
+    for col in TARGET_COLUMNS:
+        all_pred.extend(submission[col].values)
+        all_true.extend(answers[col].values)
+
+    all_pred = np.array(all_pred)
+    all_true = np.array(all_true)
+
+    # RMSLE
+    rmsle = np.sqrt(mean_squared_log_error(all_true, all_pred))
+
+    return rmsle

dslighting/registry/see_click_predict_fix/prepare.py

@@ -0,0 +1,25 @@
+from pathlib import Path
+import pandas as pd
+
+
+def prepare(raw: Path, public: Path, private: Path):
+    """
+    Prepare see-click-predict-fix dataset.
+    """
+    # Read data
+    train = pd.read_csv(raw / "train.csv")
+    test = pd.read_csv(raw / "test.csv")
+    sample_submission = pd.read_csv(raw / "sample_submission.csv")
+    test_answer = pd.read_csv(raw / "test_answer.csv")
+
+    # Public files (visible to agents)
+    train.to_csv(public / "train.csv", index=False)
+    test.to_csv(public / "test.csv", index=False)
+    sample_submission.to_csv(public / "sample_submission.csv", index=False)
+
+    # Private files (for grading)
+    test_answer.to_csv(private / "test.csv", index=False)
+
+    # Validation checks
+    assert len(test_answer) == len(sample_submission), \
+        f"Test answer ({len(test_answer)}) and sample submission ({len(sample_submission)}) must have same length"

dslighting/registry/seti-breakthrough-listen/checksums.yaml

@@ -0,0 +1,6 @@
+private:
+  test.csv: bde6668df6af0c858a8eea028a140bfb
+public:
+  sample_submission.csv: 6bec1773dc78bbe72a70a539e86a8bac
+  train_labels.csv: c2dc9aa0bb1a60ba40215f979d81df6c
+zip: 0004b231e3a9dcff5bf82b59a52b9160

dslighting/registry/seti-breakthrough-listen/config.yaml

@@ -0,0 +1,24 @@
+id: seti-breakthrough-listen
+name: SETI Breakthrough Listen - E.T. Signal Search
+competition_type: simple
+awards_medals: true
+prizes:
+  - position: 1
+    value: 6000
+  - position: 2
+    value: 5000
+  - position: 3
+    value: 4000
+description: mlebench/competitions/seti-breakthrough-listen/description.md
+
+dataset:
+  answers: seti-breakthrough-listen/prepared/private/test.csv
+  sample_submission: seti-breakthrough-listen/prepared/public/sample_submission.csv
+
+grader:
+  name: auc-roc
+  grade_fn: mlebench.competitions.seti-breakthrough-listen.grade:grade
+
+preparer: mlebench.competitions.seti-breakthrough-listen.prepare:prepare
+
+

dslighting/registry/seti-breakthrough-listen/description.md

@@ -0,0 +1,112 @@
+## **Description**
+
+**“Are we alone in the Universe?”**
+
+It's one of the most profound—and perennial—human questions. As technology improves, we're finding new and more powerful ways to seek answers. The Breakthrough Listen team at the University of California, Berkeley, employs the world's most powerful telescopes to scan millions of stars for signs of technology. Now it wants the Kaggle community to help interpret the signals they pick up.
+
+The Listen team is part of the Search for ExtraTerrestrial Intelligence (SETI) and uses the largest steerable dish on the planet, the 100-meter diameter Green Bank Telescope. Like any SETI search, the motivation to communicate is also the major challenge. Humans have built enormous numbers of radio devices. It's hard to search for a faint needle of alien transmission in the huge haystack of detections from modern technology.
+
+Current methods use two filters to search through the haystack. First, the Listen team intersperses scans of the target stars with scans of other regions of sky. Any signal that appears in both sets of scans probably isn't coming from the direction of the target star. Second, the pipeline discards signals that don't change their frequency, because this means that they are probably nearby the telescope. A source in motion should have a signal that suggests movement, similar to the change in pitch of a passing fire truck siren. These two filters are quite effective, but we know they can be improved. The pipeline undoubtedly misses interesting signals, particularly those with complex time or frequency structure, and those in regions of the spectrum with lots of interference.
+
+In this competition, use your data science skills to help identify anomalous signals in scans of Breakthrough Listen targets. Because there are no confirmed examples of alien signals to use to train machine learning algorithms, the team included some simulated signals (that they call “needles”) in the haystack of data from the telescope. They have identified some of the hidden needles so that you can train your model to find more. The data consist of two-dimensional arrays, so there may be approaches from computer vision that are promising, as well as digital signal processing, anomaly detection, and more. The algorithm that's successful at identifying the most needles will win a cash prize, but also has the potential to help answer one of the biggest questions in science.
+
+![DSC_4014-Edit_2.jpg](https://storage.googleapis.com/kaggle-media/competitions/SETI-Berkeley/DSC_4014-Edit_2.jpg)
+
+### **Acknowledgments**
+
+The Breakthrough Listen science and engineering effort is headquartered at the University of California, Berkeley SETI Research Center. The Breakthrough Prize Foundation funds the Breakthrough Initiatives which manages Breakthrough Listen. The Green Bank Observatory is supported by the National Science Foundation, and is operated by Associated Universities, Inc. under a cooperative agreement.
+
+## **Evaluation**
+
+Submissions are evaluated on [area under the ROC curve](http://en.wikipedia.org/wiki/Receiver_operating_characteristic) between the predicted probability and the observed target.
+
+### **Submission File**
+
+For each `id` in the test set, you must predict a probability for the `target` variable. The file should contain a header and have the following format:
+
+```
+id,target
+00034abb3629,0.5
+0004be0baf70,0.5
+0005be4d0752,0.5
+etc.
+
+```
+
+## **Timeline**
+
+- **May 10, 2021** - Start Date.
+- **Aug 11, 2021** - Entry Deadline. You must accept the competition rules before this date in order to compete.
+- **Aug 11, 2021** - Team Merger Deadline. This is the last day participants may join or merge teams.
+- **Aug 18, 2021** - 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**
+
+### **Cash Prizes**
+
+- 1st Place - $6,000
+- 2nd Place - $5,000
+- 3rd Place - $4,000
+
+### **Additional Opportunities**
+
+Thank you for joining our efforts! If you felt that you made innovative contributions in this competition we want to invite you to submit your work to present at an upcoming conference. Any participant, not necessarily with the highest score, is welcome to submit model (code) and documentation to a panel with international experts in SETI, radio astronomy, and machine learning. The panel will select the contribution submissions with the most original approach with respect to traditional SETI strategies. We will provide a limited budget for travel to the conference to share your experience with our community. An entry form for those of you interested in this phase will be posted in a discussion thread before the end of the competition.
+
+Selected entrants can attend one of the upcoming conferences:
+
+- Invitations (at least one) to Breakthrough Discuss, April 2022 in the San Francisco Bay Area.
+- Invitations (at least one) to the International Astronautical Congress, September 2022 in Paris, France.
+
+Alternatively selected entrants may visit the Breakthrough Listen team at UC Berkeley for discussions and collaboration at a mutually convenient time.
+
+## **Data Information**
+
+The Breakthrough Listen instrument at the Green Bank Telescope (GBT) is a digital spectrometer, which takes incoming raw data from the telescope (amounting to hundreds of TB per day) and performs a Fourier Transform to generate a spectrogram. These spectrograms, also referred to as filterbank files, or dynamic spectra, consist of measurements of signal intensity as a function of frequency and time.
+
+Below is an example of an FM radio signal. This is not from the GBT, but from a small antenna attached to a software defined radio dongle (a $20 piece of kit that you can plug into your laptop to pick up signals). The data we get from the GBT are very similar, but split into larger numbers of frequency channels, covering a much broader instantaneous frequency range, and with much better sensitivity.
+
+![Untitled](https://prod-files-secure.s3.us-west-2.amazonaws.com/667f1cbf-826f-4641-a321-96054292638d/b59a57f3-11a7-4493-8268-55c3fa632f7e/Untitled.png)
+
+The screenshot above shows frequency on the horizontal axis (running from around 88.2 to 89.8 MHz) and time on the vertical axis. The bright orange feature at 88.5 MHz is the FM signal from KQED, a radio station in the San Francisco Bay Area. The solid yellow blocks on either side (one highlighted by the pointer in the screenshot) are the KQED “HD radio” signal (the same data as the FM signal, but encoded digitally). Additional FM stations are visible at different frequencies, including another obvious FM signal (without the corresponding digital sidebands) at 89.5 MHz.
+
+Breakthrough Listen generates similar spectrograms to the one shown above, but typically spanning several GHz of the radio spectrum (rather than the approx. 2 MHz shown above). The data are stored either as filterbank format or HDF5 format files, but essentially are arrays of intensity as a function of frequency and time, accompanied by headers containing metadata such as the direction the telescope was pointed in, the frequency scale, and so on. We generate over 1 PB of spectrograms per year; individual filterbank files can be tens of GB in size. For the purposes of the Kaggle challenge, we have discarded the majority of the metadata and are simply presenting numpy arrays consisting of small regions of the spectrograms that we refer to as “snippets”.
+
+Breakthrough Listen is searching for candidate signatures of extraterrestrial technology - so-called technosignatures. The main obstacle to doing so is that our own human technology (not just radio stations, but wifi routers, cellphones, and even electronics that are not deliberately designed to transmit radio signals) also gives off radio signals. We refer to these human-generated signals as “radio frequency interference”, or RFI.
+
+One method we use to isolate candidate technosignatures from RFI is to look for signals that appear to be coming from particular positions on the sky. Typically we do this by alternating observations of our primary target star with observations of three nearby stars: 5 minutes on star “A”, then 5 minutes on star “B”, then back to star “A” for 5 minutes, then “C”, then back to “A”, then finishing with 5 minutes on star “D”. One set of six observations (ABACAD) is referred to as a “cadence”. Since we're just giving you a small range of frequencies for each cadence, we refer to the datasets you'll be analyzing as “cadence snippets”.
+
+So, you want to see an example of an extraterrestrial signal? Here you are:
+
+![Screen Shot 2021-05-03 at 11.39.42.png](https://storage.googleapis.com/kaggle-media/competitions/SETI-Berkeley/Screen%20Shot%202021-05-03%20at%2011.39.42.png)
+
+As the plot title suggests, this is the Voyager 1 spacecraft. Even though it's 20 billion kilometers from Earth, it's picked up clearly by the GBT. The first, third, and fifth panels are the “A” target (the spacecraft, in this case). The yellow diagonal line is the radio signal coming from Voyager. It's detected when we point at the spacecraft, and it disappears when we point away. It's a diagonal line in this plot because the relative motion of the Earth and the spacecraft imparts a Doppler drift, causing the frequency to change over time. As it happens, that's another possible way to reject RFI, which has a higher tendency to remain at a fixed frequency over time.
+
+While it would be nice to train our algorithms entirely on observations of interplanetary spacecraft, there are not many examples of them, and we also want to be able to find a wider range of signal types. So we've turned to simulating technosignature candidates.
+
+We've taken tens of thousands of cadence snippets, which we're calling the haystack, and we've hidden needles among them. Some of these needles look similar to the Voyager 1 signal above and should be easy to detect, even with classical detection algorithms. Others are hidden in noisy regions of the spectrum and will be harder, even though they might be relatively obvious on visual inspection:
+
+![Screen Shot 2021-05-03 at 11.34.06.png](https://storage.googleapis.com/kaggle-media/competitions/SETI-Berkeley/Screen%20Shot%202021-05-03%20at%2011.34.06.png)
+
+After we perform the signal injections, we normalize each snippet, so you probably can't identify most of the needles just by looking for excess energy in the corresponding array. You'll likely need a more subtle algorithm that looks for patterns that appear only in the on-target observations.
+
+Not all of the “needle” signals look like diagonal lines, and they may not be present for the entirety of all three “A” observations, but what they do have in common is that they are only present in some or all of the “A” observations (panels 1, 3, and 5 in the cadence snippets). Your challenge is to train an algorithm to find as many needles as you can, while minimizing the number of false positives from the haystack.
+
+## **Citation**
+
+Andrew Siemion, Don Diego Alonso, Walter Reade, Shirley Wang, Steve Croft, Yuhong Chen. (2021). SETI Breakthrough Listen - E.T. Signal Search. Kaggle. https://kaggle.com/competitions/seti-breakthrough-listen
+
+# Data
+
+## **Dataset Description**
+
+In this competition you are tasked with looking for technosignature signals in cadence snippets taken from the Green Bank Telescope (GBT). Please read the extended description on the [Data Information](https://www.kaggle.com/c/seti-breakthrough-listen/overview/data-information) tab for detailed information about the data (that's too lengthy to include here).
+
+## **Files**
+
+- **train/** - a training set of cadence snippet files stored in `numpy` `float16` format (v1.20.1), one file per cadence snippet `id`, with corresponding labels found in the `train_labels.csv` file. Each file has dimension `(6, 273, 256)`, with the 1st dimension representing the 6 positions of the cadence, and the 2nd and 3rd dimensions representing the 2D spectrogram.
+- **test/** - the test set cadence snippet files; you must predict whether or not the cadence contains a "needle", which is the `target` for this competition
+- **sample_submission.csv** - a sample submission file in the correct format
+- **train_labels** - targets corresponding (by `id`) to the cadence snippet files found in the `train/` folder
+- **old_leaky_data** - full pre-relaunch data, including test labels; you should not assume this data is helpful (it may or may not be).

dslighting/registry/seti-breakthrough-listen/description_obfuscated.md

@@ -0,0 +1,58 @@
+# Task
+
+Identify technosignature signals in cadence snippets taken from a digital spectrometer.
+
+# Metric
+
+Area under the ROC curve between the predicted probability and the observed target.
+
+# Submission Format
+
+For each `id` in the test set, you must predict a probability for the `target` variable. The file should contain a header and have the following format:
+
+```
+id,target
+00034abb3629,0.5
+0004be0baf70,0.5
+0005be4d0752,0.5
+etc.
+
+```
+
+# Dataset
+
+The data is from a digital spectrometer, which takes incoming raw data from the telescope (amounting to hundreds of TB per day) and performs a Fourier Transform to generate a spectrogram. These spectrograms, also referred to as filterbank files, or dynamic spectra, consist of measurements of signal intensity as a function of frequency and time.
+
+Below is an example of an FM radio signal. This is not from the GBT, but from a small antenna attached to a software defined radio dongle (a $20 piece of kit that you can plug into your laptop to pick up signals). The data we get from the GBT are very similar, but split into larger numbers of frequency channels, covering a much broader instantaneous frequency range, and with much better sensitivity.
+
+![frequency-time-plot](https://prod-files-secure.s3.us-west-2.amazonaws.com/667f1cbf-826f-4641-a321-96054292638d/b59a57f3-11a7-4493-8268-55c3fa632f7e/Untitled.png)
+
+The screenshot above shows frequency on the horizontal axis (running from around 88.2 to 89.8 MHz) and time on the vertical axis. The bright orange feature at 88.5 MHz is the FM signal from KQED, a radio station in the San Francisco Bay Area. The solid yellow blocks on either side (one highlighted by the pointer in the screenshot) are the KQED “HD radio” signal (the same data as the FM signal, but encoded digitally). Additional FM stations are visible at different frequencies, including another obvious FM signal (without the corresponding digital sidebands) at 89.5 MHz.
+
+The spectrometer generates similar spectrograms to the one shown above, but typically spanning several GHz of the radio spectrum (rather than the approx. 2 MHz shown above). The data are stored either as filterbank format or HDF5 format files, but essentially are arrays of intensity as a function of frequency and time, accompanied by headers containing metadata such as the direction the telescope was pointed in, the frequency scale, and so on. We generate over 1 PB of spectrograms per year; individual filterbank files can be tens of GB in size. We have discarded the majority of the metadata and are simply presenting numpy arrays consisting of small regions of the spectrograms that we refer to as “snippets”.
+
+The spectrometer is searching for candidate signatures of extraterrestrial technology - so-called technosignatures. The main obstacle to doing so is that our own human technology (not just radio stations, but wifi routers, cellphones, and even electronics that are not deliberately designed to transmit radio signals) also gives off radio signals. We refer to these human-generated signals as “radio frequency interference”, or RFI.
+
+One method we use to isolate candidate technosignatures from RFI is to look for signals that appear to be coming from particular positions on the sky. Typically we do this by alternating observations of our primary target star with observations of three nearby stars: 5 minutes on star “A”, then 5 minutes on star “B”, then back to star “A” for 5 minutes, then “C”, then back to “A”, then finishing with 5 minutes on star “D”. One set of six observations (ABACAD) is referred to as a “cadence”. Since we're just giving you a small range of frequencies for each cadence, we refer to the datasets you'll be analyzing as “cadence snippets”.
+
+An example of an extraterrestrial signal:
+
+![voyager-signal](https://storage.googleapis.com/kaggle-media/competitions/SETI-Berkeley/Screen%20Shot%202021-05-03%20at%2011.39.42.png)
+
+As the plot title suggests, this is the Voyager 1 spacecraft. Even though it's 20 billion kilometers from Earth, it's picked up clearly by the GBT. The first, third, and fifth panels are the “A” target (the spacecraft, in this case). The yellow diagonal line is the radio signal coming from Voyager. It's detected when we point at the spacecraft, and it disappears when we point away. It's a diagonal line in this plot because the relative motion of the Earth and the spacecraft imparts a Doppler drift, causing the frequency to change over time. As it happens, that's another possible way to reject RFI, which has a higher tendency to remain at a fixed frequency over time.
+
+While it would be nice to train our algorithms entirely on observations of interplanetary spacecraft, there are not many examples of them, and we also want to be able to find a wider range of signal types. So we've turned to simulating technosignature candidates.
+
+We've taken tens of thousands of cadence snippets, which we're calling the haystack, and we've hidden needles among them. Some of these needles look similar to the Voyager 1 signal above and should be easy to detect, even with classical detection algorithms. Others are hidden in noisy regions of the spectrum and will be harder, even though they might be relatively obvious on visual inspection:
+
+![needle-signal](https://storage.googleapis.com/kaggle-media/competitions/SETI-Berkeley/Screen%20Shot%202021-05-03%20at%2011.34.06.png)
+
+After we perform the signal injections, we normalize each snippet, so you probably can't identify most of the needles just by looking for excess energy in the corresponding array. You'll likely need a more subtle algorithm that looks for patterns that appear only in the on-target observations.
+
+Not all of the “needle” signals look like diagonal lines, and they may not be present for the entirety of all three “A” observations, but what they do have in common is that they are only present in some or all of the “A” observations (panels 1, 3, and 5 in the cadence snippets). Your challenge is to train an algorithm to find as many needles as you can, while minimizing the number of false positives from the haystack.
+
+- **train/** - a training set of cadence snippet files stored in `numpy` `float16` format (v1.20.1), one file per cadence snippet `id`, with corresponding labels found in the `train_labels.csv` file. Each file has dimension `(6, 273, 256)`, with the 1st dimension representing the 6 positions of the cadence, and the 2nd and 3rd dimensions representing the 2D spectrogram.
+- **test/** - the test set cadence snippet files; you must predict whether or not the cadence contains a "needle", which is the `target` for this competition
+- **sample_submission.csv** - a sample submission file in the correct format
+- **train_labels** - targets corresponding (by `id`) to the cadence snippet files found in the `train/` folder
+- **old_leaky_data** - full pre-relaunch data, including test labels; you should not assume this data is helpful (it may or may not be).

dslighting/registry/seti-breakthrough-listen/grade.py

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

dslighting/registry/seti-breakthrough-listen/prepare.py

@@ -0,0 +1,71 @@
+import shutil
+from pathlib import Path
+
+from sklearn.model_selection import train_test_split
+from tqdm import tqdm
+
+from mlebench.utils import read_csv
+
+
+def prepare(raw: Path, public: Path, private: Path):
+
+    # Create train, test from train split
+    old_train = read_csv(raw / "train_labels.csv")
+    new_train, new_test = train_test_split(old_train, test_size=0.1, random_state=0)
+
+    # Copy over files
+    new_train.to_csv(public / "train_labels.csv", index=False)
+    new_test.to_csv(private / "test.csv", index=False)
+
+    shutil.copytree(raw / "old_leaky_data", public / "old_leaky_data", dirs_exist_ok=True)
+
+    for file_id in tqdm(new_train["id"], desc="Copying train files"):
+        subdir = file_id[0]
+        src = raw / "train" / subdir / f"{file_id}.npy"
+        dst = public / "train" / subdir / f"{file_id}.npy"
+        dst.parent.mkdir(parents=True, exist_ok=True)
+        shutil.copy(src, dst)
+
+    for file_id in tqdm(new_test["id"], desc="Copying test files"):
+        subdir = file_id[0]
+        src = raw / "train" / subdir / f"{file_id}.npy"
+        dst = public / "test" / subdir / f"{file_id}.npy"
+        dst.parent.mkdir(parents=True, exist_ok=True)
+        shutil.copy(src, dst)
+
+    # Create sample submission
+    sample_submission = new_test.copy()
+    sample_submission["target"] = 0.5  # Overwrite with dummy values
+    sample_submission.to_csv(public / "sample_submission.csv", index=False)
+
+    # Checks
+    assert len(sample_submission) == len(
+        new_test
+    ), "Sample submission length does not match test length."
+    assert not set(new_train["id"]).intersection(
+        set(new_test["id"])
+    ), "There are overlapping IDs in train and test sets."
+
+    train_files = {
+        file_path.name: file_path
+        for file_path in (public / "train").rglob("*")
+        if file_path.is_file()
+    }
+    test_files = {
+        file_path.name: file_path
+        for file_path in (public / "test").rglob("*")
+        if file_path.is_file()
+    }
+
+    assert len(train_files) == len(
+        new_train
+    ), "Number of train files does not match the number of train records."
+    assert len(test_files) == len(
+        new_test
+    ), "Number of test files does not match the number of test records."
+    assert train_files.keys().isdisjoint(
+        test_files.keys()
+    ), "There are overlapping files in train and test directories."
+    assert len(sample_submission) == len(
+        new_test
+    ), "Sample submission length does not match new test length."