pytorch pretrained BigGAN
Small update to utils
Una reimplementación de Pytorch de OP-for-OP del modelo Biggan de Deepmind con los pesos previamente capacitados de DeepMind.
Este repositorio contiene una reimplementación de Pytorch de OP-for-Op de Biggan de Deepmind que se lanzó con el entrenamiento GaN a gran escala de papel para la síntesis de imágenes naturales de alta fidelidad de Andrew Brock, Jeff Donahue y Karen Simonyan.
Esta implementación de Pytorch de Biggan se proporciona con los modelos Pretenered 128x128, 256x256 y 512x512 por DeepMind. También proporcionamos los scripts utilizados para descargar y convertir estos modelos de los modelos TensorFlow Hub.
Esta reimplementación se realizó a partir del gráfico de cálculo sin procesar de la versión TensorFlow y se comportó de manera similar a la versión TensorFlow (varianza de la diferencia de salida del orden de 1e-5).
Esta implementación actualmente solo contiene el generador ya que los pesos del discriminador no se liberaron (aunque la estructura del discriminador es muy similar al generador, por lo que podría agregarse con bastante facilidad. Dime que si quieres hacer un PR al respecto, estaría encantado de ayudarlo).
Este repositorio fue probado en Python 3.6 y Pytorch 1.0.1
Pytorch Pretraned Biggan se puede instalar desde PIP de la siguiente manera:
pip install pytorch-pretrained-bigganSi simplemente quieres jugar con el GaN, esto debería ser suficiente.
Si desea utilizar los scripts de conversión y las utilidades de ImageNet, se necesitan requisitos adicionales, en particular TensorFlow y NLTK. Para instalar todos los requisitos, utilice el archivo full_requirements.txt :
git clone https://github.com/huggingface/pytorch-pretrained-BigGAN.git
cd pytorch-pretrained-BigGAN
pip install -r full_requirements.txtEste repositorio proporciona acceso directo y simple a las versiones "profundas" previas a la aparición de Biggan para las resoluciones de 128, 256 y 512 píxeles como se describe en la publicación asociada. Aquí hay algunos detalles sobre los modelos:
BigGAN-deep-128 : un modelo de parámetros de 50.4m que genera imágenes de 128x128 píxeles, el modelo de volcado 201 MB,BigGAN-deep-256 : un modelo de parámetros de 55.9m que genera imágenes de 256x256 píxeles, el modelo de volcado de pesas 224 MB,BigGAN-deep-512 : un modelo de 56.2m de parámetros que genera imágenes de 512x512 píxeles, el modelo de volcado pesa 225 MB.Consulte el Apéndice B del documento para obtener detalles sobre las arquitecturas.
Todos los modelos comprenden estadísticas de norma de lotes precomputadas para 51 valores de truncamiento entre 0 y 1 (ver Apéndice C.1 en el documento para más detalles).
Aquí hay un ejemplo de inicio rápido que usa BigGAN con un modelo previamente capacitado.
Consulte la sección Doc a continuación para obtener detalles sobre estas clases y métodos.
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 )
Para cargar uno de los modelos previamente capacitados de Deepmind, instanciar un modelo BigGAN con from_pretrained() como:
model = BigGAN . from_pretrained ( PRE_TRAINED_MODEL_NAME_OR_PATH , cache_dir = None )dónde
PRE_TRAINED_MODEL_NAME_OR_PATH es:
El nombre de acceso directo de un modelo previamente capacitado de Google AI o OpenAI seleccionado en la lista:
biggan-deep-128 : 12 capas, 768 escondidas, 12 cabezas, 110m parámetrosbiggan-deep-256 : 24 capas, 1024 escondidas, 16 cabezas, 340m parámetrosbiggan-deep-512 : 12 capas, 768 escondidas, 12 cabezas, 110m parámetrosuna ruta o URL a un archivo de modelo previo alado que contiene:
config.json : un archivo de configuración para el modelo ypytorch_model.bin un vertedero de Pytorch de una instancia previamente capacitada de BigGAN (guardada con la torch.save() ). Si PRE_TRAINED_MODEL_NAME_OR_PATH es un nombre de acceso directo, los pesos pre-entrenados se descargarán de AWS S3 (consulte los enlaces aquí) y se almacenan en una carpeta de caché para evitar la descarga futura (la carpeta de caché se puede encontrar en ~/.pytorch_pretrained_biggan/ ).
cache_dir puede ser una ruta opcional a un directorio específico para descargar y almacenar en caché los pesos del modelo previamente capacitado.
BigGANConfig es una clase para almacenar y cargar configuraciones de Biggan. Se define en config.py .
Aquí hay algunos detalles sobre los atributos:
output_dim : resolución de salida del GaN (128, 256 o 512) para los modelos previamente capacitados,z_dim : Tamaño del vector de ruido (128 para los modelos previamente capacitados).class_embed_dim : tamaño de los vectores de incrustación de clase (128 para los modelos previamente capacitados).channel_width : tamaño de cada canal (128 para los modelos previamente capacitados).num_classes : número de clases en el conjunto de datos de entrenamiento, como ImageNet (1000 para los modelos previamente capacitados).layers : una lista de definición de capas. ¿Cada definición para una capa es un triple de [muestra ascendente en la capa? (bool), número de canales de entrada (int), número de canales de salida (int)]attention_layer_position : Posición de la capa de autoatensión en la jerarquía de la capa (8 para los modelos previamente capacitados).eps : Valor de Epsilon para usar para capas de normalización espectral y por lotes (1E-4 para los modelos previamente capacitados).n_stats : Número de estadísticas precomputadas para las capas de normalización por lotes asociadas a varios valores de truncamiento entre 0 y 1 (51 para los modelos previamente capacitados). BigGAN es un modelo de Pytorch ( torch.nn.Module ) de Biggan definido en model.py . Este modelo comprende los incrustaciones de clase (una capa lineal) y el generador con una serie de convoluciones y normas de lotes condicionales. El discriminador no se implementa actualmente ya que los pesos previamente capacitados no se han liberado para ello.
Las entradas y la salida son idénticos a las entradas y salidas del modelo TensorFlow .
Los detallamos aquí.
BigGAN toma como entradas :
z : una antorcha.class_label : una antorcha opcional. El tipo 0 corresponde a una sentence A y Tipo 1 corresponde a una sentence B Token (consulte Bert Paper para obtener más detalles).truncation : un flotador entre 0 (no compuesto) y 1. El truncamiento de la normalidad truncada se usa para crear el vector de ruido. Este valor de truncamiento se utiliza para seleccionar entre un conjunto de estadísticas precomputadas (medias y variaciones) para las capas de la norma por lotes. BigGAN emite una matriz de forma [Batch_Size, 3, resolución, resolución] donde la resolución es 128, 256 o 512 dependiendo del modelo:
Proporcionamos algunos métodos de utilidad para usar el modelo. Se definen en utils.py .
Aquí hay algunos detalles sobre estos métodos:
truncated_noise_sample(batch_size=1, dim_z=128, truncation=1., seed=None) :
Crea un vector de ruido truncado.
convert_to_images(obj) :
Convierta un tensor de salida de Biggan en una lista de imágenes.
save_as_images(obj, file_name='output') :
Convierta y guarde un tensor de salida de Biggan en una lista de imágenes guardadas.
file_name_{image_number}.png display_in_terminal(obj) :
Convierta y muestre un tensor de salida de Biggan en la terminal. Esta función usa libsixel y solo funcionará en un terminal compatible con libsixel. Consulte https://github.com/saitoha/libsixel para obtener más detalles.
file_name_{image_number}.png one_hot_from_int(int_or_list, batch_size=1) :
Cree un vector único a partir de un índice de clase o una lista de índices de clase.
len(int_or_list) == batch_size one_hot_from_names(class_name, batch_size=1) :
Cree un vector único a partir del nombre de una clase de Imagenet ('Bola de tenis', 'Daisy', ...). Usamos la búsqueda de WordNet de NLTK para tratar de encontrar el synset relevante de Imagenet y tomar el primero. Si no podemos encontrarlo directamente, observamos los hiponomas e hipernyms del nombre de la clase.
Los scripts para descargar y convertir los modelos TensorFlow desde TensorFlow Hub se proporcionan en ./scripts.
Los scripts se pueden usar directamente como:
./scripts/download_tf_hub_models.sh
./scripts/convert_tf_hub_models.sh
