Foundation Models pour la 3D : Segmentation Zero-Shot en 2026

Quand les modeles de fondation rencontrent la geometrie : comprendre, segmenter et raisonner sur le monde 3D sans entrainement specifique.
Expert
55 min
SAM 3D, OpenScene, LERF, PyTorch
"En 2026, un Foundation Model ne 'voit' plus seulement une image : il comprend l'espace. La segmentation zero-shot 3D abolit la frontiere entre perception humaine et intelligence artificielle spatiale."

1. L'Ere des Foundation Models Spatiaux

Les Foundation Models ont revolutionne le traitement du langage et de l'image. En 2026, cette revolution atteint la 3D. Des architectures comme SAM 3D, OpenScene et LERF permettent desormais de segmenter des nuages de points et des scenes 3D sans aucun entrainement specifique au domaine cible.

Le paradigme zero-shot signifie que le modele peut identifier des objets qu'il n'a jamais vus pendant l'entrainement, simplement a partir d'une description textuelle ou d'un prompt visuel. C'est un changement fondamental pour l'industrie geospatiale.

setup_foundation.sh
# 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 LERF
Florent's Tip: Assurez-vous d'avoir un GPU avec au moins 12 GB de VRAM. Les Foundation Models 3D sont extremement gourmands en memoire, surtout lors de l'extraction de features multi-echelles.

Mais comment ces modeles comprennent-ils la geometrie 3D a partir de representations 2D ?

2. CLIP et la Passerelle Vision-Langage vers la 3D

Le coeur de la revolution zero-shot repose sur CLIP (Contrastive Language-Image Pre-training). Ce modele aligne un espace d'embeddings visuels et textuels dans un meme espace latent. L'astuce pour la 3D : projeter les features CLIP sur chaque point du nuage via des rendus multi-vues.

clip_feature_fusion.py
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 scene 3D avec n'importe quelle phrase en langage naturel : "chaise rouge", "fissure dans le beton" ou "vegetation haute". Le modele n'a jamais ete entraine specifiquement pour ces categories.

Comment alors projeter ces features 2D dans l'espace 3D de maniere coherente ?

3. OpenScene : Fusion Multi-Vues pour la Comprehension 3D

OpenScene est l'architecture de reference pour la comprehension open-vocabulary des scenes 3D. Elle fusionne les features CLIP extraites de multiples vues 2D et les projette sur chaque point 3D via les matrices de calibration camera.

openscene_pipeline.py
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])
Methode Type Vocabulaire mIoU ScanNet
PointNet++ (supervise) Closed-set 20 classes 53.5%
OpenScene Open-vocabulary Illimite 47.2%
LERF Open-vocabulary Illimite 44.8%
SAM 3D Zero-shot Illimite 51.1%
Pitfall: La qualite de la fusion depend directement du recouvrement des vues. Un recouvrement inferieur a 60% entre images adjacentes provoquera des trous dans les features 3D et des predictions instables.

OpenScene excelle pour les scenes interieures. Mais comment etendre cette approche aux representations neurales ?

4. LERF : Language Embedded Radiance Fields

LERF integre directement les embeddings CLIP dans un champ de radiance neural (NeRF). Chaque point de l'espace 3D porte non seulement une couleur et une densite, mais aussi un vecteur semantique interrogeable en langage naturel.

lerf_query.py
# 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 resolution continue : il n'est pas limite par la densite du nuage de points initial. L'interrogation peut se faire a n'importe quelle echelle spatiale, du batiment entier jusqu'au detail d'une poignee de porte.

Advanced: Combinez LERF avec un 3D Gaussian Splatting pour obtenir a la fois la vitesse de rendu temps reel du splatting et la richesse semantique des embeddings CLIP. C'est l'architecture dominante en 2026.

Passons maintenant a l'approche la plus impactante : l'extension de Segment Anything au monde 3D.

5. SAM 3D : Segment Anything dans l'Espace

Segment Anything 3D etend le modele SAM de Meta a la troisieme dimension. Le principe : generer des masques 2D via SAM sur des rendus multi-vues, puis les fusionner en segments 3D coherents grace a un mecanisme de vote par correspondance geometrique.

sam3d_segmentation.py
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])
Florent's Tip: Le parametre 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 scenes interieures.

Comment combiner ces approches pour construire un pipeline de production robuste ?

6. Pipeline de Production : Orchestration Multi-Modeles

En production, la strategie gagnante consiste a combiner plusieurs Foundation Models dans un pipeline en cascade. SAM 3D segmente la geometrie, CLIP classifie les segments, et un LLM spatialise les resultats via un graphe de scene.

production_pipeline.py
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 scene
        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")
Etape Modele VRAM Temps (100 vues)
Segmentation 2D SAM ViT-H 8 GB ~45s
Fusion 3D Vote geometrique 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 scene. Mais comment evaluer la qualite des resultats ?

7. Evaluation et Metriques pour le Zero-Shot 3D

L'evaluation des modeles zero-shot requiert des metriques specifiques. Le mIoU classique ne suffit plus car le vocabulaire est ouvert. Nous introduisons ici le Open-Vocabulary mAP et le Semantic Recall@K.

evaluation.py
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)
Pro Concept: En production, surveillez le Semantic Drift : la degradation progressive de la qualite des predictions lorsque les scenes cibles s'eloignent de la distribution d'entrainement du backbone CLIP. Un monitoring continu avec des metriques de confiance est indispensable.

Conclusion : L'Avenir est Open-Vocabulary

Les Foundation Models transforment radicalement l'approche de la comprehension 3D. Nous sommes passes d'un paradigme closed-set (20 classes predefinies) a un paradigme open-vocabulary (interrogation en langage naturel).

Ces technologies sont au coeur de la formation 3D Geodata Academy, ou vous apprenez a les deployer dans des contextes industriels reels : BIM, jumeaux numeriques et inspection automatisee.

🚀 Maitrisez les Foundation Models 3D

Ce guide est un apercu. Notre formation Elite vous plonge dans l'implementation complete de ces architectures sur vos propres donnees.

Rejoindre l'Elite (120h)