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

> Comment les modèles de fondation permettent de segmenter un nuage de points sans jeu d'entraînement dédié, et où cette approche atteint ses limites.

- Adresse : https://fr.learngeodata.eu/blog/foundation-models-3d-2026
- Rubrique : Articles techniques
- Langue : fr
- Auteur : Dr. Florent Poux (https://fr.learngeodata.eu/formateur/florent-poux)
- Éditeur : 3D Geodata Academy (organisme de formation, France)
- Index du site pour les assistants : https://fr.learngeodata.eu/llms.txt
- Publié le 2026-02-15

---
Un modèle de fondation segmente et nomme une scène qu'il n'a jamais vue.

## 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 LERF
```

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% |

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.

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])
```

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)
```

## 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.

### 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.

[Le programme et les tarifs →](https://fr.learngeodata.eu/tarifs)