Successfully reported this slideshow.
We use your LinkedIn profile and activity data to personalize ads and to show you more relevant ads. You can change your ad preferences anytime.

Scipy meetup-2020-02

61 views

Published on

GANs: uma breve introdução

Published in: Data & Analytics
  • Be the first to comment

  • Be the first to like this

Scipy meetup-2020-02

  1. 1. GANs: Uma breve introduçãoGANs: Uma breve introdução SciPy Meetup 15/02/2020
  2. 2. Renato CandidoRenato Candido Trabalhando com consultoria técnica Professor de cursos de engenharia e tecnologia Interesses: Processamento digital de sinais Algoritmos adaptativos e aprendizagem de máquina Dispositivos de IoT renatocan@gmail.com { , , , } / renatocan www.renatocandido.org Linkedin Twitter Github Facebook
  3. 3. PesquisaPesquisa Desde 2015, pesquisador colaborador do Laboratório de Processamento de Sinais da Escola Politécnica da USP. Coorientação de um trabalho de mestrado na área de processamento distribuído baseado em grafos. Coorientação de alguns trabalhos de iniciação científica. Restauração de imagens usando técnicas de aprendizagem de máquinas. Recentemente, foram propostas algumas soluções usando GANs.
  4. 4. O que são GANs?O que são GANs? Generative Adversarial Network → Rede Gerativa Adversária. São modelos gerativos baseados em redes neurais. Modelos gerativos são diferentes dos modelos discriminativos comumente utilizados. Tem atraído atenção pelos resultados obtidos, principalmente na área de procesamento de imagens e vídeos.
  5. 5.    (2019) https://www.thispersondoesnotexist.com/ StyleGAN
  6. 6.    https://www.thiscatdoesnotexist.com/
  7. 7.    CycleGAN - Transferência de Estilo
  8. 8. SumárioSumário 1 - Diferença entre modelo discriminativo e modelo gerativo. 2 - GANs: estrutura e treinamento. 3 - Exemplo didático com PyTorch. 4 - Exemplo mais elaborado. 5 - Alguns detalhes sobre aplicações.
  9. 9. 1 - Diferença entre modelo1 - Diferença entre modelo discriminativo e modelo gerativodiscriminativo e modelo gerativo Vamos começar relembrando como um modelo discriminativo funciona para então compará-lo com um modelo gerativo.
  10. 10. Modelo DiscriminativoModelo Discriminativo Usados para a maioria dos problemas supervisionados de classificação ou regressão. Ex.: Modelo para classificar imagens de dígitos manuscritos de 0 a 9. Conjunto de dados com imagens e os rótulos dos dígitos associados (labels). Treinamento: ajuste de parâmetros para minimizar função custo. Após o treinamento: uso para classificar uma imagem de um novo dígito.
  11. 11. Aprende a probabilidade condicional da saída , dada a entrada . Usa os dados de treinamento para aprender as fronteiras entre as classes. Usa as fronteiras para discriminar uma entrada e fazer uma predição. Diversos tipos de modelos discriminativos: Exs.: Redes neurais, modelos de regressão logística, máquinas de vetores de suporte (SVMs). P(y|x) y x
  12. 12. Modelo GerativoModelo Gerativo São treinados para descrever como um conjunto de dados é gerado. Usando um modelo gerativo, é possível gerar novos dados. Modelos discriminativos são usados com conjuntos de dados rotulados. Modelos gerativos são geralmente usados com conjuntos de dados não rotulados. Podem ser vistos como uma forma de aprendizado não supervisionado.
  13. 13. Modelo GerativoModelo Gerativo Conjunto de dados de dígitos manuscritos: Aplicação: geração de novos dígitos. Treinamento: ajuste de parâmetros para minimizar função custo. Objetivo: aprender a distribuição de probabilidade dos dados de entrada.
  14. 14. Incluem um elemento estocástico que influencia como as amostras são geradas. Após o treinamento: ruído aleatório de um espaço latente é usado para alimentar o gerador. Aprende a probabilidade dos dados de entrada.P(x)
  15. 15. Na Verdade…Na Verdade… Modelos gerativos também podem ser usados com dados rotulados. Nesse caso, são treinados para aprender a probabilidade condicional da entrada , dada a saída . Também podem ser usados para classificação mas, em geral, modelos discriminativos tem um desempenho melhor. Mais detalhes no artigo . P(x|y) x y On Discriminative vs. Generative Classifiers: A comparison of logistic regression and naive Bayes
  16. 16. Modelos GerativosModelos Gerativos Existem diversos tipos de modelos gerativos: Máquinas de Boltzmann, autoencoders variacionais, modelos ocultos de Markov, modelos que fazem predição da próxima palavra em uma sequência, como o GPT-2. As GANs têm recebido atenção pelos resultados expressivos nas áreas de imagens e vídeos.
  17. 17. 2 - GANs: estrutura e2 - GANs: estrutura e treinamentotreinamento Propostas no artigo Duas redes neurais: Gerador e Discriminador O Gerador fornece amostras semelhantes aos dados reais. Estima O Discriminador identifica se uma amostra é real ou gerada. Adversária porque o gerador e o discriminador são treinados para competir um com o outro. O gerador é treinado para enganar o discriminador. O discriminador é treinado para detectar amostras geradas. Goodfellow et al. Generative Adversarial Nets, NIPS, 2014 P(x)
  18. 18. Estrutura da GANEstrutura da GAN é alimentado com dados do espaço latente. e podem ter qualquer estrutura: MLP, CNN, etc. Desde que as dimensões de entrada e saída sejam adequadas G D G
  19. 19. Uma aplicação simplesUma aplicação simples Dados reais bidimensionais. tal que para entre e . Espaço latente bidimensional ( , )x1 x2 = sen( )x2 x1 x1 0 2π ( , )z1 z2
  20. 20. TreinamentoTreinamento Jogo do tipo minimax para resolver o problema de otimização: e são distribuições dos dados reais e gerados. Simplificando: maximiza quando e minimiza quando V (G, D) = {log(D(x))} + {1 − log(D( ))}minG maxD E x∼Pr E ∼x ~ Pg x ~ Pr Pg D V (G, D) D(x) = 1 D( ) = 0x˜ G V (G, D) D( ) = 1x˜
  21. 21. TreinamentoTreinamento Não existem rótulos no conjunto de treinamento não supervisionado Porém, a cada passo do treinamento da GAN: é treinado de forma supervisionada. é treinado de forma supervisionada. → D G
  22. 22. Na Verdade…Na Verdade… Mas vamos considerar para simplificar.k = 1
  23. 23. Treinamento DiscriminadorTreinamento Discriminador Dados reais e dados gerados são amostrados e rotulados
  24. 24. Treinamento GeradorTreinamento Gerador Parâmetros de congelados. Dados do espaço latente são rotulados como 1. Simples por conta do autodiff. D
  25. 25. 3 - Implementação com PyTorch3 - Implementação com PyTorch
  26. 26. Ambiente e importsAmbiente e imports Usando conda environments: Importando as bibliotecas: conda create --name gan conda activate gan conda install pytorch matplotlib jupyter import torch from torch import nn import math import matplotlib.pyplot as plt # Random seed for reproductibility torch.manual_seed(111)
  27. 27. Conjunto de treinamentoConjunto de treinamento train_set é uma lista com elementos (dado_i, label_i) train_data_length = 1024 train_data = torch.zeros((train_data_length, 2)) train_data[:, 0] = 2*math.pi*torch.rand(train_data_length) train_data[:, 1] = torch.sin(train_data[:, 0]) train_labels = torch.zeros(train_data_length) train_set = [(train_data[i], train_labels[i]) for i in range(train_data_length)] plt.plot(train_data[:, 0], train_data[:, 1], '.')
  28. 28. PyTorch Data LoaderPyTorch Data Loader batch_size = 32 train_loader = torch.utils.data.DataLoader(train_set, batch_size=batch_size, shuffle=True)
  29. 29. DiscriminadorDiscriminador MLP Entrada de 2 dimensões 3 camadas ocultas: 256, 128 e 64 neurônios com ativação do tipo ReLU. Camada de saída com 1 neurônio com ativação sigmoidal. Saída no intervalo [0, 1]. Dropout de 30% nas camadas ocultas.
  30. 30. DiscriminadorDiscriminador class Discriminator(nn.Module): def __init__(self): super().__init__() self.model = nn.Sequential( nn.Linear(2, 256), nn.ReLU(), nn.Dropout(0.3), nn.Linear(256, 128), nn.ReLU(), nn.Dropout(0.3), nn.Linear(128, 64), nn.ReLU(), nn.Dropout(0.3), nn.Linear(64, 1), nn.Sigmoid() ) # (...) def forward(self, x): output = self.model(x) return output discriminator = Discriminator()
  31. 31. GeradorGerador MLP Entrada de 2 dimensões (espaço latente) 2 camadas ocultas: 16 e 32 neurônios com ativação do tipo ReLU. Camada de saída com 2 neurônios com ativação linear.
  32. 32. GeradorGerador class Generator(nn.Module): def __init__(self): super().__init__() self.model = nn.Sequential( nn.Linear(2, 16), nn.ReLU(), nn.Linear(16, 32), nn.ReLU(), nn.Linear(32, 2), ) def forward(self, x): output = self.model(x) return output generator = Generator()
  33. 33. Hiperparâmetros, função custo eHiperparâmetros, função custo e otimizadoresotimizadores Função custo: Entropia Cruzada Binária. Adaptação com o algoritmo . lr = 0.001 num_epochs = 300 loss_function = nn.BCELoss() optimizer_discriminator = torch.optim.Adam(discriminator.parameters(), lr=lr) optimizer_generator = torch.optim.Adam(generator.parameters(), lr=lr) Adam
  34. 34. TreinamentoTreinamento O 1º índice dos dados fornecidos pelo Data Loader corresponde às amostras do batch. for epoch in range(num_epochs): for n, (real_samples, _) in enumerate(train_loader): # Data for training the discriminator real_samples_labels = torch.ones((batch_size, 1)) latent_space_samples = torch.randn((batch_size, 2)) generated_samples = generator(latent_space_samples) generated_samples_labels = torch.zeros((batch_size, 1)) all_samples = torch.cat((real_samples, generated_samples)) all_samples_labels = torch.cat( (real_samples_labels, generated_samples_labels)) # Training the discriminator discriminator.zero_grad() output_discriminator = discriminator(all_samples) loss_discriminator = loss_function( output_discriminator, all_samples_labels) loss_discriminator.backward() optimizer_discriminator.step()
  35. 35. Treinamento (cont.)Treinamento (cont.) Parâmetros do discriminador congelados. Adaptação apenas do gerador pois: optimizer_generator = torch.optim.Adam(generator.parameters(), lr=lr) #(...) # Data for training the generator latent_space_samples = torch.randn((batch_size, 2)) # Training the generator generator.zero_grad() generated_samples = generator(latent_space_samples) output_discriminator_generated = discriminator(generated_samples) loss_generator = loss_function( output_discriminator_generated, real_samples_labels) loss_generator.backward() optimizer_generator.step() # Show loss if epoch % 10 == 0 and n == batch_size - 1: print(f"Epoch: {epoch} Loss D.: {loss_discriminator}") print(f"Epoch: {epoch} Loss G.: {loss_generator}")
  36. 36. ResultadosResultados Treinamento rápido: 300 épocas em aprox. 5 minutos latent_space_samples = torch.randn(100, 2) generated_samples = generator(latent_space_samples) generated_samples = generated_samples.detach() plt.plot(generated_samples[:, 0], generated_samples[:, 1], '.')
  37. 37. Evolução do geradorEvolução do gerador Entrada constante. Após 10 épocas: z
  38. 38. Evolução do geradorEvolução do gerador Entrada constante. Após 40 épocas: z
  39. 39. Evolução do geradorEvolução do gerador Entrada constante. Após 70 épocas: z
  40. 40. Evolução do geradorEvolução do gerador Entrada constante. Após 90 épocas: z
  41. 41. Evolução do geradorEvolução do gerador Entrada constante. Após 150 épocas: z
  42. 42. 4 - Outra aplicação: Geração de4 - Outra aplicação: Geração de Imagens de Dígitos ManuscritosImagens de Dígitos Manuscritos Conjunto de treinamento MNIST
  43. 43. Ambiente e importsAmbiente e imports Conjunto de treinamento MNIST disponível no pacote torchvision: imports: conda activate gan conda install torchvision conda install pillow=6.2.1 # Problema com o pillow 7.0.0. Necessário downgrade import torch from torch import nn import math import matplotlib.pyplot as plt import torchvision import torchvision.transforms as transforms torch.manual_seed(111)
  44. 44. Treinamento com GPUTreinamento com GPU Conjunto de dados é maior. Necessárias redes neurais com mais parâmetros. Tempo de treinamento de 50 épocas em CPU: aprox. 2 horas. Com uma GPU, o tempo diminui para aprox. 30 minutos. device = '' if torch.cuda.is_available(): device = torch.device('cuda') else: device = torch.device('cpu')
  45. 45. Conjunto de treinamentoConjunto de treinamento Transformação nos dados. Criação de um tensor. Mudança do intervalo dos coeficientes de [0, 1] para [-1, 1] transform = transforms.Compose( [transforms.ToTensor(), transforms.Normalize((0.5,), (0.5,))])
  46. 46. Conjunto de treinamentoConjunto de treinamento Retorna: train_set = torchvision.datasets.MNIST(root='.', train=True, download=True, transform=transform) batch_size = 32 train_loader = torch.utils.data.DataLoader(train_set, batch_size=batch_size, shuffle=True) samples, labels = next(iter(train_loader)) print(samples.shape) print(labels.shape) torch.Size([32, 1, 28, 28]) torch.Size([32])
  47. 47. Conjunto de treinamentoConjunto de treinamento real_samples, mnist_labels = next(iter(train_loader)) for i in range(16): ax = plt.subplot(4, 4, i+1) plt.imshow(real_samples[i].reshape(28, 28), cmap='gray_r') plt.xticks([]) plt.yticks([])
  48. 48. DiscriminadorDiscriminador MLP Entrada de 784 dimensões (imagem 28x28) 3 camadas ocultas: 1024, 512 e 256 neurônios com ativação do tipo ReLU. Camada de saída com 1 neurônio com ativação sigmoidal. Saída no intervalo [0, 1]. Dropout de 30% nas camadas ocultas. Uso da GPU com: discriminator = Discriminator().to(device=device)
  49. 49. GeradorGerador MLP Entrada de 100 dimensões (espaço latente) 3 camadas ocultas: 256, 512 e 1024 neurônios com ativação do tipo ReLU. Camada de saída com 784 neurônios com ativação Tanh. Intervalo [-1, 1] Pós-processamento: arranjo do vetor de 784 elementos em imagem 28x28 Uso da GPU com: # (...) def forward(self, x): output = self.model(x) output = output.view(x.size(0), 1, 28, 28) return output generator = Generator().to(device=device)
  50. 50. Outras diferençasOutras diferenças Hiperparâmetros: Dados movidos para a GPU usando to(device=device): lr = 0.0001 num_epochs = 50 for epoch in range(num_epochs): for n, (real_samples, mnist_labels) in enumerate(train_loader): # Data for training the discriminator real_samples = real_samples.to(device=device) real_samples_labels = torch.ones((batch_size, 1)).to(device=device) latent_space_samples = torch.randn((batch_size, 100)).to(device=device) generated_samples = generator(latent_space_samples) # (...)
  51. 51. ResultadosResultados Dados movidos de volta para a CPU com .cpu(): latent_space_samples = torch.randn(batch_size, 100).to(device=device) generated_samples = generator(latent_space_samples) generated_samples = generated_samples.cpu().detach() for i in range(16): ax = plt.subplot(4, 4, i+1) plt.imshow(generated_samples[i].reshape(28, 28), cmap='gray_r') plt.xticks([]) plt.yticks([])
  52. 52. Evolução do geradorEvolução do gerador Entrada constante. Após 2 épocas: z
  53. 53. Evolução do geradorEvolução do gerador Entrada constante. Após 10 épocas: z
  54. 54. Evolução do geradorEvolução do gerador Entrada constante. Após 20 épocas: z
  55. 55. Evolução do geradorEvolução do gerador Entrada constante. Após 30 épocas: z
  56. 56. Evolução do geradorEvolução do gerador Entrada constante. Após 40 épocas: z
  57. 57. 5 - Alguns detalhes sobre5 - Alguns detalhes sobre aplicaçõesaplicações Imagens de alta resolução são mais complicadas de se obter. Uso de CNNs. Início com GAN para baixa resolução e aumento gradativo. Aplicações de restauração, inpainting: Espaço latente é composto por imagens degradadas. Conjunto de treinamento é composto por imagens sem degradação. Papel do gerador é eliminar a degradação das imagens. Completando lacunas, desfazendo efeito de blur. Em algumas aplicações, o pré-processamento pode ajudar. Localizar o cavalo para transformar em zebra, por exemplo. GANs exigem um grande poder computacional para treinamento.
  58. 58. Obrigado!Obrigado! renatocan@gmail.com { , , , } / renatocan Código: www.renatocandido.org Linkedin Twitter Github Facebook https://github.com/renatocan/scipy-meetup-2020-02

×