Status epistêmico: este modelo é o resultado de algumas semanas de aprendizado, não de anos de experiência. Pense nisso como notas de aula de seus amigos, não como apostilas dos professores. Para mostrar como sou subqualificado e opinativo, basta verificar a lista de problemas que não consegui resolver. E se você souber como resolvê-los, por favor, me diga.

Você já ficou confuso sobre qual é a melhor prática para PyTorch ? Tipo, quando enviar seu Tensor para GPU? ou quando ligar para zero_grad? Ou você tentou fazer algo novo, como adicionar um pipeline do tipo SimCLR e ter que reescrever a maior parte do código porque ele foi mal escrito? Ou talvez você esteja se perguntando como é o pipeline de todos os outros? São 100% mais eficientes? Quais são as dicas e truques simples que você está perdendo? Talvez não você, mas eu tenho. PyTorch Lightning (PL) vem ao resgate. É basicamente um modelo de como seu código deve ser estruturado.

PL tem muitos recursos em suas documentações, como:

• exploração madeireira
• inspecionando gradiente
• analisador
• etc.

• O exemplo mais simples chamado de modelo chato para depuração
• Modelo Scratch para prototipagem rápida
• Exemplos básicos como MNIST
• Exemplo avançado como Generative Adversarial Network (GAN)
• E ainda mais coisas no PL Bolts ( github )

O modelo

Link para o Google Colab aqui.

Recursos

Exploração madeireira

• Registrando no TensorBoard AND stdout para redundância (eu mesmo fiz isso ^^). Ainda não consigo copiar tudo. Algumas informações são colocadas apenas no stdout. Isso é um problema porque se você usar clusters de supercomputação, os arquivos de saída terão nomes indefinidos, tornando mais difícil procurar detalhes experimentais, especialmente em um futuro distante. (Estou pensando em fazer login no WandB também).
• Use corretamente hp_metric para que possamos selecionar os melhores hiperparâmetros dentro do TensorBoard (ainda não está funcionando T_T. Como uma solução temporária, ele salva em um .json que é carregado em um DataFrame do pandas).

• Curva de perda (eu mesmo fiz isso ^^).
• Tempo de script inteiro (para estimar WALLTIME se você estiver usando clusters de supercomputação) (eu mesmo fiz isso ^^).
• Inspecione as normas do gradiente para evitar o desaparecimento ou explosão do gradiente .

• Parâmetros de log como histograma para TensorBoard (eu mesmo fiz isso ^^). O registro de parâmetros individuais pode não ser realista e haveria milhões de parâmetros por época.
• Imprima um resumo do seu LightningModule . Este é um exemplo de saída impressa que não posso redirecionar para o texto do TensorBoard.
• Registre informações do sistema (hardware e software) .

• Profiler ( PyTorch ) para descobrir quais camadas / operações são o gargalo que estão roubando seu tempo e memória. Observe que isso retarda as coisas. Por muito! Portanto, certifique-se de desligar isso antes de ir para o ajuste de hiperparâmetros.
• A verificação de integridade é um recurso ativado por padrão. É bom saber que isso existe. (Descobri isso da maneira mais difícil)

• Existem 2 maneiras de monitorar a GPU. O primeiro monitora apenas a memória , enquanto o segundo pode monitorar uma série de estatísticas . Meu modelo usa apenas o primeiro.
• Existem duas maneiras de executar em períodos mais curtos. A primeira é limitando o número de lotes . Enquanto o segundo é fast_dev_run que limita o número de lotes em segundo plano de qualquer maneira, entre outras coisas. Meu modelo chama os argumentos limitantes diretamente.
• Faça o modelo overfit no subconjunto de dados

Otimização

• Parada antecipada porque não vamos desperdiçar recursos quando o modelo já convergiu.
• Recorte gradiente
• Quando se trata de otimizador, eu costumava simplesmente usar Adam , com ReduceLROnPlateau, e encerrar o dia (eu nem mesmo otimizo para betas). Mas isso me impede de dormir à noite, porque sempre me questiono, me perguntando se estou perdendo grandes melhorias. E eu sei que esta é uma área de pesquisa MUITO ativa . Mas a alternativa é a maldição da dimensionalidade com hiperparâmetros do otimizador. É aqui que a PL vem em meu socorro. Agora, eu poderia simplesmente considerar o PL como um padrão do setor, usar todas as ferramentas de otimização fornecidas e dormir um pouco mais tranquilo. E aqui estão as duas ferramentas: Learning Rate Finder e Stochastic Weight Averaging .

• Salve o melhor modelo e teste-o .
• Depois de terminar sua pesquisa de hiperparâmetro, você pode querer carregar um ponto de verificação após o encerramento da sessão para fazer coisas como análise residual ou análise de ativação (veja a bela figura acima) no melhor modelo.
• (Rastrear como as ativações mudam durante o treinamento também pode ser útil, mas eu não implemento isso neste modelo.)

• Há um exemplo de pesquisa em grade no meu modelo do Google Colab. Sim, eu sei que a pesquisa aleatória é melhor , mas isso é apenas para demonstração.
• Por algum motivo, não consigo fazer o hp_metric no TensorBoard funcionar, então fiz um .json contornar. Também está incluído um snippet para agregar os arquivos .json de diferentes execuções experimentais.
• O que também preciso é de uma biblioteca otimizadora de hiperparâmetros que implemente um bom algoritmo, que leia e grave de um arquivo offline (porque estou usando HPC). A melhor solução até agora é Optuna porque é fácil paralelizar offline .

Obviamente, meu modelo no Google Colab, se você não o verificou. Mas você pode querer verificar os modelos existentes no Bolts e fazer seu próprio LightningDataModule para seus próprios conjuntos de dados. Boa sorte!

Referências

Todas as imagens, exceto indicação em contrário na legenda, são minhas.