Orion : le cadre de planification et d'inférence de bout en bout pour la conduite autonome de Xiaomi (open source)

Dernières ressources sur l'IAPosté il y a 5 mois Cercle de partage de l'IA

12.6K 00

Introduction générale

Orion est un projet open source développé par Xiaomi Labs qui se concentre sur la technologie de conduite autonome de bout en bout (E2E). Il résout le problème de l'insuffisance du raisonnement causal dans les scénarios complexes des méthodes traditionnelles de conduite autonome grâce à des modèles de langage visuel (VLM) et des planificateurs génératifs. Orion intègre un contexte historique à long terme, un raisonnement sur le scénario de conduite et une prédiction précise de la trajectoire pour améliorer de manière significative la précision de la prise de décision. Le projet fournit un code d'inférence, des modèles pré-entraînés et des fichiers de configuration pour aider les développeurs à effectuer des évaluations en boucle ouverte et en boucle fermée sur l'ensemble de données Bench2Drive. Orion obtient de bons résultats dans les tests en boucle fermée, avec un score de conduite (DS) de 77,74 et un taux de réussite (SR) de 54,62%, ce qui est bien meilleur que les méthodes similaires. Il convient aux développeurs, aux chercheurs et aux entreprises dans le domaine de la conduite autonome pour le développement d'algorithmes et les tests de scénarios.

Liste des fonctions

Traitement du contexte historique à long termeLe module QT-Former permet d'extraire et d'intégrer des données à long terme sur le trajet du véhicule afin de fournir des informations plus complètes sur les scénarios.
Scénario de conduite Raisonnement: Analyse de l'environnement routier à l'aide d'un modèle de langage étendu (LLM) pour générer des instructions de conduite logiques.
Prédiction précise de la trajectoireLe projet : Un planificateur génératif est utilisé pour générer des trajectoires multimodales (par exemple, accélération, direction) basées sur des commandes linguistiques afin d'améliorer la précision de la planification de la trajectoire.
Cadre d'optimisation unifiéLe programme de recherche de l'Institut de recherche sur les sciences de la vie (IRSS) de l'Université du Québec à Montréal (UQAM) a pour but de soutenir l'optimisation de bout en bout des tâches de planification et de questionnement visuel (VQA), en comblant le fossé entre le raisonnement sémantique et le résultat des actions.
Évaluation en boucle ouverte et en boucle ferméeLe site Web de l'Institut de la recherche scientifique et technique (IRST) : il fournit des scripts d'évaluation en boucle ouverte et des configurations d'évaluation en boucle fermée pour soutenir les essais de l'ensemble de données Bench2Drive.
Outils de visualisation et d'analyseLes vidéos comparatives de scénarios de conduite, étiquetées avec les points de décision et les trajectoires prédites, facilitent l'analyse de la performance du modèle.
Soutien aux ressources open sourceLe code d'inférence, les modèles pré-entraînés et les fichiers de configuration sont fournis pour faciliter le développement secondaire et la recherche.

Utiliser l'aide

Orion est un framework open source pour les développeurs et les chercheurs en conduite autonome hébergé sur GitHub. Vous trouverez ci-dessous un guide d'utilisation détaillé pour aider les utilisateurs à déployer, exécuter et développer rapidement.

Processus d'installation

Orion doit être exécuté dans un environnement qui supporte Python, et un système Linux (par exemple Ubuntu 20.04) est recommandé pour assurer la compatibilité. Voici les étapes détaillées de l'installation :

Préparation de l'environnement
Assurez-vous que les outils suivants sont installés sur votre système :
- Python 3.8 (la version officiellement recommandée). Vérifiez la commande :
```
python3 --version
```
- Commande Git. install :
```
sudo apt update
sudo apt install git
```
- Conda (pour créer des environnements virtuels). Si Conda n'est pas disponible, vous pouvez le télécharger sur le site web d'Anaconda.
Créer un environnement virtuel
Utiliser Conda pour créer et activer un environnement virtuel :
```
conda create -n orion python=3.8 -y
conda activate orion
```
entrepôt de clones
Téléchargez le code source d'Orion en utilisant Git :
```
git clone https://github.com/xiaomi-mlab/Orion.git
cd Orion
```
Installation de PyTorch
La recommandation officielle est d'installer PyTorch 2.4.1 (compatible avec CUDA 11.8). Exécutez la commande suivante :
```
pip install torch==2.4.1+cu118 torchvision==0.19.1+cu118 torchaudio==2.4.1 --index-url https://download.pytorch.org/whl/cu118
```
Installation de dépendances supplémentaires
Installez les autres bibliothèques Python nécessaires à votre projet :
```
pip install -v -e .
pip install -r requirements.txt
```
au cas où requirements.txt Si certaines de ces bibliothèques échouent, essayez de les installer individuellement (par ex. transformers,numpy).
Télécharger le modèle pré-entraîné
Orion utilise des modèles externes pré-entraînés, notamment :
- Poids du modèle linguistique 2D (source :Visage étreint).
- Poids du codeur visuel et du projecteur (source :OmniDrive).
  Téléchargez et décompressez le fichier dans le répertoire spécifié :
```
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
```
Préparation du jeu de données
Orion utilise le jeu de données Bench2Drive pour l'évaluation. Les utilisateurs doivent télécharger et préparer leurs propres données. Documentation sur la préparation des données Bench2Drive. Extraire le jeu de données dans le répertoire du projet, par exemple :
```
unzip bench2drive.zip -d ./data
```
Vérifier l'installation
Exécutez le script d'inférence pour vérifier la configuration de l'environnement :
```
./adzoo/orion/orion_dist_eval.sh adzoo/orion/configs/orion_stage3.py ckpts/Orion.pth 1
```
Si aucune erreur n'est signalée, l'installation a réussi.

Principales fonctions

La fonction principale d'Orion est le raisonnement et la planification de bout en bout du pilote automatique. Voici comment cela fonctionne :

1. évaluation opérationnelle en boucle ouverte

L'évaluation en boucle ouverte est utilisée pour tester les performances d'un modèle sur un ensemble de données fixe. Étapes opérationnelles :

Assurez-vous que l'ensemble de données et les poids du modèle sont prêts.

Exécutez le script d'évaluation :

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

Pour activer le raisonnement CoT (Chain-of-Thought), exécutez :

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

La sortie est enregistrée dans le fichier output Catalogue, y compris les coordonnées de la trajectoire et les mesures d'évaluation (par exemple, l'erreur L2).

2. évaluation opérationnelle en boucle fermée

L'évaluation en boucle fermée simule l'environnement de conduite réel et nécessite le simulateur CARLA. Procédure d'exploitation :

Installation de CARLA: Référence Documentation de l'outil d'évaluation Bench2Drive Installation de CARLA et des outils d'évaluation.
Configurer les scripts d'évaluation: Modifiez le script d'évaluation (par ex. eval.sh), définissez les paramètres suivants :
```
GPU_RANK=0
TEAM_AGENT=orion
TEAM_CONFIG=adzoo/orion/configs/orion_stage3_agent.py+ckpts/Orion.pth
```
Évaluation opérationnelle en boucle ferméeExécuter les commandes d'évaluation (se référer à la documentation de Bench2Drive pour les commandes spécifiques).
Les résultats comprennent le score de conduite (DS), le taux de réussite (SR) et des vidéos de visualisation.

3. l'analyse visuelle

Orion permet de générer des vidéos comparatives de scénarios de conduite qui illustrent les décisions du modèle et les prévisions de trajectoire. Étapes opérationnelles :

Exécutez le script de visualisation :

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

La vidéo de sortie est enregistrée dans le fichier output/videos Catalogue, étiqueté avec des feux de signalisation, des obstacles et des trajectoires prédites (lignes vertes). Les utilisateurs peuvent comparer les performances d'Orion avec celles d'autres méthodes (par exemple UniAD, VAD).

Fonction en vedette Fonctionnement

Orion combine la modélisation du langage visuel et la planification générative pour fournir de puissantes capacités d'inférence de scène et de génération de trajectoire. Voici comment il fonctionne en détail :

1. raisonnement par scénario et instructions verbales

Le modèle linguistique d'Orion permet d'adapter le comportement de conduite sur la base de commandes textuelles. Par exemple, entrez "Ralentir aux intersections". Pas à pas :

Création d'un fichier de commandes commands.txt, commande d'écriture :
```
在交叉路口减速慢行
```

Exécute le script d'inférence et spécifie le fichier de commande :

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

La sortie reflétera l'ajustement de la trajectoire par la commande, sauvegardée dans le fichier output/trajectories.

2) Génération de trajectoires multimodales

Le planificateur génératif d'Orion prend en charge plusieurs modes de trajectoire (par exemple, l'accélération, la décélération, la direction). Les paramètres de génération peuvent être ajustés par l'utilisateur via un fichier de configuration :

compilateur configs/planner.yaml: :

trajectory_mode: multimodal
max_acceleration: 2.0
max_steering_angle: 30

Exécutez le script de planification :

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

Les traces de sortie sont enregistrées dans le fichier output/trajectoriesLe système de gestion de l'information de l'Union européenne (UE) permet de prendre en charge plusieurs parcours de candidats.

3. l'optimisation de bout en bout

Orion prend en charge les questions-réponses visuelles (VQA) et l'optimisation unifiée des tâches de planification. Les utilisateurs peuvent le tester en suivant les étapes ci-dessous :

Configurer les scripts d'inférence pour activer le mode VQA :

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

Introduisez une question test (par exemple, "Y a-t-il un piéton devant ?"). Le modèle renvoie la réponse sémantique et la trajectoire correspondante.

mise en garde

exigences en matière de matérielPour l'inférence, il est recommandé d'utiliser des GPU NVIDIA A100 (32 Go de RAM) ou supérieurs. Une plus grande quantité de RAM est nécessaire pour l'entraînement (80 Go recommandés).
format des donnéesLes données d'entrée doivent être conformes au format Bench2Drive (par ex. .jpg,.pcd), sinon un prétraitement est nécessaire.
poids du modèle: Le modèle officiel d'Orion a été publié (Visage étreint), mais le cadre de formation n'est pas encore ouvert.
Fréquence de mise à jourLes dépôts GitHub : Consultez régulièrement vos dépôts GitHub pour obtenir le code et la documentation les plus récents.

Grâce à ces étapes, les utilisateurs peuvent rapidement déployer Orion pour exécuter des tâches d'inférence ou effectuer le développement d'algorithmes.

scénario d'application

Développement d'algorithmes de conduite autonome
Les développeurs peuvent utiliser Orion pour tester des algorithmes de conduite autonome de bout en bout et optimiser les capacités de prise de décision dans des scénarios complexes. Le code source ouvert et les modèles permettent une itération rapide.
recherche universitaire
Grâce à Orion, les chercheurs peuvent étudier l'application des modèles de langage visuel à la conduite autonome, analyser l'effet synergique du raisonnement et de la planification et produire des articles de grande qualité.
test de simulation
Les constructeurs automobiles peuvent intégrer Orion dans des environnements de simulation, tels que CARLA, pour tester les performances des véhicules dans des scénarios virtuels et réduire les coûts des essais routiers.
Éducation et formation
Les établissements d'enseignement supérieur peuvent utiliser Orion comme outil pédagogique pour aider les étudiants à comprendre les principes de la conduite autonome et améliorer leurs compétences pratiques grâce à des vidéos de visualisation.

QA

Quels sont les ensembles de données pris en charge par Orion ?
Le jeu de données Bench2Drive est actuellement pris en charge et d'autres jeux de données (par exemple nuScenes) pourraient l'être à l'avenir. Les utilisateurs doivent préparer les données dans le format officiel.
Comment résoudre le problème de la lenteur du raisonnement ?
Le raisonnement CoT est lent et peut être basculé en mode de raisonnement standard (orion_stage3.py). L'optimisation des performances du GPU ou la réduction de la précision du modèle (par exemple, fp16) peuvent également améliorer la vitesse.
Quels sont les outils nécessaires à l'évaluation en boucle fermée ?
L'émulateur CARLA et l'outil d'évaluation Bench2Drive doivent être installés, veuillez vous référer au document officiel pour une configuration détaillée.
Orion prend-il en charge la conduite en temps réel ?
La version actuelle est basée sur le raisonnement hors ligne, les applications en temps réel ont besoin d'optimiser davantage le code et le matériel, il est recommandé de prêter attention à la mise à jour officielle.