Computational Visual Perception - Exam

Aufgabe 1)

Ein Bild im PNG-Format mit einer Auflösung von 1920 x 1080 hat eine Farbtiefe von 24 Bit pro Pixel. Du sollst verschiedene Transformationen und Komprimierungen an diesem Bild durchführen und berechnen, wie sich diese Änderungen auf das Bild auswirken.

a)

Aufgabe 1: Berechne die Dateigröße dieses Bildes vor der Komprimierung. Gib die Größe in Megabytes (MB) an.

• Hinweis: 1 Byte = 8 Bits
• Hinweis: 1 MB = 1024 Bytes

Lösung:

Aufgabe 1: Berechne die Dateigröße dieses Bildes vor der Komprimierung. Gib die Größe in Megabytes (MB) an.

• Hinweis: 1 Byte = 8 Bits
• Hinweis: 1 MB = 1024 Bytes

• Schritt 1: Berechne die gesamte Anzahl der Pixel im Bild. Da das Bild eine Auflösung von 1920 x 1080 hat, ist die Anzahl der Pixel:1920 x 1080 = 2.073.600 Pixel
• Schritt 2: Da jedes Pixel eine Farbtiefe von 24 Bit hat, berechne die gesamte Anzahl der Bits im Bild:2.073.600 Pixel x 24 Bit/Pixel = 49.766.400 Bits
• Schritt 3: Konvertiere die Bits in Bytes. Da 1 Byte = 8 Bits:49.766.400 Bits ÷ 8 = 6.220.800 Bytes
• Schritt 4: Konvertiere die Bytes in Megabytes (MB). Da 1 MB = 1024 Bytes:6.220.800 Bytes ÷ 1024 = 6.074,21875 KB6.074,21875 KB ÷ 1024 = 5,93 MB

b)

Aufgabe 2: Der Algorithmus zur verlustfreien Komprimierung des PNG-Bildes reduziert dessen Größe um 30%. Berechne die neue Dateigröße in Megabytes (MB) nach der Komprimierung.

Lösung:

Aufgabe 2: Der Algorithmus zur verlustfreien Komprimierung des PNG-Bildes reduziert dessen Größe um 30%. Berechne die neue Dateigröße in Megabytes (MB) nach der Komprimierung.Beginnen wir mit der Berechnung der neuen Dateigröße nach der Komprimierung.Schritte zur Berechnung:

• Schritt 1: Bestimme die ursprüngliche Dateigröße des Bildes. Aus Aufgabe 1 wissen wir, dass die ungefähre Dateigröße 5,93 MB beträgt.
• Schritt 2: Berechne die Größe der Reduktion. Eine Reduktion um 30% bedeutet:0,30 x 5,93 MB = 1,779 MB
• Schritt 3: Zieh die Reduktion von der ursprünglichen Dateigröße ab, um die neue Dateigröße zu erhalten:5,93 MB - 1,779 MB = 4,151 MB

c)

Aufgabe 3:Du führst eine Transformation an dem Bild durch, die eine Rotation um 45 Grad im Uhrzeigersinn beinhaltet. Beschreibe detailliert die mathematische Operation, die du ausführen musst, um die neuen Koordinaten eines Pixels \(x, y\) zu berechnen. Nutze dazu die rotierende Transformationsmatrix und stelle sicher, dass alle Zwischenrechnungen klar dargelegt werden.

Lösung:

Aufgabe 3: Du führst eine Transformation an dem Bild durch, die eine Rotation um 45 Grad im Uhrzeigersinn beinhaltet. Beschreibe detailliert die mathematische Operation, die du ausführen musst, um die neuen Koordinaten eines Pixels \(x, y\) zu berechnen. Nutze dazu die rotierende Transformationsmatrix und stelle sicher, dass alle Zwischenrechnungen klar dargelegt werden.Um die neuen Koordinaten eines Pixels nach einer Rotation um 45 Grad im Uhrzeigersinn zu berechnen, müssen wir die Rotationsmatrix nutzen. Der Winkel \(\theta\) beträgt in diesem Fall \(-45^{\circ}\).Die allgemeine Rotationsmatrix lautet:\[ R = \begin{pmatrix} \cos(\theta) & \sin(\theta) \ -\sin(\theta) & \cos(\theta) \end{pmatrix} \]Für \(\theta = -45^{\circ}\) erhalten wir:\[ \cos(-45^{\circ}) = \cos(45^{\circ}) = \frac{\sqrt{2}}{2} \]\[ \sin(-45^{\circ}) = -\sin(45^{\circ}) = -\frac{\sqrt{2}}{2} \]Somit ergibt sich die Rotationsmatrix:\[ R = \begin{pmatrix} \frac{\sqrt{2}}{2} & -\frac{\sqrt{2}}{2} \ \frac{\sqrt{2}}{2} & \frac{\sqrt{2}}{2} \end{pmatrix} \]Um die neuen Koordinaten \(x', y'\) eines Pixels \(x, y\) zu berechnen, multiplizieren wir diese Rotationsmatrix mit den ursprünglichen Koordinaten:\\[ \begin{pmatrix} x' \ y' \end{pmatrix} = \begin{pmatrix} \frac{\sqrt{2}}{2} & -\frac{\sqrt{2}}{2} \ \frac{\sqrt{2}}{2} & \frac{\sqrt{2}}{2} \end{pmatrix} \begin{pmatrix} x \ y \end{pmatrix} \]Dies ergibt:\[ x' = \frac{\sqrt{2}}{2} \cdot x - \frac{\sqrt{2}}{2} \cdot y \]\[ y' = \frac{\sqrt{2}}{2} \cdot x + \frac{\sqrt{2}}{2} \cdot y \]Zusammengefasst, die neuen Koordinaten \(x', y'\) des Pixels \(x, y\) nach einer Rotation um 45 Grad im Uhrzeigersinn sind:

• \[ x' = \frac{\sqrt{2}}{2} (x - y) \]
• \[ y' = \frac{\sqrt{2}}{2} (x + y) \]

Aufgabe 2)

Bildsegmentierung ist ein grundlegendes Verfahren in der Bildverarbeitung, das darauf abzielt, ein digitales Bild in mehrere Segmente zu unterteilen, um bedeutungsvolle Bereiche und Objekte zu erkennen. Es gibt verschiedene Methoden zur Bildsegmentierung, wie z.B. Schwellwertverfahren, Regionenwachstum, Kantendetektion, Graph-basierte Methoden, Clustering-Verfahren, Superpixel und maschinelles Lernen.

a)

Erkläre das Schwellwertverfahren zur Bildsegmentierung und beschreibe, wie es funktioniert. Diskutiere dabei mögliche Vor- und Nachteile dieser Methode.

Lösung:

Schwellwertverfahren zur Bildsegmentierung

Das Schwellwertverfahren ist eine einfache und weit verbreitete Methode zur Bildsegmentierung. Diese Methode basiert auf der Annahme, dass sich Objekte im Bild durch ihre Helligkeit oder Farbe von ihrem Hintergrund unterscheiden. Das Verfahren teilt ein Bild in zwei oder mehr Segmente, indem es alle Pixelwerte basierend auf einem oder mehreren Schwellwerten in Kategorien einteilt.

Funktionsweise

• Zunächst wird ein geeigneter Schwellwert (oder mehrere Schwellwerte) festgelegt. Der Schwellwert kann entweder manuell bestimmt oder automatisch unter Verwendung von Algorithmen wie dem Otsu-Verfahren berechnet werden.
• Alle Pixelwerte im Bild, die über dem Schwellwert liegen, werden einem Segment (z.B. dem Objekt) und alle Pixelwerte, die unter dem Schwellwert liegen, werden einem anderen Segment (z.B. dem Hintergrund) zugeordnet.
• Für farbige Bilder kann das Verfahren auf einzelne Farbkanäle angewendet werden.
• Das Ergebnis ist ein binäres Bild oder ein Bild mit mehreren Segmenten, je nach Anzahl der verwendeten Schwellwerte.

Vorteile

• Einfachheit: Das Schwellwertverfahren ist einfach zu implementieren und benötigt geringe Rechenressourcen.
• Schnelligkeit: Es arbeitet schnell und ist daher für Echtzeitanwendungen geeignet.
• Anwendungsbereiche: Es kann in verschiedenen Anwendungsbereichen eingesetzt werden, z.B. in der medizinischen Bildverarbeitung und Qualitätskontrolle.

Nachteile

• Begrenzte Genauigkeit bei komplexen Bildern: Bei Bildern mit komplexen Hintergrundstrukturen oder variierender Beleuchtung kann das Schwellwertverfahren ungenaue Ergebnisse liefern.
• Abhängigkeit von der Auswahl des Schwellwerts: Die Qualität der Segmentierung hängt stark von der Wahl des Schwellwerts ab. Eine falsche Wahl kann zu Fehlsegmentierungen führen.
• Ungeeignet für mehrdeutige Segmente: Das Verfahren ist nicht gut geeignet, wenn es viele ähnliche Grauwerte oder Farbwerte im Bild gibt.
• Farbabhängigkeit: Für farbige Bilder muss das Verfahren auf jeden Farbkanal angewendet werden, was die Segmentierung erschweren kann.

Insgesamt ist das Schwellwertverfahren eine nützliche Technik für einfache Segmentierungsaufgaben, bei denen der Kontrast zwischen Objekt und Hintergrund deutlich ist. Für komplexere Aufgaben können jedoch fortgeschrittenere Methoden erforderlich sein.

b)

Implementiere das Regionenwachstumsverfahren in Python. Der Algorithmus soll mit einem Seed-Pixel starten und durch Hinzufügen angrenzender Pixel mit ähnlichen Eigenschaften wachsen. Beschreibe außerdem die benötigten Parameter und wie man geeignete Werte für diese wählt.

import numpy as npimport cv2# Beispielcode initialisierendef region_growing(img, seed, threshold):    # not_empty ist eine Liste zur Überprüfung von besuchten Pixeln    not_empty = [seed]    # Resultatbild initialisieren    result = np.zeros_like(img)    # Region-Growing-Algorithmus implementieren    # Dein Code hier    return result# Beispielaufrufimg = cv2.imread('bild.jpg', 0)seed = (100, 100)  # Beispielkoordinatethreshold = 10result_img = region_growing(img, seed, threshold)cv2.imshow('Segmentiertes Bild', result_img)cv2.waitKey(0)cv2.destroyAllWindows()

Lösung:

Implementierung des Regionenwachstumsverfahrens in Python

Im Folgenden findest Du den vollständigen Python-Code für die Implementierung des Regionenwachstumsverfahrens. Der Algorithmus beginnt mit einem Seed-Pixel und erweitert die Region durch Hinzufügen von benachbarten Pixeln mit ähnlichen Eigenschaften. Außerdem beschreibe ich die benötigten Parameter und wie man geeignete Werte für diese wählt:

import numpy as npimport cv2# Regionenwachstumsalgorithmus implementierendef region_growing(img, seed, threshold):    # Zu prüfende Pixel initialisieren    to_be_checked = [seed]    # Resultatbild initialisieren    result = np.zeros_like(img)    # Pixeldimensionen speichern    height, width = img.shape    # Helligkeit des Seed-Pixels speichern    seed_intensity = img[seed]    # Bewegungsrichtungen für 4-neighborhood (oben, unten, links, rechts)    directions = [(-1, 0), (1, 0), (0, -1), (0, 1)]        while to_be_checked:        # Nächstes Pixel prüfen        x, y = to_be_checked.pop(0)        # Setze das Pixel im Resultierenbild        result[x, y] = 255        # Gehe durch alle möglichen Bewegungsrichtungen        for dx, dy in directions:            nx, ny = x + dx, y + dy            # Überprüfen, ob das neue Pixel innerhalb des Bildrahmens liegt            if 0 <= nx < height and 0 <= ny < width:                # Überprüfen, ob das Pixel bereits überprüft wurde                if result[nx, ny] == 0:                    # Intensität überprüfen                    intensity_diff = abs(int(seed_intensity) - int(img[nx, ny]))                    if intensity_diff <= threshold:                        to_be_checked.append((nx, ny))                        result[nx, ny] = 255    return result# Beispielaufrufimg = cv2.imread('bild.jpg', 0)seed = (100, 100)  # Beispielkoordinatethreshold = 10result_img = region_growing(img, seed, threshold)cv2.imshow('Segmentiertes Bild', result_img)cv2.waitKey(0)cv2.destroyAllWindows()

Benötigte Parameter und ihre Auswahl

• Seed-Pixel (seed): Die Startkoordinate für das Regionenwachstum. Diese sollte sich innerhalb des gewünschten Objektes befinden. Eine manuelle Auswahl oder automatische Vordefinition kann erfolgen, je nach Anwendung.
• Schwellenwert (threshold): Der Maximalunterschied der Helligkeit zwischen benachbarten Pixeln, damit diese zur selben Region gehören. Dieser Wert hängt von der Intensitätsvarianz des Objektes und Hintergrundes ab. Er muss experimentell bestimmt werden und kann durch Testen optimiert werden.

Tipps zur Auswahl der Parameter:

• Wähle den Seed-Pixel innerhalb des relevanten Bereichs/Objekts.
• Beginne mit einem niedrigen Schwellenwert und erhöhe diesen schrittweise, falls die Segmentierung zu klein ist oder das Objekt nicht vollständig abgedeckt wird.

d)

Beschreibe die Verwendung von Graph-basierten Methoden zur Bildsegmentierung. In welchem Zusammenhang steht der 'Minimum Cut' Algorithmus mit dieser Methode? Zeige anhand eines Beispiels auf, wie der 'Minimum Cut' Algorithmus angewendet wird.

Lösung:

Graph-basierte Methoden zur Bildsegmentierung

Graph-basierte Methoden sind leistungsstarke Techniken zur Bildsegmentierung. Diese Methoden modellieren das Bild als Graphen, wobei die Pixel als Knoten und deren Verbindungen als Kanten dargestellt werden. Die Kantengewichte repräsentieren die Ähnlichkeit oder Unähnlichkeit benachbarter Pixel.

Funktionsweise

In einem graph-basierten Ansatz wird das Bild in einen ungerichteten Graphen \( G = (V, E) \) überführt:

• \( V \) sind die Knoten, die den Pixeln im Bild entsprechen.
• \( E \) sind die Kanten, die die Nachbarschaftsbeziehungen zwischen den Pixeln darstellen.
• \( W(x,y) \) ist das Gewicht der Kante zwischen den Knoten \( x \) und \( y \) und repräsentiert die Ähnlichkeit zwischen den Pixeln.

Das Ziel ist es, den Graphen in verschiedene Segmente zu zerlegen, sodass die Ähnlichkeit innerhalb eines Segments maximiert und die Ähnlichkeit zwischen Segmenten minimiert wird.

Minimum Cut Algorithmus

Der 'Minimum Cut' Algorithmus ist ein Standardverfahren in der Graphentheorie und wird oft für die Bildsegmentierung verwendet. Dieser Algorithmus teilt den Graphen in zwei disjunkte Teile (Segmente) durch das Schneiden (entfernen) von Kanten, so dass die Summe der Gewichte der geschnittenen Kanten minimiert wird.

Mathematisch formuliert, für einen Graphen \( G = (V, E) \) mit Schnitt \( C \), wird das Minimum Cut Problem gelöst durch:

• \( \text{min-cut}(G) = \text{argmin} \sum_{(x,y) \in C} w(x,y) \)

Beispiel: Anwendung des 'Minimum Cut' Algorithmus

Betrachten wir ein einfaches Beispielfall, um die Anwendung des 'Minimum Cut' Algorithmus zu erläutern.

Stellen wir uns ein Bild vor, das in Schwarz-Weiß gehalten ist, mit einem horizontalen Übergang von schwarzem zu weißem Bereich. Dies modellieren wir als einen Graphen mit Knoten für jedes Pixel und Kanten zwischen benachbarten Pixeln.

• Die Kanten zwischen verschiedenen Farbbereichen (Schwarz und Weiß) haben hohe Gewichte.
• Kanten innerhalb des gleichen Farbbereichs (Schwarz-Schwarz oder Weiß-Weiß) haben niedrige Gewichte.

Schritte

• 1. Konstruktion des Graphen: Verknüpfe alle benachbarten Pixel mit Kanten, basierend auf ihren Helligkeitswerten.
• 2. Gewichtung der Kanten: Setze hohe Gewichte für große Unterschiede in den Helligkeitswerten und niedrige Gewichte für geringe Unterschiede.
• 3. Minimum Cut Berechnung: Führe den Minimum Cut Algorithmus aus, um die Kante oder Kanten zu finden, deren Entfernung die geringste Summe der Gewichte hat.
• 4. Segmentierung: Der Graph wird in zwei Teile geteilt, die durch den Minimum Cut entstanden sind. Diese Teile stellen die verschiedenen Segmente des ursprünglichen Bildes dar (z.B. Schwarz und Weiß).

Dies ist eine sehr vereinfachte Darlegung. In der Praxis werden fortgeschrittenere Techniken, wie der 'Normalized Cut', verwendet, die die Unterteilung des Graphen weiter verfeinern und robustere Segmente liefern.

Zusammenfassung

• Graph-basierte Methoden modellieren ein Bild als Graphen mit Knoten und Kanten, die die Ähnlichkeit zwischen den Pixeln darstellen.
• Der 'Minimum Cut' Algorithmus wird verwendet, um den Graphen in Segmente zu teilen, indem Kanten mit minimalen Gewichtssummen geschnitten werden.
• Ein Beispiel illustriert die Anwendung des Algorithmus zur Segmentierung eines Schwarz-Weiß-Bildes.

Aufgabe 3)

Du arbeitest an einem Projekt, das die Extrahierung relevanter Merkmale aus Bilddaten zur Beschreibung von Objekten umfasst. Ziel ist es, die Datenmenge zu reduzieren und dennoch die relevanten Informationen beizubehalten. Dafür sollen verschiedene Methoden der Feature-Extraktion und Deskriptoren angewandt werden. Die wichtigsten Methoden der Feature-Extraktion umfassen Kanten- und Eckendetektion wie z.B. Canny oder Harris und Texturmerkmale wie Gabor-Filter. Zu den wichtigsten Deskriptoren zählen SIFT (Scale-Invariant Feature Transform), SURF (Speeded Up Robust Features) und ORB (Oriented FAST and Rotated BRIEF). Insbesondere soll der SIFT-Deskriptor genauer betrachtet werden, welcher durch ein 128-dimensionales Histogramm von Gradientenorientierungen in 4x4 Pixelblöcken beschrieben wird. Diese Methoden sind wichtig für Anwendungen wie Objekt- und Szenenerkennung, Bildregistrierung und Bewegungsverfolgung.

c)

Vergleiche SIFT mit SURF und ORB in Bezug auf ihre Vor- und Nachteile. Gehe auf die theoretischen Grundlagen, die Rechenzeiten und die Genauigkeit ein. Welche Praktiken würdest Du in welcher realen Anwendungssituation einsetzen und warum?

Lösung:

Vergleich von SIFT, SURF und ORB

In der Feature-Extraktion sind SIFT, SURF und ORB drei der gängigsten Methoden. Jede dieser Methoden hat ihre eigenen Vor- und Nachteile in Bezug auf theoretische Grundlagen, Rechenzeiten und Genauigkeit. Hier ist ein Vergleich, der diese Aspekte beleuchtet und typische Anwendungen für jede Methode vorschlägt:

• SIFT (Scale-Invariant Feature Transform)

  Theoretische Grundlagen: SIFT ist skalen- und rotationsinvariant. Es verwendet eine Difference of Gaussian (DoG)-Darstellung, um Merkmale in verschiedenen Skalen zu finden und Gradientenhistogramme zur Beschreibung dieser Merkmale.

  Rechenzeiten: SIFT ist bekannt für seine Rechenintensität und benötigt daher vergleichsweise viel Zeit und Ressourcen, um die Merkmale zu extrahieren und zu beschreiben.

  Genauigkeit: SIFT bietet sehr genaue und robuste Merkmale, die auch unter Beleuchtungs- und Betrachtungsveränderungen gut funktionieren.

  Typische Anwendungen: SIFT ist ideal für Anwendungen, bei denen Genauigkeit und Robustheit wichtig sind, wie z.B. Bildregistrierung, 3D-Rekonstruktion und Objektverfolgung in unstrukturierten Umgebungen.

• SURF (Speeded Up Robust Features)

  Theoretische Grundlagen: SURF wurde entwickelt, um die Rechenzeit im Vergleich zu SIFT zu reduzieren. Es basiert auf einer approximierten Hessian-Matrix und verwendet Haarwellenfilter für die Integralbilddarstellung.

  Rechenzeiten: SURF ist schneller als SIFT, da es weniger Rechenressourcen benötigt. Es führt die Merkmalsextraktion und -beschreibung effizienter durch.

  Genauigkeit: SURF ist ebenfalls skalen- und rotationsinvariant, aber es kann unter extremen Beleuchtungsänderungen und Verdeckungen weniger robust sein als SIFT.

  Typische Anwendungen: SURF ist eine gute Wahl für Echtzeitanwendungen, wie z.B. robotische Navigation oder Bildverfolgung, bei denen eine Balance zwischen Geschwindigkeit und Genauigkeit erforderlich ist.

• ORB (Oriented FAST and Rotated BRIEF)

  Theoretische Grundlagen: ORB kombiniert die FAST-Eckendetektion mit BRIEF-Deskriptoren, die rotiert und skaliert werden können. Es ist primär darauf ausgelegt, die Effizienz und Geschwindigkeit zu maximieren.

  Rechenzeiten: ORB ist sehr schnell und ressourcenschonend, weshalb es besonders für mobile und eingebettete Systeme geeignet ist.

  Genauigkeit: Obwohl ORB im Vergleich zu SIFT und SURF weniger genau ist, bietet es dennoch eine gute Performanz und ist robust gegenüber einfachen Rotationen und Maßstabsänderungen.

  Typische Anwendungen: ORB eignet sich für Anwendungen auf mobilen Geräten und in Echtzeit, wie z.B. Augmented Reality, wo Geschwindigkeit und Effizienz wichtiger sind als die höchste Genauigkeit.

Empfohlene Praktiken für reale Anwendungssituationen

• SIFT: Verwende SIFT für hochpräzise Aufgaben wie Szenen- und Objekterkennung unter komplexen Bedingungen. Ideal, wenn Rechenzeit und Ressourcen weniger kritisch sind oder wenn eine hohe Genauigkeit und Robustheit erforderlich sind.
• SURF: Setze SURF in Echtzeitanwendungen ein, bei denen ein Kompromiss zwischen Geschwindigkeit und Genauigkeit akzeptabel ist. Geeignet für robotische Navigation, interaktive Systeme und schnelle Verfolgungsalgorithmen.
• ORB: Nutze ORB in mobilen Anwendungen und eingebetteten Systemen, wo begrenzte Rechenressourcen und schnelles Feedback erforderlich sind. Optimal für Augmented Reality, Echtzeit-Tracking und Anwendungen mit eingeschränkter Hardware.

Insgesamt hängt die Wahl der Methode stark von der spezifischen Anwendung ab und davon, welche Kompromisse zwischen Genauigkeit, Rechenzeit und Robustheit sinnvoll sind.

Aufgabe 4)

Objekterkennung mit neuronalen NetzwerkenErkennung und Klassifizierung von Objekten in Bildern durch den Einsatz von tiefen neuronalen Netzwerken. Convolutional Neural Networks (CNNs) sind die standardmäßige Architektur. Die Datenvorverarbeitung schließt Normalisierung und Datenaugmentation ein. Typische Layer-Typen umfassen Convolutional Layer, Pooling Layer und Fully Connected Layer. Gängige Aktivierungsfunktionen sind ReLU und Softmax. Bei der Klassifizierung wird oft die Cross-Entropy Loss als Verlustfunktion genutzt. Zur Optimierung werden oft Stochastic Gradient Descent (SGD) und Adam-Optimizer verwendet. Die Bewertung der Modelle erfolgt über Metriken wie Genauigkeit, Precision, Recall und F1-Score.

a)

(a) Erkläre, wie Datenvorverarbeitung (Normalisierung und Datenaugmentation) das Training eines CNNs beeinflusst. Nutze dazu sowohl qualitative Beschreibungen als auch mathematische Formeln, wenn es angebracht ist.

Lösung:

• Datenvorverarbeitung: Die Datenvorverarbeitung ist ein entscheidender Schritt beim Training eines Convolutional Neural Networks (CNN). Sie umfasst hauptsächlich zwei Techniken: Normalisierung und Datenaugmentation. Diese Techniken verbessern die Leistung und die Robustheit des Modells erheblich.
• Normalisierung: Normalisierung skaliert die Pixelwerte der Bilder auf einen bestimmten Bereich, typischerweise zwischen 0 und 1 oder -1 und 1. Dies trägt dazu bei, die numerischen Werte zu vereinheitlichen und die Konvergenz während des Trainings zu verbessern. Die Normalisierung kann folgendermaßen mathematisch ausgedrückt werden:
• Für einen Pixelwert x in einem Bild:
• \( \tilde{x} = \frac{x - \text{Min}}{\text{Max} - \text{Min}} \)
• Hierbei ist Min der minimale Pixelwert (z.B. 0) und Max der maximale Pixelwert (z.B. 255).
• Alternativ kann auch die Z-Score-Normalisierung verwendet werden, die wie folgt definiert ist:
• \( \tilde{x} = \frac{x - \text{mean}}{\text{std}} \)
• Hierbei ist mean der Mittelwert und std die Standardabweichung der Pixelwerte im Datensatz.
• Datenaugmentation: Datenaugmentation erhöht künstlich die Größe des Trainingsdatensatzes durch Anwendung verschiedener Transformationen auf die Originalbilder. Diese Transformationen umfassen Rotation, Verschiebung, Skalierung, Spiegelung und Zufallsausschnitte. Der Zweck der Datenaugmentation ist es, das Modell robuster gegenüber Variationen in den Eingabedaten zu machen und Overfitting zu vermeiden. Zu den gängigen Datenaugmentationsmethoden gehören:
• Rotation \(\theta\):
• \( x_{neu} = x \cdot \cos(\theta) - y \cdot \sin(\theta) \)
• \( y_{neu} = x \cdot \sin(\theta) + y \cdot \cos(\theta) \)
• Verschiebung (\text{tx}, \text{ty}):
• \( x_{neu} = x + \text{tx} \)
• \( y_{neu} = y + \text{ty} \)
• Skalierung (\text{sx}, \text{sy}):
• \( x_{neu} = x \cdot \text{sx} \)
• \( y_{neu} = y \cdot \text{sy} \)
• Durch die Nutzung von Normalisierung und Datenaugmentation wird das CNN besser in der Lage sein, Invarianzen und Variabilitäten in den Eingabedaten zu lernen. Dies führt zu einer besseren Generalisierung und höherer Genauigkeit des Modells auf neuen, ungesehenen Daten.

b)

(b) Implementiere eine Convolutional Neural Network (CNN) Architektur in Python unter Nutzung von Keras/TensorFlow. Definiere dabei folgende Layer: Convolutional Layer, Pooling Layer und Fully Connected Layer. Verwende ReLU als Aktivierungsfunktion und Cross-Entropy als Verlustfunktion. Optimiere das Modell mit dem Adam-Optimizer.

'from tensorflow.keras.models import Sequentialfrom tensorflow.keras.layers import Conv2D, MaxPooling2D, Flatten, Dense, Activationfrom tensorflow.keras.optimizers import Adam# Modell initialisierenmodel = Sequential()# Convolutional Layermodel.add(Conv2D(32, (3, 3), input_shape=(64, 64, 3)))model.add(Activation('relu'))model.add(MaxPooling2D(pool_size=(2, 2)))# Weitere Convolutional und Pooling Layermodel.add(Conv2D(64, (3, 3)))model.add(Activation('relu'))model.add(MaxPooling2D(pool_size=(2, 2)))# Flatten Layermodel.add(Flatten())# Fully Connected Layermodel.add(Dense(128))model.add(Activation('relu'))# Output Layermodel.add(Dense(10))model.add(Activation('softmax'))# Modell kompilierenmodel.compile(optimizer=Adam(), loss='categorical_crossentropy', metrics=['accuracy'])# Modell anzeigenmodel.summary()'

Lösung:

• Objekterkennung mit neuronalen Netzwerken: Erkennung und Klassifizierung von Objekten in Bildern durch den Einsatz von tiefen neuronalen Netzwerken. Convolutional Neural Networks (CNNs) sind die standardmäßige Architektur. Die Datenvorverarbeitung schließt Normalisierung und Datenaugmentation ein. Typische Layer-Typen umfassen Convolutional Layer, Pooling Layer und Fully Connected Layer. Gängige Aktivierungsfunktionen sind ReLU und Softmax. Bei der Klassifizierung wird oft die Cross-Entropy Loss als Verlustfunktion genutzt. Zur Optimierung werden oft Stochastic Gradient Descent (SGD) und Adam-Optimizer verwendet. Die Bewertung der Modelle erfolgt über Metriken wie Genauigkeit, Precision, Recall und F1-Score.
• (b) Implementiere eine Convolutional Neural Network (CNN) Architektur in Python unter Nutzung von Keras/TensorFlow. Definiere dabei folgende Layer: Convolutional Layer, Pooling Layer und Fully Connected Layer. Verwende ReLU als Aktivierungsfunktion und Cross-Entropy als Verlustfunktion. Optimiere das Modell mit dem Adam-Optimizer.

'from tensorflow.keras.models import Sequentialfrom tensorflow.keras.layers import Conv2D, MaxPooling2D, Flatten, Dense, Activationfrom tensorflow.keras.optimizers import Adam# Modell initialisierenmodel = Sequential()# Convolutional Layermodel.add(Conv2D(32, (3, 3), input_shape=(64, 64, 3)))model.add(Activation('relu'))model.add(MaxPooling2D(pool_size=(2, 2)))# Weitere Convolutional und Pooling Layermodel.add(Conv2D(64, (3, 3)))model.add(Activation('relu'))model.add(MaxPooling2D(pool_size=(2, 2)))# Flatten Layermodel.add(Flatten())# Fully Connected Layermodel.add(Dense(128))model.add(Activation('relu'))# Output Layermodel.add(Dense(10))model.add(Activation('softmax'))# Modell kompilierenmodel.compile(optimizer=Adam(), loss='categorical_crossentropy', metrics=['accuracy'])# Modell anzeigenmodel.summary()'