Wann brauchen Sie ein Custom Vision Model?

Vortrainierte Modelle wie YOLO oder ResNet lösen viele Standard-Aufgaben. Doch für spezialisierte Anwendungsfälle - wie Qualitätskontrolle in der Fertigung oder Klassifikation unternehmenseigener Produkte - führt kein Weg an Custom Models vorbei.

Bei innFactory entwickeln wir Custom Vision Models für verschiedene Branchen. In diesem Artikel teilen wir unsere bewährten Praktiken.

Der Computer Vision Entwicklungsprozess

1. Datensammlung & Annotation

Die Datenqualität entscheidet über den Erfolg. Unsere Empfehlungen:

Mindestdatenmenge:

Klassifikation: 100-500 Bilder pro Klasse
Object Detection: 500-2000 annotierte Bounding Boxes pro Klasse
Segmentation: 200-500 pixelgenaue Masken pro Klasse

Annotation-Tools:

Label Studio - Open Source, flexibel
CVAT - Spezialisiert auf Video
Roboflow - All-in-One mit Augmentation

Best Practices:

# Datenstruktur für Klassifikation
data/
├── train/
│   ├── class_a/
│   │   ├── img_001.jpg
│   │   └── ...
│   └── class_b/
├── val/
└── test/

2. Transfer Learning Setup

Starten Sie nie von Null. Vortrainierte Backbones beschleunigen das Training erheblich:

import torch
import torchvision.models as models

# ResNet50 mit ImageNet-Gewichten
model = models.resnet50(weights=models.ResNet50_Weights.IMAGENET1K_V2)

# Letzte Schicht für eigene Klassen anpassen
num_classes = 5
model.fc = torch.nn.Linear(model.fc.in_features, num_classes)

# Backbone einfrieren (optional für kleine Datensätze)
for param in model.parameters():
    param.requires_grad = False
    
# Nur Classifier trainieren
for param in model.fc.parameters():
    param.requires_grad = True

3. Data Augmentation

Künstliche Datenvervielfältigung ist essenziell:

from torchvision import transforms

train_transform = transforms.Compose([
    transforms.RandomResizedCrop(224),
    transforms.RandomHorizontalFlip(),
    transforms.RandomRotation(15),
    transforms.ColorJitter(
        brightness=0.2, 
        contrast=0.2, 
        saturation=0.2
    ),
    transforms.ToTensor(),
    transforms.Normalize(
        mean=[0.485, 0.456, 0.406],
        std=[0.229, 0.224, 0.225]
    ),
])

# Für Produktion: Albumentations ist schneller
import albumentations as A
from albumentations.pytorch import ToTensorV2

train_transform = A.Compose([
    A.RandomResizedCrop(224, 224),
    A.HorizontalFlip(p=0.5),
    A.ShiftScaleRotate(p=0.5),
    A.Normalize(),
    ToTensorV2(),
])

4. Training Loop

Ein produktionstauglicher Training Loop:

import torch
from torch.cuda.amp import GradScaler, autocast
from tqdm import tqdm

def train_epoch(model, loader, optimizer, criterion, scaler, device):
    model.train()
    total_loss = 0
    correct = 0
    total = 0
    
    for images, labels in tqdm(loader):
        images, labels = images.to(device), labels.to(device)
        
        optimizer.zero_grad()
        
        # Mixed Precision für schnelleres Training
        with autocast():
            outputs = model(images)
            loss = criterion(outputs, labels)
        
        scaler.scale(loss).backward()
        scaler.step(optimizer)
        scaler.update()
        
        total_loss += loss.item()
        _, predicted = outputs.max(1)
        correct += predicted.eq(labels).sum().item()
        total += labels.size(0)
    
    return total_loss / len(loader), correct / total

# Training
scaler = GradScaler()
for epoch in range(num_epochs):
    train_loss, train_acc = train_epoch(
        model, train_loader, optimizer, criterion, scaler, device
    )
    val_loss, val_acc = validate(model, val_loader, criterion, device)
    
    # Learning Rate Scheduling
    scheduler.step(val_loss)
    
    # Early Stopping
    if val_loss < best_val_loss:
        best_val_loss = val_loss
        torch.save(model.state_dict(), 'best_model.pth')
        patience_counter = 0
    else:
        patience_counter += 1
        if patience_counter >= patience:
            break

5. Hyperparameter-Tuning

Wichtige Hyperparameter und Startwerte:

Parameter	Empfehlung	Bereich
Learning Rate	1e-4 (Transfer)	1e-5 - 1e-3
Batch Size	32	16-128
Weight Decay	1e-4	1e-5 - 1e-3
Epochs	50-100	-
Image Size	224	224-512

Für systematisches Tuning: Optuna oder Weights & Biases Sweeps

6. Model Export & Optimierung

Für Produktion das Modell optimieren:

# TorchScript für Deployment
model.eval()
scripted_model = torch.jit.script(model)
scripted_model.save('model_scripted.pt')

# ONNX für Cross-Platform
dummy_input = torch.randn(1, 3, 224, 224).to(device)
torch.onnx.export(
    model, 
    dummy_input, 
    'model.onnx',
    opset_version=13,
    input_names=['input'],
    output_names=['output'],
    dynamic_axes={'input': {0: 'batch_size'}}
)

# Quantisierung für Edge-Devices
quantized_model = torch.quantization.quantize_dynamic(
    model, {torch.nn.Linear}, dtype=torch.qint8
)

7. Deployment-Optionen

Option	Latenz	Kosten	Use Case
AWS SageMaker	~100ms	€€€	Enterprise
Google Vertex AI	~100ms	€€€	GCP-Umgebung
TorchServe	~50ms	€€	Self-hosted
ONNX Runtime	~20ms	€	Edge/On-Premise
TensorRT	~10ms	€	NVIDIA GPUs

Praxisbeispiel: Qualitätskontrolle

Ein typischer Use Case bei innFactory:

Aufgabe: Automatische Erkennung von Produktdefekten

Lösung:

2000 Bilder mit 4 Defektklassen annotiert
EfficientNet-B3 als Backbone
Augmentation mit Albumentations
Training auf AWS p3.2xlarge (1x V100)
Deployment als ONNX auf Edge-Device

Ergebnis:

98.5% Accuracy auf Testdaten
<50ms Inferenzzeit pro Bild
ROI: Ersparnis von 2 FTE in der manuellen Kontrolle

Fazit

Custom Vision Models erfordern:

Hochwertige Trainingsdaten - Investieren Sie in Annotation
Transfer Learning - Nutzen Sie vortrainierte Modelle
Systematisches Experimentieren - Hyperparameter-Tuning ist entscheidend
Produktionsreife Architektur - Export, Optimierung, Monitoring

Bei innFactory begleiten wir Sie durch den gesamten Prozess - von der Datenanalyse bis zum produktiven Vision-System.

Computer Vision Projekt geplant? Kontaktieren Sie uns für eine unverbindliche Beratung.