So erstellen Sie in wenigen Minuten eine vollständige Computer-Vision-Anwendung mit nur zwei Python-Funktionen

Übersetzer |. Li Rui

Rezensent |. Chonglou

In diesem Artikel werden zunächst kurz die grundlegenden Anforderungen von Computer-Vision-Anwendungen vorgestellt. Anschließend wird Pipeless, ein Open-Source-Framework, ausführlich vorgestellt, das eine serverlose Entwicklungserfahrung für Embedded Computer Vision bietet. Abschließend wird eine detaillierte Schritt-für-Schritt-Anleitung bereitgestellt, die zeigt, wie Sie mithilfe einiger Python-Funktionen und eines Modells eine einfache Objekterkennungsanwendung erstellen und ausführen.

Erstellen Sie Computer Vision-Anwendungen

Eine Möglichkeit, „Computer Vision“ zu beschreiben, besteht darin, es als „den Bereich der Bilderkennung und -verarbeitung, der Kameras und algorithmische Techniken nutzt“ zu definieren. Diese einfache Definition befriedigt jedoch möglicherweise nicht vollständig das Verständnis der Menschen für das Konzept. Um ein tieferes Verständnis des Prozesses der Erstellung von Computer-Vision-Anwendungen zu erlangen, müssen wir daher die Funktionalität berücksichtigen, die jedes Subsystem implementieren muss. Der Prozess der Erstellung von Computer-Vision-Anwendungen umfasst mehrere wichtige Schritte, darunter Bilderfassung, Bildverarbeitung, Merkmalsextraktion, Objekterkennung und Entscheidungsfindung. Zunächst werden Bilddaten über eine Kamera oder ein anderes Bilderfassungsgerät erfasst. Die Bilder werden dann mithilfe von Algorithmen verarbeitet, einschließlich Vorgängen wie Rauschunterdrückung, Verbesserung und Segmentierung zur weiteren Analyse. Während der Merkmalsextraktionsphase identifiziert das System wichtige Merkmale im Bild, wie z. B.

Um einen 60-fps-Videostream in Echtzeit zu verarbeiten, muss jedes Bild innerhalb von 16 Millisekunden verarbeitet werden. Dies wird normalerweise durch Multithreading und Multi-Processing erreicht. Manchmal ist es sogar notwendig, mit der Verarbeitung des nächsten Frames zu beginnen, bevor der vorherige abgeschlossen ist, um eine wirklich schnelle Frame-Verarbeitung zu gewährleisten.

Für Modelle der künstlichen Intelligenz stehen mittlerweile glücklicherweise viele hervorragende Open-Source-Modelle zur Verfügung, so dass es in den meisten Fällen nicht nötig ist, ein eigenes Modell von Grund auf zu entwickeln, sondern lediglich die Parameter fein abzustimmen, um den spezifischen Anwendungsfall zu erfüllen. Diese Modelle führen in jedem Frame eine Inferenz durch und führen Aufgaben wie Objekterkennung, Segmentierung, Posenschätzung und mehr aus.

• Inferenzlaufzeit: Die Inferenzlaufzeit ist dafür verantwortlich, das Modell zu laden und effizient auf verschiedenen verfügbaren Geräten (GPU oder CPU) auszuführen.

Um sicherzustellen, dass das Modell während des Inferenzprozesses schnell ausgeführt werden kann, ist die Verwendung einer GPU unerlässlich. GPUs können um Größenordnungen mehr parallele Operationen verarbeiten als CPUs, insbesondere wenn sie große Mengen mathematischer Operationen verarbeiten. Bei der Verarbeitung von Frames müssen Sie den Speicherort berücksichtigen, an dem sich der Frame befindet. Sie können ihn im GPU-Speicher oder im CPU-Speicher (RAM) speichern. Das Kopieren von Bildern zwischen diesen beiden Speichern kann jedoch zu langsameren Vorgängen führen, insbesondere wenn die Bildgröße groß ist. Dies bedeutet auch, dass Speicherauswahl und Datenübertragungsaufwand abgewogen werden müssen, um einen effizienteren Modellinferenzprozess zu erreichen.

Die Multimedia-Pipeline besteht aus einer Reihe von Komponenten, die einen Videostream von einer Datenquelle aufnehmen, ihn in Frames aufteilen und ihn dann als Eingabe für das Modell verwenden. Manchmal können diese Komponenten auch den Videostream für die Weiterleitung modifizieren und rekonstruieren. Diese Komponenten spielen eine Schlüsselrolle bei der Verarbeitung von Videodaten und stellen sicher, dass der Videostream effizient übertragen und verarbeitet werden kann.

• Videostream-Verwaltung: Entwickler möchten möglicherweise, dass Anwendungen Unterbrechungen von Videostreams und Wiederverbindungen widerstehen, Videostreams dynamisch hinzufügen und entfernen, mehrere Videostreams gleichzeitig verarbeiten und vieles mehr können.

Alle diese Systeme müssen erstellt oder in das Projekt integriert werden, und daher muss der Code gepflegt werden. Das Problem besteht jedoch darin, dass Sie am Ende eine große Menge an Code verwalten, der nicht anwendungsspezifisch ist, sondern Subsysteme, die den eigentlichen fallspezifischen Code umgeben.

Pipeless Framework

Um nicht alles von Grund auf neu erstellen zu müssen, können Sie stattdessen das Pipeless-Framework verwenden. Hierbei handelt es sich um ein Open-Source-Framework für Computer Vision, das einige fallspezifische Funktionen ermöglicht und andere Dinge bewältigen kann.

Pipeless Framework unterteilt die Logik der Anwendung in „Stufen“, von denen eine wie eine Mikroanwendung eines einzelnen Modells ist. Eine Phase kann die Vorverarbeitung, das Ausführen von Inferenzen mithilfe der vorverarbeiteten Eingabe und die Nachverarbeitung der Modellausgabe für Maßnahmen umfassen. Sie können dann beliebig viele Schritte zu einer vollständigen Anwendung verketten, auch wenn Sie mehrere Modelle verwenden.

Um die Logik für jede Stufe bereitzustellen, fügen Sie einfach eine anwendungsspezifische Codefunktion hinzu und Pipeless kümmert sich bei Bedarf um den Aufruf. Aus diesem Grund kann Pipeless als Framework betrachtet werden, das eine serverähnliche Entwicklungserfahrung für eingebettetes Computer Vision bietet und einige Funktionen bereitstellt, ohne sich Gedanken über die Notwendigkeit zusätzlicher Subsysteme machen zu müssen.

Eine weitere großartige Funktion von Pipeless ist die Möglichkeit, die Videostream-Verarbeitung durch dynamisches Hinzufügen, Löschen und Aktualisieren von Videostreams über CLI oder REST API zu automatisieren. Sie können sogar eine Neustartrichtlinie festlegen, die angibt, wann die Verarbeitung des Videostreams neu gestartet werden soll, ob er nach einem Fehler neu gestartet werden soll usw.

Um das Pipeless-Framework schließlich bereitzustellen, installieren Sie es einfach auf einem beliebigen Gerät und führen Sie es mit Ihren Codefunktionen aus, sei es in einer virtuellen Cloud-Computing-Maschine oder im Containermodus oder direkt in einem Edge-Gerät wie Nvidia Jetson, Raspberry usw.

Erstellen einer Objekterkennungsanwendung

Hier erfahren Sie ausführlich, wie Sie mit dem Pipeless-Framework eine einfache Objekterkennungsanwendung erstellen.

Der erste Schritt ist die Installation. Das Installationsskript macht die Installation sehr einfach:

Curl https://raw.githubusercontent.com/pipeless-ai/pipeless/main/install.sh | bash

Jetzt muss ein Projekt erstellt werden. Ein Pipeless-Projekt ist ein Verzeichnis, das Phasen enthält. Jede Stufe befindet sich in einem Unterverzeichnis und in jedem Unterverzeichnis wird eine Datei mit Hooks (spezifische Codefunktionen) erstellt. Der für jeden Bühnenordner angegebene Name ist der Bühnenname, der später im Pipeless-Feld angegeben werden muss, wenn Sie diese Bühne für den Videostream ausführen möchten.

pipeless init my-project --template emptycd my-project

Hier weist die leere Vorlage die CLI an, nur das Verzeichnis zu erstellen. Wenn keine Vorlage bereitgestellt wird, fordert die CLI einige Fragen auf, um die Bühne interaktiv zu erstellen.

Wie oben erwähnt, ist es nun notwendig, dem Projekt eine Phase hinzuzufügen. Laden Sie ein Stage-Beispiel von GitHub mit dem folgenden Befehl herunter:

wget -O - https://github.com/pipeless-ai/pipeless/archive/main.tar.gz | tar -xz --strip=2 "pipeless-main/examples/onnx-yolo"

Dadurch wird ein Stage-Verzeichnis onnx-yolo erstellt, das die Anwendungsfunktionen enthält.

Überprüfen Sie dann den Inhalt jeder Stage-Datei, bei der es sich um Anwendungs-Hooks handelt.

Hier ist eine pre-process.py-Datei, die eine Funktion (Hooks) definiert, die einen Frame und eine Szene akzeptiert. Diese Funktion führt einige Vorgänge aus, um die Eingabedaten, die RGB-Frames empfangen, so vorzubereiten, dass sie dem vom Modell erwarteten Format entsprechen. Diese Daten werden zu „frame_data['interence_input']“ hinzugefügt, den Daten, die Pipeless an das Modell übergibt.

def hook(frame_data, context):frame = frame_data["original"].view()yolo_input_shape = (640, 640, 3) # h,w,cframe = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)frame = resize_rgb_frame(frame, yolo_input_shape)frame = cv2.normalize(frame, None, 0.0, 1.0, cv2.NORM_MINMAX)frame = np.transpose(frame, axes=(2,0,1)) # Convert to c,h,winference_inputs = frame.astype("float32")frame_data['inference_input'] = inference_inputs... (some other auxiliar functions that we call from the hook function)

Es gibt auch die Datei „process.json“, die angibt, welche Pipeless-Inferenzlaufzeit (in diesem Fall ONNX-Laufzeit) verwendet werden soll, wo sich das zu ladende Modell befindet und einige seiner optionalen Parameter, wie z als zu verwendender Ausführungsanbieter, d. h. CPU, CUDA, TensorRT usw.

{ "runtime": "onnx","model_uri": "https://pipeless-public.s3.eu-west-3.amazonaws.com/yolov8n.onnx","inference_params": { "execution_provider": "tensorrt" }}

Schließlich definiert die Datei post-process.py eine Funktion ähnlich der in pre-process.py. Dieses Mal akzeptiert es die Inferenzausgabe, die Pipeless in frame_data["inference_output"] speichert, und führt den Vorgang des Parsens dieser Ausgabe in einen Begrenzungsrahmen durch. Später zeichnet es den Begrenzungsrahmen auf den Rahmen und weist schließlich den geänderten Rahmen Frame_data['modified'] zu. Auf diese Weise leitet Pipeless den bereitgestellten Videostream weiter, jedoch mit geänderten Frames, einschließlich Begrenzungsrahmen.

def hook(frame_data, _):frame = frame_data['original']model_output = frame_data['inference_output']yolo_input_shape = (640, 640, 3) # h,w,cboxes, scores, class_ids =  parse_yolo_output(model_output, frame.shape, yolo_input_shape)class_labels = [yolo_classes[id] for id in class_ids]for i in range(len(boxes)):draw_bbox(frame, boxes[i], class_labels[i], scores[i])frame_data['modified'] = frame... (some other auxiliar functions that we call from the hook function)

Der letzte Schritt besteht darin, Pipeless zu starten und einen Videostream bereitzustellen. Um Pipeless zu starten, führen Sie einfach den folgenden Befehl im Verzeichnis „my-project“ aus:

pipeless start --stages-dir .

Nach der Ausführung wird der Videostream von der Webcam (v4l2) bereitgestellt und die Ausgabe direkt auf dem Bildschirm angezeigt. Es ist zu beachten, dass eine Liste der Phasen bereitgestellt werden muss, die der Videostream nacheinander ausführt. In diesem Fall ist es nur die Onnx-Yolo-Phase:

pipeless add stream --input-uri "v4l2" --output-uri "screen" --frame-path "onnx-yolo"

Fazit

Das Erstellen einer Computer-Vision-Anwendung ist eine komplexe Aufgabe, da viele Faktoren und Subsysteme um sie herum implementiert werden müssen. Mit einem Framework wie Pipeless dauert die Inbetriebnahme nur wenige Minuten, sodass Sie sich auf das Schreiben von Code für bestimmte Anwendungsfälle konzentrieren können. Darüber hinaus sind Pipeless-„Stufen“ in hohem Maße wiederverwendbar und leicht zu warten, sodass die Wartung einfach ist und sehr schnell wiederholt werden kann.

Wenn Sie an der Entwicklung von Pipeless teilnehmen möchten, können Sie dies über das GitHub-Repository tun.

Original -Titel: Erstellen Sie eine komplette Computer -Vision -App in wenigen Minuten mit nur zwei Python -Funktionen, Autor: Miguel Angel Cabrera

link: https: //m.sbmmt.com/link/E26DBB5B1843BF566EA7EC7F3333333333333333325C4