neural style pt
v1.0.0
Esta é uma implementação de Pytorch do artigo Um algoritmo neural de estilo artístico de Leon A. Gatys, Alexander S. Ecker e Matthias Bethge. O código é baseado no estilo neural de Justin Johnson.
O artigo apresenta um algoritmo para combinar o conteúdo de uma imagem com o estilo de outra imagem usando redes neurais convolucionais. Aqui está um exemplo que mapeia o estilo artístico da noite estrelada em uma fotografia noturna do campus de Stanford:
A aplicação do estilo de imagens diferentes na mesma imagem de conteúdo fornece resultados interessantes. Aqui reproduzimos a Figura 2 do artigo, que torna uma fotografia do Tubingen na Alemanha em vários estilos:
Aqui estão os resultados da aplicação do estilo de várias obras de arte a esta fotografia da Ponte Golden Gate:
O algoritmo permite ao usuário trocar o peso relativo dos termos de estilo e reconstrução de conteúdo, como mostrado neste exemplo em que portamos o estilo do auto-retrato de Picasso em 1907 para Brad Pitt:
Ao redimensionar a imagem do estilo antes de extrair recursos do estilo, podemos controlar os tipos de recursos artísticos que são transferidos da imagem do estilo; Você pode controlar esse comportamento com o sinalizador -style_scale . Abaixo, vemos três exemplos de renderizar a ponte Golden Gate no estilo da noite estrelada. Da esquerda para a direita, -style_scale é 2,0, 1,0 e 0,5.
Você pode usar mais de uma imagem de estilo para misturar vários estilos artísticos.
No sentido horário do canto superior esquerdo: "The Starry Night" + "The Scream", "The Scream" + "Composition VII", "Sentado Nude" + "Composition VII" e "Sentado Nude" + "The Starry Night"
Ao usar imagens de vários estilos, você pode controlar o grau em que elas são misturadas:
Se você adicionar o sinalizador -original_colors 1 , a imagem de saída reterá as cores da imagem original.
Dependências:
Dependências opcionais:
Depois de instalar as dependências, você precisará executar o seguinte script para baixar o modelo VGG:
python models/download_models.py
Isso baixará o modelo VGG-19 original. O modelo VGG-16 original também será baixado. Por padrão, o modelo VGG-19 original é usado.
Se você tiver uma GPU de memória menor, o uso do modelo Nin ImageNet será melhor e fornecerá resultados um pouco piores, mas comparáveis. Você pode obter os detalhes do modelo do BVLC Caffe Modelzoo. O modelo NIN é baixado quando você executa o script download_models.py .
Você pode encontrar instruções detalhadas de instalação para o Ubuntu e o Windows no guia de instalação.
Uso básico:
python neural_style.py -style_image <image.jpg> -content_image <image.jpg>
Uso do CUDNN com o NIN Model:
python neural_style.py -style_image examples/inputs/picasso_selfport1907.jpg -content_image examples/inputs/brad_pitt.jpg -output_image profile.png -model_file models/nin_imagenet.pth -gpu 0 -backend cudnn -num_iterations 1000 -seed 123 -content_layers relu0,relu3,relu7,relu12 -style_layers relu0,relu3,relu7,relu12 -content_weight 10 -style_weight 500 -image_size 512 -optimizer adam
Para usar imagens de vários estilos, passe uma lista separada por vírgula como esta:
-style_image starry_night.jpg,the_scream.jpg .
Observe que os caminhos para as imagens não devem conter o caractere ~ para representar seu diretório inicial; Em vez disso, você deve usar um caminho relativo ou um caminho absoluto completo.
Opções :
-image_size : comprimento lateral máximo (em pixels) da imagem gerada. O padrão é 512.-style_blend_weights : o peso para misturar o estilo de imagens de vários estilos, como uma lista separada por vírgula, como -style_blend_weights 3,7 . Por padrão, todas as imagens de estilo são igualmente ponderadas.-gpu : ID INDEXO DE ZERO da GPU para usar; Para o modo CPU Defina -gpu como c .Opções de otimização :
-content_weight : quanto peso o termo de reconstrução de conteúdo. O padrão é 5E0.-style_weight : quanto peso o termo de reconstrução de estilo. O padrão é 1E2.-tv_weight : Peso da regularização da varia total (TV); Isso ajuda a suavizar a imagem. O padrão é 1E-3. Defina como 0 para desativar a regularização da TV.-num_iterations : o padrão é 1000.-init : método para gerar a imagem gerada; um de random ou image . O padrão é random que usa uma inicialização de ruído como no papel; image inicializa com a imagem de conteúdo.-init_image : substitui a imagem de inicialização por uma imagem especificada pelo usuário.-optimizer : o algoritmo de otimização a ser usado; lbfgs ou adam ; O padrão é lbfgs . O L-BFGS tende a fornecer melhores resultados, mas usa mais memória. Mudar para Adam reduzirá o uso da memória; Ao usar o Adam, você provavelmente precisará brincar com outros parâmetros para obter bons resultados, especialmente o peso do estilo, o peso do conteúdo e a taxa de aprendizado.-learning_rate : Taxa de aprendizado para usar com o Adam Optimizer. O padrão é 1E1.-normalize_gradients : Se esse sinalizador estiver presente, os gradientes de estilo e conteúdo de cada camada serão normalizados L1.Opções de saída :
-output_image : nome da imagem de saída. O padrão está out.png .-print_iter : Imprima Progresso a cada print_iter iterações. Defina como 0 para desativar a impressão.-save_iter : salve a imagem a todas as iterações save_iter . Defina como 0 para desativar os resultados intermediários.Opções de camada :
-content_layers : Lista de nomes de camadas separada por vírgula a ser usada para reconstrução de conteúdo. O padrão é relu4_2 .-style_layers : Lista de nomes de camadas separada por vírgula a ser usada para reconstrução de estilo. O padrão é relu1_1,relu2_1,relu3_1,relu4_1,relu5_1 .Outras opções :
-style_scale : escala para extrair recursos da imagem de estilo. O padrão é 1.0.-original_colors : Se você definir isso como 1, a imagem de saída manterá as cores da imagem de conteúdo.-model_file : caminho para o arquivo .pth para o modelo VGG Caffe. O padrão é o modelo VGG-19 original; Você também pode experimentar o modelo VGG-16 original.-pooling : o tipo de camadas de agrupamento a usar; um dos max ou avg . O padrão é max . Os modelos VGG-19 usam camadas máximas de pool, mas o papel menciona que a substituição dessas camadas por camadas médias de pool pode melhorar os resultados. Não consegui obter bons resultados usando o agrupamento médio, mas a opção está aqui.-seed : um valor inteiro que você pode especificar para obter resultados repetíveis. Por padrão, esse valor é aleatório para cada execução.-multidevice_strategy : Uma lista separada por vírgula de índices de camada para dividir a rede ao usar vários dispositivos. Consulte a escala multi-GPU para obter mais detalhes.-backend : nn , cudnn , openmp ou mkl . O padrão é nn . mkl requer o back -end da Intel.-cudnn_autotune : Ao usar o back-end do CUDNN, passe esse sinalizador para usar o AutoTunener CUDNN embutido para selecionar os melhores algoritmos de convolução para sua arquitetura. Isso tornará a primeira iteração um pouco mais lenta e pode levar um pouco mais de memória, mas poderá acelerar significativamente o back -end do CUDNN. Problema: o programa fica sem memória e morre
Solução: tente reduzir o tamanho da imagem: -image_size 256 (ou inferior). Observe que diferentes tamanhos de imagem provavelmente exigirão valores que não sejam de defesa para -style_weight e -content_weight para obter melhores resultados. Se você estiver executando em uma GPU, também pode tentar correr com -backend cudnn para reduzir o uso da memória.
Problema: -backend cudnn é mais lento que o back -end de NN padrão
Solução: adicione o sinalizador -cudnn_autotune ; Isso usará o CUDNN AutoTuner embutido para selecionar os melhores algoritmos de convolução.
Problema: Obtenha a seguinte mensagem de erro:
Missing key(s) in state_dict: "classifier.0.bias", "classifier.0.weight", "classifier.3.bias", "classifier.3.weight". Unexpected key(s) in state_dict: "classifier.1.weight", "classifier.1.bias", "classifier.4.weight", "classifier.4.bias".
Solução: Devido a uma mistura com locais de camada, os modelos mais antigos exigem que uma correção seja compatível com versões mais recentes do Pytorch. O script incluído donwload_models.py executará automaticamente essas correções após o download dos modelos.
Por padrão, neural-style-pt usa o back-end nn para convoluções e L-BFGs para otimização. Estes dão bons resultados, mas podem usar muita memória. Você pode reduzir o uso da memória com o seguinte:
-backend cudnn para usar o back -end do CUDNN. Isso funcionará apenas no modo GPU.-optimizer adam para usar o ADAM em vez de L -BFGS. Isso deve reduzir significativamente o uso da memória, mas pode exigir o ajuste de outros parâmetros para obter bons resultados; Em particular, você deve brincar com a taxa de aprendizado, o peso do conteúdo e o peso do estilo. Isso deve funcionar nos modos CPU e GPU.-image_size 256 para gerar uma imagem na metade do tamanho padrão.Com as configurações padrão, o estilo neural-PT usa cerca de 3,7 GB de memória da GPU no meu sistema; A mudança para Adam e Cudnn reduz a pegada de memória da GPU para cerca de 1 GB.
A velocidade pode variar muito, dependendo do back -end e do otimizador. Aqui estão algumas vezes para executar 500 iterações com -image_size=512 em um Tesla K80 com diferentes configurações:
-backend nn -optimizer lbfgs : 117 segundos-backend nn -optimizer adam : 100 segundos-backend cudnn -optimizer lbfgs : 124 segundos-backend cudnn -optimizer adam : 107 segundos-backend cudnn -cudnn_autotune -optimizer lbfgs : 109 segundos-backend cudnn -cudnn_autotune -optimizer adam : 91 segundosAqui estão os mesmos referências em um GTX 1080:
-backend nn -optimizer lbfgs : 56 segundos-backend nn -optimizer adam : 38 segundos-backend cudnn -optimizer lbfgs : 40 segundos-backend cudnn -optimizer adam : 40 segundos-backend cudnn -cudnn_autotune -optimizer lbfgs : 23 segundos-backend cudnn -cudnn_autotune -optimizer adam : 24 segundos Você pode usar vários dispositivos CPU e GPU para processar imagens em resoluções mais altas; Diferentes camadas da rede serão calculadas em diferentes dispositivos. Você pode controlar quais dispositivos GPU e CPU são usados com o sinalizador -gpu e controlar como dividir camadas entre os dispositivos usando o sinalizador -multidevice_strategy .
Por exemplo, em um servidor com quatro GPUs, você pode fornecer ao sinalizador -gpu 0,1,2,3 para processar nas GPUs 0, 1, 2 e 3 nessa ordem; Ao fornecer também a bandeira -multidevice_strategy 3,6,12 você indica que as duas primeiras camadas devem ser calculadas na GPU 0, as camadas 3 a 5 devem ser calculadas na GPU 1, as camadas -multidevice_strategy a 11 devem ser calculadas para o máximo.
Podemos obter resultados de alta qualidade em alta resolução, combinando processamento multi-GPU com geração em várias escalas, conforme descrito no artigo que controla fatores perceptivos na transferência de estilo neural de Leon A. Gatys, Alexander S. Ecker, Matthias Bethge, Aaron Hertzmann e Eli Shechtman.
Aqui está uma imagem 4016 x 2213 gerada em um servidor com oito GPUs Tesla K80:
O script usado para gerar esta imagem pode ser encontrado aqui.
As imagens são inicializadas com ruído branco e otimizadas usando L-BFGs.
Executamos reconstruções de estilo usando as camadas conv1_1 , conv2_1 , conv3_1 , conv4_1 e conv5_1 e reconstruções de conteúdo usando a camada conv4_2 . Como no artigo, as cinco perdas de reconstrução de estilo têm pesos iguais.
Se você achar esse código útil para sua pesquisa, cite -o usando a citação fornecida.
