PyTorch StudioGAN
v.0.4.0
Studiogan est une bibliothèque Pytorch fournissant des implémentations de réseaux adversaires génératifs représentatifs (GAN) pour la génération d'images conditionnelle / inconditionnelle. Studiogan vise à offrir un terrain de jeu identique aux Gans modernes afin que les chercheurs de l'apprentissage automatique puissent facilement comparer et analyser une nouvelle idée.
De plus , Studiogan fournit une référence à échelle sans précédent pour les modèles génératifs. La référence comprend les résultats des GAN (Biggan-Deep, Stylegan-XL), des modèles auto-régressifs (Maskgit, RQ-Transformateur) et des modèles de diffusion (LSGM ++, CLD-SGM, ADM-Gu).
| Méthode | Lieu | Architecture | GC | Dc | Perte | Ema |
|---|---|---|---|---|---|---|
| Dcgan | arXiv'15 | Dcgan / resnetgan 1 | N / A | N / A | Vanille | FAUX |
| Infogan | Nips'16 | Dcgan / resnetgan 1 | N / A | N / A | Vanille | FAUX |
| Lsgan | ICCV'17 | Dcgan / resnetgan 1 | N / A | N / A | Le moins sqaure | FAUX |
| Ggan | arXiv'17 | Dcgan / resnetgan 1 | N / A | N / A | Charnière | FAUX |
| Wgan-wc | ICLR'17 | Resnetgan | N / A | N / A | Wasserstein | FAUX |
| Wgan-gp | Nips'17 | Resnetgan | N / A | N / A | Wasserstein | FAUX |
| Wgan-dra | arXiv'17 | Resnetgan | N / A | N / A | Wasserstein | FAUX |
| Acgan-mod 2 | - | Resnetgan | cbn | CA | Charnière | FAUX |
| Pdgan | Iclr'18 | Resnetgan | cbn | PD | Charnière | FAUX |
| Sngan | Iclr'18 | Resnetgan | cbn | PD | Charnière | FAUX |
| Sagan | Icml'19 | Resnetgan | cbn | PD | Charnière | FAUX |
| Tacgan | Nererips'19 | Grandeur | cbn | Tac | Charnière | Vrai |
| Lgan | Icml'19 | Resnetgan | N / A | N / A | Vanille | FAUX |
| Biggan inconditionnel | Iclr'19 | Grandeur | N / A | N / A | Charnière | Vrai |
| Grandeur | Iclr'19 | Grandeur | cbn | PD | Charnière | Vrai |
| Compare-compagnie de profondeur | Iclr'19 | Comparegan en profondeur | cbn | PD | Charnière | Vrai |
| Grandeur de fond | - | Studiogan en profondeur | cbn | PD | Charnière | Vrai |
| Stylegan2 | CVPR '20 | Stylegan2 | cadain | SPD | Logistique | Vrai |
| Crgan | Iclr'20 | Grandeur | cbn | PD | Charnière | Vrai |
| Icrgan | Aaai'21 | Grandeur | cbn | PD | Charnière | Vrai |
| Logan | arXiv'19 | Resnetgan | cbn | PD | Charnière | Vrai |
| Contrefait | Neirips'20 | Grandeur | cbn | 2c | Charnière | Vrai |
| Mhgan | Wacv'21 | Grandeur | cbn | MH | MH | Vrai |
| Biggan + diffaugment | Neirips'20 | Grandeur | cbn | PD | Charnière | Vrai |
| Stylegan2 + Ada | Neirips'20 | Stylegan2 | cadain | SPD | Logistique | Vrai |
| Biggan + Lecam | CVPR'2021 | Grandeur | cbn | PD | Charnière | Vrai |
| Rearecgan | Nererips'21 | Grandeur | cbn | D2D-CE | Charnière | Vrai |
| Stylegan2 + apa | Nererips'21 | Stylegan2 | cadain | SPD | Logistique | Vrai |
| Stylegan3-t | Nererips'21 | Stylegan3 | Caain | SPD | Logistique | Vrai |
| Stylegan3-r | Nererips'21 | Stylegan3 | Caain | SPD | Logistique | Vrai |
| Adcgan | Icml'22 | Grandeur | cbn | ADC | Charnière | Vrai |
GC / DC indique la façon dont nous injectons les informations sur l'étiquette au générateur ou au discriminateur.
EMA: mise à jour de moyenne mobile exponentielle du générateur. CBN: normalisation du lot conditionnel. Cadain: version conditionnelle de la normalisation des instances adaptatives. AC: Classificateur auxiliaire. PD: Discriminateur de projection. TAC: classificateur auxiliaire jumeau. SPD: PD modifié pour Stylegan. 2c: perte contrastive conditionnelle. MH: Perte multi-hardhes. ADC: classificateur discriminant auxiliaire. D2D-CE: entropie croisée de données sur les données.
| Méthode | Lieu | Architecture |
|---|---|---|
| Score de création (IS) | Nererips'16 | Inceptionv3 |
| Distance de création de Frechet (FID) | Nererips'17 | Inceptionv3 |
| Amélioration de la précision et du rappel | Nererips'19 | Inceptionv3 |
| Score de précision du classificateur (CAS) | Nererips'19 | Inceptionv3 |
| Densité et couverture | Icml'20 | Inceptionv3 |
| FID intra-classe | - | Inceptionv3 |
| Swav FID | Iclr'21 | Agiter |
| Mesures propres (IS, FID, PRDC) | Cvpr'22 | Inceptionv3 |
| Métriques conviviales en architecture (IS, FID, PRDC) | arXiv'22 | Non limité à INCECKETV3 |
| Méthode | Lieu | Architecture cible |
|---|---|---|
| Congélé | Cvprw'20 | Sauf pour stylegan2 |
| Formation Top-K | Neirips'2020 | - |
| DDL | Neirips'2020 | - |
| Sefa | CVPR'2021 | Grandeur |
Nous vérifions la reproductibilité des Gans mis en œuvre dans Studiogan en comparant IS et FID avec les articles originaux. Nous identifions notre plateforme reproduit avec succès la plupart des Gans représentatifs, à l'exception de PD-GAN, ACGAN, LOGAN, SAGAN et BIGGAN-EFFED. FQ signifie Flickr-Faces-HQ DataSet (FFHQ). Les résolutions des ensembles de données ImageNet, AFHQV2 et FQ sont respectivement de 128, 512 et 1024.
Tout d'abord, installez Pytorch en rencontrant votre environnement (au moins 1,7):
pip install torch torchvision torchaudio --extra-index-url https://download.pytorch.org/whl/cu116Ensuite, utilisez la commande suivante pour installer le reste des bibliothèques:
pip install tqdm ninja h5py kornia matplotlib pandas sklearn scipy seaborn wandb PyYaml click requests pyspng imageio-ffmpeg timmAvec Docker, vous pouvez utiliser (mis à jour 14 / déc / 2022):
docker pull alex4727/experiment:pytorch113_cuda116Il s'agit de notre commande de fabriquer un conteneur nommé "Studiogan".
docker run -it --gpus all --shm-size 128g --name StudioGAN -v /path_to_your_folders:/root/code --workdir /root/code alex4727/experiment:pytorch113_cuda116 /bin/zshSi votre version Nvidia Driver ne satisfait pas aux exigences, vous pouvez essayer d'ajouter ci-dessous à la commande ci-dessus.
--env NVIDIA_DISABLE_REQUIRE=true CIFAR10 / CIFAR100: Studiogan téléchargera automatiquement l'ensemble de données une fois que vous exécutez main.py
Tiny ImageNet, Imagenet ou un ensemble de données personnalisés:
data
└── ImageNet, Tiny_ImageNet, Baby ImageNet, Papa ImageNet, or Grandpa ImageNet
├── train
│ ├── cls0
│ │ ├── train0.png
│ │ ├── train1.png
│ │ └── ...
│ ├── cls1
│ └── ...
└── valid
├── cls0
│ ├── valid0.png
│ ├── valid1.png
│ └── ...
├── cls1
└── ...
Avant de commencer, les utilisateurs doivent se connecter WANDB en utilisant leur clé API personnelle.
wandb login PERSONAL_API_KEY À partir de la version 0.3.0, vous pouvez désormais définir les mesures d'évaluation à utiliser via l'option -metrics . Ne pas spécifier l'option par défaut pour calculer le FID uniquement. IE -metrics is fid calcule uniquement est et FID et -metrics none ne saute l'évaluation.
-t ) et évaluer est, FID, PRC, Rec, DNS, CVG ( -metrics is fid prdc ) du modèle défini dans CONFIG_PATH en utilisant GPU 0 . CUDA_VISIBLE_DEVICES=0 python3 src/main.py -t -metrics is fid prdc -cfg CONFIG_PATH -data DATA_PATH -save SAVE_PATH--pre_resizer lanczos ). Ensuite, Train ( -t ) et évaluez-vous amical, amical, FIMILY PRC, amical-REC, Friendly-DNS, amical-CVG ( -metrics is fid prdc --post_resizer clean ) du modèle défini dans CONFIG_PATH en utilisant GPU 0 . CUDA_VISIBLE_DEVICES=0 python3 src/main.py -t -metrics is fid prdc --pre_resizer lanczos --post_resizer clean -cfg CONFIG_PATH -data DATA_PATH -save SAVE_PATH-t ) et évaluer le FID du modèle défini dans CONFIG_PATH via DataParallel à l'aide de GPU (0, 1, 2, 3) . L'évaluation du FID ne nécessite pas d'argument ( -metrics )! CUDA_VISIBLE_DEVICES=0,1,2,3 python3 src/main.py -t -cfg CONFIG_PATH -data DATA_PATH -save SAVE_PATH-t ) et évaluation de saut ( -metrics none ) du modèle défini dans CONFIG_PATH via DistributedDataParallel en utilisant des GPU (0, 1, 2, 3) , Synchronized batch norm et Mixed precision . export MASTER_ADDR= " localhost "
export MASTER_PORT=2222
CUDA_VISIBLE_DEVICES=0,1,2,3 python3 src/main.py -t -metrics none -cfg CONFIG_PATH -data DATA_PATH -save SAVE_PATH -DDP -sync_bn -mpc Essayez python3 src/main.py pour voir les options disponibles.
Chargez toutes les données dans la mémoire principale ( -hdf5 -l )
CUDA_VISIBLE_DEVICES=0,...,N python3 src/main.py -t -hdf5 -l -cfg CONFIG_PATH -data DATA_PATH -save SAVE_PATH DistributedDataparalleall (veuillez vous référer à ici) ( -DDP )
# ## NODE_0, 4_GPUs, All ports are open to NODE_1
~ /code>>> export MASTER_ADDR=PUBLIC_IP_OF_NODE_0
~ /code>>> export MASTER_PORT=AVAILABLE_PORT_OF_NODE_0
~ /code/PyTorch-StudioGAN>>> CUDA_VISIBLE_DEVICES=0,1,2,3 python3 src/main.py -t -DDP -tn 2 -cn 0 -cfg CONFIG_PATH -data DATA_PATH -save SAVE_PATH # ## NODE_1, 4_GPUs, All ports are open to NODE_0
~ /code>>> export MASTER_ADDR=PUBLIC_IP_OF_NODE_0
~ /code>>> export MASTER_PORT=AVAILABLE_PORT_OF_NODE_0
~ /code/PyTorch-StudioGAN>>> CUDA_VISIBLE_DEVICES=0,1,2,3 python3 src/main.py -t -DDP -tn 2 -cn 1 -cfg CONFIG_PATH -data DATA_PATH -save SAVE_PATH Formation de précision mixte ( -mpc )
CUDA_VISIBLE_DEVICES=0,...,N python3 src/main.py -t -mpc -cfg CONFIG_PATH -data DATA_PATH -save SAVE_PATHModifier les statistiques de normalisation par lots
# Synchronized batchNorm (-sync_bn)
CUDA_VISIBLE_DEVICES=0,...,N python3 src/main.py -t -sync_bn -cfg CONFIG_PATH -data DATA_PATH -save SAVE_PATH
# Standing statistics (-std_stat, -std_max, -std_step)
CUDA_VISIBLE_DEVICES=0,...,N python3 src/main.py -std_stat -std_max STD_MAX -std_step STD_STEP -cfg CONFIG_PATH -ckpt CKPT -data DATA_PATH -save SAVE_PATH
# Batch statistics (-batch_stat)
CUDA_VISIBLE_DEVICES=0,...,N python3 src/main.py -batch_stat -cfg CONFIG_PATH -ckpt CKPT -data DATA_PATH -save SAVE_PATHTruc de troncature
CUDA_VISIBLE_DEVICES=0,...,N python3 src/main.py --truncation_factor TRUNCATION_FACTOR -cfg CONFIG_PATH -ckpt CKPT -data DATA_PATH -save SAVE_PATH Ddls ( -lgv -lgv_rate -lgv_std -lgv_decay -lgv_decay_steps -lgv_steps )
CUDA_VISIBLE_DEVICES=0,...,N python3 src/main.py -lgv -lgv_rate LGV_RATE -lgv_std LGV_STD -lgv_decay LGV_DECAY -lgv_decay_steps LGV_DECAY_STEPS -lgv_steps LGV_STEPS -cfg CONFIG_PATH -ckpt CKPT -data DATA_PATH -save SAVE_PATH Discriminateur de gel ( -freezeD )
CUDA_VISIBLE_DEVICES=0,...,N python3 src/main.py -t --freezeD FREEZED -ckpt SOURCE_CKPT -cfg TARGET_CONFIG_PATH -data DATA_PATH -save SAVE_PATH Studiogan prend en charge Image visualization, K-nearest neighbor analysis, Linear interpolation, Frequency analysis, TSNE analysis, and Semantic factorization . Tous les résultats seront enregistrés dans SAVE_DIR/figures/RUN_NAME/*.png .
CUDA_VISIBLE_DEVICES=0,...,N python3 src/main.py -v -cfg CONFIG_PATH -ckpt CKPT -save SAVE_DIR
CUDA_VISIBLE_DEVICES=0,...,N python3 src/main.py -knn -cfg CONFIG_PATH -ckpt CKPT -data DATA_PATH -save SAVE_PATHCUDA_VISIBLE_DEVICES=0,...,N python3 src/main.py -itp -cfg CONFIG_PATH -ckpt CKPT -save SAVE_DIRCUDA_VISIBLE_DEVICES=0,...,N python3 src/main.py -fa -cfg CONFIG_PATH -ckpt CKPT -data DATA_PATH -save SAVE_PATHCUDA_VISIBLE_DEVICES=0,...,N python3 src/main.py -tsne -cfg CONFIG_PATH -ckpt CKPT -data DATA_PATH -save SAVE_PATHCUDA_VISIBLE_DEVICES=0,...,N python3 src/main.py -sefa -sefa_axis SEFA_AXIS -sefa_max SEFA_MAX -cfg CONFIG_PATH -ckpt CKPT -save SAVE_PATHStudiogan soutient la formation de 30 Gans représentatifs de DCGAN à Stylegan3-R.
Nous avons utilisé différents scripts en fonction de l'ensemble de données et du modèle, et c'est le suivant:
CUDA_VISIBLE_DEVICES=0 python3 src/main.py -t -hdf5 -l -std_stat -std_max STD_MAX -std_step STD_STEP -metrics is fid prdc -ref " train " -cfg CONFIG_PATH -data DATA_PATH -save SAVE_PATH -mpc --post_resizer " friendly " --eval_backbone " InceptionV3_tf "CUDA_VISIBLE_DEVICES=0 python3 src/main.py -t -hdf5 -l -metrics is fid prdc -ref " train " -cfg CONFIG_PATH -data DATA_PATH -save SAVE_PATH -mpc --post_resizer " friendly " --eval_backbone " InceptionV3_tf "CUDA_VISIBLE_DEVICES=0,1,2,3 python3 src/main.py -t -hdf5 -l -sync_bn -std_stat -std_max STD_MAX -std_step STD_STEP -metrics is fid prdc -ref " train " -cfg CONFIG_PATH -data DATA_PATH -save SAVE_PATH -mpc --pre_resizer " lanczos " --post_resizer " friendly " --eval_backbone " InceptionV3_tf " export MASTER_ADDR= " localhost "
export MASTER_PORT=8888
CUDA_VISIBLE_DEVICES=0,1,2,3 python3 src/main.py -t -metrics is fid prdc -ref " train " -cfg CONFIG_PATH -data DATA_PATH -save SAVE_PATH -mpc --pre_resizer " lanczos " --post_resizer " friendly " --eval_backbone " InceptionV3_tf " export MASTER_ADDR= " localhost "
export MASTER_PORT=8888
CUDA_VISIBLE_DEVICES=0,1,2,3,4,5,6,7 python3 src/main.py -t -metrics is fid prdc -ref " train " -cfg CONFIG_PATH -data DATA_PATH -save SAVE_PATH -mpc --pre_resizer " lanczos " --post_resizer " friendly " --eval_backbone " InceptionV3_tf " Studiogan prend en charge le score de création, la distance de création de Frechet, la précision et le rappel améliorés, la densité et la couverture, le score de précision du classificateur intra-classe. Les utilisateurs peuvent obtenir des scores Intra-Class FID, Classifier Accuracy Score à l'aide des options -iFID, -GAN_train, and -GAN_test , respectivement.
Les utilisateurs peuvent modifier l'épine dorsale de l'évaluation de Inergionv3 à Resnet50, swav, dino ou transformateur SWIN en utilisant --eval_backbone ResNet50_torch, SwAV_torch, DINO_torch, or Swin-T_torch .
De plus, les utilisateurs peuvent calculer des mesures avec un résiseur propre ou convivial à l'aide de --post_resizer clean or friendly .
Le score de création (IS) est une métrique pour mesurer la quantité de GaN génère des images à haute fidélité et diverses. Le calcul nécessite le réseau de création-V3 pré-formé. Notez que nous ne divisons pas un ensemble de données en dix plis à calculer est dix fois.
Le FID est une métrique largement utilisée pour évaluer les performances d'un modèle GaN. Le calcul du FID nécessite le réseau de création-V3 pré-formé, et les approches modernes utilisent le FID basé sur TensorFlow. Studiogan utilise le FID basé sur Pytorch pour tester les modèles GaN dans le même environnement Pytorch. Nous montrons que l'implémentation de FID basée sur Pytorch fournit presque les mêmes résultats avec l'implémentation de TensorFlow (voir l'annexe F du papier Contragan).
Une précision et un rappel améliorés sont développés pour compenser les lacunes de la précision et du rappel. Comme l'IS, FID, le calcul de la précision améliorée et le rappel nécessite le modèle de création-V3 pré-formé. Studiogan utilise la mise en œuvre de Pytorch fournie par les développeurs de scores de densité et de couverture.
Les mesures de densité et de couverture peuvent estimer la fidélité et la diversité des images générées en utilisant le modèle de création-V3 pré-formé. Les mesures sont connues pour être robustes aux valeurs aberrantes, et ils peuvent détecter des distributions réelles et fausses identiques. Studiogan utilise la mise en œuvre officielle des auteurs Pytorch et Studiogan suit la suggestion de l'auteur pour la sélection des hyperparamètres.
Nous rapportons le meilleur est, FID, une précision et un rappel améliorés, ainsi que la densité et la couverture des Gans.
Pour télécharger tous les points de contrôle rapportés dans Studiogan, veuillez cliquer ici (Hugging Face Hub).
Vous pouvez évaluer le point de contrôle en ajoutant -ckpt CKPT_PATH Option avec le chemin de configuration correspondant -cfg CORRESPONDING_CONFIG_PATH .
Les résolutions de CIFAR10, Baby Imagenet, Papa Imagenet, Grandpa ImageNet, Imagenet, AFHQV2 et FQ sont respectivement 32, 64, 64, 64, 128, 512 et 1024.
Nous utilisons le même nombre d'images générées que les images d'entraînement pour la distance de création de Frechet (FID), la précision, le rappel, la densité et le calcul de la couverture. Pour les expériences utilisant Baby / Papa / Grandpa ImageNet et ImageNet, nous utilisons exceptionnellement des fausses images 50K contre un ensemble de formation complet en tant qu'images réelles.
Toutes les fonctionnalités et moments des ensembles de données de référence peuvent être téléchargés via des fonctionnalités et des moments .
Les résolutions d'imageNet-128 et d'imageNet 256 sont respectivement de 128 et 256.
Toutes les images utilisées pour la référence peuvent être téléchargées via un seul lecteur (seront téléchargées bientôt).
-metrics is fid prdc ) des dossiers d'image (déjà prétraités) enregistrés dans DSET1 et DSET2 en utilisant des GPU (0,...,N) . CUDA_VISIBLE_DEVICES=0,...,N python3 src/evaluate.py -metrics is fid prdc --dset1 DSET1 --dset2 DSET2-metrics is fid prdc ) du dossier d'image enregistré dans DSET2 en utilisant des fonctionnalités pré-calculées ( --dset1_feats DSET1_FEATS ), des moments de DSET1 ( --dset1_moments DSET1_MOMENTS ) et GPUS (0,...,N) . CUDA_VISIBLE_DEVICES=0,...,N python3 src/evaluate.py -metrics is fid prdc --dset1_feats DSET1_FEATS --dset1_moments DSET1_MOMENTS --dset2 DSET2-metrics is fid prdc --post_resizer friendly ) de dossiers d'images enregistrés dans DSET1 et DSET2 via DistributedDataParallel à l'aide de GPU (0,...,N) . export MASTER_ADDR= " localhost "
export MASTER_PORT=2222
CUDA_VISIBLE_DEVICES=0,...,N python3 src/evaluate.py -metrics is fid prdc --post_resizer friendly --dset1 DSET1 --dset2 DSET2 -DDP[Licence MIT] Batchnorm synchronisé: https://github.com/vacancy/synchronized-batchnorm-pytorch
[Licence du MIT] Module d'auto-traitement: https://github.com/votetiv/self-attention-gan-pytorch
[Licence du MIT] Diffaugment: https://github.com/mit-han-lab/data-efesivet-gans
[MIT_LICENNE] Pytorch Amélioration de la précision et du rappel: https://github.com/clovaai/generative-evaluation-pdc
[MIT_LICENNE] Densité et couverture pytorch: https://github.com/clovaai/generative-evaluation-pdc
[Licence MIT] Pytorch Clean-Fid: https://github.com/gaparmar/clean-fid
[Licence de code source NVIDIA] Stylegan2: https://github.com/nvlabs/stylegan2
[Licence de code source NVIDIA] Augmentation du discriminateur adaptatif: https://github.com/nvlabs/stylegan2
[Licence Apache] Pytorch FID: https://github.com/mseitzer/pytorch-fid
Pytorch-studiogan est une bibliothèque open source sous la licence MIT (MIT). Cependant, les parties de la bibliothèque sont avaiables selon des termes de licence distincts: Stylegan2, Stylegan2-Ada et Stylegan3 sont sous licence NVIDIA CODE SOURCE, et Pytorch-fid est concédé sous licence Apache.
Studiogan est créé pour les projets de recherche suivants. Veuillez citer notre travail si vous utilisez Studiogan.
@article { kang2023StudioGANpami ,
title = { {StudioGAN: A Taxonomy and Benchmark of GANs for Image Synthesis} } ,
author = { MinGuk Kang and Joonghyuk Shin and Jaesik Park } ,
journal = { IEEE Transactions on Pattern Analysis and Machine Intelligence (TPAMI) } ,
year = { 2023 }
} @inproceedings { kang2021ReACGAN ,
title = { {Rebooting ACGAN: Auxiliary Classifier GANs with Stable Training} } ,
author = { Minguk Kang, Woohyeon Shim, Minsu Cho, and Jaesik Park } ,
journal = { Conference on Neural Information Processing Systems (NeurIPS) } ,
year = { 2021 }
} @inproceedings { kang2020ContraGAN ,
title = { {ContraGAN: Contrastive Learning for Conditional Image Generation} } ,
author = { Minguk Kang and Jaesik Park } ,
journal = { Conference on Neural Information Processing Systems (NeurIPS) } ,
year = { 2020 }
}[1] Des expériences sur de minuscules imageNet sont menées en utilisant l'architecture RESNET au lieu de CNN.
[2] Notre réimplémentation d'ACGAN (ICML'17) avec de légères modifications, qui apportent une forte amélioration des performances pour l'expérience en utilisant CIFAR10.
