benchmark_VAE
Pythae 0.1.2
Documentación
Esta biblioteca implementa algunos de los modelos de autoencoder más comunes (variacionales) bajo una implementación unificada. En particular, proporciona la posibilidad de realizar experimentos y comparaciones de referencia entrenando a los modelos con la misma arquitectura de red neuronal de autoinscuesta. La función hace que su propio autoencoder le permita capacitar a cualquiera de estos modelos con sus propios datos y redes neuronales de codificadores y decodificadores. Integra herramientas de monitoreo de experimentos como wandb, mlflow o comet-ml? ¿Y permite compartir y cargar el modelo desde el HuB Huggingface? En algunas líneas de código.
Noticias ?
A partir de V0.1.0, Pythae ahora admite la capacitación distribuida usando el DDP de Pytorch. Ahora puede entrenar su VAE favorito más rápido y en conjuntos de datos más grandes, aún con algunas líneas de código. Vea nuestro punto de referencia de velocidad.
wandb / Experimento con mlflow / Experimento de seguimiento con comet_ml Para instalar la última versión estable de esta biblioteca, ejecute lo siguiente con pip
$ pip install pythae Para instalar la última versión de GitHub de esta biblioteca, ejecute lo siguiente con pip
$ pip install git+https://github.com/clementchadebec/benchmark_VAE.gitO alternativamente, puede clonar el repositorio de GitHub para acceder a pruebas, tutoriales y scripts.
$ git clone https://github.com/clementchadebec/benchmark_VAE.gite instalar la biblioteca
$ cd benchmark_VAE
$ pip install -e . A continuación se muestra la lista de los modelos actualmente implementados en la biblioteca.
| Modelos | Ejemplo de entrenamiento | Papel | Implementación oficial |
|---|---|---|---|
| Autoencoder (AE) | |||
| Autoencoder variacional (VAE) | enlace | ||
| Autoencoder variacional beta (Betavae) | enlace | ||
| VAE con flujos de normalización lineal (VAE_LINNF) | enlace | ||
| VAE con flujos autorregresivos inversos (VAE_IAF) | enlace | enlace | |
| Desenglido beta variacional autoencoder (desangledbetavae) | enlace | ||
| Desenangado por factorización (Factorvae) | enlace | ||
| Beta-TC-Vae (Betatcvae) | enlace | enlace | |
| Importancia Autoencoder ponderada (Iwae) | enlace | enlace | |
| Autoencoder ponderado de importancia multiplicada (Miwae) | enlace | ||
| Autoencoder ponderado de importancia parcial (Piwae) | enlace | ||
| Autoencoder ponderado de importancia combinada (CIWAE) | enlace | ||
| VAE con similitud métrica perceptiva (MSSSIM_VAE) | enlace | ||
| Wasserstein Autoencoder (Wae) | enlace | enlace | |
| Información Variacional Autoencoder (infovae_mmd) | enlace | ||
| VAMP Autoencoder (VAMP) | enlace | enlace | |
| VAE hiperesféricos (SVAE) | enlace | enlace | |
| Poinctaré Disk Vae (Poincareva) | enlace | enlace | |
| Autoencoder adversario (adversarial_ae) | enlace | ||
| Autoencoder variacional GaN (VAEGAN)? | enlace | enlace | |
| Vector cuantificada VAE (vqvae) | enlace | enlace | |
| VAE hamiltonianos (HVAE) | enlace | enlace | |
| AE regularizado con L2 Decoder Param (RAE_L2) | enlace | enlace | |
| AE regularizado con penalización de gradiente (rae_gp) | enlace | enlace | |
| Riemannian hamiltonian vae (rhvae) | enlace | enlace | |
| Cuantización residual jerárquica (HRQVAE) | enlace | enlace |
Ver Resultados de Reconstrucción y Generación para todos los modelos antes mencionados
A continuación se muestra la lista de los modelos actualmente implementados en la biblioteca.
| Muestras | Modelos | Papel | Implementación oficial |
|---|---|---|---|
| Prior normal (Normalsampler) | Todos los modelos | enlace | |
| Mezcla gaussiana (GaussianMixturesampler) | Todos los modelos | enlace | enlace |
| Sampler VAE de dos etapas (TwostaGevaesampler) | Todos los modelos basados en VAE | enlace | enlace |
| Unidad Sampler uniforme de Sphere (Amampler de hipersphereuniform) | Sva | enlace | enlace |
| Sampler de disco Poinctaré (Poincedisksampler) | Poincareva | enlace | enlace |
| VAMP ARRIBLE PRERIVO (Amampler Vampser) | VAMP | enlace | enlace |
| Manufold Sampler (Rhvaesampler) | Rhvae | enlace | enlace |
| Sampler de flujo autorregresivo enmascarado (Mafsampler) | Todos los modelos | enlace | enlace |
| Muestra de flujo autorregresivo inverso (IAFSAMPLER) | Todos los modelos | enlace | enlace |
| Pixelcnn (Pixelcnnsampler) | Vqvae | enlace |
Validamos las implementaciones reproduciendo algunos resultados presentados en las publicaciones originales cuando se ha publicado el código oficial o cuando había suficientes detalles sobre la sección experimental de los documentos disponibles. Ver reproducibilidad para más detalles.
Para lanzar una capacitación de modelo, solo necesita llamar a una instancia TrainingPipeline .
> >> from pythae . pipelines import TrainingPipeline
> >> from pythae . models import VAE , VAEConfig
> >> from pythae . trainers import BaseTrainerConfig
> >> # Set up the training configuration
>> > my_training_config = BaseTrainerConfig (
... output_dir = 'my_model' ,
... num_epochs = 50 ,
... learning_rate = 1e-3 ,
... per_device_train_batch_size = 200 ,
... per_device_eval_batch_size = 200 ,
... train_dataloader_num_workers = 2 ,
... eval_dataloader_num_workers = 2 ,
... steps_saving = 20 ,
... optimizer_cls = "AdamW" ,
... optimizer_params = { "weight_decay" : 0.05 , "betas" : ( 0.91 , 0.995 )},
... scheduler_cls = "ReduceLROnPlateau" ,
... scheduler_params = { "patience" : 5 , "factor" : 0.5 }
... )
> >> # Set up the model configuration
>> > my_vae_config = model_config = VAEConfig (
... input_dim = ( 1 , 28 , 28 ),
... latent_dim = 10
... )
> >> # Build the model
>> > my_vae_model = VAE (
... model_config = my_vae_config
... )
> >> # Build the Pipeline
>> > pipeline = TrainingPipeline (
... training_config = my_training_config ,
... model = my_vae_model
... )
> >> # Launch the Pipeline
>> > pipeline (
... train_data = your_train_data , # must be torch.Tensor, np.array or torch datasets
... eval_data = your_eval_data # must be torch.Tensor, np.array or torch datasets
... ) Al final de la capacitación, los mejores pesos del modelo, la configuración del modelo y la configuración de entrenamiento se almacenan en una carpeta final_model disponible en my_model/MODEL_NAME_training_YYYY-MM-DD_hh-mm-ss (con my_model es el argumento output_dir del BaseTrainerConfig ). Si establece además el argumento steps_saving en un cierto valor, las carpetas llamadas checkpoint_epoch_k que contienen los mejores pesos del modelo, optimizador, programador, configuración y configuración de entrenamiento en la época k también aparecerán en my_model/MODEL_NAME_training_YYYY-MM-DD_hh-mm-ss .
También proporcionamos un ejemplo de script de capacitación aquí que se puede utilizar para entrenar los modelos en conjuntos de datos de puntos de referencia (MNIST, CIFAR10, Celeba ...). El script se puede iniciar con la siguiente línea de comandos
python training.py --dataset mnist --model_name ae --model_config ' configs/ae_config.json ' --training_config ' configs/base_training_config.json 'Consulte ReadMe.md para obtener más detalles sobre este script
GenerationPipeline La forma más fácil de lanzar una generación de datos a partir de un modelo capacitado consiste en usar la GenerationPipeline provocada en Pythae. Digamos que desea generar 100 muestras utilizando un MAFSampler , todo lo que tiene que hacer es 1) Relea el modelo entrenado, 2) Defina la configuración del muestreador y 3) Crear y iniciar la GenerationPipeline de la siguiente manera de la siguiente manera
> >> from pythae . models import AutoModel
> >> from pythae . samplers import MAFSamplerConfig
> >> from pythae . pipelines import GenerationPipeline
> >> # Retrieve the trained model
>> > my_trained_vae = AutoModel . load_from_folder (
... 'path/to/your/trained/model'
... )
> >> my_sampler_config = MAFSamplerConfig (
... n_made_blocks = 2 ,
... n_hidden_in_made = 3 ,
... hidden_size = 128
... )
> >> # Build the pipeline
>> > pipe = GenerationPipeline (
... model = my_trained_vae ,
... sampler_config = my_sampler_config
... )
> >> # Launch data generation
>> > generated_samples = pipe (
... num_samples = args . num_samples ,
... return_gen = True , # If false returns nothing
... train_data = train_data , # Needed to fit the sampler
... eval_data = eval_data , # Needed to fit the sampler
... training_config = BaseTrainerConfig ( num_epochs = 200 ) # TrainingConfig to use to fit the sampler
... )Alternativamente, puede iniciar el proceso de generación de datos desde un modelo capacitado directamente con la muestra. Por ejemplo, para generar nuevos datos con su muestra, ejecute lo siguiente.
> >> from pythae . models import AutoModel
> >> from pythae . samplers import NormalSampler
> >> # Retrieve the trained model
>> > my_trained_vae = AutoModel . load_from_folder (
... 'path/to/your/trained/model'
... )
> >> # Define your sampler
>> > my_samper = NormalSampler (
... model = my_trained_vae
... )
> >> # Generate samples
>> > gen_data = my_samper . sample (
... num_samples = 50 ,
... batch_size = 10 ,
... output_dir = None ,
... return_gen = True
... ) Si establece output_dir en una ruta específica, las imágenes generadas se guardarán como archivos .png llamados 00000000.png , 00000001.png ... Las muestras se pueden usar con cualquier modelo siempre que sea adecuado. Por ejemplo, se puede usar una instancia GaussianMixtureSampler para generar a partir de cualquier modelo, pero un VAMPSampler solo se puede usar con un modelo VAMP . Consulte aquí para ver cuáles se aplican a su modelo. Tenga cuidado de que algunos muestreadores como el GaussianMixtureSampler , por ejemplo, sea necesario ajustar llamando al método fit antes de usar. A continuación se muestra un ejemplo para el GaussianMixtureSampler .
> >> from pythae . models import AutoModel
> >> from pythae . samplers import GaussianMixtureSampler , GaussianMixtureSamplerConfig
> >> # Retrieve the trained model
>> > my_trained_vae = AutoModel . load_from_folder (
... 'path/to/your/trained/model'
... )
> >> # Define your sampler
... gmm_sampler_config = GaussianMixtureSamplerConfig (
... n_components = 10
... )
> >> my_samper = GaussianMixtureSampler (
... sampler_config = gmm_sampler_config ,
... model = my_trained_vae
... )
> >> # fit the sampler
>> > gmm_sampler . fit ( train_dataset )
> >> # Generate samples
>> > gen_data = my_samper . sample (
... num_samples = 50 ,
... batch_size = 10 ,
... output_dir = None ,
... return_gen = True
... )Pythae le brinda la posibilidad de definir sus propias redes neuronales dentro de los modelos VAE. Por ejemplo, digamos que desea entrenar un Wassertstein AE con un codificador y decodificador específico, puede hacer lo siguiente:
> >> from pythae . models . nn import BaseEncoder , BaseDecoder
> >> from pythae . models . base . base_utils import ModelOutput
> >> class My_Encoder ( BaseEncoder ):
... def __init__ ( self , args = None ): # Args is a ModelConfig instance
... BaseEncoder . __init__ ( self )
... self . layers = my_nn_layers ()
...
... def forward ( self , x : torch . Tensor ) -> ModelOutput :
... out = self . layers ( x )
... output = ModelOutput (
... embedding = out # Set the output from the encoder in a ModelOutput instance
... )
... return output
...
... class My_Decoder ( BaseDecoder ):
... def __init__ ( self , args = None ):
... BaseDecoder . __init__ ( self )
... self . layers = my_nn_layers ()
...
... def forward ( self , x : torch . Tensor ) -> ModelOutput :
... out = self . layers ( x )
... output = ModelOutput (
... reconstruction = out # Set the output from the decoder in a ModelOutput instance
... )
... return output
...
> >> my_encoder = My_Encoder ()
> >> my_decoder = My_Decoder ()Y ahora construye el modelo
> >> from pythae . models import WAE_MMD , WAE_MMD_Config
> >> # Set up the model configuration
>> > my_wae_config = model_config = WAE_MMD_Config (
... input_dim = ( 1 , 28 , 28 ),
... latent_dim = 10
... )
...
> >> # Build the model
>> > my_wae_model = WAE_MMD (
... model_config = my_wae_config ,
... encoder = my_encoder , # pass your encoder as argument when building the model
... decoder = my_decoder # pass your decoder as argument when building the model
... ) Nota importante 1 : Para todos los modelos basados en AE (AE, WAE, RAE_L2, RAE_GP), tanto el codificador como el decodificador deben devolver una instancia ModelOutput . Para el codificador, la instancia ModelOutput debe contener las embarcaciones debajo de la embedding de la llave. Para el decodificador, la instancia ModelOutput debe contener las reconstrucciones bajo la reconstruction clave.
Nota importante 2 : Para todos los modelos basados en VAE (VAE, Betavae, IWAE, HVAE, VAMP, RHVAE), tanto el codificador como el decodificador deben devolver una instancia ModelOutput . Para el codificador, la instancia ModelOutput debe contener las matrices de embarcaciones y log -covariance (de Shape Batch_Size x LATENT_SPACE_DIM) respectivamente bajo la tecla embedding y log_covariance . Para el decodificador, la instancia ModelOutput debe contener las reconstrucciones bajo la reconstruction clave.
También puede encontrar arquitecturas de redes neuronales predefinidas para los conjuntos de datos más comunes ( es decir , Mnist, Cifar, Celeba ...) que se pueden cargar de la siguiente manera
> >> from pythae . models . nn . benchmark . mnist import (
... Encoder_Conv_AE_MNIST , # For AE based model (only return embeddings)
... Encoder_Conv_VAE_MNIST , # For VAE based model (return embeddings and log_covariances)
... Decoder_Conv_AE_MNIST
... )Reemplace Mnist por Cifar o Celeba para acceder a otras redes neuronales.
Pythae A partir de v0.1.0 , Pythae ahora admite la capacitación distribuida usando el DDP de Pytorch. Le permite entrenar a su VAE favorito más rápido y en un conjunto de datos más grande utilizando entrenamiento multi-GPU y/o de nodos múltiples.
Para hacerlo, puede construir un script de Python que luego será lanzado por un lanzador (como srun en un clúster). Lo único que se necesita en el script es especificar algunos elementos en relación con el entorno distribuido (como el número de nodos/GPU) directamente en la configuración de capacitación de la siguiente manera
> >> training_config = BaseTrainerConfig (
... num_epochs = 10 ,
... learning_rate = 1e-3 ,
... per_device_train_batch_size = 64 ,
... per_device_eval_batch_size = 64 ,
... train_dataloader_num_workers = 8 ,
... eval_dataloader_num_workers = 8 ,
... dist_backend = "nccl" , # distributed backend
... world_size = 8 # number of gpus to use (n_nodes x n_gpus_per_node),
... rank = 5 # global gpu id,
... local_rank = 1 # gpu id within a node,
... master_addr = "localhost" # master address,
... master_port = "12345" # master port,
... ) Vea este script de ejemplo que define un entrenamiento VQVAE multi-GPU en el conjunto de datos de ImageNet. Tenga en cuenta que la forma en que se recuperan las variables de entorno distribuidas ( world_size , rank ...) puede ser específica para el clúster y el lanzador que usa.
A continuación se indican los tiempos de entrenamiento para una VAE cuantificada vectorial (VQ-VAE) con Pythae para 100 épocas en MNIST en V100 16GB GPU (S), para 50 épocas en FFHQ (imágenes 1024x1024) y para 20 épocas en Imagenet-1k en V100 32GB GPU (S).
| Datos de tren | 1 GPU | 4 GPU | 2x4 GPU | |
|---|---|---|---|---|
| Mnist (VQ-Vae) | 28x28 imágenes (50k) | 235.18 S | 62.00 s | 35.86 s |
| FFHQ 1024x1024 (vqvae) | 1024x1024 Imágenes RGB (60k) | 19h 1min | 5h 6min | 2h 37min |
| Imagenet-1k 128x128 (vqvae) | 128x128 Imágenes RGB (~ 1.2m) | 6h 25min | 1h 41min | 51min 26S |
Para cada conjunto de datos, proporcionamos los scripts de evaluación comparativa aquí
Pythae también le permite compartir sus modelos en el Hub Huggingface. Para hacerlo, necesitas:
huggingface_hub instalado en su env de vista virtual. Si no, puede instalarlo con $ python -m pip install huggingface_hub
$ huggingface-cli login
Cualquier modelo Pythae se puede cargar fácilmente utilizando el método push_to_hf_hub
> >> my_vae_model . push_to_hf_hub ( hf_hub_path = "your_hf_username/your_hf_hub_repo" ) NOTA: Si your_hf_hub_repo ya existe y no está vacío, los archivos se anularán. En caso de que el repositorio your_hf_hub_repo no exista, se creará una carpeta que tiene el mismo nombre.
De manera equivalente, puede descargar o recargar cualquier modelo de Pythae directamente desde el concentrador utilizando el método load_from_hf_hub
> >> from pythae . models import AutoModel
> >> my_downloaded_vae = AutoModel . load_from_hf_hub ( hf_hub_path = "path_to_hf_repo" )wandb ?Pythae también integra la herramienta de seguimiento del experimento Wandb, lo que permite a los usuarios almacenar sus configuraciones, monitorear sus entrenamientos y comparar las ejecuciones a través de una interfaz gráfica. Para poder usar esta función que necesitará:
wandb instalado en su env de virtual. Si no, puede instalarlo con $ pip install wandb
$ wandb login
WandbCallback Lanzar un experimento monitoreo con wandb en Pythae es bastante simple. Lo único que un usuario necesita hacer es crear una instancia WandbCallback ...
> >> # Create you callback
>> > from pythae . trainers . training_callbacks import WandbCallback
> >> callbacks = [] # the TrainingPipeline expects a list of callbacks
> >> wandb_cb = WandbCallback () # Build the callback
> >> # SetUp the callback
>> > wandb_cb . setup (
... training_config = your_training_config , # training config
... model_config = your_model_config , # model config
... project_name = "your_wandb_project" , # specify your wandb project
... entity_name = "your_wandb_entity" , # specify your wandb entity
... )
> >> callbacks . append ( wandb_cb ) # Add it to the callbacks list ... y luego pasarlo a la TrainingPipeline .
> >> pipeline = TrainingPipeline (
... training_config = config ,
... model = model
... )
> >> pipeline (
... train_data = train_dataset ,
... eval_data = eval_dataset ,
... callbacks = callbacks # pass the callbacks to the TrainingPipeline and you are done!
... )
> >> # You can log to https://wandb.ai/your_wandb_entity/your_wandb_project to monitor your trainingVer el tutorial detallado
mlflow ?Pythae también integra la herramienta de seguimiento de experimentos Mlflow, lo que permite a los usuarios almacenar sus configuraciones, monitorear sus entrenamientos y comparar las ejecuciones a través de una interfaz gráfica. Para poder usar esta función que necesitará:
mlfow instalado en su env de vista virtual. Si no, puede instalarlo con $ pip install mlflow
MLFlowCallback Lanzar un experimento monitoreo con mlfow en Pythae es bastante simple. Lo único que un usuario necesita hacer es crear una instancia MLFlowCallback ...
> >> # Create you callback
>> > from pythae . trainers . training_callbacks import MLFlowCallback
> >> callbacks = [] # the TrainingPipeline expects a list of callbacks
> >> mlflow_cb = MLFlowCallback () # Build the callback
> >> # SetUp the callback
>> > mlflow_cb . setup (
... training_config = your_training_config , # training config
... model_config = your_model_config , # model config
... run_name = "mlflow_cb_example" , # specify your mlflow run
... )
> >> callbacks . append ( mlflow_cb ) # Add it to the callbacks list ... y luego pasarlo a la TrainingPipeline .
> >> pipeline = TrainingPipeline (
... training_config = config ,
... model = model
... )
> >> pipeline (
... train_data = train_dataset ,
... eval_data = eval_dataset ,
... callbacks = callbacks # pass the callbacks to the TrainingPipeline and you are done!
... ) Puede visualizar su métrica ejecutando lo siguiente en el directorio donde el ./mlruns
$ mlflow ui Ver el tutorial detallado
comet_ml ?Pythae también integra la herramienta de seguimiento de experimentos Comet_ML, lo que permite a los usuarios almacenar sus configuraciones, monitorear sus entrenamientos y comparar las ejecuciones a través de una interfaz gráfica. Para poder usar esta función que necesitará:
comet_ml instalado en su env virtual. Si no, puede instalarlo con $ pip install comet_ml
CometCallback Lanzar un experimento monitoreo con comet_ml en Pythae es bastante simple. Lo único que un usuario necesita hacer es crear una instancia CometCallback ...
> >> # Create you callback
>> > from pythae . trainers . training_callbacks import CometCallback
> >> callbacks = [] # the TrainingPipeline expects a list of callbacks
> >> comet_cb = CometCallback () # Build the callback
> >> # SetUp the callback
>> > comet_cb . setup (
... training_config = training_config , # training config
... model_config = model_config , # model config
... api_key = "your_comet_api_key" , # specify your comet api-key
... project_name = "your_comet_project" , # specify your wandb project
... #offline_run=True, # run in offline mode
... #offline_directory='my_offline_runs' # set the directory to store the offline runs
... )
> >> callbacks . append ( comet_cb ) # Add it to the callbacks list ... y luego pasarlo a la TrainingPipeline .
> >> pipeline = TrainingPipeline (
... training_config = config ,
... model = model
... )
> >> pipeline (
... train_data = train_dataset ,
... eval_data = eval_dataset ,
... callbacks = callbacks # pass the callbacks to the TrainingPipeline and you are done!
... )
> >> # You can log to https://comet.com/your_comet_username/your_comet_project to monitor your trainingVer el tutorial detallado
Para ayudarlo a comprender la forma en que funciona Pythae y cómo puede capacitar a sus modelos con esta biblioteca, también proporcionamos tutoriales:
Making_your_own_autoencoder.ipynb le muestra cómo pasar sus propias redes a los modelos implementados en Pythae
custom_dataset.ipynb le muestra cómo usar conjuntos de datos personalizados con cualquiera de los modelos implementados en Pythae
HF_HUB_MODELS_SHARING.IPYNB le muestra cómo cargar y descargar modelos para el Hub Huggingface
wandb_experiment_monitoring.ipynb le muestra cómo monitorear sus experimentos usando wandb
mlflow_experiment_monitoring.ipynb le muestra cómo monitorear sus experimentos usando mlflow
comet_experiment_monitoring.ipynb te muestra cómo monitorear tus experimentos usando comet_ml
La carpeta Models_Training proporciona cuadernos que muestran cómo capacitar a cada modelo implementado y cómo probarlo usando pythae.samplers .
La carpeta de Scripts proporciona en particular un ejemplo de un script de entrenamiento para entrenar los modelos en conjuntos de datos de referencia (MNIST, CIFAR10, Celeba ...)
Si está experimentando algún problema mientras ejecuta el código o solicita nuevas funciones/modelos que se implementarán, abra un problema en GitHub.
¿Desea contribuir a esta biblioteca agregando un modelo, una muestra o simplemente solucionar un error? ¡Eso es increíble! ¡Gracias! Consulte Contriping.MD para seguir las principales pautas contribuyentes.
Primero echemos un vistazo a las muestras reconstruidas tomadas del conjunto de evaluación.
| Modelos | Mnista | Ceneba |
|---|---|---|
| Evaluación de datos |  |  |
| Ae |  |  |
| VAE |  |  |
| Beta |  |  |
| VAE LIN NF |  |  |
| VAE IF |  |  |
| Desanimado beta-Vae |  |  |
| Factorvas |  |  |
| Betatcvae |  |  |
| Iwae |  |  |
| Msssim_vae |  |  |
| Wae |  |  |
| Información VAE |  |  |
| VAMP |  |  |
| Sva |  |  |
| Adversar_ae |  |  |
| Vae_gan |  |  |
| Vqvae |  |  |
| Hvae |  |  |
| RAE_L2 |  |  |
| RAE_GP |  |  |
| Riemannian hamiltonian vae (rhvae) |  |  |
Aquí, mostramos las muestras generadas utilizando cada modelo implementado en la biblioteca y diferentes muestras.
| Modelos | Mnista | Ceneba |
|---|---|---|
| AE + GaussianMixturesMpler |  |  |
| VAE + Normalsampler |  |  |
| VAE + GaussianMixturesAmpler |  |  |
| VAE + TWOSTAVAESAMPLER |  |  |
| VAE + Mafsampler |  |  |
| Beta-Vae + Amalsampler |  |  |
| VAE LIN NF + Normalsampler |  |  |
| VAE IF + Normalsampler |  |  |
| Desenglido Beta-Vae + Normalsampler |  |  |
| FactorVae + Normalsampler |  |  |
| Betatcvae + Amalsampler |  |  |
| Iwae + muestreador normal |  |  |
| MSSSIM_VAE + Normalsampler |  |  |
| WAE + Normalsampler |  |  |
| Info VAE + Normalsampler |  |  |
| SVAE + HyperSerhereuniformsampler |  |  |
| Vampirrenador + vampiros |  |  |
| Adversarial_ae + normalsampler |  |  |
| VAEGAN + NORMALSMAMER |  |  |
| Vqvae + mafsampler |  |  |
| HVAE + Amalsampler |  |  |
| Rae_l2 + gaussianmixturesampler |  |  |
| Rae_gp + gaussianmixturesampler |  |  |
| Vae hamiltoniano riemanniano (Rhvae) + Rhvae Sampler |  |  |
Si encuentra útil este trabajo o lo usa en su investigación, considere citarnos
@inproceedings { chadebec2022pythae ,
author = { Chadebec, Cl'{e}ment and Vincent, Louis and Allassonniere, Stephanie } ,
booktitle = { Advances in Neural Information Processing Systems } ,
editor = { S. Koyejo and S. Mohamed and A. Agarwal and D. Belgrave and K. Cho and A. Oh } ,
pages = { 21575--21589 } ,
publisher = { Curran Associates, Inc. } ,
title = { Pythae: Unifying Generative Autoencoders in Python - A Benchmarking Use Case } ,
volume = { 35 } ,
year = { 2022 }
}
