Whatsapp Telegram Telegram Call Anrufen
Ajjoub Development Logo

Computer Vision mit TensorFlow


1. Einführung in Computer Vision

Computer Vision ist ein Bereich des maschinellen Lernens und der künstlichen Intelligenz, der sich mit der automatischen Extraktion, Analyse und Interpretation nützlicher Informationen aus digitalen Bildern oder Videos beschäftigt. Es umfasst verschiedene Aufgaben wie Bildklassifikation, Objekterkennung und Bildsegmentierung.

2. Bildklassifikation (Image Classification)

Bildklassifikation ist die Aufgabe, ein Bild einer oder mehreren vordefinierten Klassen zuzuordnen. Dies ist eine grundlegende Aufgabe in der Computer Vision und bildet die Grundlage für viele weiterführende Anwendungen.

Beispiel: Bildklassifikation mit TensorFlow
import tensorflow as tf
from tensorflow.keras import layers, models
from tensorflow.keras.datasets import cifar10

# Laden des CIFAR-10-Datensatzes
(x_train, y_train), (x_test, y_test) = cifar10.load_data()

# Normalisierung der Bilddaten
x_train, x_test = x_train / 255.0, x_test / 255.0

# Aufbau des Modells
model = models.Sequential([
    layers.Conv2D(32, (3, 3), activation='relu', input_shape=(32, 32, 3)),
    layers.MaxPooling2D((2, 2)),
    layers.Conv2D(64, (3, 3), activation='relu'),
    layers.MaxPooling2D((2, 2)),
    layers.Conv2D(64, (3, 3), activation='relu'),
    layers.Flatten(),
    layers.Dense(64, activation='relu'),
    layers.Dense(10, activation='softmax')
])

# Kompilieren des Modells
model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])

# Trainieren des Modells
model.fit(x_train, y_train, epochs=10, validation_data=(x_test, y_test))

# Evaluieren des Modells
test_loss, test_acc = model.evaluate(x_test, y_test)
print(f'Test accuracy: {test_acc}')


In diesem Beispiel verwenden wir den CIFAR-10-Datensatz, der aus 60.000 32x32 Farbbildern in 10 Klassen besteht. Das Modell besteht aus mehreren Faltungsschichten (Convolutional Layers), Max-Pooling-Schichten und vollständig verbundenen Schichten (Fully Connected Layers).

3. Objekterkennung (Object Detection)

Die Objekterkennung geht einen Schritt weiter als die Bildklassifikation, indem sie nicht nur die Klasse eines Objekts im Bild identifiziert, sondern auch dessen Position lokalisiert. Dies wird oft durch umgebende Begrenzungsrahmen (Bounding Boxes) dargestellt.

Beispiel: Objekterkennung mit TensorFlow und YOLO
YOLO (You Only Look Once) ist ein bekanntes Modell zur Echtzeit-Objekterkennung.

import tensorflow as tf
import cv2
import numpy as np

# Laden des vortrainierten YOLO-Modells und der COCO-Klassen
net = cv2.dnn.readNet("yolov3.weights", "yolov3.cfg")
layer_names = net.getLayerNames()
output_layers = [layer_names[i - 1] for i in net.getUnconnectedOutLayers()]

classes = []
with open("coco.names", "r") as f:
    classes = [line.strip() for line in f.readlines()]

# Laden und Vorverarbeiten eines Bildes
image = cv2.imread("image.jpg")
height, width, channels = image.shape
blob = cv2.dnn.blobFromImage(image, 0.00392, (416, 416), (0, 0, 0), True, crop=False)
net.setInput(blob)
outs = net.forward(output_layers)

# Verarbeitung der Ausgaben
class_ids = []
confidences = []
boxes = []

for out in outs:
    for detection in out:
        scores = detection[5:]
        class_id = np.argmax(scores)
        confidence = scores[class_id]
        if confidence > 0.5:
            center_x = int(detection[0] * width)
            center_y = int(detection[1] * height)
            w = int(detection[2] * width)
            h = int(detection[3] * height)
            x = int(center_x - w / 2)
            y = int(center_y - h / 2)
            boxes.append([x, y, w, h])
            confidences.append(float(confidence))
            class_ids.append(class_id)

# Zeichnen der Bounding Boxes
for i in range(len(boxes)):
    x, y, w, h = boxes[i]
    label = str(classes[class_ids[i]])
    cv2.rectangle(image, (x, y), (x + w, y + h), (0, 255, 0), 2)
    cv2.putText(image, label, (x, y - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2)

# Anzeigen des Ergebnisses
cv2.imshow("Image", image)
cv2.waitKey(0)
cv2.destroyAllWindows()


In diesem Beispiel verwenden wir das vortrainierte YOLOv3-Modell zur Erkennung von Objekten in einem Bild. Das Modell identifiziert die Objekte und zeichnet Bounding Boxes um sie herum.


4. Bildsegmentierung (Image Segmentation)

Die Bildsegmentierung teilt ein Bild in mehrere Segmente auf, um die Struktur des Bildes besser zu verstehen. Jeder Pixel des Bildes wird einer Klasse zugeordnet. Zu den gängigen Anwendungen gehören die medizinische Bildverarbeitung und autonomes Fahren.

Der U-Net-Modell ist eine spezielle Art von neuronalen Netzwerken, die vor allem für Bildsegmentierungsaufgaben entwickelt wurde. Das Modell wurde erstmals 2015 von Olaf Ronneberger, Philipp Fischer und Thomas Brox in ihrem Paper "U-Net: Convolutional Networks for Biomedical Image Segmentation" vorgestellt. Der U-Net-Architektur verdankt ihren Namen der charakteristischen U-Form.

U-net architecture (example for 32x32 pixels in the lowest resolution)



Hier sind die Hauptmerkmale und Komponenten des U-Net-Modells:

  1. Encoder-Teil: Der Encoder, auch als kontraktiver Pfad bezeichnet, besteht aus einer Reihe von Convolutional Layers, gefolgt von Max-Pooling-Schichten. Dieser Teil des Netzwerks extrahiert zunehmend abstrakte Merkmale aus dem Bild und reduziert dabei die räumliche Auflösung.

  2. Bottleneck: Dies ist der tiefste Punkt der U-Net-Architektur, wo die Merkmalsdarstellung des Bildes am abstraktesten ist. Hier werden die Informationen stark verdichtet.

  3. Decoder-Teil: Der Decoder, auch als expansiver Pfad bezeichnet, besteht aus einer Reihe von Up-Convolutions (auch Transposed Convolutions genannt) und Convolutional Layers. Dieser Teil des Netzwerks erhöht die räumliche Auflösung der Merkmalskarten wieder und rekonstruiert das Bildsegment.

  4. Skip-Verbindungen: Eine der Schlüsselinnovationen des U-Net ist die Verwendung von Skip-Verbindungen. Diese Verbindungen überspringen mehrere Schichten und verbinden den Encoder direkt mit dem Decoder. Sie helfen dabei, detaillierte Informationen von den hohen Auflösungsschichten des Encoders zu den entsprechenden Schichten des Decoders zu übertragen, was die Segmentierungsergebnisse erheblich verbessert.

  5. Loss-Funktion: Für die Bildsegmentierung wird häufig der Dice-Koeffizient oder der Cross-Entropy-Loss verwendet, um die Genauigkeit der Segmentierung zu maximieren.

Das U-Net-Modell wird häufig in der biomedizinischen Bildverarbeitung verwendet, insbesondere für Aufgaben wie Zellsegmentierung in Mikroskopbildern, da es in der Lage ist, genaue und feinkörnige Segmentierungen zu liefern. Durch seine Architektur kann das U-Net-Modell sowohl globale als auch lokale Informationen effektiv verarbeiten und liefert daher sehr präzise Segmentierungsergebnisse.


Beispiel: Bildsegmentierung mit TensorFlow und U-Net

U-Net ist ein beliebtes Modell für die Bildsegmentierung, insbesondere in der biomedizinischen Bildverarbeitung.


import tensorflow as tf
from tensorflow.keras import layers, models

# Aufbau des U-Net-Modells
def unet_model(input_size=(128, 128, 1)):
    inputs = layers.Input(input_size)
    conv1 = layers.Conv2D(64, (3, 3), activation='relu', padding='same')(inputs)
    conv1 = layers.Conv2D(64, (3, 3), activation='relu', padding='same')(conv1)
    pool1 = layers.MaxPooling2D(pool_size=(2, 2))(conv1)

    conv2 = layers.Conv2D(128, (3, 3), activation='relu', padding='same')(pool1)
    conv2 = layers.Conv2D(128, (3, 3), activation='relu', padding='same')(conv2)
    pool2 = layers.MaxPooling2D(pool_size=(2, 2))(conv2)

    conv3 = layers.Conv2D(256, (3, 3), activation='relu', padding='same')(pool2)
    conv3 = layers.Conv2D(256, (3, 3), activation='relu', padding='same')(conv3)
    pool3 = layers.MaxPooling2D(pool_size=(2, 2))(conv3)

    conv4 = layers.Conv2D(512, (3, 3), activation='relu', padding='same')(pool3)
    conv4 = layers.Conv2D(512, (3, 3), activation='relu', padding='same')(conv4)
    drop4 = layers.Dropout(0.5)(conv4)
    pool4 = layers.MaxPooling2D(pool_size=(2, 2))(drop4)

    conv5 = layers.Conv2D(1024, (3, 3), activation='relu', padding='same')(pool4)
    conv5 = layers.Conv2D(1024, (3, 3), activation='relu', padding='same')(conv5)
    drop5 = layers.Dropout(0.5)(conv5)

    up6 = layers.Conv2D(512, (2, 2), activation='relu', padding='same')(layers.UpSampling2D(size=(2, 2))(drop5))
    merge6 = layers.concatenate([drop4, up6], axis=3)
    conv6 = layers.Conv2D(512, (3, 3), activation='relu', padding='same')(merge6)
    conv6 = layers.Conv2D(512, (3, 3), activation='relu', padding='same')(conv6)

    up7 = layers.Conv2D(256, (2, 2), activation='relu', padding='same')(layers.UpSampling2D(size=(2, 2))(conv6))
    merge7 = layers.concatenate([conv3, up7], axis=3)
    conv7 = layers.Conv2D(256, (3, 3), activation='relu', padding='same')(merge7)
    conv7 = layers.Conv2D(256, (3, 3), activation='relu', padding='same')(conv7)

    up8 = layers.Conv2D(128, (2, 2), activation='relu', padding='same')(layers.UpSampling2D(size=(2, 2))(conv7))
    merge8 = layers.concatenate([conv2, up8], axis=3)
    conv8 = layers.Conv2D(128, (3, 3), activation='relu', padding='same')(merge8)
    conv8 = layers.Conv2D(128, (3, 3), activation='relu', padding='same')(conv8)

    up9 = layers.Conv2D(64, (2, 2), activation='relu', padding='same')(layers.UpSampling2D(size=(2, 2))(conv8))
    merge9 = layers.concatenate([conv1, up9], axis=3)
    conv9 = layers.Conv2D(64, (3, 3), activation='relu', padding='same')(merge9)
    conv9 = layers.Conv2D(64, (3, 3), activation='relu', padding='same')(conv9)
    conv9 = layers.Conv2D(2, (3, 3), activation='relu', padding='same')(conv9)
    conv10 = layers.Conv2D(1, (1, 1), activation='sigmoid')(conv9)

    model = models.Model(inputs=inputs, outputs=conv10)
    return model

model = unet_model()
model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])

# Anzeigen der Modellzusammenfassung
model.summary()

# Annehmen, dass x_train und y_train bereits vorverarbeitet und geladen sind
# x_train: Eingabebilder
# y_train: Segmentierungsmasken

# Trainieren des Modells
model.fit(x_train, y_train, epochs=10, batch_size=8, validation_split=0.1)


In diesem Beispiel erstellen wir ein U-Net-Modell für die Bildsegmentierung. Das Modell besteht aus mehreren Faltungs- und Max-Pooling-Schichten, gefolgt von Aufwärtsabtastungen (UpSampling) und Verkettungen (Concatenations), um die Segmentierung zu erzeugen.



Mit diesen detaillierten Erklärungen und Beispielen können Sie die Grundlagen der Computer Vision verstehen und lernen, wie Sie Aufgaben wie Bildklassifikation, Objekterkennung und Bildsegmentierung in TensorFlow implementieren. Computer Vision ist ein leistungsfähiges Werkzeug zur Verarbeitung und Analyse visueller Daten und bietet viele Anwendungsmöglichkeiten in verschiedenen Bereichen.

CEO Image

Ali Ajjoub

info@ajjoub.com

Adresse 0049-15773651670

Adresse Jacob-winter-platz,1 01239 Dresden

Buchen Sie jetzt Ihren Termin für eine umfassende und individuelle Beratung.

Termin Buchen

Kontaktieren Sie uns

Lassen Sie uns K o n t a k t aufnehmen!