Update README.md

README.md

@@ -1,3 +1,524 @@
 ---
-license: apache-2.0
+pretty_name: Stochastic Depth Thesis Benchmark Datasets
+license: other
+task_categories:
+- image-classification
+tags:
+- computer-vision
+- image-classification
+- benchmark
+- resnet
+- stochastic-depth
+- reproducibility
+- pytorch
+- imagefolder
+- academic
+size_categories:
+- 100K<n<1M
 ---
+
+<div align="center">
+
+# Stochastic Depth Thesis Benchmark Datasets
+
+### Five reproducibly prepared image-classification benchmarks for controlled ResNet and stochastic-depth experiments
+
+[![Hugging Face Dataset](https://img.shields.io/badge/Hugging%20Face-Dataset-FFD21E?logo=huggingface&logoColor=black)](https://huggingface.co/datasets/hermanhugging/thesis_stochastic_depth)
+[![PyTorch](https://img.shields.io/badge/PyTorch-Compatible-EE4C2C?logo=pytorch&logoColor=white)](https://pytorch.org/)
+[![Task](https://img.shields.io/badge/Task-Image%20Classification-blue)](#dataset-overview)
+[![License](https://img.shields.io/badge/License-Mixed%20%2F%20Other-lightgrey)](#licensing)
+
+**Prepared for the bachelor thesis  
+_A Study of “Stochastic Depth” for Regularizing Residual Convolutional Neural Networks_**
+
+</div>
+
+---
+
+## Dataset summary
+
+This repository contains the exact dataset variants used to compare a baseline ResNet with batch-level and sample-level stochastic-depth implementations. It is a **collection of five independent classification benchmarks**, not one merged label space.
+
+The preparation pipeline was designed for reproducibility:
+
+- all generated splits use a dedicated split seed of `42`;
+- the split seed is independent of model-training seeds;
+- unreadable files are recorded;
+- exact duplicates are detected deterministically;
+- duplicate handling is documented separately for every dataset;
+- large images are converted to a common RGB `224 × 224` representation;
+- training, validation, and test membership is recorded in machine-readable manifests;
+- the test split is kept separate from checkpoint selection.
+
+The source code used to prepare and load the datasets is available in the accompanying project repository:
+
+> **Code:** https://github.com/gerageragera39/A-Study-of-Stochastic-Depth-for-Regularizing-Residual-Convolutional-Neural-Networks/tree/feature/test
+
+## Dataset overview
+
+| Dataset ID | Benchmark | Classes | Experimental split | Stored resolution | Main preparation rule |
+|---|---:|---:|---|---:|---|
+| `cifar100` | CIFAR-100 | 100 | 45,000 train / 5,000 validation / 10,000 official test | `32 × 32` | Official test preserved; exact-image anomalies are diagnostic only |
+| `caltech256` | Caltech-256 | 256 | Stratified `70 / 15 / 15` after cleaning | `224 × 224` RGB | Clutter excluded; exact duplicates handled before splitting |
+| `google4` | Google Scraped Image Dataset | 4 | Stratified `80 / 10 / 10` after merging and cleaning | `224 × 224` RGB | Source train/test folders merged; class aliases normalized |
+| `oxford102` | Oxford Flowers-102 | 102 | Existing train/validation/test membership preserved | `224 × 224` RGB | Cross-split exact duplicates removed without random resplitting |
+| `stanford120` | Stanford Dogs | 120 | Official train split approximately `90 / 10`; official test preserved | `224 × 224` RGB | Official metadata required; test membership is not reconstructed |
+
+Exact final counts for the cleaned higher-resolution datasets are stored in each dataset's `split_summary.csv` and `split_config.json`. These generated files are the authoritative source for the published release.
+
+## Important distinction: preprocessing vs. augmentation
+
+The images stored in this repository contain only **deterministic offline preprocessing**. Random augmentation is **not baked into the files**.
+
+### Deterministic offline preprocessing
+
+For Caltech-256, Google-4, Oxford Flowers-102, and Stanford Dogs:
+
+1. verify that the image can be decoded;
+2. convert it to RGB;
+3. resize with bilinear interpolation so that the shorter side becomes 224 pixels;
+4. take a centered `224 × 224` crop;
+5. preserve already compatible RGB `224 × 224` files without unnecessary re-encoding.
+
+### Online training augmentation
+
+The training code applies the following transforms at runtime:
+
+```python
+from torchvision import transforms
+
+train_transform_224 = transforms.Compose([
+    transforms.RandomRotation(15),
+    transforms.RandomHorizontalFlip(),
+    transforms.ColorJitter(
+        brightness=0.2,
+        contrast=0.2,
+        saturation=0.2,
+        hue=0.1,
+    ),
+    transforms.ToTensor(),
+    transforms.Normalize(
+        mean=[0.485, 0.456, 0.406],
+        std=[0.229, 0.224, 0.225],
+    ),
+])
+
+eval_transform_224 = transforms.Compose([
+    transforms.ToTensor(),
+    transforms.Normalize(
+        mean=[0.485, 0.456, 0.406],
+        std=[0.229, 0.224, 0.225],
+    ),
+])
+```
+
+CIFAR-100 uses a separate `32 × 32` pipeline:
+
+```python
+from torchvision import transforms
+
+train_transform_cifar = transforms.Compose([
+    transforms.RandomCrop(32, padding=4),
+    transforms.RandomHorizontalFlip(),
+    transforms.ToTensor(),
+    transforms.Normalize(
+        mean=(0.5071, 0.4867, 0.4408),
+        std=(0.2675, 0.2565, 0.2761),
+    ),
+])
+
+eval_transform_cifar = transforms.Compose([
+    transforms.ToTensor(),
+    transforms.Normalize(
+        mean=(0.5071, 0.4867, 0.4408),
+        std=(0.2675, 0.2565, 0.2761),
+    ),
+])
+```
+
+Validation and test images receive no random augmentation.
+
+## Split and duplicate policies
+
+### CIFAR-100
+
+The official 50,000-image training set is divided deterministically into 45,000 training images and 5,000 validation images, with 450 training and 50 validation images per class. The official 10,000-image test set is preserved unchanged.
+
+Exact pixel-array duplicates and label conflicts are reported for diagnostics, but they are not used to remove, relabel, or move official CIFAR-100 samples.
+
+### Caltech-256
+
+The `257.clutter` directory is excluded, leaving 256 object categories. Unreadable files are recorded before splitting.
+
+For a same-label SHA-256 duplicate group, one deterministic representative is retained. If the same exact file hash appears under different class labels, every member of that conflicting group is excluded. The cleaned data are then divided using a class-stratified `70 / 15 / 15` split.
+
+### Google-4
+
+The labelled source folders originally named `train` and `test` are merged before creating the experimental split. Directory-name variants and misspellings are normalized to four canonical classes:
+
+- `architecture`
+- `art and culture`
+- `food`
+- `travel and adventure`
+
+Unlabelled demonstration images are excluded from quantitative evaluation. Exact duplicate handling follows the same pre-split policy as Caltech-256. The cleaned collection is divided using a class-stratified `80 / 10 / 10` split.
+
+### Oxford Flowers-102
+
+The source package's train, validation, and test membership is preserved; no random resplitting is performed.
+
+When a same-label exact duplicate occurs in more than one split, the retained split is selected according to:
+
+```text
+test > validation > training
+```
+
+Copies in lower-priority splits are excluded, and no image is moved between splits. Cross-label exact duplicates are treated as blocking conflicts requiring manual review.
+
+### Stanford Dogs
+
+The official Stanford Dogs metadata is required. The official 12,000-image training set is divided approximately `90 / 10` into training and validation subsets. The official 8,580-image test set is preserved.
+
+Exact-hash groups from the official training data are kept within one generated split. Anomalies involving official benchmark membership are reported diagnostically rather than used to silently modify the benchmark.
+
+## Reproducibility metadata
+
+Each prepared dataset is accompanied by machine-readable metadata. Depending on the dataset-specific policy, the repository may contain:
+
+| File | Purpose |
+|---|---|
+| `split_manifest.csv` | One row per retained sample, including class, split, source path, processed path, and SHA-256 hashes |
+| `split_summary.csv` | Per-class sample counts for each split |
+| `class_to_idx.json` | Deterministic mapping from class names to integer labels |
+| `split_config.json` | Split policy, seed, image-preparation settings, counts, warnings, and dataset-specific decisions |
+| `corrupt_images.json` | Source files that could not be decoded |
+| `duplicates.json` | Detected same-label exact-duplicate groups |
+| `label_conflicts.json` | Exact hashes observed under more than one label |
+| `excluded_same_label_duplicates.csv` | Same-label copies removed before splitting where applicable |
+| `excluded_cross_split_duplicates.csv` | Oxford copies removed to prevent split leakage |
+| `excluded_conflicts.csv` | Files excluded because of cross-label exact conflicts |
+| `train_indices.npy` / `val_indices.npy` | Deterministic CIFAR-100 split indices |
+
+An “exact duplicate” in the folder-based datasets means an identical SHA-256 hash of the source file. This method does not detect perceptually similar images that were recompressed, resized, cropped, rotated, or otherwise modified.
+
+## Repository layout
+
+The preparation code produces the following logical layout:
+
+```text
+data/
+├── processed/
+│   ├── cifar100/
+│   │   └── cifar-100-python/
+│   ├── caltech256/
+│   │   ├── train/<class>/*
+│   │   ├── val/<class>/*
+│   │   └── test/<class>/*
+│   ├── google4/
+│   │   ├── train/<class>/*
+│   │   ├── val/<class>/*
+│   │   └── test/<class>/*
+│   ├── oxford102/
+│   │   ├── train/<class>/*
+│   │   ├── val/<class>/*
+│   │   └── test/<class>/*
+│   └── stanford120/
+│       ├── train/<class>/*
+│       ├── val/<class>/*
+│       └── test/<class>/*
+└── splits/
+    ├── cifar100/
+    ├── caltech256/
+    ├── google4/
+    ├── oxford102/
+    └── stanford120/
+```
+
+If the Hub upload uses a flatter directory structure, the dataset identifiers and metadata filenames remain the same.
+
+## Download
+
+Install the required client:
+
+```bash
+pip install -U huggingface_hub
+```
+
+Download the complete repository:
+
+```python
+from huggingface_hub import snapshot_download
+
+local_path = snapshot_download(
+    repo_id="hermanhugging/thesis_stochastic_depth",
+    repo_type="dataset",
+)
+
+print(local_path)
+```
+
+Download only one subset and its metadata:
+
+```python
+from huggingface_hub import snapshot_download
+
+local_path = snapshot_download(
+    repo_id="hermanhugging/thesis_stochastic_depth",
+    repo_type="dataset",
+    allow_patterns=[
+        "data/processed/caltech256/**",
+        "data/splits/caltech256/**",
+        "caltech256/**",
+        "splits/caltech256/**",
+    ],
+)
+
+print(local_path)
+```
+
+## Loading the higher-resolution datasets with PyTorch
+
+The four higher-resolution datasets use an `ImageFolder`-compatible split layout.
+
+```python
+from pathlib import Path
+
+from huggingface_hub import snapshot_download
+from torchvision.datasets import ImageFolder
+
+repo_dir = Path(
+    snapshot_download(
+        repo_id="hermanhugging/thesis_stochastic_depth",
+        repo_type="dataset",
+    )
+)
+
+def find_dataset_root(repo: Path, dataset_id: str) -> Path:
+    candidates = [
+        repo / "data" / "processed" / dataset_id,
+        repo / "processed" / dataset_id,
+        repo / dataset_id,
+    ]
+    for candidate in candidates:
+        if candidate.is_dir():
+            return candidate
+    raise FileNotFoundError(
+        f"Could not locate {dataset_id!r}. Checked: "
+        + ", ".join(str(path) for path in candidates)
+    )
+
+root = find_dataset_root(repo_dir, "caltech256")
+
+train_dataset = ImageFolder(root / "train", transform=train_transform_224)
+val_dataset = ImageFolder(root / "val", transform=eval_transform_224)
+test_dataset = ImageFolder(root / "test", transform=eval_transform_224)
+
+print(len(train_dataset), len(val_dataset), len(test_dataset))
+print(train_dataset.class_to_idx)
+```
+
+Replace `caltech256` with `google4`, `oxford102`, or `stanford120`.
+
+## Loading CIFAR-100 with the prepared indices
+
+CIFAR-100 remains compatible with the official Python pickle format. The repository adds deterministic training and validation index arrays.
+
+```python
+from pathlib import Path
+
+import numpy as np
+from huggingface_hub import snapshot_download
+from torch.utils.data import Subset
+from torchvision.datasets import CIFAR100
+
+repo_dir = Path(
+    snapshot_download(
+        repo_id="hermanhugging/thesis_stochastic_depth",
+        repo_type="dataset",
+    )
+)
+
+def first_existing(*paths: Path) -> Path:
+    for path in paths:
+        if path.exists():
+            return path
+    raise FileNotFoundError(
+        "None of the expected paths exists: "
+        + ", ".join(str(path) for path in paths)
+    )
+
+cifar_root = first_existing(
+    repo_dir / "data" / "processed" / "cifar100",
+    repo_dir / "processed" / "cifar100",
+    repo_dir / "cifar100",
+)
+
+split_root = first_existing(
+    repo_dir / "data" / "splits" / "cifar100",
+    repo_dir / "splits" / "cifar100",
+)
+
+official_train_for_training = CIFAR100(
+    root=str(cifar_root),
+    train=True,
+    transform=train_transform_cifar,
+    download=False,
+)
+
+official_train_for_validation = CIFAR100(
+    root=str(cifar_root),
+    train=True,
+    transform=eval_transform_cifar,
+    download=False,
+)
+
+official_test = CIFAR100(
+    root=str(cifar_root),
+    train=False,
+    transform=eval_transform_cifar,
+    download=False,
+)
+
+train_indices = np.load(split_root / "train_indices.npy")
+val_indices = np.load(split_root / "val_indices.npy")
+
+train_dataset = Subset(official_train_for_training, train_indices)
+val_dataset = Subset(official_train_for_validation, val_indices)
+test_dataset = official_test
+
+print(len(train_dataset), len(val_dataset), len(test_dataset))
+```
+
+Separate CIFAR-100 dataset objects are intentionally used for training and validation so that validation samples do not inherit random crop or horizontal-flip transforms.
+
+## Recommended evaluation protocol
+
+For results comparable with the thesis experiments:
+
+1. use the published training split for optimization;
+2. use validation accuracy for checkpoint selection;
+3. do not tune hyperparameters on the test split;
+4. load the checkpoint with the best validation top-1 accuracy;
+5. evaluate the test split only after model selection;
+6. report the training seed, architecture, batch size, optimizer configuration, and stochastic-depth variant.
+
+## Intended uses
+
+This collection is intended for:
+
+- academic image-classification experiments;
+- reproducibility studies;
+- controlled comparisons of ResNet regularization methods;
+- investigation of batch-level and sample-level stochastic depth;
+- teaching and demonstration of deterministic dataset preparation;
+- benchmarking under fixed train/validation/test membership.
+
+## Out-of-scope uses
+
+This repository is not designed or validated for:
+
+- biometric identification or surveillance;
+- safety-critical or high-stakes decision making;
+- claims about human populations or demographic groups;
+- commercial deployment without an independent rights review;
+- treating accuracy across different datasets as directly comparable without accounting for differences in class count, difficulty, and source distribution.
+
+## Limitations and known risks
+
+- SHA-256 detects byte-identical files, not perceptual near-duplicates.
+- Central cropping can remove content near the edge of an original image.
+- The higher-resolution datasets have different collection processes and class distributions.
+- Web-sourced datasets may contain unknown provenance, copyright restrictions, trademarks, artworks, or identifiable people.
+- The Google-4 collection may reflect search-engine and web-publication biases.
+- Caltech-256, Oxford Flowers-102, and Stanford Dogs contain class imbalance or fine-grained visual similarity that can affect metric interpretation.
+- CIFAR-100 retains the official benchmark even when exact-image anomalies are detected.
+- The collection was prepared for a specific thesis protocol and should not be interpreted as a universally optimal preprocessing scheme.
+
+## Licensing
+
+**Hugging Face metadata for this repository is intentionally set to `license: other`.**
+
+This repository combines several third-party datasets with different or insufficiently explicit licensing information. A single permissive license such as MIT, Apache-2.0, CC0, or CC BY must not be presented as covering all image files.
+
+The original images and source labels remain subject to the terms, restrictions, and rights of their respective sources and copyright holders. The repository's curation does not create new rights over third-party images.
+
+See [`LICENSE.md`](./LICENSE.md) for the repository-wide licensing notice and dataset-specific source information.
+
+For the most conservative distribution model, publish the split manifests, indices, preparation code, and checksums while requiring users to obtain the original image data from the official or cited sources. If image files are redistributed, the uploader is responsible for confirming that redistribution is permitted.
+
+## Source datasets
+
+| Dataset | Primary or used source |
+|---|---|
+| CIFAR-100 | https://www.cs.toronto.edu/~kriz/cifar.html |
+| Caltech-256 | https://data.caltech.edu/records/nyy15-4j048 |
+| Google Scraped Image Dataset | https://www.kaggle.com/datasets/duttadebadri/image-classification |
+| Oxford Flowers-102 | https://www.robots.ox.ac.uk/~vgg/data/flowers/102/ |
+| Oxford package used in the experiments | https://www.kaggle.com/datasets/nunenuh/pytorch-challange-flower-dataset |
+| Stanford Dogs | http://vision.stanford.edu/aditya86/ImageNetDogs/ |
+| Stanford Dogs package used in the experiments | https://www.kaggle.com/datasets/jessicali9530/stanford-dogs-dataset |
+
+## Citation
+
+When using this prepared collection, please cite both the thesis and the original dataset relevant to your experiment.
+
+### Thesis
+
+```bibtex
+@thesis{dihtenko2026stochasticdepth,
+  author  = {Herman Dihtenko},
+  title   = {A Study of ``Stochastic Depth'' for Regularizing Residual Convolutional Neural Networks},
+  school  = {Catholic University of Eichstätt-Ingolstadt},
+  type    = {Bachelor's thesis},
+  year    = {2026}
+}
+```
+
+### CIFAR-100
+
+```bibtex
+@techreport{krizhevsky2009learning,
+  author = {Alex Krizhevsky},
+  title  = {Learning Multiple Layers of Features from Tiny Images},
+  year   = {2009}
+}
+```
+
+### Caltech-256
+
+```bibtex
+@techreport{griffin2007caltech,
+  author      = {Gregory Griffin and Alex Holub and Pietro Perona},
+  title       = {Caltech-256 Object Category Dataset},
+  institution = {California Institute of Technology},
+  year        = {2007}
+}
+```
+
+### Oxford Flowers-102
+
+```bibtex
+@inproceedings{nilsback2008automated,
+  author    = {Maria-Elena Nilsback and Andrew Zisserman},
+  title     = {Automated Flower Classification over a Large Number of Classes},
+  booktitle = {Proceedings of the Indian Conference on Computer Vision, Graphics and Image Processing},
+  year      = {2008}
+}
+```
+
+### Stanford Dogs
+
+```bibtex
+@inproceedings{khosla2011novel,
+  author    = {Aditya Khosla and Nityananda Jayadevaprakash and Bangpeng Yao and Li Fei-Fei},
+  title     = {Novel Dataset for Fine-Grained Image Categorization: Stanford Dogs},
+  booktitle = {CVPR Workshop on Fine-Grained Visual Categorization},
+  year      = {2011}
+}
+```
+
+## Maintainer
+
+**Herman Dihtenko**
+
+For questions about split generation, preprocessing, or the thesis experiments, please use the issue tracker in the accompanying GitHub repository.