Computer Vision QC: 99.7% Genauigkeit + €127k gespart [Vision-AI 2025]

Vision System Komponenten:
  Kameras (pro Maschine):
    - Basler ace 2 (5 MP, 75 FPS, GigE)
    - Preis: €890/Kamera
    - Objektiv: 25mm, F2.8 (€340)
    - Anzahl: 12 Maschinen × 1 Kamera = €14.760
  
  Beleuchtung:
    - LED-Ringlicht (Dome, diffus)
    - Preis: €240/Licht
    - Total: 12 × €240 = €2.880
  
  Edge-Computer (zentral):
    - NVIDIA Jetson AGX Orin (32GB)
    - GPU: 275 TOPS AI Performance
    - Preis: €1.890
    - Verarbeitet alle 12 Kameras parallel
  
  Montage & Verkabelung:
    - Kamera-Halterungen, GigE-Switch
    - Preis: €3.200

Total Hardware: €22.730
Installation (3 Tage): €4.800

Computer Vision Pipeline:
  Image Acquisition:
    - Basler Pylon SDK
    - Trigger: PLC-Signal (Teil ausgeworfen)
    - Capture-Rate: 1 Bild/Zyklus
  
  Preprocessing:
    - OpenCV (Normalisierung, Rauschfilter)
    - ROI-Extraction (nur relevanter Bereich)
    - Augmentation für Training
  
  Detection Model:
    - YOLOv8 (You Only Look Once)
    - Custom-trained auf Kunststoff-Defekte
    - Classes: Lunker, Kratzer, Fließnaht, Verfärbung, OK
  
  Postprocessing:
    - Geometrie-Checks (Maße, Winkel)
    - Regelwerk-Engine (Toleranzen)
    - Confidence-Thresholds
  
  Integration:
    - MQTT zu PLC (OK/NOK Signal)
    - REST API zu MES (Qualitätsdaten)
    - PostgreSQL (Bild-Archiv)

Hosting: On-Premise (Jetson)
Software: Open Source (€0)

# YOLOv8 Training für Defekt-Erkennung

from ultralytics import YOLO
import cv2

# 1. Dataset vorbereiten
# Gesammelt: 8.500 Bilder über 2 Wochen Produktion
# Gelabelt mit CVAT (5 Klassen):
#   - lunker (Lunker/Poren): 1.200 Samples
#   - kratzer (Oberflächenkratzer): 890 Samples
#   - fliessnaht (Schweißnähte): 650 Samples
#   - verfaerbung (Farbabweichung): 420 Samples
#   - ok (Gutteile): 5.340 Samples

# 2. YOLOv8 Model initialisieren
model = YOLO('yolov8n.pt')  # Nano (schnell auf Jetson)

# 3. Training
results = model.train(
    data='kunststoff_defects.yaml',
    epochs=100,
    imgsz=640,
    batch=16,
    device=0,  # GPU
    project='qc_model',
    name='kunststoff_v1'
)

# Training Results nach 100 Epochs:
# - mAP@0.5: 0.978 (97.8% Genauigkeit)
# - Precision: 0.984
# - Recall: 0.972
# - Inference Time: 12ms/Bild (Jetson AGX)

# 4. Export für Production
model.export(format='tensorrt')  # TensorRT für max Speed
# → Inference Time: 6ms/Bild (2× schneller!)

print("✅ Model trained & optimized!")
print(f"mAP: {results.maps:.3f}")
print(f"Inference: 6ms = {1000/6:.0f} FPS")

Parallel-Betrieb (Mensch + KI):
  Setup:
    - 1 Woche Produktion normal
    - KI läuft parallel (loggt Predictions)
    - Prüfer markiert tatsächliche Fehler
    - Vergleich: KI vs Mensch

  Ergebnisse (5.400 Teile):
    Confusion Matrix:
                 Predicted OK  |  Predicted NOK
    Actual OK:   5.156 (TP)    |  18 (FP) = 0.3% False Positive
    Actual NOK:  8 (FN)        |  218 (TN) = 96.5% True Negative
    
    KI Accuracy: 99.5%
    Mensch Accuracy: 91.2% (Ermüdung, Inkonsistenz)
    
    → KI ist 8,3 Punkte genauer! ✅

  Fehler-Analyse:
    - 8 False Negatives: Sehr kleine Lunker (\<0,5mm)
    - 18 False Positives: Staub auf Kamera (Problem behoben)
    
  Maßnahmen:
    - Kamera-Reinigung automatisiert (Druckluft)
    - Confidence-Threshold angepasst: 0.75 → 0.70
    - Retraining mit neuen Edge-Cases

# MQTT-Kommunikation mit SPS

import paho.mqtt.client as mqtt
import json

class QualityControlSystem:
    def __init__(self):
        self.model = YOLO('kunststoff_v1_tensorrt.engine')
        self.mqtt_client = mqtt.Client()
        self.mqtt_client.connect("192.168.1.100", 1883)
        
    def process_image(self, image, machine_id, part_id):
        """
        Verarbeitet Bild und sendet Ergebnis an PLC
        """
        # Inference
        results = self.model(image, conf=0.70)
        
        # Defekte extrahieren
        defects = []
        for r in results:
            for box in r.boxes:
                class_name = r.names[int(box.cls)]
                confidence = float(box.conf)
                
                if class_name != 'ok':
                    defects.append({
                        'type': class_name,
                        'confidence': confidence,
                        'bbox': box.xyxy[0].tolist()
                    })
        
        # Entscheidung
        is_ok = len(defects) == 0
        
        # MQTT Nachricht an PLC
        message = {
            'machine_id': machine_id,
            'part_id': part_id,
            'timestamp': datetime.now().isoformat(),
            'result': 'OK' if is_ok else 'NOK',
            'defects': defects,
            'confidence': float(results[0].boxes.conf.max()) if len(results[0].boxes) > 0 else 0.0
        }
        
        topic = f'qc/machine/{machine_id}/result'
        self.mqtt_client.publish(topic, json.dumps(message))
        
        # Bei NOK: Bild speichern für Analyse
        if not is_ok:
            self.save_defect_image(image, part_id, defects)
        
        return message
    
    def save_defect_image(self, image, part_id, defects):
        """
        Speichert NOK-Bilder für Nachverfolgung
        """
        filename = f'nok_{part_id}_{datetime.now().strftime("%Y%m%d_%H%M%S")}.jpg'
        cv2.imwrite(f'/mnt/qc_archive/{filename}', image)
        
        # In DB loggen
        db.insert_quality_record({
            'part_id': part_id,
            'result': 'NOK',
            'defects': defects,
            'image_path': filename,
            'timestamp': datetime.now()
        })

# System starten
qc_system = QualityControlSystem()

# Kamera-Loop (läuft auf Jetson)
while True:
    # Warte auf Trigger von PLC
    if plc_trigger_received():
        machine_id, part_id = get_current_part_info()
        image = capture_image(machine_id)
        
        result = qc_system.process_image(image, machine_id, part_id)
        
        if result['result'] == 'NOK':
            # PLC aktiviert Ausschleusung
            pass  # PLC handled automatisch
        else:
            # Teil OK → Weiter zur Verpackung
            pass

Workflow NOK-Teil:
  1. KI erkennt Defekt → MQTT an PLC
  2. PLC aktiviert Pneumatik-Zylinder
  3. Teil wird in NOK-Behälter geschoben
  4. MES bekommt Qualitätsdaten (für Statistik)
  5. Bild archiviert (Rückverfolgbarkeit)
  
  Zyklus-Zeit: 3,8 Sekunden
  (manuelle Prüfung: 15 Sekunden)

# Automatisches Drift-Detection

import numpy as np
from scipy import stats

class ModelMonitor:
    def __init__(self):
        self.baseline_confidence = 0.87  # Durchschnitt aus Training
        
    def check_weekly_performance(self, predictions_last_week):
        """
        Wöchentlicher Health-Check
        """
        df = pd.DataFrame(predictions_last_week)
        
        # 1. Confidence Distribution
        current_conf = df['confidence'].mean()
        confidence_drop = (self.baseline_confidence - current_conf) / self.baseline_confidence
        
        if confidence_drop > 0.10:  # >10% Drop
            alert = {
                'type': 'confidence_drop',
                'severity': 'warning',
                'message': f'Confidence dropped {confidence_drop*100:.1f}% vs baseline',
                'action': 'Check camera calibration & lighting'
            }
            send_alert_to_maintenance(alert)
        
        # 2. Defekt-Rate Trend
        defect_rate = (df['result'] == 'NOK').mean()
        expected_rate = 0.035  # 3,5% (historisch)
        
        if defect_rate > expected_rate * 1.5:  # 50% höher
            alert = {
                'type': 'defect_spike',
                'severity': 'critical',
                'message': f'Defect rate {defect_rate*100:.1f}% (expected {expected_rate*100:.1f}%)',
                'action': 'Check production process & material quality'
            }
            send_alert_to_production(alert)
        
        # 3. Neue Defekt-Typen?
        unknown_defects = df[df['confidence'] < 0.50]
        if len(unknown_defects) > 10:
            # Potentiell neue Fehlerart
            alert = {
                'type': 'new_defect_pattern',
                'severity': 'info',
                'message': f'{len(unknown_defects)} low-confidence predictions',
                'action': 'Review images & consider retraining'
            }
            send_alert_to_quality_team(alert)

monitor = ModelMonitor()
# Läuft automatisch jeden Montag

Kontinuierliches Lernen:
  Monatlich:
    - Alle NOK-Bilder reviewen
    - Neue Edge-Cases zum Trainings-Set hinzufügen
    - Model neu trainieren (1-2 Stunden auf Cloud-GPU)
    - A/B-Test: Altes vs Neues Model (1 Woche)
    - Rollout wenn besser
  
  Tracking:
    - Model-Version in DB
    - Performance-Metriken pro Version
    - Rollback-Option bei Verschlechterung

Checkliste:
  □ Defekt-Typen definieren (5-10 Klassen)
  □ Kamera-Position festlegen (Abstand, Winkel, Licht)
  □ Test-Aufnahmen machen (verschiedene Beleuchtungen)
  □ Hardware bestellen (Lieferzeit 2-4 Wochen!)
  □ Mechanische Halterungen anfertigen

Checkliste:
  □ 5.000-10.000 Bilder sammeln (2 Wochen Produktion)
  □ Labeling mit CVAT/Label Studio (10-15h Aufwand)
  □ Train/Val/Test Split (70/20/10)
  □ Augmentation-Strategie festlegen

Checkliste:
  □ YOLOv8 Training (Cloud-GPU: €2/h × 20h = €40)
  □ Hyperparameter-Tuning
  □ Validation auf Test-Set (mAP >95%)
  □ TensorRT Export für Jetson
  □ Parallel-Test (1 Woche Produktion)

Checkliste:
  □ PLC-Protokoll implementieren (MQTT/OPC-UA)
  □ MES-Integration (Qualitätsdaten)
  □ Monitoring-Dashboard (Grafana)
  □ Schulung Bediener (2h Session)
  □ Go-Live & Support (1 Woche onsite)