BigGAN PyTorch Download - BigGAN PyTorch Código Fonte Download

BigGAN PyTorch

Pitão

1.0.0

Baixar

Biggan-pytorch

A implementação de Pytorch Biggan oficialmente oficialmente oficial do autor.

Dogball? Dogball!

Este repositório contém código para o treinamento de 4-8 GPU de figuras de treinamento em grande escala GaN para síntese de imagem natural de alta fidelidade por Andrew Brock, Jeff Donahue e Karen Simonyan.

Este código é de Andy Brock e Alex Andonian.

Como usar este código

Você precisará:

Pytorch, versão 1.0.1
TQDM, Numpy, Scipy e H5py
O conjunto de treinamento da imagenet

Primeiro, você pode opcionalmente preparar uma versão HDF5 pré-processada do seu conjunto de dados de destino para E/S mais rápida. Depois disso (ou não), você precisará dos momentos de início necessários para calcular o FID. Estes podem ser feitos modificando e executando

sh scripts/utils/prepare_data.sh

O que, por padrão, assume que seu conjunto de treinamento ImageNet é baixado nos data da pasta raiz neste diretório e preparará o HDF5 em cache a resolução de 128x128 pixels.

Na pasta Scripts, existem vários scripts de bash que treinarão biggans com diferentes tamanhos de lote. Este código pressupõe que você não tenha acesso a um POD completo da TPU e, portanto, falsifica mega-lotes usando o acúmulo de gradiente (com a média de graduados em vários minibatches e apenas tomando um passo otimizador após n acumulações). Por padrão, o script launch_BigGAN_bs256x8.sh treina um modelo de biggan em tamanho grande com um tamanho de lote de 256 e 8 acumulações de gradiente, para um tamanho total de 2048.

Primeiro, você precisará descobrir o tamanho máximo em lote que sua configuração pode suportar. Os modelos pré-treinados fornecidos aqui foram treinados em 8xv100 (16 GB de VRAM cada), que podem suportar um pouco mais do que o BS256 usado por padrão. Depois de determinar isso, você deve modificar o script para que o tamanho do lote vezes o número de acumulações de gradiente seja igual ao tamanho total desejado do lote (o biggan padrão é 2048).

Observe também que este script usa o arquivo --load_in_mem carrega o arquivo inteiro (~ 64 GB) i128.hdf5 na RAM para um carregamento de dados mais rápido. Se você não tiver RAM suficiente para apoiar isso (provavelmente 96 GB+), remova esse argumento.

Métricas e amostragem

I believe I can fly!

Durante o treinamento, este script produzirá logs com métricas de treinamento e métricas de teste, salvará várias cópias (2 mais recentes e 5 de maior pontuação) dos parâmetros de peso/otimizador do modelo e produzirão amostras e interpolações toda vez que economizam pesos. A pasta Logs contém scripts para processar esses logs e plotar os resultados usando o MATLAB (desculpe não desculpe).

Após o treinamento, pode -se usar sample.py para produzir amostras e interpolações adicionais, testar com diferentes valores de truncamento, tamanhos de lote, número de acumulações de estatísticas permanentes, etc. Consulte o script sample_BigGAN_bs256x8.sh para um exemplo.

Por padrão, tudo é salvo em pesos/amostras/logs/pastas de dados que se supõe estar na mesma pasta que este repo. Você pode apontar tudo isso para uma pasta de base diferente usando o argumento --base_root ou escolher locais específicos para cada um deles com seus respectivos argumentos (por exemplo --logs_root ).

Incluímos scripts para executar o Biggan, mas não treinamos totalmente um modelo usando-os, então considere-os não testados. Além disso, incluímos scripts para executar um modelo no CIFAR e para executar o sa-Gan (com EMA) e Sn-Gan no ImageNet. O código SA-GAN assume que você tem 4xtitanx (ou equivalente em termos de RAM da GPU) e será executado com um tamanho de lotes de 128 e 2 acumulações de gradiente.

Uma nota importante sobre as métricas de início

Este repositório usa a rede de iniciativa Pytorch embutida para calcular o IS e o FID. Essas pontuações são diferentes das pontuações que você usaria usando o código oficial de Inception TF e são apenas para fins de monitoramento! Execute sample.py no seu modelo, com o argumento --sample_npz e execute o INFCECCECCETION_TF13 para calcular o tensorflow real é. Observe que você precisará ter o TensorFlow 1.3 ou anteriormente instalado, pois o TF1.4+ quebra o código original.

Modelos pré -terem sido pretados

Pytorch Inception Score e FID Incluímos dois pontos de verificação de modelo pré -terenciados (com G, D, a cópia EMA de G, os otimizadores e o ditado do estado):

O principal ponto de verificação é para um biggan treinado no Imagenet em 128x128, usando acumulações de gradiente BS256 e 8, tomadas pouco antes do colapso, com uma pontuação de início de TF de 97,35 +/- 1,79: link
Um ponto de verificação anterior do primeiro modelo (100k g iters), em alto desempenho, mas bem antes do colapso, o que pode ser mais fácil de ajustar: link

Modelos pré-criados para lugares-365 em breve.

Este repositório também contém scripts para portar os pesos originais do TFHub Biggan Generator para Pytorch. Veja os scripts na pasta TFHUB para obter mais detalhes.

Ajuste fino, usando seu próprio conjunto de dados ou fazendo novas funções de treinamento

That's deep, man

Se você deseja retomar o treinamento interrompido ou ajustar um modelo pré-treinado, execute o mesmo script de lançamento, mas com o argumento --resume adicionado. Os nomes dos experimentos são gerados automaticamente a partir da configuração, mas podem ser substituídos usando o --experiment_name arg (por exemplo, se você deseja ajustar um modelo usando configurações de otimizador modificado).

Para preparar seu próprio conjunto de dados, você precisará adicioná -lo ao DataSets.py e modificar os ditos de conveniência no utils.py (dset_dict, imsize_dict, root_dict, ncllass_dict, classes_per_sheet_dict) para ter o metadata apropriado para o seu datásico. Repita o processo em preparar_data.sh (opcionalmente, produz uma cópia pré -processada HDF5 e calcule os momentos de início para FID).

Por padrão, o script de treinamento salvará os 5 melhores pontos de verificação, conforme medido pela pontuação inicial. Para os conjuntos de dados que não sejam o ImageNet, a pontuação inicial pode ser uma medida muito ruim de qualidade; portanto, você provavelmente desejará usar --which_best FID .

Para usar sua própria função de treinamento (por exemplo, um bigvae): modifique o trep_fns.gan_training_function ou adicione um novo trem fn e adicione -o após a if config['which_train_fn'] == 'GAN': linha em train.py .

Coisas legais

Incluímos os registros completos de treinamento e métricas aqui para referência. Descobri que uma das coisas mais difíceis de reimplementar um artigo pode estar verificando se os logs se alinharem no início do treinamento, especialmente se o treinamento levar várias semanas. Espero que isso seja útil para trabalhos futuros.
Incluímos um cálculo acelerado do FID-a versão cipy original pode exigir mais de 10 minutos para calcular o SQRT da matriz, esta versão usa uma versão acelerada do Pytorch para calculá-la em um segundo.
Incluímos uma implementação acelerada de Ortho Reg.
Por padrão, calculamos apenas o valor singular superior (a norma espectral), mas esse código suporta a computação mais SVS através do argumento --num_G_SVs .

Principais diferenças entre este código e o biggan original

Utilizamos as configurações de otimizador de sa-gan (g_lr = 1e-4, d_lr = 4e-4, num_d_steps = 1, em oposição ao g_lr de biggan = 5e-5, d_lr = 2e-4, num_d_steps = 2). Embora um pouco menos de desempenho, essa foi a primeira esquina que cortamos para reduzir os tempos de treinamento.
Por padrão, não usamos o batchnorm de replica cruzada (também conhecida como sinalizada BatchNorm). As duas variantes que tentamos (personalizadas, ingênuas e as incluídas neste repositório) têm gradientes ligeiramente diferentes (embora idênticos passes para a frente) da formação de batedores embutidos, que parecem ser suficientes para prejudicar o treinamento.
A acumulação de gradiente significa que atualizamos as estimativas de SV e as estatísticas do BN 8 vezes mais frequentemente. Isso significa que as estatísticas do BN estão muito mais próximas das estatísticas permanentes e que as estimativas de valor singular tendem a ser mais precisas. Por esse motivo, medimos as métricas por padrão com G no modo de teste (usando as estimativas de estatísticas em execução do BatchNorm em vez de calcular estatísticas permanentes como no papel). Ainda apoiamos estatísticas permanentes (consulte os scripts da amostra.SH). Isso também pode resultar em gradientes das acumulações anteriores sendo obsoletas, mas na prática isso não parece ser um problema.
Os modelos pré -ridicularizados atualmente fornecidos não foram treinados com regularização ortogonal. Treinar sem orto Reg parece aumentar a probabilidade de que os modelos não sejam passíveis de truncamento, mas parece que esse modelo em particular recebeu um bilhete vencedor. Independentemente disso, fornecemos duas implementações de orto -reg altamente otimizadas (rápida e mínima de memória) que calculam diretamente o Ortho Reg. gradientes.

Uma nota sobre o design deste repo

Este código foi projetado desde o início para servir como uma base extensível e hackeable para um código de pesquisa adicional. Pensamos muito em garantir que as abstrações sejam a espessura certa para a pesquisa-não tão grossa que seja impenetrável, mas não tão fina que seja inútil. A idéia principal é que, se você deseja experimentar uma configuração do SOTA e fazer alguma modificação (experimente sua nova função de perda, arquitetura, bloco de auto-atendimento etc.), você poderá fazê-lo facilmente apenas soltando seu código em um ou dois lugares, sem ter que se preocupar com o restante da base de código. Coisas como o uso de self.which_conv e functools.parcial na definição do modelo biggan.py foram montadas juntas com isso em mente, assim como o design da herança da classe de norma espectral.

Com isso dito, esta é uma base de código um tanto grande para um único projeto. Enquanto tentamos ser minuciosos com os comentários, se houver algo que você acha que pode ser mais claro, melhor escrito ou melhor reformado, sinta -se à vontade para levantar um problema ou uma solicitação de tração.

Solicitações de recursos

Deseja trabalhar ou melhorar este código? Há algumas coisas pelas quais o repositório se beneficiaria, mas que ainda não funcionariam.

Norm em lote sincronizado (também conhecido como replica cruzada). Tentamos duas variantes disso, mas, por algum motivo desconhecido, prejudicava o treinamento a cada vez. Não experimentamos o Apex SyncBN, pois os servidores da minha escola estão em drivers antigos da NVIDIA que não o apoiam-a APEX provavelmente seria um bom lugar para começar.
Treinamento de precisão mista e uso de núcleos tensores. Esse repositório inclui uma implementação ingênua de precisão mista, que funciona no início do treinamento, mas leva ao colapso precoce e não faz nada para ativar núcleos tensores (apenas reduz o consumo de memória). Como acima, a integração do APEX nesse código e empregando suas técnicas de treinamento de precisão mista para aproveitar os núcleos tensores e reduzir o consumo de memória pode produzir ganhos substanciais de velocidade.

Misc Notes

Veja este diretório para rótulos do ImageNet.

Se você usar este código, cite

 @inproceedings{
brock2018large,
title={Large Scale {GAN} Training for High Fidelity Natural Image Synthesis},
author={Andrew Brock and Jeff Donahue and Karen Simonyan},
booktitle={International Conference on Learning Representations},
year={2019},
url={https://openreview.net/forum?id=B1xsqj09Fm},
}