Foundation Models pour la 3D : Segmentation Zero-Shot en 2026
1. L'Ère des Foundation Models Spatiaux
Les Foundation Models ont révolutionné le traitement du langage et de l'image. En 2026, cette révolution atteint la 3D. Des architectures comme SAM 3D, OpenScene et LERF permettent désormais de segmenter des nuages de points et des scènes 3D sans aucun entraînement spécifique au domaine cible.
Le paradigme zero-shot signifie que le modèle peut identifier des objets qu'il n'a jamais vus pendant l'entraînement, simplement à partir d'une description textuelle ou d'un prompt visuel. C'est un changement fondamental pour l'industrie géospatiale.
# Installation de l'ecosysteme Foundation Models 3D
mamba create -n fm3d python=3.11 -y
mamba activate fm3d
pip install torch torchvision open3d transformers
pip install segment-anything clip openscene
pip install nerfstudio # Pour LERF12 GB de VRAM. Les Foundation Models 3D sont extrêmement gourmands en mémoire, surtout lors de l'extraction de features multi-échelles.
Mais comment ces modèles comprennent-ils la géométrie 3D à partir de représentations 2D ?
2. CLIP et la Passerelle Vision-Langage vers la 3D
Le coeur de la révolution zero-shot repose sur CLIP (Contrastive Language-Image Pre-training). Ce modèle aligne un espace d'embeddings visuels et textuels dans un même espace latent. L'astuce pour la 3D : projeter les features CLIP sur chaque point du nuage via des rendus multi-vues.
import torch
import clip
import numpy as np
from PIL import Image
# Charger CLIP
model, preprocess = clip.load("ViT-L/14", device="cuda")
def extract_clip_features(images_list):
"""Extrait les features CLIP pour un ensemble de vues 2D."""
features = []
for img_path in images_list:
image = preprocess(Image.open(img_path)).unsqueeze(0).to("cuda")
with torch.no_grad():
feat = model.encode_image(image)
features.append(feat.cpu().numpy())
return np.vstack(features)
def text_query_embedding(text_prompt):
"""Encode une requete textuelle dans l'espace CLIP."""
tokens = clip.tokenize([text_prompt]).to("cuda")
with torch.no_grad():
text_feat = model.encode_text(tokens)
return text_feat.cpu().numpy()La force de cette approche est que l'on peut interroger la scène 3D avec n'importe quelle phrase en langage naturel : "chaise rouge", "fissure dans le beton" ou "vegetation haute". Le modèle n'a jamais été entraîné spécifiquement pour ces catégories.
Comment alors projeter ces features 2D dans l'espace 3D de manière cohérente ?
3. OpenScene : Fusion Multi-Vues pour la Compréhension 3D
OpenScene est l'architecture de référence pour la compréhension open-vocabulary des scènes 3D. Elle fusionne les features CLIP extraites de multiples vues 2D et les projette sur chaque point 3D via les matrices de calibration caméra.
import open3d as o3d
import numpy as np
from openscene import OpenSceneModel
# Charger le nuage de points et les poses cameras
pcd = o3d.io.read_point_cloud("scene.ply")
points = np.asarray(pcd.points)
# Initialiser OpenScene avec le backbone CLIP
model = OpenSceneModel(
backbone="ViT-L/14",
feature_dim=768,
fusion_strategy="weighted_average"
)
# Fusion des features multi-vues sur le nuage
point_features = model.compute_3d_features(
points=points,
images_dir="./renders/",
poses_file="./poses.json",
intrinsics_file="./intrinsics.json"
)
# Requete open-vocabulary
query = "extincteur"
scores = model.query(point_features, query)
mask = scores > 0.75
# Extraction des points correspondants
result = pcd.select_by_index(np.where(mask)[0])
o3d.visualization.draw_geometries([result])| Méthode | Type | Vocabulaire | mIoU ScanNet |
|---|---|---|---|
| PointNet++ (supervisé) | Closed-set | 20 classes | 53.5% |
| OpenScene | Open-vocabulary | Illimité | 47.2% |
| LERF | Open-vocabulary | Illimité | 44.8% |
| SAM 3D | Zero-shot | Illimité | 51.1% |
60% entre images adjacentes provoquera des trous dans les features 3D et des prédictions instables.
OpenScene excelle pour les scènes intérieures. Mais comment étendre cette approche aux représentations neurales ?
4. LERF : Language Embedded Radiance Fields
LERF intègre directement les embeddings CLIP dans un champ de radiance neural (NeRF). Chaque point de l'espace 3D porte non seulement une couleur et une densité, mais aussi un vecteur sémantique interrogeable en langage naturel.
# Entrainement LERF via Nerfstudio
# ns-train lerf --data ./scene_data/
from nerfstudio.pipelines.base_pipeline import Pipeline
import torch
# Charger le modele LERF entraine
pipeline = Pipeline.load("outputs/scene/lerf/2026-02-15/")
model = pipeline.model
# Requete spatiale en langage naturel
query_text = "porte de sortie de secours"
relevancy_map = model.get_relevancy(
query=query_text,
resolution=512,
scale_range=(0.1, 1.5) # Multi-echelle
)
# Seuillage et extraction du masque 3D
threshold = 0.6
spatial_mask = relevancy_map > threshold
print(f"Points pertinents : {spatial_mask.sum()} sur {spatial_mask.numel()}")L'avantage majeur de LERF est sa résolution continue : il n'est pas limité par la densité du nuage de points initial. L'interrogation peut se faire à n'importe quelle échelle spatiale, du bâtiment entier jusqu'au détail d'une poignée de porte.
3D Gaussian Splatting pour obtenir à la fois la vitesse de rendu temps réel du splatting et la richesse sémantique des embeddings CLIP. C'est l'architecture dominante en 2026.
Passons maintenant à l'approche la plus impactante : l'extension de Segment Anything au monde 3D.
5. SAM 3D : Segment Anything dans l'Espace
Segment Anything 3D étend le modèle SAM de Meta à la troisième dimension. Le principe : générer des masques 2D via SAM sur des rendus multi-vues, puis les fusionner en segments 3D coherents grâce à un mécanisme de vote par correspondance géométrique.
import numpy as np
import open3d as o3d
from segment_anything import SamAutomaticMaskGenerator, sam_model_registry
from sam3d import MultiViewFusion, MaskMerger
# Initialiser SAM avec le modele ViT-H
sam = sam_model_registry["vit_h"](checkpoint="sam_vit_h_4b8939.pth")
sam.to(device="cuda")
mask_gen = SamAutomaticMaskGenerator(
model=sam,
points_per_side=32,
pred_iou_thresh=0.86,
stability_score_thresh=0.92,
min_mask_region_area=100
)
# Pipeline de fusion 3D
fusion = MultiViewFusion(
pcd_path="scene.ply",
images_dir="./views/",
depth_dir="./depth/",
poses_file="./camera_poses.json"
)
# Generer les masques 2D pour chaque vue
all_masks = fusion.generate_2d_masks(mask_gen)
# Fusionner en segments 3D par vote geometrique
merger = MaskMerger(
iou_threshold=0.5,
min_views=3 # Un segment doit etre vu dans au moins 3 vues
)
segments_3d = merger.merge(all_masks, fusion.point_cloud)
print(f"Segments 3D detectes : {len(segments_3d)}")
# Visualisation coloree par segment
colors = np.random.rand(len(segments_3d), 3)
pcd = fusion.point_cloud
pcd_colors = np.zeros_like(np.asarray(pcd.points))
for i, seg in enumerate(segments_3d):
pcd_colors[seg.indices] = colors[i]
pcd.colors = o3d.utility.Vector3dVector(pcd_colors)
o3d.visualization.draw_geometries([pcd])min_views est crucial. Avec min_views=1, vous obtiendrez des segments parasites dus aux occultations. min_views=3 est le sweet spot pour la plupart des scènes intérieures.
Comment combiner ces approches pour construire un pipeline de production robuste ?
6. Pipeline de Production : Orchestration Multi-Modèles
En production, la stratégie gagnante consiste à combiner plusieurs Foundation Models dans un pipeline en cascade. SAM 3D segmente la géométrie, CLIP classifie les segments, et un LLM spatialise les résultats via un graphe de scène.
import json
from dataclasses import dataclass
from typing import List
@dataclass
class Segment3D:
indices: np.ndarray
label: str
confidence: float
bbox: np.ndarray
class ZeroShotPipeline:
"""Pipeline zero-shot complet pour la comprehension 3D."""
def __init__(self, sam_ckpt, clip_model="ViT-L/14"):
self.sam = self._load_sam(sam_ckpt)
self.clip = self._load_clip(clip_model)
def process_scene(self, pcd_path, images_dir, categories=None):
# Etape 1 : Segmentation geometrique (SAM 3D)
segments = self.segment_3d(pcd_path, images_dir)
# Etape 2 : Classification open-vocabulary (CLIP)
if categories:
segments = self.classify_segments(segments, categories)
else:
segments = self.auto_label(segments)
# Etape 3 : Construction du graphe de scène
scene_graph = self.build_scene_graph(segments)
return scene_graph
def export_to_json(self, scene_graph, output_path):
"""Export pour integration avec un Agent Spatial."""
with open(output_path, "w") as f:
json.dump(scene_graph.to_dict(), f, indent=2)
# Utilisation
pipeline = ZeroShotPipeline(sam_ckpt="sam_vit_h.pth")
graph = pipeline.process_scene(
pcd_path="building_scan.ply",
images_dir="./captures/",
categories=["mur", "sol", "plafond", "porte", "fenetre", "mobilier"]
)
pipeline.export_to_json(graph, "scene_graph.json")| Étape | Modèle | VRAM | Temps (100 vues) |
|---|---|---|---|
| Segmentation 2D | SAM ViT-H | 8 GB | ~45s |
| Fusion 3D | Vote géométrique | 4 GB | ~12s |
| Classification | CLIP ViT-L/14 | 3 GB | ~3s |
| Scene Graph | Relations spatiales | 1 GB | ~1s |
Ce pipeline est directement exploitable par un Agent IA Spatial pour du raisonnement en langage naturel sur la scène. Mais comment évaluer la qualité des résultats ?
7. Évaluation et Métriques pour le Zero-Shot 3D
L'évaluation des modèles zero-shot requiert des métriques spécifiques. Le mIoU classique ne suffit plus car le vocabulaire est ouvert. Nous introduisons ici le Open-Vocabulary mAP et le Semantic Recall@K.
import numpy as np
from sklearn.metrics import average_precision_score
def compute_open_vocab_map(predictions, ground_truth, iou_threshold=0.5):
"""Calcule le mAP open-vocabulary pour la segmentation 3D."""
aps = []
for query, pred_mask in predictions.items():
if query in ground_truth:
gt_mask = ground_truth[query]
iou = compute_iou_3d(pred_mask, gt_mask)
if iou >= iou_threshold:
aps.append(1.0)
else:
aps.append(0.0)
return np.mean(aps) if aps else 0.0
def semantic_recall_at_k(features_3d, text_queries, ground_truth, k=5):
"""Mesure si la bonne region 3D apparait dans les top-K resultats."""
recalls = []
for query in text_queries:
scores = cosine_similarity(features_3d, query)
top_k_indices = np.argsort(scores)[-k:]
gt_indices = ground_truth[query]
overlap = len(set(top_k_indices) & set(gt_indices))
recalls.append(overlap / len(gt_indices))
return np.mean(recalls)Semantic Drift : la dégradation progressive de la qualité des prédictions lorsque les scènes cibles s'éloignent de la distribution d'entraînement du backbone CLIP. Un monitoring continu avec des métriques de confiance est indispensable.
Conclusion : L'Avenir est Open-Vocabulary
Les Foundation Models transforment radicalement l'approche de la compréhension 3D. Nous sommes passes d'un paradigme closed-set (20 classes prédéfinies) à un paradigme open-vocabulary (interrogation en langage naturel).
- CLIP : La passerelle universelle entre le langage et la vision, désormais étendue à la 3D.
- OpenScene : La référence pour la fusion multi-vues dense sur nuages de points.
- LERF : L'intégration sémantique native dans les représentations neurales.
- SAM 3D : La segmentation zero-shot la plus robuste, par vote géométrique multi-vues.
Ces technologies sont au coeur de la formation 3D Geodata Academy, où vous apprenez à les déployer dans des contextes industriels réels : BIM, jumeaux numériques et inspection automatisée.
Sur ce sujet : Les modules d’apprentissage profond 3D.
Maîtrisez les Foundation Models 3D
Ce guide est un aperçu. Notre formation Elite vous plonge dans l'implémentation complète de ces architectures sur vos propres données.
Recevoir le guide gratuit Passer le test (10 min)