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

dslighting/registry/icecube-neutrinos-in-deep-ice/prepare.py

@@ -0,0 +1,127 @@
+import shutil
+from pathlib import Path
+
+import pandas as pd
+from sklearn.model_selection import train_test_split
+from tqdm.auto import tqdm
+
+from mlebench.utils import get_logger
+
+logger = get_logger(__name__)
+
+
+def prepare(raw: Path, public: Path, private: Path):
+    DEV = False
+
+    if DEV:
+        batch_cutoff = 66  # 66 instead of 660 when in dev mode
+    else:
+        batch_cutoff = None
+
+    logger.info("Loading raw metadata")
+    old_train = pd.read_parquet(raw / "train_meta.parquet")
+
+    # this has batch_id and event_id, we will do a test-train split based on batch_id
+    # each batch id is equally sized so we can proceed with a simple split
+    batch_ids = old_train["batch_id"].unique()[:batch_cutoff]
+
+    logger.info("Splitting batches into train and test")
+    train_batch_ids, test_batch_ids = train_test_split(batch_ids, test_size=0.1, random_state=0)
+
+    # new column tracking the split
+    old_train["split"] = None
+    old_train.loc[old_train["batch_id"].isin(train_batch_ids), "split"] = "train"
+    old_train.loc[old_train["batch_id"].isin(test_batch_ids), "split"] = "test"
+
+    new_train = (
+        old_train[old_train["split"] == "train"]
+        .drop(columns=["split"])
+        .reset_index(drop=True)
+        .copy()
+    )
+    new_test = (
+        old_train[old_train["split"] == "test"]
+        .drop(columns=["split"])
+        .reset_index(drop=True)
+        .copy()
+    )
+
+    logger.info("Creating label-less test and sample submission")
+    new_test_without_labels = new_test.drop(columns=["azimuth", "zenith"])
+
+    # match sample submission format
+    new_test = new_test[["event_id", "azimuth", "zenith"]]
+
+    # copy the format as the private test and fill dummy values like kaggle.com
+    sample_submission = new_test.copy()
+    sample_submission["azimuth"] = 1
+    sample_submission["zenith"] = 1
+
+    logger.info("Saving files")
+    # save the prepared tables
+    new_train.to_parquet(public / "train_meta.parquet", index=False, engine="fastparquet")
+    new_test_without_labels.to_parquet(
+        public / "test_meta.parquet", index=False, engine="fastparquet"
+    )
+    sample_submission.to_csv(public / "sample_submission.csv", index=False)
+    new_test.to_csv(private / "test.csv", index=False)
+
+    logger.info("Copying remaining files")
+
+    # sensor_geometry can be copied as is
+    shutil.copy(raw / "sensor_geometry.csv", public / "sensor_geometry.csv")
+
+    # copy the raw train files to train and test folders respectively
+    train_batch_ids = set(train_batch_ids)
+    train_dest = public / "train"
+    train_dest.mkdir(exist_ok=True, parents=True)
+    test_batch_ids = set(test_batch_ids)
+    test_dest = public / "test"
+    test_dest.mkdir(exist_ok=True, parents=True)
+    for batch_file in tqdm(
+        sorted((raw / "train").glob("*.parquet")), desc="Copying batch parquet files"
+    ):
+        batch_id = int(
+            batch_file.stem.split("_")[-1]
+        )  # i.e. go from e.g. 'train_000.parquet' to '000' to 0
+        if batch_id in train_batch_ids:
+            shutil.copy(batch_file, train_dest / batch_file.name)
+        elif batch_id in test_batch_ids:
+            shutil.copy(batch_file, test_dest / batch_file.name)
+
+    logger.info("Running checks")
+    # Asserts
+    assert len(list(public.glob("train/*.parquet"))) == len(
+        train_batch_ids
+    ), "Not all train batches copied"
+    assert len(list(public.glob("test/*.parquet"))) == len(
+        test_batch_ids
+    ), "Not all test batches copied"
+    assert len(train_batch_ids) + len(test_batch_ids) == len(
+        batch_ids
+    ), "Something went wrong with splitting the batches"
+
+    assert len(new_train) + len(new_test) == len(
+        old_train[old_train["split"].notnull()]
+    ), "Expected train + test to equal the original data"
+    assert len(sample_submission) == len(
+        new_test
+    ), "Length mismatch between private test and sample submission"
+
+    assert sample_submission.columns.equals(
+        new_test.columns
+    ), f"Column mismatch between sample_submission and private test"
+    assert new_train.columns.equals(
+        old_train.drop(columns=["split"]).columns
+    ), f"Unexpected columns in train, expected {old_train.columns}, got {new_train.columns}"
+    assert new_test_without_labels.columns.equals(
+        old_train.drop(columns=["azimuth", "zenith", "split"]).columns
+    ), f"Unexpected columns in test, expected {old_train.drop(columns=['azimuth', 'zenith']).columns}, got {new_test_without_labels.columns}"
+
+    assert (
+        len(set(new_train["event_id"]).intersection(set(new_test["event_id"]))) == 0
+    ), "Event ids overlap between train and test"
+    assert set(new_test["event_id"]) == set(
+        sample_submission["event_id"]
+    ), "Event ids mismatch between test and sample submission"
+    logger.info("Done.")

dslighting/registry/icecube-neutrinos-in-deep-ice/prepare_val.py

@@ -0,0 +1,183 @@
+import shutil
+from pathlib import Path
+
+import pandas as pd
+from sklearn.model_selection import train_test_split
+from tqdm.auto import tqdm
+
+from mlebench.utils import get_logger
+
+logger = get_logger(__name__)
+
+
+def _create_split_files(
+    original_meta_df: pd.DataFrame,
+    train_batch_ids: list,
+    test_batch_ids: list,
+    public_dir: Path,
+    private_dir: Path,
+    raw_dir: Path,
+):
+    """
+    Helper function to process a split (e.g., train/test or train_val/test_val),
+    save the necessary files, and run checks.
+    """
+    logger.info(f"Processing split for destination: {public_dir.name}")
+    public_dir.mkdir(exist_ok=True, parents=True)
+    private_dir.mkdir(exist_ok=True, parents=True)
+
+    new_train = (
+        original_meta_df[original_meta_df["batch_id"].isin(train_batch_ids)]
+        .reset_index(drop=True)
+        .copy()
+    )
+    new_test = (
+        original_meta_df[original_meta_df["batch_id"].isin(test_batch_ids)]
+        .reset_index(drop=True)
+        .copy()
+    )
+
+    logger.info("Creating label-less test and sample submission")
+    new_test_without_labels = new_test.drop(columns=["azimuth", "zenith"])
+
+    # format private test to only contain event_id and labels
+    new_test = new_test[["event_id", "azimuth", "zenith"]]
+
+    # copy the format as the private test and fill dummy values like kaggle.com
+    sample_submission = new_test.copy()
+    sample_submission["azimuth"] = 1
+    sample_submission["zenith"] = 1
+
+    logger.info("Saving metadata files")
+    new_train.to_parquet(public_dir / "train_meta.parquet", index=False, engine="fastparquet")
+    new_test_without_labels.to_parquet(
+        public_dir / "test_meta.parquet", index=False, engine="fastparquet"
+    )
+    sample_submission.to_csv(public_dir / "sample_submission.csv", index=False)
+    new_test.to_csv(private_dir / "test.csv", index=False)
+
+    logger.info("Copying sensor geometry and batch data files")
+    # sensor_geometry can be copied as is
+    shutil.copy(raw_dir / "sensor_geometry.csv", public_dir / "sensor_geometry.csv")
+
+    # copy the raw train files to train and test folders respectively
+    train_ids_set = set(train_batch_ids)
+    train_dest = public_dir / "train"
+    train_dest.mkdir(exist_ok=True, parents=True)
+    test_ids_set = set(test_batch_ids)
+    test_dest = public_dir / "test"
+    test_dest.mkdir(exist_ok=True, parents=True)
+
+    for batch_file in tqdm(
+        sorted((raw_dir / "train").glob("*.parquet")), desc=f"Copying batches to {public_dir.name}"
+    ):
+        batch_id = int(batch_file.stem.split("_")[-1])
+        if batch_id in train_ids_set:
+            shutil.copy(batch_file, train_dest / batch_file.name)
+        elif batch_id in test_ids_set:
+            shutil.copy(batch_file, test_dest / batch_file.name)
+
+    logger.info("Running checks")
+    assert len(list(public_dir.glob("train/*.parquet"))) == len(
+        train_batch_ids
+    ), "Not all train batches copied"
+    assert len(list(public_dir.glob("test/*.parquet"))) == len(
+        test_batch_ids
+    ), "Not all test batches copied"
+    assert len(train_batch_ids) + len(test_batch_ids) == len(
+        set(train_batch_ids) | set(test_batch_ids)
+    ), "Something went wrong with splitting the batches"
+
+    # Drop the 'split' column for accurate checks, as it's not in the final data
+    original_meta_subset = original_meta_df[
+        original_meta_df["batch_id"].isin(train_batch_ids + test_batch_ids)
+    ]
+    if "split" in original_meta_subset.columns:
+        original_meta_subset = original_meta_subset.drop(columns=["split"])
+
+    assert len(new_train) + len(new_test) == len(
+        original_meta_subset
+    ), "Expected train + test to equal the original data"
+    assert len(sample_submission) == len(
+        new_test
+    ), "Length mismatch between private test and sample submission"
+
+    assert sample_submission.columns.equals(
+        new_test.columns
+    ), "Column mismatch between sample_submission and private test"
+    assert new_train.columns.equals(
+        original_meta_subset.columns
+    ), f"Unexpected columns in train, expected {original_meta_subset.columns}, got {new_train.columns}"
+    assert new_test_without_labels.columns.equals(
+        original_meta_subset.drop(columns=["azimuth", "zenith"]).columns
+    ), f"Unexpected columns in test"
+
+    assert (
+        len(set(new_train["event_id"]).intersection(set(new_test["event_id"]))) == 0
+    ), "Event ids overlap between train and test"
+    assert set(new_test["event_id"]) == set(
+        sample_submission["event_id"]
+    ), "Event ids mismatch between test and sample submission"
+
+
+def prepare(raw: Path, public: Path, private: Path):
+    DEV = False
+
+    if DEV:
+        batch_cutoff = 66  # 66 instead of 660 when in dev mode
+    else:
+        batch_cutoff = None
+
+    logger.info("Loading raw metadata")
+    old_train = pd.read_parquet(raw / "train_meta.parquet")
+    batch_ids = old_train["batch_id"].unique()[:batch_cutoff]
+
+    # Clean the dataframe for processing.
+    # The original script adds a 'split' column which we don't need in the helper.
+    old_train_clean = old_train[old_train["batch_id"].isin(batch_ids)].drop(
+        columns=["split"], errors="ignore"
+    )
+
+    # --- 1. Original Split: Raw Data -> Train / Test ---
+    logger.info("Splitting batches into original train and test sets")
+    train_batch_ids, test_batch_ids = train_test_split(
+        batch_ids, test_size=0.1, random_state=0
+    )
+
+    # Process and save the original split to 'public' and 'private'
+    _create_split_files(
+        original_meta_df=old_train_clean,
+        train_batch_ids=list(train_batch_ids),
+        test_batch_ids=list(test_batch_ids),
+        public_dir=public,
+        private_dir=private,
+        raw_dir=raw,
+    )
+
+    # --- 2. New Validation Split: Original Train -> New Train / Validation Test ---
+    logger.info("Creating new parallel directories for validation split")
+    public_val = public.parent / "public_val"
+    private_val = private.parent / "private_val"
+
+    # The new validation set should be the same size as the original test set.
+    # Calculate the required test_size for the second split.
+    # test_size = (size of desired val set) / (size of set being split)
+    #           = len(test_batch_ids) / len(train_batch_ids)
+    test_val_size_ratio = len(test_batch_ids) / len(train_batch_ids)
+
+    logger.info(f"Splitting original train set to create validation set")
+    train_val_batch_ids, test_val_batch_ids = train_test_split(
+        train_batch_ids, test_size=test_val_size_ratio, random_state=0
+    )
+
+    # Process and save the new validation split to 'public_val' and 'private_val'
+    _create_split_files(
+        original_meta_df=old_train_clean,
+        train_batch_ids=list(train_val_batch_ids),
+        test_batch_ids=list(test_val_batch_ids),
+        public_dir=public_val,
+        private_dir=private_val,
+        raw_dir=raw,
+    )
+
+    logger.info("All data preparation tasks are complete.")

dslighting/registry/ili/checksums.yaml

@@ -0,0 +1,3 @@
+# Checksums for ili dataset
+# This file will be auto-generated during data preparation
+zip: ""

dslighting/registry/ili/config.yaml

@@ -0,0 +1,16 @@
+id: ili
+name: ILI Time Series Forecasting
+competition_type: code
+awards_medals: false
+prizes: null
+description: mlebench/competitions/ili/description.md
+
+dataset:
+  answers: ili/prepared/private/test_targets.csv
+  sample_submission: ili/prepared/public/sample_submission.csv
+
+grader:
+  name: mse-mae
+  grade_fn: mlebench.competitions.ili.grade:grade
+
+preparer: mlebench.competitions.ili.prepare:prepare

dslighting/registry/ili/description.md

@@ -0,0 +1,61 @@
+# ILI Time Series Forecasting
+
+## Task Description
+
+You are solving a machine learning task of time series forecasting using the ILI (Influenza-Like Illness) dataset.
+
+The dataset presented here comprises real-world time series data tracking influenza-like illness statistics. We have split the dataset into train, validation, and test parts.
+
+## Data Description
+
+- **Input**: A sequence of past observations (INPUT_SEQ_LEN=36, INPUT_DIM=7)
+- **Output**: Predict the next future sequence (PRED_SEQ_LEN=24, PRED_DIM=7)
+- **Evaluation Metrics**: Mean Squared Error (MSE) and Mean Absolute Error (MAE)
+
+The dataset contains 7 features from the CDC's influenza surveillance system:
+1. % WEIGHTED ILI
+2. % UNWEIGHTED ILI
+3. AGE 0-4
+4. AGE 5-24
+5. ILITOTAL
+6. NUM. OF PROVIDERS
+7. OT (Other)
+
+
+
+
+## Submission Format
+
+The submission should be a CSV file with the following format:
+- Column `id`: Integer index for each test sample (0 to N_test-1)
+- Columns `pred_0` to `pred_167`: Flattened predictions (24 timesteps × 7 features = 168 values per sample)
+
+Example CSV structure:
+```
+id,pred_0,pred_1,pred_2,...,pred_166,pred_167
+0,0.5,0.3,0.7,...,0.2,0.4
+1,0.6,0.4,0.8,...,0.3,0.5
+...
+```
+
+
+## Evaluation
+
+Your predictions will be evaluated using two metrics:
+1. **MSE (Mean Squared Error)**: Lower is better
+2. **MAE (Mean Absolute Error)**: Lower is better
+
+The primary ranking metric is MSE.
+
+## Goal
+
+Train a time series forecasting model to accurately predict future ILI statistics based on historical observations.
+
+## Notes
+
+- This is a multivariate time series forecasting problem
+- Each input sequence covers 36 weeks of data
+- You need to predict the next 24 weeks
+- All 7 features need to be predicted simultaneously
+- The data has been preprocessed and standardized
+

dslighting/registry/ili/grade.py

@@ -0,0 +1,60 @@
+import pandas as pd
+import numpy as np
+
+
+def grade(submission: pd.DataFrame, answers: pd.DataFrame) -> float:
+    """
+    Grade the submission using MSE metric.
+
+    Args:
+        submission: DataFrame with columns ['id', 'pred_0', 'pred_1', ..., 'pred_167']
+                   Each row represents one test sample
+                   Columns pred_0 to pred_167 represent flattened predictions (24 timesteps * 7 features)
+        answers: DataFrame with columns ['id', 'pred_0', 'pred_1', ..., 'pred_167']
+                Ground truth in same format as submission
+
+    Returns:
+        MSE score (float) - lower is better
+    """
+    try:
+        # Extract prediction columns (pred_0 to pred_167 for 24*7=168 values)
+        pred_cols = [f'pred_{i}' for i in range(24 * 7)]
+
+        # Check if all required columns exist
+        if not all(col in submission.columns for col in pred_cols):
+            print(f"Error: Missing prediction columns. Expected columns: {pred_cols[:5]}...{pred_cols[-5:]}")
+            return float(1e10)
+
+        # Sort by id to ensure alignment
+        submission = submission.sort_values('id').reset_index(drop=True)
+        answers = answers.sort_values('id').reset_index(drop=True)
+
+        # Extract predictions
+        predictions = submission[pred_cols].values
+        ground_truth = answers[pred_cols].values
+
+        # Reshape to (N, 24, 7) for MSE calculation
+        predictions_3d = predictions.reshape(-1, 24, 7)
+        ground_truth_3d = ground_truth.reshape(-1, 24, 7)
+
+        # Ensure shapes match
+        if predictions_3d.shape != ground_truth_3d.shape:
+            print(f"Error: Shape mismatch. Got {predictions_3d.shape}, expected {ground_truth_3d.shape}")
+            return float(1e10)
+
+        # Calculate MSE (primary metric)
+        mse = np.mean((predictions_3d - ground_truth_3d) ** 2)
+
+        # Calculate MAE (for logging/debugging)
+        mae = np.mean(np.abs(predictions_3d - ground_truth_3d))
+
+        print(f"MSE: {mse:.6f}, MAE: {mae:.6f}")
+
+        return float(mse)
+
+    except Exception as e:
+        print(f"Error during grading: {e}")
+        import traceback
+        traceback.print_exc()
+        # Return a very high score (bad) on error
+        return float(1e10)

dslighting/registry/ili/prepare.py

@@ -0,0 +1,99 @@
+import pandas as pd
+import numpy as np
+import sys
+from pathlib import Path
+
+
+def prepare(raw: Path, public: Path, private: Path):
+    """
+    Prepare the ILI dataset for the benchmark.
+
+    This function converts the CSV time series data to numpy arrays for
+    time series forecasting.
+
+    Args:
+        raw: Path to raw data directory (contains national_illness.csv)
+        public: Path to public directory (visible to participants)
+        private: Path to private directory (hidden from participants, used for grading)
+    """
+    try:
+        # Add raw directory to path temporarily to import dataset module
+        sys.path.insert(0, str(raw))
+
+        # Use the local dataset module to load data
+        from dataset import get_dataset
+
+        # Change to raw directory to load data
+        import os
+        original_dir = os.getcwd()
+        os.chdir(str(raw))
+
+        try:
+            # Load train and test datasets
+            X_train, y_train = get_dataset('train')
+            X_test, y_test = get_dataset('test')
+
+            print(f"Loaded training data: X_train.shape = {X_train.shape}, y_train.shape = {y_train.shape}")
+            print(f"Loaded test data: X_test.shape = {X_test.shape}, y_test.shape = {y_test.shape}")
+
+            # Save training data as numpy arrays in public directory
+            np.save(public / "train_input.npy", X_train)
+            np.save(public / "train_target.npy", y_train)
+
+            # Save test input (without targets) in public directory
+            np.save(public / "test_input.npy", X_test)
+
+            # Save test targets for grading (private)
+            # Save as both numpy (for convenience) and CSV (for framework compatibility)
+            np.save(private / "test_targets.npy", y_test)
+
+            # Also save as CSV for framework compatibility
+            test_targets_flat = y_test.reshape(len(y_test), -1)
+            test_targets_df = pd.DataFrame(test_targets_flat,
+                                          columns=[f'pred_{i}' for i in range(24 * 7)])
+            test_targets_df.insert(0, 'id', range(len(y_test)))
+            test_targets_df.to_csv(private / "test_targets.csv", index=False)
+
+            # Create sample submission CSV file
+            # Flatten (N, 24, 7) to (N, 168) where 168 = 24*7
+            sample_submission_flat = np.zeros((len(y_test), 24 * 7))
+            sample_submission_df = pd.DataFrame(sample_submission_flat,
+                                               columns=[f'pred_{i}' for i in range(24 * 7)])
+            sample_submission_df.insert(0, 'id', range(len(y_test)))
+            sample_submission_df.to_csv(public / "sample_submission.csv", index=False)
+
+            # Also save numpy version for convenience
+            np.save(public / "sample_submission.npy", np.zeros_like(y_test))
+
+            print(f"Data preparation completed:")
+            print(f"  - Training: {len(X_train)} samples")
+            print(f"  - Test: {len(X_test)} samples")
+            print(f"  - Input sequence length: {X_train.shape[1]}")
+            print(f"  - Input features: {X_train.shape[2]}")
+            print(f"  - Output sequence length: {y_train.shape[1]}")
+            print(f"  - Output features: {y_train.shape[2]}")
+
+        finally:
+            os.chdir(original_dir)
+            sys.path.remove(str(raw))
+
+    except Exception as e:
+        print(f"Error loading data: {e}")
+        import traceback
+        traceback.print_exc()
+        # Fallback: create dummy files if loading fails
+        print("Creating dummy submission files...")
+        dummy_array = np.zeros((1, 24, 7))
+        np.save(private / "test_targets.npy", dummy_array)
+        np.save(public / "sample_submission.npy", dummy_array)
+
+    # Validation checks
+    assert (public / "train_input.npy").exists(), "Training input should exist"
+    assert (public / "train_target.npy").exists(), "Training target should exist"
+    assert (public / "test_input.npy").exists(), "Test input should exist"
+    assert (private / "test_targets.npy").exists(), "Test targets should exist"
+    assert (public / "sample_submission.npy").exists(), "Sample submission should exist"
+
+    print(f"\nPrepared ILI dataset:")
+    print(f"  - Public files: {list(public.glob('*'))}")
+    print(f"  - Private files: {list(private.glob('*'))}")

dslighting/registry/imet-2020-fgvc7/checksums.yaml

@@ -0,0 +1,7 @@
+private:
+  answers.csv: c708435becf1c7679bf09c1746942992
+public:
+  labels.csv: a62c433510585b96a558564fa8f530f4
+  sample_submission.csv: 879aa23cfa7947e6c39737615fa7f429
+  train.csv: ce560adcffe6ee6e9b6da89981f8da2e
+zip: 5e91584b7f667ed2c267fbc2ee83b335

dslighting/registry/imet-2020-fgvc7/config.yaml

@@ -0,0 +1,16 @@
+id: imet-2020-fgvc7
+name: iMet Collection 2020 - FGVC7 
+competition_type: code
+awards_medals: false
+prizes: null
+description: mlebench/competitions/imet-2020-fgvc7/description.md
+
+dataset:
+  answers: imet-2020-fgvc7/prepared/private/answers.csv
+  sample_submission: imet-2020-fgvc7/prepared/public/sample_submission.csv
+
+grader:
+  name: micro-f1-score
+  grade_fn: mlebench.competitions.imet-2020-fgvc7.grade:grade
+
+preparer: mlebench.competitions.imet-2020-fgvc7.prepare:prepare

dslighting/registry/imet-2020-fgvc7/description.md

@@ -0,0 +1,81 @@
+# Overview
+
+## Description
+
+The [Metropolitan Museum of Art](https://www.metmuseum.org/) in New York, also known as The Met, has a diverse collection of over 1.5M objects of which over 200K have been digitized with imagery. Can you help find the significant attributes to identify a specific work of art? Help advance this research in this notebook competition.
+
+The online cataloguing information is generated by subject matter experts and includes a wide range of data. These include, but are not limited to: multiple object classifications, artist, title, period, date, medium, culture, size, provenance, geographic location, and other related museum objects within The Met’s collection. While the annotations describe the object from an art history perspective, they can also be indirect in describing finer-grained attributes for the museum-goer’s understanding. Adding fine-grained attributes to aid in the visual understanding of the museum objects will enable the ability to search for visually related objects.
+
+> This is a Code Competition. Refer to Code Requirements for details.
+
+### About
+
+This is an FGVCx competition hosted as part of the [FGVC7 workshop](https://sites.google.com/view/fgvc7/home) at [CVPR 2020](http://cvpr2020.thecvf.com/).
+
+## Evaluation
+
+Submissions will be evaluated based on their micro averaged [F1 score](https://en.wikipedia.org/wiki/F1_score).
+
+### Submission File
+
+```
+id,attribute_ids
+00011f01965f141f5d1eea6592fa9862,0 1 2
+00014abc91ed3e4bf1663fde8136fe80,0 1 2
+0002e2054e303badc1a33463f6fb7973,0 1 2
+```
+
+## Timeline
+
+- **May 21, 2020** - Entry deadline. You must accept the competition rules before this date in order to compete.
+- **May 21, 2020** - Team Merger deadline. This is the last day participants may join or merge teams.
+- **May 28, 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.
+
+## 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 Notebook <= 9 hours run-time
+- GPU Notebook <= 4 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.
+
+## CVPR 2020
+
+This competition is part of the Fine-Grained Visual Categorization [FGVC7](https://sites.google.com/view/fgvc7/home) workshop at the Computer Vision and Pattern Recognition Conference [CVPR 2020](http://cvpr2020.thecvf.com/). A panel will review the top submissions for the competition based on the description of the methods provided. From this, a subset may be invited to 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.
+
+There is no cash prize for this competition. Attendees presenting in person are responsible for all costs associated with travel, expenses, and fees to attend CVPR 2020. PLEASE NOTE: CVPR frequently sells out early, we cannot guarantee CVPR registration after the competition's end. If you are interested in attending, please plan ahead.
+
+You can see a list of all of the FGVC7 competitions [here](https://sites.google.com/corp/view/fgvc7/competitions).
+
+## Citation
+
+Chenyang Zhang, Christine Kaeser-Chen, Grace Vesom, Jennie Choi, Maggie, Will Cukierski. (2020). iMet Collection 2020 - FGVC7. Kaggle. https://kaggle.com/competitions/imet-2020-fgvc7
+
+# Data
+
+## Dataset Description
+
+In this dataset, you are presented with a large number of artwork images and associated attributes of the art. The dataset has been expanded from the [2019 edition](https://www.kaggle.com/c/imet-2019-fgvc6/) of this competition. Multiple modalities can be expected and the camera sources are unknown. The photographs are often centered for objects, and in the case where the museum artifact is an entire room, the images are scenic in nature.
+
+Each object is annotated by a single annotator without a verification step. Annotators were advised to add multiple labels from an ontology provided by The Met, and additionally are allowed to add free-form text when they see fit. They were able to view the museum's online collection pages and advised to avoid annotating labels already present. The attributes can relate to what one "sees" in the work or what one infers as the object's "utility."
+
+While we have made efforts to make the attribute labels as high quality as possible, you should consider these annotations noisy. There may be a small number of attributes with similar meanings. The competition metric, F2 score, was intentionally chosen to provide some robustness against noisy labels, favoring recall over precision.
+
+This is a synchronous-rerun competition. When you submit, your code will be rerun on a private test set that contains unseen images.
+
+### Files
+
+The filename of each image is its `id`.
+
+- **train.csv** gives the `attribute_ids` for the train images in **/train**
+- **/test** contains the test images. You must predict the `attribute_ids` for these images.
+- **sample_submission.csv** contains a submission in the correct format
+- **labels.csv** provides descriptions of the attributes