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

dslighting/registry/instant-gratification/prepare.py

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

dslighting/registry/instant_gratification/grade.py

@@ -0,0 +1,55 @@
+import numpy as np
+import pandas as pd
+from sklearn.metrics import roc_auc_score
+
+from mlebench.grade_helpers import InvalidSubmissionError
+
+
+def prepare_for_metric(submission: pd.DataFrame, answers: pd.DataFrame):
+    """Prepare submission and answers for AUC-ROC calculation."""
+    if len(submission) != len(answers):
+        raise InvalidSubmissionError(
+            f"Submission length ({len(submission)}) != answers length ({len(answers)})"
+        )
+
+    if "id" not in submission.columns:
+        raise InvalidSubmissionError("Submission must have an 'id' column")
+
+    if "target" not in submission.columns:
+        raise InvalidSubmissionError("Submission must have a 'target' column")
+
+    # Sort by id
+    submission = submission.sort_values("id").reset_index(drop=True)
+    answers = answers.sort_values("id").reset_index(drop=True)
+
+    # Check id alignment
+    if not (submission["id"] == answers["id"]).all():
+        raise InvalidSubmissionError("Submission and answers id mismatch")
+
+    # Extract predictions and true values
+    y_pred = submission["target"].values
+    y_true = answers["target"].values
+
+    # Validate predictions
+    try:
+        y_pred = y_pred.astype(float)
+    except (ValueError, TypeError):
+        raise InvalidSubmissionError("Predictions must be numeric")
+
+    if np.any(np.isnan(y_pred)):
+        raise InvalidSubmissionError("Predictions cannot contain NaN values")
+
+    if np.any((y_pred < 0) | (y_pred > 1)):
+        raise InvalidSubmissionError("Predictions must be probabilities between 0 and 1")
+
+    return y_true, y_pred
+
+
+def grade(submission: pd.DataFrame, answers: pd.DataFrame) -> float:
+    """Calculate AUC-ROC score."""
+    y_true, y_pred = prepare_for_metric(submission, answers)
+
+    # AUC-ROC
+    auc = roc_auc_score(y_true, y_pred)
+
+    return auc

dslighting/registry/instant_gratification/prepare.py

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

dslighting/registry/invasive-species-monitoring/checksums.yaml

@@ -0,0 +1,5 @@
+private:
+  answers.csv: 931c56b826f984b6e8e38de046240166
+  sample_submission.csv: 3fc85f5b579bbf85aa605899887df903
+public: {}
+zip: 6e32b8c25b22dc4653540891871bc853

dslighting/registry/invasive-species-monitoring/config.yaml

@@ -0,0 +1,16 @@
+id: invasive-species-monitoring
+name: Invasive Species Monitoring
+competition_type: simple
+awards_medals: false
+prizes: null
+description: mlebench/competitions/invasive-species-monitoring/description.md
+
+dataset:
+  answers: invasive-species-monitoring/prepared/private/answers.csv
+  sample_submission: invasive-species-monitoring/prepared/private/sample_submission.csv
+
+grader:
+  name: auc-roc
+  grade_fn: mlebench.competitions.invasive-species-monitoring.grade:grade
+
+preparer: mlebench.competitions.invasive-species-monitoring.prepare:prepare

dslighting/registry/invasive-species-monitoring/description.md

@@ -0,0 +1,55 @@
+# Overview
+
+## Description
+
+Tangles of kudzu overwhelm trees in Georgia while cane toads threaten habitats in over a dozen countries worldwide. These are just two invasive species of many which can have damaging effects on the environment, the economy, and even human health. Despite widespread impact, efforts to track the location and spread of invasive species are so costly that they’re difficult to undertake at scale.
+
+Currently, ecosystem and plant distribution monitoring depends on expert knowledge. Trained scientists visit designated areas and take note of the species inhabiting them. Using such a highly qualified workforce is expensive, time inefficient, and insufficient since humans cannot cover large areas when sampling.
+
+![invasive-species-monitoring.png](https://storage.googleapis.com/kaggle-media/competitions/kaggle/3333/media/invasive-species-monitoring.png)
+
+Because scientists cannot sample a large quantity of areas, some machine learning algorithms are used in order to predict the presence or absence of invasive species in areas that have not been sampled. The accuracy of this approach is far from optimal, but still contributes to approaches to solving ecological problems.
+
+In this playground competition, Kagglers are challenged to develop algorithms to more accurately identify whether images of forests and foliage contain invasive hydrangea or not. Techniques from computer vision alongside other current technologies like aerial imaging can make invasive species monitoring cheaper, faster, and more reliable.
+
+### Acknowledgments
+
+Data providers: [Christian Requena Mesa](https://www.linkedin.com/in/requenac), Thore Engel, [Amrita Menon](https://www.linkedin.com/in/amrita-menon-12b58947/), Emma Bradley.
+
+## Evaluation
+
+Submissions are evaluated on [area under the ROC curve](http://en.wikipedia.org/wiki/Receiver_operating_characteristic) between the predicted probability and the observed target.
+
+### Submission File
+
+For each image in the test set, you must predict a probability for the target variable on whether the image contains invasive species or not. The file should contain a header and have the following format:
+
+```
+name,invasive
+2,0.5
+5,0
+6,0.2
+etc.
+```
+
+## Citation
+
+Crequena, Thore Engel, Wendy Kan. (2017). Invasive Species Monitoring. Kaggle. https://kaggle.com/competitions/invasive-species-monitoring
+
+# Data
+
+## Dataset Description
+
+The data set contains pictures taken in a Brazilian national forest. In some of the pictures there is *Hydrangea*, a beautiful invasive species original of Asia. Based on the training pictures and the labels provided, the participant should predict the presence of the invasive species in the testing set of pictures.
+
+## File descriptions
+
+- **train.7z** - the training set (contains 2295 images).
+- **train_labels.csv** - the correct labels for the training set.
+- **test.7z** - the testing set (contains 1531 images), ready to be labeled by your algorithm.
+- **sample_submission.csv** - a sample submission file in the correct format.
+
+## Data fields
+
+- **name** - name of the sample picture file (numbers)
+- **invasive** - probability of the picture containing an invasive species. A probability of 1 means the species is present.

dslighting/registry/invasive-species-monitoring/description_obfuscated.md

@@ -0,0 +1,33 @@
+# Task
+
+Predict the presence of an invasive hydrangea species in images of foliage.
+
+# Metric
+
+Area under the ROC curve.
+
+# Submission Format
+
+For each image in the test set, you must predict a probability for the target variable on whether the image contains invasive species or not. The file should contain a header and have the following format:
+
+```
+name,invasive
+2,0.5
+5,0
+6,0.2
+etc.
+```
+
+# Dataset
+
+The data set contains pictures taken in a forest.
+
+- **train.7z** - the training set (contains 2295 images).
+- **train_labels.csv** - the correct labels for the training set.
+- **test.7z** - the testing set (contains 1531 images), ready to be labeled by your algorithm.
+- **sample_submission.csv** - a sample submission file in the correct format.
+
+## Data fields
+
+- **name** - name of the sample picture file (numbers)
+- **invasive** - probability of the picture containing an invasive species. A probability of 1 means the species is present.

dslighting/registry/invasive-species-monitoring/grade.py

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

dslighting/registry/invasive-species-monitoring/prepare.py

@@ -0,0 +1,97 @@
+import shutil
+from pathlib import Path
+
+import py7zr
+from sklearn.model_selection import train_test_split
+from tqdm import tqdm
+
+from mlebench.utils import extract, 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.
+    """
+    # extract only what we need
+    extract(raw / "train.7z", raw)
+    extract(raw / "train_labels.csv.zip", raw)
+
+    # Create train, test from train split
+    # Original ratio is 1531/(1531+2295) = 0.4
+    test_ratio = 0.2
+    old_train = read_csv(raw / "train_labels.csv")
+    new_train, answers = train_test_split(old_train, test_size=test_ratio, random_state=0)
+
+    # Sample submission
+    sample_submission = answers.copy()
+    sample_submission["invasive"] = 0.5
+
+    # Checks
+    assert new_train["name"].is_unique, "new_train should have unique names"
+    assert answers["name"].is_unique, "answers should have unique names"
+    assert set(new_train["name"]).isdisjoint(
+        set(answers["name"])
+    ), "new_train and answers should be disjoint"
+    assert len(new_train) + len(answers) == len(
+        old_train
+    ), "new_train and answers together should have the same number of rows as old_train"
+    assert (
+        new_train.columns.tolist() == old_train.columns.tolist()
+    ), "new_train should have the same columns as old_train"
+    assert (
+        answers.columns.tolist() == old_train.columns.tolist()
+    ), "answers should have the same columns as old_train"
+    assert (
+        sample_submission.columns.tolist() == old_train.columns.tolist()
+    ), "sample_submission should have the same columns as old_train"
+
+    # Write CSVs
+    answers.to_csv(private / "answers.csv", index=False)
+    new_train.to_csv(public / "train_labels.csv", index=False)
+    sample_submission.to_csv(private / "sample_submission.csv", index=False)
+    sample_submission.to_csv(public / "sample_submission.csv", index=False)
+
+    # Copy files
+    (public / "train").mkdir(exist_ok=True)
+    (public / "test").mkdir(exist_ok=True)
+
+    for file_id in tqdm(new_train["name"], desc="Copying Train Images"):
+        shutil.copyfile(
+            src=raw / "train" / f"{file_id}.jpg",
+            dst=public / "train" / f"{file_id}.jpg",
+        )
+
+    for file_id in tqdm(answers["name"], desc="Copying Test Images"):
+        shutil.copyfile(
+            src=raw / "train" / f"{file_id}.jpg",
+            dst=public / "test" / f"{file_id}.jpg",
+        )
+
+    # Checks
+    assert len(list((public / "train").glob("*.jpg"))) == len(
+        new_train
+    ), "public/train should have the same number of files as new_train"
+    assert len(list((public / "test").glob("*.jpg"))) == len(
+        answers
+    ), "public/test should have the same number of files as answers"
+
+    # Zip
+    shutil.make_archive(
+        str(public / "sample_submission.csv"),
+        "zip",
+        root_dir=public,
+        base_dir="sample_submission.csv",
+    )
+    shutil.make_archive(
+        str(public / "train_labels.csv"), "zip", root_dir=public, base_dir="train_labels.csv"
+    )
+    with py7zr.SevenZipFile(public / "train.7z", "w") as z:
+        z.write(public / "train")
+    with py7zr.SevenZipFile(public / "test.7z", "w") as z:
+        z.write(public / "test")
+
+    # Delete
+    shutil.rmtree(public / "train")
+    shutil.rmtree(public / "test")
+    (public / "sample_submission.csv").unlink()
+    (public / "train_labels.csv").unlink()

dslighting/registry/invasive-species-monitoring/prepare_val.py

@@ -0,0 +1,164 @@
+import shutil
+from pathlib import Path
+
+import pandas as pd
+import py7zr
+from sklearn.model_selection import train_test_split
+from tqdm import tqdm
+
+from mlebench.utils import extract, read_csv
+
+
+def _process_split(
+    train_df: pd.DataFrame,
+    test_df: pd.DataFrame,
+    raw_images_dir: Path,
+    public_dir: Path,
+    private_dir: Path,
+):
+    """
+    Helper function to process a single data split (train/test).
+
+    This function handles:
+    - Creating a sample submission.
+    - Writing all necessary CSV files to public and private directories.
+    - Copying image files to temporary train/test subdirectories.
+    - Zipping the final artifacts.
+    - Cleaning up temporary files.
+    """
+    # Create output directories if they don't exist
+    public_dir.mkdir(exist_ok=True, parents=True)
+    private_dir.mkdir(exist_ok=True, parents=True)
+
+    # Sample submission
+    sample_submission = test_df.copy()
+    sample_submission["invasive"] = 0.5
+
+    # Write CSVs
+    test_df.to_csv(private_dir / "answers.csv", index=False)
+    train_df.to_csv(public_dir / "train_labels.csv", index=False)
+    sample_submission.to_csv(private_dir / "sample_submission.csv", index=False)
+    sample_submission.to_csv(public_dir / "sample_submission.csv", index=False)
+
+    # Create temporary directories for image copying
+    public_train_images_dir = public_dir / "train"
+    public_test_images_dir = public_dir / "test"
+    public_train_images_dir.mkdir(exist_ok=True)
+    public_test_images_dir.mkdir(exist_ok=True)
+
+    # Copy files
+    for file_id in tqdm(train_df["name"], desc=f"Copying Train Images to {public_dir.name}"):
+        shutil.copyfile(
+            src=raw_images_dir / f"{file_id}.jpg",
+            dst=public_train_images_dir / f"{file_id}.jpg",
+        )
+
+    for file_id in tqdm(test_df["name"], desc=f"Copying Test Images to {public_dir.name}"):
+        shutil.copyfile(
+            src=raw_images_dir / f"{file_id}.jpg",
+            dst=public_test_images_dir / f"{file_id}.jpg",
+        )
+
+    # Checks
+    assert len(list(public_train_images_dir.glob("*.jpg"))) == len(
+        train_df
+    ), f"{public_dir.name}/train should have the same number of files as its corresponding train df"
+    assert len(list(public_test_images_dir.glob("*.jpg"))) == len(
+        test_df
+    ), f"{public_dir.name}/test should have the same number of files as its corresponding test df"
+
+    # Zip
+    shutil.make_archive(
+        str(public_dir / "sample_submission.csv"),
+        "zip",
+        root_dir=public_dir,
+        base_dir="sample_submission.csv",
+    )
+    shutil.make_archive(
+        str(public_dir / "train_labels.csv"),
+        "zip",
+        root_dir=public_dir,
+        base_dir="train_labels.csv",
+    )
+    with py7zr.SevenZipFile(public_dir / "train.7z", "w") as z:
+        z.write(public_train_images_dir, arcname="train")
+    with py7zr.SevenZipFile(public_dir / "test.7z", "w") as z:
+        z.write(public_test_images_dir, arcname="test")
+
+    # Delete temporary files and directories
+    shutil.rmtree(public_train_images_dir)
+    shutil.rmtree(public_test_images_dir)
+    (public_dir / "sample_submission.csv").unlink()
+    (public_dir / "train_labels.csv").unlink()
+
+
+def prepare(raw: Path, public: Path, private: Path):
+    """
+    Splits the data in raw into public and private datasets with appropriate test/train splits.
+    Additionally, creates a second, parallel validation split (public_val/private_val).
+    """
+    # Define paths for the new validation set
+    public_val = public.parent / "public_val"
+    private_val = private.parent / "private_val"
+
+    # extract only what we need
+    extract(raw / "train.7z", raw)
+    extract(raw / "train_labels.csv.zip", raw)
+
+    # ---- FIRST SPLIT (Original Train/Test) ----
+    # Create train, test from train split
+    # Original ratio is 1531/(1531+2295) = 0.4
+    test_ratio = 0.2
+    old_train = read_csv(raw / "train_labels.csv")
+    new_train, answers = train_test_split(old_train, test_size=test_ratio, random_state=0)
+
+    # Checks
+    assert new_train["name"].is_unique, "new_train should have unique names"
+    assert answers["name"].is_unique, "answers should have unique names"
+    assert set(new_train["name"]).isdisjoint(
+        set(answers["name"])
+    ), "new_train and answers should be disjoint"
+    assert len(new_train) + len(answers) == len(
+        old_train
+    ), "new_train and answers together should have the same number of rows as old_train"
+    assert (
+        new_train.columns.tolist() == old_train.columns.tolist()
+    ), "new_train should have the same columns as old_train"
+    assert (
+        answers.columns.tolist() == old_train.columns.tolist()
+    ), "answers should have the same columns as old_train"
+
+    # Process and save the original public/private split
+    # This ensures the original outputs are not modified
+    _process_split(
+        train_df=new_train,
+        test_df=answers,
+        raw_images_dir=raw / "train",
+        public_dir=public,
+        private_dir=private,
+    )
+
+    # ---- SECOND SPLIT (New Train/Validation) ----
+    # Split the `new_train` set again to create a validation set.
+    # The new test set (`test_val`) will have the same size as the original test set (`answers`).
+    val_test_ratio = len(answers) / len(new_train)
+    train_val, test_val = train_test_split(
+        new_train, test_size=val_test_ratio, random_state=0
+    )
+
+    # Checks for the validation split
+    assert set(train_val["name"]).isdisjoint(
+        set(test_val["name"])
+    ), "train_val and test_val should be disjoint"
+    assert len(train_val) + len(test_val) == len(
+        new_train
+    ), "train_val and test_val together should have the same number of rows as new_train"
+
+    # Process and save the new validation split into parallel directories
+    _process_split(
+        train_df=train_val,
+        test_df=test_val,
+        raw_images_dir=raw / "train",
+        public_dir=public_val,
+        private_dir=private_val,
+    )

dslighting/registry/iwildcam-2019-fgvc6/checksums.yaml

@@ -0,0 +1,8 @@
+private:
+  answers.csv: 83006769438332df65e5106e31c5d1fd
+  test.csv: e81e5aefbfbb046ae5cc5493012f303c
+public:
+  sample_submission.csv: 2c3d7681f93545d6c811de41fbe2013a
+  test.csv: 7b83b8c770dc4b820ab2c35484f3fc55
+  train.csv: 3e7e01b0c342da6aebda97efae2de0e4
+zip: a47f19c8dfb20d33aeb65fd3975af2c7

dslighting/registry/iwildcam-2019-fgvc6/config.yaml

@@ -0,0 +1,16 @@
+id: iwildcam-2019-fgvc6
+name: iWildCam 2019 - FGVC6
+competition_type: simple
+awards_medals: false
+prizes: null
+description: mlebench/competitions/iwildcam-2019-fgvc6/description.md
+
+dataset:
+  answers: iwildcam-2019-fgvc6/prepared/private/answers.csv
+  sample_submission: iwildcam-2019-fgvc6/prepared/public/sample_submission.csv
+
+grader:
+  name: macro-f1-score
+  grade_fn: mlebench.competitions.iwildcam-2019-fgvc6.grade:grade
+
+preparer: mlebench.competitions.iwildcam-2019-fgvc6.prepare:prepare

dslighting/registry/iwildcam-2019-fgvc6/description.md

@@ -0,0 +1,109 @@
+# Overview
+
+## Description
+
+Camera Traps (or Wild Cams) enable the automatic collection of large quantities of image data. Biologists all over the world use camera traps to monitor biodiversity and population density of animal species. We have recently been making strides towards automating the species classification challenge in camera traps, but as we try to expand the scope of these models from specific regions where we have collected training data to nearby areas we are faced with an interesting probem: how do you classify a species in a new region that you may not have seen in previous training data?
+
+In order to tackle this problem, we have prepared a challenge where the training data and test data are from different regions, namely The American Southwest and the American Northwest. The species seen in each region overlap, but are not identical, and the challenge is to classify the test species correctly. To this end, we will allow training on our American Southwest data (from [CaltechCameraTraps](https://beerys.github.io/CaltechCameraTraps/)), on [iNaturalist 2017/2018](https://github.com/visipedia/inat_comp) data, and on simulated data generated from [Microsoft AirSim](https://github.com/Microsoft/AirSim). We have provided a taxonomy file mapping our classes into the iNat taxonomy.
+
+This is an FGVCx competition as part of the [FGVC6](https://sites.google.com/view/fgvc6/home) workshop at [CVPR 2019](http://cvpr2019.thecvf.com/), and is sponsored by [Microsoft AI for Earth](https://www.microsoft.com/en-us/ai/ai-for-earth). There is a github page for the competition [here](https://github.com/visipedia/iwildcam_comp). Please open an issue if you have questions or problems with the dataset.
+
+If you use this dataset in publication, please cite:
+
+```
+@article{beery2019iwildcam,
+ title={The iWildCam 2019 Challenge Dataset},
+ author={Beery, Sara and Morris, Dan and Perona, Pietro},
+ journal={arXiv preprint arXiv:1907.07617},
+ year={2019}
+}
+```
+
+*Kaggle is excited to partner with research groups to push forward the frontier of machine learning. Research competitions make use of Kaggle's platform and experience, but are largely organized by the research group's data science team. Any questions or concerns regarding the competition data, quality, or topic will be addressed by them.*
+
+## Evaluation
+
+### Evaluation
+
+Submissions will be evaluated based on their [macro F1 score](https://en.wikipedia.org/wiki/F1_score) - i.e. F1 will be calculated for each class of animal (including "empty" if no animal is present), and the submission's final score will be the unweighted mean of all class F1 scores.
+
+## Submission Format
+
+The submission format for the competition is a csv file with the following format:
+
+```
+Id,Predicted
+58857ccf-23d2-11e8-a6a3-ec086b02610b,1
+591e4006-23d2-11e8-a6a3-ec086b02610b,5
+```
+
+The `Id` column corresponds to the test image id. The `Category` is an integer value that indicates the class of the animal, or `0` to represent the absence of an animal.
+
+## Timeline
+
+- **June 1, 2019** - Entry deadline. You must accept the competition rules before this date in order to compete.
+- **June 1, 2019** - Team Merger deadline. This is the last day participants may join or merge teams.
+- **June 7, 2019** - 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.
+
+## CVPR 2019
+
+This competition is part of the Fine-Grained Visual Categorization [FGVC6](https://sites.google.com/view/fgvc6/home) workshop at the Computer Vision and Pattern Recognition Conference [CVPR 2019](http://cvpr2019.thecvf.com/). Top submissions for the competition will be invited to attend and present their results at the workshop. Attending the workshop is not required to participate in the competition, however only teams that are attending the workshop will be considered to present their work. All teams attending the workshop will be responsible for their own conference fees and transportation and housing costs.
+
+## Citation
+
+Maggie, Phil Culliton, sbeery. (2019). iWildCam 2019 - FGVC6. Kaggle. https://kaggle.com/competitions/iwildcam-2019-fgvc6
+
+# Data
+
+## Dataset Description
+
+### Data Overview
+
+The training set contains 196,157 images from 138 different locations in Southern California. You may also choose to use supplemental training data from [iNaturalist 2017](https://github.com/visipedia/inat_comp/tree/master/2017#data), [iNaturalist 2018](https://github.com/visipedia/inat_comp#data), iNaturalist 2019, and images simulated with [Microsoft AirSim](https://github.com/Microsoft/AirSim). As a courtesy, we have curated all the images from iNaturalist 2017/2018 containing classes that might be in the test set and mapped them into the iWildCam categories. This data (which we call "iNat Idaho") can be downloaded from our git page [here](https://github.com/visipedia/iwildcam_comp).
+
+The test set contains 153,730 images from 100 locations in Idaho.
+
+The competition task is to label each image with one of the following label ids:
+
+```
+name, id
+empty, 0
+deer, 1
+moose, 2
+squirrel, 3
+rodent, 4
+small_mammal, 5
+elk, 6
+pronghorn_antelope, 7
+rabbit, 8
+bighorn_sheep, 9
+fox, 10
+coyote, 11
+black_bear, 12
+raccoon, 13
+skunk, 14
+wolf, 15
+bobcat, 16
+cat, 17
+dog, 18
+opossum, 19
+bison, 20
+mountain_goat, 21
+mountain_lion, 22
+```
+
+Some classes may not occur in train or test.
+
+## Camera Trap Animal Detection Model
+
+We are also providing a [general animal detection model](https://lilablobssc.blob.core.windows.net/models/camera_traps/megadetector/megadetector_v2.pb), using Faster-RCNN with Inception-Resnet-v2 backbone and atrous convolution, which competitors are free to use as they see fit.
+
+Sample code for running the detector over a folder of images can be found [here](https://github.com/Microsoft/CameraTraps/blob/master/detection/run_tf_detector.py).
+
+We have run the detector over the three datasets and provide the top 100 detected boxes for each image with their associated confidence [here](https://github.com/visipedia/iwildcam_comp).
+
+### Acknowledgements
+
+Data is primarily provided by Erin Boydston (USGS), Justin Brown (NPS), iNaturalist, and the Idaho Department of Fish and Game (IDFG).