PyTorch3D Stereo Implicit Shape Rendering : Apprenez À Construire Une Structure De Scène 3D

Contenu

L’apprentissage profond 3D a toujours été un point difficile dans le domaine de la vision artificielle. Afin de construire avec précision et efficacité un modèle tridimensionnel de la scène et d'obtenir des résultats de rendu relativement réalistes, certains grands fabricants de l'industrie ont successivement ouvert leurs résultats de recherche et développement.

Cependant, dans le monde réel, les objets existent principalement sous la forme de structures 3D.Comment améliorer avec précision la capacité du système d'IA à percevoir et à comprendre des environnements complexes du monde réel et à traiter correctement les images 3D,Cela devient une difficulté technique de plus en plus critique.

Le 23 janvier 2020, Facebook AI a publié PyTorch3D v0.1.0. PyTorch3D est une bibliothèque de composants optimisée, efficace et réutilisable dans PyTorch. Il présente trois caractéristiques exceptionnelles : une efficacité élevée, une modularité et une différenciation.Vise à simplifier l'apprentissage profond 3D dans PyTorch.

PyTorch3D fournit deux composants principaux : les opérateurs 3D et le rendu.

Dans les opérateurs 3D,Fit Mesh peut utiliser la fonction de perte 3D,Déformez la forme générique initiale en forme cible et rendez la forme cible plus lisse à l'aide de certaines règles.La méthode d'ajustement de faisceau dans les opérateurs 3D, puis fournit caméras , transforme , so3  Il existe 3 API au total, qui forment une cartographie de la perspective de la caméra en fonction de la perspective d'une caméra donnée, déduisant ainsi la structure 3D de la scène.

Le rendu comprend le rendu de maillage de texture (Render Textured Meshes), le rendu de maillage DensePose (Render DensePose Meshed), le rendu de nuage de points de couleur (Render Colored Pointclouds), etc.Grâce à ces moteurs de rendu, la structure 3D résultante de la scène peut être encore optimisée.

Le 6 février 2020, les codes liés à PyTorch3D ont été rendus open source sur GitHub. Après 5 versions d'itérations, le 9 février 2021, PyTorch3D a publié sa sixième version publique v0.4.0.Les nouvelles fonctionnalités incluent des fonctions implicites, un rendu stéréo et une réimplémentation NeRF.Fournit une bibliothèque open source plus rapide et plus flexible pour la recherche en apprentissage profond 3D.

Rendu de forme implicite

Le rendu de forme implicite est le processus de génération de rendus réalistes de scènes 3D basés sur de nouvelles perspectives de la scène d'entrée.L’idée principale est d’utiliser des réseaux neuronaux et un rendu différentiable pour reconstruire la forme implicite de la surface de la scène 3D.Cela permet d'apprendre la géométrie des scènes 3D en utilisant uniquement des vues 2D.

Plusieurs composants clés sont nécessaires pour effectuer un rendu de forme implicite.Inclut des abstractions pour les données de volume et les moteurs de rendu de formes implicites différentiables.

Pour permettre aux professionnels de l'industrie d'expérimenter plus facilement le rendu de formes implicites,PyTorch3D fournit déjà aux utilisateurs une série d'opérateurs 3D et de fonctions de perte couramment utilisés, ainsi qu'une API de rendu modulaire et différentiable.Tout en soulignant les principaux composants réutilisables, il fournit également des méthodes d'implémentation éprouvées et standardisées de ces composants.

Dans PyTorch3D v0.4.0, il existe 5 nouvelles fonctionnalités qui prennent en charge le rendu de forme implicite :

1. Structure du volume de données ajoutée (Structure des données des volumes), prend en charge le traitement par lots de volumes 3D et la conversion entre les cadres de coordonnées ;

2. Ajout de plusieurs méthodes d'implémentation de texture de rayon : GridRaysampler, MonteCarloRaysampler, NDCGridRaysampler

3. Ajout de plusieurs méthodes d'implémentation de Raymarcher : AbsorptionOnlyRaymarcher, EmissionAbsorptionRaymarcher

4. Ajout d'un moteur de rendu implicite (Rendu implicite) et les moteurs de rendu de volume (VolumeRenderer) API, qui se compose de Raysampler et Raymarcher

5. Ajout de plusieurs fonctions utilitaires, telles que la conversion différentiable du nuage de points au volume.

Pour utiliser ces nouveaux composants, une réimplémentation NeRF modulaire et bien documentée est disponible.

NeRF est un modèle d’apprentissage en profondeur.Développé par l'équipe de recherche de Google, il vise à représenter des scènes à l'aide de champs de rayonnement neuronal pour la synthèse de vues.
NeRF est capable de synthétiser des graphiques de scènes 3D complexes en utilisant uniquement des collections d'images non structurées.
La version améliorée de NeRF a été réimplémentée avec des performances considérablement améliorées. Il fonctionne plus rapidement que la version officielle tout en garantissant la qualité des images de sortie.

Tutoriel (Ajuster le volume texturé)

Sur la base du didacticiel officiel PyTorch3D GitHub Fit Textured Volume, nous l'avons traduit et organisé pour démontrer comment utiliser PyTorch3D.En utilisant le rendu stéréo différentiable, nous prédisons la structure stéréo d'une scène à partir d'un ensemble de vues de la scène.

Utiliser Raymarching pour construire une structure de scène 3D Ce tutoriel présentera :

• Comment créer un moteur de rendu de volume différentiable ;
• Comment créer un modèle de volume (y compris comment utiliser la classe Volumes) ;
• Utilisez un moteur de rendu stéréo différentiable pour adapter la structure stéréo de l'image ;
• Visualisez la structure tridimensionnelle prédite.

Remarque : en raison de l’espace limité, cet article n’affiche qu’une partie du code. Veuillez consulter le code completCliquez ici.

0. Installer et importer des modules

Assurez-vous qu'il est installé  torche   et  vision torche  .

Si non installé  pytorch3d , veuillez l'installer.

1. Générer des images de scènes et de masques

Le code suivant générera les données de formation. Ça passera  fit_textured_mesh.ipynb   Tutoriel, qui rend une image d'une vache sous plusieurs angles et renvoie ce qui suit :

Une série de tenseurs d'images générés par le moteur de rendu de maillage de vache et sa silhouette ; un moteur de rendu pour chaque prise de vue.

Note:  générer_des_rendus_de_vache   Pour le principe de fonctionnement du rendu de maillage implémenté dans la fonction, veuillez vous référer à :
 fit_textured_mesh.ipynb 

target_cameras, target_images, target_silhouettes = generate_cow_renders(num_views=40)
print(f'Generated {len(target_images)} images/silhouettes/cameras.')

2. Initialiser le moteur de rendu de volume

L'initialisation du moteur de rendu de volume envoie un rayon à partir de chaque pixel de l'image cible et échantillonne un ensemble de points régulièrement espacés le long du rayon. La valeur de densité et la valeur de couleur correspondant à chaque point de rayon peuvent être obtenues en interrogeant la position correspondante dans le modèle de volume de la scène.

Le moteur de rendu se compose d'un raymarcher  et un échantillonneur de rayons  constituer.

échantillonneur de rayons  Responsable de l'émission de rayons à partir des pixels de l'image et de l'échantillonnage des points le long des rayons. Celui utilisé ici est  Échantillonneur NDCGridRay , qui est conforme à la spécification de grille de coordonnées standard PyTorch3D.

raymarcher  Obtient la densité et la couleur des échantillons de rayons et rend tous les rayons comme la valeur de couleur et d'opacité du pixel d'où proviennent les rayons. Celui utilisé ici est  ÉmissionAbsorptionRaymarcher , qui implémente la norme  Raymarching d'émission-absorption   algorithme.

# render_size 表示渲染图像各个边的像素大小，将其设置为与目标图像尺寸一致
# 也就是说将其渲染成与基准图像一样的尺寸
render_size = target_images.shape[1]

# 渲染场景以（0,0,0）为中心，被限定在一个边长约等于 3.0 (国际单位) 的边框内。
volume_extent_world = 3.0

# 1) 实例化 raysampler
# 此处 NDCGridRaysampler 会生成一矩形图像网格的射线，其坐标遵循 pytorch3d 坐标规定
# 由于此处设定的体积是 128^3，因此取样 n_pts_per_ray=150
# 大致相当于每个体素都有一个射线点
# 进一步设置 min_depth=0.1，因为相机平面内的所有表面都超过了 0.1 单位
raysampler = NDCGridRaysampler(
    image_width=render_size,
    image_height=render_size,
    n_pts_per_ray=150,
    min_depth=0.1,
    max_depth=volume_extent_world,
)


# 2) 实例化 raymarcher.
# 此处用的是标准 EmissionAbsorptionRaymarcher 
# 它会沿着每条射线前进
# 将每条射线都渲染成一个单一的 3D 颜色向量和一个不透明度标量
raymarcher = EmissionAbsorptionRaymarcher()

# 最后，用 raysampler 和 raymarcher 实例化体积渲染器
renderer = VolumeRenderer(
    raysampler=raysampler, raymarcher=raymarcher,
)

3. Initialiser le modèle de volume

Ensuite, instanciez le modèle de volume de la scène. Cela entraîne une quantification de l'espace 3D en pixels de volume, où chaque voxel est représenté par un vecteur 3D de la couleur RVB du voxel et un scalaire de densité décrivant l'opacité du voxel (dans la plage [0-1], les nombres plus élevés étant plus opaques).

Pour garantir que les valeurs de densité et de couleur sont comprises dans la plage [0-1], nous représenterons le volume, la couleur et la densité dans l'espace logarithmique. Exécution du modèle  avant   Fonction, espace journal   La valeur sera transmise  sigmoïde   Passage de fonction, de sorte que  espace journal   La valeur est dans la plage correcte.

aussi,  Modèle de volume   Contient également l'objet de rendu. Cet objet reste inchangé tout au long du processus d'optimisation.

Cette section du code définit également  Huber   La fonction de perte calcule la différence entre la couleur rendue et le masque.

4. Ajustement du volume

Dans cette étape, nous utilisons le rendu différentiable pour effectuer l’ajustement du volume.

Pour adapter le volume, nous partons de  caméra_cible   Le rendu est effectué du point de vue de  images_cibles   et  silhouettes_cibles   à titre de comparaison.

Cette comparaison est évaluée par  images_cibles/images_rendues   et  silhouettes_cibles/silhouettes_rendues   Cela se fait en prenant l’erreur moyenne de Huber (lisse-L1) entre les deux.

5. Visualisez le volume de scène optimisé

Enfin, le volume optimisé est visualisé en faisant pivoter le volume de la scène sur son axe y et en le rendant à partir de plusieurs points de vue.

def generate_rotating_volume(volume_model, n_frames = 50):
    logRs = torch.zeros(n_frames, 3, device=device)
    logRs[:, 1] = torch.linspace(0.0, 2.0 * 3.14, n_frames, device=device)
    Rs = so3_exponential_map(logRs)
    Ts = torch.zeros(n_frames, 3, device=device)
    Ts[:, 2] = 2.7
    frames = []
    print('Generating rotating volume ...')
    for R, T in zip(tqdm(Rs), Ts):
        camera = FoVPerspectiveCameras(
            R=R[None], 
            T=T[None], 
            znear = target_cameras.znear[0],
            zfar = target_cameras.zfar[0],
            aspect_ratio = target_cameras.aspect_ratio[0],
            fov = target_cameras.fov[0],
            device=device,
        )
        frames.append(volume_model(camera)[..., :3].clamp(0.0, 1.0))
    return torch.cat(frames)
    
with torch.no_grad():
    rotating_volume_frames = generate_rotating_volume(volume_model, n_frames=7*4)

image_grid(rotating_volume_frames.clamp(0., 1.).cpu().numpy(), rows=4, cols=7, rgb=True, fill=True)
plt.show()

6. Conclusion

Ce tutoriel montre comment optimiser la construction du volume 3D d'une scène afin que le rendu du volume pour les points de vue connus corresponde à l'image observée pour chaque point de vue.

Le rendu dans le tutoriel a été réalisé en utilisant  Échantillonneur NDCGridRay   et   ÉmissionAbsorptionRaymarcher   Le moteur de rendu stéréo PyTorch3D construit est terminé.

Veuillez consulter le tutoriel complet.Cliquez ici.