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

dslighting/registry/spaceship-titanic/prepare.py

@@ -0,0 +1,23 @@
+from pathlib import Path
+
+from sklearn.model_selection import train_test_split
+
+from mlebench.utils import read_csv
+
+
+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)
+
+    # Create random example submission
+    example_submission = new_test[["PassengerId", "Transported"]].copy()
+    example_submission["Transported"] = False
+    example_submission.to_csv(public / "sample_submission.csv", index=False)
+
+    # 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.drop("Transported", axis="columns").to_csv(public / "test.csv", index=False)

dslighting/registry/spaceship-titanic/prepare_val.py

@@ -0,0 +1,61 @@
+from pathlib import Path
+
+import pandas as pd
+from sklearn.model_selection import train_test_split
+
+from mlebench.utils import read_csv
+
+
+def _create_split_files(
+    train_df: pd.DataFrame,
+    test_df: pd.DataFrame,
+    public_dir: Path,
+    private_dir: Path,
+):
+    """A helper function to save train/test splits and artifacts."""
+    # Create random example submission
+    example_submission = test_df[["PassengerId", "Transported"]].copy()
+    example_submission["Transported"] = False
+    example_submission.to_csv(public_dir / "sample_submission.csv", index=False)
+
+    # Create private files
+    test_df.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.drop("Transported", axis="columns").to_csv(
+        public_dir / "test.csv", index=False
+    )
+
+
+def prepare(raw: Path, public: Path, private: Path):
+    # Define and create all output directories to ensure they exist
+    public.mkdir(parents=True, exist_ok=True)
+    private.mkdir(parents=True, exist_ok=True)
+    public_val = public.parent / "public_val"
+    private_val = private.parent / "private_val"
+    public_val.mkdir(parents=True, exist_ok=True)
+    private_val.mkdir(parents=True, exist_ok=True)
+
+    # --- Original Split: Create main train and test sets ---
+    # 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)
+
+    # Generate the files for the original public/private directories
+    # This ensures the original outputs are unchanged
+    _create_split_files(new_train, new_test, public, private)
+
+    # --- Validation Split: Create a new train and validation set ---
+    # The new validation set should be approx. the same size as the original test set.
+    # We calculate the required test_size for splitting the new_train set.
+    test_size_for_val = len(new_test) / len(new_train)
+
+    # Split the training data again to create a new, smaller training set and a validation set
+    train_val, test_val = train_test_split(
+        new_train, test_size=test_size_for_val, random_state=0
+    )
+
+    # Generate the files for the new validation directories, using the exact same
+    # structure and filenames as the original split.
+    _create_split_files(train_val, test_val, public_val, private_val)

dslighting/registry/spooky-author-identification/checksums.yaml

@@ -0,0 +1,7 @@
+private:
+  test.csv: fb1381c6c9a7e9efd236c625807a0c8a
+public:
+  sample_submission.csv: 3b754ff50b2b4416150bb00c86c34889
+  test.csv: 2ea5096a8e8cf340b13a7a18d9bdd914
+  train.csv: 1124166bf7b8b1e337a32fe568732447
+zip: 8f12d4f1f138f3867e881293b9bc54ee

dslighting/registry/spooky-author-identification/classes.py

@@ -0,0 +1 @@
+CLASSES = ["EAP", "HPL", "MWS"]

dslighting/registry/spooky-author-identification/config.yaml

@@ -0,0 +1,16 @@
+id: spooky-author-identification
+name: Spooky Author Identification
+competition_type: simple
+awards_medals: false
+prizes: null
+description: mlebench/competitions/spooky-author-identification/description.md
+
+dataset:
+  answers: spooky-author-identification/prepared/private/test.csv
+  sample_submission: spooky-author-identification/prepared/public/sample_submission.csv
+
+grader:
+  name: multi-class-log-loss
+  grade_fn: mlebench.competitions.spooky-author-identification.grade:grade
+
+preparer: mlebench.competitions.spooky-author-identification.prepare:prepare

dslighting/registry/spooky-author-identification/description.md

@@ -0,0 +1,98 @@
+# Overview
+
+## Description
+
+As I scurried across the candlelit chamber, manuscripts in hand, I thought I'd made it. Nothing would be able to hurt me anymore. Little did I know there was one last fright lurking around the corner.
+
+DING! My phone pinged me with a disturbing notification. It was Will, the scariest of Kaggle moderators, sharing news of another data leak.
+
+"ph’nglui mglw’nafh Cthulhu R’lyeh wgah’nagl fhtagn!" I cried as I clumsily dropped my crate of unbound, spooky books. Pages scattered across the chamber floor. How will I ever figure out how to put them back together according to the authors who wrote them? Or are they lost, forevermore? Wait, I thought... I know, machine learning!
+
+In this year's Halloween playground competition, you're challenged to predict the author of excerpts from horror stories by Edgar Allan Poe, Mary Shelley, and HP Lovecraft. We're encouraging you ([with cash prizes!](https://www.kaggle.com/c/spooky-author-identification#Prizes)) to share your insights in the competition's discussion forum and code in Kernels. We've designated prizes to reward authors of kernels and discussion threads that are particularly valuable to the community. Click the ["Prizes" tab](https://www.kaggle.com/c/spooky-author-identification) on this overview page to learn more.
+
+### Getting Started
+
+New to Kernels or working with natural language data? We've put together some starter kernels in [Python](https://www.kaggle.com/rtatman/beginner-s-tutorial-python) and [R](https://www.kaggle.com/rtatman/beginner-s-tutorial-r) to help you hit the ground running.
+
+## Evaluation
+
+Submissions are evaluated using multi-class logarithmic loss. Each id has one true class. For each id, you must submit a predicted probability for each author. The formula is then:
+
+$$\text{log loss} = -\frac{1}{N} \sum_{i=1}^N \sum_{j=1}^M y_{ij} \log(p_{ij})$$
+
+where N is the number of observations in the test set, M is the number of class labels (3 classes), \\(log\\) is the natural logarithm, \\(y_{ij}\\) is 1 if observation \\(i\\) belongs to class \\(j\\) and 0 otherwise, and \\(p_{ij}\\) is the predicted probability that observation \\(i\\) belongs to class \\(j\\).
+
+The submitted probabilities for a given sentences are not required to sum to one because they are rescaled prior to being scored (each row is divided by the row sum). In order to avoid the extremes of the log function, predicted probabilities are replaced with \\(max(min(p,1-10^{-15}),10^{-15})\\).
+
+### Submission File
+
+You must submit a csv file with the id, and a probability for each of the three classes. The order of the rows does not matter. The file must have a header and should look like the following:
+
+```
+id,EAP,HPL,MWS
+id07943,0.33,0.33,0.33
+...
+```
+
+## Prizes
+
+### Kernels Prizes
+
+#### Total prize pool of $20,000
+
+**Upvotes**: Six awards of \$2,000 will be given to the authors of the most upvoted kernel in the competition. Self-votes and admin-votes will not be counted. The prizes will be awarded at the close of the competition.
+
+**Themed**: At the close of the competition, Kaggle data scientists will pick one kernel from each of the following categories that they feel is an exceptional example of the analysis type to award the authors each \$2,000:
+
+- an R tutorial,
+- a Python tutorial,
+- creative feature engineering,
+- creative data visualization.
+
+Tip: Add tags like "tutorial", "feature engineering", and "data visualization" to your kernel after you publish it to help others discover it.
+
+### Discussion Prizes
+
+####Total prize pool of $5,000
+
+**Upvotes**: Awards of \$1,000 each will be given to the unique authors of the top five most upvoted discussion topics on the competition.
+
+The contents of the discussion must forward the work done on the competition to be judged at Kaggle's discretion. Only votes from other competitors who have accepted the rules and made a first submission will count towards the total votes. Comments in reply to a pre-existing discussion topic also won't be considered (i.e., on the "Discussions" tab, you must click "New Topic" to start a new topic). The prizes will be awarded at the close of the competition.
+
+### Eligibility
+
+Only participants in the Spooky Author Identification competition are eligible to win prizes. Meaning, at the time the award is being given out, they must have accepted the rules and made a first submission. To read more details on eligibility, please see the Rules.
+
+## Timeline
+
+- **December 15, 2017** - Final submission deadline
+
+These awards will be made following the close of the competition:
+
+- Upvoted kernels prizes
+- Themed kernels prizes
+- Discussion prizes
+
+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.
+
+## Citation
+
+Meg Risdal, Rachael Tatman. (2017). Spooky Author Identification. Kaggle. https://kaggle.com/competitions/spooky-author-identification
+
+# Dataset Description
+
+The competition dataset contains text from works of fiction written by spooky authors of the public domain: Edgar Allan Poe, HP Lovecraft and Mary Shelley. The data was prepared by chunking larger texts into sentences using CoreNLP's MaxEnt sentence tokenizer, so you may notice the odd non-sentence here and there. Your objective is to accurately identify the author of the sentences in the test set.
+
+## File descriptions
+
+- **train.csv** - the training set
+- **test.csv** - the test set
+- **sample_submission.csv** - a sample submission file in the correct format
+
+## Data fields
+
+- **id** - a unique identifier for each sentence
+- **text** - some text written by one of the authors
+- **author** - the author of the sentence (EAP: Edgar Allan Poe, HPL: HP Lovecraft; MWS: Mary Wollstonecraft Shelley)
+
+**A reminder about playground competitions**: On Kaggle, the spirit of playground competitions is to have fun and learn together. Your score on the leaderboard doesn't earn you points, but you can still make it a rewarding competition for everyone by sharing your code in Kernels and contributing to Discussions (there are [prizes for both](https://www.kaggle.com/c/spooky-author-identification#Prizes)!). In short, please don't look up the answers.

dslighting/registry/spooky-author-identification/description_obfuscated.md

@@ -0,0 +1,35 @@
+# Task
+
+Given some text, predict the author.
+
+# Metric
+
+Multi-class logarithmic loss. 
+
+The submitted probabilities for a given sentences are not required to sum to one because they are rescaled prior to being scored (each row is divided by the row sum).
+
+In order to avoid the extremes of the log function, predicted probabilities are replaced with \\(max(min(p,1-10^{-15}),10^{-15})\\).
+
+# Submission Format
+
+You must submit a csv file with the id, and a probability for each of the three classes. The order of the rows does not matter. The file must have a header and should look like the following:
+
+```
+id,EAP,HPL,MWS
+id07943,0.33,0.33,0.33
+...
+```
+
+# Dataset 
+
+## File descriptions
+
+- **train.csv** - the training set
+- **test.csv** - the test set
+- **sample_submission.csv** - a sample submission file in the correct format
+
+## Data fields
+
+- **id** - a unique identifier for each sentence
+- **text** - some text written by one of the authors
+- **author** - the author of the sentence (EAP: Edgar Allan Poe, HPL: HP Lovecraft; MWS: Mary Wollstonecraft Shelley)

dslighting/registry/spooky-author-identification/grade.py

@@ -0,0 +1,38 @@
+import numpy as np
+import pandas as pd
+from sklearn.metrics import log_loss
+
+from mlebench.competitions.utils import one_hot_dfs_to_log_loss_inputs
+from mlebench.grade_helpers import InvalidSubmissionError
+
+from .classes import CLASSES
+
+tolerance = 1e-6
+
+
+def prepare_for_metric(submission: pd.DataFrame, answers: pd.DataFrame) -> dict:
+    id_col = "id"
+
+    if submission.shape != (len(answers), len(CLASSES) + 1):
+        raise InvalidSubmissionError(
+            f"Submission shape {submission.shape} does not match answers shape {answers.shape}."
+        )
+
+    # assert that each row in submission sums to one, accounting for floating point errors
+    if not np.all(np.isclose(submission.iloc[:, 1:].sum(axis=1), 1, atol=tolerance)):
+        raise InvalidSubmissionError("Each row in submission should sum to one, as probabilities.")
+    if not ((submission.iloc[:, 1:] >= 0) & (submission.iloc[:, 1:] <= 1)).all().all():
+        raise InvalidSubmissionError(
+            "All probabilities in submission DataFrame must be between 0 and 1."
+        )
+
+    log_loss_inputs = one_hot_dfs_to_log_loss_inputs(
+        submission, answers, id_column=id_col, apply_softmax=False
+    )
+
+    return log_loss_inputs
+
+
+def grade(submission: pd.DataFrame, answers: pd.DataFrame) -> float:
+    log_loss_inputs = prepare_for_metric(submission, answers)
+    return log_loss(**log_loss_inputs)

dslighting/registry/spooky-author-identification/prepare.py

@@ -0,0 +1,40 @@
+from pathlib import Path
+
+from sklearn.model_selection import train_test_split
+
+from mlebench.competitions.utils import df_to_one_hot
+from mlebench.utils import extract, read_csv
+
+from .classes import CLASSES
+
+
+def prepare(raw: Path, public: Path, private: Path):
+    target_col = "author"
+    id_col = "id"
+
+    # extract only what we need
+    extract(raw / "train.zip", raw)
+
+    # Create train, test from train split
+    old_train = read_csv(raw / "train.csv")
+    new_train, new_test = train_test_split(old_train, test_size=0.1, random_state=0)
+    new_test_without_labels = new_test.drop(columns=[target_col])
+
+    # private test matches the format of sample submission
+    one_hot_new_test = df_to_one_hot(
+        new_test.drop(columns=["text"]),
+        id_column=id_col,
+        target_column=target_col,
+        classes=CLASSES,
+    )
+    # fill the sample submission with arbitrary values (matching kaggle.com)
+    sample_submission = one_hot_new_test.copy()
+    sample_submission["EAP"] = 0.403493538995863
+    sample_submission["HPL"] = 0.287808366106543
+    sample_submission["MWS"] = 0.308698094897594
+
+    # save files
+    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)
+    one_hot_new_test.to_csv(private / "test.csv", index=False)

dslighting/registry/spooky-author-identification/prepare_val.py

@@ -0,0 +1,78 @@
+from pathlib import Path
+
+from sklearn.model_selection import train_test_split
+
+from mlebench.competitions.utils import df_to_one_hot
+from mlebench.utils import extract, read_csv
+
+from .classes import CLASSES
+
+
+def prepare(raw: Path, public: Path, private: Path):
+    target_col = "author"
+    id_col = "id"
+
+    # extract only what we need
+    extract(raw / "train.zip", raw)
+
+    # =================================================================
+    # == Original Data Split (for `public` and `private` directories)
+    # =================================================================
+    # Create main train/test split from the raw data
+    old_train = read_csv(raw / "train.csv")
+    train_main, test_main = train_test_split(old_train, test_size=0.1, random_state=0)
+    test_main_without_labels = test_main.drop(columns=[target_col])
+
+    # private test matches the format of sample submission
+    one_hot_test_main = df_to_one_hot(
+        test_main.drop(columns=["text"]),
+        id_column=id_col,
+        target_column=target_col,
+        classes=CLASSES,
+    )
+    # fill the sample submission with arbitrary values (matching kaggle.com)
+    sample_submission = one_hot_test_main.copy()
+    sample_submission["EAP"] = 0.403493538995863
+    sample_submission["HPL"] = 0.287808366106543
+    sample_submission["MWS"] = 0.308698094897594
+
+    # save files to original public/private directories
+    train_main.to_csv(public / "train.csv", index=False)
+    test_main_without_labels.to_csv(public / "test.csv", index=False)
+    sample_submission.to_csv(public / "sample_submission.csv", index=False)
+    one_hot_test_main.to_csv(private / "test.csv", index=False)
+
+    # =====================================================================
+    # == New Validation Split (for `public_val` and `private_val` dirs)
+    # =====================================================================
+    # Define and create the new parallel directories for the validation set
+    public_val = public.parent / "public_val"
+    private_val = private.parent / "private_val"
+    public_val.mkdir(parents=True, exist_ok=True)
+    private_val.mkdir(parents=True, exist_ok=True)
+
+    # Split the main training set again to create a new, smaller training set and a validation set.
+    # The logic and random_state are replicated to ensure the validation set size is
+    # consistent with the main test set size.
+    train_val, test_val = train_test_split(train_main, test_size=0.1, random_state=0)
+    test_val_without_labels = test_val.drop(columns=[target_col])
+
+    # Process the new validation set's labels, mirroring the original logic
+    one_hot_test_val = df_to_one_hot(
+        test_val.drop(columns=["text"]),
+        id_column=id_col,
+        target_column=target_col,
+        classes=CLASSES,
+    )
+
+    # Create a new sample submission for the validation set
+    sample_submission_val = one_hot_test_val.copy()
+    sample_submission_val["EAP"] = 0.403493538995863
+    sample_submission_val["HPL"] = 0.287808366106543
+    sample_submission_val["MWS"] = 0.308698094897594
+
+    # Save files to the new validation directories using identical filenames
+    train_val.to_csv(public_val / "train.csv", index=False)
+    test_val_without_labels.to_csv(public_val / "test.csv", index=False)
+    sample_submission_val.to_csv(public_val / "sample_submission.csv", index=False)
+    one_hot_test_val.to_csv(private_val / "test.csv", index=False)

dslighting/registry/stanford-covid-vaccine/checksums.yaml

@@ -0,0 +1,7 @@
+private:
+  test.csv: 41f284c21e1f7e112f29e1d7b7c1fd73
+public:
+  sample_submission.csv: 5d6a8da1eae26187ec3158b68ec7d666
+  test.json: 86e2201a0168275ccadd49cafa6cab66
+  train.json: 0081f791ac8730984c147955a0c7bba9
+zip: 16ec2b3aa849804b7ab68a3bd043d00c

dslighting/registry/stanford-covid-vaccine/config.yaml

@@ -0,0 +1,22 @@
+id: stanford-covid-vaccine
+name: "OpenVaccine: COVID-19 mRNA Vaccine Degradation Prediction"
+competition_type: simple
+awards_medals: true
+prizes:
+  - position: 1
+    value: 12000
+  - position: 2
+    value: 8000
+  - position: 3
+    value: 5000
+description: mlebench/competitions/stanford-covid-vaccine/description.md
+
+dataset:
+  answers: stanford-covid-vaccine/prepared/private/test.csv
+  sample_submission: stanford-covid-vaccine/prepared/public/sample_submission.csv
+
+grader:
+  name: multi-class-log-loss
+  grade_fn: mlebench.competitions.stanford-covid-vaccine.grade:grade
+
+preparer: mlebench.competitions.stanford-covid-vaccine.prepare:prepare

dslighting/registry/stanford-covid-vaccine/description.md

@@ -0,0 +1,125 @@
+# Overview
+
+## Description
+
+Winning the fight against the COVID-19 pandemic will require an effective vaccine that can be equitably and widely distributed. Building upon decades of research has allowed scientists to accelerate the search for a vaccine against COVID-19, but every day that goes by without a vaccine has enormous costs for the world nonetheless. We need new, fresh ideas from all corners of the world. Could online gaming and crowdsourcing help solve a worldwide pandemic? Pairing scientific and crowdsourced intelligence could help computational biochemists make measurable progress.
+
+mRNA vaccines have taken the lead as the fastest vaccine candidates for COVID-19, but currently, they face key potential limitations. One of the biggest challenges right now is how to design super stable messenger RNA molecules (mRNA). Conventional vaccines (like your seasonal flu shots) are packaged in disposable syringes and shipped under refrigeration around the world, but that is not currently possible for mRNA vaccines.
+
+Researchers have observed that RNA molecules have the tendency to spontaneously degrade. This is a serious limitation--a single cut can render the mRNA vaccine useless. Currently, little is known on the details of where in the backbone of a given RNA is most prone to being affected. Without this knowledge, current mRNA vaccines against COVID-19 must be prepared and shipped under intense refrigeration, and are unlikely to reach more than a tiny fraction of human beings on the planet unless they can be stabilized.
+
+![](https://storage.googleapis.com/kaggle-media/competitions/Stanford/banner%20(2).png)
+
+The Eterna community, led by Professor Rhiju Das, a computational biochemist at Stanford's School of Medicine, brings together scientists and gamers to solve puzzles and invent medicine. Eterna is an online video game platform that challenges players to solve scientific problems such as mRNA design through puzzles. The solutions are synthesized and experimentally tested at Stanford by researchers to gain new insights about RNA molecules. The Eterna community has previously unlocked new scientific principles, made new diagnostics against deadly diseases, and engaged the world's most potent intellectual resources for the betterment of the public. The Eterna community has advanced biotechnology through its contribution in over 20 publications, including advances in RNA biotechnology.
+
+In this competition, we are looking to leverage the data science expertise of the Kaggle community to develop models and design rules for RNA degradation. Your model will predict likely degradation rates at each base of an RNA molecule, trained on a subset of an Eterna dataset comprising over 3000 RNA molecules (which span a panoply of sequences and structures) and their degradation rates at each position. We will then score your models on a second generation of RNA sequences that have just been devised by Eterna players for COVID-19 mRNA vaccines. These final test sequences are currently being synthesized and experimentally characterized at Stanford University in parallel to your modeling efforts -- Nature will score your models!
+
+Improving the stability of mRNA vaccines was a problem that was being explored before the pandemic but was expected to take many years to solve. Now, we must solve this deep scientific challenge in months, if not weeks, to accelerate mRNA vaccine research and deliver a refrigerator-stable vaccine against SARS-CoV-2, the virus behind COVID-19. The problem we are trying to solve has eluded academic labs, industry R&D groups, and supercomputers, and so we are turning to you. To help, you can join the team of video game players, scientists, and developers at Eterna to unlock the key in our fight against this devastating pandemic.
+
+[![](https://storage.googleapis.com/kaggle-media/competitions/Stanford/logo_eterna_reverse.png)         ](http://eternagame.org/)[![](https://storage.googleapis.com/kaggle-media/competitions/Stanford/OpenVaccine-logo-black-transp-bg%20(1).png)         ](https://challenges.eternagame.org/)[![](https://storage.googleapis.com/kaggle-media/competitions/Stanford/logo_das.png)](http://daslab.stanford.edu/)
+
+## Evaluation
+
+Submissions are scored using MCRMSE, mean columnwise root mean squared error:
+
+$\textrm{MCRMSE} = \frac{1}{N_{t}}\sum_{j=1}^{N_{t}}\sqrt{\frac{1}{n} \sum_{i=1}^{n} (y_{ij} - \hat{y}_{ij})^2}$
+
+where $N_{t}$ is the number of scored ground truth target columns, and $y$ and $\hat{y}$ are the actual and predicted values, respectively.
+
+From the `Data` page: There are multiple ground truth values provided in the training data. While the submission format requires all 5 to be predicted, only the following are scored: reactivity, deg_Mg_pH10, and deg_Mg_50C.
+
+### Submission File
+
+For each sample `id` in the test set, you must predict targets for *each* sequence position (`seqpos`), one per row. If the length of the `sequence` of an `id` is, e.g., 107, then you should make 107 predictions. Positions greater than the `seq_scored` value of a sample are not scored, but still need a value in the solution file.
+
+```csv
+id_seqpos,reactivity,deg_Mg_pH10,deg_pH10,deg_Mg_50C,deg_50C
+id_d190610e8_0,0.1,0.3,0.2,0.5,0.4
+id_d190610e8_1,0.3,0.2,0.5,0.4,0.2
+id_d190610e8_2,0.5,0.4,0.2,0.1,0.2
+etc.
+```
+
+## Timeline
+
+- **October 2, 2020** - Entry deadline. You must accept the competition rules before this date in order to compete.
+
+- **October 2, 2020** - Team Merger deadline. This is the last day participants may join or merge teams.
+
+- **October 6, 2020** - Final submission deadline. *Date extended by one day for new data refresh.*
+
+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 - $ 12,000
+- 2nd Place - $ 8,000
+- 3rd Place - $ 5,000
+
+## Additional Resources
+
+**How RNA vaccines work, and their issues, featuring Dr. Rhiju Das**\
+<https://www.pbs.org/wgbh/nova/video/rna-coronavirus-vaccine/>
+
+**Launch of the OpenVaccine challenge**\
+<https://scopeblog.stanford.edu/2020/05/20/stanford-biochemist-works-with-gamers-to-develop-covid-19-vaccine/>
+
+**The impossibility of mass immunization with current RNA vaccines**\
+<https://www.wsj.com/articles/from-freezer-farms-to-jets-logistics-operators-prepare-for-a-covid-19-vaccine-11598639012>
+
+**CDC prepares for frozen mRNA vaccines**\
+<https://www.cdc.gov/vaccines/acip/meetings/downloads/slides-2020-08/COVID-08-Dooling.pdf>
+
+**Eterna, the crowdsourcing platform for RNA design where OpenVaccine's RNA sequences are coming from**\
+<https://eternagame.org>
+
+**How to build a better vaccine from the comfort of your own web browser**\
+<https://medium.com/eternaproject/how-to-build-a-better-vaccine-from-the-comfort-of-your-own-web-browser-233343e0210d>
+
+## Citation
+
+Rhiju Das, H Wayment-Steele, Do Soon Kim, Christian Choe, Bojan Tunguz, Walter Reade, Maggie Demkin. (2020). OpenVaccine: COVID-19 mRNA Vaccine Degradation Prediction. Kaggle. https://kaggle.com/competitions/stanford-covid-vaccine
+
+# Dataset Description
+
+In this competition, you will be predicting the degradation rates at various locations along RNA sequence.
+
+There are multiple ground truth values provided in the training data. While the submission format requires all 5 to be predicted, only the following are scored: `reactivity`, `deg_Mg_pH10`, and `deg_Mg_50C`.
+
+### Files
+
+- **train.json** - the training data
+- **test.json** - the test set, without any columns associated with the ground truth.
+- **sample_submission.csv** - a sample submission file in the correct format
+
+### Columns
+
+- `id` - An arbitrary identifier for each sample.
+- `seq_scored` - (68 in Train and Public Test, 68 in Private Test) Integer value denoting the number of positions used in scoring with predicted values. This should match the length of `reactivity`, `deg_*` and `*_error_*` columns.
+- `seq_length` - (107 in Train and Public Test, 107 in Private Test) Integer values, denotes the length of `sequence`.
+- `sequence` - (1x107 string in Train and Public Test, 107 in Private Test) Describes the RNA sequence, a combination of `A`, `G`, `U`, and `C` for each sample. Should be 107 characters long, and the first 68 bases should correspond to the 68 positions specified in `seq_scored` (note: indexed starting at 0).
+- `structure` - (1x107 string in Train and Public Test, 107 in Private Test) An array of `(`, `)`, and `.` characters that describe whether a base is estimated to be paired or unpaired. Paired bases are denoted by opening and closing parentheses e.g. (....) means that base 0 is paired to base 5, and bases 1-4 are unpaired.
+- `reactivity` - (1x68 vector in Train and Public Test, 1x68 in Private Test) An array of floating point numbers, should have the same length as `seq_scored`. These numbers are reactivity values for the first 68 bases as denoted in `sequence`, and used to determine the likely secondary structure of the RNA sample.
+- `deg_pH10` - (1x68 vector in Train and Public Test, 1x68 in Private Test) An array of floating point numbers, should have the same length as `seq_scored`. These numbers are reactivity values for the first 68 bases as denoted in `sequence`, and used to determine the likelihood of degradation at the base/linkage after incubating without magnesium at high pH (pH 10).
+- `deg_Mg_pH10` - (1x68 vector in Train and Public Test, 1x68 in Private Test) An array of floating point numbers, should have the same length as `seq_scored`. These numbers are reactivity values for the first 68 bases as denoted in `sequence`, and used to determine the likelihood of degradation at the base/linkage after incubating with magnesium in high pH (pH 10).
+- `deg_50C` - (1x68 vector in Train and Public Test, 1x68 in Private Test) An array of floating point numbers, should have the same length as `seq_scored`. These numbers are reactivity values for the first 68 bases as denoted in `sequence`, and used to determine the likelihood of degradation at the base/linkage after incubating without magnesium at high temperature (50 degrees Celsius).
+- `deg_Mg_50C` - (1x68 vector in Train and Public Test, 1x68 in Private Test) An array of floating point numbers, should have the same length as `seq_scored`. These numbers are reactivity values for the first 68 bases as denoted in `sequence`, and used to determine the likelihood of degradation at the base/linkage after incubating with magnesium at high temperature (50 degrees Celsius).
+- `*_error_*` - An array of floating point numbers, should have the same length as the corresponding `reactivity` or `deg_*` columns, calculated errors in experimental values obtained in `reactivity` and `deg_*` columns.
+- `predicted_loop_type` - (1x107 string) Describes the structural context (also referred to as 'loop type')of each character in `sequence`. Loop types assigned by bpRNA from Vienna RNAfold 2 structure. From the bpRNA_documentation: S: paired "Stem" M: Multiloop I: Internal loop B: Bulge H: Hairpin loop E: dangling End X: eXternal loop
+    - `S/N filter` Indicates if the sample passed filters described below in `Additional Notes`.
+
+### Additional Notes
+
+At the beginning of the competition, Stanford scientists have data on 2400 RNA sequences of length 107. For technical reasons, measurements cannot be carried out on the final bases of these RNA sequences, so we have experimental data (ground truth) in 5 conditions for the first 68 bases.
+
+We have split out 240 of these 2400 sequences for a public test set to allow for continuous evaluation through the competition, on the public leaderboard. These sequences, in `test.json`, have been additionally filtered based on three criteria detailed below to ensure that this subset is not dominated by any large cluster of RNA molecules with poor data, which might bias the public leaderboard. The remaining 2160 sequences for which we have data are in `train.json`.
+
+For our final and most important scoring (the Private Leaderbooard), Stanford scientists are carrying out measurements on 240 new RNAs. For these data, we expect to have measurements for the first 68 bases, again missing the ends of the RNA. These sequences constitute the 240 sequences in `test.json`.
+
+For those interested in how the sequences in `test.json` were filtered, here were the steps to ensure a diverse and high quality test set for public leaderboard scoring:
+
+1. Minimum value across all 5 conditions must be greater than -0.5.
+2. Mean signal/noise across all 5 conditions must be greater than 1.0. [Signal/noise is defined as mean( measurement value over 68 nts )/mean( statistical error in measurement value over 68 nts)]
+3. To help ensure sequence diversity, the resulting sequences were clustered into clusters with less than 50% sequence similarity, and the 240 test set sequences were chosen from clusters with 3 or fewer members. That is, any sequence in the test set should be sequence similar to at most 2 other sequences.
+
+Note that these filters have not been applied to the 2160 RNAs in the public training data `train.json` -- some of those measurements have negative values or poor signal-to-noise, or some RNA sequences have near-identical sequences in that set. But we are providing all those data in case competitors can squeeze out more signal.

dslighting/registry/stanford-covid-vaccine/description_obfuscated.md

@@ -0,0 +1,63 @@
+# Overview
+
+Predict likely degradation rates at each base of an RNA molecule.
+
+# Metric
+
+Mean columnwise root mean squared error:
+
+$\textrm{MCRMSE} = \frac{1}{N_{t}}\sum_{j=1}^{N_{t}}\sqrt{\frac{1}{n} \sum_{i=1}^{n} (y_{ij} - \hat{y}_{ij})^2}$
+
+where $N_{t}$ is the number of scored ground truth target columns, and $y$ and $\hat{y}$ are the actual and predicted values, respectively.
+
+There are multiple ground truth values provided in the training data. While the submission format requires all 5 to be predicted, only the following are scored: reactivity, deg_Mg_pH10, and deg_Mg_50C.
+
+# Submission Formats
+
+For each sample `id` in the test set, you must predict targets for *each* sequence position (`seqpos`), one per row. If the length of the `sequence` of an `id` is, e.g., 107, then you should make 107 predictions. Positions greater than the `seq_scored` value of a sample are not scored, but still need a value in the solution file.
+
+```csv
+id_seqpos,reactivity,deg_Mg_pH10,deg_pH10,deg_Mg_50C,deg_50C
+id_d190610e8_0,0.1,0.3,0.2,0.5,0.4
+id_d190610e8_1,0.3,0.2,0.5,0.4,0.2
+id_d190610e8_2,0.5,0.4,0.2,0.1,0.2
+etc.
+```
+
+# Dataset 
+
+- **train.json** - the training data
+- **test.json** - the test set, without any columns associated with the ground truth.
+- **sample_submission.csv** - a sample submission file in the correct format
+
+### Columns
+
+- `id` - An arbitrary identifier for each sample.
+- `seq_scored` - (68 in Train and Public Test, 68 in Private Test) Integer value denoting the number of positions used in scoring with predicted values. This should match the length of `reactivity`, `deg_*` and `*_error_*` columns.
+- `seq_length` - (107 in Train and Public Test, 107 in Private Test) Integer values, denotes the length of `sequence`.
+- `sequence` - (1x107 string in Train and Public Test, 107 in Private Test) Describes the RNA sequence, a combination of `A`, `G`, `U`, and `C` for each sample. Should be 107 characters long, and the first 68 bases should correspond to the 68 positions specified in `seq_scored` (note: indexed starting at 0).
+- `structure` - (1x107 string in Train and Public Test, 107 in Private Test) An array of `(`, `)`, and `.` characters that describe whether a base is estimated to be paired or unpaired. Paired bases are denoted by opening and closing parentheses e.g. (....) means that base 0 is paired to base 5, and bases 1-4 are unpaired.
+- `reactivity` - (1x68 vector in Train and Public Test, 1x68 in Private Test) An array of floating point numbers, should have the same length as `seq_scored`. These numbers are reactivity values for the first 68 bases as denoted in `sequence`, and used to determine the likely secondary structure of the RNA sample.
+- `deg_pH10` - (1x68 vector in Train and Public Test, 1x68 in Private Test) An array of floating point numbers, should have the same length as `seq_scored`. These numbers are reactivity values for the first 68 bases as denoted in `sequence`, and used to determine the likelihood of degradation at the base/linkage after incubating without magnesium at high pH (pH 10).
+- `deg_Mg_pH10` - (1x68 vector in Train and Public Test, 1x68 in Private Test) An array of floating point numbers, should have the same length as `seq_scored`. These numbers are reactivity values for the first 68 bases as denoted in `sequence`, and used to determine the likelihood of degradation at the base/linkage after incubating with magnesium in high pH (pH 10).
+- `deg_50C` - (1x68 vector in Train and Public Test, 1x68 in Private Test) An array of floating point numbers, should have the same length as `seq_scored`. These numbers are reactivity values for the first 68 bases as denoted in `sequence`, and used to determine the likelihood of degradation at the base/linkage after incubating without magnesium at high temperature (50 degrees Celsius).
+- `deg_Mg_50C` - (1x68 vector in Train and Public Test, 1x68 in Private Test) An array of floating point numbers, should have the same length as `seq_scored`. These numbers are reactivity values for the first 68 bases as denoted in `sequence`, and used to determine the likelihood of degradation at the base/linkage after incubating with magnesium at high temperature (50 degrees Celsius).
+- `*_error_*` - An array of floating point numbers, should have the same length as the corresponding `reactivity` or `deg_*` columns, calculated errors in experimental values obtained in `reactivity` and `deg_*` columns.
+- `predicted_loop_type` - (1x107 string) Describes the structural context (also referred to as 'loop type')of each character in `sequence`. Loop types assigned by bpRNA from Vienna RNAfold 2 structure. From the bpRNA_documentation: S: paired "Stem" M: Multiloop I: Internal loop B: Bulge H: Hairpin loop E: dangling End X: eXternal loop
+    - `S/N filter` Indicates if the sample passed filters described below in `Additional Notes`.
+
+### Additional Notes
+
+At the beginning of the competition, Stanford scientists have data on 2400 RNA sequences of length 107. For technical reasons, measurements cannot be carried out on the final bases of these RNA sequences, so we have experimental data (ground truth) in 5 conditions for the first 68 bases.
+
+We have split out 240 of these 2400 sequences for a public test set to allow for continuous evaluation through the competition, on the public leaderboard. These sequences, in `test.json`, have been additionally filtered based on three criteria detailed below to ensure that this subset is not dominated by any large cluster of RNA molecules with poor data, which might bias the public leaderboard. The remaining 2160 sequences for which we have data are in `train.json`.
+
+For our final and most important scoring (the Private Leaderbooard), Stanford scientists are carrying out measurements on 240 new RNAs. For these data, we expect to have measurements for the first 68 bases, again missing the ends of the RNA. These sequences constitute the 240 sequences in `test.json`.
+
+For those interested in how the sequences in `test.json` were filtered, here were the steps to ensure a diverse and high quality test set for public leaderboard scoring:
+
+1. Minimum value across all 5 conditions must be greater than -0.5.
+2. Mean signal/noise across all 5 conditions must be greater than 1.0. [Signal/noise is defined as mean( measurement value over 68 nts )/mean( statistical error in measurement value over 68 nts)]
+3. To help ensure sequence diversity, the resulting sequences were clustered into clusters with less than 50% sequence similarity, and the 240 test set sequences were chosen from clusters with 3 or fewer members. That is, any sequence in the test set should be sequence similar to at most 2 other sequences.
+
+Note that these filters have not been applied to the 2160 RNAs in the public training data `train.json` -- some of those measurements have negative values or poor signal-to-noise, or some RNA sequences have near-identical sequences in that set. But we are providing all those data in case competitors can squeeze out more signal.