YOLOE : détection et segmentation en temps réel de vocabulaire ouvert#

Ultralytics YOLOE (Real-Time Seeing Anything) est un modèle de détection et de segmentation d'instances à vocabulaire ouvert : au lieu d'une liste de classes fixe au moment de l'entraînement, il prend les catégories que tu veux au moment de l'inférence, sous forme de prompt textuel, d'exemple visuel ou d'un vocabulaire intégré de 4 585 noms. Basé sur les architectures Ultralytics YOLO — YOLOv8, YOLO11 et YOLO26 — et inspiré par YOLO-World, YOLOE atteint une précision zero-shot de pointe proche de la vitesse d'un YOLO à ensemble fermé.

Démarrage rapide#

Nomme les classes que tu veux et lance l'exécution. YOLOE-26 renvoie des boîtes et des masques de segmentation d'instances pour des catégories sur lesquelles il n'a jamais été entraîné.

from ultralytics import YOLOE

model = YOLOE("yoloe-26s-seg.pt")

# "double-decker bus" is not a COCO class; YOLOE resolves it from the words alone
model.set_classes(["double-decker bus", "person"])

results = model.predict("https://ultralytics.com/images/bus.jpg")
results[0].show()

Le premier appel à set_classes() télécharge un encodeur de texte ; consulte la section Installation et Prérequis avant de déployer sur une machine sans accès réseau.

Choisir un mode de prompt#

YOLOE prend en charge trois modes de prompt, et ton choix détermine quel point de contrôle (checkpoint) tu charges et à quoi ressemblent tes étiquettes de classe. Choisis la ligne qui correspond à ce que tu peux fournir au moment de l'inférence.

Installation et prérequis#

YOLOE est fourni dans le package principal d'Ultralytics :

pip install -U ultralytics

Le prompt textuel nécessite un encodeur de texte en plus, et celui-ci est récupéré lors de la première utilisation plutôt qu'au moment de l'installation :

• Le premier appel à set_classes() installe ultralytics/CLIP depuis GitHub avec pip (qui fournit le tokeniseur) et télécharge un encodeur de texte TorchScript dans le répertoire de travail actuel. YOLOE-26 récupère mobileclip2_b.ts, soit environ 254 Mo ; YOLOE-11 et YOLOE-v8 récupèrent mobileclip_blt.ts. Exécute le téléchargement une seule fois depuis le répertoire à partir duquel tu lanceras tes scripts, ou copie le fichier dedans, sinon il sera téléchargé à nouveau.
• Les deux étapes nécessitent un accès réseau, alors effectue une prédiction avec prompt avant de déployer sur une machine hors ligne ou isolée (air-gapped).
• Les prompts visuels et les points de contrôle sans prompt ne nécessitent aucun encodeur de texte.

Les points de contrôle YOLOE-26 nécessitent ultralytics 8.4.0 ou une version plus récente ; les familles YOLOE-11 et YOLOE-v8 sont disponibles dans les versions antérieures. Une prédiction avec prompt textuel permet de tester l'ensemble du parcours — téléchargement du point de contrôle, installation de CLIP, encodeur de texte, inférence :

yolo predict model=yoloe-26s-seg.pt source="https://ultralytics.com/images/bus.jpg" classes="person"

Pour ignorer complètement le téléchargement de l'encodeur de texte au moment de l'inférence, intègre les prompts dans les poids une bonne fois pour toutes et réutilise-les — voir Réutiliser les embeddings de prompt.

Vue d'ensemble de l'architecture#

YOLOE conserve la structure YOLO standard — une backbone (colonne vertébrale) convolutionnelle pour l'extraction de caractéristiques, un neck pour la fusion multi-échelle, et une tête découplée sans ancrage prédisant les classes et les boîtes — et ajoute trois modules, un par mode de prompt :

• Re-parameterizable Region-Text Alignment (RepRTA) affine les embeddings de texte provenant de CLIP via un petit réseau auxiliaire. Ce réseau s'exécute une fois par appel à set_classes() et est éliminé lors de l'exportation, ce qui ne coûte rien par image. Ce qui s'exécute à chaque passe avant (forward pass), c'est la comparaison des embeddings de prompt stockés avec les caractéristiques de région ; consulte la section Limitations pour connaître le coût avec un grand ensemble de prompts.
• Semantic-Activated Visual Prompt Encoder (SAVPE) encode les caractéristiques sémantiques et d'activation à partir d'une boîte d'exemple, conditionnant le modèle sur des objets qui lui ressemblent. C'est le parcours à un seul exemple (one-shot) pour les cibles difficiles à nommer, telles qu'un logo ou une pièce spécifique.
• Lazy Region-Prompt Contrast (LRPC) met en correspondance les embeddings de région avec un vocabulaire intégré de 4 585 noms, de sorte que les points de contrôle sans prompt reconnaissent les objets sans prompt externe ni encodeur de texte.

La segmentation d'instances provient d'une branche de masques sur la tête de détection, comme dans YOLOv8-Seg, et chaque prédiction transporte un masque sur results[0].masks. Une fois le modèle exporté, les modules pour le monde ouvert sont reparamétrés en une tête YOLO standard, de sorte que le fichier exporté exécute le parcours de détection/segmentation ordinaire.

Modèles disponibles#

Chaque point de contrôle ci-dessous est un modèle de segmentation d'instances et prend en charge val, predict, export et track. Charge un fichier *-seg.pt pour le prompting textuel ou visuel et un fichier *-seg-pf.pt pour l'inférence sans prompt ; ils ne sont pas interchangeables, voir Choisir un mode de prompt. Seuls les fichiers *-seg.pt prennent en charge l'entraînement (train) ; un point de contrôle sans prompt est produit à partir d'un modèle entraîné par prompt textuel, voir Entraîner les modèles officiels à partir de zéro.

Performances de YOLOE sur LVIS#

Résultats zero-shot sur le jeu minival de LVIS à 640 pixels, issus du papier de recherche d'Ultralytics YOLO26.

Prompts textuels et visuels#

Chaque cellule de précision et de paramètres se lit comme suit : prompt textuel / prompt visuel ; les FLOPs sont donnés une seule fois. Les paramètres et les FLOPs correspondent à la configuration de détection évaluée par le papier de recherche. La précision est le chiffre Non-E2E du papier, le seul protocole rapporté pour chaque modèle de la comparaison ; la tête de bout en bout (end-to-end) de YOLOE-26 la devance d'au maximum 1,1 AP sous les prompts textuels et de 2,6 AP sous les prompts visuels.

Sans prompt#

Les points de contrôle sans prompt répondent à partir de leur vocabulaire intégré sans qu'aucun prompt ne soit fourni. Chaque cellule de précision se lit bout en bout / Non-E2E, les deux protocoles selon lesquels le papier évalue YOLOE-26 ; la page YOLO26 cite la colonne Non-E2E.

Sous les prompts textuels et visuels, les modèles YOLOE-26 surpassent leurs équivalents YOLOE-11 et YOLOE-v8 à chaque échelle correspondante sur le mAP_50-95, tout en restant sous la ligne des v8 en termes de paramètres et de FLOPs. Sur la même division, le papier rapporte YOLO-Worldv2 à 24,4 (S), 32,4 (M) et 35,5 (L), et les détecteurs basés sur les Transformers GLIP-T à 26,0, GDINO-T à 27,4 et DetCLIP-T à 34,4, chacun embarquant de 155 à 232 millions de paramètres. Le papier original de YOLOE ajoute deux résultats pour les modèles à l'échelle v8 qu'il a introduits. Sur LVIS, YOLOE-v8s bat YOLO-Worldv2-S de 3,5 AP pour un tiers du coût d'entraînement et 1,4× la vitesse d'inférence. Transféré vers COCO, YOLOE-v8l gagne 0,6 AP de boîte et 0,4 AP de masque par rapport au YOLOv8-L à ensemble fermé avec un temps d'entraînement près de 4× inférieur.

Exemples d'utilisation#

Chaque exemple YOLOE ci-dessous s'exécute à partir de l'API Python. La prédiction par prompt textuel, la validation, l'exportation, le suivi et l'entraînement simple fonctionnent également depuis la CLI ; les recettes de fine-tuning et le prompting visuel passent une classe d'entraîneur ou de prédicteur en argument, ce que seule l'API Python accepte.

Utilisation pour l'entraînement#

Affine (fine-tune) n'importe quel point de contrôle publié *-seg.pt sur ton propre jeu de données YOLO. Cela suit principalement la procédure d'entraînement YOLO standard ; la différence réside dans l'entraîneur que tu passes. YOLOEPESegTrainer intègre tes noms de classe dans la tête et effectue le fine-tuning à partir de là, ce qui est exactement ce que tu veux pour tes propres étiquettes ; l'entraîneur par défaut ne s'entraîne pas sur tes noms de classe.

from ultralytics import YOLOE
from ultralytics.models.yolo.yoloe import YOLOEPESegTrainer

model = YOLOE("yoloe-26s-seg.pt")

results = model.train(
    data="coco128-seg.yaml",
    epochs=80,
    patience=10,
    trainer=YOLOEPESegTrainer,  # <- Important: the fine-tuning trainer, not the default
)

from ultralytics import YOLOE
from ultralytics.models.yolo.yoloe import YOLOEPETrainer

model = YOLOE("yoloe-26s.yaml").load("yoloe-26s-seg.pt")

results = model.train(data="coco128.yaml", epochs=80, patience=10, trainer=YOLOEPETrainer)

Utilisation pour la prédiction#

L'appel de prompt textuel est celui présenté dans le Guide de démarrage rapide. Les deux autres modes ont chacun besoin d'un argument supplémentaire :

import numpy as np

from ultralytics import YOLOE
from ultralytics.models.yolo.yoloe import YOLOEVPSegPredictor

model = YOLOE("yoloe-26l-seg.pt")

# One example box per target, each with its own class ID
visual_prompts = {
    "bboxes": np.array([[221.52, 405.8, 344.98, 857.54], [120, 425, 160, 445]]),  # person, glasses
    "cls": np.array([0, 1]),
}

results = model.predict(
    "ultralytics/assets/bus.jpg",
    visual_prompts=visual_prompts,
    predictor=YOLOEVPSegPredictor,
)
results[0].show()

import numpy as np

from ultralytics import YOLOE
from ultralytics.models.yolo.yoloe import YOLOEVPSegPredictor

model = YOLOE("yoloe-26l-seg.pt")

visual_prompts = {"bboxes": np.array([[221.52, 405.8, 344.98, 857.54]]), "cls": np.array([0])}  # person

results = model.predict(
    "ultralytics/assets/zidane.jpg",  # Target image
    refer_image="ultralytics/assets/bus.jpg",  # Where the example boxes live
    visual_prompts=visual_prompts,
    predictor=YOLOEVPSegPredictor,
)
results[0].show()

# refer_image also sets the classes permanently, so later calls need no prompts at all
results = model("ultralytics/assets/bus.jpg")
model.export(format="onnx")  # And the export keeps them

import numpy as np
import torch

from ultralytics import YOLOE
from ultralytics.models.yolo.yoloe import YOLOEVPSegPredictor

model = YOLOE("yoloe-11l-seg.pt")

img_tensor = torch.rand(1, 3, 480, 480)  # (1, 3, H, W) float tensor in [0, 1]
visual_prompts = {"bboxes": np.array([[10, 10, 50, 50]]), "cls": np.array([0])}

results = model.predict(
    img_tensor,
    refer_image=img_tensor,
    visual_prompts=visual_prompts,
    predictor=YOLOEVPSegPredictor,
    imgsz=640,
)

import numpy as np

from ultralytics import YOLOE
from ultralytics.models.yolo.yoloe import YOLOEVPSegPredictor

model = YOLOE("yoloe-26l-seg.pt")

visual_prompts = {
    "bboxes": [
        np.array([[221.52, 405.8, 344.98, 857.54], [120, 425, 160, 445]]),  # bus.jpg: person, glasses
        np.array([[150, 200, 1150, 700]]),  # zidane.jpg: person
    ],
    "cls": [np.array([0, 1]), np.array([0])],
}

results = model.predict(
    ["ultralytics/assets/bus.jpg", "ultralytics/assets/zidane.jpg"],
    visual_prompts=visual_prompts,
    predictor=YOLOEVPSegPredictor,
)
results[0].show()

Utilisation pour la validation#

La validation s'exécute comme pour n'importe quel autre modèle sur un jeu de données de segmentation :

from ultralytics import YOLOE

model = YOLOE("yoloe-26l-seg.pt")  # or yoloe-26s/m-seg.pt for other sizes

metrics = model.val(data="coco128-seg.yaml")

Deux variantes du même appel couvrent les autres modes de prompt :

• Prompts visuels — model.val(data="coco128-seg.yaml", load_vp=True) extrait un embedding visuel par catégorie directement à partir du jeu de données. Ajoute refer_data="coco.yaml" pour récupérer les embeddings d'un jeu de données différent, qui doit comporter exactement les mêmes catégories.
• Sans prompt — charge un point de contrôle *-seg-pf.pt et passe single_cls=True.

Utilisation de l'exportation#

Les plongements de l'invite peuvent être enregistrés une seule fois et réutilisés lors de la production d'exportations statiques telles que ONNX, OpenVINO, TensorRT, CoreML, LiteRT et RKNN. Le profil NPZ est chargé par le modèle PyTorch d'origine avant l'exportation ; ce n'est pas une entrée d'exécution supplémentaire et le modèle exporté ne nécessite pas le fichier NPZ.

from ultralytics import YOLOE

model = YOLOE("yoloe-26n-seg.pt")
model.set_classes(["person", "bus"])
model.save_prompt_embeddings("person-bus.npz")

# The profile is bound to the source checkpoint and can be reused for later exports.
model = YOLOE("yoloe-26n-seg.pt")
model.load_prompt_embeddings("person-bus.npz")
model.export(format="onnx")

Le même profil d'invite peut également configurer un modèle de détection seule construit à partir de l'architecture YOLOE correspondante. Cela supprime la branche de masque tout en conservant les classes invitées :

from ultralytics import YOLOE

model = YOLOE("yoloe-26n.yaml").load("yoloe-26n-seg.pt")
model.load_prompt_embeddings("person-bus.npz")
model.export(format="rknn", name="rk3588", quantize=16)

Utilisation pour le suivi#

Les classes dotées de prompts se reportent directement dans le suivi (tracking), ce qui te permet de suivre des objets sur lesquels le traqueur n'a jamais été entraîné :

from ultralytics import YOLOE

model = YOLOE("yoloe-26s-seg.pt")
model.set_classes(["forklift", "pallet"])

# persist=True keeps track IDs stable across frames
for result in model.track("path/to/video.mp4", stream=True, persist=True):
    print(result.boxes.id)

Comment se positionne YOLOE#

YOLOE se situe entre un détecteur à ensemble fermé et un modèle de vocabulaire ouvert lourd. Trois comparaisons permettent de décider s'il s'agit du bon choix :

• Par rapport à un YOLO à ensemble fermé. Une fois les prompts configurés, YOLOE prédit via le parcours de détection/segmentation ordinaire et s'exporte comme n'importe quel autre modèle. Ce qu'il apporte, c'est la capacité de changer la liste des classes au moment de l'inférence au lieu de réentraîner ; ce que cela coûte, c'est une précision zero-shot nettement inférieure à celle d'un modèle entraîné sur tes propres classes.
• Par rapport aux familles YOLOE précédentes. YOLOE-26 hérite de la tête de bout en bout sans NMS de YOLO26 et couvre cinq échelles (n/s/m/l/x) contre les trois précédentes (s/m/l), tout en prenant la tête à chaque échelle correspondante en termes de performances.
• Par rapport aux détecteurs à vocabulaire ouvert basés sur les Transformers. GLIP et OWL-ViT exécutent un Transformer vision-langage lors de l'inférence. YOLOE encode les prompts une seule fois, puis les compare aux caractéristiques régionales au sein d'une tête convolutionnelle.

Les alternatives les plus proches prennent toutes un prompt textuel, mais seuls YOLOE et SAM 3 renvoient des masques, et les trois répondent à des questions différentes :

Tu arrives de YOLO-World ? L'API a la même structure : remplace YOLOWorld par YOLOE, charge un point de contrôle *-seg.pt, et conserve ton appel set_classes() tel quel. Tu obtiens des masques et des prompts visuels ; la note d'export concernant les classes gelées s'applique aux deux.

Cas d'utilisation et applications#

La détection open-vocabulary supprime l'étape de réentraînement par classe, ce qui importe le plus lorsque la liste cible n'est pas connue à l'avance :

• Détection en monde ouvert — robotique et systèmes de sécurité qui rencontrent des objets qu'aucun humain n'a énumérés au moment de l'entraînement.
• Détection one-shot à partir d'un exemple — les prompts visuels identifient une partie spécifique, un logo ou un défaut à partir d'une seule boîte de référence, ce qui est utile en inspection industrielle.
• Catalogage à traîne longue — le vocabulaire intégré de 4 585 noms est suffisamment vaste pour la surveillance de la biodiversité ou les inventaires de détail.
• Amorçage de jeux de données — pré-étiquette des images avec des boîtes et des masques avant une vérification humaine, puis entraîne un modèle rapide à ensemble fermé sur le résultat.
• Segmentation de cibles arbitraires — les points de contrôle *-seg.pt publiés renvoient un masque avec chaque prédiction, de sorte que l'imagerie médicale et l'analyse satellitaire obtiennent un résultat précis au pixel près sans second modèle.

Un modèle courant combine deux modes : exécuter le mode sans prompt une première fois pour découvrir ce qui est présent, puis basculer sur les prompts textuels pour les catégories qui comptent.

Limites#

YOLOE sacrifie de la précision au profit de la capacité à modifier les classes au moment de l'inférence. Les conséquences à connaître avant de t'engager :

• La précision zéro-shot est nettement inférieure à celle d'un modèle entraîné sur tes classes. Les points de contrôle avec prompt se situent approximativement dans la plage de 22 à 40 mAP sur minival de LVIS ; un modèle YOLO à ensemble fermé entraîné sur tes propres données surpassera cela sur ces classes. Tourne-toi vers YOLOE pour couvrir des classes pour lesquelles tu ne peux pas t'entraîner, et non pour remplacer l'entraînement.
• Les catégories rares constituent le point faible. La colonne mAP_r dans Performances indique spécifiquement la précision sur les classes rares de LVIS, et sous l'effet des prompts textuels, elle se situe sous les colonnes des classes courantes et fréquentes dans chaque ligne. Vérifie-la plutôt que le mAP global lorsque tes cibles sont inhabituelles.
• Un prompt décrit une apparence, pas des relations. La détection fonctionne en comparant les caractéristiques des régions à l'embedding du prompt, de sorte que les prompts qui dépendent de l'état, du contexte ou de la comparaison — « endommagé », « le plus à gauche », « celui qui est porté » — ne disposent d'aucun point d'ancrage fiable pour effectuer la correspondance. Préfère un vocabulaire proche des noms de catégories du quotidien.
• De grands ensembles de prompts augmentent la latence. Les embeddings des prompts sont calculés une seule fois, mais ils sont comparés aux caractéristiques de la région à chaque passage avant. Mesuré sur CPU avec yoloe-26s-seg.pt, un passage avant augmente d'environ 19 % en passant de 80 à 1 203 classes et d'environ 89 % avec le vocabulaire complet de 4 585 noms. Les FLOPs signalés ne bougent pas du tout, car la similarité région-texte n'est pas comptabilisée, donc le profil ne t'avertira pas.
• Les noms de classes font office d'espaces réservés tant que tu n'as pas fourni de prompt. Un point de contrôle *-seg.pt fraîchement chargé indique nc=80 avec des noms numériques ("0", "1", ...), alors appelle set_classes() avant de lire les étiquettes. Les points de contrôle sans prompt fournissent le vocabulaire complet déjà renseigné.

Notes de déploiement#

• Matériel. L'inférence nécessite un GPU NVIDIA doté de 4 à 8 Go de VRAM ; les échelles n et s s'exécutent sur des GPU de périphérie tels que Jetson ou sur CPU à résolution réduite. Le réglage fin nécessite un seul GPU.
• La NMS est agnostique aux classes par défaut. YOLOE prédit avec agnostic_nms=True. Sur YOLOE-11 et YOLOE-v8, cela supprime les boîtes superposées aux scores plus faibles entre différentes classes plutôt que seulement au sein de la même classe, ce qui évite les doublons lorsqu'un objet correspond à plusieurs catégories. Les modèles YOLOE-26 de bout en bout n'appliquent aucune suppression IoU ; là, le mode agnostique conserve uniquement la seule meilleure classe par ancre au lieu de laisser une seule ancre émettre plusieurs étiquettes de classe. Passe agnostic_nms=False pour contourner ce comportement.
• Traitement par lots. L'inférence par lots fonctionne directement, et les prompts visuels peuvent différer d'une image à l'autre dans le même appel.

Entraînement des modèles officiels à partir de zéro#

La plupart des lecteurs n'en ont jamais besoin. Cela reproduit les points de contrôle open-vocabulary publiés à partir de Objects365, GQA et Flickr30k — environ 1,4 million d'échantillons d'entraînement sur 8× RTX 4090 — et n'a aucun lien avec le réglage fin sur tes propres données, qui est abordé dans la section Utilisation pour l'entraînement ci-dessus.

L'entraînement nécessite des annotations de segmentation. Télécharge les fichiers traités ci-dessous ou génère les tiens avec le script fourni par l'équipe officielle, propulsé par SAM 2.1. La validation utilise LVIS minival.

Le modèle à prompt textuel est entraîné en premier, et les deux autres modes de prompt en sont des raffinements :

from ultralytics import YOLOE
from ultralytics.models.yolo.yoloe import YOLOESegTrainerFromScratch

data = {
    "train": {
        "yolo_data": ["Objects365.yaml"],
        "grounding_data": [
            {
                "img_path": "flickr/full_images/",
                "json_file": "flickr/annotations/final_flickr_separateGT_train_segm.json",
            },
            {
                "img_path": "mixed_grounding/gqa/images",
                "json_file": "mixed_grounding/annotations/final_mixed_train_no_coco_segm.json",
            },
        ],
    },
    "val": {"yolo_data": ["lvis.yaml"]},
}

model = YOLOE("yoloe-26l-seg.yaml")
model.train(
    data=data,  # or the path to a YAML file holding the same structure
    batch=128,
    epochs=30,
    close_mosaic=2,
    optimizer="AdamW",
    lr0=2e-3,
    warmup_bias_lr=0.0,
    weight_decay=0.025,
    momentum=0.9,
    workers=4,
    trainer=YOLOESegTrainerFromScratch,
    device="0,1,2,3,4,5,6,7",
)

Les points de contrôle à prompt visuel et sans prompt démarrent à partir de ce modèle entraîné par prompt textuel et mettent à jour un module chacun. YOLOESegVPTrainer est la recette de prompt visuel et YOLOEPEFreeTrainer celle sans prompt, mais aucune des deux classes ne fige quoi que ce soit par elle-même : l'entraînement sélectif provient de la liste freeze que tu passes en parallèle, qui nomme chaque enfant de tête sauf savpe (respectivement chaque tour de classification), et l'exécution sans prompt nécessite en outre single_cls=True. Le référentiel YOLOE en amont contient les recettes complètes pour les modèles à l'échelle v8.

Une exécution sans prompt terminée est reparamétrée en un point de contrôle qui restitue ses noms sans prompt à l'inférence, en utilisant get_vocab et set_vocab :

from ultralytics import YOLOE

# Weights written by the prompt-free run and by the text-prompt run it started from. Each
# rerun creates a new directory (train-2, train-3, ...), so take the paths the runs printed.
model = YOLOE("runs/segment/train-2/weights/best.pt")  # prompt-free run, its head is already fused
text_model = YOLOE("runs/segment/train/weights/best.pt")  # text-prompt run, its head is still unfused

names = list(YOLOE("yoloe-26l-seg-pf.pt").model.names.values())  # the 4,585-name vocabulary, or your own list
vocab = text_model.get_vocab(names)

model.set_vocab(vocab, names)
model.save("yoloe-26l-seg-pf-custom.pt")  # never overwrite the released checkpoint

Citations et remerciements#

Si YOLOE a contribué à ta recherche ou projet, merci de citer l'article original par Ao Wang, Lihao Liu, Hui Chen, Zijia Lin, Jungong Han, et Guiguang Ding de l'Université Tsinghua :

@misc{wang2025yoloerealtimeseeing,
      title={YOLOE: Real-Time Seeing Anything},
      author={Ao Wang and Lihao Liu and Hui Chen and Zijia Lin and Jungong Han and Guiguang Ding},
      year={2025},
      eprint={2503.07465},
      archivePrefix={arXiv},
      primaryClass={cs.CV},
      url={https://arxiv.org/abs/2503.07465},
}

Pour aller plus loin, l'article original sur YOLOE est disponible sur arXiv. Le code source du projet et des ressources supplémentaires sont accessibles via leur dépôt GitHub.

FAQ#