Como fazer um bot que transforma uma foto em quadrinhos. Parte Dois Modelo de treinamento

⇨ A primeira parte
⇨ Terceira parte

Olá novamente!

Como você pode ver, os feriados prejudicaram um pouco a linha do tempo dos artigos.
Eu acho que muitos durante esse tempo conseguiram, se não totalmente treinar seu modelo, pelo menos experimentaram diferentes conjuntos de dados.

1. Coloque a distribuição
2. Baixando fotos
3. ???
4. Lucro!

Se você não gostou dessas redes neurais ou começou a ler este artigo, então, como eles dizem, não há tempo para explicar, pegamos o kit de distribuição, baixamos as fotos necessárias e vamos lá!

Instruções detalhadas estão no artigo anterior da série .

A primeira panqueca é irregular

Quando treinei o modelo para o @ photo2comicsbot pela primeira vez, sem mais delongas, simplesmente coloquei cerca de 1000 páginas de quadrinhos em um conjunto de dados.
Sim, junto com capas, anúncios e outros itens de preenchimento.

Na entrada, parecia assim:



O resultado é correspondente:








O modelo transmite perfeitamente as diferenças gerais entre quadrinhos e fotos:

• Classificação de cores típica
• Seleção de estrutura de tópicos
• Bloqueio
• Nuvem de texto

Em princípio, esta opção pode ser suficiente para a produção.

Mas eu queria saber quais resultados podem ser obtidos em um conjunto de dados mais "limpo".

Pegue dois

Para o próximo experimento, deixei as páginas com um bloco e, no restante, recortei as peças maiores, constituídas por um bloco, para eliminar as linhas divisórias verticais e horizontais no modelo final.

Se você fizer alterações no seu conjunto de dados, por exemplo, excluir ou adicionar fotos, não se esqueça de salvar a versão anterior. Você terá um lugar para retornar se algo der errado.

O segundo conjunto de dados ficou assim:



O resultado, como se costuma dizer, é óbvio:








As linhas divisórias desapareceram, mas com elas a expressividade deixada nas nuvens com o texto: elas começaram a se encontrar com muito menos frequência no conjunto de dados e deixaram de ser a principal característica.

O espaço vazio que costumava ser preenchido com texto agora está preenchido com ruído psicodélico.

A terceira vez é um charme

Decidi me livrar completamente do texto, deixando apenas as partes dos quadrinhos onde ele não está. Ninguém sobreviveu: sem nuvens, sem manchetes ou nomes de séries.

Conjunto de dados após o "genocídio linguístico":



O resultado final:








Por um lado, há menos artefatos, por outro, a expressividade se foi. Como no treinamento da GAN a qualidade do resultado é amplamente determinada por você e eu, não existe uma receita única para um bom modelo.

A beleza está nos olhos de quem vê, portanto, não tenha medo de experimentar e escolher o que você mais gosta.

Para a arma!

Bem, já falamos sobre as principais armadilhas e métodos para lidar com elas, é hora de começarmos a trabalhar.

Vá para a pasta em que baixamos a distribuição. Deixe-me lembrá-lo de que foi chamado pytorch-CycleGAN-and-pix2pix

Como temos instruções para manequins, não tocaremos no código de distribuição, pois todos os parâmetros necessários podem ser definidos na linha de comando.

Nesta distribuição, o treinamento padrão ocorre mais de duzentas eras, com uma atenuação linear da taxa de aprendizado após a centésima época.

A resolução máxima que minha placa de oito gigabytes conseguiu dominar era de 400x400. O treinamento completo levou cerca de 33 horas, então usaremos um pequeno truque de vida. Primeiro, treinaremos o modelo em 128x128 fotos, depois 256x256, e somente na fase final mostraremos a ela nossos lindos 400x400.
A primeira etapa durará 100 épocas, a segunda e a terceira - 50 cada, o que nos permitirá reduzir o tempo de treinamento em quase metade.

Como mostra a prática, o resultado dessa abordagem não é pior e, às vezes, melhor do que quando se treina imediatamente em resolução máxima.

Talvez seja teoria suficiente, é hora de começar a praticar.

No prompt de comando, insira.

Estágio um

python train.py --dataroot {dataset root folder} --name {model name} --model cycle_gan --crop_size 128 --load_size 180 --init_type kaiming --netG resnet_9blocks --no_dropout --batch_size 4 

Não se esqueça de substituir as chaves por seus próprios valores.

Analisaremos alguns parâmetros com mais detalhes:

 --batch_size {number} 

Esse parâmetro é responsável pelo número de imagens processadas por ciclo, afetando positivamente a velocidade e negativamente a gula do modelo.

Em cada estágio, selecione o máximo possível --batch_size, o que não causa erros devido à falta de memória da GPU.

 -- dataroot {dataset root folder} 

- pasta com nosso conjunto de dados. Dentro dela, devem estar as pastas trainA, trainB, testA, testB, conforme descrito no artigo anterior.

 --name {model name} 

- o nome do seu projeto. Pode ser arbitrário, mas recomendo incluir a arquitetura do modelo, a resolução máxima e o nome do conjunto de dados no nome.
Por exemplo: "resnet9_128to400_comics8"
Assim, você pode distinguir entre experimentos com vários parâmetros e dados.

A primeira etapa do treinamento pode ser interrompida na centésima era.

Você pode observar o progresso no navegador: localhost : 8097 /
(ou outro link que ficará visível no console)

Estágio Dois

 python train.py --dataroot {dataset root folder} --name {model name} --model cycle_gan --crop_size 256 --load_size 290 --init_type kaiming --netG resnet_9blocks --no_dropout --batch_size 2 --epoch 100 --epoch_count 0 --continue_train 

É importante indicar a época em que terminamos nossos estudos na primeira etapa.
“- Época 100” significa que carregaremos o modelo a partir do ponto de verificação da centésima era
"--Epoch_count 0" significa que começaremos o treinamento do zero, com a velocidade máxima de aprendizado.

A segunda etapa do treinamento pode ser interrompida na 50ª era.

Estágio Três

 python train.py --dataroot {dataset root folder} --name {model name} --model cycle_gan --crop_size 400 --load_size 430 --init_type kaiming --netG resnet_9blocks --no_dropout --batch_size 1 --epoch 50 --epoch_count 0 --continue_train 

A terceira etapa do treinamento pode ser interrompida na era 50, mas é uma questão de gosto. Você pode terminar até o fim e escolher o resultado intermediário que desejar. É importante lembrar que o resultado na era 200 pode ser pior do que na 150.

Agora saia e veja o que você fez

Durante o treinamento, o modelo e os resultados intermediários serão salvos em uma pasta
/ pytorch-CycleGAN-and-pix2pix / checkpoints / {nome do modelo}

Para testar o modelo, basta digitar a linha de comando:

 python test.py --dataroot {dataset root folder} --name {model name} --model cycle_gan --netG resnet_9blocks --crop_size 512 --load_size 580 --epoch {epoch name} 

Você pode ver o resultado em um conjunto de dados de teste para qualquer ponto de verificação, apenas especifique-o como {epoch name}. Se {epoch name} não for especificado, o último ponto de verificação será adotado.

O resultado será salvo na pasta:
/pytorch-CycleGAN-and-pix2pix/results/{model name}/test_{epoch name}

Para não se confundir qual modelo em qual conjunto de dados fornece qual resultado,
comece a manter um pequeno diário. Registre dados da linha de base e resultados de aprendizagem.

Por exemplo, a linha de comando e a época a que você alcançou. Esses dados são suficientes para salvar os parâmetros de treinamento e o conjunto de dados no qual treinamos.

Afinal, qual é a diferença entre um experimento científico e uma brincadeira? O fato de tudo estar documentado conosco!

Isso é tudo por hoje! No próximo artigo, aprenderemos como exportar um modelo pronto e hospedá-lo na nuvem.

Não tenha medo de experimentar. Não deixe de experimentar vários conjuntos de dados diferentes, comparar os resultados e compartilhá-los nos comentários!

Até breve!

⇨ Próxima parte