Anime Style Classifier v6

An EfficientNet-B2 model that classifies anime frames into 5 production style categories, expanding on v5 by splitting the painterly class into distinct pencil-sketch and painterly substyles. It can also produce 1,408-dimensional pooled feature embeddings for measuring visual similarity between frames. These embeddings are useful for style-oriented search, but are not guaranteed to be independent of image content.

Model Details

Architecture

EfficientNet-B2 (timm)

Parameters

7.7M

Input

440 × 440 RGB

Embedding dim

1,408 (global-average-pooled final feature map)

Classes

5 (flat, modern, retro, stylised_painterly, stylised_pencil)

Format

SafeTensors

File size

30 MB

Training data

97,444 images across 5 classes

Training method

Supervised ASL (Asymmetric Softmax) with batch-balanced sampling

Classes

Style Examples

Performance

OOD Evaluation (459 held-out images, never seen during training)

Overall accuracy: 96.30% (442/459)

Confusion Matrix

| → flat | → modern | → retro | → painterly | → pencil ---|---|---|---|---|--- flat (74) | 73 | 0 | 1 | 0 | 0 modern (206) | 2 | 204 | 0 | 0 | 0 retro (100) | 1 | 5 | 94 | 0 | 0 painterly (44) | 1 | 2 | 0 | 40 | 1 pencil (35) | 2 | 0 | 1 | 1 | 31

Error Analysis (17 total)

All errors are borderline cases. Click any thumbnail to view full size.

Comparison to V5 (4-class Baseline)

Why the Tradeoff?

V5's high accuracy (98.41% OOD) came from a small, highly-curated 19.6k image dataset and class-balanced sampling. V6 training expanded to 97.4k images across 5 classes to separate pencil and painterly:

• Data imbalance: Retro has nearly 15× more training samples than flat (dataset-driven split, not architecture-driven)
• Annotation subjectivity: The pencil class has 35 examples in the reported OOD benchmark (small sample size)
• Boundary ambiguity: Pencil/painterly blend on 2-3% of training images (subjective human labels)

The 2.11pp OOD drop is acceptable given the added classification granularity. Pencil is the weakest class at 88.6%; the other reported class recalls range from 90.9% to 99.0%.

Shared Class Performance (V5 v6 split analysis)

For direct comparison, merging V6's painterly + pencil back into single "painterly" class:

• V5 painterly: 94.0% (47/50 OOD)
• V6 painterly+pencil merged: 90.6% (71/79 OOD)
• Delta: −3.4pp (expected from increased training distribution mismatch)

Usage

Installation

pip install torch timm torchvision pillow

Classification

import torch
from safetensors.torch import load_file
import timm
from PIL import Image
from torchvision import transforms

# Load model
model = timm.create_model('efficientnet_b2', num_classes=5, pretrained=False)
state_dict = load_file('model.safetensors')
model.load_state_dict(state_dict)
model.eval()

# Preprocessing
transform = transforms.Compose([
    transforms.Resize((440, 440)),
    transforms.ToTensor(),
    transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]),
])

# Predict single image
image = Image.open('anime_frame.jpg').convert('RGB')
x = transform(image).unsqueeze(0)

with torch.no_grad():
    logits = model(x)
    probs = torch.softmax(logits, dim=1)
    pred_idx = logits.argmax(-1).item()
    confidence = probs[0, pred_idx].item()

classes = ['flat', 'modern', 'retro', 'stylised_painterly', 'stylised_pencil']
print(f'{classes[pred_idx]}: {confidence:.1%}')
# Output: modern: 96.5%

Batch Classification with Confidence

from torch.utils.data import DataLoader
from torchvision.datasets import ImageFolder
import pandas as pd

# Load images from folder
dataset = ImageFolder('anime_frames/', transform=transform)
loader = DataLoader(dataset, batch_size=32)

results = []
with torch.no_grad():
    for images, _ in loader:
        logits = model(images)
        probs = torch.softmax(logits, dim=1)
        preds = logits.argmax(-1)
        confs = probs.gather(1, preds.unsqueeze(1)).squeeze()
        
        for pred, conf in zip(preds, confs):
            results.append({'style': classes[pred], 'confidence': conf.item()})

df = pd.DataFrame(results)
print(df.groupby('style')['confidence'].agg(['count', 'mean', 'min']))

Confidence Thresholding (Optional)

If you want to reject ambiguous classifications:

with torch.no_grad():
    logits = model(x)
    probs = torch.softmax(logits, dim=1)
    pred_idx = logits.argmax(-1).item()
    confidence = probs[0, pred_idx].item()
    
    if confidence < 0.85:
        print('Ambiguous — may want to review manually')
    else:
        print(f'{classes[pred_idx]}: {confidence:.1%} (confident)')

Based on OOD evaluation:

• ≥ 0.95 confidence: >99% accurate
• 0.85–0.95 confidence: ~97% accurate
• < 0.85 confidence: Review recommended, especially for pencil class

Use as Style Embedding Model

Beyond classification, this model produces 1,408-dimensional embeddings by global-average-pooling the final convolutional feature map. They may capture visual drawing characteristics such as line weight, shading technique, color palette, and compositing approach, but can also retain scene-content information.

This enables:

• Batch style search: Find all frames in a 1.5M screencap corpus with matching visual drawing style
• Series identification: Cluster frames by series/studio without using metadata
• Style interpolation: Measure how a show's visual style evolves over seasons
• Synthetic dataset balance: Find style-similar examples of underrepresented classes

Embedding Usage

import torch
from safetensors.torch import load_file
import timm
from PIL import Image
from torchvision import transforms

# Load model
model = timm.create_model('efficientnet_b2', num_classes=5, pretrained=False)
state_dict = load_file('model.safetensors')
model.load_state_dict(state_dict)
model.eval()

transform = transforms.Compose([
    transforms.Resize((440, 440)),
    transforms.ToTensor(),
    transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]),
])

def get_style_embedding(image_path):
    """Extract a 1,408-dim embedding from the final convolutional features."""
    img = Image.open(image_path).convert('RGB')
    x = transform(img).unsqueeze(0)
    with torch.no_grad():
        features = model.forward_features(x)          # [1, 1408, 14, 14]
        embedding = features.mean(dim=[-2, -1])       # [1, 1408] global avg pool
        embedding = embedding / embedding.norm(dim=1, keepdim=True)  # L2 normalize
    return embedding.squeeze(0).numpy()

# Compare two frames
emb_a = get_style_embedding('frame_a.jpg')
emb_b = get_style_embedding('frame_b.jpg')
similarity = emb_a @ emb_b  # cosine similarity (embeddings are L2-normalized)
print(f'Style similarity: {similarity:.4f}')
# > 0.8  = very similar style (likely same series/studio)
# 0.5-0.8 = same style family (e.g., both modern)
# 0.2-0.5 = different but adjacent styles (e.g., modern vs retro)
# < 0.2  = opposite ends of spectrum (e.g., flat vs modern)

Interpreting Embedding Distances

The embedding captures how something is drawn — line weight, shading technique, color palette, compositing — not what is drawn. Scenes with completely different content (landscapes vs close-ups vs action sequences) from the same series will cluster together.

Training Details

Data Composition

Loss Function Innovation: Asymmetric Softmax (ASL)

Standard cross-entropy treats all mistakes equally. Anime style classification is imbalanced:

• In-distribution: Most training images are clean, well-lit frames with clear style markers (easy to classify)
• Out-of-distribution (OOD): Test images include ambiguous boundary cases, poor lighting, style blends (hard to classify)

Asymmetric Softmax solves this by:

1. Hard negatives (γ_neg = 4.0): Penalize false positives heavily → sharp decision boundaries on negatives
2. Soft positives (γ_pos = 1.0): Keep positive examples less strict → model learns to be confident without overfitting

Formula: p_t = (1 - p)^γ_neg * CE for negatives; p_t^γ_pos * CE for positives

Impact: +8.04pp over the cross-entropy baseline on the separate 131-image OOD experiment (89.38% CE → 97.42% ASL)

This single loss choice was more impactful than:

• Merge experiments (best merge: 95.54% on that experiment, underperformed standalone ASL)
• Post-hoc fine-tuning (specialization attempted but minimal divergence from baseline)
• Different architectures (EfficientNet-B2 already optimal for this scale)

Training Pipeline

1. Base training: EfficientNet-B2 (ImageNet pretrained), ASL loss, batch-balanced sampling (upweight flat class 3×)
2. Optimizer: AdamW with 1e-3 initial LR, cosine annealing over 25 epochs
3. Validation: held-out OOD data; the model-card result above is reported on 459 images. The loss-comparison experiments below use a separate 131-image OOD split.
4. Best checkpoint: Epoch 9/25, saved based on OOD accuracy (not validation loss)

Why ASL over Alternative Losses?

ASL's asymmetry perfectly matched the OOD challenge structure.

Limitations

Trained primarily on Japanese anime (TV series, films). May not generalize to:

• ❌ Western animation (different art direction traditions)
• ❌ Donghua (Chinese animation with distinct visual language)
• ❌ Manhwa (Korean webtoon styles)

Class-Specific Limitations

• ⚠️ Pencil class weak: 88.6% OOD accuracy (31/35). Limited training diversity and a subjective boundary with painterly. Its four errors were split across flat (2), retro (1), and painterly (1). Recommend a higher confidence threshold for pencil predictions.
• ⚠️ Painterly/pencil boundary: Subjective when styles blend (watercolor overlay on sketch lines, mixed-media). The reported confusion matrix contains 2 such cross-class errors out of 17 total errors.
• ⚠️ AI-generated art: Models trained on diffusion outputs (ComfyUI, Stable Diffusion) often misclassify between painterly and modern when they successfully mimic style.
• ⚠️ Flat class variability: Increased from 0 to 3 errors vs V5 due to larger training distribution mismatch.

What This Model is NOT

• ❌ Not a character design classifier — won't detect moe, chibi, bishounen, etc.
• ❌ Not a content classifier — sees how it's drawn, not what
• ❌ Not an era detector — a modern show using cel technique → retro (correct)
• ❌ Not a quality scorer — good and bad frames of the same style both classify identically
• ❌ Not an AI detector — AI art that successfully mimics a style gets classified by that style

Future Work (v6.1+)

Immediate Priorities (pencil class improvement)

The pencil class (88.6% OOD) is the main constraint on v6's overall performance. Paths forward:

1. Hard negative mining — Collect confident pencil misclassifications, especially near the painterly boundary. Retrain on these hard examples (20-50 images) to tighten the boundary.

2. Curriculum learning — Instead of fixed class weights, progressively increase pencil focus over epochs (0.5× → 1.0× → 3.0×), allowing the model to develop richer representations.

3. Synthetic pencil augmentation — Generate pencil-style images via style transfer or CLIP-guided diffusion to expand diversity.

4. Ensemble with V5 — Combine V6's 5-class precision with V5's 4-class robustness via voting or weighted logits to hedge pencil weakness.

Medium-term Improvements

1. Contrastive learning — Explicitly push pencil and painterly embeddings apart using contrastive loss on borderline examples.

2. OOD-aware training — If oracle OOD labels are available during training, use them in loss function to optimize for OOD rather than validation.

3. Multi-scale inference — Ensemble predictions at 440px and 512px (as V5 did) to capture different receptive fields.

Research Directions

1. Causal analysis — Which image features most influence pencil misclassifications? (Line density? Stroke boldness? Color saturation?)

2. Style interpolation — Measure how visual style evolves over a series' runtime using embeddings.

3. Synthetic dataset balancing — Use style embeddings to find and clone style-similar images for underrepresented classes (flat, pencil).

Citation

@misc{anime-style-classifier-v6,
  title={Anime Style Classifier V6},
  year={2026},
  publisher={HuggingFace},
  note={EfficientNet-B2 (7.7M) fine-tuned with Asymmetric Softmax loss for 5-class anime production style classification}
}

---

Model Card Summary

Recommended Use:

• Style classification of anime screencaps, scenes, frames
• Style embeddings for similarity search and clustering
• Dataset curation and filtering
• NOT for content classification or quality scoring

---

For questions, comparisons, or examples, see the V5 model card for additional context on the v5→v6 evolution.