AGB | AI learning

Was ist Computer Vision?

Computer Vision ist ein Bereich der Künstlichen Intelligenz, der Maschinen befähigt, visuelle Informationen aus der Welt zu verstehen und zu interpretieren. Durch Deep Learning können Computer heute Bilder klassifizieren, Objekte erkennen und sogar komplexe Szenen verstehen.

Von autonomen Fahrzeugen über medizinische Bildanalyse bis hin zu Gesichtserkennung - Computer Vision revolutioniert zahlreiche Branchen. Convolutional Neural Networks (CNNs) sind dabei die Grundlage der meisten modernen Bildverarbeitungssysteme.

Der Durchbruch durch CNNs

Im Jahr 2012 gewann AlexNet die ImageNet-Challenge mit einer CNN-Architektur und reduzierte die Fehlerrate dramatisch. Dies markierte den Beginn der Deep Learning Revolution in der Bildverarbeitung.

Bildklassifikation mit CNNs

Bildklassifikation ist die grundlegende Aufgabe in Computer Vision. Hier lernen wir, wie man ein CNN für die Klassifikation von Bildern erstellt:

        import tensorflow as tf
        from tensorflow import keras
        from tensorflow.keras import layers
        
        # CNN-Modell für Bildklassifikation
        model = keras.Sequential([
            # Erste Convolutional Block
            layers.Conv2D(32, (3, 3), activation='relu', 
                         input_shape=(224, 224, 3)),
            layers.BatchNormalization(),
            layers.MaxPooling2D((2, 2)),
            
            # Zweiter Convolutional Block
            layers.Conv2D(64, (3, 3), activation='relu'),
            layers.BatchNormalization(),
            layers.MaxPooling2D((2, 2)),
            
            # Dritter Convolutional Block
            layers.Conv2D(128, (3, 3), activation='relu'),
            layers.BatchNormalization(),
            layers.MaxPooling2D((2, 2)),
            
            # Classification Head
            layers.Flatten(),
            layers.Dense(256, activation='relu'),
            layers.Dropout(0.5),
            layers.Dense(10, activation='softmax')
        ])
        
        # Modell kompilieren
        model.compile(
            optimizer='adam',
            loss='categorical_crossentropy',
            metrics=['accuracy']
        )
        
        model.summary()
                  

CNN-Architektur Prinzipien

Convolutional Layers: Extrahieren lokale Features aus Bildern
Pooling Layers: Reduzieren die räumliche Dimension
Batch Normalization: Stabilisiert und beschleunigt das Training
Dropout: Verhindert Overfitting durch zufälliges Deaktivieren von Neuronen

Transfer Learning mit vortrainierten Modellen

Transfer Learning nutzt vortrainierte Modelle wie ResNet, VGG oder EfficientNet als Ausgangspunkt. Dies spart Trainingszeit und liefert oft bessere Ergebnisse als Training von Grund auf.

        from tensorflow.keras.applications import ResNet50
        from tensorflow.keras.applications.resnet50 import preprocess_input
        
        # Vortrainiertes ResNet50 laden (ohne Top-Layer)
        base_model = ResNet50(
            weights='imagenet',
            include_top=False,
            input_shape=(224, 224, 3)
        )
        
        # Basis-Modell einfrieren
        base_model.trainable = False
        
        # Eigenen Classification Head hinzufügen
        model = keras.Sequential([
            base_model,
            layers.GlobalAveragePooling2D(),
            layers.Dense(256, activation='relu'),
            layers.Dropout(0.5),
            layers.Dense(num_classes, activation='softmax')
        ])
        
        # Kompilieren und trainieren
        model.compile(
            optimizer=keras.optimizers.Adam(1e-4),
            loss='categorical_crossentropy',
            metrics=['accuracy']
        )
                  

Objekterkennung mit YOLO

YOLO (You Only Look Once) ist ein hochperformantes Framework für Echtzeit-Objekterkennung. Es kann mehrere Objekte in einem Bild gleichzeitig erkennen und lokalisieren.

        from ultralytics import YOLO
        import cv2
        import numpy as np
        
        # YOLO Modell laden
        model = YOLO('yolov8n.pt')
        
        # Bild laden
        image = cv2.imread('beispiel.jpg')
        
        # Objekterkennung durchführen
        results = model(image)
        
        # Ergebnisse verarbeiten
        for result in results:
            boxes = result.boxes
            for box in boxes:
                # Bounding Box Koordinaten
                x1, y1, x2, y2 = box.xyxy[0]
                
                # Klasse und Konfidenz
                cls = int(box.cls[0])
                conf = float(box.conf[0])
                
                # Box zeichnen
                cv2.rectangle(image, (int(x1), int(y1)), 
                            (int(x2), int(y2)), (0, 255, 0), 2)
                
                # Label hinzufügen
                label = f"{model.names[cls]} {conf:.2f}"
                cv2.putText(image, label, (int(x1), int(y1)-10),
                           cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2)
        
        # Ergebnis speichern
        cv2.imwrite('output.jpg', image)
                  

Data Augmentation

Data Augmentation ist eine wichtige Technik, um die Größe und Vielfalt des Trainingsdatensatzes künstlich zu erhöhen und Overfitting zu vermeiden.

        from tensorflow.keras.preprocessing.image import ImageDataGenerator
        
        # Data Augmentation Generator erstellen
        datagen = ImageDataGenerator(
            rotation_range=20,          # Zufällige Rotation
            width_shift_range=0.2,      # Horizontale Verschiebung
            height_shift_range=0.2,     # Vertikale Verschiebung
            horizontal_flip=True,       # Horizontales Spiegeln
            zoom_range=0.2,             # Zoom
            shear_range=0.2,            # Scherung
            fill_mode='nearest'
        )
        
        # Generator für Training verwenden
        train_generator = datagen.flow_from_directory(
            'data/train',
            target_size=(224, 224),
            batch_size=32,
            class_mode='categorical'
        )
        
        # Mit augmentierten Daten trainieren
        history = model.fit(
            train_generator,
            epochs=20,
            validation_data=validation_generator
        )
                  

Best Practices

Normalisierung: Pixel-Werte auf 0-1 skalieren
Augmentation: Realistische Transformationen verwenden
Batch Size: Größere Batches für stabile Gradienten
Learning Rate: Kleinere Lernraten für Transfer Learning

Fazit

Computer Vision mit Deep Learning ermöglicht beeindruckende Anwendungen. Von einfacher Bildklassifikation bis zu komplexer Objekterkennung - die Werkzeuge und Frameworks sind heute zugänglicher denn je.

Beginnen Sie mit einfachen Klassifikationsaufgaben, experimentieren Sie mit vortrainierten Modellen und arbeiten Sie sich zu komplexeren Aufgaben wie Segmentierung und Objekterkennung vor. Praktische Erfahrung ist der beste Lehrmeister!

Nächste Schritte

Erkunden Sie fortgeschrittene Themen wie Semantic Segmentation, Instance Segmentation und Vision Transformers. OpenCV und PyTorch bieten hervorragende Ressourcen für praktisches Lernen!