pytorch pretrained BigGAN
Small update to utils
Une réimplémentation Pytorch OP-FOR-OP du modèle Biggan de DeepMind avec les poids pré-formés de DeepMind.
Ce référentiel contient une réimplémentation Pytorch OP-FOR-OP de Biggan de DeepMind qui a été publié avec la formation GAN à grande échelle pour la synthèse d'image naturelle haute fidélité par Andrew Brock, Jeff Donahue et Karen Simonyan.
Cette mise en œuvre Pytorch de Biggan est dotée des modèles pré-entraînés 128x128, 256x256 et 512x512 par DeepMind. Nous fournissons également les scripts utilisés pour télécharger et convertir ces modèles à partir des modèles TensorFlow Hub.
Cette réimplémentation a été effectuée à partir du graphique de calcul brut de la version TensorFlow et se comporte de la même manière que la version TensorFlow (variance de la différence de sortie de l'ordre de 1E-5).
Cette implémentation ne contient actuellement que le générateur car les poids du discriminateur n'ont pas été libérés (bien que la structure du discriminateur soit très similaire au générateur afin qu'elle puisse être ajoutée assez facilement. Dites-moi si vous voulez faire un PR à ce sujet, je serais heureux de vous aider.)
Ce repo a été testé sur Python 3.6 et Pytorch 1.0.1
Pytorch Pretrained Biggan peut être installé à partir de PIP comme suit:
pip install pytorch-pretrained-bigganSi vous voulez simplement jouer avec le Gan, cela devrait suffire.
Si vous souhaitez utiliser les scripts de conversion et les utilitaires ImageNet, des exigences supplémentaires sont nécessaires, en particulier TensorFlow et NLTK. Pour installer toutes les exigences, veuillez utiliser le fichier full_requirements.txt :
git clone https://github.com/huggingface/pytorch-pretrained-BigGAN.git
cd pytorch-pretrained-BigGAN
pip install -r full_requirements.txtCe référentiel fournit un accès direct et simple aux versions "profondes" pré-entraînées de Biggan pour les résolutions 128, 256 et 512 pixels comme décrit dans la publication associée. Voici quelques détails sur les modèles:
BigGAN-deep-128 : un modèle de paramètres de 50,4 m générant des images de 128x128 pixels, les poids de vidage du modèle 201 Mo,BigGAN-deep-256 : un modèle de paramètres de 55,9 m générant des images de 256x256 pixels, le modèle de poids de vidage 224 Mo,BigGAN-deep-512 : un modèle de paramètres de 56,2 m générant des images de 512x512 pixels, le modèle de décharge de poids 225 Mo.Veuillez vous référer à l'annexe B du document pour plus de détails sur les architectures.
Tous les modèles comprennent des statistiques de norme par lots pré-calculées pour 51 valeurs de troncature entre 0 et 1 (voir l'annexe C.1 dans le document pour plus de détails).
Voici un exemple de démarrage rapide utilisant BigGAN avec un modèle pré-formé.
Voir la section DOC ci-dessous pour plus de détails sur ces classes et méthodes.
import torch
from pytorch_pretrained_biggan import ( BigGAN , one_hot_from_names , truncated_noise_sample ,
save_as_images , display_in_terminal )
# OPTIONAL: if you want to have more information on what's happening, activate the logger as follows
import logging
logging . basicConfig ( level = logging . INFO )
# Load pre-trained model tokenizer (vocabulary)
model = BigGAN . from_pretrained ( 'biggan-deep-256' )
# Prepare a input
truncation = 0.4
class_vector = one_hot_from_names ([ 'soap bubble' , 'coffee' , 'mushroom' ], batch_size = 3 )
noise_vector = truncated_noise_sample ( truncation = truncation , batch_size = 3 )
# All in tensors
noise_vector = torch . from_numpy ( noise_vector )
class_vector = torch . from_numpy ( class_vector )
# If you have a GPU, put everything on cuda
noise_vector = noise_vector . to ( 'cuda' )
class_vector = class_vector . to ( 'cuda' )
model . to ( 'cuda' )
# Generate an image
with torch . no_grad ():
output = model ( noise_vector , class_vector , truncation )
# If you have a GPU put back on CPU
output = output . to ( 'cpu' )
# If you have a sixtel compatible terminal you can display the images in the terminal
# (see https://github.com/saitoha/libsixel for details)
display_in_terminal ( output )
# Save results as png images
save_as_images ( output )
Pour charger l'un des modèles pré-formés de DeepMind, instanciez un modèle BigGAN avec from_pretrained() comme:
model = BigGAN . from_pretrained ( PRE_TRAINED_MODEL_NAME_OR_PATH , cache_dir = None )où
PRE_TRAINED_MODEL_NAME_OR_PATH est soit:
Le nom de raccourci d'un modèle pré-formé par Google AI ou OpenAI sélectionné dans la liste:
biggan-deep-128 : 12 couches, 768, 120 m de 110 m de 120 mètresbiggan-deep-256 : 24 couches, 1024, 16 têtes, 340 m de paramètresbiggan-deep-512 : 12 couches, 768, 120m, paramètres de 110 mun chemin ou une URL vers une archive de modèle pré-entraîné contenant:
config.json : un fichier de configuration pour le modèle, etpytorch_model.bin un vidage pytorch d'une instance pré-formée de BigGAN (sauvé avec le torch.save() ). Si PRE_TRAINED_MODEL_NAME_OR_PATH est un nom de raccourci, les poids pré-formés seront téléchargés à partir d'AWS S3 (voir les liens ici) et stockés dans un dossier de cache pour éviter le téléchargement futur (le dossier de cache peut être trouvé à ~/.pytorch_pretrained_biggan/ ).
cache_dir peut être un chemin facultatif vers un répertoire spécifique pour télécharger et mettre en cache les poids des modèles pré-formés.
BigGANConfig est une classe pour stocker et charger les configurations Biggan. Il est défini dans config.py .
Voici quelques détails sur les attributs:
output_dim : résolution de sortie du GAn (128, 256 ou 512) pour les modèles pré-formés,z_dim : taille du vecteur de bruit (128 pour les modèles pré-formés).class_embed_dim : taille des vecteurs d'intégration de classe (128 pour les modèles pré-formés).channel_width : taille de chaque canal (128 pour les modèles pré-formés).num_classes : Nombre de classes dans l'ensemble de données de formation, comme ImageNet (1000 pour les modèles pré-formés).layers : une liste de la définition des couches. Chaque définition d'une couche est un triple de [haut-échantillon dans la couche? (bool), nombre de canaux d'entrée (int), nombre de canaux de sortie (INT)]attention_layer_position : position de la couche d'auto-agencement dans la hiérarchie de la couche (8 pour les modèles pré-formés).eps : valeur d'Epsilon à utiliser pour les couches de normalisation spectrales et par lots (1E-4 pour les modèles pré-formés).n_stats : Nombre de statistiques pré-calculées pour les couches de normalisation par lots associées à diverses valeurs de troncature entre 0 et 1 (51 pour les modèles pré-formés). BigGAN est un modèle pytorch ( torch.nn.Module ) de biggan défini dans model.py . Ce modèle comprend les incorporations de classe (une couche linéaire) et le générateur avec une série de convolutions et de normes de lots conditionnelles. Le discriminateur n'est actuellement pas mis en œuvre car les poids pré-formés n'ont pas été libérés pour cela.
Les entrées et les sorties sont identiques aux entrées et sorties du modèle TensorFlow .
Nous les détaillons ici.
BigGAN prend comme entrées :
z : a torch.floattenseur de forme [batch_size, config.z_dim] avec du bruit échantillonné à partir d'une distribution normale tronquée, etclass_label : une torch facultative.longtensor de forme [Batch_size, Sequence_Length] avec les indices de types de jetons sélectionnés dans [0, 1]. Le type 0 correspond à une sentence A et le type 1 correspond à un jeton sentence B (voir le papier Bert pour plus de détails).truncation : un flotteur entre 0 (non composé) et 1. La troncature de la normale tronquée utilisée pour créer le vecteur de bruit. Cette valeur de troncature est utilisée pour sélectionner un ensemble de statistiques pré-calculées (moyennes et variances) pour les couches de norme par lots. BigGAN produit un tableau de forme [Batch_size, 3, résolution, résolution] où la résolution est de 128, 256 ou 512 selon le modèle:
Nous fournissons quelques méthodes d'utilité pour utiliser le modèle. Ils sont définis dans utils.py .
Voici quelques détails sur ces méthodes:
truncated_noise_sample(batch_size=1, dim_z=128, truncation=1., seed=None) :
Créez un vecteur de bruit tronqué.
convert_to_images(obj) :
Convertissez un tenseur de sortie de Biggan dans une liste d'images.
save_as_images(obj, file_name='output') :
Convertir et enregistrer un tenseur de sortie de Biggan dans une liste d'images enregistrées.
file_name_{image_number}.png display_in_terminal(obj) :
Convertissez et affichez un tenseur de sortie de Biggan dans le terminal. Cette fonction utilise libsixel et ne fonctionnera que dans un terminal compatible libsixel. Veuillez vous référer à https://github.com/saitoha/libsixel pour plus de détails.
file_name_{image_number}.png one_hot_from_int(int_or_list, batch_size=1) :
Créez un vecteur à un hot à partir d'un index de classe ou d'une liste des indices de classe.
len(int_or_list) == batch_size one_hot_from_names(class_name, batch_size=1) :
Créez un vecteur à un hot à partir du nom d'une classe ImageNet («Tennis Ball», «Daisy», ...). Nous utilisons la recherche WordNet de NLTK pour essayer de trouver le synSset pertinent d'imageNet et de prendre le premier. Si nous ne le trouvons pas directement, nous regardons les hyponymes et les hypernymes du nom de la classe.
Les scripts à télécharger et à convertir les modèles Tensorflow de TensorFlow Hub sont fournis en ./Scripts.
Les scripts peuvent être utilisés directement comme:
./scripts/download_tf_hub_models.sh
./scripts/convert_tf_hub_models.sh
