Texto IT3D a 3D

Repositorio oficial de IT3D (AAAI 2024)

IT3D: Generación mejorada de texto a 3D con síntesis de vista explícita (AAAI 2024) .

Yiwen Chen, Chi Zhang, Xiaofeng Yang, Zhongang Cai, Gang Yu, Lei Yang, Guosheng Lin

arxiv

Abstracto

Los avances recientes en las técnicas de conversión de texto a 3D se han visto impulsados ​​por la recopilación de conocimientos de potentes modelos de difusión de texto a imagen (LDM) de gran tamaño. No obstante, los enfoques existentes de Texto a 3D a menudo enfrentan desafíos como la sobresaturación, detalles inadecuados y resultados poco realistas. Este estudio presenta una estrategia novedosa que aprovecha imágenes multivista explícitamente sintetizadas para abordar estos problemas. Nuestro enfoque implica la utilización de canales de imagen a imagen, potenciados por LDM, para generar imágenes posadas de alta calidad basadas en representaciones de modelos 3D toscos. Aunque las imágenes generadas alivian en su mayoría los problemas antes mencionados, persisten desafíos como la inconsistencia de la vista y una variación significativa del contenido debido a la naturaleza generativa inherente de los grandes modelos de difusión, lo que plantea grandes dificultades para aprovechar estas imágenes de manera efectiva. Para superar este obstáculo, recomendamos integrar un discriminador junto con una novedosa estrategia de entrenamiento dual Diffusion-GAN para guiar el entrenamiento de modelos 3D. Para el discriminador incorporado, las imágenes multivista sintetizadas se consideran datos reales, mientras que las representaciones de los modelos 3D optimizados funcionan como datos falsos. Llevamos a cabo un conjunto completo de experimentos que demuestran la eficacia de nuestro método con respecto a los enfoques básicos.

IT3D_demo.mp4

Población

Más vídeos

Izquierda: modelo aproximado (línea de base). Derecha: Modelo refinado (el nuestro). Nombre de archivo: Aviso

un.monton.de.jasmin.blanco.mp4

Modelo.3D.de.Deadpool.mp4

un.ramo.de.crisantemo.amarillo.mp4

Modelo.3D.de.Darth.Vader.mp4

hulk.mp4

un.montón.de.crisantemo.rosa.mp4

modelo.3D.de.batman.mp4

un.modelo.3D.de.un.ironman.mp4

un.ramo.de.rosa.amarilla.mp4

un.busto.de.mármol.de.Thanos.mp4

un.plato.de.brócoli.fresco.mp4

modelo.3D.de.hulk.rojo.mp4

Instalar

git clone https://github.com/buaacyw/IT3D-text-to-3D.git
cd IT3D-text-to-3D
conda create -n it3d python==3.8
conda activate it3d
pip install -r requirements.txt
pip install ./raymarching
pip install ./shencoder
pip install ./freqencoder
pip install ./gridencoder

Iniciar sesión

Debe registrar una cuenta wandb si no tiene una.

wandb login

Descargar modelos de imagen a imagen (opcional)

Para la canalización de imagen a imagen, hemos implementado Stadiffusion Image2Image y ControlNetv1.1.

En nuestro experimento, Controlnet siempre proporciona mejores resultados. Si desea utilizar Controlnet como canalización de imagen a imagen, debe descargar los modelos desde aquí siguiendo las instrucciones de ControlNetv1.1.

Por ejemplo, si desea utilizar Controlnet condicionado a softedge, debe descargar control_v11p_sd15_softedge.yaml y control_v11p_sd15_softedge.pth y colocarlos en la carpeta ctn_models . Además, debe descargar Stable Diffusion 1.5 modelo v1-5-pruned.ckpt y colocarlo en la carpeta ctn_models .

Entornos probados

• Ubuntu 22 con torch 2.0.1 y CUDA 11.7 en un A6000.

Consejos para OOM

Todas nuestras demostraciones (modelos gruesos y modelos finos) están entrenadas en resolución 512. En una resolución de 512, se necesitan alrededor de 30G para entrenar un modelo aproximado (vainilla Stable Dreamfusion) y 35G para refinarlo con IT3D. Puede reducir el consumo de memoria mediante:

• Reduzca la resolución del entrenamiento configurando --h y --w . Si bien esto reducirá significativamente el uso de memoria, también provocará una disminución sustancial del rendimiento. Se necesitan alrededor de 10G para IT3D en resolución 64.
• Utilice NeRF ligero configurando --nerf l1 . Nuestra configuración predeterminada es --nerf l2 .
• Reduzca los pasos de muestreo por rayo configurando --max_steps . Nuestra configuración predeterminada es --max_steps 384
• Si utiliza OOM durante la generación de datos de Controlnet, baje --ctn_sample_batch_size .

Consejos para el rendimiento

• Cambie el mensaje y la semilla configurando --text y --seed . Lamentablemente, entrenar un modelo aproximado libre del problema de Janus a menudo requiere varios intentos.
• Representar NeRF como característica latente en la etapa inicial del entrenamiento del modelo aproximado configurando --latent_iter_ratio 0.1 .
• Cambiar la pérdida por discriminación --g_loss_weight . Debe reducir --g_loss_weight cuando el conjunto de datos generado sea demasiado variado. Puede ampliar --g_loss_weight para obtener un conjunto de datos de alta calidad.
• Sintonizar la GAN por más tiempo aumentará la calidad. Cambie --g_loss_decay_begin_step y --g_loss_decay_step . En nuestra configuración predeterminada, ajustamos la GAN para 7500 pasos y luego la descartamos.

Descargar puntos de control de modelo aproximado

Lanzamos nuestros puntos de control de modelo aproximado. Descomprimir en la carpeta ckpts . Todos estos puntos de control están entrenados en nuestra configuración de modelo aproximado predeterminada.

Uso

En nuestro A6000, se necesitan 6 minutos para generar un conjunto de datos de 640 imágenes usando SD-I2I y 25 minutos usando Controlnet, respectivamente.

 # # Refine a coarse NeRF
# --no_cam_D: camera free discriminator, camera pose won't be input to discriminator
# --g_loss_decay_begin_step: when to decay the weight of discrimination loss
# --real_save_path: path to generated dataset

# Jasmine
python main.py -O --text " a bunch of white jasmine " --workspace jas_ctn --ckpt ckpts/jas_df_ep0200.pth --no_cam_D --gan --ctn --g_loss_decay_begin_step 25000 --real_save_path generated_dataset/jas_ctn

# Use stable diffusion img2img pipeline instead of Controlnet
python main.py -O --text " a bunch of white jasmine " --workspace jas_sd --ckpt ckpts/jas_df_ep0200.pth --no_cam_D --gan  --g_loss_decay_begin_step 25000 --real_save_path generated_dataset/jas_sd

# Iron Man
python main.py -O --text " a 3D model of an iron man, highly detailed, full body " --workspace iron_ctn --ckpt ckpts/iron_man_df_ep0400.pth --no_cam_D --gan --ctn --g_loss_decay_begin_step 45000 --real_save_path generated_dataset/iron_ctn

# Darth Vader
python main.py -O --text " Full-body 3D model of Darth Vader, highly detailed " --workspace darth_ctn --ckpt ckpts/darth_df_ep0200.pth --no_cam_D --gan --ctn --g_loss_decay_begin_step 25000 --real_save_path generated_dataset/darth_ctn

# Hulk
python main.py -O --text " 3D model of hulk, highly detailed " --workspace hulk_ctn --ckpt ckpts/hulk_df_ep0200.pth --no_cam_D --gan --ctn  --g_loss_decay_begin_step 25000 --real_save_path generated_dataset/hulk_ctn

# Ablation Experiment in Paper
# Note: our default setting is sds loss + decayed gan loss. gan loss weight will be decayed to zero after 7500 steps (depending on g_loss_decay_begin_step)
# only l2 loss
python main.py -O --text " 3D model of hulk, highly detailed " --workspace hulk_ctn_l2 --ckpt ckpts/hulk_df_ep0200.pth --no_cam_D --gan --ctn --l2_weight 100.0 --l2_decay_begin_step 25000 --l2_decay_step 2500 --l2_weight_end 0.0 --sds_weight_end 0.0 --g_loss_decay_begin_step 0 --real_save_path generated_dataset/hulk_ctn

# l2 loss + sds loss
python main.py -O --text " 3D model of hulk, highly detailed " --workspace hulk_ctn_l2_sds --ckpt ckpts/hulk_df_ep0200.pth --no_cam_D --gan --ctn --l2_weight 100.0 --l2_decay_begin_step 25000 --l2_decay_step 2500 --l2_weight_end 0.0  --g_loss_decay_begin_step 0 --real_save_path generated_dataset/hulk_ctn

# only GAN
python main.py -O --text " 3D model of hulk, highly detailed " --workspace hulk_ctn_only_gan --ckpt ckpts/hulk_df_ep0200.pth --no_cam_D --gan --ctn --sds_weight_end 0.0 --real_save_path generated_dataset/hulk_ctn

# Edit to red Hulk, change --text
python main.py -O --text " a red hulk, red skin, highly detailed " --workspace hulk_red_ctn --ckpt ckpts/hulk_df_ep0200.pth --no_cam_D --gan --ctn  --g_loss_decay_begin_step 25000 --real_save_path generated_dataset/hulk_ctn

# # Generate Dataset and DMTET Mesh
# generate dataset
python main.py -O --text " a bunch of blue rose, highly detailed " --workspace rose_blue_ctn --ckpt ckpts/rose_df_ep0200.pth  --gan --ctn --no_cam_D --iters 0 --real_save_path generated_dataset/rose_blue_ctn 
# DMTET Mesh
python main.py -O --text " a bunch of blue rose, highly detailed " --workspace rose_blue_ctn_dm  --gan --ctn --no_cam_D  --g_loss_decay_begin_step 5000 --g_loss_decay_step 5000  --init_with ckpts/rose_df_ep0200.pth --dmtet --init_color --real_save_path generated_dataset/rose_blue_ctn


# # Train your own coarse NeRF
python main.py -O --text " a bunch of white jasmine " --workspace jas
# Refine it
python main.py -O --text " a bunch of white jasmine " --workspace jas_ctn --ckpt jas/checkpoints/df_ep0200.pth --no_cam_D --gan --ctn --g_loss_decay_begin_step 25000 --real_save_path generated_dataset/jas_ctn

Posibles hiperparámetros que necesita cambiar:

• --real_overwrite: ábrelo para sobrescribir el directorio del conjunto de datos real
• --per_view_gt: cuántas imágenes se generarán para cada vista de cámara. Predeterminado: 5
• --img2img_view_num: cuántas vistas de cámara para la generación de img2img. Predeterminado: 64.
• --gan: Incorporación de discriminador (IT3D)
• --ctn: Uso de la condición ControlNet en softedge. Si es falso, se utilizará StableDiffusion Image-to-Image Pipeline. SD I2I es mucho más rápido pero con menor calidad.
• --profundidad: Controlnet condicionado en profundidad
• --noraml: Controlnet en condiciones normales
• --fuerza: fuerza del condicionamiento Controlnet
• --init_color: si inicia el color de DMTET. A veces hay que abrir esta opción para evitar este error.

Reconocimiento

Nuestro código se basa en estos maravillosos repositorios:

• Estable-Dreamfusion

   @misc{stable-dreamfusion,
      Author = {Jiaxiang Tang},
      Year = {2022},
      Note = {https://github.com/ashawkey/stable-dreamfusion},
      Title = {Stable-dreamfusion: Text-to-3D with Stable-diffusion}
  }
  

• EG3D

   @inproceedings{Chan2022,
    author = {Eric R. Chan and Connor Z. Lin and Matthew A. Chan and Koki Nagano and Boxiao Pan and Shalini De Mello and Orazio         Gallo and Leonidas Guibas and Jonathan Tremblay and Sameh Khamis and Tero Karras and Gordon Wetzstein},
    title = {Efficient Geometry-aware {3D} Generative Adversarial Networks},
    booktitle = {CVPR},
    year = {2022}
  }
  

• controlnet

   @misc{zhang2023adding,
    title={Adding Conditional Control to Text-to-Image Diffusion Models}, 
    author={Lvmin Zhang and Maneesh Agrawala},
    year={2023},
    eprint={2302.05543},
    archivePrefix={arXiv},
    primaryClass={cs.CV}
  }
  

Citación

Si encuentra útil este trabajo, se agradecerá una cita a través de:

  @misc{chen2023it3d,
        title={IT3D: Improved Text-to-3D Generation with Explicit View Synthesis}, 
        author={Yiwen Chen and Chi Zhang and Xiaofeng Yang and Zhongang Cai and Gang Yu and Lei Yang and Guosheng Lin},
        year={2023},
        eprint={2308.11473},
        archivePrefix={arXiv},
        primaryClass={cs.CV}
  }