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

dslighting/registry/new-my-task-03/report.md

@@ -0,0 +1 @@
+Develop a model that captures the flow of play as points occur and apply it to one or more of the matches. Your model should identify which player is performing better at a given time in the match, as well as how much better they are performing. Provide a visualization based on your model to depict the match flow. Note: in tennis, the player serving has a much higher probability of winning the point/game. You may wish to factor this into your model in some way.

dslighting/registry/new-my-task-03/rubric.md

@@ -0,0 +1,10 @@
+Definition: The CPD tracks the running difference between the total points won by Player 1 and Player 2 at any given moment in the match.
+
+Formula: $$CPD_t = (P1_Points_Won_t) - (P2_Points_Won_t)$$
+
+Interpretation:
+
+CPD > 0: Player 1 is currently performing better (leading in total points).
+CPD < 0: Player 2 is currently performing better (leading in total points).
+CPD = 0: The match is tied in terms of points won.
+Contextual Adjustment (Serving): Since the server has a higher probability of winning, the 'flow' is most significant when the CPD trends upwards during the opponent's service games (break points) or maintains stability during one's own service games. The visualization will plot CPD over time (point number) to show the momentum shifts.

dslighting/registry/new-york-city-taxi-fare-prediction/checksums.yaml

@@ -0,0 +1,7 @@
+private:
+  test.csv: f51d45e95bcd7565f1175206e604506e
+public:
+  labels.csv: b1aa60e8d6ca817c18b23bd00e4a2500
+  sample_submission.csv: 10c791174db974943c1c80f38fc86391
+  test.csv: a7b9d9b7208e9b7cff6891cfd56a0053
+zip: fe01f4ab11ebb0ee2851754516883070

dslighting/registry/new-york-city-taxi-fare-prediction/config.yaml

@@ -0,0 +1,17 @@
+id: new-york-city-taxi-fare-prediction
+name: New York City Taxi Fare Prediction
+competition_type: simple
+awards_medals: false
+prizes: null
+description: mlebench/competitions/new-york-city-taxi-fare-prediction/description.md
+
+dataset:
+  answers: new-york-city-taxi-fare-prediction/prepared/private/test.csv
+  sample_submission: new-york-city-taxi-fare-prediction/prepared/public/sample_submission.csv
+
+grader:
+  name: root-mean-squared-error
+  grade_fn: mlebench.competitions.new-york-city-taxi-fare-prediction.grade:grade
+
+preparer: mlebench.competitions.new-york-city-taxi-fare-prediction.prepare:prepare
+

dslighting/registry/new-york-city-taxi-fare-prediction/description.md

@@ -0,0 +1,100 @@
+## Description
+
+In this playground competition, hosted in partnership with Google Cloud and Coursera, you are tasked with predicting the fare amount (inclusive of tolls) for a taxi ride in New York City given the pickup and dropoff locations. While you can get a basic estimate based on just the distance between the two points, this will result in an RMSE of $5-$8, depending on the model used (see [the starter code](https://www.kaggle.com/dster/nyc-taxi-fare-starter-kernel-simple-linear-model) for an example of this approach in Kernels). Your challenge is to do better than this using Machine Learning techniques!
+
+To learn how to handle large datasets with ease and solve this problem using TensorFlow, consider taking the [Machine Learning with TensorFlow on Google Cloud Platform](https://www.coursera.org/specializations/machine-learning-tensorflow-gcp?utm_source=googlecloud&utm_medium=institutions&utm_campaign=kaggle_competition_email) specialization on Coursera -- the taxi fare problem is one of several real-world problems that are used as case studies in the series of courses. To make this easier, head to [Coursera.org/NEXTextended](https://www.coursera.org/promo/NEXTExtended?utm_source=googlecloud&utm_medium=institutions&utm_campaign=kaggle_competition_2018) to claim this specialization for free for the first month!
+
+## Evaluation
+
+The evaluation metric for this competition is the [root mean-squared error](http://en.wikipedia.org/wiki/Root-mean-square_deviation) or RMSE. RMSE measures the difference between the predictions of a model, and the corresponding ground truth. A large RMSE is equivalent to a large average error, so smaller values of RMSE are better. One nice property of RMSE is that the error is given in the units being measured, so you can tell very directly how incorrect the model might be on unseen data.
+
+RMSE is given by:
+
+$$
+\mathrm{RMSE}=\sqrt{\frac{1}{n} \sum_{i=1}^n\left( \hat{y}_i-y_i\right)^2}
+$$
+where \\( y_i \\) is the ith observation and
+$$
+
+ \hat{y}_i
+
+$$
+
+is the prediction for that observation. 
+
+Example 1. Suppose we have one observation, with an actual value of 12.5 and a prediction of 12.5 (good job!). The RMSE will be:
+
+$$
+\text { RMSE }_{\text {examplel } 1}=\sqrt{\frac{1}{1}(12.5-12.5)^2}=0
+$$
+
+Example 2. We'll add another data point. Your prediction for the second data point is 11.0 and the actual value is 14.0. The RMSE will be:
+
+$$
+\operatorname{RMSE}_{\text {example } 2}=\sqrt{\frac{1}{2}\left((12.5-12.5)^2+(11.0-14.0)^2\right)}=\sqrt{\frac{9}{2}} \approx 2.12
+$$
+
+### Kernel Submissions
+
+You can make submissions directly from Kaggle Kernels. By adding your teammates as collaborators on a kernel, you can share and edit code privately with them.
+
+### Submission File
+
+For each `key` in the test set, you must predict a value for the `fare_amount` variable. The file should contain a header and have the following format:
+
+```
+key,fare_amount
+2015-01-27 13:08:24.0000002,11.00
+2015-02-27 13:08:24.0000002,12.05
+2015-03-27 13:08:24.0000002,11.23
+2015-04-27 13:08:24.0000002,14.17
+2015-05-27 13:08:24.0000002,15.12
+etc
+```
+
+## Timeline
+
+**September 25, 2018** - 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.
+
+## Getting Started
+
+- **Kernels Starter Tutorial**: Check out our [starter tutorial notebook](https://www.kaggle.com/dster/nyc-taxi-fare-starter-kernel-simple-linear-model) in Kaggle Kernels.
+- **Google Cloud Coursera Specialization**: To learn how to handle large datasets with ease and solve this problem using TensorFlow, consider taking the [Machine Learning with TensorFlow on Google Cloud Platform](https://www.coursera.org/specializations/machine-learning-tensorflow-gcp?utm_source=googlecloud&utm_medium=institutions&utm_campaign=kaggle_competition_email) specialization on Coursera -- the taxi fare problem is one of several real-world problems that are used as case studies in the series of courses. To make this easier, head to [Coursera.org/NEXTextended](https://www.coursera.org/promo/NEXTExtended?utm_source=googlecloud&utm_medium=institutions&utm_campaign=kaggle_competition_2018) to claim this specialization for free for the first month!
+- **BigQuery Dataset**: The competition data is also hosted directly within BigQuery, split into the identical Train & Test Features as provided in this competition. You can publicly access & work with the data [directly in BigQuery, here](https://bigquery.cloud.google.com/dataset/cloud-training-demos:taxifare_kaggle)!
+- **Google Cloud Platform**: Use Google Cloud Platform (GCP), including BigQuery. New users can receive [$300 in free trial credits](https://cloud.google.com/free/).
+- **Extra $50 GCP Coupons**: For those who have already exhausted the free trial credits, you can request an additional $50 in coupon credit through instructions provided on the linked doc in the Data Page files. Only those who have made a submission to the competition are eligible for this coupon.
+
+## Citation
+
+Andy Chavez, DJ Sterling, Julia Elliott, Lakshmanan V, Sagar, Will Cukierski. (2018). New York City Taxi Fare Prediction. Kaggle. https://kaggle.com/competitions/new-york-city-taxi-fare-prediction
+
+# Data
+
+## Dataset Description
+
+### File descriptions
+
+- **train.csv** - Input features and target `fare_amount` values for the training set (about 55M rows).
+- **test.csv** - Input features for the test set (about 10K rows). Your goal is to predict `fare_amount` for each row.
+- **sample_submission.csv** - a sample submission file in the correct format (columns `key` and `fare_amount`). This file 'predicts' `fare_amount` to be $`11.35` for all rows, which is the mean `fare_amount` from the training set.
+
+### Data fields
+
+**ID**
+
+- **key** - Unique `string` identifying each row in both the training and test sets. Comprised of **pickup_datetime** plus a unique integer, but this doesn't matter, it should just be used as a unique ID field.Required in your submission CSV. Not necessarily needed in the training set, but could be useful to simulate a 'submission file' while doing cross-validation within the training set.
+
+**Features**
+
+- **pickup_datetime** - `timestamp` value indicating when the taxi ride started.
+- **pickup_longitude** - `float` for longitude coordinate of where the taxi ride started.
+- **pickup_latitude** - `float` for latitude coordinate of where the taxi ride started.
+- **dropoff_longitude** - `float` for longitude coordinate of where the taxi ride ended.
+- **dropoff_latitude** - `float` for latitude coordinate of where the taxi ride ended.
+- **passenger_count** - `integer` indicating the number of passengers in the taxi ride.
+
+**Target**
+
+- **fare_amount** - `float` dollar amount of the cost of the taxi ride. This value is only in the training set; this is what you are predicting in the test set and it is required in your submission CSV.

dslighting/registry/new-york-city-taxi-fare-prediction/description_obfuscated.md

@@ -0,0 +1,46 @@
+# Task
+
+Predict the fare amount for a taxi ride given the pickup and dropoff locations.
+
+# Metric
+
+Root mean-squared error.
+
+# Submission Format
+
+For each `key` in the test set, you must predict a value for the `fare_amount` variable. The file should contain a header and have the following format:
+
+```
+key,fare_amount
+2015-01-27 13:08:24.0000002,11.00
+2015-02-27 13:08:24.0000002,12.05
+2015-03-27 13:08:24.0000002,11.23
+2015-04-27 13:08:24.0000002,14.17
+2015-05-27 13:08:24.0000002,15.12
+etc
+```
+
+# Dataset
+
+- **train.csv** - Input features and target `fare_amount` values for the training set (about 55M rows).
+- **test.csv** - Input features for the test set (about 10K rows). Your goal is to predict `fare_amount` for each row.
+- **sample_submission.csv** - a sample submission file in the correct format (columns `key` and `fare_amount`). This file 'predicts' `fare_amount` to be $`11.35` for all rows, which is the mean `fare_amount` from the training set.
+
+## Data fields
+
+**ID**
+
+- **key** - Unique `string` identifying each row in both the training and test sets. Comprised of **pickup_datetime** plus a unique integer, but this doesn't matter, it should just be used as a unique ID field.Required in your submission CSV. Not necessarily needed in the training set, but could be useful to simulate a 'submission file' while doing cross-validation within the training set.
+
+**Features**
+
+- **pickup_datetime** - `timestamp` value indicating when the taxi ride started.
+- **pickup_longitude** - `float` for longitude coordinate of where the taxi ride started.
+- **pickup_latitude** - `float` for latitude coordinate of where the taxi ride started.
+- **dropoff_longitude** - `float` for longitude coordinate of where the taxi ride ended.
+- **dropoff_latitude** - `float` for latitude coordinate of where the taxi ride ended.
+- **passenger_count** - `integer` indicating the number of passengers in the taxi ride.
+
+**Target**
+
+- **fare_amount** - `float` dollar amount of the cost of the taxi ride. This value is only in the training set; this is what you are predicting in the test set and it is required in your submission CSV.

dslighting/registry/new-york-city-taxi-fare-prediction/grade.py

@@ -0,0 +1,28 @@
+from pandas import DataFrame
+from sklearn.metrics import root_mean_squared_error
+
+from mlebench.grade_helpers import InvalidSubmissionError
+
+
+def prepare_for_metric(submission: DataFrame, answers: DataFrame) -> dict:
+
+    assert "fare_amount" in answers.columns, "Answers should have a fare_amount column"
+    assert "key" in answers.columns, "Answers should have a key column"
+    if "fare_amount" not in submission.columns:
+        raise InvalidSubmissionError("Submission should have a fare_amount column")
+    if "key" not in submission.columns:
+        raise InvalidSubmissionError("Submission should have a key column")
+
+    # Sort by 'key' to ensure alignment
+    submission = submission.sort_values("key")
+    answers = answers.sort_values("key")
+
+    y_true = answers["fare_amount"]
+    y_pred = submission["fare_amount"]
+
+    return y_true, y_pred
+
+
+def grade(submission: DataFrame, answers: DataFrame) -> float:
+    y_true, y_pred = prepare_for_metric(submission, answers)
+    return root_mean_squared_error(y_true, y_pred)

dslighting/registry/new-york-city-taxi-fare-prediction/prepare.py

@@ -0,0 +1,44 @@
+import shutil
+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, test from train split
+    old_train = read_csv(raw / "train.csv")
+
+    # Train is c. 55M rows, original test is 9914 rows
+    new_train, new_test = train_test_split(old_train, test_size=9914, random_state=0)
+    new_test_without_labels = new_test.drop(columns=["fare_amount"])
+
+    # Create a sample submission file
+    submission_df = new_test.copy()[["key"]]
+    submission_df["fare_amount"] = 11.35
+
+    # Write CSVs
+    new_train.to_csv(public / "labels.csv", index=False)
+    new_test_without_labels.to_csv(public / "test.csv", index=False)
+    submission_df.to_csv(public / "sample_submission.csv", index=False)
+    new_test.to_csv(private / "test.csv", index=False)
+
+    # Copy over other files
+    shutil.copy(raw / "GCP-Coupons-Instructions.rtf", public / "GCP-Coupons-Instructions.rtf")
+
+    # Checks
+    assert set(new_train["key"]).isdisjoint(
+        set(new_test["key"])
+    ), "Train and test sets share samples!"
+    assert new_test.shape[1] == 8, f"Test set should have 8 columns, but has {new_test.shape[1]}"
+    assert (
+        new_test_without_labels.shape[1] == 7
+    ), f"Test set without labels should have 7 columns, but has {new_test_without_labels.shape[1]}"
+    assert new_train.shape[1] == 8, f"Train set should have 8 columns, but has {new_train.shape[1]}"
+    assert (
+        submission_df.shape[1] == 2
+    ), f"Sample submission should have 2 columns, but has {submission_df.shape[1]}"
+    assert (
+        submission_df.shape[0] == new_test.shape[0]
+    ), f"Sample submission should have {new_test.shape[0]} rows, but has {submission_df.shape[0]}"

dslighting/registry/new-york-city-taxi-fare-prediction/prepare_val.py

@@ -0,0 +1,89 @@
+import shutil
+from pathlib import Path
+
+import pandas as pd
+from sklearn.model_selection import train_test_split
+
+from mlebench.utils import read_csv
+
+
+def _save_split(
+    train_df: pd.DataFrame, test_df: pd.DataFrame, public_path: Path, private_path: Path
+):
+    """
+    Saves a given train/test split to the specified public and private directories.
+
+    This helper function ensures a consistent file structure and naming convention
+    for any data split.
+
+    Args:
+        train_df: The training dataframe.
+        test_df: The testing dataframe (with labels).
+        public_path: The path to the public output directory.
+        private_path: The path to the private output directory.
+    """
+    # Ensure output directories exist
+    public_path.mkdir(parents=True, exist_ok=True)
+    private_path.mkdir(parents=True, exist_ok=True)
+
+    # Prepare dataframes for saving
+    test_without_labels = test_df.drop(columns=["fare_amount"])
+    submission_df = test_df.copy()[["key"]]
+    submission_df["fare_amount"] = 11.35  # A sample constant value
+
+    # Write CSVs to public and private directories
+    train_df.to_csv(public_path / "train.csv", index=False)
+    test_without_labels.to_csv(public_path / "test.csv", index=False)
+    submission_df.to_csv(public_path / "sample_submission.csv", index=False)
+    test_df.to_csv(private_path / "test.csv", index=False)
+
+    # Run checks to ensure data integrity
+    assert set(train_df["key"]).isdisjoint(
+        set(test_df["key"])
+    ), "Train and test sets share samples!"
+    assert test_df.shape[1] == 8, f"Test set should have 8 columns, but has {test_df.shape[1]}"
+    assert (
+        test_without_labels.shape[1] == 7
+    ), f"Test set without labels should have 7 columns, but has {test_without_labels.shape[1]}"
+    assert train_df.shape[1] == 8, f"Train set should have 8 columns, but has {train_df.shape[1]}"
+    assert (
+        submission_df.shape[1] == 2
+    ), f"Sample submission should have 2 columns, but has {submission_df.shape[1]}"
+    assert (
+        submission_df.shape[0] == test_df.shape[0]
+    ), f"Sample submission should have {test_df.shape[0]} rows, but has {submission_df.shape[0]}"
+
+
+def prepare(raw: Path, public: Path, private: Path):
+    # Load the raw training data
+    old_train = read_csv(raw / "train.csv")
+
+    # --- 1. Create the original train/test split for the main competition files ---
+    # This split creates the primary train and test sets.
+    # The outputs in `public/` and `private/` will not be changed.
+    train_orig, test_orig = train_test_split(old_train, test_size=9914, random_state=0)
+
+    # Save the original split results
+    _save_split(
+        train_df=train_orig, test_df=test_orig, public_path=public, private_path=private
+    )
+
+    # Copy over other files to the original public directory
+    shutil.copy(raw / "GCP-Coupons-Instructions.rtf", public / "GCP-Coupons-Instructions.rtf")
+
+    # --- 2. Create the new train/validation split for local validation ---
+    # This second split takes the `train_orig` set and splits it again to create
+    # a smaller training set and a new validation set (`test_val`).
+    # The logic and test size are identical to the first split.
+    public_val = public.parent / "public_val"
+    private_val = private.parent / "private_val"
+
+    train_val, test_val = train_test_split(train_orig, test_size=9914, random_state=0)
+
+    # Save the validation split results to the new directories
+    _save_split(
+        train_df=train_val, test_df=test_val, public_path=public_val, private_path=private_val
+    )
+
+    # 复制相同的文件到 public_val 目录
+    shutil.copy(raw / "GCP-Coupons-Instructions.rtf", public_val / "GCP-Coupons-Instructions.rtf")

dslighting/registry/nfl-player-contact-detection/checksums.yaml

@@ -0,0 +1,12 @@
+private:
+  test.csv: fa42cdab2f042c5bd0665d7739a715fb
+public:
+  sample_submission.csv: e4fe9463edad278506f9911fd86b17f3
+  test_baseline_helmets.csv: 2981cca0abdb9305780edfea905a7ff4
+  test_player_tracking.csv: dfa825f54143e63aa4b7ccba897e4d3f
+  test_video_metadata.csv: 6978a882a8cf8ec2141e5df6959c2617
+  train_baseline_helmets.csv: 063ba03e0ca7acf3c17bd74d704983f0
+  train_labels.csv: 8721fe87ec4fb244ecf217522045ab8c
+  train_player_tracking.csv: 5f8604c4c541db8d1f0247de34e99cd2
+  train_video_metadata.csv: 5ba91169bc8df45c0334db954c86cbc3
+zip: 9fc02688ee4e93ab144338a90f8d07a8

dslighting/registry/nfl-player-contact-detection/config.yaml

@@ -0,0 +1,26 @@
+id: nfl-player-contact-detection
+name: 1st and Future - Player Contact Detection
+competition_type: code
+awards_medals: true
+prizes:
+  - position: 1
+    value: 50000
+  - position: 2
+    value: 25000
+  - position: 3
+    value: 13000
+  - position: 4
+    value: 7000
+  - position: 5
+    value: 5000
+description: mlebench/competitions/nfl-player-contact-detection/description.md
+
+dataset:
+  answers: nfl-player-contact-detection/prepared/private/test.csv
+  sample_submission: nfl-player-contact-detection/prepared/public/sample_submission.csv
+
+grader:
+  name: matthews-correlation-coefficient
+  grade_fn: mlebench.competitions.nfl-player-contact-detection.grade:grade
+
+preparer: mlebench.competitions.nfl-player-contact-detection.prepare:prepare

dslighting/registry/nfl-player-contact-detection/description.md

@@ -0,0 +1,165 @@
+# **Overview**
+
+### **Goal of the Competition**
+
+The goal of this competition is to detect external contact experienced by players during an NFL football game. You will use video and player tracking data to identify moments with contact to help improve player safety.
+
+![](https://www.googleapis.com/download/storage/v1/b/kaggle-user-content/o/inbox%2F644036%2F65cd663d2c823043b36ecda6c93c1304%2Fcontact-example.gif?generation=1670265252697886&alt=media)
+
+### **Context**
+
+The National Football League (NFL) has teamed up with Amazon Web Services (AWS) to strengthen its commitment to predict player injuries. The NFL aspires to have the best injury surveillance and mitigation program in any sport. With your machine learning and computer vision skills, you can help the NFL accurately identify when players experience contact throughout a football play.
+
+In prior years, the NFL challenged the Kaggle community to create helmet impact detection and identification algorithms. This year the NFL looks to automatically identify all moments when players experience contact. This competition will be successful if we can reliably detect moments when players are in contact with one another and when a player’s body is in contact with the ground.
+
+Currently, the NFL uses its tracking system to monitor a large number of statistics about players’ load during the season. The league has a solution that predicts contact between players, but it only leverages the player tracking data. This competition hopes to improve the predictive power by including video in addition to tracking data. Categorizing ground contact will also provide a more comprehensive view of impacts, improving analysis for player health and safety.
+
+More accurate data is an important step toward the NFL’s injury surveillance and mitigation goals. With complete contact detection, the league can identify correlations between certain types of contact and injury, a contributor to future prevention. Your efforts could help mitigate unsafe situations to reduce injury to all players.
+
+The National Football League is America's most popular sports league. Founded in 1920, the NFL developed the model for the successful modern sports league and is committed to advancing progress in the diagnosis, prevention, and treatment of sports-related injuries. This competition is part of the Digital Athlete, a joint effort between the NFL and AWS to build a virtual, 360-degree representation of an NFL player’s experience. The Digital Athlete hopes to generate a precise picture of what they need when it comes to preventing and recovering from injuries while performing at their best. Health and safety efforts include support for independent medical research and engineering advancements as well as a commitment to work to better protect players and make the game safer, including enhancements to medical protocols and improvements to how our game is taught and played. For more information about the NFL's health and safety efforts, please visit the [NFL Player Health and Safety website](https://www.nfl.com/PlayerHealthandSafety).
+
+> This is a Code Competition. Refer to [Code Requirements](https://www.kaggle.com/c/nfl-player-contact-detection/overview/code-requirements) for details.
+> 
+
+## **Evaluation**
+
+Submissions are evaluated on [Matthews Correlation Coefficient](https://en.wikipedia.org/wiki/Phi_coefficient) between the predicted and actual contact events.
+
+### **Submission File**
+
+For every allowable `contact_id` (formed by concatenating the `game_play_step_player1_player2`), you must predict whether the involved players are in contact at that moment in time. **sample_submission.csv** provides the exhaustive list of `contact_id`s. Note that the ground, denoted as player `G`, is included as a possible contact in place of player2. The player with the lower id is always listed first in the `contact_id`.
+
+The file should contain a header and have the following format:
+
+```
+contact_id,contact
+58168_003392_0_38590_43854,0
+58168_003392_0_38590_41257,1
+58168_003392_0_38590_41944,0
+etc.
+
+```
+
+## **Timeline**
+
+- **December 5, 2022** - Start Date.
+- **February 22, 2023** - Entry Deadline. You must accept the competition rules before this date in order to compete.
+- **February 22, 2023** - Team Merger Deadline. This is the last day participants may join or merge teams.
+- **March 1, 2023** - Final Submission Deadline.
+
+All deadlines are at 11:59 PM UTC on the corresponding day unless otherwise noted. The competition organizers reserve the right to update the contest timeline if they deem it necessary.
+
+## **Prizes**
+
+1st Place - $50,000
+
+2nd Place - $25,000
+
+3rd Place - $13,000
+
+4th Place - $7,000
+
+5th Place - $5,000
+
+## **Code Requirements**
+
+![](https://storage.googleapis.com/kaggle-media/competitions/general/Kerneler-white-desc2_transparent.png)
+
+### **This is a Code Competition**
+
+Submissions to this competition must be made through Notebooks. In order for the "Submit" button to be active after a commit, the following conditions must be met:
+
+- CPU Notebook <= 9 hours run-time
+- GPU Notebook <= 9 hours run-time
+- Internet access disabled
+- Freely & publicly available external data is allowed, including pre-trained models
+- Submission file must be named `submission.csv`
+
+Please see the [Code Competition FAQ](https://www.kaggle.com/docs/competitions#notebooks-only-FAQ) for more information on how to submit. And review the [code debugging doc](https://www.kaggle.com/code-competition-debugging) if you are encountering submission errors.
+
+## **Citation**
+
+Addison Howard, Britt Evans, Rob Mulla, Ryan Holbrook, Sam Huddleston, Will Cukierski. (2022). 1st and Future - Player Contact Detection. Kaggle. https://kaggle.com/competitions/nfl-player-contact-detection
+
+# **Dataset Description**
+
+In this competition, you are tasked with predicting moments of contact between player pairs, as well as when players make non-foot contact with the ground using game footage and tracking data. Each play has four associated videos. Two videos, showing a sideline and endzone view, are time synced and aligned with each other. Additionally, an All29 view is provided but not guaranteed to be time synced. The training set videos are in **train/** with corresponding labels in **train_labels.csv**, while the videos for which you must predict are in the **test/** folder.
+
+This year we are also providing baseline helmet detection and assignment boxes for the training and test set. **train_baseline_helmets.csv** is the output from last year's winning player assignment model.
+
+**train_player_tracking.csv** provides 10 Hz tracking data for each player on the field during the provided plays.
+
+**train_video_metadata.csv** contains timestamps associated with each Sideline and Endzone view for syncing with the player tracking data.
+
+This is a code competition. When you submit, your model will be rerun on a set of 61 unseen plays located in a holdout test set. The publicly provided test videos are simply a set of mock plays (copied from the training set) which are not used in scoring.
+
+The associated **test_baseline_helmets.csv**, **test_player_tracking.csv**, and **test_video_metadata.csv** are available to your model when submitting.
+
+A **sample_submission.csv** will be available when submitting and will contain all rows required for a valid submission.
+
+## **Files**
+
+**[train/test] mp4** videos of each play. Each play has three videos. The two main view are shot from the endzone and sideline. Sideline and Endzone video pairs are matched frame for frame in time, but different players may be visible in each view. This year, an additional view is provided, All29 which should include view of every player involved in the play. All29 video is not guaranteed to be time synced with the sideline and endzone.
+
+These videos all contain a frame rate of 59.94 HZ. The moment of snap occurs 5 seconds into the video.
+
+**train_labels.csv** Contains a row for every combination of players, and players with the ground for each 0.1 second timestamp in the play.
+
+- `contact_id`: A combination of the game_play, player_ids and step columns.
+- `game_play`: the unique ID for the game and play.
+- `nfl_player_id_1` The lower numbered player id in the contact pair. If contact with ground then this is just the player id.
+- `nfl_player_id_2`: The larger number player id in the contact pair. If for contact with the ground, this will contain an uppercase "G"
+- `step`: A number representing each each timestep for each play, starting at 0 at the moment of the play starting, and incrementing by 1 every 0.1 seconds.
+- `datetime`: The timetamp of the contact, at 10Hz
+- `contact`: Whether contact occurred
+
+Note: Labels may not be exact but are expected to be within +/-10Hz from the actual moment of contact. Labels were created in a multistep process including quality checks, however there still may be mislabels. You should expect the test labels to be of similar quality as the training set labels.
+
+**sample_submission.csv** A valid sample submission file.
+
+- `contact_id`: A combination of the game_key, play_id, nfl_player_ids and step (as explained above)
+- `contact`: A binary value predicting contact. 1 indicates contact and 0 indicates no-contact.
+
+**[train/test]_baseline_helmets.csv** contains imperfect baseline predictions for helmet boxes and player assignments for the Sideline and Endzone video view. The model used to create these predictions are from the winning solution from last year's competition and can be used to leverage your predictions.
+
+- `game_play`: Unique game key and play id combination for the play.
+- `game_key`: the ID code for the game.
+- `play_id`: the ID code for the play.
+- `view`: The video view, either `Sideline` or `Endzone`
+- `video`: The filename of the associated video.
+- `frame`: The associated frame within the video.
+- `nfl_player_id`: The **imperfect** predicted player id.
+- `player_label`: The player label. A combination of V/H (home or visiting team) and the player jersey number.
+- `[left/width/top/height]`: the specification of the bounding box of the prediction.
+
+**[train/test]_player_tracking.csv** Each player wears a sensor that allows us to locate them on the field; that information is reported in these two files.
+
+- `game_play`: Unique game key and play id combination for the play.
+- `game_key`: the ID code for the game.
+- `play_id`: the ID code for the play.
+- `nfl_player_id`: the player's ID code.
+- `datetime`: timestamp at 10 Hz.
+- `step`: timestep within play relative to the play start.
+- `position`: the football position of the player.
+- `team`: team of the player, either home or away.
+- `jersey_number`: Player jersey number
+- `x_position:` player position along the long axis of the field. See figure below.
+- `y_position`: player position along the short axis of the field. See figure below.
+- `speed`: speed in yards/second.
+- `distance`: distance traveled from prior time point, in yards.
+- `orientation`: orientation of player (deg).
+- `direction`: angle of player motion (deg).
+- `acceleration`: magnitiude of the total acceleration in yards/second^2.
+- `sa`: Signed acceleration yards/second^2 in the direction the player is moving.
+
+![](https://www.googleapis.com/download/storage/v1/b/kaggle-user-content/o/inbox%2F3258%2F820e86013d48faacf33b7a32a15e814c%2FIncreasing%20Dir%20and%20O.png?generation=1572285857588233&alt=media)
+
+**[train/test]_video_metadata.csv** Metadata for each sideline and endzone video file including the timestamp information to be used to sync with player tracking data.
+
+- `game_play`: Unique game key and play id combination for the play.
+- `game_key`: the ID code for the game.
+- `play_id`: the ID code for the play.
+- `view`: The video view, either `Sideline` or `Endzone`
+- `start_time`: The timestamp of the video start.
+- `end_time`: The timestamp when the video ends.
+- `snap_time`: The timestamp when the play starts within the video. This is 5 seconds (300 frames) into the video.

dslighting/registry/nfl-player-contact-detection/description_obfuscated.md

@@ -0,0 +1,87 @@
+# Task
+
+Predict moments of contact between football player pairs, as well as when players make non-foot contact with the ground, using game footage and tracking data.
+
+# Metric
+
+Matthews Correlation Coefficient between the predicted and actual contact events.
+
+# Submission Format
+
+For every allowable `contact_id` (formed by concatenating the `game_play_step_player1_player2`), you must predict whether the involved players are in contact at that moment in time. **sample_submission.csv** provides the exhaustive list of `contact_id`s. Note that the ground, denoted as player `G`, is included as a possible contact in place of player2. The player with the lower id is always listed first in the `contact_id`.
+
+The file should contain a header and have the following format:
+
+```
+contact_id,contact
+58168_003392_0_38590_43854,0
+58168_003392_0_38590_41257,1
+58168_003392_0_38590_41944,0
+etc.
+
+```
+
+# Dataset 
+
+**[train/test] mp4** videos of each play. Each play has three videos. The two main view are shot from the endzone and sideline. Sideline and Endzone video pairs are matched frame for frame in time, but different players may be visible in each view. This year, an additional view is provided, All29 which should include view of every player involved in the play. All29 video is not guaranteed to be time synced with the sideline and endzone.
+
+These videos all contain a frame rate of 59.94 HZ. The moment of snap occurs 5 seconds into the video.
+
+**train_labels.csv** Contains a row for every combination of players, and players with the ground for each 0.1 second timestamp in the play.
+
+- `contact_id`: A combination of the game_play, player_ids and step columns.
+- `game_play`: the unique ID for the game and play.
+- `nfl_player_id_1` The lower numbered player id in the contact pair. If contact with ground then this is just the player id.
+- `nfl_player_id_2`: The larger number player id in the contact pair. If for contact with the ground, this will contain an uppercase "G"
+- `step`: A number representing each each timestep for each play, starting at 0 at the moment of the play starting, and incrementing by 1 every 0.1 seconds.
+- `datetime`: The timetamp of the contact, at 10Hz
+- `contact`: Whether contact occurred
+
+Note: Labels may not be exact but are expected to be within +/-10Hz from the actual moment of contact. Labels were created in a multistep process including quality checks, however there still may be mislabels. You should expect the test labels to be of similar quality as the training set labels.
+
+**sample_submission.csv** A valid sample submission file.
+
+- `contact_id`: A combination of the game_key, play_id, nfl_player_ids and step (as explained above)
+- `contact`: A binary value predicting contact. 1 indicates contact and 0 indicates no-contact.
+
+**[train/test]_baseline_helmets.csv** contains imperfect baseline predictions for helmet boxes and player assignments for the Sideline and Endzone video view. The model used to create these predictions are from the winning solution from last year's competition and can be used to leverage your predictions.
+
+- `game_play`: Unique game key and play id combination for the play.
+- `game_key`: the ID code for the game.
+- `play_id`: the ID code for the play.
+- `view`: The video view, either `Sideline` or `Endzone`
+- `video`: The filename of the associated video.
+- `frame`: The associated frame within the video.
+- `nfl_player_id`: The **imperfect** predicted player id.
+- `player_label`: The player label. A combination of V/H (home or visiting team) and the player jersey number.
+- `[left/width/top/height]`: the specification of the bounding box of the prediction.
+
+**[train/test]_player_tracking.csv** Each player wears a sensor that allows us to locate them on the field; that information is reported in these two files.
+
+- `game_play`: Unique game key and play id combination for the play.
+- `game_key`: the ID code for the game.
+- `play_id`: the ID code for the play.
+- `nfl_player_id`: the player's ID code.
+- `datetime`: timestamp at 10 Hz.
+- `step`: timestep within play relative to the play start.
+- `position`: the football position of the player.
+- `team`: team of the player, either home or away.
+- `jersey_number`: Player jersey number
+- `x_position:` player position along the long axis of the field. See figure below.
+- `y_position`: player position along the short axis of the field. See figure below.
+- `speed`: speed in yards/second.
+- `distance`: distance traveled from prior time point, in yards.
+- `orientation`: orientation of player (deg).
+- `direction`: angle of player motion (deg).
+- `acceleration`: magnitiude of the total acceleration in yards/second^2.
+- `sa`: Signed acceleration yards/second^2 in the direction the player is moving.
+
+**[train/test]_video_metadata.csv** Metadata for each sideline and endzone video file including the timestamp information to be used to sync with player tracking data.
+
+- `game_play`: Unique game key and play id combination for the play.
+- `game_key`: the ID code for the game.
+- `play_id`: the ID code for the play.
+- `view`: The video view, either `Sideline` or `Endzone`
+- `start_time`: The timestamp of the video start.
+- `end_time`: The timestamp when the video ends.
+- `snap_time`: The timestamp when the play starts within the video. This is 5 seconds (300 frames) into the video.