Fine-tuning 3D : adapter TRELLIS.2 avec LoRA
Apprenez à adapter TRELLIS.2 à une catégorie d’objets 3D avec LoRA : choix des composants, préparation des données, entraînement et évaluation.

Adapter TRELLIS.2 à vos objets 3D : méthode et arbitrages avec LoRA
Un modèle de génération 3D généraliste peut donner quelque chose de convaincant au premier coup d'œil, puis rater précisément ce qui compte pour votre produit. Prenez une collection de chaussures : la silhouette peut sembler juste, mais la semelle sort trop épaisse, mal dessinée, ou tout simplement différente de la référence. Si votre usage dépend de cette géométrie, une image « jolie » ne suffit pas.
Le fine-tuning peut corriger ce genre de décalage, mais pas en « réapprenant tout le modèle » pour voir ce qui change. L'idée, c'est plutôt de relier le défaut observé à une étape précise du pipeline, puis de vérifier que les données permettent vraiment d'entraîner cette étape. C'est exactement ce que suit l'expérience menée sur TRELLIS.2 : avec 188 modèles de chaussures issus de Google Scanned Objects, adapter la structure et la géométrie avec LoRA, tout en laissant intacte l'étape des matériaux.
Voici une façon de raisonner pour choisir les composants, préparer les données, lancer l'entraînement et juger les résultats - sans confondre une loss en baisse avec une amélioration utile en production.
Pourquoi adapter un modèle 3D généraliste
Un modèle généraliste capte des régularités utiles dans beaucoup de catégories. Pour démarrer, c'est un vrai point fort : il sait déjà relier une image à des formes plausibles. Mais ces régularités ne garantissent pas la précision dont vous avez besoin dans un cas d'usage concret. Une chaussure peut paraître correcte de face, puis révéler une semelle incohérente quand on la regarde de côté ou quand on l'intègre à une simulation.
Du coup, la question n'est pas : « le modèle sait-il générer une chaussure ? ». Elle devient plutôt : « quelle partie du résultat est mauvaise, et quel composant du pipeline pilote cette partie ? » Ce diagnostic évite d'entraîner au mauvais endroit - ou de casser des capacités qui marchaient déjà.
TRELLIS.2 sépare plusieurs problèmes
TRELLIS.2 convertit une image en représentations internes, puis produit une structure, une géométrie détaillée et des matériaux. Cette représentation latente sert de base commune : elle permet de générer des sorties 3D sans repartir d'un modèle entièrement séparé pour chaque type de sortie. Ensuite, le pipeline peut exporter un maillage texturé, par exemple au format GLB.
Cette séparation compte pour le fine-tuning : un défaut de volume ne se corrige pas forcément en entraînant « la partie qui gère les couleurs ». Et l'inverse est vrai : si le problème est sur la texture, les données et les réglages à prévoir ne sont pas les mêmes que pour la géométrie.
Dans l'expérience sur les chaussures, l'objet global est souvent reconnaissable, mais la semelle colle parfois mal. Donc l'objectif reste cadré : améliorer la géométrie d'une catégorie donnée, pas tout réapprendre.
Pourquoi choisir LoRA sur un petit jeu de données
LoRA (adaptation de faible rang) ajoute de petits modules entraînables au modèle, tandis que les poids principaux restent gelés. On entraîne donc les adaptateurs plutôt que l'ensemble du réseau. Résultat : moins de mémoire pour les gradients et l'optimiseur, et une meilleure préservation des capacités générales.
Le jeu de données utilisé ici comprend 188 chaussures sur 1 030 objets de GSO. Avec un volume comme celui-ci, un fine-tuning complet coûte plus cher et augmente le risque d'effacer ce qui fonctionne déjà. Dans la configuration décrite, on entraîne environ 9,3 millions de paramètres d'adaptation sur deux composants ciblés.
Cela dit, LoRA ne rend pas le surapprentissage impossible. Si les exemples sont répétitifs ou mal préparés, les adaptateurs peuvent apprendre des artefacts. Le bon arbitrage, c'est de commencer petit, de garder des objets pour l'évaluation, puis de regarder vraiment les rendus avant d'augmenter le rang ou la durée d'entraînement.
À retenir : partez du défaut observable, localisez l'étape qui le produit, puis entraînez le minimum de composants nécessaire. Plus de données ou plus de paramètres ne rattrapent pas un mauvais diagnostic.
Quels composants de TRELLIS.2 faut-il entraîner ?
Le pipeline de TRELLIS.2 contient plusieurs étapes, mais elles ne pèsent pas toutes pareil sur le problème visé. Pour améliorer la forme des chaussures, l'expérience ajoute des adaptateurs LoRA à deux modèles de diffusion de type transformer (DiT) : le modèle de structure clairsemée et celui de géométrie, appelé Shape Flow. L'étape de génération des matériaux reste gelée.
Ce n'est pas une règle « automatique ». Elle vient de deux constats : les défauts observés touchent la géométrie, et les données disponibles sont exploitables pour entraîner cette géométrie, mais pas les matériaux. En production, on refait le raisonnement à chaque catégorie et à chaque jeu de données.
Structure grossière et géométrie détaillée
Le DiT de structure clairsemée prédit une forme grossière. Son latent se découpe en grille d'occupation : chaque voxel indique si une zone appartient à l'objet ou non. Cette étape pose un cadre spatial pour ce qui suit.
Le Shape Flow prend cette structure et s'appuie aussi sur les caractéristiques de l'image pour générer une géométrie plus détaillée. Sa sortie peut être décodée dans la représentation O-Voxel de TRELLIS.2, puis convertie en maillage. En pratique, adapter ces deux étapes a du sens quand le défaut concerne à la fois l'organisation globale et des détails comme la semelle.
O-Voxel est une représentation clairsemée : elle garde surtout les voxels associés à la surface, plutôt que de traiter tout le volume pareil. Ça réduit le calcul sur les zones vides. Et ça explique aussi pourquoi les étapes du pipeline ne sont pas interchangeables : chaque modèle travaille sur une représentation et un niveau de détail précis.
Pourquoi laisser les matériaux gelés
Le modèle de matériaux produit des propriétés de surface et des textures. Or, dans le jeu de données, les cartes de couleur sont des cartes diffuses qui incorporent déjà des effets d'éclairage. Elles ne séparent pas proprement la couleur « intrinsèque » de l'objet des signaux de matériau que le modèle devrait apprendre.
Si on entraîne cette étape sur ces cartes, elle peut apprendre que les ombres et les variations de lumière font partie de la surface. Le risque est alors de confondre des effets d'éclairage avec des propriétés matérielles. Il y a aussi un autre danger : l'adaptation sur un ensemble restreint peut entraîner un oubli catastrophique, c'est-à-dire une perte de capacités apprises avant.
Le gel des poids est donc autant une décision de qualité des données qu'une décision de calcul. Si votre objectif porte réellement sur les matériaux, il faut d'abord rassembler des cibles adaptées (par exemple des cartes séparées correspondant aux propriétés attendues), puis définir une évaluation dédiée. Sans ça, laisser cette étape intacte est souvent plus sûr que d'entraîner sur des substituts trompeurs.
Les paramètres LoRA ne remplacent pas le diagnostic
Dans l'expérience, le rang vaut 8 dans les couches d'attention et les couches MLP du DiT de structure clairsemée, et 16 dans les couches d'attention du Shape Flow. Le rang correspond à la capacité des adaptateurs : l'augmenter aide à apprendre davantage, mais augmente aussi le nombre de paramètres entraînables.
Il ne faut pas lire ces nombres comme une recette universelle. Ils dépendent de l'architecture, des données et du type de défaut ciblé. Si les résultats restent faibles, avant d'augmenter le rang, commencez par vérifier les rendus, les correspondances image-maillage, les objets d'évaluation et le composant réellement ciblé.
Comment évaluer les résultats sans se fier à la loss ?
Une loss qui baisse signifie que le modèle s'ajuste mieux à l'objectif d'entraînement. Mais elle ne vous dit pas, à elle seule, si la chaussure générée a une semelle plus fidèle, si la géométrie est « utilisable » dans votre application, ou si le modèle reste pertinent sur un objet qu'il n'a jamais vu.
Dans l'expérience, les neuf objets réservés servent à comparer le modèle de base et les versions adaptées. Les rendus montrent les images d'entrée, les sorties générées et les maillages de référence. L'inspection visuelle aide à repérer les défauts structurels et les artefacts que des métriques globales peuvent masquer. L'idéal est d'évaluer sous plusieurs angles, avec des critères définis avant de regarder les résultats.
Utiliser plusieurs métriques géométriques
Trois métriques complètent l'analyse visuelle :
- Distance de Chamfer : mesure la distance entre les points de deux surfaces, dans les deux sens. Plus c'est bas, plus les surfaces se ressemblent en général.
- F-score à 0,02 : combine précision et rappel des points de surface, avec un seuil de correspondance fixé à 2 % de la diagonale de la boîte englobante du scan. Plus c'est élevé, mieux c'est.
- Cohérence des normales : compare l'orientation locale des surfaces. Plus c'est élevé, plus les directions locales sont proches.
Sur les neuf objets de test, le F-score moyen passe de 0,276 (modèle de base) à 0,803 avec les adaptateurs chaussures. La distance de Chamfer baisse de 0,174 à 0,033 et la cohérence des normales monte de 0,530 à 0,804. Dans cette comparaison, le F-score progresse pour chacun des neuf objets quand les deux adaptateurs sont utilisés.
Ces chiffres sont encourageants, mais ils ne prouvent pas que le modèle marchera sur toutes les chaussures, tous les scans, ou dans tous les scénarios commerciaux. Le test reste petit. Il faut donc lire ces résultats comme une validation sur une catégorie et un protocole précis, pas comme une preuve générale de performance.
Construire une évaluation utile au produit
Une évaluation « produit » relie les métriques à des conséquences concrètes. Si les maillages servent à visualiser, l'apparence et la stabilité du rendu peuvent compter plus que tout. Pour une simulation, certains défauts de géométrie ou des problèmes de maillage peuvent bloquer, même si le rendu « fait illusion » à l'œil. Pour un catalogue, la cohérence d'échelle et la fidélité des détails peuvent devenir prioritaires.
Avant l'entraînement, définissez un protocole simple et reproductible :
- Séparer les objets, pas seulement les vues, entre entraînement et test.
- Garder les mêmes images d'entrée et les mêmes réglages de génération pour comparer modèle de base et adaptateurs.
- Mesurer plusieurs aspects de la géométrie, puis inspecter aussi les cas difficiles visuellement.
- Classer les échecs par catégorie : forme globale, détails, matériaux, maillage, cohérence entre vues.
- Décider avec un seuil métier, par exemple le taux d'objets nécessitant encore une correction manuelle.
Ce dernier point parle souvent plus à une équipe produit qu'une métrique isolée. Si le modèle améliore le score géométrique mais ne réduit pas le volume de retouches humaines, le gain opérationnel peut être nul. À l'inverse, une amélioration modeste peut vraiment servir si elle réduit les corrections les plus coûteuses.
Points de contrôle avant de déployer : les objets de test sont-ils réellement inédits ? Les métriques correspondent-elles au cas d'usage ? Les matériaux ont-ils été préservés ? Le temps de correction humaine diminue-t-il ? Sans ces réponses, une belle courbe de loss ne suffit pas à justifier l'intégration.
Conclusion
Adapter un modèle 3D ne consiste pas à entraîner « le plus possible ». L'expérience avec TRELLIS.2 montre une approche plus cadrée : partir d'un défaut concret, cibler les étapes qui contrôlent la géométrie, préserver ce qui marche déjà, et n'entraîner que ce que les données permettent vraiment d'apprendre.
LoRA rend cette adaptation plus légère, mais le résultat dépend toujours du prétraitement, du découpage train/test et de la qualité de l'évaluation. Les gains observés sur les chaussures sont mesurables, mais ils restent liés à un jeu de données et à un protocole précis.
Avant de lancer votre propre fine-tuning, formulez le défaut métier en critères vérifiables, préparez des exemples représentatifs, et fixez un seuil de qualité qui justifiera l'intégration. C'est ce cadre - plus que le choix d'un rang LoRA pris isolément - qui permet de décider si l'adaptation crée une vraie valeur.
Comment préparer les données et lancer l'entraînement ?
Le travail ne s'arrête pas à l'optimisation. Il faut convertir les maillages dans les représentations latentes utilisées par TRELLIS.2, et générer les images de conditionnement de façon cohérente. Ensuite, une fois les latents prêts, on peut les réutiliser pour plusieurs essais sans réencoder les maillages à chaque lancement.
L'expérience s'appuie sur des conteneurs Docker, exécutables sur une machine locale (avec un GPU) ou dans des tâches cloud. Le cloud facilite le lancement sur du matériel adapté, mais il ne supprime ni les coûts ni les contraintes d'accès. Il faut aussi un jeton d'authentification, l'accès au modèle DINOv3 utilisé pour extraire les caractéristiques d'image, et un jeu de maillages déjà chargé dans le stockage choisi.
Prétraiter une fois, entraîner plusieurs fois
Le prétraitement comprend deux étapes principales. D'abord, le pipeline utilise les encodeurs gelés de TRELLIS.2 pour transformer les maillages en latents. Ensuite, Blender rend 16 vues par objet. Pendant l'entraînement, une vue est tirée aléatoirement pour servir d'image de conditionnement.
Multiplier les vues réduit la dépendance à un angle unique. Mais ça ne corrige pas une géométrie de référence incorrecte, ni des rendus incohérents. Avant de lancer une tâche longue, inspectez plusieurs objets et leurs vues : orientation, cadrage, échelle, et cohérence entre les images et les maillages. Les erreurs de préparation deviennent des signaux d'apprentissage, pas de simples défauts « d'affichage ».
Sur les 188 objets, neuf sont réservés pour l'évaluation et les 179 autres servent à l'entraînement. Ce découpage par objet compte : si des vues du même modèle se retrouvent à la fois dans le train et dans le test, l'évaluation a de fortes chances d'être trop optimiste.
Dans l'expérience, le prétraitement complet a duré environ une heure sur un GPU A100 de 80 Go. C'est un ordre de grandeur pour cette configuration ; le temps réel peut varier selon la taille des maillages, le nombre de travailleurs, le matériel et les ralentissements d'entrée-sortie.
Lancer deux entraînements distincts
Les deux DiT sont entraînés dans des modes séparés :
sspour la structure clairsemée etshapepour la géométrie. Chaque lancement charge sa configuration, les latents prétraités et les paramètres LoRA correspondants. Ensuite, adaptateurs et métriques peuvent être envoyés vers le stockage et le suivi configurés pour le projet.Exemple de lancement dans un environnement Docker déjà prêt :
Puis, relancez avec
--config shapepour entraîner le second composant. Les noms d'images et les paramètres d'accès dépendent de votre environnement ; évitez d'inclure des secrets dans l'image du conteneur ou de les exposer dans un dépôt. En local, vérifiez aussi la disponibilité du GPU, l'espace disque et la mémoire partagée. Dans le cloud, fixez un délai maximal et surveillez le coût, surtout si vous multipliez les essais.Dans l'expérimentation rapportée : un GPU A100 de 80 Go. L'entraînement de la structure clairsemée a pris environ 7,2 heures, et celui de la géométrie 3,6 heures. Ces durées ne se transfèrent pas telles quelles sur une autre machine ou avec un autre nombre d'étapes.
Suivre ce qui est réellement entraîné
Le modèle de base reste gelé : seuls les paramètres LoRA sont mis à jour. Les paramètres d'adaptation sont conservés en fp32 pour la stabilité, tandis que l'autocast bf16 réduit la mémoire utilisée pendant certaines opérations. Le gradient checkpointing aide aussi à économiser de la mémoire en recalculant des intermédiaires à la rétropropagation, au prix de calcul supplémentaire.
L'entraînement utilise un objectif de flow matching rectifié. Pour chaque lot, le script mélange des données « propres » avec du bruit à un instant tiré selon le calendrier défini, puis entraîne le modèle à prédire une vitesse cible. Les gradients sont accumulés sur plusieurs petits lots avant chaque mise à jour. Ces détails décrivent bien le script - mais ils ne remplacent pas une vérification directe des maillages générés.