Orion: Xiaomis quelloffenes End-to-End-Framework für selbstfahrende Autos und deren Planung

Allgemeine Einführung

Orion ist ein Open-Source-Projekt, das von Xiaomi Labs entwickelt wurde und sich auf die End-to-End-Technologie für autonomes Fahren konzentriert. Es löst das Problem unzureichender kausaler Schlussfolgerungen in komplexen Szenarien herkömmlicher autonomer Fahrmethoden durch visuelle Sprachmodelle (VLMs) und generative Planer. Orion integriert langfristigen historischen Kontext, Schlussfolgerungen zu Fahrszenarien und präzise Trajektorienvorhersagen, um die Entscheidungsgenauigkeit erheblich zu verbessern. Das Projekt stellt Inferenzcode, vortrainierte Modelle und Konfigurationsdateien zur Verfügung, um Entwickler bei der Durchführung von Open-Loop- und Closed-Loop-Evaluierungen auf dem Bench2Drive-Datensatz zu unterstützen. Orion schneidet bei Closed-Loop-Tests mit einem Driving Score (DS) von 77,74 und einer Success Rate (SR) von 54,62% deutlich besser ab als ähnliche Methoden. Es eignet sich für Entwickler, Forscher und Unternehmen im Bereich des autonomen Fahrens für die Algorithmenentwicklung und Szenariotests.

Funktionsliste

• Langfristige historische KontextverarbeitungQT-Former: Mit dem QT-Former-Modul werden Langzeitdaten aus der Fahrt des Fahrzeugs extrahiert und integriert, um umfassendere Szenario-Informationen zu liefern.
• Fahrszenario ReasoningAnalyse der Straßenumgebung mit Hilfe eines Large Language Model (LLM) zur Erstellung logischer Fahranweisungen.
• Genaue Vorhersage der FlugbahnEin generativer Planer wird verwendet, um multimodale Trajektorien (z.B. Beschleunigung, Lenkung) auf der Grundlage linguistischer Befehle zu generieren, um die Genauigkeit der Bahnplanung zu verbessern.
• Vereinheitlichter OptimierungsrahmenUnterstützung der End-to-End-Optimierung von visuellen Fragen und Antworten (VQA) und Planungsaufgaben, wobei die Lücke zwischen semantischen Schlussfolgerungen und der Handlungsausgabe überbrückt wird.
• Bewertung von offenen und geschlossenen KreisläufenOpen-Loop-Evaluierungsskripte und Closed-Loop-Evaluierungskonfigurationen zur Unterstützung von Bench2Drive-Datensatztests bereitstellen.
• Visualisierungs- und AnalysetoolsGenerieren Sie Vergleichsvideos von Fahrszenarien, die mit Entscheidungspunkten und vorhergesagten Trajektorien gekennzeichnet sind, um die Leistung des Modells zu analysieren.
• Unterstützung von Open-Source-RessourcenInferenzcode, vortrainierte Modelle und Konfigurationsdateien werden zur Verfügung gestellt, um Sekundärentwicklung und Forschung zu erleichtern.

Hilfe verwenden

Orion ist ein Open-Source-Framework für selbstfahrende Entwickler und Forscher, das auf GitHub gehostet wird. Im Folgenden finden Sie einen detaillierten Leitfaden für die Nutzung, der Benutzern bei der schnellen Bereitstellung, Ausführung und Entwicklung hilft.

Einbauverfahren

Orion muss in einer Umgebung ausgeführt werden, die Python unterstützt, und es wird ein Linux-System (z. B. Ubuntu 20.04) empfohlen, um die Kompatibilität sicherzustellen. Hier sind die detaillierten Installationsschritte:

1. Vorbereiten der Umgebung
   Stellen Sie sicher, dass die folgenden Tools auf Ihrem System installiert sind:
   • Python 3.8 (die offiziell empfohlene Version). Prüfen Sie den Befehl:

     python3 --version
     

   • Git. install Befehl:

     sudo apt update
     sudo apt install git
     

   • Conda (zur Erstellung virtueller Umgebungen). Wenn Conda nicht verfügbar ist, können Sie es von der Anaconda-Website herunterladen.
2. Erstellen einer virtuellen Umgebung
   Verwenden Sie Conda zur Erstellung und Aktivierung einer virtuellen Umgebung:

   conda create -n orion python=3.8 -y
   conda activate orion
   

3. Klon-Lager
   Laden Sie den Orion-Quellcode mit Git herunter:

   git clone https://github.com/xiaomi-mlab/Orion.git
   cd Orion
   

4. Installation von PyTorch
   Die offizielle Empfehlung lautet, PyTorch 2.4.1 zu installieren (unterstützt CUDA 11.8). Führen Sie den folgenden Befehl aus:

   pip install torch==2.4.1+cu118 torchvision==0.19.1+cu118 torchaudio==2.4.1 --index-url https://download.pytorch.org/whl/cu118
   

5. Installieren zusätzlicher Abhängigkeiten
   Installieren Sie die anderen Python-Bibliotheken, die Sie für Ihr Projekt benötigen:

   pip install -v -e .
   pip install -r requirements.txt
   

   für den Fall, dass requirements.txt Wenn einige dieser Bibliotheken nicht funktionieren, versuchen Sie, sie einzeln zu installieren (z. B. transformersundnumpy).

6. Herunterladen des vortrainierten Modells
   Orion verwendet externe, vortrainierte Modelle, einschließlich:
   • 2D-Sprachmodell-Gewichtungen (Quelle:Gesicht umarmen).
   • Visuelle Codierer und Projektorgewichte (Quelle:OmniDrive).
     Laden Sie die Datei herunter und entpacken Sie sie in das angegebene Verzeichnis:

   mkdir ckpts
   cd ckpts
   wget https://huggingface.co/exiawsh/pretrain_qformer/resolve/main/pretrain_qformer.pth
   wget https://github.com/NVlabs/OmniDrive/releases/download/v1.0/eva02_petr_proj.pth
   

7. Vorbereiten des Datensatzes
   Orion verwendet den Bench2Drive-Datensatz für die Auswertung. Die Benutzer müssen ihre eigenen Daten herunterladen und vorbereiten, siehe Bench2Drive Datenaufbereitung Dokumentation. Extrahieren Sie den Datensatz in das Projektverzeichnis, zum Beispiel:

   unzip bench2drive.zip -d ./data
   

8. Überprüfen der Installation
   Führen Sie das Inferenzskript aus, um die Umgebungskonfiguration zu überprüfen:

   ./adzoo/orion/orion_dist_eval.sh adzoo/orion/configs/orion_stage3.py ckpts/Orion.pth 1
   

   Wenn keine Fehler gemeldet werden, war die Installation erfolgreich.

Hauptfunktionen

Die Kernfunktion von Orion ist eine durchgängige Autopilot-Denkweise und -Planung. Und so funktioniert es:

1. operationelle Open-Loop-Bewertung

Die Open-Loop-Evaluierung wird verwendet, um die Leistung eines Modells anhand eines festen Datensatzes zu testen. Operative Schritte:

• Stellen Sie sicher, dass der Datensatz und die Modellgewichte bereit sind.
• Führen Sie das Auswertungsskript aus:

  ./adzoo/orion/orion_dist_eval.sh adzoo/orion/configs/orion_stage3.py ckpts/Orion.pth 1
  

• Um CoT (Chain-of-Thought) zu aktivieren, führen Sie aus:

  ./adzoo/orion/orion_dist_eval.sh adzoo/orion/configs/orion_stage3_cot.py ckpts/Orion.pth 1
  

• Die Ausgabe wird in der Datei output Katalog, einschließlich Flugbahnkoordinaten und Bewertungsmetriken (z. B. L2-Fehler).

2. operationelle Bewertung des geschlossenen Kreislaufs

Die Bewertung im geschlossenen Kreislauf simuliert die reale Fahrumgebung und erfordert den CARLA-Simulator. Betriebsverfahren:

• Einrichtung von CARLA: Referenz Bench2Drive Auswertungstool Dokumentation Installation von CARLA und Bewertungsinstrumenten.
• Bewertungsskripte konfigurieren: Bearbeiten Sie das Auswertungsskript (z.B. eval.sh), stellen Sie die folgenden Parameter ein:

  GPU_RANK=0
  TEAM_AGENT=orion
  TEAM_CONFIG=adzoo/orion/configs/orion_stage3_agent.py+ckpts/Orion.pth
  

• Operative Bewertung des geschlossenen KreislaufsAusführen der Auswertebefehle (spezifische Befehle finden Sie in der Bench2Drive-Dokumentation).
• Zu den Ergebnissen gehören Driving Score (DS), Erfolgsquote (SR) und Visualisierungsvideos.

3. visuelle Analyse

Orion unterstützt die Erstellung von Vergleichsvideos von Fahrszenarien, die Modellentscheidungen und Trajektorienvorhersagen demonstrieren. Operative Schritte:

• Führen Sie das Visualisierungsskript aus:

  python visualize.py --data_path ./data/test --model_path ckpts/Orion.pth
  

• Das Ausgabevideo wird im Ordner output/videos Katalog, beschriftet mit Ampeln, Hindernissen und vorhergesagten Flugbahnen (grüne Linien). Die Nutzer können die Leistung von Orion mit anderen Methoden (z. B. UniAD, VAD) vergleichen.

Featured Function Bedienung

Orion bietet eine Kombination aus visueller Sprachmodellierung und generativer Planung, um leistungsstarke Funktionen für die Inferenz von Szenen und die Generierung von Trajektorien bereitzustellen. So funktioniert es im Detail:

1. die Begründung von Szenarien und mündliche Anweisungen

Das Sprachmodell von Orion unterstützt die Anpassung des Fahrverhaltens auf der Grundlage von Textbefehlen. Geben Sie zum Beispiel "Langsam fahren an Kreuzungen" ein. Schritt für Schritt:

• Erstellen einer Befehlsdatei commands.txt, Schreibbefehl:

  在交叉路口减速慢行
  

• Führt das Inferenzskript aus und gibt die Befehlsdatei an:

  python inference.py --model_path ckpts/Orion.pth --command_file commands.txt
  

• Die Ausgabe spiegelt die Anpassung der Trajektorie durch den Befehl wider, der in der Datei output/trajectories.

2. multimodale Trajektoriengenerierung

Der generative Planer von Orion unterstützt mehrere Trajektorienmodi (z.B. Beschleunigung, Verzögerung, Lenkung). Die generativen Parameter können vom Benutzer über eine Konfigurationsdatei angepasst werden:

• Compiler configs/planner.yaml::

  trajectory_mode: multimodal
  max_acceleration: 2.0
  max_steering_angle: 30
  

• Führen Sie das Planungsskript aus:

  python planner.py --config configs/planner.yaml --model_path ckpts/Orion.pth
  

• Die ausgegebenen Traces werden in der Datei output/trajectoriesunterstützt mehrere Kandidatenpfade.

3. durchgängige Optimierung

Orion unterstützt visuelle Fragen und Antworten (VQA) und eine einheitliche Optimierung von Planungsaufgaben. Die Benutzer können es testen, indem sie die folgenden Schritte befolgen:

• Konfigurieren Sie Inferenzskripte, um den VQA-Modus zu aktivieren:

  python inference.py --model_path ckpts/Orion.pth --vqa_mode true
  

• Geben Sie eine Testfrage ein (z. B. "Gibt es vor Ihnen einen Fußgänger?"). Das Modell liefert die semantische Antwort und die entsprechende Trajektorie.

caveat

• Hardware-VoraussetzungNVIDIA A100 (32 GB RAM) oder höhere GPUs werden für die Inferenz empfohlen. Für das Training ist ein größerer Arbeitsspeicher erforderlich (80 GB empfohlen).
• DatenformatEingabedaten sollten im Bench2Drive-Format vorliegen (z. B. .jpgund.pcd), andernfalls ist eine Vorbehandlung erforderlich.
• ModellgewichtDas offizielle Orion-Modell wurde veröffentlicht (Gesicht umarmen), aber der Ausbildungsrahmen ist noch nicht offen.
• Häufigkeit der AktualisierungPrüfen Sie Ihre GitHub-Repositories regelmäßig auf den neuesten Code und die neueste Dokumentation.

Mit diesen Schritten können die Benutzer Orion schnell einsetzen, um Inferenzaufgaben auszuführen oder Algorithmen zu entwickeln.

Anwendungsszenario

1. Entwicklung von Algorithmen für das autonome Fahren
   Entwickler können mit Orion durchgängige Algorithmen für autonomes Fahren testen und die Entscheidungsfähigkeit in komplexen Szenarien optimieren. Offener Quellcode und Modelle unterstützen die schnelle Iteration.
2. akademische Forschung
   Auf der Grundlage von Orion können Forscher die Anwendung von visuellen Sprachmodellen beim autonomen Fahren erforschen, den Synergieeffekt von Argumentation und Planung analysieren und qualitativ hochwertige Arbeiten erstellen.
3. Simulationstest
   Automobilhersteller können Orion in Simulationsumgebungen wie CARLA integrieren, um die Fahrzeugleistung in virtuellen Szenarien zu testen und die Kosten für Straßentests zu senken.
4. Bildung und Ausbildung
   Hochschulen und Universitäten können Orion als Lehrmittel einsetzen, um Studenten die Prinzipien des autonomen Fahrens näher zu bringen und ihre praktischen Fähigkeiten mit Visualisierungsvideos zu verbessern.

QA

1. Welche Datensätze werden von Orion unterstützt?
   Der Bench2Drive-Datensatz wird derzeit unterstützt, andere Datensätze (z. B. nuScenes) können in Zukunft unterstützt werden. Die Nutzer müssen die Daten im offiziellen Format vorbereiten.
2. Wie löst man das Problem des langsamen Denkens?
   Das CoT-Schlussfolgern ist langsam und kann in den Standard-Schlussfolgerungsmodus umgeschaltet werden (orion_stage3.py). Die Optimierung der GPU-Leistung oder die Verringerung der Modellgenauigkeit (z. B. fp16) kann die Geschwindigkeit ebenfalls verbessern.
3. Welche Instrumente werden für die Bewertung von Kreisläufen benötigt?
   Der CARLA-Emulator und das Bench2Drive-Evaluierungstool müssen installiert werden. Die genaue Konfiguration entnehmen Sie bitte dem offiziellen Dokument.
4. Unterstützt Orion das Fahren in Echtzeit?
   Die aktuelle Version basiert auf Offline-Argumentation, Echtzeit-Anwendungen müssen den Code und die Hardware weiter optimieren, es wird empfohlen, auf das offizielle Update zu achten.