benchmark_VAE
Pythae 0.1.2
Dokumentation
Diese Bibliothek implementiert einige der häufigsten (variativen) Autocodermodelle unter einer einheitlichen Implementierung. Insbesondere bietet es die Möglichkeit, Benchmark -Experimente und -vergleiche durchzuführen, indem die Modelle mit derselben automatischen Architektur neuronaler Netzwerk trainiert werden. Mit der Funktion können Sie einen eigenen AutoCodierer ermöglichen, wenn Sie alle dieser Modelle mit Ihren eigenen Daten und Ihren eigenen Encoder- und Decoder -neuronalen Netzwerken schulen. Es integriert Experiment-Überwachungstools wie Wandb, MLFlow oder Comet-ML? und ermöglicht das Teilen und Laden von Modells aus dem Huggingface -Hub? in einigen Codezeilen.
Nachricht ?
Ab V0.1.0 unterstützt Pythae nun ein verteiltes Training mit Pytorch's DDP. Sie können jetzt Ihre Lieblings -VAE schneller und auf größeren Datensätzen trainieren, immer noch mit ein paar Codezeilen. Sehen Sie unseren Geschwindigkeits-Benchmark.
wandb / Experiment -Tracking mit mlflow / Experiment -Tracking mit comet_ml pip die neueste stabile Version dieser Bibliothek zu installieren
$ pip install pythae pip installieren
$ pip install git+https://github.com/clementchadebec/benchmark_VAE.gitOder alternativ können Sie das Github -Repo klonen, um auf Tests, Tutorials und Skripte zuzugreifen.
$ git clone https://github.com/clementchadebec/benchmark_VAE.gitund installieren Sie die Bibliothek
$ cd benchmark_VAE
$ pip install -e . Nachfolgend finden Sie die Liste der Modelle, die derzeit in der Bibliothek implementiert sind.
| Modelle | Trainingsbeispiel | Papier | Offizielle Umsetzung |
|---|---|---|---|
| AUTOCODER (AE) | |||
| Variationsautocoder (VAE) | Link | ||
| Beta Variational AutoCoder (Betavae) | Link | ||
| Vae mit linearen Normalisierungsströmen (VAE_LINNF) | Link | ||
| Vae mit umgekehrten autoregressiven Flüssen (VAE_IAF) | Link | Link | |
| Beta -Variationsautoencoder (Disentangledbetavae) entwirrt. | Link | ||
| Durch faktorisierende Entwirrung (Faktorvae) entwirren | Link | ||
| Beta-tc-vae (Betatcvae) | Link | Link | |
| Wichtigkeit gewichteter Autocoder (IWAE) | Link | Link | |
| Multiplizieren Sie die gewichtete Autocoder (Miwae) | Link | ||
| Teilweise Wichtigkeit gewichteter Autocoder (Piwae) | Link | ||
| Kombination Wichtigkeit gewichteter Autocoder (CIWAE) | Link | ||
| VAE mit Wahrnehmungsmetrikähnlichkeit (MSSSIM_VAE) | Link | ||
| Wasserstein AutoCoder (WAE) | Link | Link | |
| Info Variational AutoCoder (Infovae_mmd) | Link | ||
| VAMP Autocoder (VAMP) | Link | Link | |
| Hypersphärische Vae (SVAE) | Link | Link | |
| Poincaré Disk Vae (Poincarevae) | Link | Link | |
| Gegenteiler Autocoder (adversarial_ae) | Link | ||
| Variationsautocoder Gan (Vaegan)? | Link | Link | |
| Vektor quantisierte VAE (VQVAE) | Link | Link | |
| Hamiltonian Vae (Hvae) | Link | Link | |
| Reguliert AE mit L2 Decoder Param (RAE_L2) | Link | Link | |
| Reguliert AE mit Gradientenstrafe (RAE_GP) | Link | Link | |
| Riemannian Hamiltonian Vae (Rhvae) | Link | Link | |
| Hierarchische Restquantisierung (HRQVAE) | Link | Link |
Siehe Rekonstruktions- und Erzeugungsergebnisse für alle oben genannten Modelle
Nachfolgend finden Sie die Liste der Modelle, die derzeit in der Bibliothek implementiert sind.
| Sampler | Modelle | Papier | Offizielle Umsetzung |
|---|---|---|---|
| Normaler vorheriger (NormalSampler) | alle Modelle | Link | |
| Gaußsche Mischung (Gaußsianmixturesampler) | alle Modelle | Link | Link |
| Zwei -Stufe VAE -Sampler (Twostagevaessampler) | Alle VAE -basierten Modelle | Link | Link |
| Einheitskugel gleichmäßiger Sampler (HypersphereuniformSampler) | Svae | Link | Link |
| Poincaré -Disk -Sampler (Poincaredisksampler) | Poincarevae | Link | Link |
| VAMP -Vor -Sampler (Vampsampler) | VAMP | Link | Link |
| Krümmerabtaster (RHVAeSampler) | RHVAE | Link | Link |
| Maskierter autoregressiver Strömungsprobler (Mafsampler) | alle Modelle | Link | Link |
| Inverse autoregressive Strömungsabtaster (IAFSampler) | alle Modelle | Link | Link |
| Pixelcnn (Pixelcnnnsampler) | Vqvae | Link |
Wir validieren die Implementierungen, indem wir einige in den ursprünglichen Veröffentlichungen vorgestellte Ergebnisse reproduzieren, als der offizielle Code veröffentlicht wurde oder wenn genügend Einzelheiten zum experimentellen Abschnitt der Papiere verfügbar waren. Weitere Informationen finden Sie unter Reproduzierbarkeit.
Um ein Modelltraining zu starten, müssen Sie nur eine TrainingPipeline -Instanz anrufen.
> >> 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
... ) Am Ende des Trainings werden die besten Modellgewichte, die Modellkonfiguration und die Trainingskonfiguration in einem in my_model/MODEL_NAME_training_YYYY-MM-DD_hh-mm-ss verfügbaren final_model Ordner gespeichert (wobei my_model das output_dir des BaseTrainerConfig ist). Wenn Sie das Argument steps_saving auf einen bestimmten Wert" festlegen, werden die Ordner mit dem Namen checkpoint_epoch_k mit den besten Modellgewichten, Optimierer, Scheduler, Konfiguration und Trainingskonfiguration bei EPOCH K auch in my_model/MODEL_NAME_training_YYYY-MM-DD_hh-mm-ss angezeigt.
Wir bieten hier auch ein Trainingsskriptbeispiel, mit dem die Modelle auf Benchmarks -Datensätzen trainieren können (MNIST, CIFAR10, Celeba ...). Das Skript kann mit der folgenden Befehlszeile gestartet werden
python training.py --dataset mnist --model_name ae --model_config ' configs/ae_config.json ' --training_config ' configs/base_training_config.json 'Weitere Informationen zu diesem Skript finden Sie unter Readme.md
GenerationPipeline Der einfachste Weg, eine Datenerzeugung aus einem geschulten Modell zu starten, besteht darin, die in ein integrierte GenerationPipeline in Pythae zu verwenden. Angenommen, Sie möchten 100 Proben mit einem MAFSampler generieren, was Sie tun müssen, ist 1) RELAOD DAS GELAGED MODELL, 2) Definieren Sie die Konfiguration des Stichprobens und 3) Erstellen und starten Sie die GenerationPipeline wie folgt wie folgt
> >> 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
... )Alternativ können Sie den Datengenerierungsprozess direkt mit dem Sampler von einem geschulten Modell aus starten. Führen Sie beispielsweise Folgendes aus, um neue Daten mit Ihrem Sampler zu generieren.
> >> 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
... ) Wenn Sie output_dir auf einen bestimmten Pfad festlegen, werden die generierten Bilder als .png -Dateien mit dem Namen 00000000.png , 00000001.png ... gespeichert ... Die Sampler können mit jedem Modell verwendet werden, solange es geeignet ist. Beispielsweise kann eine GaussianMixtureSampler -Instanz verwendet werden, um aus jedem Modell zu generieren, aber ein VAMPSampler kann nur mit einem VAMP -Modell verwendet werden. Sehen Sie sich hier an, welche für Ihr Modell gelten. Achten Sie darauf, dass einige Sampler wie die GaussianMixtureSampler beispielsweise möglicherweise angepasst werden müssen, indem Sie die fit vor der Verwendung aufrufen. Unten finden Sie ein Beispiel für den 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 bietet Ihnen die Möglichkeit, Ihre eigenen neuronalen Netze in den VAE -Modellen zu definieren. Angenommen, Sie möchten einen Wassertstein AE mit einem bestimmten Encoder und Decoder trainieren, können Sie Folgendes tun:
> >> 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 ()Und bauen Sie jetzt das Modell auf
> >> 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
... ) Wichtiger Anmerkung 1 : Für alle AE-basierten Modelle (AE, WAE, RAE_L2, RAE_GP) müssen sowohl der Encoder als auch der Decoder eine ModelOutput Instanz zurückgeben. Für den Encoder muss die ModelOutput -Instanz die Einbettungen unter der wichtigsten embedding enthalten. Für den Decoder muss die ModelOutput -Instanz die Rekonstruktionen unter der reconstruction enthalten.
Wichtiger Anmerkung 2 : Für alle vae-basierten Modelle (VAE, Betavae, Iwae, Hvae, VAMP, RHVAE) müssen sowohl der Encoder als auch der Decoder eine ModelOutput Instanz zurückgeben. Für den Encoder muss die ModelOutput -Instanz die Embbettings und log -Kovarianzmatrizen (von Shape batch_size x latent_space_dim) unter dem Schlüssel embedding und log_covariance enthalten. Für den Decoder muss die ModelOutput -Instanz die Rekonstruktionen unter der reconstruction enthalten.
Sie können auch vordefinierte neuronale Netzwerkarchitekturen für die häufigsten Datensätze ( dh MNIST, CIFAR, Celeba ...) finden, die wie folgt geladen werden können
> >> 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
... )Ersetzen Sie MNIST durch Cifar oder Celeba, um auf andere neuronale Netze zuzugreifen.
Pythae Ab v0.1.0 unterstützt Pythae nun ein verteiltes Training mit Pytorch's DDP. Sie können Ihre Lieblings-VAE schneller und auf größerem Datensatz mithilfe von Multi-GPU- und/oder Multi-Knoten-Training trainieren.
Dazu können Sie ein Python -Skript erstellen, das dann von einem Launcher (wie srun auf einem Cluster) gestartet wird. Das einzige, was im Skript benötigt wird, ist, einige Elemente in Bezug auf die verteilte Umgebung (wie die Anzahl der Knoten/GPUs) direkt in der Trainingskonfiguration wie folgt anzugeben
> >> 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,
... ) Siehe dieses Beispielskript, das ein Multi-GPU-VQVAE-Training auf dem ImageNet-Datensatz definiert. Bitte beachten Sie, dass die Art und Weise, wie die verteilten Umgebungsvariablen ( world_size , rank ...) wiederhergestellt werden, spezifisch für den von Ihnen verwendeten Cluster und Launcher sind.
Im Folgenden sind die Trainingszeiten für einen vektor-quantisierten VAE (VQ-VAE) mit Pythae für 100 Epochen auf MNIST auf V100 16 GB GPU (S) für 50 Epochen auf FFHQ (1024x1024-Bildern) und für 20 Epochen auf ImagNet-1K auf V100 32GB-GPU (S) (S) (S) (S) (S).
| Daten trainieren | 1 GPU | 4 GPUs | 2x4 GPUs | |
|---|---|---|---|---|
| MNIST (VQ-VAE) | 28x28 Bilder (50k) | 235.18 s | 62.00 s | 35,86 s |
| FFHQ 1024x1024 (VQVAE) | 1024x1024 RGB -Bilder (60k) | 19h 1min | 5H 6min | 2H 37min |
| ImageNET-1K 128x128 (VQVAE) | 128x128 RGB -Bilder (~ 1,2 m) | 6h 25 min | 1H 41 min | 51 min 26s |
Für jeden Datensatz geben wir hier die Benchmarking -Skripte an
Mit Pythae können Sie auch Ihre Modelle auf dem Hubface -Hub teilen. Um dies zu tun, brauchen Sie:
huggingface_hub . Wenn nicht, können Sie es mit installieren $ python -m pip install huggingface_hub
$ huggingface-cli login
Jedes Pythae -Modell kann einfach mit der Methode push_to_hf_hub hochgeladen werden
> >> my_vae_model . push_to_hf_hub ( hf_hub_path = "your_hf_username/your_hf_hub_repo" ) HINWEIS: Wenn your_hf_hub_repo bereits vorhanden ist und nicht leer ist, werden Dateien überschrieben. Falls das Repo your_hf_hub_repo nicht existiert, wird ein Ordner mit demselben Namen erstellt.
load_from_hf_hub können Sie jedes Pythae -Modell direkt aus der Hub herunterladen oder neu laden
> >> from pythae . models import AutoModel
> >> my_downloaded_vae = AutoModel . load_from_hf_hub ( hf_hub_path = "path_to_hf_repo" )wandb ?Pythae integriert auch das Experiment -Tracking -Tool Wandb, mit dem Benutzer ihre Konfigurationen speichern, ihre Schulungen überwachen und die Läufe über eine grafische Schnittstelle vergleichen können. Um diese Funktion verwenden zu können, benötigen Sie:
wandb . Wenn nicht, können Sie es mit installieren $ pip install wandb
$ wandb login
WandbCallback Die Einführung einer Experimentsüberwachung mit wandb in Pythae ist ziemlich einfach. Das einzige, was ein Benutzer tun muss, ist eine WandbCallback -Instanz zu erstellen ...
> >> # 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 ... und geben Sie es dann an die 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 trainingSiehe das detaillierte Tutorial
mlflow ?Pythae integriert auch das Experiment -Tracking -Tool MLFlow, mit dem Benutzer ihre Konfigurationen speichern, ihre Schulungen überwachen und die Läufe über eine grafische Schnittstelle vergleichen können. Um diese Funktion verwenden zu können, benötigen Sie:
mlfow . Wenn nicht, können Sie es mit installieren $ pip install mlflow
MLFlowCallback Die Einführung einer Experimentüberwachung mit mlfow in Pythae ist ziemlich einfach. Das einzige, was ein Benutzer tun muss, ist eine MLFlowCallback -Instanz zu erstellen ...
> >> # 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 ... und geben Sie es dann an die 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!
... ) Sie können Ihre Metrik visualisieren, indem Sie Folgendes im Verzeichnis ausführen, in dem die ./mlruns
$ mlflow ui Siehe das detaillierte Tutorial
comet_ml ?Pythae integriert auch das Experiment -Tracking -Tool comet_ml, mit dem Benutzer ihre Konfigurationen speichern, ihre Schulungen überwachen und die Läufe über eine grafische Schnittstelle vergleichen können. Um diese Funktion verwenden zu können, benötigen Sie:
comet_ml in Ihrer virtuellen Umgebung installiert. Wenn nicht, können Sie es mit installieren $ pip install comet_ml
CometCallback Das Starten einer Experimentüberwachung mit comet_ml in Pythae ist ziemlich einfach. Das einzige, was ein Benutzer tun muss, ist eine CometCallback -Instanz zu erstellen ...
> >> # 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 ... und geben Sie es dann an die 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 trainingSiehe das detaillierte Tutorial
Um Ihnen zu helfen, zu verstehen, wie Pythae funktioniert und wie Sie Ihre Modelle mit dieser Bibliothek trainieren können, stellen wir auch Tutorials an:
make_your_own_autoencoder.ipynb zeigt Ihnen, wie Sie Ihre eigenen Netzwerke an die in Pythae implementierten Modelle übergeben können
Custom_dataset.ipynb zeigt, wie Sie benutzerdefinierte Datensätze mit einem der in Pythae implementierten Modelle verwenden
hf_hub_models_sharing.ipynb zeigt Ihnen, wie Sie Modelle für den Huggingface -Hub hochladen und herunterladen
wandb_experiment_monitoring.ipynb zeigt Ihnen, wie Sie Ihre Experimente mit wandb überwachen
mlflow_experiment_monitoring.ipynb zeigt Ihnen, wie Sie Ihre Experimente mit mlflow überwachen
comet_experiment_monitoring.ipynb zeigt Ihnen, wie Sie Ihre Experimente mit comet_ml überwachen können
Models_Training -Ordner bietet Notebooks, die zeigen, wie jedes implementierte Modell trainiert wird und wie man mit pythae.samplers davon probiert.
Der Scripts -Ordner bietet insbesondere ein Beispiel für ein Trainingsskript, um die Modelle in Benchmark -Datensätzen zu trainieren (MNIST, CIFAR10, Celeba ...)
Wenn Sie Probleme haben, während Sie den Code ausführen oder neue Funktionen/Modelle anfordern, die implementiert werden sollen, öffnen Sie bitte ein Problem auf GitHub.
Sie möchten zu dieser Bibliothek beitragen, indem Sie ein Modell, einen Sampler oder einfach einen Fehler fixieren? Das ist großartig! Danke schön! Bitte befolgen Sie die wichtigsten Richtlinien.
Schauen wir uns zunächst die rekonstruierten Proben an, die aus dem Bewertungssatz entnommen wurden.
| Modelle | MNIST | Celeba |
|---|---|---|
| Daten bewerten |  |  |
| Ae |  |  |
| Vae |  |  |
| Beta-vae |  |  |
| VAE Lin Nf |  |  |
| VAE IAF |  |  |
| Beta-vae entwirrt |  |  |
| Faktorvae |  |  |
| Betatcvae |  |  |
| Iwae |  |  |
| MSSSIM_VAE |  |  |
| Wae |  |  |
| Info Vae |  |  |
| VAMP |  |  |
| Svae |  |  |
| Kontrovers_ae |  |  |
| VAE_GAN |  |  |
| Vqvae |  |  |
| Hvae |  |  |
| Rae_l2 |  |  |
| Rae_gp |  |  |
| Riemannian Hamiltonian Vae (Rhvae) |  |  |
Hier zeigen wir die generierten Samples anhand jedes in der Bibliothek implementierten Modells und verschiedenen Stichproben.
| Modelle | MNIST | Celeba |
|---|---|---|
| AE + GAUSSIANMIXTUREMPLER |  |  |
| VAE + NORMALSAMPLER |  |  |
| VAE + GAUSSIANMICTUREAMPLER |  |  |
| VAE + TWOSTAGEVAESAMPLER |  |  |
| Vae + Mafsampler |  |  |
| Beta-vae + NormalSampler |  |  |
| VAE lin NF + NormalSampler |  |  |
| VAE IAF + NORMALSAMPLER |  |  |
| Beta-vae + NormalSampler entwirrt |  |  |
| Faktorvae + NormalSampler |  |  |
| BetaTcvae + NormalSampler |  |  |
| Iwae + normaler Sampler |  |  |
| MSSSIM_VAE + NORMALSAMPLER |  |  |
| Wae + NormalSampler |  |  |
| Info Vae + NormalSampler |  |  |
| Svae + hypershereuniformSampler |  |  |
| VAMP + VAMPSAMPLER |  |  |
| Edversarial_ae + normalSampler |  |  |
| Vaegan + NormalSampler |  |  |
| Vqvae + mafsampler |  |  |
| Hvae + NormalSampler |  |  |
| Rae_l2 + gaußsianmixturesAmpler |  |  |
| Rae_gp + gaußsianmixturesAmpler |  |  |
| Riemannian Hamiltonian Vae (RHVAE) + RHVAE -Sampler |  |  |
Wenn Sie diese Arbeit nützlich finden oder sie in Ihren Forschungen verwenden, sollten Sie uns untersuchen
@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 }
}
