Intelligente Städte zielen darauf ab, digitale Technologien wie Big Data, das Internet der Dinge (IoT), künstliche Intelligenz und 5G zu nutzen, um das Niveau öffentlicher staatlicher Dienstleistungen und die Wirksamkeit sozialer Governance zu verbessern, das Wirtschaftswachstum zu fördern und die Vernunft der Menschen kontinuierlich zu verbessern von Gewinn, Sicherheit und Glück. Seit dem 14. Fünfjahresplan beschleunigen das Land und die Großstädte den Aufbau einer neuen Art der Smart-City-Klassifizierung und -Klassifizierung, bei der Umsetzung sind jedoch auch einige Probleme und Schwierigkeiten aufgetreten.
Bei der Implementierung der KI-Bereitstellung in Smart Cities treten häufig Probleme auf, darunter die Inkonsistenz der Edge-Geräte-Hardware, hohe plattformübergreifende Entwicklungskosten und Schwierigkeiten bei der Optimierung der Modellinferenzgeschwindigkeit . Konzentriert man sich auf die Nutzer des KI-Systems, gibt es auch viele Hindernisse bei der Umsetzung von Smart Cities. Wenn Umweltingenieure beispielsweise Daten im Freien sammeln, wollen sie Daten in Echtzeit sammeln, analysieren und speichern Sie müssen eine mit einer Grafikkarte ausgestattete Workstation mit sich führen, um ins Freie zu gehen . Gleichzeitig ist es notwendig, ein mobiles XXXXL-Netzteil mitzubringen, um das Stromversorgungsproblem zu lösen. Sein Gewicht ist zweifellos eine Überforderung für Umweltingenieure.
Um das Problem der schwierigen Entwicklung für Softwareentwickler zu lösen, demonstriert diese Lösung den AI-Workflow-Modus von FastDeploy (OpenVINO) + ein leichtes Modell und hofft, Benutzern eine leichtere, einfachere und effizientere Lösung zu bieten.
Dieses Projekt verwendet das Echtzeit-Nachrichtenübertragungsprotokoll (RTMP), das mit dem UAV-Steuerterminal geliefert wird, um das Echtzeitbild des UAV in geringer Höhe an das Inferenz-Hardwaregerät zu übertragen und die grüne Abdeckungsrate, die Gebäuderate und die Anzahl zu berechnen Die Anzahl der Fahrzeuge, die Anzahl der Personen und andere Indikatoren können durch Modellinferenz für die groß angelegte städtische Umweltüberwachung, die Fernerkundung von Land in geringer Höhe, die Straßenverkehrskontrolle und die Sicherheit von Drohnen in geringer Höhe verwendet werden .
Bei dieser Aufgabe handelt es sich um eine Echtzeit-Inferenz auf den UAV-Bilddatenfluss, die extrem hohe Anforderungen an die Inferenzgeschwindigkeit stellt. Um die Entwicklungsschwierigkeiten und Migrationskosten zu reduzieren, haben wir gleichzeitig das Intel NUC Mini-Computer-Kit mit X86-CPU-Architektur als Inferenzhardware übernommen und die FastDeploy-Inferenzbereitstellungs-Toolbox für die Software ausgewählt, um die Back- Beenden Sie die OpenVINO-Inferenz-Engine, um die KI-Modellinferenz zu beschleunigen. Darüber hinaus haben wir bei der Auswahl der KI-Modelle zwei leichte Modelle ausgewählt, Flying Paddle PP-LiteSeg und Flying Paddle PP-YOLO Tiny, um semantische Segmentierungs- und Zielerkennungsaufgaben abzuschließen.
Gesamtprojektablauf
Wie in der Abbildung oben gezeigt, muss zunächst der RTMP-Streaming-Dienst auf dem NUC eingerichtet werden und der UAV APP-Client mit dem RTMP-Server im Intranet verbunden werden, damit die Bilder des UAV an den NUC übertragen werden können Gerät über den Router in Echtzeit. Nachdem das NUC-Gerät das Bild erhalten hat, rendert es es im Anzeigefenster am Front-End von PySide. Gleichzeitig führt der FastDeploy-Thread die Argumentationsaufgaben der semantischen Segmentierung und Objekterkennung aus und rendert das Ergebnis und das visualisierte Bild in Echtzeit an die Frontscheibe.
Vorbereitung der Entwicklungsumgebung
Kernhardware und -software
Intel NUC Mini-PC-Kit
(Modell: NUC8i5BEH)
FastDeploy >= 0.2.1
PaddleDetection >= 2,5
PaddleSeg >= 2,6
PySide6 >= 6.3.2
Optionale Software und Hardware (für die Echtzeiterfassung im Freien)
Drohnen der DJI-Serie und DJI Fly APP
Router (für Intranet-RTMP-Übertragung)
Intel NUC Mini-Computerhardware
UAV-Echtzeit-Bildübertragung
RTMP (Real-Time Messaging Protocol, Echtzeit-Messaging-Protokoll) ist ein Netzwerkprotokoll, das für die Echtzeit-Datenkommunikation entwickelt wurde. Es wird heute hauptsächlich für die Audio-, Video- und Datenkommunikation zwischen Live-Übertragungsgeräten und Servern verwendet, die das RTMP-Protokoll unterstützen. Die Echtzeit-Bildübertragungsverbindung zwischen dem UAV und dem Argumentations-Hardwaregerät in diesem Projekt nutzt den RTMP-Streaming-Dienst der DJI-Steuerterminal-APP. Um die Zeitverzögerung der Bildübertragung zu minimieren, verwenden wir direkt Nginx, um RTMP auf dem Intel aufzubauen NUC-Dienst.
Das vorinstallierte Betriebssystem von Intel NUC ist Windows 10, sodass Sie Nginx mit RTMP-Modul direkt herunterladen können.
- Download-Link
http://nginx-win.ecsds.eu/download/nginx%201.7.11.3%20Gryphon.zip
Nachdem Sie es lokal heruntergeladen haben, dekomprimieren Sie es, erstellen Sie eine neue Datei im Verzeichnis nginx/conf, nennen Sie sie nginx.conf und geben Sie den folgenden Inhalt ein.
worker_processes 1;events { worker_connections 1024;}rtmp { server { listen 8899; chunk_size 4000; application live { live on; allow publish all; allow play all; } }}
Öffnen Sie dann das cmd-Befehlszeilenfenster, geben Sie das Nginx-Verzeichnis ein und geben Sie nginx ein, um den Nginx-Dienst zu starten. Wie in der Abbildung gezeigt, ist der Start erfolgreich.
An dieser Stelle müssen wir den Befehl ipconfig in der cmd-Befehlszeile eingeben, um die Intranet-IPv4-Adresse des NUC-Geräts abzufragen.
Öffnen Sie die DJI Fly-App, suchen Sie nach dem RTMP-Live-Streaming und geben Sie die Streaming-Adresse ein: rtmp://192.168.31.246:8899/live
Nachdem die APP-Streaming-Konfiguration abgeschlossen ist, können Sie die OpenCV-API auf der NUC-Geräteseite aufrufen, um den Streaming-Vorgang durchzuführen und das Echtzeitbild der Drohne zu erhalten. Der Python-Implementierungscode lautet wie folgt.
import cv2rtmpUrl = 'rtmp://192.168.31.246:8899/live'vid = cv2.VideoCapture(rtmpUrl)while vid.isOpened(): ret,frame = vid.read() cv2.imshow('RTMP Test',frame) if cv2.waitKey(1) & 0xFF == ord('q'): breakvid.release()cv2.destroyAllWindows()
Nach dem Ausführen dieses Codes ruft das Python-Programm die von der UAV-App übertragenen Echtzeit-RTMP-Stream-Daten ab und aktualisiert sie zur Anzeige im OpenCV-Fenster. Der Ausführungseffekt ist in der folgenden Abbildung dargestellt.
FastDeploy
Bereitstellung von Modellinferenzen
Nachdem wir den Link zur Echtzeitübertragung von UAV-Bildern durchlaufen hatten, gaben wir den Kernbegründungs- und Bereitstellungslink ein. Wie aus dem obigen Python-Code ersichtlich ist, wird der RTMP-Datenstrom von OpenCV dekodiert, um einen Bildrahmen (Frame) zu erhalten. Der Kern der Arbeit des Reasoning-Links besteht also darin, jeden Bildrahmen in das Modell einzugeben und ihn dann zu erhalten das Ergebnis und visualisieren Sie das Ausgabeergebnis. Dieser Link ist hauptsächlich in drei Schritte unterteilt: dynamische und statische Modellkonvertierung, Schreiben von Argumentationsskripten und Front-End-Integration.
Dynamische und statische Konvertierung des Modells
Zuerst müssen wir das dynamische Diagrammmodell, das mit den Entwicklungskits PaddleSeg und PaddleDetection trainiert wurde, in ein statisches Diagrammmodell konvertieren. Dieser Schritt kann einfach mit den von den beiden Kits bereitgestellten Skripten durchgeführt werden. Das trainierte dynamische Diagrammmodell kann im AI Studio-Projekt abgerufen werden.
- Verknüpfung
https://aistudio.baidu.com/aistudio/projectdetail/4535658
Das dynamische Diagrammmodell zur semantischen Segmentierungsobjekterkennung und die semantische Segmentierung befinden sich jeweils in den Verzeichnissen ppyolo_inference_model und output_ppliteseg_stdc1/best_model/ im AI Studio-Projekt, und die entsprechenden dynamischen und statischen Konvertierungsskripte werden aufgerufen, um die beiden dynamischen Diagrammmodelle in statische Diagramme umzuwandeln .
- PaddleSeg
python PaddleSeg/export.py \ --config ppliteseg_stdc1.yml \ #配置文件路径，根据实际情况修改 --model_path output_ppliteseg_stdc1/best_model/model.pdparams \ # 动态图模型路径，根据实际情况修改 --save_dir inference_ppliteseg_stdc1 \ # 导出目录 --input_shape 1 3 512 1024 #模型输入尺寸
- PaddleDetection
python PaddleDetection/tools/export_model.py \ -c PaddleDetection/configs/ppyolo/ppyolo_tiny_650e_coco.yml \ # 配置文件路径，根据实际情况修改 --output_dir=./ppyolo_inference_model \ # 保存模型的路径 -o weights=ppyolo_tiny_650e_coco.pdparams # 动态图模型路径
Hinweis: Ausführliche Anleitungen zur Modellkonvertierung finden Sie unter
https://github.com/PaddlePaddle/PaddleSeg/blob/release/2.6/docs/model_export_cn.md
https://github.com/PaddlePaddle/PaddleClas/blob/release/2.4/README_ch.md
Nachdem die Konvertierung abgeschlossen ist, können wir zwei Sätze von model.pdmodel- und model.pdiparams-Dateien sowie entsprechende Yaml-Konfigurationsdateien erhalten.
Entwickelt auf Basis von FastDeploy
OpenVINO-Argumentationsmodul
Dieses Projekt verwendet das Intel NUC Mini-Computer-Kit und das OpenVINO-Backend von FastDeploy wird als Inferenzbereitstellungslösung ausgewählt. In der Vergangenheit erforderte die Verwendung von OpenVINO das Herunterladen von Paketen, die Installation und Konfiguration, und der Prozess war relativ umständlich. Daher habe ich die FastDeploy-Bereitstellungslösung übernommen und ihr integriertes OpenVINO-Inferenz-Backend für schnelle Entwicklung und Bereitstellung genannt. Das Tutorial zur vorkompilierten Bibliotheksinstallation und -nutzung von FastDeploy finden Sie in der offiziellen Github-Dokumentation.
- Verknüpfung
https://github.com/PaddlePaddle/FastDeploy
Unter Berücksichtigung der Anwendbarkeit des Programms und der Kompatibilität mit verschiedenen Hardwareumgebungen habe ich zunächst die Optionskonfiguration geschrieben, um je nach Hardware unterschiedliche Inferenz-Backends auszuwählen. In der CPU-Umgebung wird standardmäßig OpenVINO als Inferenz-Backend verwendet.
import cv2import numpy as npimport fastdeploy as fdfrom PIL import Imagefrom collections import Counterdef FastdeployOption(device=0): option = fd.RuntimeOption() if device == 0: option.use_gpu() else: # 使用OpenVino推理 option.use_openvino_backend() option.use_cpu() return option
Anschließend wird der Argumentationscode des semantischen Segmentierungsmodells in eine Klasse gekapselt, was für den schnellen Aufruf des Front-Ends praktisch ist. In der Init-Methode wird die Funktion SegModel () direkt aufgerufen, um das Modell zu initialisieren (Hot Loading), und die Argumentation der Ergebnisse wird über SegModel.predict () abgeschlossen. Nachdem die Argumentationsergebnisse erhalten wurden, wird postprocess () ausgeführt Analysieren Sie die Ergebnisse und extrahieren Sie die Pixel von Gebäuden und Grünflächen. Quantifizieren Sie den Anteil der Bilder und erhalten Sie das Anteilsergebnis der Umgebungselemente. Rufen Sie abschließend die integrierte Visualisierungsfunktion vis_segmentation() von FastDeploy auf, um die Inferenzergebnisse zu visualisieren.
class SegModel(object): def __init__(self, device=0) -> None: self.segModel = fd.vision.segmentation.ppseg.PaddleSegModel( model_file = 'inference/ppliteseg/model.pdmodel', params_file = 'inference/ppliteseg/model.pdiparams', config_file = 'inference/ppliteseg/deploy.yaml', runtime_option=FastdeployOption(device) ) def predict(self, img): segResult = self.segModel.predict(img) result = self.postprocess(segResult) visImg = fd.vision.vis_segmentation(img, segResult) return result, visImg def postprocess(self, result): resultShape = result.shape labelmap = result.label_map labelmapCount = dict(Counter(labelmap)) pixelTotal = int(resultShape[0] * resultShape[1]) # 统计建筑率和绿地率 buildingRate, greenRate = 0, 0 if 8 in labelmapCount: buildingRate = round(labelmapCount[8] / pixelTotal* 100, 3) if 9 in labelmapCount: greenRate = round(labelmapCount[9] / pixelTotal * 100 , 3) return {"building": buildingRate, "green": greenRate}
Rufen Sie auf die gleiche Weise direkt die PPYOLO()-Methode von FastDeploy auf, um die Argumentation des Modells abzuschließen, und rufen Sie die entsprechende Visualisierungsfunktion vis_detection() auf, um sie nach der Nachbearbeitung und Formatierung der Daten zu rendern.
class DetModel(object): def __init__(self, device=0) -> None: self.detModel = fd.vision.detection.PPYOLO( model_file = 'inference/ppyolo/model.pdmodel', params_file = 'inference/ppyolo/model.pdiparams', config_file = 'inference/ppyolo/infer_cfg.yml', runtime_option=FastdeployOption(device) ) # 阈值设置 self.threshold = 0.3 def predict(self, img): detResult = self.detModel.predict(img.copy()) result = self.postprocess(detResult) visImg = fd.vision.vis_detection(img, detResult, self.threshold, 2) return result, visImg def postprocess(self, result): # 得到结果 detIds = result.label_ids detScores = result.scores # 统计数量 humanNum, CarNum = 0, 0 for i in range(len(detIds)): if detIds[i] == 0 and detScores[i] >= self.threshold: humanNum += 1 if detIds[i] == 2 and detScores[i] >= self.threshold: CarNum += 1 return {"human": humanNum, "car": CarNum}
Nachdem Sie das semantische Segmentierungsmodell PP-LiteSeg und das Zielerkennungsmodell PP-YOLO Tiny in einer Klasse gekapselt haben, speichern Sie es als inferEngine.py-Datei für nachfolgende Front-End-Codeaufrufe.
Kombiniert mit PySide6
Entwickeln Sie eine visuelle GUI-Schnittstelle
Die Front-End-Entwicklung verwendet PySide6, und der Quellcode der Schnittstelle kann über den Github-Projektlink am Ende des Artikels abgerufen werden. Im Großen und Ganzen stellt die Entwicklung keine Schwierigkeiten dar. Die Hauptschwierigkeit liegt im Einfrieren oder Verzögern des Programms, das durch die gleichzeitige Aktualisierung der drei Videowiedergabekomponenten verursacht wird.
Die in diesem Projekt angewandte Lösung besteht darin, Multithreading zu verwenden, um das Back-End der drei Videowiedergabekomponenten in drei unabhängige Threads aufzuteilen. Ein Thread (displayThread) schiebt das Originalgemälde des Echtzeit-Videostreams zur Aktualisierung an das Front-End Die beiden anderen Threads (segThread und detThread) führen synchron die semantische Segmentierung und die Inferenz von Echtzeit-Videobildern zur Zielerkennung durch und aktualisieren die Inferenzergebnisbilder nach der Nachbearbeitung an die Front-End-Komponenten. Der spezifische Code lautet wie folgt (main.py).
Scrollen Sie nach unten, um alle Inhalte anzuzeigen
Führen Sie abschließend python main.py aus, um das Programm auszuführen und den Argumentationseffekt zu überprüfen.
**
Zusammenfassung **
FastDeploy ist eine Inferenzbereitstellungs-Toolbox, die Entwicklern hilft, Deep-Learning-Modelle schnell bereitzustellen. Es verfügt über integrierte Backends wie OpenVINO, TensorRT, ONNX Runtime und Paddle Inference und integriert Inferenz-Backends wie Paddle Lite und RKNN. Die gezielte Optimierung jedes Backends ist gut mit der Hardware des Intel NUC Mini-Hosts kompatibel, es ist keine Installation des OpenVINO-Kits und der Konfigurationsumgebung erforderlich und es entfällt auch die Mühe der Optimierung und Beschleunigung, wodurch die Lernkurve für Entwickler, Kosten und Kosten reduziert wird Bereitstellungskosten, wodurch die Effizienz von Bereitstellung und Entwicklung verbessert wird. Derzeit werden mehr als 60 beliebte ökologische Modelle unterstützt, darunter Flugpaddel. Weitere Gründe für die Bereitstellung von KI-Modellen finden Sie auf GitHub von FastDeploy.
- Verknüpfung
https://github.com/PaddlePaddle/FastDeploy
Wunderbare Vergangenheit
Folgen Sie dem öffentlichen Konto „Flying PaddlePaddlePaddle“.
Erhalten Sie mehr technische Inhalte~