ALAE
1.0.0
Stanislav Pidhorskyi • Donald A. Adjeroh • Gianfranco Doretto
 |  |
Pasta Google Drive com modelos e resultados qualitativos
Autoencoders latentes adversários
Stanislav Pidhorskyi, Donald Adjeroh, Gianfranco DorettoResumo: Redes autoencoder são abordagens não supervisionadas que visam combinar propriedades generativas e representacionais aprendendo simultaneamente um mapa codificador-gerador. Embora estudadas extensivamente, as questões sobre se elas têm o mesmo poder gerador das GANs, ou se aprendem representações desembaraçadas, não foram totalmente abordadas. Apresentamos um autoencoder que aborda esses problemas em conjunto, que chamamos de Adversarial Latent Autoencoder (ALAE). É uma arquitetura geral que pode aproveitar melhorias recentes nos procedimentos de treinamento da GAN. Projetamos dois autoencoders: um baseado em um codificador MLP e outro baseado em um gerador StyleGAN, que chamamos de StyleALAE. Verificamos as propriedades de desemaranhamento de ambas as arquiteturas. Mostramos que o StyleALAE pode não apenas gerar imagens faciais de 1024x1024 com qualidade comparável ao StyleGAN, mas na mesma resolução também pode produzir reconstruções e manipulações faciais com base em imagens reais. Isso torna o ALAE o primeiro autoencoder capaz de comparar e ir além dos recursos de um tipo de arquitetura somente gerador.
@InProceedings{pidhorskyi2020adversarial,
author = {Pidhorskyi, Stanislav and Adjeroh, Donald A and Doretto, Gianfranco},
booktitle = {Proceedings of the IEEE Computer Society Conference on Computer Vision and Pattern Recognition (CVPR)},
title = {Adversarial Latent Autoencoders},
year = {2020},
note = {[to appear]},
}
Para executar a demonstração, você precisará ter uma GPU compatível com CUDA, PyTorch >= v1.3.1 e drivers cuda/cuDNN instalados. Instale os pacotes necessários:
pip install -r requirements.txt
Baixe modelos pré-treinados:
python training_artifacts/download_all.py
Execute a demonstração:
python interactive_demo.py
Você pode especificar a configuração do yaml a ser usada. As configurações estão localizadas aqui: https://github.com/podgorskiy/ALAE/tree/master/configs. Por padrão, ele usa um para o conjunto de dados FFHQ. Você pode alterar a configuração usando o parâmetro -c . Para rodar em celeb-hq em resolução 256x256, execute:
python interactive_demo.py -c celeba-hq256
No entanto, para configurações diferentes de FFHQ, é necessário obter novos vetores de direção principais para os atributos.
O código no repositório é organizado de tal forma que todos os scripts devem ser executados a partir da raiz do repositório. Se você usar um IDE (por exemplo, PyCharm ou Visual Studio Code), basta definir o Working Directory para apontar para a raiz do repositório.
Se quiser executar a partir da linha de comando, você também precisará definir a variável PYTHONPATH para apontar para a raiz do repositório.
Por exemplo, digamos que clonamos o repositório para o diretório ~/ALAE , então faça:
$ cd ~/ALAE
$ export PYTHONPATH=$PYTHONPATH:$(pwd)
Agora você pode executar scripts da seguinte maneira:
$ python style_mixing/stylemix.py
| Caminho | Descrição |
|---|---|
| ALAE | Pasta raiz do repositório |
| ├ configurações | Pasta com arquivos de configuração yaml. |
| │ ├ quarto.yaml | Arquivo de configuração para conjunto de dados de quarto LSUN com resolução de 256x256. |
| │ ├celeba.yaml | Arquivo de configuração para conjunto de dados CelebA com resolução de 128x128. |
| │ ├ celeba-hq256.yaml | Arquivo de configuração para conjunto de dados CelebA-HQ com resolução de 256x256. |
| │ ├ celeba_ablation_nostyle.yaml | Arquivo de configuração para conjunto de dados CelebA 128x128 para estudo de ablação (sem estilos). |
| │ ├ celeba_ablation_separate.yaml | Arquivo de configuração para conjunto de dados CelebA 128x128 para estudo de ablação (codificador e discriminador separados). |
| │ ├ celeba_ablation_z_reg.yaml | Arquivo de configuração para conjunto de dados CelebA 128x128 para estudo de ablação (regressão no espaço Z, não W). |
| │ ├ ffhq.yaml | Arquivo de configuração para conjunto de dados FFHQ com resolução de 1024x1024. |
| │ ├ mnist.yaml | Arquivo de configuração para conjunto de dados MNIST usando arquitetura Style. |
| │ └ mnist_fc.yaml | Arquivo de configuração para conjunto de dados MNIST usando apenas camadas totalmente conectadas (Permutation Invariant MNIST). |
| ├ preparação do conjunto de dados | Pasta com scripts para preparação de conjunto de dados. |
| │ ├ prepare_celeba_hq_tfrec.py | Para preparar TFRecords para o conjunto de dados CelebA-HQ com resolução de 256x256. |
| │ ├ prepare_celeba_tfrec.py | Para preparar TFRecords para o conjunto de dados CelebA com resolução de 128x128. |
| │ ├ prepare_mnist_tfrec.py | Para preparar TFRecords para o conjunto de dados MNIST. |
| │ ├ split_tfrecords_bedroom.py | Para dividir TFRecords oficiais do papel StyleGAN para o conjunto de dados do quarto LSUN. |
| │ └ split_tfrecords_ffhq.py | Para dividir TFRecords oficiais do papel StyleGAN para o conjunto de dados FFHQ. |
| ├ conjunto de dados_amostras | Pasta com amostras de entradas para diferentes conjuntos de dados. Usado para figuras e para entradas de teste durante o treinamento. |
| ├ fazer_figuras | Scripts para fazer várias figuras. |
| ├ métricas | Scripts para calcular métricas. |
| ├direções_principais | Scripts para calcular vetores de direção principais para vários atributos. Para demonstração interativa . |
| ├ mixagem de estilo | Exemplos de entradas e roteiro para produzir figuras que misturam estilos. |
| ├ artefatos_treinamento | Local padrão para salvar pontos de verificação/saídas/parcelas de amostra. |
| │ └ download_all.py | Script para baixar todos os modelos pré-treinados. |
| ├ interativo_demo.py | Script executável para demonstração interativa. |
| ├ train_alae.py | Script executável para treinamento. |
| ├ train_alae_separate.py | Script executável para treinamento para estudo de ablação (codificador e discriminador separados). |
| ├ checkpointer.py | Módulo para salvar/restaurar pesos de modelos, estado do otimizador e histórico de perdas. |
| ├ custom_adam.py | Otimizador Adam personalizado para equalização da taxa de aprendizagem e beta de zero segundos. |
| ├ dataloader.py | Módulo com classes de conjunto de dados, carregadores, iteradores, etc. |
| ├ padrões.py | Definição para variáveis de configuração com valores padrão. |
| ├ launcher.py | Auxiliar para executar treinamento multi-GPU e multiprocesso. Configura configuração e registro. |
| ├lod_driver.py | Classe auxiliar para gerenciar rede em crescimento/estabilização. |
| ├lreq.py | Módulos Linear , Conv2d e ConvTranspose2d personalizados para equalização da taxa de aprendizagem. |
| ├modelo.py | Módulo com definição de modelo de alto nível. |
| ├model_separate.py | O mesmo que acima, mas para estudo de ablação. |
| ├ net.py | Definição de todos os blocos de rede para múltiplas arquiteturas. |
| ├ registro.py | Registro de blocos de rede para seleção no arquivo de configuração. |
| ├ agendador.py | Agendadores customizados com inicialização a quente e agregação de diversos otimizadores. |
| ├ tracker.py | Módulo para plotagem de perdas. |
| └ utilitários.py | Decorador para chamada assíncrona, decorador para cache, registro para blocos de rede. |
Nesta base de código, yacs é usado para lidar com configurações.
A maioria dos scripts executáveis aceita o parâmetro -c que pode especificar arquivos de configuração a serem usados. Por exemplo, para fazer figuras de reconstrução, você pode executar:
python make_figures/make_recon_figure_paged.py
python make_figures/make_recon_figure_paged.py -c celeba
python make_figures/make_recon_figure_paged.py -c celeba-hq256
python make_figures/make_recon_figure_paged.py -c bedroom
A configuração padrão é ffhq .
O treinamento é feito usando TFRecords. TFRecords são lidos usando DareBlopy, que permite usá-los com Pytorch.
Nos arquivos de configuração, bem como em todos os scripts de preparação, assume-se que todos os conjuntos de dados estão em /data/datasets/ . Você pode alterar o caminho nos arquivos de configuração ou criar um link simbólico para onde você armazena os conjuntos de dados.
A forma oficial de gerar CelebA-HQ pode ser desafiadora. Consulte esta página: https://github.com/suvojit-0x55aa/celebA-HQ-dataset-download Você pode obter o conjunto de dados pré-gerado em: https://drive.google.com/drive/folders/11Vz0fqHS2rXDb5pprgTjpD7S2BAJhi1P
Para baixar modelos pré-treinados, execute:
python training_artifacts/download_all.py
Observação : costumava haver problemas com o download de modelos do Google Drive devido ao limite de download. Agora, o script está configurado de forma que, se não conseguir baixar os dados do Google Drive, ele tentará baixá-los do S3.
Se você tiver problemas, tente excluir todos os arquivos *.pth, atualizar o pacote dlutils ( pip install dlutils --upgrade ) e execute download_all.py novamente. Se isso não resolver o problema, abra um problema. Além disso, você pode tentar baixar modelos manualmente aqui: https://drive.google.com/drive/folders/1tsI1q1u8QRX5t7_lWCSjpniLGlNY-3VY?usp=sharing
Nos arquivos de configuração, OUTPUT_DIR aponta para onde os pesos são salvos e lidos. Por exemplo: OUTPUT_DIR: training_artifacts/celeba-hq256
Em OUTPUT_DIR ele salva um arquivo last_checkpoint que contém o caminho para o pickle .pth real com peso do modelo. Se quiser testar o modelo com um arquivo de peso específico, você pode simplesmente modificar o arquivo last_checkpoint .
Para gerar figuras de mistura de estilos, execute:
python style_mixing/stylemix.py -c <config>
Onde em vez de <config> coloque um de: ffhq , celeba , celeba-hq256 , bedroom
Para gerar reconstrução com imagens em múltiplas escalas:
python make_figures/make_recon_figure_multires.py -c <config>
Para gerar a reconstrução de todas as entradas de amostra em múltiplas páginas:
python make_figures/make_recon_figure_paged.py -c <config>
Existem também:
python make_figures/old/make_recon_figure_celeba.py
python make_figures/old/make_recon_figure_bed.py
Para gerar a reconstrução do conjunto de teste do FFHQ:
python make_figures/make_recon_figure_ffhq_real.py
Para gerar figura de interpolação:
python make_figures/make_recon_figure_interpolation.py -c <config>
Para gerar figura de travessia:
(Para conjuntos de dados diferentes de FFHQ, você precisará primeiro encontrar as direções principais)
python make_figures/make_traversarls.py -c <config>
Para fazer o cálculo da geração ser executado:
make_generation_figure.py -c <config>
Além de instalar os pacotes necessários:
pip install -r requirements.txt
Você precisará instalar o DareBlopy:
pip install dareblopy
Para executar o treinamento:
python train_alae.py -c <config>
Ele executará treinamento multi-GPU em todas as GPUs disponíveis. Ele usa DistributedDataParallel para paralelismo. Se apenas uma GPU estiver disponível, ela funcionará em uma única GPU, sem necessidade de cuidados especiais.
O número recomendado de GPUs é 8. A reprodutibilidade em um número menor de GPUs pode apresentar problemas. Pode ser necessário ajustar o tamanho do lote no arquivo de configuração dependendo do tamanho da memória das GPUs.
Além de instalar os pacotes necessários e o DareBlopy, você precisa instalar o TensorFlow e o dnnlib do StyleGAN.
O Tensorflow deve ser da versão 1.10 :
pip install tensorflow-gpu==1.10
Requer CUDA versão 9.0.
Talvez a melhor maneira seja usar o Anaconda para lidar com isso, mas eu prefiro instalar o CUDA 9.0 a partir de repositórios pop-os (funciona no Ubuntu):
sudo echo "deb http://apt.pop-os.org/proprietary bionic main" | sudo tee -a /etc/apt/sources.list.d/pop-proprietary.list
sudo apt-key adv --keyserver keyserver.ubuntu.com --recv-key 204DD8AEC33A7AFF
sudo apt update
sudo apt install system76-cuda-9.0
sudo apt install system76-cudnn-9.0
Depois é só definir a variável LD_LIBRARY_PATH :
export LD_LIBRARY_PATH=/usr/lib/cuda-9.0/lib64
Dnnlib é um pacote usado no StyleGAN. Você pode instalá-lo com:
pip install https://github.com/podgorskiy/dnnlib/releases/download/0.0.1/dnnlib-0.0.1-py3-none-any.whl
Todo o código para executar métricas é fortemente baseado naqueles do repositório StyleGAN. Ele também usa os mesmos modelos pré-treinados:
https://github.com/NVlabs/stylegan#licenses
inception_v3_features.pkl e inception_v3_softmax.pkl são derivados da rede Inception-v3 pré-treinada por Christian Szegedy, Vincent Vanhoucke, Sergey Ioffe, Jonathon Shlens e Zbigniew Wojna. A rede foi originalmente compartilhada sob licença Apache 2.0 no repositório TensorFlow Models.
vgg16.pkl e vgg16_zhang_perceptual.pkl são derivados da rede VGG-16 pré-treinada por Karen Simonyan e Andrew Zisserman. A rede foi originalmente compartilhada sob a licença Creative Commons BY 4.0 na página do projeto Very Deep Convolutional Networks for Large-Scale Visual Recognition.
vgg16_zhang_perceptual.pkl é ainda derivado dos pesos LPIPS pré-treinados por Richard Zhang, Phillip Isola, Alexei A. Efros, Eli Shechtman e Oliver Wang. Os pesos foram originalmente compartilhados sob a licença "Simplificada" de 2 cláusulas BSD no repositório PerceptualSimilarity.
Finalmente, para executar métricas:
python metrics/fid.py -c <config> # FID score on generations
python metrics/fid_rec.py -c <config> # FID score on reconstructions
python metrics/ppl.py -c <config> # PPL score on generations
python metrics/lpips.py -c <config> # LPIPS score of reconstructions
