Datasets:

Tran1312
/

object365-labels_80Cls

@@ -5,7 +5,7 @@ task_categories:
 size_categories:
   - 1M<n<10M
 source_datasets:
-  - extended
 annotations_creators:
   - found
 license: cc-by-4.0
@@ -22,268 +22,231 @@ tags:
   - 80-classes
 ---
-# Objects365 Label Organization and DataLoader Architecture (80 Classes)
-This dataset provides a filtered **80-class subset of Objects365** for large-scale object-detection pretraining and training. It contains COCO-style bounding-box annotations reorganized into JSONL files, explicit image-path mappings, train/validation metadata, and optional class-repeat factors for long-tail rebalancing.
-The accompanying DataLoader uses **disk-backed JSONL records with cached in-memory indexes** for direct byte-offset access, deterministic epoch-level sampling, train-time class oversampling, bounding-box validation, letterbox resizing, Albumentations-based augmentation, and retry/error logging for malformed samples.
-This card documents the label organization, directory structure, schemas, relationships between files, and the runtime data-loading architecture. It has been aligned with the current `dataloader.py` implementation.
 ---
-## 1. Overview
-Labels and metadata are stored primarily in **JSON Lines (`.jsonl`)** format rather than one deeply nested JSON file.
-### Why JSONL is used
-- Suitable for large datasets containing more than 1.7 million image records and nearly 16 million annotations.
-- Records can be scanned sequentially without deserializing the entire source file.
-- Byte offsets can be cached and later used with `f.seek()` for direct random access to individual records.
-- Corrupted lines can be skipped during index construction without invalidating the rest of the file.
-- The format is easy to filter, shard, inspect, and regenerate.
-> **Important:** the JSONL files themselves are not fully loaded into RAM, but the current DataLoader does keep several Python data structures in memory: the image-ID offset index, annotation-group index, image-path map, image-category map during dataset construction, and the final image-ID list. Therefore, the implementation should be described as **disk-backed record access with in-memory indexes**, not as an `O(1)`-memory loader.
 ---
-## 2. Directory Structure and Dataset Statistics
-The `labels/` directory is split into independent `train/` and `val/` subsets.
 ```text
 labels/
 ├── README.md
 ├── train/
-│   ├── annotations.jsonl      # 15,538,897 annotations (~2.64 GB)
-│   ├── categories.jsonl       # 80 object classes (~2.4 KB)
-│   ├── class_sampling.jsonl   # Class repeat/oversampling factors (~2.5 KB)
-│   ├── images_info.jsonl      # 1,652,206 labeled images (~177.93 MB)
-│   └── images_train.jsonl     # 1,742,289 physical image paths (~150.87 MB)
 └── val/
-    ├── annotations.jsonl      # 442,988 annotations (~75.53 MB)
-    ├── categories.jsonl       # 80 object classes (~2.4 KB)
-    ├── images_info.jsonl      # 67,749 labeled images (~7.30 MB)
-    └── images_val.jsonl       # 80,000 physical image paths (~6.93 MB)
 ```
-### Detailed statistics
-| Split | File | Records | Approx. size | Main purpose |
 | :--- | :--- | ---: | ---: | :--- |
-| **train** | `annotations.jsonl` | 15,538,897 | 2.64 GB | Bounding boxes and annotation flags such as `iscrowd` and `isfake` |
-| | `categories.jsonl` | 80 | 2.4 KB | Definition of the 80 target classes |
-| | `class_sampling.jsonl` | 80 | 2.5 KB | Per-class repeat factors used for train-time oversampling |
-| | `images_info.jsonl` | 1,652,206 | 177.93 MB | Image IDs, original dimensions, file names, and metadata |
-| | `images_train.jsonl` | 1,742,289 | 150.87 MB | Maps image file names to physical patch paths |
 | **val** | `annotations.jsonl` | 442,988 | 75.53 MB | Validation bounding boxes and labels |
-| | `categories.jsonl` | 80 | 2.4 KB | Same target-class definition as the train split |
-| | `images_info.jsonl` | 67,749 | 7.30 MB | Metadata for labeled validation images |
-| | `images_val.jsonl` | 80,000 | 6.93 MB | Maps validation image names to physical patch paths |
-> **Notes**
->
-> - `images_train.jsonl` contains more records than `images_info.jsonl` because the downloaded image collection includes images that do not contain any of the retained 80 target classes or whose labels were filtered during preprocessing.
-> - Every labeled image represented by `images_info.jsonl` is expected to have a corresponding physical-path entry.
-> - `class_sampling.jsonl` exists only for the training split because class rebalancing must not alter the validation distribution.
 ---
-## 3. Entity Relationships
-The JSONL files are linked through explicit keys in a relational-database-like structure.
-```mermaid
-erDiagram
-    CATEGORIES ||--o{ ANNOTATIONS : "category_id"
-    CATEGORIES ||--o{ CLASS_SAMPLING : "id"
-    IMAGES_INFO ||--o{ ANNOTATIONS : "image_id"
-    IMAGES_INFO ||--|| IMAGE_PATH_MAP : "file_name == image_name"
-    CATEGORIES {
-        int id PK "Raw category identifier"
-        string name "Object-class name"
-    }
-    CLASS_SAMPLING {
-        int id FK "Category identifier"
-        float probability "Sampling percentage"
-    }
-    IMAGES_INFO {
-        int id PK "Image identifier"
-        string file_name "Original image filename"
-        int width "Original width in pixels"
-        int height "Original height in pixels"
-        int license "Source license identifier"
-        string url "Source URL"
-    }
-    IMAGE_PATH_MAP {
-        string image_name PK "Image filename"
-        string path "Relative physical path"
-    }
-    ANNOTATIONS {
-        int id PK "Annotation identifier"
-        int image_id FK "References IMAGES_INFO.id"
-        int category_id FK "References CATEGORIES.id"
-        array bbox "[x_min, y_min, width, height]"
-        float area "Bounding-box area"
-        int iscrowd "Crowd-region flag"
-        int isfake "Synthetic/drawn-object flag"
-        int isreflected "Reflection flag"
-        int flag_reflected "Auxiliary reflection flag"
-    }
-```
-The loader normalizes the category records and constructs a `cat_id_to_idx` mapping from raw dataset category IDs to contiguous model-class indices.
----
-## 4. Data Schemas
-Each non-empty line in a `.jsonl` file is an independent JSON object.
-### 4.1. `categories.jsonl`
-Defines the **80-class object vocabulary**.
-**Schema**
 - `id` (`int`): raw category identifier.
-- `name` (`str`): English class name.
-**Example**
 ```json
 {"name": "Person", "id": 0}
-{"name": "Sneakers", "id": 2}
 {"name": "Chair", "id": 1}
 ```
-The current DataLoader passes these records through `normalize_categories()` before constructing the model-facing class-index mapping.
 ---
-### 4.2. `images_info.jsonl`
-Stores geometric and identifying metadata for each labeled image.
-**Schema**
 - `id` (`int`): unique image identifier.
 - `file_name` (`str`): original image filename.
-- `width` (`int`): original image width in pixels.
-- `height` (`int`): original image height in pixels.
-- `license` (`int`): source license identifier.
-- `url` (`str`): source URL, often an empty string.
-**Example**
 ```json
 {"height": 512, "id": 420917, "license": 5, "width": 769, "file_name": "objects365_v1_00420917.jpg", "url": ""}
-{"height": 500, "id": 900001, "license": 5, "width": 333, "file_name": "objects365_v2_00900001.jpg", "url": ""}
-```
-The DataLoader builds a cached mapping:
-```text
-image_id -> byte_offset_in_images_info.jsonl
 ```
-This allows metadata for one image to be retrieved by seeking directly to the corresponding byte position.
 ---
-### 4.3. `images_train.jsonl` and `images_val.jsonl`
-The physical image collection downloaded from Hugging Face (`Tran1312/object365-images`) is distributed across patch directories such as `patch0/`, `patch1/`, ..., `patch50/`.
-These files map an image filename to its relative path on disk.
-**Schema**
-- `image_name` (`str`): image filename; expected to match `file_name` in `images_info.jsonl`.
-- `path` (`str`): relative path from the corresponding image-split root directory.
-**Example**
 ```json
 {"image_name": "objects365_v2_00953995.jpg", "path": "patch17/objects365_v2_00953995.jpg"}
-{"image_name": "objects365_v2_01598998.jpg", "path": "patch33/objects365_v2_01598998.jpg"}
 ```
-The current implementation loads this mapping into a Python dictionary and optionally caches the dictionary as a pickle file.
 ---
-### 4.4. `annotations.jsonl`
-Stores bounding boxes and annotation attributes.
-**Schema**
-- `id` (`int`): unique annotation identifier.
-- `image_id` (`int`): foreign key referencing an image in `images_info.jsonl`.
-- `category_id` (`int`): foreign key referencing a category in `categories.jsonl`.
-- `bbox` (`list[float]`): COCO-style box `[x_min, y_min, width, height]`, expressed in original-image pixels.
 - `area` (`float`): bounding-box area.
 - `iscrowd` (`int`): crowd-region flag.
 - `isfake` (`int`): synthetic/drawn-object flag.
-- `isreflected` (`int`) and `flag_reflected` (`int`): reflection-related metadata.
-**Example**
 ```json
 {"id": 26899493, "iscrowd": 0, "isfake": 0, "area": 3764.58, "isreflected": 0, "bbox": [20.3, 260.25, 82.69, 45.52], "image_id": 0, "category_id": 0, "flag_reflected": 0}
 ```
-The DataLoader constructs a cached annotation-group index:
-```text
-image_id -> [annotation_byte_offset_1, annotation_byte_offset_2, ...]
-```
-At runtime, only the annotation records associated with the requested image are read from the JSONL file.
 ---
-### 4.5. `class_sampling.jsonl`
-Used only by the training split to mitigate long-tail class imbalance.
-**Schema**
-- `id` (`int`): raw category identifier.
-- `probability` (`int` or `float`): repeat percentage, where `100` corresponds to a repeat factor of `1.0`.
-The loader computes
-\[
-\text{factor}(c)=\max\left(1,\frac{\text{probability}(c)}{100}\right).
-\]
-For an image containing multiple retained classes, its image-level repeat factor is
-\[
-r_i=\max_{c\in C_i}\text{factor}(c),
-\]
-where \(C_i\) is the set of valid categories present in image \(i\).
-The actual repeat count uses **stochastic rounding**:
-\[
-n_i = \lfloor r_i \rfloor +
-\mathbf{1}\left[u < r_i-\lfloor r_i \rfloor\right],
-\qquad u\sim U(0,1).
-\]
-Therefore, a factor such as `2.39` produces two copies deterministically and a third copy with probability `0.39`.
-**Example**
 ```json
 {"id": 0, "probability": 100}
@@ -291,359 +254,124 @@ Therefore, a factor such as `2.39` produces two copies deterministically and a t
 {"id": 78, "probability": 202}
 ```
-Classes absent from the sampling file effectively fall back to a repeat factor of `1.0` when images are oversampled.
 ---
-## 5. DataLoader Architecture
-The current implementation has four conceptually distinct phases.
-```mermaid
-flowchart TD
-    subgraph Indexing ["1. Index Construction / Cache Loading"]
-        A1["images_info.jsonl"] -->|"build_id_offset_index()"| B1["image_id -> byte offset"]
-        A2["annotations.jsonl"] -->|"build_annotation_group_index()"| B2["image_id -> annotation offsets"]
-        A3["images_train/val.jsonl"] -->|"load_image_path_map()"| B3["file_name -> relative path"]
-    end
-    subgraph DatasetBuild ["2. Dataset Construction"]
-        B1 --> C["Collect valid categories per image"]
-        B2 --> C
-        C --> D{"Keep images without valid annotations?"}
-        D --> E["Final image-ID list"]
-        S["class_sampling.jsonl"] -->|"train only"| F["Image-level repeat factors"]
-        E --> F
-        F --> G["Oversampled train image-ID list"]
-    end
-    subgraph SampleLoad ["3. Per-Sample Loading"]
-        G --> H["Select image_id"]
-        H --> I["Seek image metadata"]
-        H --> J["Seek relevant annotations"]
-        H --> K["Resolve physical image path"]
-        K --> L["cv2.imread()"]
-        I & J & L --> M["Filter / clip boxes"]
-        M --> N["Letterbox to square input size"]
-        N --> O["Albumentations train augmentation"]
-        O --> P["Tensor image + target dict"]
-    end
-    subgraph Batching ["4. Batching"]
-        P --> Q["collate_fn()"]
-        Q --> R["Tensor batch + list[target]"]
-    end
-```
-### 5.1. Cached indexes
-Three expensive data structures are persisted as pickle files when caching is enabled:
-1. **Image metadata offset index**
-   ```text
-   image_id -> byte_offset
-   ```
-2. **Annotation-group index**
-   ```text
-   image_id -> [byte_offset, byte_offset, ...]
-   ```
-3. **Image-path map**
-   ```text
-   file_name -> relative_path
-   ```
-If a cache file already exists and `force_rebuild` / `cfg.rebuild_index` is false, it is loaded directly.
-> The current cache mechanism does not automatically validate source-file modification time, file size, or content hash. If a JSONL source file changes, `cfg.rebuild_index=True` should be used to rebuild the corresponding cache.
-### 5.2. Dataset-construction pass
-After the indexes are available, `collect_image_categories()` traverses the image IDs and their annotation offsets to determine the set of valid categories present in each image.
-This pass is used to:
-- exclude images without retained annotations when `include_images_without_annotations=False`;
-- compute image-level repeat factors for class-balanced training.
-This category map is created during dataset construction and is not currently persisted as its own cache.
-### 5.3. Per-sample annotation filtering
-For every annotation associated with an image, `annotation_target()`:
-1. optionally removes `iscrowd == 1`;
-2. optionally removes `isfake == 1`;
-3. removes categories not present in the normalized class mapping;
-4. rejects missing, malformed, non-finite, zero-width, zero-height, or negative-size boxes;
-5. converts `[x, y, w, h]` to `[x1, y1, x2, y2]`;
-6. **clips** coordinates to image boundaries;
-7. rejects the box only if its area becomes non-positive after clipping.
-Therefore, boxes that partially extend outside the image are not automatically discarded; they are clipped to the valid image region.
-### 5.4. Image resizing and augmentation order
-The implementation performs transformations in this order:
-1. Read BGR image with OpenCV.
-2. Validate that the decoded image has shape `H x W x 3`.
-3. Convert BGR to RGB.
-4. Apply square **letterbox resizing** unless the image is already exactly `imgsz x imgsz`.
-5. Transform bounding boxes using the same scale and padding.
-6. Apply training augmentation with Albumentations.
-7. Convert the final uint8 RGB array to a contiguous PyTorch tensor.
-8. Convert pixel values to `float32` in `[0, 1]`.
-The train-time augmentation pipeline contains:
-```text
-HorizontalFlip
--> ShiftScaleRotate
--> RandomBrightnessContrast
--> HueSaturationValue
--> GaussNoise
--> Blur
-```
-Bounding boxes use Albumentations `pascal_voc` format (`[x1, y1, x2, y2]`) with `min_visibility=0.4`.
-If a sample has no boxes before augmentation, `DetectionAugmenter.__call__()` currently returns immediately, so no image-only augmentation is applied to that sample.
-### 5.5. Returned sample format
-Each dataset item is returned as
-```python
-image_tensor, {
-    "boxes": boxes_tensor,
-    "labels": labels_tensor,
-}
-```
-with:
-```text
-image_tensor : float32 [3, imgsz, imgsz], range [0, 1]
-boxes        : float32 [N, 4], pixel-space xyxy coordinates
-labels       : int64   [N], contiguous model-class indices
-```
-An image with no retained objects receives:
-```text
-boxes  -> shape [0, 4]
-labels -> shape [0]
-```
-The custom `collate_fn()` stacks image tensors into one batch while preserving targets as a Python list because the number of objects varies between images.
 ---
-## 6. Deterministic Sampling, Epochs, and Resume Support
-Training uses a custom `EpochBatchSampler` instead of DataLoader's ordinary `batch_size + shuffle` path.
-For epoch \(e\), shuffled indices are generated from
-```python
-torch.Generator().manual_seed(seed + epoch)
-```
-so a given seed and epoch produce the same permutation.
-The sampler yields tuples of
 ```text
-(sample_seed, dataset_index)
 ```
-rather than only the dataset index. The dataset uses `sample_seed` to seed:
-- the local retry RNG;
-- the Albumentations transform for that specific sample.
-The per-sample seed is computed as
-\[
-\text{sample\_seed} =
-\text{seed} + e\cdot |\mathcal D| + i,
-\]
-where \(i\) is the sampled dataset index.
-`EpochBatchSampler.start_batch` allows iteration to begin from a later batch, which is useful for exact or near-exact mid-epoch resume when the training loop restores the corresponding sampler state.
----
-## 7. Bad-Sample Recovery
-`ObjectDetectionDataset.__getitem__()` does not immediately terminate training when one sample cannot be loaded.
-For each requested sample, it can retry up to `max_load_retries` times.
-A failed sample can arise from conditions such as:
-- missing path-map entry;
-- unreadable or missing image file;
-- unexpected decoded image shape;
-- malformed metadata or annotations.
-When a load fails:
-1. the exception is printed;
-2. the error is optionally appended to a split-specific log file;
-3. another dataset index is drawn from a deterministic local RNG;
-4. loading is retried.
-If all attempts fail, the dataset raises a `RuntimeError`.
-> Because a failed sample is replaced by another index, a batch can contain a replacement image instead of the originally requested one. This keeps training alive but means silent replacement is part of the effective sampling distribution and should be monitored through the error log.
 ---
-## 8. Memory and I/O Characteristics
-The implementation avoids loading the raw 2.6 GB annotation JSONL or the full image pixel dataset into memory, but it is **not constant-memory with respect to dataset size**.
-### Structures held in RAM
-Depending on split and configuration, RAM includes at least:
-- `images_offset_index`: one dictionary entry per labeled image;
-- `ann_group_index`: one dictionary/list structure containing an offset for every indexed annotation;
-- `image_path_map`: one filename/path pair per physical image-map record;
-- `image_ids`: the final dataset index list, potentially expanded by oversampling;
-- `image_categories`: category sets constructed for every image during dataset initialization;
-- loaded pickle representations of the above cached indexes.
-The annotation-group index is especially significant because Python integers, lists, and dictionary entries introduce substantially more overhead than their raw binary values.
-### Per-sample I/O
-For each sample, the current dataset implementation:
-- opens `images_info.jsonl`, seeks to one metadata offset, reads one line, then closes the file;
-- opens `annotations.jsonl`, seeks to each relevant annotation offset, reads the associated lines, then closes the file;
-- reads the image file with `cv2.imread()`.
-This design is worker-safe because file handles are local to each call/process, but repeated file opening introduces additional system-call overhead.
-### Practical characterization
-The architecture is best summarized as:
-> **Disk-backed JSONL storage + cached in-memory random-access indexes + on-demand image/record reads.**
-Its primary benefit is avoiding full deserialization of the raw metadata files and avoiding image preloading, while still providing direct lookup by image ID.
----
-## 9. Multi-Worker DataLoader Behavior
-The DataLoader supports standard PyTorch multiprocessing through `num_workers`.
-When workers are enabled:
-- `persistent_workers` can keep them alive across epochs;
-- `prefetch_factor` controls how many batches are prepared ahead of consumption;
-- `pin_memory` can accelerate host-to-device transfer when used appropriately;
-- dataset records are read through worker-local file opens rather than one shared mutable file pointer.
-The training loader delegates shuffling and batch formation to `EpochBatchSampler`. The validation loader uses ordinary deterministic ordering with `shuffle=False`.
----
-## 10. Validation-Split Consistency Checks
-Before building the datasets, the loader:
-1. loads and normalizes training categories;
-2. checks that `cfg.nc` matches the number of normalized classes;
-3. if validation metadata exists, loads validation categories;
-4. requires the normalized train and validation class definitions to match exactly.
-If validation image metadata is absent, the loader skips construction of `val_loader` rather than failing the entire training setup.
----
-## 11. List of 80 Object Classes
-| ID | Class Name | ID | Class Name | ID | Class Name | ID | Class Name |
-| :---: | :--- | :---: | :--- | :---: | :--- | :---: | :--- |
-| **0** | Person | **20** | Potted Plant | **40** | Umbrella | **60** | Bed |
-| **1** | Chair | **21** | Flower | **41** | Bicycle | **61** | Laptop |
-| **2** | Sneakers | **22** | Bench | **42** | Stool | **62** | Hockey Stick |
-| **3** | Desk | **23** | Pillow | **43** | Couch | **63** | Stuffed Toy |
-| **4** | Hat | **24** | SUV | **44** | Trash bin Can | **64** | Tent |
-| **5** | Car | **25** | Bowl/Basin | **45** | Drum | **65** | Awning |
-| **6** | Lamp | **26** | Leather Shoes | **46** | Van | **66** | Pickup Truck |
-| **7** | Street Lights | **27** | Necklace | **47** | Barrel/bucket | **67** | Paddle |
-| **8** | Cabinet/shelf | **28** | Microphone | **48** | Guitar | **68** | Sailboat |
-| **9** | Glasses | **29** | Boots | **49** | Bus | **69** | Mirror |
-| **10** | Bottle | **30** | Bracelet | **50** | Carpet | **70** | Camera |
-| **11** | Cup | **31** | Moniter/TV | **51** | Slippers | **71** | Horse |
-| **12** | Handbag/Satchel | **32** | Vase | **52** | Watch | **72** | Cell Phone |
-| **13** | Picture/Frame | **33** | Flag | **53** | Bakset | **73** | Wild Bird |
-| **14** | Other Shoes | **34** | Backpack | **54** | Motorcycle | **74** | Dog |
-| **15** | Helmet | **35** | Book | **55** | High Heels | **75** | Towel |
-| **16** | Plate | **36** | Speaker | **56** | Sandals | **76** | Tripod |
-| **17** | Storage box | **37** | Belt | **57** | Truck | **77** | Canned |
-| **18** | Gloves | **38** | Wine Glass | **58** | Traffic Light | **78** | Traffic cone |
-| **19** | Boat | **39** | Tie | **59** | Cymbal | **79** | Sink |
-> The names above preserve the dataset labels as documented in the source metadata, including existing spelling/capitalization such as `Moniter/TV` and `Bakset`.
 ---
-## 12. Minimal Usage Example
-The normal entry point is `build_dataloaders()`:
-```python
-from src.config import TrainConfig
-from train.dataloader import build_dataloaders
-cfg = TrainConfig()
-train_loader, val_loader, classes, num_classes = build_dataloaders(cfg)
-images, targets = next(iter(train_loader))
-print(images.shape)          # [B, 3, imgsz, imgsz]
-print(len(targets))          # B
-print(targets[0]["boxes"])   # [N, 4], xyxy pixels
-print(targets[0]["labels"])  # [N]
-```
-For training code that modifies epoch/resume state, access the custom sampler through:
-```python
-sampler = train_loader.batch_sampler
-sampler.epoch = epoch
-sampler.start_batch = start_batch
 ```
-The training loop is responsible for resetting or updating these values consistently across epochs and checkpoint resume.
 ---
-## 13. Source and License
-This repository is an **extended/filtered derivative of Objects365**: the original label space has been reduced and standardized to 80 target classes for the training setup documented here.
-The original Objects365 project states that its **annotations and website are licensed under CC BY 4.0**. The Objects365 Consortium does **not** own the copyright to the underlying images, and image use remains subject to the original image-source terms and the Objects365 dataset conditions. Accordingly, the `cc-by-4.0` metadata in this card refers to the annotation-derived content in this repository and must not be interpreted as relicensing third-party images.
-Original dataset: **Objects365: A Large-scale, High-quality Dataset for Object Detection**.
 ---
-## 14. Operational Notes
-- Set `cfg.rebuild_index=True` whenever the source JSONL metadata changes and cached pickle indexes may be stale.
-- Monitor the bad-sample log instead of assuming all fallback retries are harmless.
-- Large Python index structures can consume substantial RAM even though the raw JSONL data remains on disk.
-- Class oversampling changes the effective number of training samples per epoch and therefore changes the number of optimizer steps unless the training schedule compensates for it.
-- `min_visibility=0.4` in Albumentations can remove boxes after geometric augmentation.
-- Validation data is not oversampled and is not augmented by `DetectionAugmenter`.
-- Images are normalized only to `[0, 1]` in this DataLoader; no mean/std normalization is applied here.

 size_categories:
   - 1M<n<10M
 source_datasets:
+  - Objects365
 annotations_creators:
   - found
 license: cc-by-4.0
   - 80-classes
 ---
+# Objects365 80-Class Object Detection Subset
+## Dataset Description
+This dataset is a filtered **80-class subset of Objects365** prepared for large-scale object-detection pretraining and training.
+The original Objects365 dataset contains **365 object categories**, more than **600,000 training images**, and over **10 million manually annotated bounding boxes**. This derived version retains 80 target classes and reorganizes the corresponding metadata and annotations into JSON Lines (`.jsonl`) files for large-scale sequential and random-access processing.
+The dataset card focuses on the **data itself**: provenance, statistics, directory organization, schemas, class definitions, annotation representation, and licensing.
+The original Objects365 dataset should be cited whenever this derived subset is used in research.
 ---
+## Source Dataset
+This dataset is derived from:
+**Objects365: A Large-Scale, High-Quality Dataset for Object Detection**
+- Authors: Shuai Shao, Zeming Li, Tianyuan Zhang, Chao Peng, Gang Yu, Xiangyu Zhang, Jing Li, Jian Sun
+- Venue: IEEE/CVF International Conference on Computer Vision (ICCV), 2019
+- Pages: 8430–8439
+- Official project: https://www.objects365.org/
+- Paper: https://openaccess.thecvf.com/content_ICCV_2019/html/Shao_Objects365_A_Large-Scale_High-Quality_Dataset_for_Object_Detection_ICCV_2019_paper.html
+### Citation
+```bibtex
+@inproceedings{Shao_2019_ICCV,
+  author    = {Shao, Shuai and Li, Zeming and Zhang, Tianyuan and Peng, Chao and Yu, Gang and Zhang, Xiangyu and Li, Jing and Sun, Jian},
+  title     = {Objects365: A Large-Scale, High-Quality Dataset for Object Detection},
+  booktitle = {Proceedings of the IEEE/CVF International Conference on Computer Vision (ICCV)},
+  month     = {October},
+  year      = {2019},
+  pages     = {8430--8439}
+}
+```
+Please cite the original Objects365 paper rather than treating this 80-class reorganization as an independently collected image dataset.
 ---
+## Dataset Derivation
+The dataset is an **extended/filtered derivative** of Objects365.
+The transformation consists primarily of:
+1. selecting 80 target object categories from the original Objects365 label space;
+2. retaining image metadata associated with the selected categories;
+3. retaining and reorganizing corresponding bounding-box annotations;
+4. converting large metadata structures into JSONL files;
+5. creating explicit image-name-to-path mappings for locally stored image patches;
+6. optionally storing class-frequency / sampling metadata separately from the original annotations.
+No claim is made that the underlying images were created or owned by the maintainers of this derived dataset.
+---
+## Directory Structure
 ```text
 labels/
 ├── README.md
 ├── train/
+│   ├── annotations.jsonl
+│   ├── categories.jsonl
+│   ├── class_sampling.jsonl
+│   ├── images_info.jsonl
+│   └── images_train.jsonl
 └── val/
+    ├── annotations.jsonl
+    ├── categories.jsonl
+    ├── images_info.jsonl
+    └── images_val.jsonl
 ```
+### Dataset Statistics
+| Split | File | Records | Approx. size | Purpose |
 | :--- | :--- | ---: | ---: | :--- |
+| **train** | `annotations.jsonl` | 15,538,897 | 2.64 GB | Bounding boxes and annotation attributes |
+| | `categories.jsonl` | 80 | 2.4 KB | Definition of the retained object classes |
+| | `class_sampling.jsonl` | 80 | 2.5 KB | Per-class sampling metadata |
+| | `images_info.jsonl` | 1,652,206 | 177.93 MB | Image IDs, dimensions, names, licenses, and URLs |
+| | `images_train.jsonl` | 1,742,289 | 150.87 MB | Image-name to physical-path mappings |
 | **val** | `annotations.jsonl` | 442,988 | 75.53 MB | Validation bounding boxes and labels |
+| | `categories.jsonl` | 80 | 2.4 KB | Validation class definitions |
+| | `images_info.jsonl` | 67,749 | 7.30 MB | Validation image metadata |
+| | `images_val.jsonl` | 80,000 | 6.93 MB | Validation image-path mappings |
+`images_train.jsonl` may contain more physical image records than `images_info.jsonl` because not every downloaded image contains one of the retained 80 categories after filtering.
 ---
+## Data Organization
+Metadata is stored primarily in **JSON Lines (`.jsonl`)** format.
+Each non-empty line contains one independent JSON object.
+This representation is useful for very large annotation collections because individual records can be scanned, filtered, sharded, or indexed without deserializing one monolithic JSON object.
+The principal relations are:
+```text
+categories.jsonl
+      │
+      └── id
+           │
+           ▼
+annotations.jsonl
+      │
+      ├── category_id
+      └── image_id
+           │
+           ▼
+images_info.jsonl
+      │
+      └── file_name
+           │
+           ▼
+images_train.jsonl / images_val.jsonl
+```
+---
+## Data Schemas
+### `categories.jsonl`
+Defines the retained **80-class object vocabulary**.
+Fields:
 - `id` (`int`): raw category identifier.
+- `name` (`str`): category name.
+Example:
 ```json
 {"name": "Person", "id": 0}
 {"name": "Chair", "id": 1}
+{"name": "Sneakers", "id": 2}
 ```
 ---
+### `images_info.jsonl`
+Stores metadata for labeled images.
+Fields:
 - `id` (`int`): unique image identifier.
 - `file_name` (`str`): original image filename.
+- `width` (`int`): original image width.
+- `height` (`int`): original image height.
+- `license` (`int`): license identifier inherited from the source metadata.
+- `url` (`str`): source URL when available.
+Example:
 ```json
 {"height": 512, "id": 420917, "license": 5, "width": 769, "file_name": "objects365_v1_00420917.jpg", "url": ""}
 ```
+The `license` field is source metadata and should not be interpreted, by itself, as granting new rights over the underlying image.
 ---
+### `images_train.jsonl` and `images_val.jsonl`
+These files map image filenames to their relative physical storage paths.
+Fields:
+- `image_name` (`str`): image filename.
+- `path` (`str`): relative path to the image file.
+Example:
 ```json
 {"image_name": "objects365_v2_00953995.jpg", "path": "patch17/objects365_v2_00953995.jpg"}
 ```
+These path files are storage metadata for this dataset organization and are not original Objects365 annotations.
 ---
+### `annotations.jsonl`
+Stores object-detection annotations.
+Fields:
+- `id` (`int`): annotation identifier.
+- `image_id` (`int`): associated image identifier.
+- `category_id` (`int`): associated object category.
+- `bbox` (`list[float]`): COCO-style bounding box `[x_min, y_min, width, height]`.
 - `area` (`float`): bounding-box area.
 - `iscrowd` (`int`): crowd-region flag.
 - `isfake` (`int`): synthetic/drawn-object flag.
+- `isreflected` (`int`): reflection-related metadata.
+- `flag_reflected` (`int`): auxiliary reflection-related metadata.
+Example:
 ```json
 {"id": 26899493, "iscrowd": 0, "isfake": 0, "area": 3764.58, "isreflected": 0, "bbox": [20.3, 260.25, 82.69, 45.52], "image_id": 0, "category_id": 0, "flag_reflected": 0}
 ```
 ---
+### `class_sampling.jsonl`
+Contains auxiliary per-class sampling metadata for the training split.
+Fields:
+- `id` (`int`): category identifier.
+- `probability` (`int` or `float`): stored sampling percentage / repeat metadata.
+Example:
 ```json
 {"id": 0, "probability": 100}
 {"id": 78, "probability": 202}
 ```
+This file is not part of the original Objects365 annotation format; it is derived metadata associated with this 80-class subset.
 ---
+## 11. List of 80 Object Classes
+| ID | Class Name | ID | Class Name | ID | Class Name | ID | Class Name |
+| :
 ---
+## Provenance
+The data lineage is:
 ```text
+Objects365
+    │
+    ├── original images
+    ├── image metadata
+    ├── 365-category label space
+    └── bounding-box annotations
+            │
+            ▼
+      80-class selection
+            │
+            ▼
+  metadata / annotation filtering
+            │
+            ▼
+       JSONL reorganization
+            │
+            ▼
+Objects365 80-Class Object Detection Subset
 ```
+The derived dataset changes the organization and retained label space but does not alter the provenance of the original images.
 ---
+## License and Copyright
+### Objects365 annotations and website
+The official Objects365 project states that its **annotations and website are licensed under the Creative Commons Attribution 4.0 International License (CC BY 4.0)**.
+Accordingly, annotation-derived metadata in this repository should retain attribution to Objects365.
+CC BY 4.0:
+https://creativecommons.org/licenses/by/4.0/
+### Underlying images
+The **CC BY 4.0 license does not automatically apply to the underlying images**.
+The Objects365 Consortium explicitly states that it does **not own the copyright to the images**. Image use remains subject to the terms and copyright conditions of the original image sources and the Objects365 dataset conditions.
+The official Objects365 download page further states that users must accept responsibility for their use of copyrighted images and places restrictions on redistribution of those images.
+Therefore:
+- `license: cc-by-4.0` in this dataset card should be interpreted as applying to the Objects365 annotation-derived content and associated metadata where applicable;
+- it must **not** be interpreted as relicensing third-party images under CC BY 4.0;
+- redistribution of the underlying image files should be evaluated separately against the Objects365 terms and the rights of the original image owners.
+Official Objects365 license / download page:
+https://www.objects365.org/download.html
+### Derived metadata
+Files generated specifically for this reorganization, such as image-path mappings or class-selection metadata, may be distributed separately by the maintainers, but they do not change the legal status of the underlying Objects365 images or annotations.
 ---
+## Attribution
+When using this dataset, please acknowledge that it is derived from Objects365 and cite the original paper:
+> Shuai Shao, Zeming Li, Tianyuan Zhang, Chao Peng, Gang Yu, Xiangyu Zhang, Jing Li, and Jian Sun.
+> **Objects365: A Large-Scale, High-Quality Dataset for Object Detection.**
+> Proceedings of the IEEE/CVF International Conference on Computer Vision (ICCV), 2019, pp. 8430–8439.
+```bibtex
+@inproceedings{Shao_2019_ICCV,
+  author    = {Shao, Shuai and Li, Zeming and Zhang, Tianyuan and Peng, Chao and Yu, Gang and Zhang, Xiangyu and Li, Jing and Sun, Jian},
+  title     = {Objects365: A Large-Scale, High-Quality Dataset for Object Detection},
+  booktitle = {Proceedings of the IEEE/CVF International Conference on Computer Vision (ICCV)},
+  month     = {October},
+  year      = {2019},
+  pages     = {8430--8439}
+}
 ```
 ---
+## References
+1. **Shao, S., Li, Z., Zhang, T., Peng, C., Yu, G., Zhang, X., Li, J., Sun, J.**
+   *Objects365: A Large-Scale, High-Quality Dataset for Object Detection.* ICCV 2019.
+   https://openaccess.thecvf.com/content_ICCV_2019/html/Shao_Objects365_A_Large-Scale_High-Quality_Dataset_for_Object_Detection_ICCV_2019_paper.html
+2. **Objects365 Official Project**
+   https://www.objects365.org/
+3. **Objects365 Download and License Terms**
+   https://www.objects365.org/download.html
+4. **Creative Commons Attribution 4.0 International**
+   https://creativecommons.org/licenses/by/4.0/
 ---
+## Notes
+- This is a **filtered 80-class derivative**, not the complete 365-class Objects365 dataset.
+- The original Objects365 paper and project remain the authoritative sources for the parent dataset.
+- Annotation provenance should be preserved when redistributing derived label files.
+- Image copyright is distinct from annotation licensing.
+- The presence of an image in Objects365 does not imply that the image itself is licensed under CC BY 4.0.