Crie dados a partir de ruído aleatório com redes adversárias generativas

Desde que descobri as redes generativas de adversários (GANs), fiquei fascinado por elas. Uma GAN é um tipo de rede neural capaz de gerar novos dados do zero. Você pode alimentá-lo com um pouco de ruído aleatório como entrada, e ele pode produzir imagens realistas de quartos, ou pássaros, ou o que quer que seja treinado para gerar.

Uma coisa com a qual todos os cientistas podem concordar é que precisamos de mais dados.

As GANs, que podem ser usadas para produzir novos dados em situações de dados limitados, podem ser realmente úteis. Os dados às vezes podem ser difíceis, caros e demorados para gerar. Para serem úteis, porém, os novos dados precisam ser realistas o suficiente para que quaisquer insights que obtivermos dos dados gerados ainda se apliquem aos dados reais. Se você está treinando um gato para caçar ratos e está usando ratos falsos, é melhor se certificar de que os ratos falsos realmente se parecem com ratos.

Outra maneira de pensar sobre isso é que as GANs estão descobrindo a estrutura nos dados que lhes permite criar dados realistas. Isso pode ser útil se não pudermos ver essa estrutura por conta própria ou não pudermos retirá-la com outros métodos.

Neste artigo, você aprenderá como as GANs podem ser usadas para gerar novos dados. Para manter este tutorial realista, usaremos o conjunto de dados de detecção de fraude de cartão de crédito do Kaggle.

Em meus experimentos, tentei usar esse conjunto de dados para ver se consigo um GAN para criar dados realistas o suficiente para nos ajudar a detectar casos fraudulentos. Este conjunto de dados destaca o problema de dados limitados: de 285.000 transações, apenas 492 são fraudes. 492 casos de fraude não é um grande conjunto de dados para treinar, especialmente quando se trata de tarefas de aprendizado de máquina em que as pessoas gostam de ter conjuntos de dados várias ordens de magnitude maiores. Embora os resultados do meu experimento não tenham sido surpreendentes, aprendi muito sobre GANs ao longo do caminho que estou feliz em compartilhar.

Antes que você comece

Antes de nos aprofundarmos nesse domínio de GANs, se você quiser aprimorar rapidamente suas habilidades de aprendizado de máquina ou aprendizado profundo, dê uma olhada nestas duas postagens de blog relacionadas:

• Uma introdução à teoria do aprendizado de máquina e sua aplicação: um tutorial visual com exemplos
• Um tutorial de aprendizado profundo: de perceptrons a redes profundas

Por que GAN?

As redes generativas adversariais (GANs) são uma arquitetura de rede neural que mostrou melhorias impressionantes em relação aos métodos generativos anteriores, como codificadores automáticos variacionais ou máquinas boltzman restritas. As GANs foram capazes de gerar imagens mais realistas (por exemplo, DCGAN), permitir a transferência de estilo entre imagens (veja aqui e aqui), gerar imagens a partir de descrições de texto (StackGAN) e aprender com conjuntos de dados menores por meio de aprendizado semi-supervisionado. Devido a essas conquistas, eles estão gerando muito interesse nos setores acadêmico e comercial.

O diretor de pesquisa de IA do Facebook, Yann LeCunn, até os chamou de desenvolvimento mais empolgante em aprendizado de máquina na última década.

O básico

Pense em como você aprende. Você tenta alguma coisa, você recebe algum feedback. Você ajusta sua estratégia e tenta novamente.

O feedback pode vir na forma de crítica, dor ou lucro. Pode vir de seu próprio julgamento de quão bem você fez. Muitas vezes, o feedback mais útil é o feedback que vem de outra pessoa, porque não é apenas um número ou sensação, mas uma avaliação inteligente de quão bem você executou a tarefa.

Quando um computador é treinado para uma tarefa, o humano geralmente fornece o feedback na forma de parâmetros ou algoritmos ajustados. Isso funciona bem quando a tarefa está bem definida, como aprender a multiplicar dois números. Você pode facilmente e exatamente dizer ao computador como ele estava errado.

Com uma tarefa mais complicada, como criar uma imagem de cachorro, fica mais difícil fornecer feedback. A imagem está embaçada, parece mais com um gato ou se parece com alguma coisa? Estatísticas complexas poderiam ser implementadas, mas seria difícil capturar todos os detalhes que fazem uma imagem parecer real.

Um humano pode dar alguma estimativa, porque temos muita experiência em avaliar a entrada visual, mas somos relativamente lentos e nossas avaliações podem ser altamente subjetivas. Em vez disso, poderíamos treinar uma rede neural para aprender a tarefa de discriminar entre imagens reais e geradas.

Então, ao permitir que o gerador de imagem (também uma rede neural) e o discriminador se revezem aprendendo um com o outro, eles podem melhorar com o tempo. Essas duas redes, jogando este jogo, são uma rede adversária generativa.

Você pode ouvir o inventor dos GANs, Ian Goodfellow, falar sobre como uma discussão em um bar sobre esse tópico levou a uma noite febril de codificação que resultou no primeiro GAN. E sim, ele reconhece a barra em seu jornal. Você pode aprender mais sobre GANs no blog de Ian Goodfellow sobre este tópico.

Há uma série de desafios ao trabalhar com GANs. Treinar uma única rede neural pode ser difícil devido ao número de opções envolvidas: arquitetura, funções de ativação, método de otimização, taxa de aprendizado e taxa de abandono, para citar apenas algumas.

As GANs duplicam todas essas opções e adicionam novas complexidades. Tanto o gerador quanto o discriminador podem esquecer truques que usaram anteriormente em seu treinamento. Isso pode levar as duas redes a ficarem presas em um ciclo estável de soluções que não melhoram com o tempo. Uma rede pode dominar a outra rede, de modo que nenhuma delas possa aprender mais. Ou, o gerador pode não explorar muito do espaço de solução possível, apenas o suficiente para encontrar soluções realistas. Esta última situação é conhecida como colapso de modo.

O colapso do modo é quando o gerador aprende apenas um pequeno subconjunto dos modos realistas possíveis. Por exemplo, se a tarefa é gerar imagens de cachorros, o gerador pode aprender a criar apenas imagens de pequenos cachorros marrons. O gerador teria perdido todos os outros modos que consistem em cães de outros tamanhos ou cores.

Muitas estratégias foram implementadas para resolver isso, incluindo normalização em lote, adição de rótulos nos dados de treinamento ou alteração da maneira como o discriminador julga os dados gerados.

As pessoas notaram que adicionar rótulos aos dados, ou seja, dividi-los em categorias, quase sempre melhora o desempenho das GANs. Em vez de aprender a gerar imagens de animais de estimação em geral, deveria ser mais fácil gerar imagens de gatos, cachorros, peixes e furões, por exemplo.

Talvez os avanços mais significativos no desenvolvimento de GAN tenham ocorrido em termos de mudança na forma como o discriminador avalia os dados, então vamos dar uma olhada mais de perto nisso.

Na formulação original das GANs em 2014 por Goodfellow et al., o discriminador gera uma estimativa da probabilidade de uma determinada imagem ser real ou gerada. O discriminador receberia um conjunto de imagens que consistia em imagens reais e geradas e geraria uma estimativa para cada uma dessas entradas. O erro entre a saída do discriminador e os rótulos reais seria então medido pela perda de entropia cruzada. A perda de entropia cruzada pode ser equiparada à métrica de distância Jensen-Shannon, e foi demonstrado no início de 2017 por Arjovsky et al. que essa métrica falharia em alguns casos e não apontaria na direção certa em outros casos. Este grupo mostrou que a métrica de distância de Wasserstein (também conhecida como terra ou distância EM) funcionou e funcionou melhor em muitos outros casos.

A perda de entropia cruzada é uma medida da precisão com que o discriminador identificou imagens reais e geradas. A métrica Wasserstein, em vez disso, analisa a distribuição de cada variável (ou seja, cada cor de cada pixel) nas imagens reais e geradas e determina a distância entre as distribuições para dados reais e gerados. A métrica Wasserstein analisa quanto esforço, em termos de massa vezes distância, seria necessário para empurrar a distribuição gerada para a forma da distribuição real, daí o nome alternativo “distância do motor de terra”. Como a métrica Wasserstein não está mais avaliando se uma imagem é real ou não, mas sim fornecendo críticas sobre a distância entre as imagens geradas e as imagens reais, a rede “discriminadora” é chamada de rede “crítica” no Wasserstein. arquitetura.

Para uma exploração um pouco mais abrangente das GANs, neste artigo, exploraremos quatro arquiteturas diferentes:

• GAN: O GAN original (“baunilha”)
• CGAN: Uma versão condicional do GAN original que faz uso de rótulos de classe
• WGAN: O Wasserstein GAN (com penalidade de gradiente)
• WCGAN: Uma versão condicional do Wasserstein GAN

Mas vamos dar uma olhada em nosso conjunto de dados primeiro.

Uma olhada nos dados de fraude de cartão de crédito

Trabalharemos com o conjunto de dados de detecção de fraude de cartão de crédito da Kaggle.

O conjunto de dados consiste em aproximadamente 285.000 transações, das quais apenas 492 são fraudulentas. Os dados consistem em 31 recursos: "tempo", "quantidade", "classe" e 28 recursos anonimizados adicionais. A característica de classe é o rótulo que indica se uma transação é fraudulenta ou não, com 0 indicando normal e 1 indicando fraude. Todos os dados são numéricos e contínuos (exceto o rótulo). O conjunto de dados não possui valores ausentes. O conjunto de dados já está em boa forma para começar, mas farei um pouco mais de limpeza, principalmente ajustando as médias de todos os recursos para zero e os desvios padrão para um. Eu descrevi meu processo de limpeza mais no notebook aqui. Por enquanto vou apenas mostrar o resultado final:

Pode-se facilmente identificar diferenças entre os dados normais e de fraude nessas distribuições, mas também há muita sobreposição. Podemos aplicar um dos algoritmos de aprendizado de máquina mais rápidos e poderosos para identificar os recursos mais úteis para identificar fraudes. Esse algoritmo, xgboost, é um algoritmo de árvore de decisão impulsionado por gradiente. Vamos treiná-lo em 70% do conjunto de dados e testá-lo nos 30% restantes. Podemos configurar o algoritmo para continuar até que ele não melhore o recall (a fração de amostras de fraude detectadas) no conjunto de dados de teste. Isso atinge 76% de recall no conjunto de teste, o que claramente deixa espaço para melhorias. Atinge uma precisão de 94%, o que significa que apenas 6% dos casos de fraude previstos foram realmente transações normais. A partir dessa análise, também obtemos uma lista de recursos classificados por sua utilidade na detecção de fraudes. Podemos usar os recursos mais importantes para ajudar a visualizar nossos resultados mais tarde.

Novamente, se tivéssemos mais dados de fraude, poderíamos detectá-los melhor. Ou seja, poderíamos alcançar um recall maior. Agora, tentaremos gerar dados de fraude novos e realistas usando GANs para nos ajudar a detectar fraudes reais.

Gerando novos dados de cartão de crédito com GANs

Para aplicar várias arquiteturas GAN a esse conjunto de dados, usarei o GAN-Sandbox, que possui várias arquiteturas GAN populares implementadas em Python usando a biblioteca Keras e um back-end do TensorFlow. Todos os meus resultados estão disponíveis como um notebook Jupyter aqui. Todas as bibliotecas necessárias estão incluídas na imagem Kaggle/Python Docker, se você precisar de uma configuração fácil.

Os exemplos no GAN-Sandbox são configurados para processamento de imagem. O gerador produz uma imagem 2D com 3 canais de cores para cada pixel, e o discriminador/crítico é configurado para avaliar tais dados. As transformações convolucionais são utilizadas entre as camadas das redes para aproveitar a estrutura espacial dos dados da imagem. Cada neurônio em uma camada convolucional trabalha apenas com um pequeno grupo de entradas e saídas (por exemplo, pixels adjacentes em uma imagem) para permitir o aprendizado de relações espaciais. Nosso conjunto de dados de cartão de crédito não possui nenhuma estrutura espacial entre as variáveis, então converti as redes convolucionais em redes com camadas densamente conectadas. Os neurônios em camadas densamente conectadas são conectados a todas as entradas e saídas da camada, permitindo que a rede aprenda seus próprios relacionamentos entre os recursos. Usarei essa configuração para cada uma das arquiteturas.

A primeira GAN que vou avaliar coloca a rede geradora contra a rede discriminadora, fazendo uso da perda de entropia cruzada do discriminador para treinar as redes. Esta é a arquitetura GAN original, “baunilha”. A segunda GAN que avaliarei adiciona rótulos de classe aos dados na forma de uma GAN condicional (CGAN). Este GAN possui mais uma variável nos dados, o rótulo da classe. A terceira GAN utilizará a métrica de distância de Wasserstein para treinar as redes (WGAN), e a última utilizará os rótulos de classe e a métrica de distância de Wasserstein (WCGAN).

Treinaremos as várias GANs usando um conjunto de dados de treinamento que consiste em todas as 492 transações fraudulentas. Podemos adicionar classes ao conjunto de dados de fraude para facilitar as arquiteturas GAN condicionais. Eu explorei alguns métodos diferentes de agrupamento no notebook e usei uma classificação do KMeans que classifica os dados de fraude em 2 classes.

Vou treinar cada GAN por 5.000 rodadas e examinar os resultados ao longo do caminho. Na Figura 4, podemos ver os dados de fraude reais e os dados de fraude gerados das diferentes arquiteturas GAN à medida que o treinamento avança. Podemos ver os dados de fraude reais divididos nas 2 classes KMeans, plotadas com as 2 dimensões que melhor discriminam essas duas classes (características V10 e V17 das características transformadas do PCA). Os dois GANs que não fazem uso de informações de classe, o GAN e o WGAN, têm suas saídas geradas todas como uma classe. As arquiteturas condicionais, CGAN e WCGAN, mostram seus dados gerados por classe. Na etapa 0, todos os dados gerados mostram a distribuição normal da entrada aleatória alimentada aos geradores.

Podemos ver que a arquitetura GAN original começa a aprender a forma e o alcance dos dados reais, mas depois colapsa em direção a uma pequena distribuição. Este é o colapso de modo discutido anteriormente. O gerador aprendeu um pequeno intervalo de dados que o discriminador tem dificuldade em detectar como falsos. A arquitetura CGAN faz um pouco melhor, espalhando e aproximando as distribuições de cada classe de dados de fraude, mas então o colapso do modo se instala, como pode ser visto na etapa 5000.

O WGAN não experimenta o colapso de modo exibido pelas arquiteturas GAN e CGAN. Mesmo sem informações de classe, ele começa a assumir a distribuição não normal dos dados reais de fraude. A arquitetura WCGAN funciona de forma semelhante e é capaz de gerar as classes de dados separadas.

Podemos avaliar a aparência realista dos dados usando o mesmo algoritmo xgboost usado anteriormente para detecção de fraude. É rápido e poderoso e funciona sem muito ajuste. Treinaremos o classificador xgboost usando metade dos dados reais de fraude (246 amostras) e um número igual de exemplos gerados por GAN. Em seguida, testaremos o classificador xgboost usando a outra metade dos dados de fraude reais e um conjunto diferente de 246 exemplos gerados por GAN. Este método ortogonal (no sentido experimental) nos dará alguma indicação de quão bem sucedido o gerador é na produção de dados realistas. Com dados gerados perfeitamente realistas, o algoritmo xgboost deve atingir uma precisão de 0,50 (50%) - em outras palavras, não é melhor do que adivinhar.

Podemos ver a precisão do xgboost nos dados gerados pela GAN diminuindo no início e depois aumentando após a etapa de treinamento 1000 à medida que o colapso do modo se instala. Nós vamos. As arquiteturas WGAN e WCGAN obtêm dados mais realistas mais rapidamente e continuam a aprender à medida que o treinamento avança. O WCGAN não parece ter muita vantagem sobre o WGAN, sugerindo que essas classes criadas podem não ser úteis para as arquiteturas Wasserstein GAN.

Você pode aprender mais sobre a arquitetura WGAN aqui e aqui.

A rede crítica nas arquiteturas WGAN e WCGAN está aprendendo a calcular a distância Wasserstein (Earth-mover, EM) entre um determinado conjunto de dados e os dados reais de fraude. Idealmente, ele medirá uma distância próxima de zero para uma amostra de dados reais de fraude. O crítico, no entanto, está aprendendo a fazer esse cálculo. Desde que meça uma distância maior para dados gerados do que para dados reais, a rede pode melhorar. Podemos observar como a diferença entre as distâncias de Wasserstein para dados gerados e reais muda ao longo do treinamento. Se ele se estabilizar, o treinamento adicional pode não ajudar. Podemos ver na figura 6 que parece haver mais melhorias a serem obtidas tanto para o WGAN quanto para o WCGAN neste conjunto de dados.

O que aprendemos?

Agora podemos testar se somos capazes de gerar novos dados de fraude realistas o suficiente para nos ajudar a detectar dados reais de fraude. Podemos pegar o gerador treinado que obteve a pontuação de precisão mais baixa e usá-lo para gerar dados. Para nosso conjunto de treinamento básico, usaremos 70% dos dados não fraudulentos (199.020 casos) e 100 casos dos dados fraudulentos (~20% dos dados fraudulentos). Em seguida, tentaremos adicionar diferentes quantidades de dados de fraude reais ou gerados a esse conjunto de treinamento, até 344 casos (70% dos dados de fraude). Para o conjunto de teste, usaremos os outros 30% dos casos de não fraude (85.295 casos) e casos de fraude (148 casos). Podemos tentar adicionar dados gerados de uma GAN não treinada e da GAN melhor treinada para testar se os dados gerados são melhores do que ruído aleatório. De nossos testes, parece que nossa melhor arquitetura foi a WCGAN na etapa de treinamento 4800, onde alcançou uma precisão xgboost de 70% (lembre-se, idealmente, a precisão seria de 50%). Portanto, usaremos essa arquitetura para gerar novos dados de fraude.

Podemos ver na figura 7 que o recall (a fração de amostras de fraude reais identificadas com precisão no conjunto de teste) não aumenta à medida que usamos mais dados de fraude gerados para treinamento. O classificador xgboost é capaz de reter todas as informações usadas para identificar fraudes dos 100 casos reais e não se confundir com os dados adicionais gerados, mesmo ao selecioná-los entre centenas de milhares de casos normais. Os dados gerados do WCGAN não treinado não ajudam nem prejudicam, sem surpresa. Mas os dados gerados do WCGAN treinado também não ajudam. Parece que os dados não são suficientemente realistas. Podemos ver na figura 7 que quando dados reais de fraude são usados ​​para complementar o conjunto de treinamento, o recall aumenta significativamente. Se o WCGAN tivesse acabado de aprender a duplicar os exemplos de treinamento, sem ser criativo, poderia ter alcançado taxas de recall mais altas, como vemos com os dados reais.

Ao infinito e além

Embora não tenhamos conseguido gerar dados de fraude de cartão de crédito realistas o suficiente para nos ajudar a detectar fraudes reais, mal arranhamos a superfície com esses métodos. Poderíamos treinar por mais tempo, com redes maiores, e ajustar os parâmetros para as arquiteturas que tentamos neste artigo. As tendências na precisão do xgboost e na perda do discriminador sugerem que mais treinamento ajudará as arquiteturas WGAN e WCGAN. Outra opção é revisitar a limpeza de dados que realizamos, talvez projetar algumas novas variáveis ​​ou alterar se e como abordamos a assimetria nos recursos. Talvez diferentes esquemas de classificação dos dados de fraude ajudem.

Também poderíamos tentar outras arquiteturas GAN. O DRAGAN tem evidências teóricas e experimentais mostrando que treina mais rápido e mais estável do que os Wasserstein GANs. Poderíamos integrar métodos que fazem uso de aprendizado semi-supervisionado, que se mostraram promissores no aprendizado de conjuntos de treinamento limitados (consulte “Técnicas aprimoradas para treinamento de GANs”). Poderíamos tentar uma arquitetura que nos fornecesse modelos compreensíveis para humanos, para que possamos entender melhor a estrutura dos dados (consulte InfoGAN).

Também devemos ficar atentos a novos desenvolvimentos no campo e, por último, mas não menos importante, podemos trabalhar na criação de nossas próprias inovações neste espaço em rápido desenvolvimento.

Você pode encontrar todo o código relevante para este artigo neste repositório do GitHub.