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

dslighting/registry/handwriting/description.md

@@ -0,0 +1,39 @@
+# Handwriting Time Series Classification
+
+## Task Description
+
+You are solving a machine learning task of time series classification using the Handwriting dataset.
+
+The dataset presented here comprises real-world time series data. We have split the dataset into train and test parts.
+
+## Data Description
+
+- **Input**: A sequence of observed features (SEQUENCE_LENGTH=152, FEATURE_DIM=3)
+- **Output**: Predict the labels for the given sequence, where the label is in range of {0, 1, ..., 25} (26 classes total)
+- **Evaluation Metric**: Accuracy
+
+## Files
+
+- `train_data.npy` - Training features as a dense NumPy array of shape `(150, 152, 3)`
+- `train_labels.npy` - Training labels as integers in `[0, 25]` with shape `(150,)`
+- `test_data.npy` - Test features as a dense NumPy array of shape `(850, 152, 3)`
+- `sample_submission.csv` - Sample submission file showing the required format
+
+## Submission Format
+
+The submission file should contain predictions for each test sample:
+- Column `id`: Integer index for each test sample
+- Column `label`: Predicted class label (integer in range [0, 25])
+
+Example:
+```
+id,label
+0,5
+1,12
+2,3
+...
+```
+
+## Goal
+
+Train a time series classification model to achieve good performance on the test set as measured by accuracy.

dslighting/registry/handwriting/grade.py

@@ -0,0 +1,23 @@
+import pandas as pd
+import numpy as np
+from sklearn.metrics import accuracy_score
+
+
+def grade(submission: pd.DataFrame, answers: pd.DataFrame) -> float:
+    """
+    Grade the submission using accuracy metric.
+
+    Args:
+        submission: DataFrame with columns ['id', 'label']
+        answers: DataFrame with columns ['id', 'label']
+
+    Returns:
+        Accuracy score (float between 0 and 1)
+    """
+    # Merge on id to ensure alignment
+    merged = pd.merge(answers, submission, on='id', suffixes=('_true', '_pred'))
+
+    # Calculate accuracy
+    accuracy = accuracy_score(merged['label_true'], merged['label_pred'])
+
+    return accuracy

dslighting/registry/handwriting/prepare.py

@@ -0,0 +1,179 @@
+import numpy as np
+import pandas as pd
+from pathlib import Path
+
+
+def _label_sort_key(label: str):
+    try:
+        return float(label)
+    except (TypeError, ValueError):
+        return label
+
+
+def _build_label_mapping(raw_labels):
+    unique_labels = sorted({lbl for lbl in raw_labels if lbl is not None}, key=_label_sort_key)
+    return {label: idx for idx, label in enumerate(unique_labels)}
+
+
+def _load_ts_split(ts_path: Path, label_mapping=None):
+    """
+    Load a .ts file into a dense NumPy tensor and label vector.
+
+    Returns:
+        data: np.ndarray of shape (num_samples, seq_len, num_features)
+        labels: np.ndarray of int labels with shape (num_samples,)
+        mapping: dict mapping original labels to encoded integers
+    """
+    num_dimensions = None
+    seq_length_hint = None
+    in_data_section = False
+
+    samples = []
+    raw_labels = []
+
+    with ts_path.open("r", encoding="utf-8") as handle:
+        for line in handle:
+            stripped = line.strip()
+            if not stripped or stripped.startswith("#"):
+                continue
+
+            if not in_data_section:
+                if stripped.lower().startswith("@data"):
+                    in_data_section = True
+                    continue
+
+                if stripped.startswith("@"):
+                    parts = stripped[1:].split(None, 1)
+                    key = parts[0].lower()
+                    value = parts[1].strip() if len(parts) > 1 else ""
+                    if key == "dimensions":
+                        num_dimensions = int(value)
+                    elif key == "serieslength":
+                        try:
+                            seq_length_hint = int(value)
+                        except ValueError:
+                            seq_length_hint = None
+                    continue
+
+                continue
+
+            # Data row
+            if num_dimensions is None:
+                raise ValueError(f"Unable to parse dimensions from header in {ts_path}")
+
+            parts = stripped.split(":")
+            if len(parts) < num_dimensions:
+                raise ValueError(f"Unexpected data row format in {ts_path}: {stripped[:50]}...")
+
+            dimension_series = []
+            for dim_idx in range(num_dimensions):
+                seq_str = parts[dim_idx].strip()
+                if not seq_str:
+                    dimension_series.append([])
+                    continue
+
+                values = []
+                for token in seq_str.split(","):
+                    token = token.strip()
+                    if not token:
+                        continue
+                    if token == "?":
+                        values.append(np.nan)
+                    else:
+                        values.append(float(token))
+
+                dimension_series.append(values)
+
+            samples.append(dimension_series)
+
+            label_str = parts[num_dimensions].strip() if len(parts) > num_dimensions else None
+            raw_labels.append(label_str or None)
+
+    if not samples:
+        raise ValueError(f"No samples parsed from {ts_path}")
+
+    # Ensure label mapping
+    mapping = label_mapping or _build_label_mapping(raw_labels)
+    labels = np.array([mapping[label] for label in raw_labels], dtype=np.int64)
+
+    # Convert dimension lists into dense arrays
+    tensor_samples = []
+    global_seq_len = None
+
+    for dims in samples:
+        series_arrays = []
+        sample_len = None
+
+        for dim_values in dims:
+            arr = np.asarray(dim_values, dtype=np.float32)
+            if sample_len is None:
+                sample_len = arr.shape[0]
+            elif arr.shape[0] != sample_len:
+                raise ValueError("Inconsistent dimension lengths within sample.")
+
+            if seq_length_hint is not None and arr.shape[0] != seq_length_hint:
+                raise ValueError("Sequence length mismatch relative to header declaration.")
+
+            series_arrays.append(arr)
+
+        sample_tensor = np.stack(series_arrays, axis=-1)  # (seq_len, num_features)
+        global_seq_len = sample_tensor.shape[0] if global_seq_len is None else global_seq_len
+        if sample_tensor.shape[0] != global_seq_len:
+            raise ValueError("Inconsistent sequence lengths across samples.")
+
+        tensor_samples.append(sample_tensor)
+
+    data = np.stack(tensor_samples, axis=0)  # (num_samples, seq_len, num_features)
+    return data, labels, mapping
+
+
+def prepare(raw: Path, public: Path, private: Path):
+    """
+    Prepare the handwriting dataset for the benchmark.
+
+    Args:
+        raw: Path to raw data directory (contains Handwriting_TRAIN.ts and Handwriting_TEST.ts)
+        public: Path to public directory (visible to participants)
+        private: Path to private directory (hidden from participants, used for grading)
+    """
+    # Materialize dense tensors from the raw .ts files
+    train_path = raw / "Handwriting_TRAIN.ts"
+    test_path = raw / "Handwriting_TEST.ts"
+
+    X_train, y_train, label_mapping = _load_ts_split(train_path)
+    X_test, y_test, _ = _load_ts_split(test_path, label_mapping=label_mapping)
+
+    # Convert labels to 1D arrays
+    y_train = np.asarray(y_train, dtype=np.int64).reshape(-1)
+    y_test = np.asarray(y_test, dtype=np.int64).reshape(-1)
+
+    # Persist prepared arrays for participants
+    np.save(public / "train_data.npy", X_train)
+    np.save(public / "train_labels.npy", y_train)
+    np.save(public / "test_data.npy", X_test)
+
+    # Sample submission (default all zeros)
+    sample_submission = pd.DataFrame({"id": range(len(y_test)), "label": 0})
+    sample_submission.to_csv(public / "sample_submission.csv", index=False)
+
+    # Private ground-truth labels for grading
+    test_labels_df = pd.DataFrame({"id": range(len(y_test)), "label": y_test})
+    test_labels_df.to_csv(private / "test_labels.csv", index=False)
+
+    # Basic validation checks
+    expected_public = [
+        public / "train_data.npy",
+        public / "train_labels.npy",
+        public / "test_data.npy",
+        public / "sample_submission.csv",
+    ]
+    for path in expected_public:
+        assert path.exists(), f"Missing public artifact: {path.name}"
+
+    assert (private / "test_labels.csv").exists(), "Test labels should exist"
+
+    print(
+        "Prepared handwriting dataset:\n"
+        f"  - Train split: {X_train.shape}, labels: {y_train.shape}\n"
+        f"  - Test split: {X_test.shape}, labels: {y_test.shape}"
+    )

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

@@ -0,0 +1,5 @@
+private:
+  answers.csv: 5e7355890f648e4f8be7a68e6c9c71c5
+public:
+  sample_submission.csv: a1bdb830f6582fcb9cffe8cec363a0b1
+zip: 30eafe0eda5d047bce1488c9a3470d57

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

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

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

@@ -0,0 +1,159 @@
+# Overview
+
+## Description
+
+The Herbarium 2020 FGVC7 Challenge is to identify vascular plant species from a large, long-tailed collection herbarium specimens provided by the [New York Botanical Garden](https://www.nybg.org/plant-research-and-conservation/) (NYBG).
+
+The Herbarium 2020 dataset contains over 1M images representing over 32,000 plant species. This is a dataset with a long tail; there are a minimum of 3 specimens per species. However, some species are represented by more than a hundred specimens. This dataset only contains vascular land plants which includes lycophytes, ferns, gymnosperms, and flowering plants. The extinct forms of lycophytes are the major component of coal deposits, ferns are indicators of ecosystem health, gymnosperms provide major habitats for animals, and flowering plants provide all of our crops, vegetables, and fruits.
+
+![specimen1](https://raw.githubusercontent.com/visipedia/herbarium_comp/master/2020/assets/specimen1.jpg)
+![specimen2](!https://raw.githubusercontent.com/visipedia/herbarium_comp/master/2020/assets/specimen2.jpg)
+![specimen3](https://raw.githubusercontent.com/visipedia/herbarium_comp/master/2020/assets/specimen3.jpg)
+![specimen4](https://raw.githubusercontent.com/visipedia/herbarium_comp/master/2020/assets/specimen4.jpg)
+![specimen5](https://raw.githubusercontent.com/visipedia/herbarium_comp/master/2020/assets/specimen5.jpg)
+
+The teams with the most accurate models will be contacted, with the intention of using them on the un-named plant collections in the NYBG herbarium collection, and assessed by the NYBG plant specialists.
+
+### Background
+
+The New York Botanical Garden (NYBG) herbarium contains more than 7.8 million plant and fungal specimens. Herbaria are a massive repository of plant diversity data. These collections not only represent a vast amount of plant diversity, but since herbarium collections include specimens dating back hundreds of years, they provide snapshots of plant diversity through time. The integrity of the plant is maintained in herbaria as a pressed, dried specimen; a specimen collected nearly two hundred years ago by Darwin looks much the same as one collected a month ago by an NYBG botanist. All specimens not only maintain their morphological features but also include collection dates and locations, and the name of the person who collected the specimen. This information, multiplied by millions of plant collections, provides the framework for understanding plant diversity on a massive scale and learning how it has changed over time.
+
+### About
+
+This is an FGVC competition hosted as part of the [FGVC7](https://sites.google.com/corp/view/fgvc7/home) workshop at [CVPR 2020](http://cvpr2020.thecvf.com/) and sponsored by [NYBG](https://www.nybg.org/plant-research-and-conservation/).
+
+Details of this competition are mirrored on the [github page](https://github.com/visipedia/herbarium_comp). Please post in the forum or open an issue if you have any questions or problems with the dataset.
+
+## Evaluation
+
+Submissions are evaluated using the [macro F1 score](https://scikit-learn.org/stable/modules/generated/sklearn.metrics.f1_score.html).
+
+F1 is calculated as follows:
+
+$$
+F_1=2 * \frac{\text { precision } * \text { recall }}{\text { precision }+ \text { recall }}
+$$
+
+where:
+
+$$
+\begin{gathered}
+\text { precision }=\frac{T P}{T P+F P} \\
+\text { recall }=\frac{T P}{T P+F N}
+\end{gathered}
+$$
+
+In "macro" F1 a separate F1 score is calculated for each `species` value and then averaged.
+
+### Submission Format
+
+For each image `Id`, you should predict the corresponding image label ("category_id") in the `Predicted` column. The submission file should have the following format:
+
+```
+Id,Predicted
+0,0
+1,27
+2,42
+...
+```
+
+## Timeline
+
+- **March 9, 2020** - Competition start date.
+- **May 19, 2020** - Entry deadline. You must accept the competition rules before this date in order to compete.
+- **May 19, 2020** - Team Merger deadline. This is the last day participants may join or merge teams.
+- **May 26, 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.
+
+## 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
+
+Christine Kaeser-Chen, Kiat Chuan Tan, Walter Reade, Maggie Demkin. (2020). Herbarium 2020 - FGVC7. Kaggle. https://kaggle.com/competitions/herbarium-2020-fgvc7
+
+# Data
+
+## Dataset Description
+
+### Data Overview
+
+The training and test set contain images of herbarium specimens, from over 32,000 species of vascular plants. Each image contains exactly one specimen. The text and barcode labels on the specimen images have been blurred to remove category information in the image.
+
+The data has been approximately split 80%/20% for training/test. Each category has at least 1 instance in both the training and test datasets. Note that the test set distribution is slightly different from the training set distribution. The training set contains species with hundreds of examples, but the test set has the number of examples per species capped at a maximum of 10.
+
+### Dataset Details
+
+Each image has different image dimensions, with a maximum of 1000 pixels in the larger dimension. These have been resized from the original image resolution. All images are in JPEG format.
+
+### Dataset Format
+
+This dataset uses the [COCO dataset format](http://cocodataset.org/#format-data) with additional annotation fields. In addition to the species category labels, we also provide region and supercategory information.
+
+The training set metadata (`train/metadata.json`) and test set metadata (`test/metadata.json`) are JSON files in the format below. Naturally, the test set metadata file omits the "annotations", "categories" and "regions" elements.
+
+```
+{
+  "annotations" : [annotation],
+  "categories" : [category],
+  "images" : [image],
+  "info" : info,
+  "licenses": [license],
+  "regions": [region]
+}
+
+info {
+  "year" : int,
+  "version" : str,
+  "url": str,
+  "description" : str,
+  "contributor" : str,
+  "date_created" : datetime
+}
+
+image {
+  "id" : int,
+  "width" : int,
+  "height" : int,
+  "file_name" : str,
+  "license" : int
+}
+
+annotation {
+  "id": int,
+  "image_id": int,
+  "category_id": int,
+  # Region where this specimen was collected.
+  "region_id": int
+}
+
+category {
+  "id" : int,
+  # Species name
+  "name" : str,
+  # We also provide the super-categories for each species.
+  "family": str,
+  "genus": str
+}
+
+region {
+  "id": int
+  "name": str
+}
+
+license {
+  "id": 1,
+  "name": str,
+  "url": str
+}
+```
+
+The training set images are organized in subfolders `train/<subfolder1>/<subfolder2>/<image id>.jpg`.
+
+The test set images are organized in subfolders `test/<subfolder>/<image id>.jpg`.

dslighting/registry/herbarium-2020-fgvc7/description_obfuscated.md

@@ -0,0 +1,27 @@
+# Task
+
+Build a model to classify the species of plants from images.
+
+# Metric
+
+Macro F1 score. A separate F1 score is calculated for each `species` value and then averaged.
+
+# Submission Format
+
+For each image `Id`, you should predict the corresponding image label ("category_id") in the `Predicted` column. The submission file should have the following format:
+
+```
+Id,Predicted
+0,0
+1,27
+2,42
+...
+```
+
+# Dataset 
+
+This dataset uses the [COCO dataset format](http://cocodataset.org/#format-data) with additional annotation fields. In addition to the species category labels, we also provide region and supercategory information.
+
+The training set images are organized in subfolders `train/<subfolder1>/<subfolder2>/<image id>.jpg`.
+
+The test set images are organized in subfolders `test/<subfolder>/<image id>.jpg`.

dslighting/registry/herbarium-2020-fgvc7/grade.py

@@ -0,0 +1,34 @@
+import pandas as pd
+from sklearn.metrics import f1_score
+
+from mlebench.grade_helpers import InvalidSubmissionError
+
+
+def prepare_for_metric(submission: pd.DataFrame, answers: pd.DataFrame):
+    """
+    `submission` and `answers` are pd.DataFrame with "Id" and "Predicted" columns
+    """
+    if len(submission) != len(answers):
+        raise InvalidSubmissionError(
+            f"Submission length {len(submission)} != answers length {len(answers)}"
+        )
+    if "Id" not in submission.columns or "Predicted" not in submission.columns:
+        raise InvalidSubmissionError("Submission must have 'Id' and 'Predicted' columns")
+
+    assert "Id" in answers.columns, "Answers must have 'Id' column"
+    assert "Predicted" in answers.columns, "Answers must have 'Predicted' column"
+
+    # Sort submission and answers by "Id"
+    submission = submission.sort_values("Id")
+    answers = answers.sort_values("Id")
+    if (submission["Id"].values != answers["Id"].values).any():
+        raise InvalidSubmissionError("Submission and answers have mismatched 'Id' columns")
+
+    y_true = [int(y) for y in answers["Predicted"]]
+    y_pred = [int(y) for y in submission["Predicted"]]
+    return y_true, y_pred
+
+
+def grade(submission: pd.DataFrame, answers: pd.DataFrame) -> float:
+    y_true, y_pred = prepare_for_metric(submission, answers)
+    return f1_score(y_true=y_true, y_pred=y_pred, average="macro")