anime-frame-interesting-classifier-cnn-v2

Anime Frame Interesting Classifier (CNN v2.0)

Model Details

Architecture: EfficientNetV2-S (CNN)
Framework: PyTorch
Input Size: 224x224 RGB images
Output: Binary classification (Boring/Interesting)

Performance

Evaluated on v2.0 test set (433 frames):

• F1 Score: 95.15%
• Accuracy: 95.15%
• Precision: 95.16%
• Recall: 95.15%

Training data: 3,999 frames (4,432 total with test holdout)

Intended Use

What it does: Classifies anime frames as either "interesting" (depicting meaningful character/scene details) or "boring" (back-of-head shots, non-descript backgrounds, montages).

When to use:

• Filtering extracted anime keyframes for quality
• Pre-scoring large frame datasets before manual review
• Combined with transformer model for ensemble voting (higher confidence)

When NOT to use:

• Real-world photos or non-anime content
• Frames smaller than 224x224 (resize required)
• Critical applications requiring >99% precision without human review

Labels

• Class 0 (Boring): Frames lacking interesting visual details or character focus
• Class 1 (Interesting): Frames with clear character/scene details suitable for downstream tasks

Model Size & Speed

• Model Size: 78 MB (SafeTensors format)
• Inference Speed: ~20ms per image on GPU
• VRAM Required: ~2 GB (including activations)

Training Data Composition

• 900 manually curated frames (hand-labeled)
• 1,655 frames filtered via dual-agreement with garbage classifier
• 1,877 frames from curated anime site scraper
• Total: 4,432 frames (90% train, 10% test holdout)

All frames are 224x224 RGB anime screenshots.

How to Use

Recommended: HuggingFace Transformers (SafeTensors)

from transformers import AutoImageProcessor, AutoModelForImageClassification
from PIL import Image

# Load model (automatically uses SafeTensors)
processor = AutoImageProcessor.from_pretrained(
    "hf_models/anime-frame-interesting-classifier-cnn-v2"
)
model = AutoModelForImageClassification.from_pretrained(
    "hf_models/anime-frame-interesting-classifier-cnn-v2",
    trust_remote_code=False  # Safe: SafeTensors prevents code execution
)

image = Image.open('frame.png')
inputs = processor(images=image, return_tensors="pt")
outputs = model(**inputs)
prediction = outputs.logits.argmax(-1).item()

print(f"Prediction: {'Interesting' if prediction == 1 else 'Boring'}")

Alternative: PyTorch with SafeTensors

from torchvision import models
import torch
from safetensors.torch import load_file

# Load model using SafeTensors (secure, no pickle deserialization)
model = models.efficientnet_v2_s()
model.classifier[1] = torch.nn.Linear(model.classifier[1].in_features, 2)
model.load_state_dict(load_file('model.safetensors'))
model.eval()

# Inference
import torchvision.transforms as transforms
from PIL import Image

transform = transforms.Compose([
    transforms.Resize(256),
    transforms.CenterCrop(224),
    transforms.ToTensor(),
    transforms.Normalize(mean=[0.485, 0.456, 0.406],
                        std=[0.229, 0.224, 0.225])
])

image = Image.open('frame.png')
x = transform(image).unsqueeze(0)

with torch.no_grad():
    output = model(x)
    logits = output
    prediction = logits.argmax(1).item()
    confidence = logits.softmax(1)[0][prediction].item()

print(f"Prediction: {'Interesting' if prediction == 1 else 'Boring'}")
print(f"Confidence: {confidence:.2%}")

Security Note: This model uses SafeTensors format (not pickle). This prevents arbitrary code execution during model loading. For maximum safety, use HuggingFace Transformers with trust_remote_code=False.

Comparison with Transformer Model

See anime-frame-interesting-classifier-vit-v2 for transformer alternative:

For maximum confidence, use ensemble voting: classify with both models and flag disagreements for manual review.

Limitations

• Anime-only: Trained exclusively on anime content, not tested on other media
• Dataset bias: Training data skewed toward popular anime styles (may underperform on niche art styles)
• Resolution: Trained on 224x224 frames; extreme aspect ratios may need preprocessing
• Edge cases: Minimal training on hard-to-classify frames (90-95% confidence borderline cases)

Training Details

• Dataset: v2.0 (4,432 frames)
• Train/Test Split: 90/10 (3,999 train, 433 test)
• Epochs: 20
• Batch Size: 64
• Optimizer: AdamW (lr=1e-4)
• Loss: CrossEntropyLoss
• Augmentation: None (data quality sufficient at this scale)

Version History

• v2.0 (current): 95.15% F1, retrained on expanded 4,432-frame dataset
• v1.0: 86% F1, 900-frame dataset (legacy, deprecated)

Citation

If you use this model, please reference:

• Dataset: Anime Frame Interesting v2.0 (4,432 curated frames)
• Architecture: EfficientNetV2-S
• Training: PyTorch, 2026

Future Improvements

• Collect 1,000+ edge-case frames for hard-negatives mining
• Ensemble with ViT for higher confidence decisions
• Fine-tune on downstream style classification tasks