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

dslighting/registry/tmdb-box-office-prediction/prepare.py

@@ -0,0 +1,35 @@
+from pathlib import Path
+import pandas as pd
+
+
+def prepare(raw: Path, public: Path, private: Path):
+    """
+    Prepare tmdb-box-office-prediction dataset.
+
+    Raw data contains:
+    - train.csv: training data with movie features and revenue
+    - test.csv: test data with movie features only
+    - sample_submission.csv: sample submission format
+    - test_answer.csv: test revenue (private)
+    """
+    # 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"
+    assert "id" in test_answer.columns, "Test answer must have 'id' column"
+    assert "revenue" in test_answer.columns, "Test answer must have 'revenue' column"
+    assert "id" in sample_submission.columns, "Sample submission must have 'id' column"
+    assert "revenue" in sample_submission.columns, "Sample submission must have 'revenue' column"

dslighting/registry/tweet-sentiment-extraction/checksums.yaml

@@ -0,0 +1,7 @@
+private:
+  test.csv: f67a6c60b4b93ad6a7a248a0dfcae16c
+public:
+  sample_submission.csv: 0341dc99c0063baba150e1e64d8b5000
+  test.csv: b52b4f32e127ea49f8f0d218527fa93f
+  train.csv: 4248531bac2a97518a553a38d05355ac
+zip: 561dfe47375e6fdd7b36cd507509f1c2

dslighting/registry/tweet-sentiment-extraction/config.yaml

@@ -0,0 +1,22 @@
+id: tweet-sentiment-extraction
+name: Tweet Sentiment Extraction
+competition_type: code
+awards_medals: true
+prizes:
+  - position: 1
+    value: 7000
+  - position: 2
+    value: 5000
+  - position: 3
+    value: 3000
+description: mlebench/competitions/tweet-sentiment-extraction/description.md
+
+dataset:
+  answers: tweet-sentiment-extraction/prepared/private/test.csv
+  sample_submission: tweet-sentiment-extraction/prepared/public/sample_submission.csv
+
+grader:
+  name: jaccard-similarity
+  grade_fn: mlebench.competitions.tweet-sentiment-extraction.grade:grade
+
+preparer: mlebench.competitions.tweet-sentiment-extraction.prepare:prepare

dslighting/registry/tweet-sentiment-extraction/description.md

@@ -0,0 +1,130 @@
+# Overview
+
+## Description
+
+*"My ridiculous dog is amazing."* [sentiment: positive]
+
+With all of the tweets circulating every second it is hard to tell whether the sentiment behind a specific tweet will impact a company, or a person's, brand for being viral (positive), or devastate profit because it strikes a negative tone. Capturing sentiment in language is important in these times where decisions and reactions are created and updated in seconds. But, which words actually lead to the sentiment description? In this competition you will need to pick out the part of the tweet (word or phrase) that reflects the sentiment.
+
+Help build your skills in this important area with this broad dataset of tweets. Work on your technique to grab a top spot in this competition. What words in tweets support a positive, negative, or neutral sentiment? How can you help make that determination using machine learning tools?
+
+In this competition we've extracted support phrases from [Figure Eight's Data for Everyone platform](https://www.figure-eight.com/data-for-everyone/). The dataset is titled Sentiment Analysis: Emotion in Text tweets with existing sentiment labels, used here under creative commons attribution 4.0. international licence. Your objective in this competition is to construct a model that can do the same - look at the labeled sentiment for a given tweet and figure out what word or phrase best supports it.
+
+Disclaimer: The dataset for this competition contains text that may be considered profane, vulgar, or offensive.
+
+## Evaluation
+
+The metric in this competition is the [word-level Jaccard score](https://en.wikipedia.org/wiki/Jaccard_index). A good description of Jaccard similarity for strings is [here](https://towardsdatascience.com/overview-of-text-similarity-metrics-3397c4601f50). A Python implementation based on the links above, and matched with the output of the C# implementation on the back end, is provided below.
+
+```python
+def jaccard(str1, str2):
+    a = set(str1.lower().split())
+    b = set(str2.lower().split())
+    c = a.intersection(b)
+    return float(len(c)) / (len(a) + len(b) - len(c))
+```
+
+The formula for the overall metric, then, is:
+
+score $=\frac{1}{n} \sum_{i=1}^n \text{jaccard} \left(g t \_i, d t \_i\right)$
+
+where:
+
+- $n$ = number of documents
+
+- $\text{jaccard}$ = the function provided above
+
+- $gt\_i$ = the ith ground truth
+
+- $dt\_i$= the ith prediction
+
+## Submission File
+
+For each ID in the test set, you must predict the string that best supports the sentiment for the tweet in question. Note that the selected text _needs_ to be **quoted** and **complete** (include punctuation, etc. - the above code splits ONLY on whitespace) to work correctly. The file should contain a header and have the following format:
+```
+textID,selected_text
+2,"very good"
+5,"I don't care"
+6,"bad"
+8,"it was, yes"
+etc.
+```
+
+### Timeline
+
+- June 9, 2020 - Entry deadline. You must accept the competition rules before this date in order to compete.
+
+- June 9, 2020 - Team Merger deadline. This is the last day participants may join or merge teams.
+
+- June 16, 2020 - 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 - $7,000
+- 2nd Place - $5,000
+- 3rd Place - $3,000
+
+## Code Requirements
+
+### This is a Code Competition
+
+Submissions to this competition must be made through Notebooks. In order for the "Submit to Competition" button to be active after a commit, the following conditions must be met:
+
+- CPU Kernel <= 3 hours run-time
+- GPU Kernel <= 3 hours run-time
+- No internet access enabled
+- External data, freely & publicly available, is allowed, including pre-trained models
+- Submission file must be named "submission.csv"\
+    Please see the [Code Competition FAQ](https://www.kaggle.com/docs/competitions#kernels-only-FAQ) for more information on how to submit.
+
+### Citation
+
+Maggie, Phil Culliton, Wei Chen. (2020). Tweet Sentiment Extraction. Kaggle. https://kaggle.com/competitions/tweet-sentiment-extraction
+
+
+# Data
+
+## Dataset Description
+
+### What files do I need?
+
+You'll need **train.csv**, **test.csv**, and **sample_submission.csv**.
+
+### What should I expect the data format to be?
+
+Each row contains the `text` of a tweet and a `sentiment` label. In the training set you are provided with a word or phrase drawn from the tweet (`selected_text`) that encapsulates the provided sentiment.
+
+Make sure, when parsing the CSV, to remove the beginning / ending quotes from the `text` field, to ensure that you don't include them in your training.
+
+### What am I predicting?
+
+You're attempting to predict the word or phrase from the tweet that exemplifies the provided sentiment. The word or phrase should include all characters within that span (i.e. including commas, spaces, etc.). The format is as follows:
+
+`<id>,"<word or phrase that supports the sentiment>"`
+
+For example:
+
+```
+2,"very good"
+5,"I am neutral about this"
+6,"bad"
+8,"if you say so!"
+etc.
+```
+
+Files
+-----
+
+- **train.csv** - the training set
+- **test.csv** - the test set
+- **sample_submission.csv** - a sample submission file in the correct format
+
+Columns
+-------
+
+- `textID` - unique ID for each piece of text
+- `text` - the text of the tweet
+- `sentiment` - the general sentiment of the tweet
+- `selected_text` - [train only] the text that supports the tweet's sentiment

dslighting/registry/tweet-sentiment-extraction/description_obfuscated.md

@@ -0,0 +1,30 @@
+# Task
+
+Predict the word or phrase from tweets that exemplifies the labelled sentiment.
+
+# Metric
+
+Word-level Jaccard score.
+
+# Submission Format
+
+For each ID in the test set, you must predict the string that best supports the sentiment for the tweet in question. Note that the selected text _needs_ to be **quoted** and **complete** (include punctuation, etc. - the above code splits ONLY on whitespace) to work correctly. The file should contain a header and have the following format:
+```
+textID,selected_text
+2,"very good"
+5,"I don't care"
+6,"bad"
+8,"it was, yes"
+etc.
+```
+
+# Dataset
+
+- **train.csv** - the training set
+- **test.csv** - the test set
+- **sample_submission.csv** - a sample submission file in the correct format
+
+- `textID` - unique ID for each piece of text
+- `text` - the text of the tweet
+- `sentiment` - the general sentiment of the tweet
+- `selected_text` - [train only] the text that supports the tweet's sentiment

dslighting/registry/tweet-sentiment-extraction/grade.py

@@ -0,0 +1,67 @@
+import numpy as np
+import pandas as pd
+
+from mlebench.grade_helpers import InvalidSubmissionError
+
+
+def jaccard(str1: str, str2: str) -> float:
+    """
+    Given by the competition page: https://www.kaggle.com/competitions/tweet-sentiment-extraction/overview
+    """
+    a = set(str1.lower().split())
+    b = set(str2.lower().split())
+    c = a.intersection(b)
+    return float(len(c)) / (len(a) + len(b) - len(c))
+
+
+def mean_jaccard(preds: list[str], answers: list[str]) -> float:
+    return float(np.mean([jaccard(a, b) for a, b in zip(preds, answers)]))
+
+
+def prepare_for_metric(
+    submission: pd.DataFrame, answers: pd.DataFrame
+) -> tuple[list[str], list[str]]:
+    """
+    The submission and answers are DataFrames with the following columns:
+    ```
+    textID,selected_text
+    2,"very good"
+    5,"I don't care"
+    6,"bad"
+    8,"it was, yes"
+    etc.
+    ```
+    """
+
+    if "textID" not in submission.columns:
+        raise InvalidSubmissionError("Submission DataFrame must have a 'textID' column.")
+    if "selected_text" not in submission.columns:
+        raise InvalidSubmissionError("Submission DataFrame must have a 'selected_text' column.")
+    if len(submission) != len(answers):
+        raise InvalidSubmissionError(
+            "Submission and answers DataFrames must have the same number of rows."
+        )
+    assert "textID" in answers.columns, "Answers DataFrame must have a 'textID' column."
+    assert (
+        "selected_text" in answers.columns
+    ), "Answers DataFrame must have a 'selected_text' column."
+
+    # Sort by textID
+    submission = submission.sort_values("textID")
+    answers = answers.sort_values("textID")
+
+    if (submission["textID"].values != answers["textID"].values).any():
+        raise InvalidSubmissionError(
+            "Submission and answers DataFrames must have the same textID values."
+        )
+
+    # Note: empty strings in the submission get read as NaNs, so we fill them with empty strings
+    # before converting to str (otherwise pandas will convert NaNs to "nan" strings)
+    submission_labels = submission["selected_text"].fillna("").astype(str).tolist()
+    answer_labels = answers["selected_text"].fillna("").astype(str).tolist()
+    return submission_labels, answer_labels
+
+
+def grade(submission: pd.DataFrame, answers: pd.DataFrame) -> float:
+    submission_labels, answer_labels = prepare_for_metric(submission, answers)
+    return mean_jaccard(submission_labels, answer_labels)

dslighting/registry/tweet-sentiment-extraction/prepare.py

@@ -0,0 +1,36 @@
+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):
+    """
+    Splits the data in raw into public and private datasets with appropriate test/train splits.
+    """
+
+    # 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=["selected_text"])
+
+    new_train.to_csv(public / "train.csv", index=False)
+    new_test.to_csv(private / "test.csv", index=False)
+    new_test_without_labels.to_csv(public / "test.csv", index=False)
+
+    assert len(new_test_without_labels) == len(
+        new_test
+    ), f"Expected new_test_without_labels ({len(new_test_without_labels)}) == new_test ({len(new_test)})"
+    assert len(new_train) + len(new_test) == len(
+        old_train
+    ), f"Expected new_train ({len(new_train)}) + new_test ({len(new_test)}) == old_train ({len(old_train)})"
+
+    # Create a sample submission file
+    submission_df = new_test.copy()[["textID", "selected_text"]]
+    submission_df["selected_text"] = ""
+
+    submission_df.to_csv(public / "sample_submission.csv", index=False)
+    assert len(submission_df) == len(
+        new_test
+    ), f"Expected submission_df ({len(submission_df)}) == new_test ({len(new_test)})"

dslighting/registry/tweet-sentiment-extraction/prepare_val.py

@@ -0,0 +1,106 @@
+from pathlib import Path
+import pandas as pd
+
+from sklearn.model_selection import train_test_split
+
+from mlebench.utils import read_csv
+
+
+def _split_and_save(
+    source_df: pd.DataFrame,
+    test_size: float,
+    random_state: int,
+    public_dir: Path,
+    private_dir: Path,
+    label_col: str = "selected_text",
+    id_col: str = "textID",
+) -> tuple[pd.DataFrame, pd.DataFrame]:
+    """
+    Helper function to perform a train/test split and save the results.
+
+    Args:
+        source_df: The DataFrame to split.
+        test_size: The proportion of the dataset to allocate to the test split.
+        random_state: The seed used by the random number generator.
+        public_dir: The directory to save public artifacts (train set, unlabeled test set).
+        private_dir: The directory to save private artifacts (labeled test set).
+        label_col: The name of the column containing the label.
+        id_col: The name of the column containing the unique ID.
+
+    Returns:
+        A tuple containing the created train and test DataFrames.
+    """
+    # Ensure output directories exist
+    public_dir.mkdir(parents=True, exist_ok=True)
+    private_dir.mkdir(parents=True, exist_ok=True)
+
+    # Perform the split
+    train_df, test_df = train_test_split(
+        source_df, test_size=test_size, random_state=random_state
+    )
+    test_df_without_labels = test_df.drop(columns=[label_col])
+
+    # Save the datasets
+    train_df.to_csv(public_dir / "train.csv", index=False)
+    test_df.to_csv(private_dir / "test.csv", index=False)
+    test_df_without_labels.to_csv(public_dir / "test.csv", index=False)
+
+    assert len(test_df_without_labels) == len(
+        test_df
+    ), f"Expected test_df_without_labels ({len(test_df_without_labels)}) == test_df ({len(test_df)})"
+    assert len(train_df) + len(test_df) == len(
+        source_df
+    ), f"Expected train_df ({len(train_df)}) + test_df ({len(test_df)}) == source_df ({len(source_df)})"
+
+    # Create and save a sample submission file
+    submission_df = test_df.copy()[[id_col, label_col]]
+    submission_df[label_col] = ""
+
+    submission_df.to_csv(public_dir / "sample_submission.csv", index=False)
+    assert len(submission_df) == len(
+        test_df
+    ), f"Expected submission_df ({len(submission_df)}) == test_df ({len(test_df)})"
+
+    return train_df, test_df
+
+
+def prepare(raw: Path, public: Path, private: Path):
+    """
+    Splits the data in raw into public and private datasets with appropriate test/train splits.
+    Also creates a second, parallel split for validation purposes.
+    """
+    old_train = read_csv(raw / "train.csv")
+
+    # ---- Original Data Split (for final test set) ----
+    # This split creates the main train and test sets for the competition.
+    # The outputs in `public` and `private` are left completely unchanged.
+    train_for_val_split, _ = _split_and_save(
+        source_df=old_train,
+        test_size=0.1,
+        random_state=0,
+        public_dir=public,
+        private_dir=private,
+    )
+
+    # ---- New Validation Data Split ----
+    # This second split takes the training set created above and splits it *again*
+    # to create a new, smaller training set and a validation set. The results are
+    # saved to parallel `public_val` and `private_val` directories.
+
+    # Define paths for the new validation split
+    public_val = public.parent / "public_val"
+    private_val = private.parent / "private_val"
+
+    # The original test set size was 0.1 of the total data. The new train set
+    # is 0.9 of the total. To make the new validation set (test_val) have
+    # roughly the same number of samples as the original test set, we use a
+    # test_size of (0.1 / 0.9) = 1/9.
+    validation_test_size = 1 / 9
+
+    _split_and_save(
+        source_df=train_for_val_split,
+        test_size=validation_test_size,
+        random_state=0,  # Use same random_state for consistency
+        public_dir=public_val,
+        private_dir=private_val,
+    )

dslighting/registry/us-patent-phrase-to-phrase-matching/checksums.yaml

@@ -0,0 +1,7 @@
+private:
+  test.csv: 34f67932a2c9f49169cdccf5e7bbc57f
+public:
+  sample_submission.csv: 282590a9bcbf32edf5d351a40a30c6a0
+  test.csv: ea1dccd31666f938f0ae7632c69c95c6
+  train.csv: 48042478b2d9a8f36d614589b7ee86e4
+zip: e3eae0b5c78ed58de04e1f32e499188a

dslighting/registry/us-patent-phrase-to-phrase-matching/config.yaml

@@ -0,0 +1,22 @@
+id: us-patent-phrase-to-phrase-matching
+name: U.S. Patent Phrase to Phrase Matching
+competition_type: code
+awards_medals: true
+prizes:
+  - position: 1
+    value: 1200
+  - position: 2
+    value: 8000
+  - position: 3
+    value: 5000
+description: mlebench/competitions/us-patent-phrase-to-phrase-matching/description.md
+
+dataset:
+  answers: us-patent-phrase-to-phrase-matching/prepared/private/test.csv
+  sample_submission: us-patent-phrase-to-phrase-matching/prepared/public/sample_submission.csv
+
+grader:
+  name: pearson-correlation-coefficient
+  grade_fn: mlebench.competitions.us-patent-phrase-to-phrase-matching.grade:grade
+
+preparer: mlebench.competitions.us-patent-phrase-to-phrase-matching.prepare:prepare

dslighting/registry/us-patent-phrase-to-phrase-matching/description.md

@@ -0,0 +1,118 @@
+# Overview
+
+## Description
+
+Can you extract meaning from a large, text-based dataset derived from inventions? Here's your chance to do so.
+
+The U.S. Patent and Trademark Office (USPTO) offers one of the largest repositories of scientific, technical, and commercial information in the world through its [Open Data Portal](https://developer.uspto.gov/about-open-data). Patents are a form of [intellectual property](https://www.uspto.gov/patents/basics/general-information-patents) granted in exchange for the public disclosure of new and useful inventions. Because patents undergo an intensive [vetting process](https://www.uspto.gov/sites/default/files/documents/InventionCon2020_Understanding_the_Patent_Examination_Process.pdf) prior to grant, and because the history of U.S. innovation spans over two centuries and 11 million patents, the U.S. patent archives stand as a rare combination of data volume, quality, and diversity.
+
+> "The USPTO serves an American innovation machine that never sleeps by granting patents, registering trademarks, and promoting intellectual property around the globe. The USPTO shares over 200 years' worth of human ingenuity with the world, from lightbulbs to quantum computers. Combined with creativity from the data science community, USPTO datasets carry unbounded potential to empower AI and ML models that will benefit the progress of science and society at large."
+>
+> --- USPTO Chief Information Officer Jamie Holcombe
+
+In this competition, you will train your models on a novel semantic similarity dataset to extract relevant information by matching key phrases in patent documents. Determining the semantic similarity between phrases is critically important during the patent search and examination process to determine if an invention has been described before. For example, if one invention claims "television set" and a prior publication describes "TV set", a model would ideally recognize these are the same and assist a patent attorney or examiner in retrieving relevant documents. This extends beyond paraphrase identification; if one invention claims a "strong material" and another uses "steel", that may also be a match. What counts as a "strong material" varies per domain (it may be steel in one domain and ripstop fabric in another, but you wouldn't want your parachute made of steel). We have included the Cooperative Patent Classification as the technical domain context as an additional feature to help you disambiguate these situations.
+
+Can you build a model to match phrases in order to extract contextual information, thereby helping the patent community connect the dots between millions of patent documents?
+
+> This is a Code Competition. Refer to [Code Requirements](https://www.kaggle.com/c/us-patent-phrase-to-phrase-matching/overview/code-requirements) for details.
+
+## Evaluation
+
+Submissions are evaluated on the [Pearson correlation coefficient](https://en.wikipedia.org/wiki/Pearson_correlation_coefficient) between the predicted and actual similarity `score`s.
+
+## Submission File
+
+For each `id` (representing a pair of phrases) in the test set, you must predict the similarity `score`. The file should contain a header and have the following format:
+
+```
+id,score
+4112d61851461f60,0
+09e418c93a776564,0.25
+36baf228038e314b,1
+etc.
+
+```
+
+## Timeline
+
+- March 21, 2022 - Start Date.
+- June 13, 2022 - Entry Deadline. You must accept the competition rules before this date in order to compete.
+- June 13, 2022 - Team Merger Deadline. This is the last day participants may join or merge teams.
+- June 20, 2022 - 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 - $ 12,000
+- 2nd Place - $ 8,000
+- 3rd 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.
+
+## USPTO Open Data
+
+## Acknowledgments
+
+![USPTO logo](https://www.uspto.gov/profiles/uspto_gov/themes/uspto/images/USPTO-logo-RGB-stacked-1200px.png)
+
+Data for this competition is derived from the public archives of the U.S. Patent and Trademark Office (USPTO). These archives, offered in machine-readable formats, have already enabled numerous AI research projects such as the [training of large-scale language models](https://arxiv.org/abs/2101.00027). Beyond enabling AI research, patent documents can also be used to understand the [dynamics of AI innovation at large](https://www.uspto.gov/ip-policy/economic-research/research-datasets/artificial-intelligence-patent-dataset).
+
+USPTO data is offered both in bulk and via API through the [USPTO Open Data Portal](https://developer.uspto.gov/). Additionally, a prototype API covering a subset of USPTO data is available at [PatentsView](https://patentsview.org/apis/purpose).
+
+## Citation
+
+Don Cenkci, Grigor Aslanyan, Ian Wetherbee, jm, Kiran Gunda, Maggie, Scott Beliveau, Will Cukierski. (2022). U.S. Patent Phrase to Phrase Matching . Kaggle. https://kaggle.com/competitions/us-patent-phrase-to-phrase-matching
+
+
+# Data
+
+## Dataset Description
+
+In this dataset, you are presented pairs of phrases (an `anchor` and a `target` phrase) and asked to rate how similar they are on a scale from 0 (not at all similar) to 1 (identical in meaning). This challenge differs from a standard semantic similarity task in that similarity has been scored here within a patent's `context`, specifically its [CPC classification (version 2021.05)](https://en.wikipedia.org/wiki/Cooperative_Patent_Classification), which indicates the subject to which the patent relates. For example, while the phrases "bird" and "Cape Cod" may have low semantic similarity in normal language, the likeness of their meaning is much closer if considered in the context of "house".
+
+This is a code competition, in which you will submit code that will be run against an unseen test set. The unseen test set contains approximately 12k pairs of phrases. A small public test set has been provided for testing purposes, but is not used in scoring.
+
+Information on the meaning of CPC codes may be found on the [USPTO website](https://www.uspto.gov/web/patents/classification/cpc/html/cpc.html). The CPC version 2021.05 can be found on the [CPC archive website](https://www.cooperativepatentclassification.org/Archive).
+
+## Score meanings
+
+The scores are in the 0-1 range with increments of 0.25 with the following meanings:
+
+- **1.0** - Very close match. This is typically an exact match except possibly for differences in conjugation, quantity (e.g. singular vs. plural), and addition or removal of stopwords (e.g. "the", "and", "or").
+- **0.75** - Close synonym, e.g. "mobile phone" vs. "cellphone". This also includes abbreviations, e.g. "TCP" -> "transmission control protocol".
+- **0.5** - Synonyms which don't have the same meaning (same function, same properties). This includes broad-narrow (hyponym) and narrow-broad (hypernym) matches.
+- **0.25** - Somewhat related, e.g. the two phrases are in the same high level domain but are not synonyms. This also includes antonyms.
+- **0.0** - Unrelated.
+
+Files
+-----
+
+- **train.csv** - the training set, containing phrases, contexts, and their similarity scores
+- **test.csv** - the test set set, identical in structure to the training set but without the score
+- **sample_submission.csv** - a sample submission file in the correct format
+
+Columns
+-------
+
+- `id` - a unique identifier for a pair of phrases
+- `anchor` - the first phrase
+- `target` - the second phrase
+- `context` - the [CPC classification (version 2021.05)](https://en.wikipedia.org/wiki/Cooperative_Patent_Classification), which indicates the subject within which the similarity is to be scored
+- `score` - the similarity. This is sourced from a combination of one or more manual expert ratings.
+
+> "Google Patent Phrase Similarity Dataset" by Google is licensed under a Creative Commons Attribution 4.0 International License (CC BY 4.0)

dslighting/registry/us-patent-phrase-to-phrase-matching/description_obfuscated.md

@@ -0,0 +1,46 @@
+# Task
+
+Given pairs of phrases (an `anchor` and a `target` phrase), build a model to rate how similar they are.  
+
+# Metric
+
+Pearson correlation coefficient.
+
+# Submission Format
+
+For each `id` (representing a pair of phrases) in the test set, you must predict the similarity `score`. The file should contain a header and have the following format:
+
+```
+id,score
+4112d61851461f60,0
+09e418c93a776564,0.25
+36baf228038e314b,1
+etc.
+
+```
+
+# Dataset
+
+The scores are in the 0-1 range with increments of 0.25 with the following meanings:
+
+- **1.0** - Very close match. This is typically an exact match except possibly for differences in conjugation, quantity (e.g. singular vs. plural), and addition or removal of stopwords (e.g. "the", "and", "or").
+- **0.75** - Close synonym, e.g. "mobile phone" vs. "cellphone". This also includes abbreviations, e.g. "TCP" -> "transmission control protocol".
+- **0.5** - Synonyms which don't have the same meaning (same function, same properties). This includes broad-narrow (hyponym) and narrow-broad (hypernym) matches.
+- **0.25** - Somewhat related, e.g. the two phrases are in the same high level domain but are not synonyms. This also includes antonyms.
+- **0.0** - Unrelated.
+
+Files
+-----
+
+- **train.csv** - the training set, containing phrases, contexts, and their similarity scores
+- **test.csv** - the test set set, identical in structure to the training set but without the score
+- **sample_submission.csv** - a sample submission file in the correct format
+
+Columns
+-------
+
+- `id` - a unique identifier for a pair of phrases
+- `anchor` - the first phrase
+- `target` - the second phrase
+- `context` - the [CPC classification (version 2021.05)](https://en.wikipedia.org/wiki/Cooperative_Patent_Classification), which indicates the subject within which the similarity is to be scored
+- `score` - the similarity. This is sourced from a combination of one or more manual expert ratings.