Upload folder using huggingface_hub

.gitattributes

@@ -33,3 +33,123 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+validation/images/dark/dark_01.png filter=lfs diff=lfs merge=lfs -text
+validation/images/dark/dark_02.png filter=lfs diff=lfs merge=lfs -text
+validation/images/dark/dark_03.png filter=lfs diff=lfs merge=lfs -text
+validation/images/dark/dark_04.png filter=lfs diff=lfs merge=lfs -text
+validation/images/dark/dark_05.png filter=lfs diff=lfs merge=lfs -text
+validation/images/dark/dark_06.png filter=lfs diff=lfs merge=lfs -text
+validation/images/dark/dark_07.png filter=lfs diff=lfs merge=lfs -text
+validation/images/dark/dark_08.png filter=lfs diff=lfs merge=lfs -text
+validation/images/dark/dark_09.png filter=lfs diff=lfs merge=lfs -text
+validation/images/dark/dark_10.png filter=lfs diff=lfs merge=lfs -text
+validation/images/dark/dark_11.png filter=lfs diff=lfs merge=lfs -text
+validation/images/dark/dark_12.png filter=lfs diff=lfs merge=lfs -text
+validation/images/dark/dark_13.png filter=lfs diff=lfs merge=lfs -text
+validation/images/dark/dark_14.png filter=lfs diff=lfs merge=lfs -text
+validation/images/dark/dark_15.png filter=lfs diff=lfs merge=lfs -text
+validation/images/dark/dark_16.png filter=lfs diff=lfs merge=lfs -text
+validation/images/dark/dark_17.png filter=lfs diff=lfs merge=lfs -text
+validation/images/dark/dark_18.png filter=lfs diff=lfs merge=lfs -text
+validation/images/dark/dark_19.png filter=lfs diff=lfs merge=lfs -text
+validation/images/dark/dark_20.png filter=lfs diff=lfs merge=lfs -text
+validation/images/flat/flat_01.png filter=lfs diff=lfs merge=lfs -text
+validation/images/flat/flat_02.png filter=lfs diff=lfs merge=lfs -text
+validation/images/flat/flat_03.png filter=lfs diff=lfs merge=lfs -text
+validation/images/flat/flat_04.png filter=lfs diff=lfs merge=lfs -text
+validation/images/flat/flat_05.png filter=lfs diff=lfs merge=lfs -text
+validation/images/flat/flat_06.png filter=lfs diff=lfs merge=lfs -text
+validation/images/flat/flat_07.png filter=lfs diff=lfs merge=lfs -text
+validation/images/flat/flat_08.png filter=lfs diff=lfs merge=lfs -text
+validation/images/flat/flat_09.png filter=lfs diff=lfs merge=lfs -text
+validation/images/flat/flat_10.png filter=lfs diff=lfs merge=lfs -text
+validation/images/flat/flat_11.png filter=lfs diff=lfs merge=lfs -text
+validation/images/flat/flat_12.png filter=lfs diff=lfs merge=lfs -text
+validation/images/flat/flat_13.png filter=lfs diff=lfs merge=lfs -text
+validation/images/flat/flat_14.png filter=lfs diff=lfs merge=lfs -text
+validation/images/flat/flat_15.png filter=lfs diff=lfs merge=lfs -text
+validation/images/flat/flat_16.png filter=lfs diff=lfs merge=lfs -text
+validation/images/flat/flat_17.png filter=lfs diff=lfs merge=lfs -text
+validation/images/flat/flat_18.png filter=lfs diff=lfs merge=lfs -text
+validation/images/flat/flat_19.png filter=lfs diff=lfs merge=lfs -text
+validation/images/flat/flat_20.png filter=lfs diff=lfs merge=lfs -text
+validation/images/modern/modern_01.png filter=lfs diff=lfs merge=lfs -text
+validation/images/modern/modern_02.png filter=lfs diff=lfs merge=lfs -text
+validation/images/modern/modern_03.png filter=lfs diff=lfs merge=lfs -text
+validation/images/modern/modern_04.png filter=lfs diff=lfs merge=lfs -text
+validation/images/modern/modern_05.png filter=lfs diff=lfs merge=lfs -text
+validation/images/modern/modern_06.png filter=lfs diff=lfs merge=lfs -text
+validation/images/modern/modern_07.png filter=lfs diff=lfs merge=lfs -text
+validation/images/modern/modern_08.png filter=lfs diff=lfs merge=lfs -text
+validation/images/modern/modern_09.png filter=lfs diff=lfs merge=lfs -text
+validation/images/modern/modern_10.png filter=lfs diff=lfs merge=lfs -text
+validation/images/modern/modern_11.png filter=lfs diff=lfs merge=lfs -text
+validation/images/modern/modern_12.png filter=lfs diff=lfs merge=lfs -text
+validation/images/modern/modern_13.png filter=lfs diff=lfs merge=lfs -text
+validation/images/modern/modern_14.png filter=lfs diff=lfs merge=lfs -text
+validation/images/modern/modern_15.png filter=lfs diff=lfs merge=lfs -text
+validation/images/modern/modern_16.png filter=lfs diff=lfs merge=lfs -text
+validation/images/modern/modern_17.png filter=lfs diff=lfs merge=lfs -text
+validation/images/modern/modern_18.png filter=lfs diff=lfs merge=lfs -text
+validation/images/modern/modern_19.png filter=lfs diff=lfs merge=lfs -text
+validation/images/modern/modern_20.png filter=lfs diff=lfs merge=lfs -text
+validation/images/moe/moe_01.png filter=lfs diff=lfs merge=lfs -text
+validation/images/moe/moe_02.png filter=lfs diff=lfs merge=lfs -text
+validation/images/moe/moe_03.png filter=lfs diff=lfs merge=lfs -text
+validation/images/moe/moe_04.png filter=lfs diff=lfs merge=lfs -text
+validation/images/moe/moe_05.png filter=lfs diff=lfs merge=lfs -text
+validation/images/moe/moe_06.png filter=lfs diff=lfs merge=lfs -text
+validation/images/moe/moe_07.png filter=lfs diff=lfs merge=lfs -text
+validation/images/moe/moe_08.png filter=lfs diff=lfs merge=lfs -text
+validation/images/moe/moe_09.png filter=lfs diff=lfs merge=lfs -text
+validation/images/moe/moe_10.png filter=lfs diff=lfs merge=lfs -text
+validation/images/moe/moe_11.png filter=lfs diff=lfs merge=lfs -text
+validation/images/moe/moe_12.png filter=lfs diff=lfs merge=lfs -text
+validation/images/moe/moe_13.png filter=lfs diff=lfs merge=lfs -text
+validation/images/moe/moe_14.png filter=lfs diff=lfs merge=lfs -text
+validation/images/moe/moe_15.png filter=lfs diff=lfs merge=lfs -text
+validation/images/moe/moe_16.png filter=lfs diff=lfs merge=lfs -text
+validation/images/moe/moe_17.png filter=lfs diff=lfs merge=lfs -text
+validation/images/moe/moe_18.png filter=lfs diff=lfs merge=lfs -text
+validation/images/moe/moe_19.png filter=lfs diff=lfs merge=lfs -text
+validation/images/moe/moe_20.png filter=lfs diff=lfs merge=lfs -text
+validation/images/painterly/painterly_01.png filter=lfs diff=lfs merge=lfs -text
+validation/images/painterly/painterly_02.png filter=lfs diff=lfs merge=lfs -text
+validation/images/painterly/painterly_03.png filter=lfs diff=lfs merge=lfs -text
+validation/images/painterly/painterly_04.png filter=lfs diff=lfs merge=lfs -text
+validation/images/painterly/painterly_05.png filter=lfs diff=lfs merge=lfs -text
+validation/images/painterly/painterly_06.png filter=lfs diff=lfs merge=lfs -text
+validation/images/painterly/painterly_07.png filter=lfs diff=lfs merge=lfs -text
+validation/images/painterly/painterly_08.png filter=lfs diff=lfs merge=lfs -text
+validation/images/painterly/painterly_09.png filter=lfs diff=lfs merge=lfs -text
+validation/images/painterly/painterly_10.png filter=lfs diff=lfs merge=lfs -text
+validation/images/painterly/painterly_11.png filter=lfs diff=lfs merge=lfs -text
+validation/images/painterly/painterly_12.png filter=lfs diff=lfs merge=lfs -text
+validation/images/painterly/painterly_13.png filter=lfs diff=lfs merge=lfs -text
+validation/images/painterly/painterly_14.png filter=lfs diff=lfs merge=lfs -text
+validation/images/painterly/painterly_15.png filter=lfs diff=lfs merge=lfs -text
+validation/images/painterly/painterly_16.png filter=lfs diff=lfs merge=lfs -text
+validation/images/painterly/painterly_17.png filter=lfs diff=lfs merge=lfs -text
+validation/images/painterly/painterly_18.png filter=lfs diff=lfs merge=lfs -text
+validation/images/painterly/painterly_19.png filter=lfs diff=lfs merge=lfs -text
+validation/images/painterly/painterly_20.png filter=lfs diff=lfs merge=lfs -text
+validation/images/retro/retro_01.png filter=lfs diff=lfs merge=lfs -text
+validation/images/retro/retro_02.png filter=lfs diff=lfs merge=lfs -text
+validation/images/retro/retro_03.png filter=lfs diff=lfs merge=lfs -text
+validation/images/retro/retro_04.png filter=lfs diff=lfs merge=lfs -text
+validation/images/retro/retro_05.png filter=lfs diff=lfs merge=lfs -text
+validation/images/retro/retro_06.png filter=lfs diff=lfs merge=lfs -text
+validation/images/retro/retro_07.png filter=lfs diff=lfs merge=lfs -text
+validation/images/retro/retro_08.png filter=lfs diff=lfs merge=lfs -text
+validation/images/retro/retro_09.png filter=lfs diff=lfs merge=lfs -text
+validation/images/retro/retro_10.png filter=lfs diff=lfs merge=lfs -text
+validation/images/retro/retro_11.png filter=lfs diff=lfs merge=lfs -text
+validation/images/retro/retro_12.png filter=lfs diff=lfs merge=lfs -text
+validation/images/retro/retro_13.png filter=lfs diff=lfs merge=lfs -text
+validation/images/retro/retro_14.png filter=lfs diff=lfs merge=lfs -text
+validation/images/retro/retro_15.png filter=lfs diff=lfs merge=lfs -text
+validation/images/retro/retro_16.png filter=lfs diff=lfs merge=lfs -text
+validation/images/retro/retro_17.png filter=lfs diff=lfs merge=lfs -text
+validation/images/retro/retro_18.png filter=lfs diff=lfs merge=lfs -text
+validation/images/retro/retro_19.png filter=lfs diff=lfs merge=lfs -text
+validation/images/retro/retro_20.png filter=lfs diff=lfs merge=lfs -text

README.md

@@ -0,0 +1,276 @@
+# Anime Style Classifier - EfficientNet-B0
+
+A fine-tuned EfficientNet-B0 model for classifying anime/visual novel images into 6 distinct art styles.
+
+## Model Description
+
+- **Model Architecture**: EfficientNet-B0 (~5.3M parameters)
+- **Base Model**: ImageNet pretrained weights
+- **Task**: Multi-class image classification (6 styles)
+- **Input Resolution**: 224x224 RGB
+- **Framework**: PyTorch
+- **License**: MIT
+
+## Performance
+
+### Test Set Results (Holdout)
+
+- **Accuracy**: 100.0%
+- **Macro F1-Score**: 1.000
+- **Validation Accuracy**: 98.18%
+
+Perfect classification across all 120 holdout images (20 per class). Note: with n=120 the 95% Wilson confidence interval for this result is approximately 96.90%—100.00%, so the perfect score should be interpreted cautiously alongside validation metrics. Taking both validation and holdout into account, a realistic estimate of the model's true accuracy is likely in the mid-to-high 90s (≈96–98%) — still very strong and, for most applications, likely fit for purpose.
+
+### Per-Class Performance
+
+| Style | Precision | Recall | F1-Score | Support |
+|-------|-----------|--------|----------|---------|
+| **dark** | 1.000 | 1.000 | 1.000 | 20 |
+| **flat** | 1.000 | 1.000 | 1.000 | 20 |
+| **modern** | 1.000 | 1.000 | 1.000 | 20 |
+| **moe** | 1.000 | 1.000 | 1.000 | 20 |
+| **painterly** | 1.000 | 1.000 | 1.000 | 20 |
+| **retro** | 1.000 | 1.000 | 1.000 | 20 |
+
+## Style Definitions
+
+1. **dark**: Low-key lighting, chiaroscuro, desaturated palette, high contrast shadows, moody atmosphere
+2. **flat**: Minimalist flat colors, vector illustration, solid color blocks, no gradients or shading
+3. **modern**: Clean digital rendering, smooth gradients, glossy finish, contemporary anime aesthetic
+4. **moe**: Soft pastel colors, rounded features, cute/adorable character focus, gentle shading
+5. **painterly**: Watercolor or gouache appearance, visible brush strokes, paper texture, artistic feel
+6. **retro**: 80s/90s anime aesthetic, vintage color palette, classic cel animation style
+
+## Training Details
+
+### Dataset
+
+- **Training Images**: 933 (scene-level split)
+- **Validation Images**: 165
+- **Holdout Images**: 120
+- **Total Scenes**: 203 perfectly balanced scenes
+- **Images per Style**: 183 training + 20 holdout = 203 each
+- **Source Resolution**: 1920x1088
+- **Training Resolution**: 224x224
+
+**Data Split Strategy**: Scene-level 90/10 split to prevent data leakage. All 6 style variants of each scene are kept together in either training or holdout set.
+
+**Data Generation**: Synthetic images generated via ComfyUI with Flux diffusion model, validated by Gemma-12B vision-language model. Only scenes with 6/6 style agreement (all variants correctly classified) were included.
+
+### Training Regime
+
+```yaml
+Architecture: EfficientNet-B0
+Pretrained: ImageNet weights
+Optimizer: AdamW
+Learning Rate: 0.001
+Weight Decay: 1e-05
+Batch Size: 16
+Epochs: 30 (early stopping at ~12-15 epochs typical)
+Scheduler: CosineAnnealingLR
+Loss: CrossEntropyLoss
+Early Stopping: 10 epochs patience (val accuracy)
+```
+
+### Data Augmentation (Training Only)
+
+- Resize to 256x256
+- Random crop to 224x224
+- Random horizontal flip (p=0.5)
+- Color jitter (brightness=0.1, saturation=0.1, hue=0.05)
+- ImageNet normalization (mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
+
+### Hardware
+
+- GPU: NVIDIA GPU (CUDA)
+- Training Time: ~15 minutes (with early stopping)
+
+## Usage
+
+### Installation
+
+```bash
+pip install torch torchvision pillow
+```
+
+### Inference
+
+This repository includes a small CLI inference script, `inference.py`, which auto-detects `.safetensors` (preferred) or a PyTorch `.pth` checkpoint and provides a convenient command-line interface for classification. Because `inference.py` already contains the full, tested loading and preprocessing logic, the README keeps only the minimal usage notes below and a short programmatic example that delegates to the script's functions.
+
+Install (optional: include safetensors for safer loading):
+
+```bash
+pip install torch torchvision pillow safetensors
+```
+
+CLI usage (example):
+
+```bash
+python inference.py --model model.safetensors --config config.json examples/retro_1.png
+```
+
+This will print a ranked list of predictions and a top prediction summary (see the script output example above).
+
+Programmatic usage (calls the same functions used by the CLI):
+
+```python
+# Minimal programmatic example using functions from inference.py
+from inference import load_model, classify_image
+
+model, config = load_model('model.safetensors', 'config.json')
+results = classify_image(model, config, 'examples/retro_1.png')
+print(results[:3])  # top-3 predictions as (style, confidence)
+```
+
+For the full implementation and additional options (e.g., --top-k), see `inference.py` in the repository.
+
+## Publishing the validation set
+
+If you'd like to publish the 120 AI-generated validation images for transparency, you can place the images into `validation/images/` and provide an annotations JSON (`validation/annotations.json`) that maps filenames to styles and source scene ids. A small helper script is included to build a simple HTML index (SCENE | STYLE) with thumbnails:
+
+```bash
+python validation/generate_index.py --annotations validation/annotations.json --out validation/validation_grid.md --images-dir validation/images
+```
+
+The script writes `validation/validation_index.html`. It does not copy image files — place your images in `validation/images/` using the same filenames referenced in `validation/annotations.json`.
+
+Canonical folder layout (now `validation/`)
+
+To avoid confusion between different folds, this repository now uses a canonical `validation/` folder to store the full published validation/holdout set (images + index). The previous `examples/` demo files have been removed to avoid duplication. Use the files under `validation/` as the canonical published dataset.
+
+Consolidation summary performed here:
+
+1. Images were moved to `validation/images/` (canonical image storage).
+2. Annotations and the generated markdown index are now under `validation/annotations.json` and `validation/validation_index.md`.
+
+How to show examples in the README (recommended)
+
+If you want to show example commands in the README that run against the full published directory, use the `validation/images/` path. For example:
+
+```bash
+# Classify one of the published validation images
+python inference.py --model model.safetensors --config config.json validation/images/retro_10.png
+```
+
+Or programmatically:
+
+```python
+from inference import load_model, classify_image
+
+model, config = load_model('model.safetensors', 'config.json')
+results = classify_image(model, config, 'validation/images/retro_10.png')
+print(results[0])
+```
+
+## Limitations
+
+- **Input Resolution**: Model processes images at 224x224, which may lose fine texture details from high-resolution sources (1920x1088+)
+- **Domain**: Trained on synthetically generated anime/visual novel images. May not generalize perfectly to all anime art styles, manga, or hand-drawn artwork
+- **Style Ambiguity**: Some real-world images may blend multiple styles (e.g., painterly with modern digital techniques)
+-- **Validation Bias**: Ground truth labels come from Gemma-12B vision model, so classifier may inherit some of its biases
+
+Small-sample caution: The internal validation set achieved 98.18% (162/165). The 95% Wilson confidence interval for this is approximately 94.79%—99.38%. Because the holdout set is relatively small (20 images per class, 120 total), perfect classification on that set is possible by chance and should be reported with its confidence interval (see above).
+
+Decision rule note: The model uses the standard softmax + argmax decision rule by default (choose the class with highest predicted probability). No abstain threshold is applied in the shipped `inference.py`; if you later want an abstain/human-review mode, adding a `--min-conf` option is straightforward.
+
+## Model Selection
+
+This model was selected from a hyperparameter sweep of 144+ configurations across 6 architectures:
+- ResNet-18
+- MobileNetV3-Large
+- MobileNetV3-Small
+- EfficientNet-B0 ⭐ (winner)
+- EfficientNetV2-S
+- ViT-B/16
+
+EfficientNet-B0 achieved perfect 100% holdout accuracy with:
+- Excellent efficiency (~5.3M parameters)
+- Fast inference
+- Strong generalization (98.18% val → 100% holdout)
+
+## Citation
+
+```bibtex
+@software{anime_style_classifier_2025,
+  author = {Your Name},
+  title = {Anime Style Classifier},
+  year = {2025},
+  url = {https://huggingface.co/Mitchins/anime-style-classifier-efficientnet-b0}
+}
+```
+
+## Publishing to Hugging Face
+
+If you'd like to publish this model under the name `Mitchins/anime-style-classifier-efficientnet-b0` on Hugging Face, here's a compact guide.
+
+Recommended files to include in the model repo:
+- `model.safetensors` (weights)
+- `config.json` (model metadata)
+- `inference.py` (inference CLI/helpers)
+- `validation/validation_grid.md` and `validation/validation_index.md` (visual index)
+- `README.md` (this file / model card)
+- `LICENSE` (MIT is used in this repo)
+
+Commands (zsh) to create the repo and push files using the Hugging Face CLI and git-lfs:
+
+```bash
+# install HF CLI and git-lfs if missing
+pip install huggingface_hub
+brew install git-lfs || true
+git lfs install
+
+# create the HF model repo (run once)
+huggingface-cli repo create Mitchins/anime-style-classifier-efficientnet-b0 --type model
+
+# Initialize a git repo (or use your existing one)
+git init
+git remote add origin https://huggingface.co/Mitchins/anime-style-classifier-efficientnet-b0
+
+# Track safetensors with LFS
+git lfs track "*.safetensors"
+
+# Add files, commit and push
+git add .gitattributes model.safetensors config.json inference.py README.md validation/
+git commit -m "Add model weights, inference script and validation index"
+git branch -M main
+git push origin main
+```
+
+Model card snippet (place in the repo README or on the HF model card):
+
+```markdown
+## Mitchins/anime-style-classifier-efficientnet-b0
+
+EfficientNet-B0 fine-tuned to classify anime/visual-novel images into 6 styles: dark, flat, modern, moe, painterly, retro.
+
+- Architecture: EfficientNet-B0
+- Framework: PyTorch
+- Weights: `model.safetensors`
+- Input resolution: 224x224
+- License: MIT
+
+### How to use
+
+See `inference.py` for a CLI and programmatic interface to run inference locally.
+
+### Validation set
+
+A visual index of the published validation/holdout images is included in `validation/validation_grid.md` for transparency.
+
+### Tags
+
+`image-classification`, `anime`, `art-style`, `efficientnet-b0`, `pytorch`, `safetensors`, `multi-class`
+```
+
+If you want, I can prepare the git commands and a short final checklist and run them locally (I won't push without your confirmation). I can also prepare a small HF-friendly model card file and a suggested README title/description.
+
+## Acknowledgments
+
+- **Base Model**: EfficientNet-B0 from torchvision (ImageNet pretrained)
+- **Synthetic Data Generation**: ComfyUI + Flux diffusion model
+- **Data Validation**: Gemma-12B vision-language model
+- **Framework**: PyTorch, torchvision
+
+## Contact
+
+For questions or feedback, please open an issue on the GitHub repository.

config.json

@@ -0,0 +1,40 @@
+{
+  "architectures": [
+    "EfficientNet"
+  ],
+  "model_type": "efficientnet_b0",
+  "num_classes": 6,
+  "id2label": {
+    "0": "dark",
+    "1": "flat",
+    "2": "modern",
+    "3": "moe",
+    "4": "painterly",
+    "5": "retro"
+  },
+  "label2id": {
+    "dark": 0,
+    "flat": 1,
+    "modern": 2,
+    "moe": 3,
+    "painterly": 4,
+    "retro": 5
+  },
+  "image_size": 224,
+  "pretrained_backbone": "imagenet",
+  "framework": "pytorch",
+  "performance": {
+    "holdout_accuracy": 100.0,
+    "holdout_f1": 1.0,
+    "val_accuracy": 98.18181818181819,
+    "best_val_acc": 98.18181818181819
+  },
+  "training": {
+    "batch_size": 16,
+    "epochs": 30,
+    "lr": 0.001,
+    "weight_decay": 1e-05,
+    "pretrained": true,
+    "best_epoch": 11
+  }
+}

inference.py

@@ -0,0 +1,122 @@
+#!/usr/bin/env python3
+"""
+Simple inference script for anime style classification.
+"""
+
+import torch
+from torchvision import models, transforms
+from PIL import Image
+import json
+from pathlib import Path
+
+
+def load_model(model_path=None, config_path='config.json'):
+    """Load the trained model.
+
+    Args:
+        model_path: Path to model weights. If None, auto-detects (.safetensors preferred)
+        config_path: Path to config file
+    """
+    # Load config
+    with open(config_path, 'r') as f:
+        config = json.load(f)
+
+    # Create model
+    model = models.efficientnet_b0(pretrained=False)
+    num_classes = config['num_classes']
+    model.classifier[-1] = torch.nn.Linear(model.classifier[-1].in_features, num_classes)
+
+    # Auto-detect model format if not specified
+    if model_path is None:
+        if Path('model.safetensors').exists():
+            model_path = 'model.safetensors'
+        elif Path('pytorch_model.pth').exists():
+            model_path = 'pytorch_model.pth'
+        else:
+            raise FileNotFoundError("No model weights found (model.safetensors or pytorch_model.pth)")
+
+    # Load weights based on format
+    if model_path.endswith('.safetensors'):
+        from safetensors.torch import load_file
+        state_dict = load_file(model_path)
+        model.load_state_dict(state_dict)
+    else:
+        checkpoint = torch.load(model_path, map_location='cpu')
+        model.load_state_dict(checkpoint['model_state_dict'])
+
+    model.eval()
+    return model, config
+
+
+def preprocess_image(image_path, img_size=224):
+    """Preprocess image for model input."""
+    transform = transforms.Compose([
+        transforms.Resize((img_size, img_size)),
+        transforms.ToTensor(),
+        transforms.Normalize(mean=[0.485, 0.456, 0.406],
+                           std=[0.229, 0.224, 0.225])
+    ])
+
+    image = Image.open(image_path).convert('RGB')
+    return transform(image).unsqueeze(0)
+
+
+def classify_image(model, config, image_path):
+    """Classify a single image."""
+    # Preprocess
+    input_tensor = preprocess_image(image_path)
+
+    # Inference
+    with torch.no_grad():
+        output = model(input_tensor)
+        probabilities = torch.nn.functional.softmax(output[0], dim=0)
+
+    # Get predictions
+    results = []
+    for idx, prob in enumerate(probabilities):
+        style = config['id2label'][str(idx)]
+        results.append({
+            'style': style,
+            'confidence': float(prob)
+        })
+
+    # Sort by confidence
+    results.sort(key=lambda x: x['confidence'], reverse=True)
+
+    return results
+
+
+def main():
+    import argparse
+
+    parser = argparse.ArgumentParser(description='Classify anime style')
+    parser.add_argument('image', type=str, help='Path to image')
+    parser.add_argument('--model', type=str, default=None,
+                       help='Path to model weights (auto-detects .safetensors or .pth if not specified)')
+    parser.add_argument('--config', type=str, default='config.json')
+    parser.add_argument('--top-k', type=int, default=3, help='Show top-K predictions')
+
+    args = parser.parse_args()
+
+    # Load model
+    print(f"Loading model from {args.model}...")
+    model, config = load_model(args.model, args.config)
+
+    # Classify
+    print(f"Classifying {args.image}...")
+    results = classify_image(model, config, args.image)
+
+    # Display results
+    print()
+    print("=" * 60)
+    print("PREDICTIONS")
+    print("=" * 60)
+    for i, result in enumerate(results[:args.top_k], 1):
+        print(f"{i}. {result['style']:12s} {result['confidence']:>7.2%}")
+    print("=" * 60)
+    print()
+    print(f"Top prediction: {results[0]['style']} ({results[0]['confidence']:.2%})")
+
+
+if __name__ == '__main__':
+    main()

model.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:fa35588f3171f47ea118f0b685a355b35109cd667ec3382590866f89a159016b
+size 16264280

requirements.txt

@@ -0,0 +1,4 @@
+torch>=2.0.0
+torchvision>=0.15.0
+pillow>=9.0.0
+safetensors>=0.4.0

tools/eval_ci.py

@@ -0,0 +1,60 @@
+#!/usr/bin/env python3
+"""Compute simple confidence intervals for binary accuracy results.
+
+Usage:
+    python tools/eval_ci.py --correct 120 --n 120
+    python tools/eval_ci.py --correct 162 --n 165
+
+Outputs Wilson score interval and normal approx CI.
+"""
+import math
+import argparse
+
+
+def wilson_ci(k, n, alpha=0.05):
+    if n == 0:
+        return (0.0, 1.0)
+    z = 1.96  # for 95%
+    phat = k / n
+    denom = 1 + z*z/n
+    centre = phat + z*z/(2*n)
+    margin = z * math.sqrt((phat*(1-phat) + z*z/(4*n)) / n)
+    lower = (centre - margin) / denom
+    upper = (centre + margin) / denom
+    return max(0.0, lower), min(1.0, upper)
+
+
+def normal_approx(k, n, alpha=0.05):
+    if n == 0:
+        return (0.0, 1.0)
+    z = 1.96
+    phat = k/n
+    se = math.sqrt(phat*(1-phat)/n)
+    lower = phat - z*se
+    upper = phat + z*se
+    return max(0.0, lower), min(1.0, upper)
+
+
+def percent(x):
+    return f"{x*100:.2f}%"
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--correct', type=int, required=True)
+    parser.add_argument('--n', type=int, required=True)
+    args = parser.parse_args()
+
+    k = args.correct
+    n = args.n
+    phat = k/n if n>0 else 0.0
+    wlo, whi = wilson_ci(k,n)
+    nlo, nhi = normal_approx(k,n)
+
+    print(f"Results: {k}/{n} = {percent(phat)}")
+    print(f"Wilson 95% CI: {percent(wlo)} — {percent(whi)}")
+    print(f"Normal approx 95% CI: {percent(nlo)} — {percent(nhi)}")
+
+
+if __name__ == '__main__':
+    main()

validation/annotations.json

@@ -0,0 +1,14 @@
+[
+  {"style": "dark", "filename": "dark_11.png", "source": "scene39_riverbank_spring_cycling_dark_00001_.png"},
+  {"style": "dark", "filename": "dark_15.png", "source": "scene57_sky_garden_walkway_dark_00001_.png"},
+  {"style": "flat", "filename": "flat_10.png", "source": "scene31_campus_courtyard_rain_flat_00001_.png"},
+  {"style": "flat", "filename": "flat_19.png", "source": "scene99_town_square_clock_rain_flat_00001_.png"},
+  {"style": "modern", "filename": "modern_20.png", "source": "scene99_town_square_clock_rain_modern_00001_.png"},
+  {"style": "modern", "filename": "modern_16.png", "source": "scene72_spirit_shrine_waterfall_modern_00001_.png"},
+  {"style": "moe", "filename": "moe_07.png", "source": "scene241_meteor_defense_bunker_moe_00001_.png"},
+  {"style": "moe", "filename": "moe_04.png", "source": "scene16_rain_on_train_crossing_moe_00001_.png"},
+  {"style": "painterly", "filename": "painterly_07.png", "source": "scene257_holo_library_steps_painterly_00001_.png"},
+  {"style": "painterly", "filename": "painterly_08.png", "source": "scene31_campus_courtyard_rain_painterly_00001_.png"},
+  {"style": "retro", "filename": "retro_10.png", "source": "scene31_campus_courtyard_rain_retro_00001_.png"},
+  {"style": "retro", "filename": "retro_02.png", "source": "scene133_fey_crossing_footbridge_retro_00001_.png"}
+]

validation/generate_index.py

@@ -0,0 +1,72 @@
+#!/usr/bin/env python3
+"""Generate a compact grid (Markdown) of validation images arranged by scene and style.
+
+This script is the canonical generator for the validation preview and lives under `validation/`.
+"""
+import json
+from pathlib import Path
+import argparse
+
+STYLES = ['modern', 'painterly', 'retro', 'moe', 'flat', 'dark']
+
+MD_HEADER = """
+# Validation set — visual grid
+
+A compact birds-eye preview. Columns: modern | painterly | retro | moe | flat | dark
+
+"""
+
+CELL_HTML = '<img src="{img}" alt="{alt}" style="width:150px;height:auto;margin:2px;"/>'
+
+
+def load_annotations(path):
+    return json.loads(Path(path).read_text())
+
+
+def build_scene_map(annotations):
+    scene_map = {}
+    for ann in annotations:
+        scene = ann.get('source') or ann.get('filename')
+        scene_map.setdefault(scene, {})[ann['style']] = ann['filename']
+    return scene_map
+
+
+def render_grid(scene_map, images_dir):
+    lines = [MD_HEADER]
+    # header row with style labels
+    header = '| Scene | ' + ' | '.join(s.capitalize() for s in STYLES) + ' |'
+    sep = '|---' + ('|---' * len(STYLES)) + '|'  # simple separators
+    lines.append(header)
+    lines.append(sep)
+
+    for scene, style_map in sorted(scene_map.items()):
+        cells = []
+        for s in STYLES:
+            if s in style_map:
+                fn = style_map[s]
+                img_path = f"{images_dir}/{fn}"
+                cells.append(CELL_HTML.format(img=img_path, alt=fn))
+            else:
+                cells.append('')
+        scene_cell = f'`{scene}`'
+        lines.append('| ' + scene_cell + ' | ' + ' | '.join(cells) + ' |')
+
+    return '\n'.join(lines)
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--annotations', default='validation/annotations.json')
+    parser.add_argument('--out', default='validation/validation_grid.md')
+    parser.add_argument('--images-dir', default='validation/images')
+    args = parser.parse_args()
+
+    annotations = load_annotations(args.annotations)
+    scene_map = build_scene_map(annotations)
+    md = render_grid(scene_map, args.images_dir)
+    Path(args.out).write_text(md)
+    print(f"Wrote {args.out}")
+
+
+if __name__ == '__main__':
+    main()