Datasets:

pdf2dataset

/

9ef7e448f98c9c2dc5909bfe8f887c25

like 0

Follow

PDF2Dataset 9

380 | Capítulo 13: Redes Neurais Convolucionais (CNN) Camada Pooling É muito fácil entender as camadas pooling depois que entendemos como as camadas convolucionais funcionam. Seu objetivo é subamostrar (ou seja, diminuir) a imagem de entrada para reduzir a carga computacional, o uso de memória e o número de parâmetros (limitando assim o risco de sobreajuste). Assim como nas camadas convolucionais, cada neurônio na camada pooling é conectado às saídas de um número limitado de neurônios na camada anterior, localizados dentro de um pequeno campo receptivo retangular. Como antes, você deve definir seu tamanho, o stride e o tipo de preenchimento. No entanto, um neurônio de pooling não tem pesos; com a utilização de uma função de agregação, ele apenas une as entradas, como a max ou a mean. A Figura 13-8 mostra uma max pooling layer que é o tipo mais comum de camada pooling. Neste exemplo, utilizamos um pooling kernel 2 × 2, um stride de 2 e nenhum preenchimento. Note que apenas o valor máximo de entrada em cada kernel chega à próxima camada e as outras entradas são descartadas. Figura 13-8. Camada max pooling (kernel pooling 2 × 2, stride de 2, sem padding) Este é claramente um tipo muito destrutivo de camada: sua saída será duas vezes menor em ambas as direções (sua área será quatro vezes menor), descartando 75% dos valores de entrada, mesmo com um minúsculo kernel 2 × 2 e um incremento de 2. A camada de pooling funciona de forma independente em todos os canais de entrada, portanto, a profundidade de saída é a mesma de entrada. Você pode alternativamente agrupar a dimensão de profundidade, como veremos a seguir, caso em que as dimen-sões espaciais da imagem (altura e largura) permanecem inalteradas, mas o número de canais é reduzido. É muito fácil a implementação de uma camada max pooling no Tensor Flow. O código a seguir cria uma camada max pooling utilizando um kernel 2 × 2, stride de 2 e sem padding e, em seguida, a aplica a todas as imagens no conjunto de dados: CG_MIOLO_Hands_On_Machine_Learning. indb 380 07/05/2019 17:09:51

Mãos à obra Aprendizado de máquina Aurelien Geron.pdf

Arquiteturas CNN | 381[... ] # carregue o conjunto de dados das imagens, como acima # Crie um grafo com uma entrada X mais uma camada max pooling X = tf. placeholder(tf. float32, shape=(None, height, width, channels)) max_pool = tf. nn. max_pool(X, ksize=[1,2,2,1], strides=[1,2,2,1],padding="VALID") with tf. Session() as sess: output = sess. run(max_pool, feed_dict={X: dataset}) plt. imshow(output[0]. astype(np. uint8)) # plota a saída da primeira imagem plt. show() O argumento ksize contém o formato do kernel ao longo de todas as quatro dimensões do tensor de entrada: [batch size, height, width, channels]. O Tensor Flow atualmente não suporta o agrupamento em múltiplas instâncias, então o primeiro elemento ksize deve ser igual a 1. Além disso, tanto nas dimensões espaciais (altura e largura) quanto na de profundidade, ele não suporta o agrupamento, portanto ksize[1] e ksize[2] devem ser iguais a 1, ou ksize[3] deve ser igual a 1. Para criar uma camada average pooling, utilize a função avg_pool() em vez da max_pool(). Agora você conhece todos os blocos de construção para criar uma rede neural convo-lucional. Veremos como montá-las. Arquiteturas CNN As arquiteturas CNN típicas empilham algumas camadas convolucionais (cada uma geral-mente seguida por uma camada Re LU), depois uma camada pooling, depois outras camadas convolucionais (+ Re LU), depois outra camada pooling e assim por diante. A imagem fica cada vez menor à medida que avança pela rede, mas também fica mais e mais profunda (isto é, com mais mapas de características) graças às camadas convolucionais (consulte a Figura 13-9). No topo da pilha, uma rede neural feedforward regular é adicionada, composta de algumas camadas totalmente conectadas (+Re LUs) e a camada final gera a previsão (por exemplo, uma camada softmax que gera probabilidades estimadas de classe). Entrada Convolução Pooling Convolução Pooling Totalmente conec tada Figura 13-9. Arquitetura CNN típica CG_MIOLO_Hands_On_Machine_Learning. indb 381 07/05/2019 17:09:52

Mãos à obra Aprendizado de máquina Aurelien Geron.pdf

382 | Capítulo 13: Redes Neurais Convolucionais (CNN) É um erro comum utilizar kernels de convolução muito grandes. Você pode obter o mesmo efeito de uma camada convolucional com um kernel 9 × 9 ao empilhar duas camadas com kernels 3 × 3 com muito menos cálculos e parâmetros. Ao longo dos anos, foram desenvolvidas variantes dessa arquitetura fundamental, le-vando a avanços surpreendentes no campo. Uma boa medida desse progresso é a taxa de erro em competições, como o desafio ILSVRC Image Net ( http://image-net. org/ ), no qual as taxas de erro top-5 para a classificação de imagens caiu de 26% para menos de 3% em apenas seis anos. As cinco primeiras taxas de erros são o número de imagens de teste para as quais as cinco principais previsões do sistema não incluíram a resposta correta. As imagens são grandes (256 pixels de altura) e há 1 mil classes, algumas das quais realmente sutis (tente distinguir 120 raças de cães). Uma boa maneira de entender como as CNNs funcionam é observar a evolução das entradas vencedoras. Observaremos primeiro a arquitetura clássica Le Net-5 (1998), depois veremos três dos vencedores do desafio ILSVRC: Alex Net (2012), Goog Le Net (2014) e Res Net (2015). Outras Tarefas Visuais Houve um progresso impressionante também em outras tarefas visuais, como a detecção e lo-calização de objetos e a segmentação de imagens. Na detecção e localização de objetos, a rede neural produz uma sequência de caixas delimitadoras em torno de vários objetos na imagem. Por exemplo, veja o artigo de 2015 de Maxine Oquab et al. (https://goo. gl/ZKu Dtv), que pro-duz um mapa de calor para cada classe do objeto, ou o artigo de 2015 de Russell Stewart et al. (https://goo gl/ upu Hl2), que utiliza uma combinação de uma CNN para detectar faces e uma rede neural recorrente para gerar uma sequência de caixas delimitadoras em torno delas. Na segmentação de imagem, a rede produz uma imagem (geralmente do mesmo tamanho que a entrada) em que cada pixel indica a classe do objeto a qual pertence o pixel correspondente de entrada. Por exemplo, confira o artigo de Evan Shelhamer et al. 2016 (https://goo. gl/7Re Zql). Le Net-5 A arquitetura Le Net-5 é talvez a arquitetura CNN mais conhecida e, como mencionado anteriormente, foi criada por Yann Le Cun em 1998 e amplamente utilizada para reco-nhecimento de dígitos manuscritos (MNIST). É composta pelas camadas mostradas na Tabela 13-1. CG_MIOLO_Hands_On_Machine_Learning. indb 382 07/05/2019 17:09:52

Mãos à obra Aprendizado de máquina Aurelien Geron.pdf

Arquiteturas CNN | 38 3Tabela 13-1. Arquitetura Le Net-5 Camada Tipo Mapas Tamanho Tamanho do Kernel Stride Ativação Out Totalmente conectado-10--RBF F6 Totalmente conectado-84--tanh C5 Convolução 120 1 × 1 5 × 5 1 tanh S4 Média de Pooling 16 5 × 5 2 × 2 2 tanh C3 Convolução 16 10 × 10 5 × 5 1 tanh S2 Média de Pooling 6 14 × 14 2 × 2 2 tanh C1 Convolução 6 28 × 28 5 × 5 1 tanh In Entrada 1 32 × 32---Há alguns detalhes extras a serem observados: Ima gens MNIST têm 28 × 28 pixels, mas são preenchidas com zeros para chegar a 32 × 32 pixels e normalizadas antes de serem fornecidas à rede. O restante da rede não utiliza nenhum preenchimento, razão pela qual o tamanho continua encolhendo à medida que a imagem avança por ela; As ca madas comuns de agrupamento são um pouco mais complexas do que o normal: cada neurônio calcula a média de suas entradas, multiplica o resultado por um coeficiente de aprendizado (um por mapa), adiciona um termo de polari-zação de aprendizado (novamente, um por mapa) e, finalmente, aplica a função de ativação; A mai oria dos neurônios nos mapas C3 está conectada aos neurônios em apenas três ou quatro mapas S2 (em vez de todos os seis mapas S2). Veja a tabela 1 no documento original para detalhes; A cam ada de saída é especial: em vez de calcular o produto escalar das entradas e do vetor de peso, cada neurônio produz o quadrado da distância Euclidiana en-tre seu vetor de entrada e seu vetor de peso. Cada saída mede o quanto a imagem pertence a uma determinada classe de dígitos. A função de custo de entropia cruzada é preferida, pois penaliza muito mais as previsões ruins, produzindo gradientes maiores e, portanto, convergindo mais rapidamente. O site de Yann Le Cun ( http://yann. lecun. com/ ) (seção “LENET”) apresenta ótimas de-monstrações de classificação dos dígitos da Le Net-5. CG_MIOLO_Hands_On_Machine_Learning. indb 383 07/05/2019 17:09:52

Mãos à obra Aprendizado de máquina Aurelien Geron.pdf

384 | Capítulo 13: Redes Neurais Convolucionais (CNN) Alex Net A arquitetura CNN Alex Net (http://goo. gl/m WRBRp )9 venceu o desafio 2012 Image Net ILSVRC com vantagem: alcançou 17% de taxa de erro no top-5 enquanto o segundo melhor alcançou apenas 26%! Foi desenvolvida por Alex Krizhevsky (daí o nome), Ilya Sutskever e Geoffrey Hinton, e foi a primeira a empilhar camadas convolucionais dire-tamente umas sobre as outras em vez de empilhar uma camada pooling no topo de cada camada convolucional. Se assemelha muito ao Le Net-5, apenas é muito maior e mais profunda. A Tabela 13-2 apresenta essa arquitetura. Tabela 13-2. Arquitetura Alex Net Camada Tipo Mapas Tamanho Tamanho do Kernel Incremento Preenchimento Ativação Out Totalmente conectado-1. 000---Softmax F9 Totalmente conectado-4. 096---Re LU F8 Totalmente conectado-4. 096---Re LU C7 Convolução 256 13 × 13 3 × 3 1 SAME Re LU C6 Convolução 384 13 × 13 3 × 3 1 SAME Re LU C5 Convolução 384 13 × 13 3 × 3 1 SAME Re LU S4 Max Pooling256 13 × 13 3 × 3 2 VALID-C3 Convolução 256 27 × 27 5 × 5 1 SAME Re LU S2 Max Pooling96 27 × 27 3 × 3 2 VALID-C1 Convolução 96 55 × 55 11 × 11 4 SAME Re LU In Entrada 3 (RGB) 224 × 224 ----Os autores utilizaram duas técnicas de regularização que discutimos nos capítulos anteriores para a redução do sobreajuste. Para as saídas das camadas F8 e F9, primeiro eles aplicaram o dropout (com uma taxa de descarte de 50%) durante o treinamento e, em seguida, realizaram o aumento de dados através do deslocamento aleatório das imagens de treinamento por vários desvios, invertendo-as horizontalmente e alterando as condições de iluminação. A Alex Net também utiliza uma etapa de normalização competitiva imediatamente após a etapa Re LU das camadas C1 e C3, chamada normalização de resposta local (LRN, em inglês). Essa forma de normalização faz com que os neurônios ativados mais fortemente inibam neurônios no mesmo local, mas em mapas de características vizinhos (tal ativação 9 “Image Net Classification with Deep Convolutional Neural Networks”, A. Krizhevsky et al. (2012). CG_MIOLO_Hands_On_Machine_Learning. indb 384 07/05/2019 17:09:52

Mãos à obra Aprendizado de máquina Aurelien Geron.pdf

Arquiteturas CNN | 385competitiva foi observada em neurônios biológicos). Isso incentiva os diferentes mapas a se especializarem, separando-os e forçando-os a explorar uma gama mais ampla das características, melhorando a generalização. A Equação 13-2 mostra como aplicar a LRN. Equação 13-2. Normalização de resposta local bi=aik+α∑ j=jbaixojalto aj2-β comjalto=m ini+r 2,fn-1 jbaixo=max0,i-r 2 bi é a saída normalizada do neurônio localizado no mapa de características i, em alguma linha u e coluna v (observe que nesta equação consideramos apenas neurônios localizados nesta linha e coluna, então u e v não são exibidos); ai é a ativação daquele neurônio após o passo Re LU, mas antes da normalização; k, α, β e r sã o hiperparâmetros. k é chamado de bias e r é chamado de depth radius ; fn é o número de mapas de características. Por exemplo, se r = 2 e um neurônio tiver uma forte ativação, ele inibirá a ativação dos neurônios localizados no mapa de características imediatamente acima e abaixo. Na Alex Net, os hiperparâmetros são definidos da seguinte forma: r = 2, α = 0,00002, β = 0,75 e k = 1. Com a utilização da operação tf. nn. local_response_normalization() do Tensor Flow, esta etapa pode ser implementada. Uma variante do Alex Net chamada ZF Net foi desenvolvida por Matthew Zeiler e Rob Fergus e venceu o desafio ILSVRC 2013. É essencialmente a Alex Net com alguns hiperpa-râmetros ajustados (número de mapas de características, tamanho do kernel, stride, etc. ). Goog Le Net A arquitetura Goog Le Net ( http://goo. gl/t CFz Vs ) foi desenvolvida por Christian Szegedy et al. da Google Research,10 e venceu o desafio ILSVRC 2014 deixando a taxa de erro do top-5 abaixo de 7%. Esse ótimo desempenho se deu em grande parte pelo fato de que a rede era muito mais profunda que as CNNs anteriores (veja a Figura 13-11). Isso foi possível graças a subredes chamadas módulos inception,11 que possibilitam que o Goog Le Net utilize parâmetros muito mais eficientemente do que as arquiteturas ante-10 “Going Deeper with Convolutions”, C. Szegedy et al. (2015). 11 No filme A Origem (do inglês, Inception), de 2010, os personagens continuam se aprofundando em camadas múltiplas de sonhos, daí o nome desses módulos. CG_MIOLO_Hands_On_Machine_Learning. indb 385 07/05/2019 17:09:52

Mãos à obra Aprendizado de máquina Aurelien Geron.pdf

386 | Capítulo 13: Redes Neurais Convolucionais (CNN) riores: o Goog Le Net na verdade tem 10 vezes menos parâmetros que a Alex Net (cerca de 6 milhões em vez de 60 milhões). A Figura 13-10 mostra a arquitetura de um módulo de criação. A notação “3 × 3 + 2 (S)” significa que a camada utiliza um kernel 3 × 3, stride de 2 e padding SAME. Primeiro o sinal de entrada é copiado e alimentado em quatro camadas diferentes. Todas as camadas convolucionais utilizam a função de ativação Re LU. Observe que o segundo conjunto de camadas convolucionais utiliza diferentes tamanhos de kernel (1 × 1, 3 × 3 e 5 × 5), permitindo que eles capturem padrões em diferentes escalas. Observe também que cada camada utiliza um stride de 1 e padding SAME (até mesmo a camada max pooling), portanto todas as suas saídas têm a mesma altura e largura de suas entradas. Isso possibilita a concatenação de todas as saídas ao longo da dimensão de profundidade na camada final depth concat (isto é, empilhar os mapas de todas as quatro camadas convolucionais superiores). Com a utilização da operação tf. concat() com axis=3 (eixo 3 é a profundidade) essa camada de concatenação pode ser implementada no Tensor Flow. Concat Profunda Módulo Inception Convolução Convolução Convolução Convolução Convolução Convolução Max Pool Figura 13-10. Módulo Inception Você pode se perguntar por que os módulos de criação têm camadas convolucionais com núcleos 1 × 1. Já que olham apenas um pixel por vez, certamente essas camadas não podem capturar nenhuma característica. Na verdade, essas camadas servem dois propósitos: Pri meiro, para que sirvam como camadas de gargalo, elas são configuradas para exibir muito menos mapas do que suas entradas, o que significa que reduzem a dimensionalidade. Isso é particularmente útil antes das convoluções 3 × 3 e 5 × 5, já que essas camadas são muito dispendiosas em termos computacionais; Seg undo, cada par de camadas convolucionais ([1 × 1, 3 × 3] e [1 × 1, 5 × 5]) age como uma única e poderosa camada convolucional capaz de capturar padrões mais complexos. De fato, em vez de varrer um classificador linear simples pela imagem (como faz uma única camada convolucional), este par de camadas con-volucionais varre uma rede neural de duas camadas pela imagem. CG_MIOLO_Hands_On_Machine_Learning. indb 386 07/05/2019 17:09:53

Mãos à obra Aprendizado de máquina Aurelien Geron.pdf

Arquiteturas CNN | 387Em suma, você pode pensar em todo o módulo de criação como uma camada convolucional bombada, capaz de produzir mapas que capturem padrões complexos em várias escalas. O número de kernels convolucionais para cada camada convolucio-nal é um hiperparâmetro. Infelizmente, isso significa que você terá mais seis hiperparâmetros para ajustar para cada camada de criação adicionada. Agora, veremos a arquitetura CNN do Goog Le Net (veja a Figura 13-11). O Goog Le Net é tão profundo que tivemos que representá-lo em três colunas, mas, na verdade, ele é uma pilha alta que inclui nove módulos inception (as caixas com os peões). O número de mapas produzidos por cada camada convolucional e cada camada pooling é mostrado antes do tamanho do kernel. O número de mapas gerados por cada camada convolu-cional no módulo (na mesma ordem da Figura 13-10) representa os seis números nos módulos iniciais. Observe que todas as camadas convolucionais utilizam a função de ativação Re LU. Max Pool Max Pool Max Pool Max Pool Convolução Convolução Norma de Resposta Local Norma de Resposta Local Entrada Convolução Avg Pool Max Pool Dropout Softmax 1000 unidades totalmente conec tadas módulo inception Figura 13-11. Arquitetura Goog Le Net CG_MIOLO_Hands_On_Machine_Learning. indb 387 07/05/2019 17:09:53

Mãos à obra Aprendizado de máquina Aurelien Geron.pdf

388 | Capítulo 13: Redes Neurais Convolucionais (CNN) Analisaremos essa rede: As du as primeiras camadas dividem a altura e a largura da imagem por 4 (por-tanto sua área é dividida por 16) para reduzir a carga computacional; Em se guida, a camada de normalização de resposta local garante que as camadas anteriores aprendam uma ampla variedade de características (conforme discu-tido anteriormente); Seg uem-se duas camadas convolucionais onde a primeira atua como uma camada de gargalo. Você pode pensar neste par como uma única camada convolucional mais inteligente, como explicado anteriormente; Nov amente, uma camada de normalização de resposta local garante que as camadas anteriores capturem uma ampla variedade de padrões; Em se guida, novamente para acelerar os cálculos, uma camada max pooling reduz a altura e a largura da imagem em 2; Em se guida vem a pilha alta de nove módulos de criação, intercalados com um par de camadas max pooling para reduzir a dimensionalidade e acelerar a rede; Ent ão, a camada média de pooling utiliza um kernel do tamanho dos mapas com padding VALID produzindo mapas 1 × 1: essa estratégia surpreendente é chamada de global average pooling. Ela efetivamente força as camadas anterio-res a produzir mapas que são, na verdade, mapas de confiança para cada classe de destino (já que outros tipos de características seriam destruídos pela etapa média). Isso torna desnecessário ter várias camadas totalmente conectadas no topo da CNN (como na Alex Net), reduzindo consideravelmente o número de parâmetros na rede e limitando o risco de sobreajuste; As úl timas camadas são autoexplicativas: dropout para regularização, depois uma camada totalmente conectada com uma função de ativação softmax para gerar probabilidades estimadas de classe. Este diagrama é um pouco simplificado: a arquitetura Goog Le Net original também incluiu dois classificadores auxiliares conectados ao terceiro e ao sexto módulos inception. Ambos foram compostos por uma camada average pooling, uma camada convolucional, duas camadas totalmente conectadas e uma camada de ativação softmax. Sua perda (reduzida em 70%) foi adicionada à perda total durante o treinamento. O objetivo era combater o problema dos vanishing gradients e regularizar a rede. No entanto, foi demonstrado que o seu efeito foi relativamente pequeno. CG_MIOLO_Hands_On_Machine_Learning. indb 388 07/05/2019 17:09:53

Mãos à obra Aprendizado de máquina Aurelien Geron.pdf

Arquiteturas CNN | 389Res Net Por último, mas não menos importante, o vencedor do desafio ILSVRC 2015, foi a Residual Network (http://goo. gl/4pu HU5 ) (ou Res Net), desenvolvida por Kaiming He et al12, que apresentou uma surpreendente taxa de erro nos top-5 abaixo de 3,6%, usando uma CNN extremamente profunda composta por 152 camadas. A chave para poder treinar uma rede tão profunda é utilizar conexões skip (também chamadas de shortcuts connections ): o sinal fornecido a uma camada também é adicionado à saída de uma camada localizada um pouco acima da pilha. Veremos por que isso é útil. Ao treinar uma rede neural, o objetivo é fazer com que ela modele uma função alvo h(x). Se você adicionar a entrada x à saída da rede (isto é, adicionar uma conexão skip), então a rede será forçada a modelar f(x) = h(x)-x em vez de h(x), o que é chamado residual learning (veja a Figura 13-12). Entrada Entrada Camada 1 Camada 1Camada 2 Camada 2Conexãoo skip Figura 13-12. Residual Learning Quando você inicializa uma rede neural regular, os seus pesos estão próximos de zero, então a rede apenas produz valores próximos de zero. Se você adicionar uma conexão skip, a rede resultante exibirá apenas uma cópia de suas entradas; em outras palavras, ela inicialmente modela a função de identidade, acelerando consideravelmente o trei-namento se a função de destino estiver razoavelmente próxima da função identidade (o que geralmente é o caso). Além disso, se você adicionar muitas conexões skip, a rede pode começar a fazer pro-gresso mesmo se várias camadas ainda não começaram a aprender (veja a Figura 13-13). Graças às conexões skip, o sinal pode passar facilmente por toda a rede. A rede residual profunda pode ser vista como uma pilha de unidades residuais, sendo que cada uma delas é uma pequena rede neural com uma conexão skip. 12 “Deep Residual Learning for Image Recognition,” K. He (2015). CG_MIOLO_Hands_On_Machine_Learning. indb 389 07/05/2019 17:09:54

Mãos à obra Aprendizado de máquina Aurelien Geron.pdf

390 | Capítulo 13: Redes Neurais Convolucionais (CNN) Unidades Residuais Camada próxima ao seu estado inicial Camadas com saídas próximas de zero e que bloqueiam a retropropagação Figura 13-13. Rede neural profunda regular (esquerda) e rede residual profunda (direita) Agora veremos a arquitetura Res Net (veja a Figura 13-14). Na verdade, ela é surpreen-dentemente simples. Ela começa e termina exatamente como o Goog Le Net (mas sem uma camada de dropout) e entre elas há apenas uma pilha muito profunda de unidades residuais simples. Cada unidade residual é composta por duas camadas convolucionais com Normalização por Lote (BN), ativação Re LU com a utilização de kernels 3 × 3 e com a preservação de dimensões espaciais (stride de 1 e padding SAME ) Convolução Convolução Convolução Convolução Convolução Convolução Convolução Convolução Convolução Convolução Convolução Entrada Softmax Pular BN + Re LURe LU Unidade Residual Profundo!1000 unidades totalmente conec tadas Norma do Lote Figura 13-14. Arquitetura Res Net CG_MIOLO_Hands_On_Machine_Learning. indb 390 07/05/2019 17:09:54

Mãos à obra Aprendizado de máquina Aurelien Geron.pdf

Arquiteturas CNN | 391Note que o número de mapas é dobrado em poucas unidades residuais, ao mesmo tempo em que sua altura e largura são reduzidas pela metade (utilizando uma camada convolucional com stride de 2). As entradas não podem ser adicionadas diretamente às saídas da unidade residual quando isso acontece, pois elas não têm o mesmo formato (por exemplo, esse problema afeta a conexão skip representada pela seta tracejada na Figura 13-14). Para resolver este problema, as entradas são passadas através de uma ca-mada convolucional de 1 × 1 com stride de 2 e o número certo de mapas de saída (veja a Figura 13-15). Convolução Convolução Convolução Re LU BN BN + Re LUBN Figura 13-15. Conexão skip ao alterar o tamanho e a profundidade do mapa de características A Res Net-34 é a Res Net com 34 camadas (contando apenas as camadas convolucionais e uma camada totalmente conectada) contendo três unidades residuais que geram 64 mapas, 4 RUs com 128 mapas, 6 RUs com 256 mapas e 3 RUs com 512 mapas. Res Nets mais profundas do que isso, como a Res Net-152, utilizam unidades residuais ligeiramente diferentes. Em vez de duas camadas convolucionais 3 × 3 com (digamos) 256 mapas de características, elas utilizam três camadas convolucionais: primeiro uma camada convolucional 1 × 1 com apenas 64 mapas de características (4 vezes menos) que atua como uma camada de gargalo (como já discutido), em seguida uma camada 3 × 3 com 64 mapas e, finalmente, outra camada convolucional 1 × 1 com 256 mapas (4 vezes 64) que restaura a profundidade original. A Res Net-152 contém três dessas RUs que geram 256 mapas, em seguida 8 RUs com 512 mapas, uma impressionante 36 RUs com 1. 024 mapas e finalmente, 3 RUs com 2. 048 mapas. Como você pode ver, com vários tipos de arquiteturas surgindo a cada ano, a área está mudando rapidamente. Uma tendência clara é que as CNNs se aprofundem cada vez mais, além de também estarem ficando mais leves e exigindo menos parâmetros. No CG_MIOLO_Hands_On_Machine_Learning. indb 391 07/05/2019 17:09:55

Mãos à obra Aprendizado de máquina Aurelien Geron.pdf

392 | Capítulo 13: Redes Neurais Convolucionais (CNN) momento, a arquitetura Res Net é a mais poderosa, e, sem dúvida, a mais simples, então é realmente a que você deve utilizar por enquanto, mas continue checando o desafio da ILSVRC a cada ano. Com uma impressionante taxa de erro de 2,99% a vencedora de 2016 foi a equipe Trimps-Soushen da China. Para tanto, eles treinaram combinações dos modelos anteriores e os uniram em um ensemble. A taxa de erro reduzida pode, ou não, dependendo da tarefa, valer a complexidade extra. Verifique outras arquiteturas, em particular a VGGNet ( http://goo. gl/Qc Mj XQ )13 (vice--campeã do desafio ILSVRC 2014) e a Inception-v4 (http://goo. gl/Ak2v Bp )14 (que mescla as ideias da Goog Le Net e da Res Net e alcança uma taxa de erro de 3% no top-5 na classificação do Image Net). Não há realmente nada de especial na implementação das várias arquiteturas CNN que acabamos de discutir. Vimos anteriormente como construir todos os blocos de construção individuais, então você só precisa montá-los para criar a arquitetura desejada. Cons-truiremos uma CNN completa nos próximos exercícios e você en-contrará um código de trabalho completo nos notebooks da Jupyter Operações de Convolução do Tensor Flow O Tensor Flow também oferece alguns outros tipos de camadas convolucionais: tf. layers. conv1d() cria uma camada convolucional para entradas 1D, o que é útil, por exemplo, em uma sentença que pode ser representada como um array 1D de palavras e o campo receptivo abrange algumas palavras vizinhas no processamento de linguagem natural; tf. layers. conv3d() cria uma camada convolucional para entradas 3D, como o scan 3D PET; tf. nn. atrous_conv2d() cria a atrous convolutional layer (“à trous” significa “com buracos” em Francês). Inserir linhas e colunas de zeros (isto é, buracos) equivale a utilizar uma camada convolucional regular com um filtro dilatado. Por exemplo, o filtro 1 × 3 igual a [[1,2,3]] pode ser dilatado com uma taxa de dilatação de 4, resultando em um filtro dilatado [[1, 0, 0, 0, 2, 0, 0, 0, 3]], permitindo que a camada convolucional tenha um campo receptivo maior sem nenhum preço computacional e sem utilizar parâmetros extras; 13 “Very Deep Convolutional Networks for Large-Scale Image Recognition”, K. Simonyan and A. Zisserman (2015) 14 “Inception-v4, Inception-Res Net and the Impact of Residual Connections on Learning”, C. Szegedy et al. (2016) CG_MIOLO_Hands_On_Machine_Learning. indb 392 07/05/2019 17:09:55

Mãos à obra Aprendizado de máquina Aurelien Geron.pdf

Exercícios | 393 tf. layers. conv2d_transpose() cria uma camada convolucional de transposição, às vezes chamada de camada desconvolucional,15 que aumenta a amostragem ( upsample ) de uma imagem inserindo zeros entre as entradas, então você pode pensar nisso como uma camada convolucional comum usando um stride fracionário. A upsampling tem sua utilidade, por exemplo, na segmentação da imagem: em uma CNN típica, os mapas ficam cada vez menores à medida em que você avança na rede. Então, para produzir uma imagem do mesmo tamanho de sua entrada, você precisará de uma camada de upsampling; tf. nn. depthwise_conv2d() cria uma camada convolucional em profundidade que apli-ca cada filtro para cada canal de entrada individual de forma independente. Assim, se houver filtros f n e canais de entrada f n′ ela produzirá f n × fn′ mapas; tf. layers. separable_conv2d() cria uma camada convolucional separável que primeiro age como uma camada convolucional profunda, então aplica uma camada convolucional de 1 × 1 aos mapas resultantes, possibilitando a aplicação de filtros a conjuntos arbitrários de canais de entrada. Exercícios 1. Quais são as vantagens de uma CNN sobre uma DNN totalmente conectada para a cl assificação de imagens? 2. Con sidere uma CNN composta por três camadas convolucionais, cada uma com kernels 3 × 3, um stride de 2 e padding SAME. A camada inferior gera 100 mapas, a do meio gera 200 e a de cima 400. As imagens de entrada são RGB de 200 × 300 pixels. Qual é o número total de parâmetros na CNN? Se estivermos utilizando floats de 32 bits, quanto de RAM essa rede exigirá ao fazer uma previsão para uma única instância? E quando treinamos em um minilote de 50 imagens? 3. Se su a GPU ficar sem memória durante o treinamento de uma CNN, quais são cinco coisas que você poderia tentar para resolver o problema? 4. Por q ue você adicionaria uma camada max pooling em vez de uma camada convolucional com o mesmo stride? 5. Qua ndo você adicionaria uma camada de normalização de resposta local ? 6. Voc ê pode citar as principais inovações na Alex Net em comparação com a Le Net-5? E as principais inovações da Goog Le Net e da Res Net? 7. Con strua sua própria CNN e tente atingir a maior precisão possível no MNIST. 15 Este nome é bastante enganador, já que esta camada não re aliza uma desconvolução, que é uma operação matemática bem definida (o inverso de uma convolução). CG_MIOLO_Hands_On_Machine_Learning. indb 393 07/05/2019 17:09:55

Mãos à obra Aprendizado de máquina Aurelien Geron.pdf

394 | Capítulo 13: Redes Neurais Convolucionais (CNN) 8. Classificando imagens grandes utilizando o Inception v3. a. Bai xe algumas imagens de vários animais. Carregue-as no Python, por exem-plo, utilizando a função matplotlib. image. mpimg. imread() ou a função scipy. misc. imread(). Redimensione e/ou corte-as em 299 × 299 pixels e garanta que elas tenham apenas três canais (RGB), sem o de transparência. As imagens que foram treinadas no modelo Inception foram pré-processadas para que seus va-lores variem de-1,0 a 1,0, então você deve garantir isso também para as suas. b. Faç a o download do modelo mais recente do Inception v3: o ponto de veri-ficação está disponível em https://goo. gl/25u DF7. A lista dos nomes das clas-ses está disponível em https://goo. gl/br XRt Z, mas você deve inserir uma classe “background” no início. c. Cri e o modelo Inception v3 chamando a função inception_v3(), como mos-trado abaixo. Isto deve ser feito dentro de um escopo do argumento criado pela função inception_v3_arg_scope(). Você também deve configurar is_training=False e num_classes=1001 da seguinte forma: from tensorflow. contrib. slim. nets import inception import tensorflow. contrib. slim as slim X = tf. placeholder(tf. float32, shape=[None, 299, 299, 3], name="X") with slim. arg_scope(inception. inception_v3_arg_scope()) : logits, end_points = inception. inception_v3( X, num_classes=1001, is_training=False ) predictions = end_points["Predictions"] saver = tf. train. Saver() d. Abra uma sessão e utilize o Saver para restaurar o ponto de verificação do modelo pré-treinado que você baixou anteriormente. e. Exe cute o modelo para classificar as imagens que você preparou. Exiba as cin-co principais previsões para cada imagem junto com a probabilidade estima-da. Qual é a acurácia do modelo? 9. Tra nsferência de aprendizado para classificação de imagens grandes. a. Cri e um conjunto de treinamento contendo pelo menos 100 imagens por clas-se. Por exemplo, você pode classificar suas próprias imagens com base no local (praia, montanha, cidade etc. ) ou, como alternativa, utilizar apenas um con-junto de dados existente como o conjunto de dados das flores ( https://goo. gl/ Eg JVXZ ) ou o dos locais do MIT ( http://places. csail. mit. edu/ ) (requer registro e é enorme). b. Esc reva uma etapa de pré-processamento que redimensionará e recortará a imagem em 299 × 299 com alguma aleatoriedade para o aumento de dados. CG_MIOLO_Hands_On_Machine_Learning. indb 394 07/05/2019 17:09:55

Mãos à obra Aprendizado de máquina Aurelien Geron.pdf

Exercícios | 395c. Utilizando o modelo Inception v3 pré-treinado do exercício anterior, congele to das as camadas até a camada de gargalo (ou seja, a última camada antes da camada de saída) e substitua a camada de saída pelo número apropriado de saídas para sua nova tarefa de classificação (por exemplo, o conjunto de dados das flores tem cinco classes mutuamente exclusivas, então a camada de saída deve ter cinco neurônios e utilizar a função de ativação softmax). d. Divi da seu conjunto de dados em um conjunto de treinamento e um conjunto de testes. Treine o modelo no conjunto de treinamento e o avalie no conjunto de testes. 10. Ace sse o tutorial Deep Dream do Tensor Flow (https://goo. gl/4b2s6g). É uma forma divertida de se familiarizar com várias formas de visualizar os padrões aprendi-dos por uma CNN e de gerar arte com a utilização do Aprendizado Profundo. Soluções para estes exercícios estão disponíveis no Apêndice A. CG_MIOLO_Hands_On_Machine_Learning. indb 395 07/05/2019 17:09:55

Mãos à obra Aprendizado de máquina Aurelien Geron.pdf

CG_MIOLO_Hands_On_Machine_Learning. indb 396 07/05/2019 17:09:55

Mãos à obra Aprendizado de máquina Aurelien Geron.pdf

397Capítulo 14 Redes Neurais Recorrentes (RNN) O taco rebate a bola. Imediatamente, você começa a correr antecipando sua trajetória e, ao segui-la, adapta seus movimentos para, finalmente, capturar a bola (sob uma chuva de aplausos). Prever o futuro é o que você faz o tempo todo, seja terminando a frase de um amigo ou antecipando o cheiro do café da manhã. Neste capítulo, discutiremos redes neurais recorrentes (RNN, do inglês), uma classe de redes que pode prever o futuro (bem, até certo ponto, é claro). Elas podem analisar dados de séries temporais, como preços de ações, e informar quando comprar ou vender, podem também antecipar trajetórias de carros e ajudar na prevenção de acidentes em sistemas autônomos de direção. Mais geralmente, em vez de em entradas de tamanho fixo, elas podem trabalhar em sequências de comprimentos arbitrários, como todas as redes que discutimos até agora. Por exemplo, podem utilizar frases, documentos ou amostras de áudio como entrada, tornando-as extremamente úteis para sistemas de processamento de linguagem natural (PNL) como a tradução automática, voz para texto ou análise comportamental (por exemplo, lendo resenhas de filmes e extraindo a impressão do avaliador quanto ao filme). Além disso, a capacidade de antecipação das RNNs também as torna capazes de uma cria-tividade surpreendente. Você pode pedir para prever quais serão as próximas notas mais prováveis de uma melodia, escolher depois aleatoriamente uma dessas notas e tocá-la. Em seguida, peça à rede para reproduzir as próximas notas mais prováveis e repita várias vezes o processo. Antes que você perceba, sua rede comporá uma melodia, como a que foi produzida pelo projeto Magenta do Google ( http://goo. gl/Ix IL1V ) (https://magenta. tensorflow. org/ ). Da mesma forma, as RNNs podem gerar sentenças ( http://goo. gl/onk PNd ), legendas de imagens (http://goo. gl/Nwx7Kh ) e muito mais. O resultado não é ainda exatamente um Shakespeare ou Mozart, mas quem sabe o que produzirão daqui a alguns anos?Neste capítulo, examinaremos os conceitos fundamentais subjacentes às RNNs, o prin-cipal problema que elas enfrentam (a saber, gradientes vanishing/exploding discutidos no Capítulo 11) e as soluções amplamente utilizadas para combatê-lo: células LSTM e CG_MIOLO_Hands_On_Machine_Learning. indb 397 07/05/2019 17:09:55

Mãos à obra Aprendizado de máquina Aurelien Geron.pdf

398 | Capítulo 14: Redes Neurais Recorrentes (RNN)GRU. Ao longo do caminho, como sempre utilizando o Tensor Flow, mostraremos como implementar RNNs. Finalmente, daremos uma olhada na arquitetura de um sistema de tradução automática. Neurônios Recorrentes Até agora, vimos principalmente redes neurais feedforward nas quais as ativações fluem apenas em uma direção, da camada de entrada à camada de saída (exceto algumas redes no Apêndice E). Uma rede neural recorrente é muito parecida com uma rede neural feed-forward, exceto por também conter conexões apontando para trás. Vejamos a RNN mais simples possível, composta de apenas um neurônio recebendo entradas, produzindo uma saída e enviando essa saída de volta para si mesmo, conforme mostrado na Figura 14-1 (esquerda). A cada intervalo de tempo t (também chamado de frame ) este neurônio recor-rente recebe as entradas x(t), bem como sua própria saída do intervalo de tempo anterior, y(t-1). Podemos representar essa minúscula rede em relação ao eixo do tempo, conforme mostrado na Figura 14-1 (direita). Isto é chamado desenrolando a rede ao longo do tempo. Tempo Figura 14-1. Um neurônio recorrente (esquerda), desenrolado através do tempo (direita) Você pode criar facilmente uma camada de neurônios recorrentes. A cada etapa de tempo t, cada neurônio recebe tanto o vetor de entrada x(t) quanto o vetor de saída da etapa de tempo anterior y(t-1), como mostrado na Figura 14-2. Note que, agora, tanto as entradas quanto as saídas são vetores (quando havia apenas um único neurônio a saída era um escalar). CG_MIOLO_Hands_On_Machine_Learning. indb 398 07/05/2019 17:09:56

Mãos à obra Aprendizado de máquina Aurelien Geron.pdf

Neurônios Recorrentes | 399 Tempo Figura 14-2. Uma camada de neurônios recorrentes (esquerda) desenrolados através do tempo (direita) Cada neurônio recorrente tem dois conjuntos de pesos: um para as entradas x(t) e outro para as saídas do intervalo de tempo anterior, y(t-1), chamaremos estes vetores de peso de wx e wy. Se considerarmos toda a camada recorrente em vez de apenas um neurônio recorrente, podemos colocar todos os vetores de peso em duas matrizes de peso, Wx e Wy. Como você poderia esperar, o vetor de saída de toda a camada recorrente pode, então, ser calculado ( b é o vetor de polarização e ϕ(·) é a função de ativação, por exemplo, Re LU1) como mostrado na Equação 14-1. Equação 14-1. Saída de uma camada recorrente para uma única instância yt=/uni03D5Wx T·xt+Wy T·yt-1+b Assim como para redes neurais feedforward, podemos calcular a saída de uma camada recorrente em uma só tomada para um minilote inteiro colocando todas as entradas no intervalo de tempo em uma matriz de entrada X(t) (veja a Equação 14-2). Equação 14-2. Saídas de uma camada de neurônios recorrentes para todas as instâncias em um minilote com 1 Observe que muitos pesquisadores preferem a utilização da função de ativação tangente hiperbólica (tanh) em RNNs em vez da função de ativação Re LU. Por exemplo, dê uma olhada no artigo de Vu Pham et al. “Dropout Improves Recurrent Neural Networks for Handwriting Recognition” ( https://goo. gl/2WSnaj ). No entanto, RNNs baseados em Re LU também conseguem, conforme mostrado no artigo de Quoc V. Le et al “A Simple Way to Initialize Recurrent Networks of Rectified Linear Units” ( https://goo. gl/Nr KAP0 ). CG_MIOLO_Hands_On_Machine_Learning. indb 399 07/05/2019 17:09:56

Mãos à obra Aprendizado de máquina Aurelien Geron.pdf

400 | Capítulo 14: Redes Neurais Recorrentes (RNN) Y(t) é uma matriz m × nneurônios que contém as saídas das camadas em um intervalo de tempo t para cada instância no minilote ( m é o número de instâncias no mini-lote e n neurônios é o número de neurônios); X(t) é uma matriz m × nentradas que contém as entradas para todas as instâncias (nentradas é o número de características de entrada); Wx é uma matriz n entradas × nneurônios que contém os pesos de conexão para as entradas do intervalo de tempo atual; Wy é uma matriz n neurônios × nneurônios que contém os pesos de conexão para as saídas do intervalo de tempo anterior; b é um ve tor de tamanho n neurônios que contém cada termo de polarização do neurônio; As ma trizes de peso W x e Wy são frequentemente concatenadas verticalmente em uma única matriz de peso W no formato ( nentradas + nneurônios ) × n neurônios (veja a segun-da linha da Equação 14-2); A nota ção [ X(t) Y(t-1)] representa a concatenação horizontal das matrizes X(t) e Y(t-1). Observe que Y (t) é uma função de X (t) e Y(t-1), que é uma função de X (t-1) e Y(t-2), que é uma função de X (t-2) e Y(t-3), e assim por diante, tornando Y(t) uma função de todas as entradas, pois o intervalo é t = 0 (ou seja, X (0), X(1),..., X (t)). No primeiro intervalo de tempo, t = 0, não existem saídas anteriores, então elas tipicamente assumem como sendo zeros. Células de Memória Como a saída de um neurônio recorrente no intervalo t é uma função de todas as entradas dos intervalos de tempos anteriores, você poderia dizer que ele tem uma aparência de memória. Uma parte de uma rede neural que preserva algum estado nos intervalos de tempo é chamada de célula de memória (ou simplesmente célula ). Um único neurônio recorrente, ou uma camada de neurônios recorrentes, é uma célula muito básica, porém mais adiante neste capítulo veremos alguns tipos de células mais complexas e poderosas. No geral, o estado de uma célula em um intervalo de tempo t, denominado h (t) (o “h” é de “hidden” [escondido]), é uma função de algumas entradas naquele intervalo de tempo e seu estado no intervalo de tempo anterior: h (t) = f(h(t-1), x(t)). Sua saída no intervalo de tempo t, denominada y (t), também é uma função do estado anterior e das entradas atuais. No caso das células básicas, que discutimos até agora, a saída é igual ao estado, mas em células mais complexas este nem sempre é o caso, como mostrado na Figura 14-3. CG_MIOLO_Hands_On_Machine_Learning. indb 400 07/05/2019 17:09:57

Mãos à obra Aprendizado de máquina Aurelien Geron.pdf

Neurônios Recorrentes | 401 Tempo Figura 14-3. O estado oculto de uma célula e sua saída podem ser diferentes Sequências de Entrada e Saída Uma RNN pode simultaneamente pegar uma sequência de entradas e produzir uma sequência de saídas (veja a Figura 14-4, rede acima à esquerda). Por exemplo, esse tipo de rede é útil para prever séries temporais como cotações de ações: você fornece os preços dos últimos N dias e ela exibe os preços deslocados em um dia no futuro (ou seja, de N-1 dias antes para amanhã). Como alternativa, você poderia alimentar a rede com uma sequência de entradas e ig-norar todas as saídas, exceto a última (veja a rede superior direita). Em outras palavras, esta é uma rede sequência-para-vetor. Por exemplo, você poderia alimentá-la com uma sequência de palavras correspondente a uma resenha de filme e a rede produziria uma pontuação de sentimento (por exemplo,-1 [ódio] e +1 [amor]) Por outro lado, você poderia alimentar a rede com uma única entrada na primeira vez (e zeros para todos os outros intervalos de tempo) e deixar que ela produza uma saída (veja a rede inferior esquerda). Esta é uma rede vetor-para-sequência. Por exemplo, a entrada poderia ser uma imagem e a saída poderia ser uma legenda para essa imagem. Por fim, você poderia ter uma rede sequência-a-vetor chamada codificador, seguida de uma rede vetor-a-sequência, chamada decodificador (veja a rede inferior direita). Por exemplo, isso pode ser utilizado para traduzir uma frase de um idioma para outro. Você alimentaria a rede com uma frase em um idioma, o codificador converteria essa frase em uma única representação vetorial e, em seguida, o decodificador decodificaria esse vetor em uma sentença em outro idioma. Este modelo de duas etapas, chamado de Codificador-Decodificador, funciona muito melhor do que tentar traduzir rapidamente com uma única RNN sequência-a-sequência (como o representado no canto superior esquerdo), pois as últimas palavras de uma frase podem afetar as primeiras palavras da tradução e você precisa esperar até ter ouvido toda a frase antes de traduzi-la. CG_MIOLO_Hands_On_Machine_Learning. indb 401 07/05/2019 17:09:57

Mãos à obra Aprendizado de máquina Aurelien Geron.pdf

402 | Capítulo 14: Redes Neurais Recorrentes (RNN) Codi/f_icador Decodi/f_icador Saídas ignoradas Figura 14-4. Seq para seq (canto superior esquerdo), seq para vetor (canto superior direi-to), vetor para seq (canto inferior esquerdo), delayed seq para seq (canto inferior direito) Parece promissor, então começaremos a programar! RNNs Básicas no Tensor Flow Primeiro, sem utilizar nenhuma das operações RNN do Tensor Flow, implementaremos um modelo RNN muito simples para entender melhor o que acontece nos bastidores. Criaremos uma RNN composta por uma camada com cinco neurônios recorrentes (como a RNN representada na Figura 14-2) usando a função de ativação tanh. Assumiremos que a RNN roda somente em dois intervalos de tempo, tomando vetores de entrada de tamanho 3 em cada intervalo. O código a seguir cria esta RNN desenrolada por meio de dois intervalos de tempo: n_inputs = 3 n_neurons = 5 X0 = tf. placeholder(tf. float32, [None, n_inputs]) X1 = tf. placeholder(tf. float32, [None, n_inputs]) Wx = tf. Variable(tf. random_normal(shape=[n_inputs, n_neurons],dtype=tf. float32)) Wy = tf. Variable(tf. random_normal(shape=[n_neurons,n_neurons],dtype=tf. float32)) b = tf. Variable(tf. zeros([1, n_neurons], dtype=tf. float32)) Y0 = tf. tanh(tf. matmul(X0, Wx) + b) Y1 = tf. tanh(tf. matmul(Y0, Wy) + tf. matmul(X1, Wx) + b) CG_MIOLO_Hands_On_Machine_Learning. indb 402 07/05/2019 17:09:57

Mãos à obra Aprendizado de máquina Aurelien Geron.pdf

RNNs Básicas no Tensor Flow | 403init = tf. global_variables_initializer() Essa rede se parece muito com uma rede neural feedforward de duas camadas com algumas modificações: primeiro, os mesmos pesos e termos de polarização são com-partilhados por ambas as camadas e, segundo, alimentamos entradas em cada camada e obtemos saídas de cada camada. Para executar o modelo, precisamos alimentá-lo nas entradas em ambos os intervalos de tempo, assim: import numpy as np # Minilote: instância 0,instância 1,instância 2,instância 3 X0_batch = np. array([[0, 1, 2], [3, 4, 5], [6, 7, 8], [9, 0, 1]]) # t = 0 X1_batch = np. array([[9, 8, 7], [0, 0, 0], [6, 5, 4], [3, 2, 1]]) # t = 1 with tf. Session() as sess: init. run() Y0_val, Y1_val = sess. run([Y0, Y1], feed_dict={X0: X0_batch, X1: X1_batch}) Este minilote contém quatro instâncias, cada uma com uma sequência de entrada composta de exatamente duas entradas. Ao final, Y0_val e Y1_val conterá as saídas da rede em ambos os intervalos para todos os neurônios e todas as instâncias no minilote: >>> print(Y0_val) # saída em t = 0 [[-0. 0664006 0. 96257669 0. 68105787 0. 70918542-0. 89821595] # instância 0 [ 0. 9977755 -0. 71978885-0. 99657625 0. 9673925 -0. 99989718] # instância 1 [ 0. 99999774-0. 99898815-0. 99999893 0. 99677622-0. 99999988] # instância 2 [ 1. -1. -1. -0. 99818915 0. 99950868]] # instância 3 >>> print(Y1_val) # saída em t = 1 [[ 1. -1. -1. 0. 40200216-1. ] # instância 0 [-0. 12210433 0. 62805319 0. 96718419-0. 99371207-0. 25839335] # instância 1 [ 0. 99999827-0. 9999994 -0. 9999975 -0. 85943311-0. 9999879 ] # instância 2 [ 0. 99928284-0. 99999815-0. 99990582 0. 98579615-0. 92205751]] # instância 3 Não foi muito difícil, mas é claro que o grafo ficará muito grande se executarmos uma RNN com mais de 100 intervalos de tempo. Agora, utilizando as operações RNN do Tensor Flow, veremos como criar o mesmo modelo. Desenrolamento Estático Através do Tempo A função static_rnn() cria uma rede RNN desenrolada encadeando células. O código a seguir cria exatamente o mesmo modelo que o anterior: X0 = tf. placeholder(tf. float32, [None, n_inputs]) X1 = tf. placeholder(tf. float32, [None, n_inputs]) basic_cell = tf. contrib. rnn. Basic RNNCell(num_units=n_neurons) output_seqs, states = tf. contrib. rnn. static_rnn(basic_cell, [X0, X1], dtype=tf. float32) Y0, Y1 = output_seqs CG_MIOLO_Hands_On_Machine_Learning. indb 403 07/05/2019 17:09:58

Mãos à obra Aprendizado de máquina Aurelien Geron.pdf

404 | Capítulo 14: Redes Neurais Recorrentes (RNN)Como antes, primeiro criamos os placeholders de entrada. Em seguida, criamos uma Basic RNNCell, que você pode imaginar como sendo uma fábrica que cria cópias da célula para construir a RNN desenrolada (uma para cada intervalo de tempo). Em seguida, chamamos a static_rnn(), dando-lhe a fábrica de células e os tensores de entrada e informando o tipo de dados das entradas (isso é usado para criar a matriz de estado inicial, que por padrão é cheia de zeros). A função static_rnn() chama a função call() da fábrica de células uma vez por entrada e as encadeia como fizemos anteriormente, criando duas cópias da célula (cada uma contendo uma camada de cinco neurônios re-correntes) com pesos e termos de polarização compartilhados. A função static_rnn() retorna dois objetos. O primeiro é uma lista do Python que contém os tensores de saída para cada intervalo de tempo e o segundo é um tensor que contém os estados finais da rede. Quando você utiliza células básicas, o estado final é simplesmente igual ao último resultado. Se houvesse 50 intervalos de tempo, não seria muito conveniente definir 50 placeholders e 50 tensores de saída. Além disso, você teria que alimentar cada um dos 50 placeholders e manipular as 50 saídas em tempo de execução. Vamos simplificar isso. O código a se-guir cria a mesma RNN novamente, mas, dessa vez, é necessário um único placeholder para entrada no formato [None, n_steps, n_inputs] sendo que a primeira dimensão é o tamanho do minilote. Em seguida, extrai a lista de sequências de entrada para cada intervalo de tempo. X_seqs é uma lista Python de tensores n_steps no formato [None, n_inputs] e, mais uma vez, a primeira dimensão é do tamanho do minilote. Para fazer isto, primeiro trocamos as duas primeiras dimensões usando a função transpose() para que os intervalos de tempo sejam agora a primeira dimensão. Em seguida, extraímos uma lista de tensores Python na primeira dimensão (ou seja, um tensor por intervalo de tempo) usando a função unstack(). As próximas duas linhas são as mesmas de antes. Finalmente, mesclamos todos os tensores de saída usando a função stack() e trocamos as primeiras duas dimensões para obter um tensor outputs final no formato [None, n_steps, n_neurons] (de novo, a primeira dimensão é do tamanho de um minilote). X = tf. placeholder(tf. float32, [None, n_steps, n_inputs]) X_seqs = tf. unstack(tf. transpose(X, perm=[1, 0, 2]))basic_cell = tf. contrib. rnn. Basic RNNCell(num_units=n_neurons) output_seqs, states = tf. contrib. rnn. static_rnn(basic_cell, X_seqs, dtype=tf. float32)outputs = tf. transpose(tf. stack(output_seqs), perm=[1, 0, 2]) Agora podemos rodar a rede alimentando-a com um único tensor que contém todas as sequências do minilote: CG_MIOLO_Hands_On_Machine_Learning. indb 404 07/05/2019 17:09:58

Mãos à obra Aprendizado de máquina Aurelien Geron.pdf

RNNs Básicas no Tensor Flow | 405X_batch = np. array([ # t = 0 t = 1 [[0, 1, 2], [9, 8, 7]], # instância 0 [[3, 4, 5], [0, 0, 0]], # instância 1 [[6, 7, 8], [6, 5, 4]], # instância 2 [[9, 0, 1], [3, 2, 1]], # instância 3 ]) with tf. Session() as sess: init. run() outputs_val = outputs. eval(feed_dict={X: X_batch}) E obtemos um único tensor outputs_val para todas as instâncias, todos os intervalos de tempo e todos os neurônios: >>> print(outputs_val) [[[-0. 91279727 0. 83698678-0. 89277941 0. 80308062-0. 5283336 ] [-1. 1. -0. 99794829 0. 99985468-0. 99273592]] [[-0. 99994391 0. 99951613-0. 9946925 0. 99030769-0. 94413054] [ 0. 48733309 0. 93389565-0. 31362072 0. 88573611 0. 2424476 ]] [[-1. 0. 99999875-0. 99975014 0. 99956584-0. 99466234] [-0. 99994856 0. 99999434-0. 96058172 0. 99784708-0. 9099462 ]] [[-0. 95972425 0. 99951482 0. 96938795-0. 969908 -0. 67668229] [-0. 84596014 0. 96288228 0. 96856463-0. 14777924-0. 9119423 ]]] No entanto, essa abordagem ainda cria um grafo que contém uma célula por intervalo de tempo. O grafo ficaria muito feio se houvesse 50 intervalos de tempo, seria como escre-ver um programa sem nunca utilizar loops (por exemplo, Y0=f(0, X0); Y1=f(Y0, X1); Y2=f(Y1, X2);... ; Y50=f(Y49, X50) ). Com um grafo tão grande, durante a retropropa-gação você poderia obter erros de falta de memória (OOM, do inglês) (especialmente com a memória limitada das placas GPU), pois ela deve armazenar todos os valores do tensor durante o forward pass e utilizá-los para calcular os gradientes durante o reverse pass. Felizmente, existe uma solução melhor: a função dynamic_rnn(). Desenrolamento Dinâmico Através do Tempo A função dynamic_rnn() utiliza uma operação while_loop() para executar o número apropriado de vezes na célula, e você pode definir a swap_memory=True se quiser que ela troque a memória GPU para a memória CPU durante a retropropagação a fim de evitar erros do tipo OOM. Convenientemente, em cada intervalo de tempo ela também aceita um único tensor para todas as entradas (formato [None, n_steps, n_inputs] ) e exibe um CG_MIOLO_Hands_On_Machine_Learning. indb 405 07/05/2019 17:09:59

Mãos à obra Aprendizado de máquina Aurelien Geron.pdf

406 | Capítulo 14: Redes Neurais Recorrentes (RNN)único tensor para todas as saídas a cada intervalo de tempo (formato [None, n_steps, n_neurons] ); não há necessidade de empilhar, desempilhar ou transpor. Ao utilizar a função dynamic_rnn(), o código a seguir cria a mesma RNN de antes. É muito melhor! X = tf. placeholder(tf. float32, [None, n_steps, n_inputs]) basic_cell = tf. contrib. rnn. Basic RNNCell(num_units=n_neurons) outputs, states = tf. nn. dynamic_rnn(basic_cell, X, dtype=tf. float32) Durante a retropropagação, a operação while_loop() faz a mágica certa: armazena os valores do tensor para cada iteração durante o forward pass para que possa utilizá-los para calcular gradientes du-rante o reverse pass. Manipulando Sequências de Entrada de Comprimento Variável Até agora, utilizamos apenas sequências de entrada de tamanho fixo (todas com exata-mente dois passos). E se as sequências de entrada tiverem comprimentos variáveis (por exemplo, sentenças)? Nesse caso, você deve definir o argumento sequence_length quando chamar a função dynamic_rnn() (ou static_rnn() ); deve ser um tensor 1D indicando o comprimento da sequência de entrada para cada instância. Por exemplo: seq_length = tf. placeholder(tf. int32, [None]) [... ] outputs, states = tf. nn. dynamic_rnn(basic_cell, X, dtype=tf. float32, sequence_length=seq_length) Por exemplo, suponha que a segunda sequência de entrada contenha apenas uma entrada em vez de duas. Ela deve ser preenchida com um vetor zero para encaixar no tensor de entrada X (porque a segunda dimensão do tensor de entrada é do tamanho da sequência mais longa — ou seja, 2). X_batch = np. array([ # passo 0 passo 1 [[0, 1, 2], [9, 8, 7]], # instância0 [[3, 4, 5], [0, 0, 0]], # instância 1 (com um vetor zero) [[6, 7, 8], [6, 5, 4]], # instância2 [[9, 0, 1], [3, 2, 1]], # instância3 ]) seq_length_batch = np. array([2, 1, 2, 2]) Claro, agora você precisa alimentar valores para ambos placeholders X e seq_length : with tf. Session() as sess: init. run() outputs_val, states_val = sess. run( [outputs, states], feed_dict={X: X_batch, seq_length: seq_length_batch}) CG_MIOLO_Hands_On_Machine_Learning. indb 406 07/05/2019 17:09:59

Mãos à obra Aprendizado de máquina Aurelien Geron.pdf

Treinando RNNs | 407Agora, a RNN produz vetores zero para cada vez que ultrapassa o comprimento da sequência (observe a saída da segunda instância para o segundo intervalo de tempo): >>> print(outputs_val) [[[-0. 68579948-0. 25901747-0. 80249101-0. 18141513-0. 37491536] [-0. 99996698-0. 94501185 0. 98072106-0. 9689762 0. 99966913]] # estado final [[-0. 99099374-0. 64768541-0. 67801034-0. 7415446 0. 7719509 ] # estado final [ 0. 0. 0. 0. 0. ]] # vetor zero [[-0. 99978048-0. 85583007-0. 49696958-0. 93838578 0. 98505187] [-0. 99951065-0. 89148796 0. 94170523-0. 38407657 0. 97499216]] # estado final [[-0. 02052618-0. 94588047 0. 99935204 0. 37283331 0. 9998163 ] [-0. 91052347 0. 05769409 0. 47446665-0. 44611037 0. 89394671]]] # estado final Além disso, o tensor states contém o estado final de cada célula (excluindo os vetores zero): >>> print(states_val) [[-0. 99996698-0. 94501185 0. 98072106-0. 9689762 0. 99966913] # t = 1 [-0. 99099374-0. 64768541-0. 67801034-0. 7415446 0. 7719509 ] # t = 0 !!! [-0. 99951065-0. 89148796 0. 94170523-0. 38407657 0. 97499216] # t = 1 [-0. 91052347 0. 05769409 0. 47446665-0. 44611037 0. 89394671]] # t = 1 Manipulando Sequências de Saída de Comprimento Variável E se as sequências de saída também tiverem comprimentos variáveis? Se você sou-ber antecipadamente o comprimento de cada sequência (por exemplo, se souber que será o mesmo comprimento que a sequência de entrada), poderá definir o parâmetro sequence_length conforme descrito acima. Infelizmente, isso não será possível: por exemplo, o comprimento de uma sentença traduzida é diferente do tamanho da sentença de entrada. Neste caso, a solução mais comum seria definir uma saída especial chamada end-of-sequence token (EOS token). Qualquer saída após a EOS deve ser ignorada (dis-cutiremos isso mais adiante neste capítulo). Ok, agora você sabe como construir uma rede RNN (ou, mais precisamente, uma rede RNN desenrolada através do tempo). Mas como você a treina? Treinando RNNs Para treinar uma RNN, o truque é desenrolá-la através do tempo (como acabamos de fazer) e, então, utilizar a retropropagação comum (veja a Figura 14-5), estratégia chamada de retropropagação através do tempo (BPTT, do inglês). CG_MIOLO_Hands_On_Machine_Learning. indb 407 07/05/2019 17:10:00

Mãos à obra Aprendizado de máquina Aurelien Geron.pdf

408 | Capítulo 14: Redes Neurais Recorrentes (RNN) Figura 14-5. Retropropagação ao longo do tempo Assim como na retropropagação normal há um primeiro forward pass pela rede desen-rolada (representado pelas setas tracejadas); então a sequência de saída é avaliada com a utilização de uma função de custo (na qual tmin e tmax são os primeiros e últimos intervalos de tempo de saída, sem contar as saídas ignoradas) e os gradientes dessa função de custo são propagados para trás através da rede desenrolada (representada pelas setas sólidas); e, finalmente, os parâmetros do modelo são atualizados com a utilização dos gradientes calculados durante a BPTT. Note que os gradientes fluem para trás através de todas as saídas utilizadas pela função de custo, não apenas através da saída final (por exemplo, na Figura 14-5 a função de custo é calculada utilizando as últimas três saídas da rede, Y(2), Y(3) e Y(4), desta forma gradientes fluem através das três saídas, mas não através de Y(0) e Y(1)). Além disso, como os mesmos parâmetros W e b são utilizados em cada etapa de tempo, a retropropagação fará a coisa certa e somará todas as etapas do tempo. Treinando um Classificador de Sequência Treinaremos uma RNN para classificar imagens MNIST. Uma rede neural convolucional seria mais adequada para a classificação de imagens (consulte o Capítulo 13), mas este é um exemplo simples com o qual você já está familiarizado. Trataremos cada imagem como uma sequência de 28 linhas de 28 pixels cada (já que cada imagem MNIST contém 28 × 28 pixels). Utilizaremos células de 150 neurônios recorrentes, além de uma camada totalmente conectada contendo 10 neurônios (um por classe) conectados à saída do último intervalo de tempo, seguidos por uma camada softmax (veja a Figura 14-6). CG_MIOLO_Hands_On_Machine_Learning. indb 408 07/05/2019 17:10:00

Mãos à obra Aprendizado de máquina Aurelien Geron.pdf

Treinando RNNs | 409 Softmax 10 unidades totalmente conec tadas Figura 14-6. Classificador de Sequência A fase de construção é bastante simples; é praticamente a mesma do classificador MNIST que criamos no Capítulo 10, exceto que uma RNN desenrolada substitui as camadas ocultas. Observe que a camada totalmente conectada está conectada ao tensor de estados que contém apenas o estado final da RNN (ou seja, a saída 28). Observe também que y é um placeholder para as classes-alvo. n_steps = 28 n_inputs = 28 n_neurons = 150 n_outputs = 10 learning_rate = 0. 001X = tf. placeholder(tf. float32, [None, n_steps, n_inputs]) y = tf. placeholder(tf. int32, [None]) basic_cell = tf. contrib. rnn. Basic RNNCell(num_units=n_neurons) outputs, states = tf. nn. dynamic_rnn(basic_cell, X, dtype=tf. float32) logits = tf. layers. dense(states, n_outputs) xentropy = tf. nn. sparse_softmax_cross_entropy_with_logits(labels=y, logits=logits) loss = tf. reduce_mean(xentropy) optimizer = tf. train. Adam Optimizer(learning_rate=learning_rate)training_op = optimizer. minimize(loss)correct = tf. nn. in_top_k(logits, y, 1)accuracy = tf. reduce_mean(tf. cast(correct, tf. float32)) init = tf. global_variables_initializer()n_steps = 28 n_inputs = 28 n_neurons = 150 n_outputs = 10 learning_rate = 0. 001X = tf. placeholder(tf. float32, [None, n_steps, n_inputs]) y = tf. placeholder(tf. int32, [None]) basic_cell = tf. contrib. rnn. Basic RNNCell(num_units=n_neurons) outputs, states = tf. nn. dynamic_rnn(basic_cell, X, dtype=tf. float32) logits = tf. layers. dense(states, n_outputs) xentropy = tf. nn. sparse_softmax_cross_entropy_with_logits(labels=y, logits=logits) loss = tf. reduce_mean(xentropy) optimizer = tf. train. Adam Optimizer(learning_rate=learning_rate)training_op = optimizer. minimize(loss)correct = tf. nn. in_top_k(logits, y, 1)accuracy = tf. reduce_mean(tf. cast(correct, tf. float32)) init = tf. global_variables_initializer() Agora, como é esperado pela rede, carregaremos os dados do MNIST e remodelare-mos os dados de teste para [batch_size, n_steps, n_inputs]. Reformularemos os dados de treinamento em breve. CG_MIOLO_Hands_On_Machine_Learning. indb 409 07/05/2019 17:10:01

Mãos à obra Aprendizado de máquina Aurelien Geron.pdf

410 | Capítulo 14: Redes Neurais Recorrentes (RNN)from tensorflow. examples. tutorials. mnist import input_data mnist = input_data. read_data_sets("/tmp/data/") X_test = mnist. test. images. reshape((-1, n_steps, n_inputs)) y_test = mnist. test. labels Agora estamos prontos para treinar a RNN. A fase de execução é igual à do classificador MNIST no Capítulo 10, exceto pelo fato de que reformulamos cada lote de treinamento antes de fornecê-lo à rede. n_epochs = 100 batch_size = 150 with tf. Session() as sess: init. run() for epoch in range(n_epochs): for iteration in range(mnist. train. num_examples // batch_size): X_batch, y_batch = mnist. train. next_batch(batch_size) X_batch = X_batch. reshape((-1, n_steps, n_inputs)) sess. run(training_op, feed_dict={X: X_batch, y: y_batch}) acc_train = accuracy. eval(feed_dict={X: X_batch, y: y_batch}) acc_test = accuracy. eval(feed_dict={X: X_test, y: y_test}) print(epoch, "Train accuracy:", acc_train, "Test accuracy:", acc_test) A saída se parece com isso: 0 Train accuracy: 0. 94 Test accuracy: 0. 9308 1 Train accuracy: 0. 933333 Test accuracy: 0. 9431 [... ] 98 Train accuracy: 0. 98 Test accuracy: 0. 9794 99 Train accuracy: 1. 0 Test accuracy: 0. 9804 Nada mal, temos mais de 98% de acurácia! Além disso, inicializando os pesos da RNN com a utilização da inicialização He, você certamente obteria um melhor resultado ajustando os hiperparâmetros, treinando por mais tempo ou adicionando um pouco de regularização (por exemplo, dropout). Você pode especificar um inicializador para a RNN envolvendo seu código de construção em um escopo variável (por exemplo, utilize variable_scope(“rnn”, initializer=variance_sca-ling_ini tializer()) para utilizar a inicialização He). Treinando para Prever Séries Temporais Agora daremos uma olhada em como lidar com séries temporais como: preços de ações, temperatura do ar, padrões de ondas cerebrais e assim por diante. Nesta seção, treina-remos uma RNN para prever o próximo valor em uma série temporal. Cada instância de treinamento será uma sequência aleatoriamente selecionada da série temporal de 20 CG_MIOLO_Hands_On_Machine_Learning. indb 410 07/05/2019 17:10:01

Mãos à obra Aprendizado de máquina Aurelien Geron.pdf

Treinando RNNs | 411valores consecutivos e a sequência de destino é a mesma da sequência de entrada, com a exceção dela ser mudada em um intervalo de tempo no futuro (veja a Figura 14-7). Valor Uma série temp oral (gerada) Uma in stân cia de treinament o instância alvo Tempo Tempo Uma instância de treinamento Figura 14-7. Séries temporais (à esquerda) e uma instância de treinamento dessa série (à direita) Primeiro, criaremos a RNN, que conterá 100 neurônios recorrentes e a desenrolaremos em 20 intervalos de tempo, já que cada instância de treinamento terá 20 entradas. Cada entrada conterá apenas uma característica (o valor naquele momento). Os alvos são também sequências de 20 entradas, cada uma contendo um único valor. O código é quase o mesmo de antes: n_steps = 20 n_inputs = 1 n_neurons = 100 n_outputs = 1 X = tf. placeholder(tf. float32, [None, n_steps, n_inputs]) y = tf. placeholder(tf. float32, [None, n_steps, n_outputs]) cell = tf. contrib. rnn. Basic RNNCell(num_units=n_neurons, activation=tf. nn. relu) outputs, states = tf. nn. dynamic_rnn(cell, X, dtype=tf. float32) No geral, você teria mais do que apenas um recurso de entrada. Por exemplo, se você estivesse tentando prever preços de ações, prova-velmente teria muitos outros recursos de entrada em cada intervalo de tempo como preços de ações concorrentes, classificações de ana-listas ou qualquer outro recurso que ajudasse o sistema a fazer suas previsões. A cada intervalo de tempo temos agora um vetor de saída de tamanho 100, mas o que realmente queremos é um valor único de saída em cada intervalo de tempo. A solução mais simples é envolver a célula em um Output Projection Wrapper. Uma célula wrapper age como uma célula normal fazendo proxy de cada chamada de método para uma célula subjacente, mas também adiciona alguma funcionalidade. O Output Projection Wrapper adiciona uma camada totalmente conectada de neurônios lineares (ou seja, sem qualquer função CG_MIOLO_Hands_On_Machine_Learning. indb 411 07/05/2019 17:10:02

Mãos à obra Aprendizado de máquina Aurelien Geron.pdf

412 | Capítulo 14: Redes Neurais Recorrentes (RNN)de ativação) no topo de cada saída (mas isso não afeta o estado da célula). Todas essas camadas totalmente conectadas compartilham os mesmos pesos e termos de polarização (treináveis). A RNN resultante é representada na Figura 14-8. 1 unidade 1 unidade 1 unidade 1 unidade Figura 14-8. Células RNN utilizando projeções de saída Envolver uma célula é bem fácil. Ajustaremos o código anterior envolvendo o Basic RNNCell em um Output Projection Wrapper : cell = tf. contrib. rnn. Output Projection Wrapper( tf. contrib. rnn. Basic RNNCell(num_units=n_neurons, activation=tf. nn. relu), output_size=n_outputs) Por enquanto, tudo bem. Agora precisamos definir a função de custo. Utilizaremos o Erro Médio Quadrático (MSE), como fizemos em tarefas de regressão anteriores. Em seguida, como de costume, criaremos um otimizador Adam, o treinamento op e a ini-cialização da variável op: learning_rate = 0. 001 loss = tf. reduce_mean(tf. square(outputs-y)) optimizer = tf. train. Adam Optimizer(learning_rate=learning_rate) training_op = optimizer. minimize(loss) init = tf. global_variables_initializer() Agora para a fase de execução: n_iterations = 1500 batch_size = 50 with tf. Session() as sess: init. run() for iteration in range(n_iterations): X_batch, y_batch = [... ] # fetch the next training batch sess. run(training_op, feed_dict={X: X_batch, y: y_batch}) if iteration % 100 == 0: mse = loss. eval(feed_dict={X: X_batch, y: y_batch}) print(iteration, "\t MSE:", mse) CG_MIOLO_Hands_On_Machine_Learning. indb 412 07/05/2019 17:10:02

Mãos à obra Aprendizado de máquina Aurelien Geron.pdf

Treinando RNNs | 413n_iterations = 1500 batch_size = 50 with tf. Session() as sess: init. run() for iteration in range(n_iterations): X_batch, y_batch = [... ] # fetch the next training batch sess. run(training_op, feed_dict={X: X_batch, y: y_batch}) if iteration % 100 == 0: mse = loss. eval(feed_dict={X: X_batch, y: y_batch}) print(iteration, "\t MSE:", mse) A saída do programa deve ser parecida com esta: 0 MSE: 13. 6543 100 MSE: 0. 538476 200 MSE: 0. 168532 300 MSE: 0. 0879579 400 MSE: 0. 0633425 [... ] Uma vez treinado o modelo, você pode fazer previsões: X_new = [... ] # Novas sequências y_pred = sess. run(outputs, feed_dict={X: X_new}) A Figura 14-9 mostra a sequência prevista para a instância que examinamos anterior-mente (na Figura 14-7) após apenas 1 mil iterações de treinamento. Embora a utilização de um Output Projection Wrapper seja a solução mais simples para reduzir a dimensionalidade das sequências de saída da RNN para apenas um valor por intervalo de tempo (por instância), ela não é a mais eficiente. Existe uma solução mais eficiente, porém mais complicada: você pode remodelar as saídas da RNN de [batch_ size, n_steps, n_neurons] para [batch_size * n_steps, n_neurons], em seguida aplicar uma única camada totalmente conectada com o tamanho de saída apropriada (no nosso caso apenas 1) que resultará em um tensor de saída no formato [batch_size * n_steps, n_outputs] e, então, remodelar este tensor para [batch_size, n_steps, n_outputs]. Estas operações estão representadas na Figura 14-10. Tempoprevisãoalvoinstância Testando o modelo Figura 14-9. Previsões de séries temporais CG_MIOLO_Hands_On_Machine_Learning. indb 413 07/05/2019 17:10:03

Mãos à obra Aprendizado de máquina Aurelien Geron.pdf

414 | Capítulo 14: Redes Neurais Recorrentes (RNN) Remodele Remodeleun. Figura 14-10. Empilhe todas as saídas, aplique a projeção e forneça o resultado Para implementar esta solução, primeiro revertemos para uma célula básica, sem o Output Projection Wrapper : cell = tf. contrib. rnn. Basic RNNCell(num_units=n_neurons, activation=tf. nn. relu) rnn_outputs, states = tf. nn. dynamic_rnn(cell, X, dtype=tf. float32) Em seguida, com a utilização da operação reshape(), empilhamos todas as saídas, apli-camos a camada linear totalmente conectada (sem usar nenhum função de ativação; isto é, apenas uma projeção) e, finalmente, desempilhamos todas as saídas utilizando reshape() novamente : stacked_rnn_outputs = tf. reshape(rnn_outputs, [-1, n_neurons]) stacked_outputs = tf. layers. dense(stacked_rnn_outputs, n_outputs) outputs = tf. reshape(stacked_outputs, [-1, n_steps, n_outputs]) O restante do código é o mesmo de antes, podendo fornecer um aumento de velocidade significativo, pois há apenas uma camada totalmente conectada, em vez de uma por intervalo de tempo. CG_MIOLO_Hands_On_Machine_Learning. indb 414 07/05/2019 17:10:03

Mãos à obra Aprendizado de máquina Aurelien Geron.pdf

RNNs Profundas | 415RNN Criativa Agora que temos um modelo que pode prever o futuro, podemos usá-lo para gerar algumas sequências criativas, como explicado no início do capítulo. Precisamos fornecer apenas uma sequência semente que contenha valores n_steps (por exemplo, cheio de zeros), utilizar o modelo para prever o próximo valor, acrescentar este valor previsto à sequência, fornecer os últimos valores n_steps para o modelo e, então, prever o próximo valor e assim por diante. Este processo gera uma nova sequência que tem alguma semelhança com a série temporal original (veja a Figura 14-11). sequence = [0. ] * n_steps for iteration in range(300): X_batch = np. array(sequence[-n_steps:]). reshape(1, n_steps, 1) y_pred = sess. run(outputs, feed_dict={X: X_batch}) sequence. append(y_pred[0,-1, 0]) Tempo Tempo Valor Figura 14-11. Sequências criativas permeadas com zeros (esquerda) ou com uma instância (direita) Agora você pode tentar fornecer para uma RNN todos os seus álbuns do John Lennon e verificar se ela consegue gerar a próxima “Imagine”. Você provavelmente precisará de uma RNN muito mais poderosa, com mais neurônios, e também muito mais profunda. Daremos uma olhada nas RNNs profundas agora. RNNs Profundas É muito comum, como mostrado na Figura 14-12, empilhar múltiplas camadas de células, resultando em uma RNN profunda. Para implementar uma RNN profunda no Tensor Flow, você pode criar várias células e empilhá-las em uma Multi RNNCell. No código a seguir, empilharemos três células CG_MIOLO_Hands_On_Machine_Learning. indb 415 07/05/2019 17:10:04

Mãos à obra Aprendizado de máquina Aurelien Geron.pdf

416 | Capítulo 14: Redes Neurais Recorrentes (RNN)idênticas (mas você poderia muito bem utilizar vários tipos de células com um número diferente de neurônios): n_neurons = 100 n_layers = 3 layers = [tf. contrib. rnn. Basic RNNCell(num_units=n_neurons, activation=tf. nn. relu) for layer in range(n_layers)] multi_layer_cell = tf. contrib. rnn. Multi RNNCell(layers) outputs, states = tf. nn. dynamic_rnn(multi_layer_cell, X, dtype=tf. float32) Figura 14-12. RNN profunda (esquerda) desenrolada através do tempo (direita) Isso é tudo! A variável states é uma tupla que contém um tensor por camada, cada um representando o estado final daquela célula da camada (com formato [batch_size, n_neu rons] ). Se você configurar state_is_tuple=False ao criar uma Multi RNNCell, então states se torna um tensor único contendo os estados de cada camada concatenado no eixo coluna (ou seja, seu formato é [batch_size, n_layers * n_neurons] ). Observe que este comportamento era o padrão antes do Tensor Flow 0. 11. 0. Distribuindo uma RNN Profunda Através de Múltiplas GPUs O Capítulo 12 apontou que, ao fixarmos cada camada a uma GPU diferente, podemos distribuir eficientemente RNNs profundas através de múltiplas GPUs (veja a Figu-ra 12-16). No entanto, não funcionará se você tentar criar cada célula em um bloco device() diferente: with tf. device("/gpu:0"): # PÉSSIMO! Foi ignorado. layer1 = tf. contrib. rnn. Basic RNNCell(num_units=n_neurons) with tf. device("/gpu:1"): # PÉSSIMO! Ignorado novamente. layer2 = tf. contrib. rnn. Basic RNNCell(num_units=n_neurons) CG_MIOLO_Hands_On_Machine_Learning. indb 416 07/05/2019 17:10:04

Mãos à obra Aprendizado de máquina Aurelien Geron.pdf

RNNs Profundas | 417Isto falhará porque uma Basic RNNCell é uma fábrica de células, não uma célula per se (como mencionado anteriormente); nenhuma célula é criada quando você cria a fábrica e, portanto, nenhuma variável também. O bloco do dispositivo é simples-mente ignorado e as células são criadas depois. Quando você chama dynamic_rnn(), ela chama a Multi RNNCell, que chama cada Basic RNNCell individual, que cria as cé-lulas atuais (incluindo suas variáveis). Infelizmente, nenhuma dessas classes fornece uma maneira de controlar os dispositivos nos quais as variáveis são criadas. Se você tentar colocar a chamada dynamic_rnn() dentro de um bloco do dispositivo, toda a RNN será fixada em um único dispositivo. Então, isso significa que você está preso? Felizmente não! O truque é criar seu próprio wrapper de célula (ou utilizar a classe tf. contrib. rnn. Device Wrapper, que foi adicionada no Tensor Flow 1. 1): import tensorflow as tf class Device Cell Wrapper(tf. contrib. rnn. RNNCell): def __init__(self, device, cell): self. _cell = cell self. _device = device @property def state_size(self): return self. _cell. state_size @property def output_size(self): return self. _cell. output_size def __call__(self, inputs, state, scope=None): with tf. device(self. _device): return self. _cell(inputs, state, scope) Esse wrapper simplesmente faz o proxy [solicitação] de toda chamada de método para outra célula, exceto que envolve a função _ call_() dentro de um bloco do dispositivo. 2 Agora, você pode distribuir cada camada em uma GPU diferente: devices = ["/gpu:0", "/gpu:1", "/gpu:2"] cells = [Device Cell Wrapper(dev,tf. contrib. rnn. Basic RNNCell(num_units=n_neurons)) for dev in devices] multi_layer_cell = tf. contrib. rnn. Multi RNNCell(cells) outputs, states = tf. nn. dynamic_rnn(multi_layer_cell, X, dtype=tf. float32) Não configure state_is_tuple=False pois a Multi RNNCell conca-tenará todos os estados da célula em um tensor único em uma única GPU. 2 Usa o padrão de design decorato r. CG_MIOLO_Hands_On_Machine_Learning. indb 417 07/05/2019 17:10:05

Mãos à obra Aprendizado de máquina Aurelien Geron.pdf

418 | Capítulo 14: Redes Neurais Recorrentes (RNN)Aplicando o Dropout Se você construir uma RNN muito profunda, ela pode acabar se sobreajustando ao conjunto de treinamento. Uma técnica comum para evitarmos isso é aplicar o dropout (apresentado no Capítulo 11). Como de costume, podemos adicionar uma camada de dropout antes ou depois da RNN, mas se você também quiser aplicar o dropout entre as camadas da RNN terá que utilizar um Dropout Wrapper. O código a seguir aplica na RNN o dropout às entradas de cada camada: keep_prob = tf. placeholder_with_default(1. 0, shape=()) cells = [tf. contrib. rnn. Basic RNNCell(num_units=n_neurons) for layer in range(n_layers)] cells_drop = [tf. contrib. rnn. Dropout Wrapper(cell, input_keep_prob=keep_prob) for cell in cells]multi_layer_cell = tf. contrib. rnn. Multi RNNCell(cells_drop) rnn_outputs, states = tf. nn. dynamic_rnn(multi_layer_cell, X, dtype=tf. float32) # O resto da fase de construção é igual à anterior. Você pode fornecer o valor que quiser ao placeholder keep_prob (geralmente 0. 5) du-rante o treinamento: n_iterations = 1500 batch_size = 50 train_keep_prob = 0. 5 with tf. Session() as sess: init. run() for iteration in range(n_iterations): X_batch, y_batch = next_batch(batch_size, n_steps) _, mse = sess. run([training_op, loss], feed_dict={X: X_batch, y: y_batch, keep_prob: train_keep_prob}) saver. save(sess, ". /my_dropout_time_series_model") Desativando o dropout durante o teste, você deve deixar o keep_prob no padrão 1. 0 (lembre-se de que ele deve estar ativo somente durante o treinamento): with tf. Session() as sess: saver. restore(sess, ". /my_dropout_time_series_model") X_new = [... ] # alguns dados de teste y_pred = sess. run(outputs, feed_dict={X: X_new}) Observe que também é possível, desde o Tensor Flow 1. 1, aplicar o dropout às saídas, e também é possível, com a utilização do state_keep_prob, aplicar o dropout ao estado da célula. Com isso, você deve ser capaz de treinar todos os tipos de RNNs! Infelizmente, as coisas ficarão um pouco mais difíceis se você quiser treinar uma RNN em longas sequências. Veremos por quê, e o quê você pode fazer a respeito. CG_MIOLO_Hands_On_Machine_Learning. indb 418 07/05/2019 17:10:06

Mãos à obra Aprendizado de máquina Aurelien Geron.pdf

RNNs Profundas | 419A Dificuldade de Treinar Muitos Intervalos de Tempo Para treinar uma RNN em longas sequências, tornando-a uma rede desenrolada muito profunda, você precisará executá-la ao longo de vários intervalos de tempo. Assim como qualquer rede neural profunda, ela pode demorar uma eternidade no treinamento e sofrer com o problema dos gradientes vanishing/exploding (discutido no Capítulo 11). Muitos dos truques que discutimos para aliviar este problema também podem ser utilizados para RNNs profundas desenroladas: boa inicialização do parâmetro, funções de ativação não saturadas (por exemplo, Re LU), Normalização de Lotes, Recorte de Gradiente e otimi-zadores mais rápidos. No entanto, o treinamento ainda será muito lento, até mesmo se a RNN precisar lidar com sequências moderadamente longas (por exemplo, 100 entradas). A solução mais simples e comum para esse problema durante o treinamento é desenrolar a RNN somente durante um número limitado de intervalos de tempo, o que é chamado de retropropagação truncada através do tempo. Você pode implementá-lo no Tensor Flow simplesmente truncando as sequências de entrada. Por exemplo, você simplesmente reduziria n_steps durante o treinamento no problema da previsão de séries temporais. O problema, claro, é que o modelo não será capaz de aprender padrões de longo prazo. Uma solução alternativa seria garantir que essas sequências abreviadas contenham dados antigos e recentes para que o modelo aprenda a utilizar ambos (por exemplo, a sequência pode conter dados mensais dos últimos cinco meses e, em seguida, dados semanais das últimas cinco semanas, em seguida, dados diários dos últimos cinco dias). Mas essa so-lução alternativa tem seus limites: os dados refinados do ano passado foram realmente úteis? E se houve um evento breve, mas significativo, que absolutamente deva ser levado em consideração, mesmo anos depois (por exemplo, o resultado de uma eleição)? Um segundo problema enfrentado pelas RNNs de longa duração é o fato de que a memória das primeiras entradas desaparece gradualmente, além do longo tempo de treinamento. De fato, algumas informações são perdidas após cada intervalo de tempo devido às transformações pelas quais os dados passam ao atravessar uma RNN. Depois de um tempo, o estado da RNN praticamente não contém traços das primeiras entra-das e isso pode ser um erro severo. Por exemplo, digamos que você queira realizar uma análise de sentimento em um longo artigo que comece com as três palavras “Adorei esse filme", mas o resto da resenha lista muitas coisas que poderiam ter tornado o filme ainda melhor. Se a RNN gradualmente esquece as quatro primeiras palavras, ela interpretará equivocadamente o artigo. Foram introduzidos vários tipos de células com memória de longo prazo para resolver esse problema, e elas se mostraram tão bem sucedidas que as células básicas já não são muito utilizadas. Veremos primeiro a mais popular dessas células de memória longa: a célula LSTM. CG_MIOLO_Hands_On_Machine_Learning. indb 419 07/05/2019 17:10:06

Mãos à obra Aprendizado de máquina Aurelien Geron.pdf

420 | Capítulo 14: Redes Neurais Recorrentes (RNN)Célula LSTM A célula Memória Longa de Curto Prazo (LSTM, do inglês) foi proposta em 1997 ( https:// goo. gl/j39AGv )3 por Sepp Hochreiter e Jurgen Schmidhuber e aperfeiçoada por muitos pesquisadores como Alex Graves, Haşim Sak ( https://goo. gl/6BHh81 ),4 Wojciech Zaremba (https://goo. gl/SZ9kz B ),5 e muitos outros ao longo dos anos. Ela poderá ser utilizada de maneira muito parecida com uma célula básica se você a considera como uma caixa preta, mas terá um desempenho muito melhor; o treinamento convergirá mais rápido e detectará dependências de longo prazo nos dados. Você pode simplesmente utilizar uma Basic LSTMCell em vez de uma Basic RNNCell no Tensor Flow: lstm_cell = tf. contrib. rnn. Basic LSTMCell(num_units=n_neurons) Células LSTM gerenciam dois vetores de estado e, por razões de desempenho, eles são mantidos separados por padrão. Configurando state_is_tuple=False ao criar uma Basic LSTMCell você pode mudar este comportamento padrão. Então, como funciona uma célula LSTM? Sua arquitetura básica é mostrada na Figura 14-13. Adição logística tanh Multiplicação do element-wise Célula LSTM Figura 14-13. Célula LSTM 3 “Long Short-Term Memory”, S. Hochreiter and J. Schmidhuber (1997). 4 “Long Short-Term Memory Recurrent Neural Network Architectures for Large Scale Acoustic Modelling”, H. Sak et al. (2014). 5 “Re current Neural Network Regularization”, W. Zaremba et al. (2015). CG_MIOLO_Hands_On_Machine_Learning. indb 420 07/05/2019 17:10:06

Mãos à obra Aprendizado de máquina Aurelien Geron.pdf

Célula LSTM | 421Se você não olhar para o que está dentro da caixa, a célula LSTM se parece exatamente com uma célula comum, exceto pelo seu estado dividido em dois vetores: h (t) e c(t) (“c” se refere a “célula”). Você pode pensar em h (t) como o estado de curto prazo e c(t) como o estado de longo prazo. Agora abriremos a caixa! A ideia-chave é que a rede possa aprender o que armazenar no estado de longo prazo, o que jogar fora e o que ler a partir dele. Como o estado de longo prazo c (t-1) atravessa a rede da esquerda para a direita, você pode ver que ele passa primeiro por um forget gate, descartando algumas memórias e adicionando algumas novas memórias através da operação de adição (que acrescenta as memórias que foram selecionadas por um input gate ). O resultado c (t) é enviado diretamente, sem qualquer transformação adicional. Então algumas memórias são descartadas e algumas são adi-cionadas a cada intervalo de tempo. Além disso, após a operação de adição, o estado de longo prazo é copiado e passado pela função tanh e, em seguida, seu resultado é filtrado pelo output gate, produzindo o estado de curto prazo h (t) (que é igual à saída da célula para este intervalo de tempo y (t)). Agora, veremos de onde vêm as novas memórias e como funcionam as portas. Primeiro, o vetor de entrada atual x (t) e o estado de curto prazo anterior h (t-1) são for-necidos para quatro camadas diferentes totalmente conectadas. Todos servem a um propósito diferente: A cam ada principal é aquela que produz g (t) e, normalmente, assume o papel de analisar as entradas atuais x(t) e o estado anterior (de curto prazo) h(t-1). Em uma célula básica não há nada além desta camada, e sua saída vai direto para y (t) e h(t). Em contraste, em uma célula LSTM a saída dessa camada não se extingue dire-tamente, mas é armazenada parcialmente no estado de longo prazo; As tr ês outras camadas são gate controllers. Como elas utilizam a função de ati-vação logística, suas saídas variam de 0 a 1. Como você pode ver, suas saídas são fornecidas para operações de multiplicação elemento por elemento, então, se eles produzem 0s, fecham o gate e, se geram 1s, os gates se abrem. Especificamente: —O forget gate (controlado por f (t)) controla quais partes do estado de longo prazo devem ser apagadas; —O input gate (controlado por i (t)) controla quais partes de g (t) devem ser adicio-nadas ao estado de longo prazo (é por isso que dissemos que era apenas“par-cialmente armazenado”); —Finalmente, o output gate (controlado por o (t)) controla quais partes do estado de longo prazo devem ser lidas e exibidas neste intervalo de tempo (ambos para h(t)) e y(t). CG_MIOLO_Hands_On_Machine_Learning. indb 421 07/05/2019 17:10:06

Mãos à obra Aprendizado de máquina Aurelien Geron.pdf

422 | Capítulo 14: Redes Neurais Recorrentes (RNN)Em resumo, uma célula LSTM pode aprender a reconhecer uma entrada importante (que é o papel do input gate ), armazená-la no estado de longo prazo, aprender a preservá-la pelo tempo necessário (esse é o papel do forget gate ) e aprender a extraí-la sempre que for preciso. Isso explica por que elas têm sido surpreendentemente bem-sucedidas em capturar padrões de longo prazo em séries temporais, textos longos, gravações de áudio e muito mais. A Equação 14-3 resume como calcular em cada intervalo de tempo para uma única instância: o estado de longo prazo da célula, seu estado de curto prazo e sua saída (as equações para um minilote inteiro são muito semelhantes). Equação 14-3. Cálculos LSTM it=σWxi T·xt+Whi T·ht-1+bi ft=σWxf T·xt+Whf T·ht-1+bf ot=σWxo T·xt+Who T·ht-1+bo gt= tanh Wxg T·xt+Whg T·ht-1+bg ct=ftct-1+itgt yt=ht=ottanh ct Wxi, Wxf, Wxo, Wxg são as matrizes de peso de cada uma das quatro camadas para suas conexões com o vetor de entrada x (t); Whi, Whf, Who, e W hg são as matrizes de peso de cada uma das quatro camadas para suas conexões com o estado anterior de curto prazo h (t-1); bi, bf, bo, e b g são os termos de polarização para cada uma das quatro camadas. Observe que o Tensor Flow inicializa b f para um vetor cheio de 1s em vez de 0s, evitando esquecer tudo no início do treinamento. Conexões Peephole Em uma célula LSTM básica, os controladores do gate podem olhar apenas para a entra-da x(t) e o estado anterior de curto prazo h (t-1). Permitir também que observem o estado de longo prazo pode ser uma boa ideia para dar-lhes um pouco mais de contexto. Esta ideia foi proposta por Felix Gers e Jürgen Schmidhuber em 2000 ( https://goo. gl/ch8x-z3),6 quando propuseram uma variante LSTM com conexões extras chamadas conexões peephole : o estado de longo prazo anterior c (t-1) é adicionado como uma entrada para os 6 “Recurrent Nets that Time and Count”, F. Gers and J. Schmidhube (2000). CG_MIOLO_Hands_On_Machine_Learning. indb 422 07/05/2019 17:10:07

Mãos à obra Aprendizado de máquina Aurelien Geron.pdf

Célula GRU | 423controladores do forget gate e do input gate e o estado de longo prazo c (t) é adicionado como entrada para o controlador do output gate. Para implementar as conexões peephole no Tensor Flow você deve utilizar a LSTMCell em vez da Basic LSTMCell e configurar use_peepholes=True : lstm_cell = tf. contrib. rnn. LSTMCell(num_units=n_neurons, use_peepholes=True) Existem muitas outras variantes da célula LSTM e uma popular é a célula GRU que veremos agora. Célula GRU A célula Gated Recurrent Unit (GRU) foi proposta por Kyunghyun Cho et al. em um artigo de 2014 ( https://goo. gl/Zn AEOZ )7 que também introduziu a rede Encoder-Decoder que mencionamos anteriormente (veja a Figura 14-14). Célula GRU Figura 14-14. Célula GRU A célula GRU é uma versão simplificada da célula LSTM e parece funcionar muito bem8 (o que explica sua crescente popularidade). As principais simplificações são: Amb os os vetores de estado são mesclados em um único vetor h (t); Um ú nico gate controller controla tanto o forget gate quanto o input gate. Se o gate controller gerar um 1 o forget gate é aberto e o input gate é fechado. Se o re-sultado for 0, o oposto acontece. Em outras palavras, sempre que uma memória precisar ser armazenada, o local onde ela será armazenada será apagado primei-ro. Esta é realmente uma variante frequente para a célula LSTM em si; 7 “Learning Phrase Representations using RNN Encoder-Decoder for Statistical Machine Translation”, K. Cho et al. (2014). 8 Um ar tigo de 2015 por Klaus Greff et al., "LSTM: A Search Space Odyssey", ( http://goo. gl/h ZB4KW ) parece mostrar que todas as variantes LSTM têm desempenho semelhante. CG_MIOLO_Hands_On_Machine_Learning. indb 423 07/05/2019 17:10:07

Mãos à obra Aprendizado de máquina Aurelien Geron.pdf

424 | Capítulo 14: Redes Neurais Recorrentes (RNN) Não há porta de saída; o vetor de estado completo é gerado a cada intervalo de tem po. No entanto, há um novo controlador da porta que controla qual parte do estado anterior será mostrada para a camada principal. A Equação 14-4 resume como calcular o estado da célula a cada intervalo de tempo para uma única instância. Equação 14-4. Cálculos da GRU zt=σWxz T·xt+Whz T·ht-1+bz rt=σWxr T·xt+Whr T·ht-1+br gt= tanh Wxg T·xt+Whg T·rtht-1+bg ht=ztht-1+1-ztgt Criar uma célula GRU no Tensor Flow é trivial: gru_cell = tf. contrib. rnn. GRUCell(num_units=n_neurons) As células LSTM ou GRU são uma das principais razões por trás do sucesso das RNNs nos últimos anos, principalmente para aplicações em processamento de linguagem natural (PNL). Processamento de Linguagem Natural A maioria dos aplicativos de última geração da PNL, como tradução automática, resumo automático, análise sintática, análise de sentimento e muito mais, agora se baseia (pelo menos em parte) em RNNs. Nesta última seção, daremos uma rápida olhada no modelo de tradução automática. Este tópico é muito bem coberto pelos incríveis tutoriais do Tensor Flow Word2Vec ( https://goo. gl/ed Ardi ) e Seq2Seq ( https://goo. gl/L82gv S ), então você definitivamente deveria conferi-los. Word Embeddings Antes de começarmos, precisamos escolher uma representação de palavras. Uma opção poderia ser representar cada palavra utilizando um vetor one-hot. Suponha que seu vocabulário contenha 50 mil palavras, então a enésima palavra seria representada como um vetor de 50 mil dimensões, cheio de “0” com exceção de um “1” na enésima posição. No entanto, essa representação esparsa não seria eficiente com um vocabulário tão grande. Você quer que palavras semelhantes tenham representações semelhantes, facilitando a gene-ralização do que o modelo aprende sobre uma palavra, para todas as palavras semelhantes. CG_MIOLO_Hands_On_Machine_Learning. indb 424 07/05/2019 17:10:08

Mãos à obra Aprendizado de máquina Aurelien Geron.pdf

Processamento de Linguagem Natural | 425Por exemplo, se o modelo diz que “eu bebo leite” é uma sentença válida, e se ele sabe que “leite” está perto de “água”, mas longe de “sapatos”, então também saberá que “eu bebo água” provavelmente é uma sentença válida, enquanto “eu bebo sapatos” provavelmente não é. Mas como você pode chegar a uma representação tão significativa? A solução mais comum é representar cada palavra no vocabulário com a utilização de um vetor razoavelmente pequeno e denso (por exemplo, 150 dimensões), chamado embedding, e simplesmente deixar a rede neural aprender uma boa embedding para cada palavra durante o treinamento. No início do treinamento, as word embeddings são escolhidas aleatoriamente, mas durante o treinamento a retropropagação as move automaticamente de forma a ajudar a rede neural a executar sua tarefa. Normalmente, isso significa que palavras semelhantes se agruparão gradualmente umas às outras e até terminarão orga-nizadas de maneira bastante significativa. Por exemplo, as word embeddings podem ser posicionadas ao longo de vários eixos que representam gênero, singular/plural, adjetivo/ substantivo e assim por diante. O resultado pode ser verdadeiramente surpreendente. 9 Você primeiro precisa criar no Tensor Flow a variável que representa as embeddings para cada palavra em seu vocabulário (inicializado aleatoriamente): vocabulary_size = 50000 embedding_size = 150 init_embeds = tf. random_uniform([vocabulary_size, embedding_size],-1. 0, 1. 0) embeddings = tf. Variable(init_embeds) Agora, suponha que você queira alimentar em sua rede neural a frase “eu bebo leite", comece pré-processando a frase e dividindo-a em uma lista de palavras conhecidas. Por exemplo, você pode remover caracteres desnecessários, substituir palavras desconhecidas por um token predefinido como “[UNK]”, substituir valores numéricos por “[NUM]”, substituir URLs por “[URL]” e assim por diante. Depois de ter uma lista de palavras conhecidas, você pode procurar o identificador de número inteiro de cada palavra (de 0 a 49999) em um dicionário, por exemplo [72, 3335, 288]. Nesse ponto, você está pronto para fornecer esses identificadores de palavras ao Tensor Flow com a utilização de um placehol-der, e aplicar a função embedding_lookup() para obter as embeddings correspondentes: train_inputs = tf. placeholder(tf. int32, shape=[None]) # de ids... embed = tf. nn. embedding_lookup(embeddings, train_inputs) #... a embeddings Uma vez que seu modelo tenha aprendido boas embeddings ele pode ser reutilizado de forma bastante eficiente em qualquer aplicação NLP: afinal, “leite” ainda está perto de “água” e longe de “sapatos”, não importa qual seja sua aplicação. Na verdade, em vez de treinar suas próprias word embeddings, você pode querer baixá-las de palavras pré-trei-9 Para mais detalhes, confira o ótimo post de Christopher Olah ( ht tps://goo. gl/5r LNTj ), ou a série de posts de Sebastian Ruder ( https://goo. gl/oj Jji E ). CG_MIOLO_Hands_On_Machine_Learning. indb 425 07/05/2019 17:10:08

Mãos à obra Aprendizado de máquina Aurelien Geron.pdf

426 | Capítulo 14: Redes Neurais Recorrentes (RNN)nadas. Assim como quando reutilizamos camadas pré-treinadas (veja o Capítulo 11), você pode escolher congelar a variável embeddings pré-treinada (por exemplo, criando as embeddings utilizando trainable=False ) ou deixando a retropropagação ajustá-las para sua aplicação. A primeira opção acelerará o treinamento, mas a segunda pode levar a um desempenho ligeiramente superior. Embeddings também são úteis para representar atributos categóri-cos que podem assumir um grande número de valores diferentes, especialmente quando há semelhanças complexas entre os valores. Por exemplo, considere profissões, hobbies, pratos, espécies, marcas e assim por diante. Agora você tem quase todas as ferramentas necessárias para implementar um sistema de tradução automática. Vejamos isso agora. Uma Rede Codificador-Decodificador para Tradução de Máquina Daremos uma olhada em um modelo simples de tradução automática ( https://goo. gl/0g-9z WP )10 que traduzirá frases do inglês para o francês (veja a Figura 14-15). Alvo : Previsão: Codi/f_icador-Decodi/f_icador Softmax Pesquisa de incorporação Pesquisa de incorporação Figura 14-15. Um modelo simples de máquina de tradução As sentenças em inglês fornecidas ao codificador e o decodificador exibem as traduções em francês. Note que as traduções francesas também são utilizadas como entradas para o decodificador, mas retrocedidas em uma etapa. Em outras palavras, o decodificador 10 “Sequence to Sequence learning with Neural Networks”, I. Sutskever et al. (2014). CG_MIOLO_Hands_On_Machine_Learning. indb 426 07/05/2019 17:10:08

Mãos à obra Aprendizado de máquina Aurelien Geron.pdf

Processamento de Linguagem Natural | 427é tido como a entrada da palavra que deve ter sua saída na etapa anterior (independen-temente do que realmente exibe). É dado um token que representa o início da sentença (por exemplo, “<go>”) para a primeira palavra. Espera-se que o decodificador finalize a sentença com um token de final de sequência (EOS) (por exemplo, “<eos>”). Observe que as sentenças em inglês são invertidas antes de serem fornecidas ao codifi-cador. Por exemplo, “I drink milk” é revertido para “milk drink I". Isso garante que o início da sentença em inglês seja fornecido por último ao codificador, o que é útil porque geralmente é a primeira coisa que o decodificador precisa traduzir. Cada palavra é inicialmente representada por um identificador numeral (por exemplo, 288 para a palavra “milk”). Em seguida, uma pesquisa de embedding retorna a palavra incorporada (como explicado anteriormente, trata-se de um vetor denso de baixa dimen-sionalidade). Estas word embeddings são o que realmente é fornecido para o codificador e o decodificador. A cada etapa, o decodificador exibe uma pontuação para cada palavra no vocabulário de saída (ou seja, Francês) e, então, a camada Softmax transforma essas pontuações em pro-babilidades. Por exemplo, na primeira etapa a palavra “Je” pode ter uma probabilidade de 20%, “Tu” pode ter uma probabilidade de 1%, e assim por diante. A palavra com a maior probabilidade é exibida, o que é muito parecido com uma tarefa de classificação regular, então utilizando a função soft max_cross_entropy_with_logits(), você pode treinar o modelo. Observe que você não terá a sentença de destino para alimentar o decodificador no mo-mento da inferência (após o treinamento). Em vez disso, conforme mostrado na Figura 14-16, alimente o decodificador com a palavra que ele emitiu na etapa anterior (isso exigirá uma pesquisa de incorporação que não é mostrada no diagrama). <go> Figura 14-16. Alimentando a palavra de saída anterior como entrada no tempo de inferência CG_MIOLO_Hands_On_Machine_Learning. indb 427 07/05/2019 17:10:09

Mãos à obra Aprendizado de máquina Aurelien Geron.pdf

428 | Capítulo 14: Redes Neurais Recorrentes (RNN)Ok, agora você já consegue ver o quadro geral. No entanto, se passar pelo tutorial do Tensor Flow de sequência-para-sequência e observar o código em rnn/translate/seq-2seq_model. py (nos modelos do Tensor Flow [ https://github. com/tensorflow/models] ), você notará algumas diferenças importantes: Pri meiro, até agora assumimos que todas as sequências de entrada (para o codifica-dor e o decodificador) têm um comprimento constante. Mas obviamente os compri-mentos das frases podem variar. Existem várias formas de lidar com isso — por exemplo, utilizar o argumento sequence_length para as funções static_rnn() ou dynamic_rnn() para especificar o comprimento de cada frase (como discuti-do anteriormente). No entanto, outra abordagem é utilizada no tutorial (presumi-velmente por motivos de desempenho): as sentenças são agrupadas em intervalos de comprimento semelhante (por exemplo, um intervalo para as frases de 1 a 6 palavras, outro para as frases de 7 a 12, e assim por diante) 11, e as sentenças mais curtas são preenchidas com a utilização de um token especial de preenchimento (por exemplo, “<pad>”). Por exemplo, “I drink milk” se torna “<pad> <pad> <pad> milk drink I” e sua tradução se torna “Je bois du lait <eos> <pad>”. Claro, queremos ignorar qualquer saída após o token EOS e a implementação do tutorial utiliza um vetor target_weights para isso. Por exemplo, os pesos seriam ajusta-dos para [1. 0, 1. 0, 1. 0, 1. 0, 1. 0, 0. 0] para a sentença de destino “Je bois du lait <es> <pad>” (observe o peso 0. 0 correspondente ao token de preenchimento na sentença de destino). Multiplicar as perdas pelos pesos-alvo zerará as perdas que correspondem a palavras passadas em tokens EOS; Seg undo, seria terrivelmente lento produzir uma probabilidade para cada pala-vra possível quando o vocabulário de saída for grande (o que é o caso aqui). Se o vocabulário-alvo contém, digamos, 50 mil palavras em francês, seria muito intensivo em termos computacionais para se calcular a função softmax sobre um vetor tão grande, então o decodificador produziria vetores de 50 mil dimensões. Uma solução para evitar isso seria deixar o decodificador gerar vetores muito menores e utilizar uma técnica de amostragem para estimar a perda sem pre-cisar calculá-la sobre cada palavra do vocabulário-alvo, como vetores de 1 mil dimensões. Esta técnica Sampled Softmax foi introduzida em 2015 por Sébastien Jean et al. (https://goo. gl/u0GR8k). 12 No Tensor Flow, você pode utilizar a função sampled_softmax_loss() ; 11 Os tamanhos de unidades de dados utilizados no tutorial são diferentes. 12 “On U sing Very Large Target Vocabulary for Neural Machine Translation”, S. Jean et al. (2015). CG_MIOLO_Hands_On_Machine_Learning. indb 428 07/05/2019 17:10:09

Mãos à obra Aprendizado de máquina Aurelien Geron.pdf

Exercícios | 429 Em terceiro lugar, a implementação do tutorial utiliza um mecanismo de atenção qu e permite ao decodificador espiar a sequência de entrada. RNNs de atenção aumentadas estão além do escopo deste livro, mas existem artigos úteis sobre a tradução automática ( https://goo. gl/8RCous ),13 leitura de máquina ( https://goo. gl/ X0Nau8 )14 e legendas de imagens ( https://goo. gl/xmhvf K );15 Finalmente, a implementação do tutorial faz uso do tf. nn. legacy_seq2seq, módulo que fornece ferramentas para construir facilmente vários modelos Encoder-Decoder. Por exemplo, a função embedding_rnn_seq2seq() cria um modelo simples Encoder-Decoder que cuida automaticamente das incorpora-ções para você, assim como o representado na Figura 14-15. Este código poderia ser atualizado rapidamente para utilizar o novo módulo tf. nn. seq2seq. Você tem agora todas as ferramentas necessárias para entender a implementação do tutorial sequência-para-sequência. Confira e treine seu próprio tradutor de inglês para francês! Exercícios 1. Você pode pensar em algumas aplicações para uma RNN de sequência-a-sequên-ci a? Que tal uma RNN sequência-vetor? E uma RNN vetor-a-sequência? 2. Por q ue as pessoas utilizam RNNs de codificador-decodificador em vez de RNNs de sequência-a-sequência simples para tradução automática? 3. Com o você poderia combinar uma rede neural convolucional com uma RNN para classificar vídeos? 4. Qua is são as vantagens de se construir uma RNN utilizando dynamic_rnn() em vez de static_rnn() ? 5. Com o você pode lidar com sequências de entrada de comprimento variável? E quanto às sequências de saída de tamanho variável? 6. Qua l é uma forma comum de se distribuir treinamento e execução de uma RNN profunda em várias GPUs? 7. Emb edded Reber grammars foram utilizadas por Hochreiter e Schmidhuber em seu artigo sobre LSTMs. São gramáticas artificiais que produzem strings como “BPBTSXXVPSEPE. ” Confira a bela introdução de Jenny Orr ( https://goo. gl/7Ck NRn) sobre este tópico. Escolha uma gramática embutida específica (como 13 “Neural Machine Translation by Jointly Learning to Align and Translate”, D. Bahdanau et al. (2014). 14 “Lon g Short-Term Memory-Networks for Machine Reading”, J. Cheng (2016). 15 “Sh ow, Attend and Tell: Neural Image Caption Generation with Visual Attention”, K. Xu et al. (2015). CG_MIOLO_Hands_On_Machine_Learning. indb 429 07/05/2019 17:10:09

Mãos à obra Aprendizado de máquina Aurelien Geron.pdf

430 | Capítulo 14: Redes Neurais Recorrentes (RNN)a representada na página de Jenny Orr) depois treine uma RNN para identificar se uma string respeita ou não essa gramática. Você primeiro precisará escrever uma função capaz de gerar um lote de treinamento contendo cerca de 50% de strings que respeitem a gramática e 50% que não. 8. Enc are a competição Kaggle “How much did it rain? II" ( https://goo. gl/0DS5Xe ). Esta é uma tarefa de previsão de séries temporais: são fornecidas fotografias de va-lores de radares polarimétricos e é solicitada a previsão do total de precipitação pluviométrica por hora. A entrevista de Luis André Dutra e Silva ( https://goo. gl/ f TA90W ) dá algumas informações interessantes sobre as técnicas que ele utilizou para alcançar o segundo lugar na competição. Em particular, ele utilizou uma RNN composta de duas camadas LSTM. 9. Ace sse o tutorial Word2Vec (https://goo. gl/ed Ardi) do Tensor Flow para criar uma word embedding e, em seguida, leia o tutorial Seq2Seq (https://goo. gl/L82gv S) para treinar um sistema de tradução do inglês para o francês. Soluções para estes exercícios estão disponíveis no Apêndice A. CG_MIOLO_Hands_On_Machine_Learning. indb 430 07/05/2019 17:10:09

Mãos à obra Aprendizado de máquina Aurelien Geron.pdf

431Capítulo 15 Autoencoders Autoencoders são redes neurais artificiais capazes de aprender representações eficientes dos dados de entrada, conhecidos como codificações, sem supervisão alguma (ou seja, o conjunto de treinamento é não rotulado). Essas codificações geralmente têm uma dimensionalidade muito menor do que os dados de entrada, o que as torna úteis para redução de dimensionalidade (consulte o Capítulo 8). Mais importante, os autoenco-ders atuam como detectores de características poderosos e podem ser utilizados para pré-treinamento não supervisionado de redes neurais profundas (como discutimos no Capítulo 11). Por último, eles são capazes de gerar novos dados aleatoriamente que são muito semelhantes aos dados de treinamento, o que é chamado de modelo gerador. Por exemplo, você poderia treinar um autoencoder em imagens de rostos e, em seguida, ele seria capaz de gerar novos rostos. Surpreendentemente, o funcionamento dos autoencoders se resume a simplesmente aprender a copiar suas entradas para suas saídas, o que pode soar como uma tarefa trivial, mas veremos que restringir a rede de várias maneiras pode dificultá-la bastante. Por exemplo, você pode limitar o tamanho da representação interna ou adicionar ruído às entradas e treinar a rede para recuperar as entradas originais. Essas restrições impedem que o autoencoder copie as entradas diretamente para as saídas, o que o obriga a aprender maneiras eficientes de representar os dados. Em suma, os códigos são subprodutos da tentativa do autoencoder de aprender a função de identidade, sob algumas restrições. Neste capítulo, explicaremos com mais profundidade como funcionam os autoenco-ders, que tipos de restrições podem ser impostas e como implementá-las utilizando o Tensor Flow, seja para redução de dimensionalidade, extração de características, pré--treinamento não supervisionado ou como modelos geradores. CG_MIOLO_Hands_On_Machine_Learning. indb 431 07/05/2019 17:10:09

Mãos à obra Aprendizado de máquina Aurelien Geron.pdf

432 | Capítulo 15: Autoencoders Representações Eficientes de Dados Quais das seguintes sequências numéricas você acha mais fácil de memorizar? 40, 2 7, 25, 36, 81, 57, 10, 73, 19, 68 50, 2 5, 76, 38, 19, 58, 29, 88, 44, 22, 11, 34, 17, 52, 26, 13, 40, 20 À primeira vista, parece que a primeira sequência deve ser mais fácil, pois é muito mais curta. No entanto, se você observar a segunda sequência atentamente, notará que ela segue duas regras simples: os números pares são seguidos pela sua metade e os números ímpares são seguidos pelos triplos, mais um (essa é uma sequência famosa conhecida como números de granizo ). Ao percebermos esse padrão, a segunda sequência se torna muito mais fácil de memorizar do que a primeira, porque você só precisa memorizar as duas regras, o primeiro número e a duração da sequência. Você não se importaria muito com a existência de um padrão na segunda sequência se pudesse memorizar ra-pidamente sequências muito longas, apenas aprenderia cada número de cor, e seria isso. É o fato de ser difícil memorizar sequências longas que torna útil o reconhecimento de padrões e esperamos que isso esclareça por que a restrição de um autoencoder durante o treinamento o leva a descobrir e explorar padrões nos dados. A relação entre memória, percepção e correspondência de padrões foi notoriamente estudada por William Chase e Herbert Simon no início dos anos 1970 ( https://goo. gl/ k SNc X0 )1, quando observaram que os jogadores de xadrez experientes eram capazes de memorizar as posições de todas as peças em um jogo olhando para o tabuleiro por apenas 5 segundos, uma tarefa que a maioria das pessoas consideraria impossível. No entanto, este foi o caso apenas quando as peças foram posicionadas em posições realistas (de jogos reais), não quando foram posicionadas aleatoriamente. Os especialistas em xadrez não possuem uma memória muito melhor do que você e eu, eles simplesmente enxergam mais facilmente os padrões de xadrez graças à experiência com o jogo. Observar padrões os ajuda a armazenar informações de forma eficiente. Assim como os jogadores de xadrez neste experimento de memória, um autoencoder examina as entradas, as converte em uma representação interna eficiente e, em seguida, entrega algo que (esperamos) seja muito parecido com as entradas. Um autoencoder sempre é composto de duas partes: um codificador (ou rede de reconhecimento), que converte as entradas para uma representação interna, seguido de um decodificador (ou rede geradora) que converte a representação interna para as saídas (veja a Figura 15-1). Como você pode ver, um autoencoder geralmente tem a mesma arquitetura de um Perceptron Multicamada (MLP; veja o Capítulo 10), exceto que o número de neurônios 1 “Perception in chess”, W. Chase and H. Simon (1973). CG_MIOLO_Hands_On_Machine_Learning. indb 432 07/05/2019 17:10:09

Mãos à obra Aprendizado de máquina Aurelien Geron.pdf

Executando o PCA com um Autoencoder Linear Incompleto | 433na camada de saída deve ser igual ao número de entradas. Neste exemplo, há apenas uma camada oculta composta por dois neurônios (o codificador) e uma camada de saí-da composta por três neurônios (o decodificador). As saídas geralmente são chamadas de reconstruções e a função de custo contém uma perda de reconstrução que penaliza o modelo quando as reconstruções são diferentes das entradas, já que o autoencoder tenta reconstruí-las. Saídas ( Entradas) Representação interna Entradas Decodi/f_icador Codi/f_icador Figura 15-1. O experimento de memória do xadrez (esquerda) e um autoencoder simples (direita) Dizem que o autoencoder é incompleto porque a representação interna tem uma menor dimensionalidade do que os dados de entrada (2D em vez de 3D). Um autoencoder incompleto não pode copiar trivialmente suas entradas para as codificações, mas deve encontrar uma forma de produzir uma cópia delas, portanto, ele é forçado a aprender as características mais importantes nos dados de entrada (e descartar as que não forem importantes). Vejamos como implementar um autoencoder incompleto bem simples para a redução da dimensionalidade. Executando o PCA com um Autoencoder Linear Incompleto Se o autoencoder utilizar apenas ativações lineares e a função de custo for o erro médio quadrático (MSE), então será possível mostrar que ele acaba executando a análise do componente principal (consulte o Capítulo 8). O código a seguir cria um autoencoder linear simples para a execução do PCA em um conjunto de dados 3D, projetando-o para 2D: CG_MIOLO_Hands_On_Machine_Learning. indb 433 07/05/2019 17:10:10

Mãos à obra Aprendizado de máquina Aurelien Geron.pdf

434 | Capítulo 15: Autoencodersimport tensorflow as tf n_inputs = 3 # entradas 3D n_hidden = 2 # códigos 2D n_outputs = n_inputs learning_rate = 0. 01 X = tf. placeholder(tf. float32, shape=[None, n_inputs]) hidden = tf. layers. dense(X, n_hidden) outputs = tf. layers. dense(hidden, n_outputs) reconstruction_loss = tf. reduce_mean(tf. square(outputs-X)) # MSE optimizer = tf. train. Adam Optimizer(learning_rate) training_op = optimizer. minimize(reconstruction_loss) init = tf. global_variables_initializer() Este código não é muito diferente de todos os MLPs que construímos nos capítulos anteriores. As duas coisas a notar são: O núm ero de saídas é igual ao número de entradas; Par a executar o PCA simples, não utilizamos nenhuma função de ativação (ou seja, todos os neurônios são lineares) e a função de custo é o MSE. Veremos au-toencoders mais complexos em breve. Agora vamos carregar o conjunto de dados, treinar o modelo no conjunto de treinamento e utilizá-lo para programar o conjunto de teste (ou seja, projetá-lo para 2D): X_train, X_test = [... ] # carregue o conjunto de dados n_iterations = 1000 codings = hidden # a saída das camadas ocultas fornece o código with tf. Session() as sess: init. run() for iteration in range(n_iterations): training_op. run(feed_dict={X: X_train}) # sem rótulos (não supervisionado) codings_val = codings. eval(feed_dict={X: X_test}) A Figura 15-2 mostra o conjunto de dados 3D original (à esquerda) e a saída da camada oculta do autoencoder (ou seja, a camada de codificação, à direita). Como você pode ver, o autoencoder encontrou o melhor plano 2D para projetar os dados, preservando ao máximo a variação neles (assim como o PCA). CG_MIOLO_Hands_On_Machine_Learning. indb 434 07/05/2019 17:10:10

Mãos à obra Aprendizado de máquina Aurelien Geron.pdf

Autoencoders Empilhados | 435 Conjunto de dados original 3D Projeção 2D com variância máxima Lorem ipsum Figura 15-2. PCA realizada por um autoencoder linear incompleto Autoencoders Empilhados Assim como outras redes neurais que discutimos, os autoencoders podem ter várias ca-madas ocultas, sendo chamados de autoencoders empilhados (ou autoencoders profundos ). Adicionar mais camadas ajuda o codificador automático a aprender codificações mais complexas, mas é preciso ter cuidado para não torná-lo muito poderoso. Imagine um codificador tão poderoso que aprenda a mapear cada entrada para um único número arbitrário (e o decodificador aprende o mapeamento reverso). Obviamente, tal autoencoder reconstruirá os dados de treinamento perfeitamente, mas não terá aprendido nenhuma representação útil de dados no processo (e é improvável que generalize bem para novas instâncias). A arquitetura de um autoencoder empilhado é simétrica em relação à camada oculta central (a camada de codificação), simplificando: parece um sanduíche. Por exemplo, um autoencoder do MNIST (introduzido no Capítulo 3) pode ter 784 entradas, seguidas por uma camada oculta com 300 neurônios, depois uma camada oculta central de 150 neurônios e, então, outra camada oculta com 300 neurônios e uma camada de saída com 784. Este autoencoder empilhado está representado na Figura 15-3. Reconstruções ( entradas) Codi/f_icações784 unidades 300 unidades 150 unidades 300 unidades 784 unidades Entradas Oculta 1Oculta 3Saídas Oculta 2 Figura 15-3. Autoencoder Empilhado CG_MIOLO_Hands_On_Machine_Learning. indb 435 07/05/2019 17:10:11

Mãos à obra Aprendizado de máquina Aurelien Geron.pdf

436 | Capítulo 15: Autoencoders Implementação do Tensor Flow É possível implementar um autoencoder empilhado muito parecido com um MLP profundo normal aplicando as mesmas técnicas que utilizamos no Capítulo 11 para o treinamento de redes profundas. Por exemplo, o código a seguir com a utilização da inicialização He, a função de ativação ELU e a regularização ℓ 2 cria um autoencoder empilhado para o MNIST. O código deve parecer bem familiar, porém não existem labels (sem y): from functools import partial n_inputs = 28 * 28 # para MNIST n_hidden1 = 300 n_hidden2 = 150 # códigos n_hidden3 = n_hidden1 n_outputs = n_inputs learning_rate = 0. 01 l2_reg = 0. 0001 X = tf. placeholder(tf. float32, shape=[None, n_inputs]) he_init = tf. contrib. layers. variance_scaling_initializer() l2_regularizer = tf. contrib. layers. l2_regularizer(l2_reg) my_dense_layer = partial(tf. layers. dense, activation=tf. nn. elu, kernel_initializer=he_init, kernel_regularizer=l2_regularizer) hidden1 = my_dense_layer(X, n_hidden1) hidden2 = my_dense_layer(hidden1, n_hidden2) # códigos hidden3 = my_dense_layer(hidden2, n_hidden3)outputs = my_dense_layer(hidden3, n_outputs, activation=None) reconstruction_loss = tf. reduce_mean(tf. square(outputs-X)) # MSEreg_losses = tf. get_collection(tf. Graph Keys. REGULARIZATION_LOSSES) loss = tf. add_n([reconstruction_loss] + reg_losses) optimizer = tf. train. Adam Optimizer(learning_rate) training_op = optimizer. minimize(loss) init = tf. global_variables_initializer() Você pode, então, treinar o modelo normalmente. Observe que os rótulos dos dígitos (y_batch ) não são utilizados: n_epochs = 5 batch_size = 150 with tf. Session() as sess: init. run() for epoch in range(n_epochs): CG_MIOLO_Hands_On_Machine_Learning. indb 436 07/05/2019 17:10:11

Mãos à obra Aprendizado de máquina Aurelien Geron.pdf

Autoencoders Empilhados | 437 n_batches = mnist. train. num_examples // batch_size for iteration in range(n_batches): X_batch, y_batch = mnist. train. next_batch(batch_size) sess. run(training_op, feed_dict={X: X_batch}) Amarrando Pesos Uma técnica comum é amarrar os pesos das camadas do decodificador aos pesos das camadas do codificador quando um autoencoder for nitidamente simétrico, como o que construímos, o que diminuirá pela metade o número de pesos no modelo, acelerando o treinamento e limitando o risco de sobreajuste. Especificamente, se o autoencoder tiver um total de N camadas (sem contar a camada de entrada) e WL representa os pesos de conexão da L-ésima camada (por exemplo, a camada 1 é a primeira camada oculta, camada é a camada de codificação e a camada N é a camada de saída), então os pe-sos da camada de decodificação podem ser definidos simplesmente como: WN-L +1 = WLT (com L = 1, 2, ⋯, ). Infelizmente, é um pouco incômodo implementar pesos amarrados no Tensor Flow com a utilização da função dense() ; na verdade, é mais fácil definir apenas as camadas manualmente. O código fica significativamente mais detalhado: activation = tf. nn. elu regularizer = tf. contrib. layers. l2_regularizer(l2_reg) initializer = tf. contrib. layers. variance_scaling_initializer() X = tf. placeholder(tf. float32, shape=[None, n_inputs]) weights1_init = initializer([n_inputs, n_hidden1]) weights2_init = initializer([n_hidden1, n_hidden2]) weights1 = tf. Variable(weights1_init, dtype=tf. float32, name="weights1") weights2 = tf. Variable(weights2_init, dtype=tf. float32, name="weights2") weights3 = tf. transpose(weights2, name="weights3") # pesos amarrados weights4 = tf. transpose(weights1, name="weights4") # pesos amarrados biases1 = tf. Variable(tf. zeros(n_hidden1), name="biases1") biases2 = tf. Variable(tf. zeros(n_hidden2), name="biases2") biases3 = tf. Variable(tf. zeros(n_hidden3), name="biases3") biases4 = tf. Variable(tf. zeros(n_outputs), name="biases4") hidden1 = activation(tf. matmul(X, weights1) + biases1) hidden2 = activation(tf. matmul(hidden1, weights2) + biases2) hidden3 = activation(tf. matmul(hidden2, weights3) + biases3) outputs = tf. matmul(hidden3, weights4) + biases4 reconstruction_loss = tf. reduce_mean(tf. square(outputs-X)) reg_loss = regularizer(weights1) + regularizer(weights2) loss = reconstruction_loss + reg_loss optimizer = tf. train. Adam Optimizer(learning_rate) CG_MIOLO_Hands_On_Machine_Learning. indb 437 07/05/2019 17:10:12

Mãos à obra Aprendizado de máquina Aurelien Geron.pdf

438 | Capítulo 15: Autoencoderstraining_op = optimizer. minimize(loss) init = tf. global_variables_initializer() Este código é bastante simples, mas há algumas coisas importantes a serem observadas: Primeiro, weight3 e weights4 não são variáveis, são a transposição de weights2 e weights1 (eles estão “amarrados” a eles), respectivamente; Segundo, como não são variáveis, não adianta regularizá-las: só regularizamos weights1 e weights2 ; Terceiro, vieses nunca são amarrados, e nunca regularizados. Treinando um Autoencoder por Vez Em vez de treinar todo o autoencoder empilhado de uma só vez, como fizemos, é muito mais rápido treinar um autoencoder raso de cada vez e depois empilhá-los em um único autoencoder empilhado (daí o nome), como mostrado na Figura 15-4. Isto é especialmente útil para autoencoders muito profundos. Saídas Saídas Oculta 1Oculta 3 Oculta 2 Oculta 1Oculta 3 Oculta 2 Oculta 1Oculto 1 Entradas Entradas Copie os parâmetros Entradas Fase 1 Fase 2 Fase 3 Empilhe os autoencoders Treine o segundo autoencoder Treine o primeiro autoencoder Figura 15-4. Treinando um autoencoder por vez Durante a primeira fase do treinamento, o primeiro autoencoder aprende a reconstruir as entradas, já na fase seguinte, o segundo autoencoder aprende a reconstruir a saída da camada oculta do primeiro autoencoder. Finalmente, como mostrado na Figura 15-4, você constrói um grande sanduíche utilizando todos esses autoencoders (ou seja, você primeiro empilha as camadas ocultas de cada autoencoder e, em seguida, as camadas de saída na ordem inversa), o que lhe fornecerá o autoencoder final empilhado. Crian-do um autoencoder empilhado muito profundo, você poderia facilmente treinar mais autoencoders dessa maneira. CG_MIOLO_Hands_On_Machine_Learning. indb 438 07/05/2019 17:10:12

Mãos à obra Aprendizado de máquina Aurelien Geron.pdf

Autoencoders Empilhados | 439A abordagem mais simples para implementar este algoritmo de treinamento multifásico seria a utilização de um grafo diferente do Tensor Flow para cada fase. Depois de treinar um autoencoder, basta executar o conjunto de treinamento e capturar a saída da camada oculta, que serve como o conjunto de treinamento para o próximo autoencoder. Após todos os autoencoders terem sido treinados dessa maneira, você copiará os pesos e os vieses de cada um e os utilizará para criar o autoencoder empilhado. A implementação desta abordagem é bem simples, por isso não a detalhamos aqui, mas, para ver um exemplo, confira o código nos notebooks do Jupyter (https://github. com/ageron/handson-ml). Outra abordagem, como mostrado na Figura 15-5, seria utilizar um único grafo con-tendo o autoencoder todo empilhado, além de algumas operações extras para executar cada fase de treinamento. Entradas Oculta 1Oculta 3 Oculta 2Saídas Fase 1 Saídas MSE (Saídas-Entradas)Fase 1 Treinando OPFase 2 Treinando OP MSE (Oculta 3-Oculta 1) Parâmetros Fixos durante a fase 2Mesmos parâmetro s Figura 15-5. Um único grafo para treinar um autoencoder empilhado Isto merece uma explicação: A col una central no grafo é o autoencoder totalmente empilhado, parte que pode ser utilizada após o treinamento; A col una da esquerda é o conjunto de operações necessário para executar a pri-meira fase do treinamento. Ela cria uma camada de saída que ultrapassa as ca-madas ocultas 2 e 3, e compartilha os mesmos pesos e vieses da camada de saída do autoencoder empilhado. Além disso, elas são as operações de treinamento que visam aproximar ao máximo a saída das entradas. Assim, esta fase treinará os pesos e vieses para a camada oculta 1 e a camada de saída (ou seja, o primeiro autoencoder); CG_MIOLO_Hands_On_Machine_Learning. indb 439 07/05/2019 17:10:13

Mãos à obra Aprendizado de máquina Aurelien Geron.pdf

440 | Capítulo 15: Autoencoders A coluna da direita no grafo é o conjunto de operações necessário para executar a se gunda fase do treinamento. Ela adiciona a operação de treinamento que terá como objetivo de aproximar ao máximo a saída da camada oculta 3 da saída da camada oculta 1. Observe que devemos congelar a camada oculta 1 durante a fase 2, que treinará os pesos e vieses para as camadas ocultas 2 e 3 (ou seja, o segundo autoencoder). O código do Tensor Flow é assim: [... ] # Construa todo o autoencoder empilhado normalmente # Neste exemplo, os pesos não estão amarrados optimizer = tf. train. Adam Optimizer(learning_rate)with tf. name_scope("phase1"): phase1_outputs = tf. matmul(hidden1, weights4) + biases4 phase1_reconstruction_loss = tf. reduce_mean(tf. square(phase1_outputs-X)) phase1_reg_loss = regularizer(weights1) + regularizer(weights4) phase1_loss = phase1_reconstruction_loss + phase1_reg_loss phase1_training_op = optimizer. minimize(phase1_loss) with tf. name_scope("phase2"): phase2_reconstruction_loss = tf. reduce_mean(tf. square(hidden3-hidden1)) phase2_reg_loss = regularizer(weights2) + regularizer(weights3) phase2_loss = phase2_reconstruction_loss + phase2_reg_loss train_vars = [weights2, biases2, weights3, biases3] phase2_training_op = optimizer. minimize(phase2_loss, var_list=train_vars) A primeira fase é bastante direta: apenas criamos uma camada de saída que pula as ca-madas ocultas 2 e 3, depois construímos as operações de treinamento para minimizar a distância entre as saídas e as entradas (mais alguma regularização). A segunda fase apenas adiciona as operações necessárias para minimizar a distância entre a saída da camada oculta 3 e a camada oculta 1 (também com alguma regula-rização). Mais importante, deixando de fora weights1 e biases1, fornecemos a lista de variáveis treináveis para o método minimize() ; efetivamente congelando a camada oculta 1 durante a fase 2. Durante a fase de execução, você só precisa executar o treinamento da fase 1 para um número de épocas, depois o treinamento de fase 2 para mais algumas épocas. Como a camada oculta 1 é congelada durante a fase 2, sua saída sem-pre será a mesma para qualquer instância de treinamento. Para evitar recalcular a saída da camada oculta 1 em cada época, você pode cal-culá-la para todo o conjunto de treinamento no final da fase 1 e, em seguida, alimentar diretamente a saída em cache da camada oculta 1 durante a fase 2, resultando em um bom aumento de desempenho. CG_MIOLO_Hands_On_Machine_Learning. indb 440 07/05/2019 17:10:13

Mãos à obra Aprendizado de máquina Aurelien Geron.pdf

Autoencoders Empilhados | 44 1Visualizando as Reconstruções Comparar as entradas e as saídas é uma forma de garantir que um autoencoder seja adequadamente treinado. Elas devem ser bem semelhantes e as diferenças devem ser detalhes sem importância. Plotaremos dois dígitos aleatórios e suas reconstruções: n_test_digits = 2 X_test = mnist. test. images[:n_test_digits] with tf. Session() as sess: [... ] # Treine o Autoencoder outputs_val = outputs. eval(feed_dict={X: X_test}) def plot_image(image, shape=[28, 28]): plt. imshow(image. reshape(shape), cmap="Greys", interpolation="nearest") plt. axis("off") for digit_index in range(n_test_digits): plt. subplot(n_test_digits, 2, digit_index * 2 + 1) plot_image(X_test[digit_index]) plt. subplot(n_test_digits, 2, digit_index * 2 + 2) plot_image(outputs_val[digit_index]) A Figura 15-6 mostra as imagens resultantes. Figura 15-6. Dígitos Originais (esquerda) e suas reconstruções (direita) Parece perto o suficiente. Portanto, o autoencoder aprendeu adequadamente a reproduzir suas entradas, mas será que aprendeu características úteis? Vejamos. Visualizando as Características Uma vez que seu autoencoder tenha aprendido algumas características, convém observá-las e existem várias técnicas para isso. Indiscutivelmente, mais simples delas é considerar cada neurônio em cada camada oculta e encontrar as instâncias de treinamento que mais o ativam, o que é especialmente útil para as camadas ocultas superiores, pois elas geral-CG_MIOLO_Hands_On_Machine_Learning. indb 441 07/05/2019 17:10:13

Mãos à obra Aprendizado de máquina Aurelien Geron.pdf

442 | Capítulo 15: Autoencodersmente capturam características relativamente grandes que você identifica facilmente em um grupo de instâncias de treinamento que as contêm. Por exemplo, se um neurônio se ativar quando vir um gato em uma foto, será bastante óbvio que as imagens que mais o ativam contêm gatos. No entanto, para as camadas inferiores, essa técnica não funciona tão bem, pois as características são menores e mais abstratas. Por isso, muitas vezes é difícil entender exatamente o porquê de o neurônio estar se animando. Veremos outra técnica. Para cada neurônio na primeira camada oculta é possível criar uma imagem cuja intensidade de um pixel corresponde ao peso da conexão com o mesmo neurônio. Por exemplo, o código a seguir mapeia as características aprendidas por cinco neurônios na primeira camada oculta: with tf. Session() as sess: [... ] # treine o autoencoder weights1_val = weights1. eval() for i in range(5): plt. subplot(1, 5, i + 1) plot_image(weights1_val. T[i]) Você pode obter características de baixo nível, como as mostradas na Figura 15-7. Figura 15-7. Características aprendidas por cinco neurônios da primeira camada oculta As primeiras quatro características parecem corresponder a pequenos patches, enquanto a quinta característica parece procurar por traços verticais (observe que essas características vêm de autoencoders de remoção de ruídos empilhados que discutiremos mais adiante). Outra técnica seria alimentar o autoencoder com uma imagem aleatória de entrada, medir a ativação do neurônio em que você está interessado e, em seguida, realizar a retropropagação para ajustar a imagem de tal forma que o neurônio seja ativado ain-da mais. A imagem gradualmente se transformará na imagem mais excitante (para o neurônio) se você iterar várias vezes (realizando a subida do gradiente), uma técnica útil para visualização dos tipos de entradas buscadas por um neurônio. Finalmente, se você estiver utilizando um autoencoder para executar pré-treinamento não supervisionado, por exemplo, para uma tarefa de classificação, medir o desempenho do classificador é uma forma simples de verificar se as características aprendidas pelo autoencoder são úteis. CG_MIOLO_Hands_On_Machine_Learning. indb 442 07/05/2019 17:10:13

Mãos à obra Aprendizado de máquina Aurelien Geron.pdf

Pré-treinamento Não Supervisionado Utilizando Autoencoders Empilhados | 443Pré-treinamento Não Supervisionado Utilizando Autoencoders Empilhados Como discutimos no Capítulo 11, se você estiver lidando com uma tarefa supervisionada complexa, mas não tiver muitos dados rotulados de treinamento, uma solução seria en-contrar uma rede neural que execute uma tarefa semelhante e, em seguida, reutilizar suas camadas inferiores. Isto possibilita treinar um modelo de alto desempenho utilizando apenas pequenos dados de treinamento porque sua rede neural não precisa aprender todas as características de baixo nível, apenas reutilizará os detectores das características aprendidos pela rede existente. Da mesma forma, se você tiver um grande conjunto de dados, mas com a maioria sem rótulos, você pode primeiro treinar um autoenconder empilhado e, então, reutilizar as camadas inferiores para criar uma rede neural para sua tarefa atual e treiná-la com a atualização dos dados rotulados. Por exemplo, a Figura 15-8 mostra como utilizar um autoencoder empilhado para executar pré-treinamento não supervisionado para uma rede neural de classificação. Conforme discutido anteriormente, o próprio autoencoder empilhado é treinado em um autoencoder de cada vez. Se você realmente não tiver muitos dados de treinamento rotulados ao treinar o classificador, convém congelar as camadas pré-treinadas (pelo menos as inferiores). Entradas Oculta 1Oculta 3 Oculta 2Saídas Oculta 1Oculta 2 Entradas Entradas Rótulos Softmax FC Fase 1 Fase 2 Treine o autoencoder utilizando todos os dados Treine o classi/f_icador nos dados *rotulados* Parâmetros de cópia Figura 15-8. Pré-treinamento não supervisionado utilizando autoencoders CG_MIOLO_Hands_On_Machine_Learning. indb 443 07/05/2019 17:10:14

Mãos à obra Aprendizado de máquina Aurelien Geron.pdf

444 | Capítulo 15: Autoencoders Essa situação é bastante comum porque a construção de um grande conjunto de dados não rotulados geralmente é barata (por exemplo, um simples script pode baixar milhões de imagens da internet), mas rotulá-las só poderia ser feito de forma confiável por humanos (por exemplo, classificar imagens como bonitas ou não). As instâncias de rotulagem consomem muito tempo e são caras, por isso é muito comum ter apenas algumas milhares de instâncias rotuladas. Como discutimos anteriormente, a descoberta feita em 2006 por Geoffrey Hinton et al. de que as redes neurais profundas podem ser pré-treinadas de maneira não supervisio-nada é um dos desencadeadores do atual tsunami do Aprendizado Profundo. Para isso, eles utilizaram máquinas restritas de Boltzmann (consulte o apêndice E), mas, em 2007, Yoshua Bengio et al. ( https://goo. gl/R5L7HJ )2 mostraram que os autoencoders também funcionavam nesse caso. Não há nada de especial sobre a implementação do Tensor Flow: para criar uma nova rede neural, apenas treine um autoencoder utilizando todos os dados de treinamento e reutilize suas camadas do codificador (consulte o Capítulo 11 para obter mais detalhes sobre como reutilizar camadas pré-treinadas ou consulte os exemplos de código nos notebooks do Jupyter). Até agora, limitamos o tamanho da camada de codificação tornando-a incompleta para forçar o autoencoder a aprender características interessantes. Na verdade, existem muitos outros tipos de restrições que podem ser utilizados, incluindo aquelas que permitem que a camada de codificação seja do tamanho das entradas, ou até maiores, resultando em um autoencoder supercompleto. Veremos algumas dessas abordagens agora. Autoencoders de Remoção de Ruídos Outra maneira de forçar o autoencoder a aprender características úteis é adicionar ruído às suas entradas, treinando-o para recuperar as entradas originais sem ruído, impedindo que o autoencoder copie suas entradas para suas saídas e acabe forçado a encontrar padrões nos dados. A ideia de utilizar autoencoders para remover o ruído existe desde os anos 1980 (por exemplo, é mencionada na tese de mestrado de Yann Le Cun em 1987). Em um artigo de 2008 ( https://goo. gl/K9pqcx ), 3 Pascal Vincent et al. demonstraram que autoencoders também podiam ser utilizados para a extração de características. Em um artigo de 2 “Greedy Layer-Wise Training of Deep Networks,” Y. Bengio et al. (2007). 3 “Ex tracting and Composing Robust Features with Denoising Autoencoders”, P. Vincent et al. (2008)“ CG_MIOLO_Hands_On_Machine_Learning. indb 444 07/05/2019 17:10:14

Mãos à obra Aprendizado de máquina Aurelien Geron.pdf

Autoencoders de Remoção de Ruídos | 4452010 ( https://goo. gl/Hg CDIA ),4 Vincent et al. introduziram os autoencoders de remoção de barulho empilhados. O ruído pode ser puro ruído Gaussiano adicionado às entradas ou pode ser desligado aleatoriamente, assim como no dropout (introduzido no Capítulo 11). A Figura 15-9 mostra as duas opções. Entradas Oculta 1Oculta 3 Oculta 2 Oculta 1Oculta 3 Oculta 2Saídas Saídas Entradas Entradas Entradas Dropout Ruído Gaussiano Figura 15-9. Autoencoders de Remoção de Ruído, com ruído Gaussiano (esquerda) ou dropout (direita) Implementando o Tensor Flow A implementação de autoencoders de remoção de ruídos no Tensor Flow não é muito difícil e começaremos com o ruído gaussiano. É como treinar um autoencoder regular, mas você adiciona ruído às entradas e a perda de reconstrução é calculada com base nas entradas originais: noise_level = 1. 0 X = tf. placeholder(tf. float32, shape=[None, n_inputs]) X_noisy = X + noise_level * tf. random_normal(tf. shape(X)) hidden1 = tf. layers. dense(X_noisy, n_hidden1, activation=tf. nn. relu, name="hidden1") [... ]reconstruction_loss = tf. reduce_mean(tf. square(outputs-X)) # MSE [... ] 4 “Stacked Denoising Autoencoders: Learning Useful Representations in a Deep Network with a Local Denoising Criterion”, P. Vincent et al. (2010). CG_MIOLO_Hands_On_Machine_Learning. indb 445 07/05/2019 17:10:15

Mãos à obra Aprendizado de máquina Aurelien Geron.pdf

446 | Capítulo 15: Autoencoders Como a forma de X é apenas parcialmente definida durante a fase de construção, não podemos saber antecipadamente a for-ma do ruído que devemos adicionar a X. Nós não podemos recorrer a X. get_shape() porque isso apenas retornaria a forma parcialmen-te definida de X ([None, n_inputs] ), e random_normal() espera uma forma totalmente definida para que possa gerar uma exceção. Em vez disso, chamamos tf. shape(X), que cria uma operação que retornará a forma de X em tempo de execução, que será totalmente definida nesse ponto. Não é difícil implementar a versão dropout, que é a mais comum: dropout_rate = 0. 3 training = tf. placeholder_with_default(False, shape=(), name='training')X = tf. placeholder(tf. float32, shape=[None, n_inputs]) X_drop = tf. layers. dropout(X, dropout_rate, training=training) hidden1 = tf. layers. dense(X_drop, n_hidden1, activation=tf. nn. relu, name="hidden1")[... ] reconstruction_loss = tf. reduce_mean(tf. square(outputs-X)) # MSE [... ] Durante o treinamento, devemos configurar training para True (como explicado no Capítulo 11) utilizando o feed_dict : sess. run(training_op, feed_dict={X: X_batch, training: True}) Durante o teste, não é necessário configurar training para False, já que definimos isto como padrão na chamada para a função placeholder_with_default(). Autoencoders Esparsos Outro tipo de restrição que muitas vezes leva a uma boa extração de características é a esparsidade: ao adicionar um termo apropriado à função de custo, o autoencoder é pressionado a reduzir o número de neurônios ativos na camada de codificação. Por exemplo, ele pode ser forçado a ter, em média, apenas 5% de neurônios significativa-mente ativos na camada de codificação, forçando o autoencoder a representar cada entrada como uma combinação de um pequeno número de ativações. Como resultado, cada neurônio na camada de codificação acaba representando uma característica útil (se você só pudesse falar algumas palavras por mês, provavelmente tentaria fazê-las dignas de serem ouvidas). CG_MIOLO_Hands_On_Machine_Learning. indb 446 07/05/2019 17:10:15

Mãos à obra Aprendizado de máquina Aurelien Geron.pdf

Autoencoders Esparsos | 447Devemos primeiro medir a dispersão real da camada de codificação em cada iteração de treinamento para favorecer modelos esparsos, o que pode ser feito por meio do cálculo da ativação média de cada neurônio na camada de codificação durante todo o lote de treinamento cujo tamanho não deve ser muito pequeno ou a média não será precisa. Uma vez que temos a ativação média por neurônio, queremos penalizar aqueles que estão muito ativos com a adição de uma perda de esparsidade à função de custo. Por exemplo, se medirmos que um neurônio tem uma ativação média de 0,3, mas a esparsidade alvo é 0,1, ele deve ser penalizado para ativar menos. Uma abordagem poderia ser adicionar o erro ao quadrado (0,3-0,1)2 à função de custo, mas, na prática, como é possível ver na Figura 15-10, uma abordagem melhor seria utilizar a divergência de Kullback-Leibler (brevemente discutida no Capítulo 4) que tem gradientes muito mais fortes do que o erro médio quadrático. Divergência KL MSE Esparsidade Custo Esparsidade realalvo Figura 15-10. Perda de esparsidade Dadas duas distribuições de probabilidade discretas P e Q e utilizando a Equação 15-1 a divergência KL entre essas distribuições, descrita DKL(P ∥ Q), pode ser calculada. Equação 15-1. Divergência Kullback-Leibler DKLPQ=∑ i Pilog Pi Qi No nosso caso, queremos medir a divergência entre a probabilidade alvo p de que um neurônio ativará na camada de codificação e a probabilidade real q (isto é, a ativação média sobre o lote de treinamento). Então a divergência KL simplifica para a Equação 15-2. CG_MIOLO_Hands_On_Machine_Learning. indb 447 07/05/2019 17:10:16

Mãos à obra Aprendizado de máquina Aurelien Geron.pdf

448 | Capítulo 15: Autoencoders Equação 15-2. Divergência KL entre a esparsidade alvo p e a esparsidade real q DKLpq=plogp q+1-plog1-p 1-q Depois de calcularmos a perda de esparsidade para cada neurônio na camada de codi-ficação, resumimos essas perdas e adicionamos o resultado à função de custo. A fim de controlar a importância relativa da perda de esparsidade e da perda de reconstrução, podemos multiplicar a perda da esparsidade por um hiperparâmetro de peso da espar-sidade. Se esse peso for muito alto, o modelo permanecerá próximo à esparsidade do alvo, mas poderá não reconstruir as entradas corretamente, tornando o modelo inútil. Por outro lado, se for muito baixo, o modelo ignorará principalmente o objetivo da esparsidade e não aprenderá nenhuma característica interessante. Implementando no Tensor Flow Agora, temos tudo que precisamos para implementar um autoencoder esparso utilizando o Tensor Flow: def kl_divergence(p, q): return p * tf. log(p / q) + (1-p) * tf. log((1-p) / (1-q)) learning_rate = 0. 01 sparsity_target = 0. 1 sparsity_weight = 0. 2 [... ] # Construa um autoencoder normal (neste exemplo, a camada de código está escondida) hidden1_mean = tf. reduce_mean(hidden1, axis=0) # batch mean sparsity_loss = tf. reduce_sum(kl_divergence(sparsity_target, hidden1_mean))reconstruction_loss = tf. reduce_mean(tf. square(outputs-X)) # MSEloss = reconstruction_loss + sparsity_weight * sparsity_loss optimizer = tf. train. Adam Optimizer(learning_rate) training_op = optimizer. minimize(loss) Um detalhe importante é o fato de que as ativações da camada de codificação devem estar entre 0 e 1 (mas não iguais a 0 ou 1) ou, então, a divergência KL retornará Na N (Not a Number ). Uma solução simples é utilizar a função de ativação logística para a camada de codificação: hidden1 = tf. layers. dense(X, n_hidden1, activation=tf. nn. sigmoid) Um truque simples pode acelerar a convergência: em vez de usar o MSE, podemos escolher uma perda de reconstrução que terá gradientes maiores. A entropia cruzada geralmente é uma boa escolha e, para utilizá-la, devemos normalizar as entradas para fazê-las assumir valores de 0 a 1 e utilizar a função de ativação logística na camada de saída para que as elas também assumam valores de 0 a 1. A função do Tensor Flow CG_MIOLO_Hands_On_Machine_Learning. indb 448 07/05/2019 17:10:16

Mãos à obra Aprendizado de máquina Aurelien Geron.pdf

Autoencoders Variacionais | 44 9sigmoid_cross_entropy_with_logits() cuida de aplicar eficientemente a função de ativação logística (sigmoide) às saídas e calcular a entropia cruzada: [... ] logits = tf. layers. dense(hidden1, n_outputs) outputs = tf. nn. sigmoid(logits) xentropy = tf. nn. sigmoid_cross_entropy_with_logits(labels=X, logits=logits) reconstruction_loss = tf. reduce_sum(xentropy) Observe que a operação outputs não é necessária durante o treinamento (só a usamos quando queremos examinar as reconstruções). Autoencoders Variacionais Outra importante categoria de autoencoders foi introduzida em 2014 ( https://goo. gl/ NZq7r2 ) por Diederik Kingma e Max Welling5 e rapidamente se tornou um dos tipos mais populares: autoencoders variacionais. Eles são bem diferentes de todos os autoencoders que discutimos até agora, em particular: São autoencoders probabilísticos, o que significa que suas saídas são parcialmen-te determinadas pelo acaso, mesmo após o treinamento (ao contrário dos au-toencoders de remoção de ruídos que utilizam a aleatoriedade apenas durante o treinamento); Mai s importante, eles são autoencoders geradores, o que significa que podem gerar novas instâncias que parecem ter sido amostradas a partir do conjunto de treinamento. Ambas as propriedades os tornam bastante semelhantes às RBMs (consulte o Apêndice E), mas é fácil treiná-los e o processo de amostragem é muito mais rápido (com os RBMs você precisa esperar que a rede se estabilize em um “equilíbrio térmico” antes de poder amostrar uma nova instância). Daremos uma olhada em como eles funcionam. A Figura 15-11 (esquerda) mostra um autoencoder variacional. Você pode reconhecer, é claro, a estrutura básica de todos os autoencoders, com um codificador seguido por um decodificador (neste exemplo, ambos têm duas camadas ocultas), mas há uma alteração nesse caso: em vez de produzir direta-mente uma codificação para uma dada entrada, o codificador produz uma codificação média μ e um desvio padrão σ. A codificação atual é, então, amostrada aleatoriamente a 5 “Auto-Encoding Variation”, Bayes, D. Kingma and M. Welling (2014). CG_MIOLO_Hands_On_Machine_Learning. indb 449 07/05/2019 17:10:16

Mãos à obra Aprendizado de máquina Aurelien Geron.pdf

450 | Capítulo 15: Autoencoderspartir de uma distribuição Gaussiana, com média μ e um desvio padrão σ. Depois disso, o decodificador apenas decodifica normalmente a codificação da amostra. A parte di-reita do diagrama mostra uma instância de treinamento passando por esse autoencoder. Primeiro, o codificador produz μ e σ, então uma codificação é amostrada aleatoriamente (observe que ela não está exatamente localizada em μ) e, finalmente, essa codificação é decodificada e a saída final se assemelha à instância de treinamento. Oculta 1Oculta 2Oculta 4Oculta 5Entradas Saídas Entradas Espaço de entrada Espaço de codi/f_icação Ruído Gaussiano Codi/f_icações Codi/f_icações Figura 15-11. Autoencoder Variacional (esquerda) e uma instância passando por ele (direita) Como pode ser visto no diagrama, embora as entradas possam ter uma distribuição muito complicada, um autoencoder variacional tende a produzir codificações que pa-recem ter sido amostradas a partir de uma distribuição Gaussiana simples:6 a função de custo (discutida a seguir) empurra as codificações para migrar gradualmente dentro do espaço de codificação durante o treinamento (também chamado de espaço latente ), para ocupar uma região aproximadamente (hiper) esférica que se parece com uma nuvem de pontos gaussianos. Uma grande consequência é que, após o treinamento de um autoen-coder variacional, é possível gerar facilmente uma nova instância: basta amostrar uma codificação aleatória da distribuição gaussiana, decodificá-la e, voilà ! Então, observaremos a função de custo, que é composta de duas partes. A primeira é a perda de reconstrução usual que empurra o autoencoder para reproduzir suas entradas (podemos utilizar entropia cruzada para isso, conforme discutido anteriormente). A segunda é a perda 6 Os autoencoders va riacionais são, na verdade, mais gerais; as codificações não estão limitadas a distribuições gaussianas. CG_MIOLO_Hands_On_Machine_Learning. indb 450 07/05/2019 17:10:17

Mãos à obra Aprendizado de máquina Aurelien Geron.pdf

Autoencoders Variacionais | 451latente que faz com que o autoencoder tenha codificações que parecem ter sido amostradas a partir de uma distribuição Gaussiana simples, para a qual utilizamos a divergência KL entre a distribuição de destino (a distribuição Gaussiana) e a distribuição real das codificações. A matemática é um pouco mais complexa do que antes, principalmente por causa do ruído Gaussiano que limita a quantidade de informação que pode ser transmitida à camada de codificação (empurrando assim o autoencoder para aprender características úteis). Feliz-mente, as equações simplificam o código a seguir para a perda latente:7 eps = 1e-10 # suavizar termo para evitar computar log(0) que é Na N latent_loss = 0. 5 * tf. reduce_sum( tf. square(hidden3_sigma) + tf. square(hidden3_mean) -1-tf. log(eps + tf. square(hidden3_sigma))) Treinar o codificador para exibir γ = log( σ2) em vez de σ é uma variante comum. Onde quer que precisemos de σ, podemos apenas calcular σ = exp , facilitando a captura de sigmas de diferentes escalas pelo codificador, e assim ajudando a acelerar a convergência. A perda latente é um pouco mais simples: latent_loss = 0. 5 * tf. reduce_sum( tf. exp(hidden3_gamma) + tf. square(hidden3_mean)-1-hidden3_gamma) O código a seguir constrói o autoencoder variacional mostrado na Figura 15-11 (esquerda) utilizando a variante log( σ2): from functools import partial n_inputs = 28 * 28 n_hidden1 = 500 n_hidden2 = 500 n_hidden3 = 20 # codings n_hidden4 = n_hidden2 n_hidden5 = n_hidden1 n_outputs = n_inputs learning_rate = 0. 001 initializer = tf. contrib. layers. variance_scaling_initializer() my_dense_layer = partial( tf. layers. dense, activation=tf. nn. elu, kernel_initializer=initializer) X = tf. placeholder(tf. float32, [None, n_inputs]) hidden1 = my_dense_layer(X, n_hidden1) hidden2 = my_dense_layer(hidden1, n_hidden2) hidden3_mean = my_dense_layer(hidden2, n_hidden3, activation=None) hidden3_gamma = my_dense_layer(hidden2, n_hidden3, activation=None) noise = tf. random_normal(tf. shape(hidden3_gamma), dtype=tf. float32) hidden3 = hidden3_mean + tf. exp(0. 5 * hidden3_gamma) * noise hidden4 = my_dense_layer(hidden3, n_hidden4) hidden5 = my_dense_layer(hidden4, n_hidden5) logits = my_dense_layer(hidden5, n_outputs, activation=None) outputs = tf. sigmoid(logits)7 Para mais detalhes matemáticos, confira o artigo original sobre autoencoders variacionais, ou o ótimo tutorial de Carl Doersch ( https://goo. gl/Vii Az Q ) (2016). CG_MIOLO_Hands_On_Machine_Learning. indb 451 07/05/2019 17:10:17

Mãos à obra Aprendizado de máquina Aurelien Geron.pdf

452 | Capítulo 15: Autoencodersfrom functools import partial n_inputs = 28 * 28 n_hidden1 = 500 n_hidden2 = 500 n_hidden3 = 20 # codings n_hidden4 = n_hidden2 n_hidden5 = n_hidden1 n_outputs = n_inputs learning_rate = 0. 001 initializer = tf. contrib. layers. variance_scaling_initializer() my_dense_layer = partial( tf. layers. dense, activation=tf. nn. elu, kernel_initializer=initializer) X = tf. placeholder(tf. float32, [None, n_inputs]) hidden1 = my_dense_layer(X, n_hidden1) hidden2 = my_dense_layer(hidden1, n_hidden2) hidden3_mean = my_dense_layer(hidden2, n_hidden3, activation=None) hidden3_gamma = my_dense_layer(hidden2, n_hidden3, activation=None)noise = tf. random_normal(tf. shape(hidden3_gamma), dtype=tf. float32)hidden3 = hidden3_mean + tf. exp(0. 5 * hidden3_gamma) * noise hidden4 = my_dense_layer(hidden3, n_hidden4) hidden5 = my_dense_layer(hidden4, n_hidden5)logits = my_dense_layer(hidden5, n_outputs, activation=None)outputs = tf. sigmoid(logits) xentropy = tf. nn. sigmoid_cross_entropy_with_logits(labels=X, logits=logits) reconstruction_loss = tf. reduce_sum(xentropy) latent_loss = 0. 5 * tf. reduce_sum( tf. exp(hidden3_gamma) + tf. square(hidden3_mean)-1-hidden3_gamma) loss = reconstruction_loss + latent_loss optimizer = tf. train. Adam Optimizer(learning_rate=learning_rate) training_op = optimizer. minimize(loss) init = tf. global_variables_initializer() saver = tf. train. Saver() Gerando Dígitos Agora utilizaremos esse autoencoder variacional para gerar imagens que parecem com dígitos manuscritos. Precisamos apenas treinar o modelo, amostrar códigos aleatórios de uma distribuição Gaussiana e decodificá-los. import numpy as np n_digits = 60 n_epochs = 50 batch_size = 150 with tf. Session() as sess: init. run() for epoch in range(n_epochs): n_batches = mnist. train. num_examples // batch_size for iteration in range(n_batches): X_batch, y_batch = mnist. train. next_batch(batch_size) sess. run(training_op, feed_dict={X: X_batch}) codings_rnd = np. random. normal(size=[n_digits, n_hidden3]) outputs_val = outputs. eval(feed_dict={hidden3: codings_rnd}) É isso aí. Agora podemos ver como são os dígitos “manuscritos” produzidos pelo autoencoder (veja a Figura 15-12): for iteration in range(n_digits): plt. subplot(n_digits, 10, iteration + 1) plot_image(outputs_val[iteration]) CG_MIOLO_Hands_On_Machine_Learning. indb 452 07/05/2019 17:10:18

Mãos à obra Aprendizado de máquina Aurelien Geron.pdf

Outros Autoencoders | 45 3 Figura 15-12. Imagens de dígitos manuscritos gerados pelo autoencoder variacional Enquanto alguns são bastante “criativos”, a maioria desses dígitos parece bastante convincente. Mas não seja muito duro com o autoencoder, pois ele começou a aprender menos de uma hora atrás. Dê um pouco mais de tempo de treinamento a ele e esses dígitos ficarão cada vez melhores. Outros Autoencoders O incrível sucesso do aprendizado supervisionado ofuscou o aprendizado não supervisio-nado em reconhecimento de imagem, reconhecimento de voz, tradução de texto e muito mais, mas, na verdade, ele ainda está crescendo. Novas arquiteturas para autoencoders e outros algoritmos de aprendizado não supervisionados são inventadas regularmente, tanto que não conseguiremos abordar todas neste livro. Segue uma breve (não exaus-tiva) visão geral de mais alguns tipos de autoencoders que você talvez queira verificar: Contractive autoencoder (CAE) (https://goo. gl/U5t9Ux) 8 O autoencoder é restringido durante o treinamento para que as derivadas das codificações com relação às entradas sejam pequenas. Em outras palavras, duas entradas semelhantes devem ter codificações semelhantes. 8 “Contractive Auto-Encoders: Explicit Invariance During ”feature Extraction, S. Rifai et al. (2011). CG_MIOLO_Hands_On_Machine_Learning. indb 453 07/05/2019 17:10:18

Mãos à obra Aprendizado de máquina Aurelien Geron.pdf

454 | Capítulo 15: Autoencoders Stacked convolutional autoencoders (https://goo. gl/PTwsol)9 Autoencoders que aprendem a extrair recursos visuais reconstruindo imagens processadas por meio de camadas convolucionais. Generative stochastic network (GSN) (https://goo. gl/Hj ON1m)10 Uma generalização de autoencoders de remoção de ruídos, com a capacidade adicional de gerar dados. Winner-take-all (WTA) autoencoder (https://goo. gl/I1Lvz L)11 Após calcular as ativações de todos os neurônios na camada de codificação du-rante o treinamento, são preservadas apenas as ativações de k % superiores para cada neurônio sobre o lote de treinamento, e o restante é definido como zero, naturalmente, levando a codificações esparsas. Além disso, pode ser utilizada uma abordagem WTA semelhante para produzir autoencoders convolucionais esparsos. Generative Adversarial Network (GAN) (https://goo. gl/qd4Rhn)12 Uma rede chamada “discriminadora” é treinada para distinguir dados reais de dados falsos produzidos por uma segunda rede chamada “geradora”. A geradora aprende a enganar a discriminadora, enquanto a discriminadora aprende a evitar os truques da geradora. Esta competição leva a dados falsificados cada vez mais realistas e codificações muito robustas. Treinamento adversário é uma ideia muito poderosa que vem ganhando impulso. Yann Lecun chegou a chamá-lo de “a coisa mais legal desde o pão fatiado”. Exercícios 1. Quais são as principais tarefas realizadas pelos autoencoders? 2. Sup onha que você queira treinar um classificador e tenha muitos dados de treina-mento não rotulados e apenas algumas milhares de instâncias rotuladas. Como os autoencoders podem ajudar? Como você procederia? 3. Se um a utoencoder reconstrói perfeitamente as entradas, ele é necessaria-mente um bom autoencoder? Como você pode avaliar o desempenho de um autoencoder? 9 “Stacked Convolutional Auto-Encoders for Hierarchical ”feature Extraction, J. Masci et al. (2011). 10 “GS Ns: Generative Stochastic Networks”, G. Alain et al. (2015). 11 “Wi nner-Tak-All Autoencoders”, A. Makhzani and B. Frey (2015). 12 “Ge nerative Adevrsarial Networks”, I. Goodfellow et al. (2014). CG_MIOLO_Hands_On_Machine_Learning. indb 454 07/05/2019 17:10:18

Mãos à obra Aprendizado de máquina Aurelien Geron.pdf

Exercícios | 4554. O que são autoencoders incompletos e supercompletos? Qual é o principal risco de um a utoencoder excessivamente incompleto? E quanto ao principal risco de um autoencoder supercompleto? 5. Com o você amarra pesos em um autoencoder empilhado? Qual é o sentido de se fazer isso? 6. Qua l é a técnica comum para visualizar as características aprendidas pela camada inferior de um autoencoder empilhado? E quanto às camadas superiores? 7. O que é u m modelo gerador? Você pode nomear um tipo de autoencoder gerador? 8. Uti lizaremos um autoencoder de remoção de ruído para pré-treinar um classificador de imagens: Voc ê pode utilizar o MNIST (mais simples) ou outro grande conjunto de imagens, como o CIFAR10 (https://goo. gl/Vbsmx G) se quiser um desa-fio maior. Se você escolher o CIFAR10, precisará escrever o código para car-regar lotes de imagens para treinamento. Se você quiser pular essa parte, o modelo zoo do Tensor Flow contém ferramentas para fazer exatamente isso (https://goo. gl/3i ENgb); Divi da o conjunto de dados em um conjunto de treinamento e um conjunto de testes. Treine um autoencoder profundo de remoção de ruído no conjunto de treinamento completo; Ver ifique se as imagens estão razoavelmente bem reconstruídas e visualize as ca-racterísticas de baixo nível. Visualize as imagens que mais ativam cada neurônio na camada de codificação; Con strua uma rede neural profunda de classificação reutilizando as cama-das inferiores do autoencoder. Treine-a utilizando apenas 10% do conjunto de treinamento. Você consegue fazer com que ela tenha desempenho tão bom quanto o mesmo classificador treinado no conjunto de treinamento completo? 9. Sem antic hashing foi uma técnica introduzida em 2008 por Ruslan Salakhutdi-nov e Geoffrey Hinton (https://goo. gl/LXz FX6),13 utilizada para a recuperação eficiente de informações: um documento (por exemplo, uma imagem) é passado por um sistema, geralmente, uma rede neural que exibe um vetor binário de baixa dimensionalidade (por exemplo, 30 bits). É provável que dois documentos seme-lhantes tenham hashes idênticos ou muito semelhantes. Ao indexar cada docu-mento utilizando seu hash, é possível recuperar quase instantaneamente muitos documentos semelhantes a um específico, mesmo que haja bilhões deles: basta calcular o hash do documento e procurar todos aqueles com o mesmo hash (ou 13 “Semantic Hashing”, R. Salakhutdinov and G. Hinton (2008). CG_MIOLO_Hands_On_Machine_Learning. indb 455 07/05/2019 17:10:18

Mãos à obra Aprendizado de máquina Aurelien Geron.pdf

456 | Capítulo 15: Autoencodershashes diferindo por apenas um ou dois bits). Implementaremos o hashing se-mântico com a utilização de um autoencoder empilhado ligeiramente ajustado: Cri e um autoencoder empilhado contendo duas camadas ocultas abaixo da camada de codificação e treine-o no conjunto de dados de imagens que você utilizou no exercício anterior. A camada de codificação deve conter 30 neurô-nios e utilizar a função de ativação logística para gerar valores entre 0 e 1. Após o treinamento, para produzir o hash de uma imagem, execute-o através do autoencoder, obtenha a saída da camada de codificação e arredonde todos os valores para o inteiro mais próximo (0 ou 1); Um tr uque proposto por Salakhutdinov e Hinton é adicionar ruído gaussiano (com média zero) às entradas da camada de codificação somente durante o treinamento. O autoencoder aprenderá a alimentar grandes valores para a ca-mada de codificação a fim de preservar uma alta relação sinal-ruído (de modo que o ruído se torne insignificante). Por sua vez, isso significa que a função logística da camada de codificação provavelmente saturará em 0 ou 1. Como resultado, arredondando os códigos para 0 ou 1 não os distorcerá muito e isso aumentará a confiabilidade dos hashes; Cal cule o hash de cada imagem e veja se imagens com hashes idênticos são pa-recidas. Como o MNIST e o CIFAR10 são rotulados, uma forma mais objetiva de medir o desempenho do autoencoder para o hashing semântico é garantir que as imagens com o mesmo hash tenham a mesma classe. Uma maneira de fazer isso é medir o coeficiente de Gini médio (apresentado no Capítulo 6) dos conjuntos de imagens com hashes idênticos (ou muito semelhantes); Ten te ajustar os hiperparâmetros com a utilização da validação cruzada; Obse rve que, com um conjunto de dados rotulados, outra abordagem seria treinar uma rede neural convolucional (consulte o Capítulo 13) para classifi-cação e, em seguida, utilizar a camada abaixo da camada de saída para produ-zir os hashes. Veja o artigo de 2015 de Jinma Gua e Jianmin Li ( https://goo. gl/ i9FTln )14 e descubra se isso funciona melhor. 10. Tre ine um autoencoder variacional no conjunto de dados da imagem utilizado nos exercícios anteriores (MNIST ou CIFAR10) e faça com que ele gere imagens. Como alternativa, tente encontrar um conjunto de dados não rotulados do seu interesse e veja se é possível gerar novas amostras. Soluções para estes exercícios estão disponíveis no Apêndice A. 14 “CNN Based Hashing for Image Retrieval,” J. Gua and J. Li (2015) CG_MIOLO_Hands_On_Machine_Learning. indb 456 07/05/2019 17:10:18

Mãos à obra Aprendizado de máquina Aurelien Geron.pdf

457Capítulo 16 Aprendizado por Reforço O Aprendizado por Reforço (AR) é atualmente um dos campos mais empolgantes do Aprendizado de Máquina, e também um dos mais antigos. Ele existe desde os anos 1950, e vem produzindo muitas aplicações interessantes ao longo dos anos,1 em particular nos jogos (por exemplo, o TD-Gammon, um programa de gamão ) e no controle de má-quinas, mas raramente aparece em manchetes. No entanto, uma revolução ocorreu em 2013 quando pesquisadores de uma startup inglesa chamada Deep Mind demonstraram um sistema que poderia aprender a jogar praticamente qualquer jogo de Atari do zero (https://goo. gl/hce Ds5 )2 e, na maioria deles, eventualmente superar os humanos ( https:// goo. gl/hgpvz7 )3 somente com a utilização de pixels brutos como entradas, e sem qualquer conhecimento prévio das regras dos jogos. 4 Este foi o primeiro de uma série de feitos incríveis, culminando em maio de 2017 com a vitória do seu sistema Alpha Go contra Ke Jie, o campeão mundial do jogo Go. Nenhum programa chegou perto de bater um mestre deste jogo, muito menos o campeão mundial. Hoje, todo o setor do AR está fervendo com novas ideias, com uma ampla gama de aplicações. A Deep Mind foi comprada pelo Google por mais de 500 milhões de dólares em 2014. Então, como eles fizeram? Em retrospecto, parece bastante simples: eles aplicaram o poder do Aprendizado Profundo no campo do Aprendizado por Reforço, e isso fun-cionou além de seus sonhos mais loucos. Neste capítulo, primeiro explicaremos o que é Aprendizado por Reforço e no que ele é bom, e então apresentaremos duas das técnicas mais importantes no Aprendizado por Reforço profundo: gradientes de políticas e deep 1 Para mais detalhes, não deixe de conferir o livro de Richard Sutton e Andrew Barto sobre AR ( ht tps://goo. gl/7ut Zaz ), Reinforcement Learning: An Introduction (MIT Press), ou o curso gratuito de AR online de David Silver ( https://goo. gl/AWc MFW ) na University College London. 2 “Pl aying Atari with Deep Reinforcement Learning”, V. Mnih et al. (2013). 3 “Hu man-level control through deep reinforcement learning”, V. Mnih et al. (2015). 4 Conf ira os vídeos do sistema da Deep Mind aprendendo a jogar Space Invaders, Breakout e outros em https:// goo. gl/y Ts H6X. CG_MIOLO_Hands_On_Machine_Learning. indb 457 07/05/2019 17:10:19

Mãos à obra Aprendizado de máquina Aurelien Geron.pdf

458 | Capítulo 16: Aprendizado por Reforço Q-networks (DQN), incluindo uma discussão dos processos de decisão de Markov (MDP, do inglês). Utilizaremos estas técnicas para treinar um modelo para equilibrar um bastão em um carrinho em movimento e outro para jogar jogos de Atari. As mes-mas técnicas podem ser utilizadas para uma ampla variedade de tarefas, desde robôs andando, a carros autônomos. Aprendendo a Otimizar Recompensas No Aprendizado por Reforço, um agente de software faz observações e realiza ações dentro de um ambiente e, em troca, recebe recompensas. Seu objetivo é aprender a agir de forma a maximizar suas recompensas esperadas de longo prazo. Caso não se importe com um pouco de antropomorfismo, pode-se pensar em recompensas positivas como o prazer, e recompensas negativas como a dor (o termo “recompensa” é um pouco enganador neste caso). Em suma, o agente age no ambiente e aprende por tentativa e erro a maximizar seu prazer e minimizar sua dor. Esta é uma configuração bastante genérica que pode ser aplicada a uma ampla variedade de tarefas. Seguem alguns exemplos (veja a Figura 16-1): a. O ag ente pode ser um programa que controla um robô andante. Neste caso, o ambiente é o mundo real e o agente observa-o através de um conjunto de sensores, como câmeras e sensores de toque, e suas ações consistem em enviar sinais para ativar motores. Ele pode ser programado para obter recompensas positivas sempre que se aproximar do destino e recompensas negativas sempre que perder tempo, seguir na direção errada ou cair; b. O age nte pode ser um programa que controla a Ms. Pac-Man. Neste caso, o ambiente é uma simulação do jogo de Atari, as ações são as nove possíveis posições do controle (superior esquerdo, baixo, centro e assim por diante), as observações são capturas de tela e as recompensas são apenas pontos do jogo; c. Da me sma forma, o agente pode ser um programa jogando um jogo de tabu-leiro, como o Go; d. O age nte não precisa controlar fisicamente uma coisa em movimento (ou vir-tualmente). Por exemplo, pode ser um termostato inteligente recebendo re-compensas sempre que estiver próximo da temperatura desejada e economi-zar energia, além das recompensas negativas quando os humanos precisarem ajustar a temperatura para que o agente aprenda a antecipar suas necessidades; e. O age nte pode observar os preços do mercado de ações e decidir a cada se-gundo quanto comprar ou vender. Recompensas são obviamente os ganhos e perdas monetárias. CG_MIOLO_Hands_On_Machine_Learning. indb 458 07/05/2019 17:10:19

Mãos à obra Aprendizado de máquina Aurelien Geron.pdf

Pesquisa de Políticas | 459 Figura 16-1. Exemplos de Aprendizado por Reforço: (a) robô andante, (b) Ms. Pac-Man, (c) jogador de Go, (d) termostato, (e) operador automático5 Note que pode não haver nenhuma recompensa positiva; por exemplo, o agente pode se movimentar em um labirinto recebendo uma recompensa negativa a cada intervalo de tempo, então é melhor encontrar a saída o mais rápido possível! Há muitos outros exemplos de tarefas nas quais o Aprendizado por Reforço é bem adequado, como carros autônomos, colocar anúncios em uma página da Web ou controlar onde um sistema de classificação de imagens deve focar sua atenção. Pesquisa de Políticas O algoritmo utilizado pelo agente de software para determinar suas ações é chamado de política. Por exemplo, a política poderia ser uma rede neural absorvendo as observações como entradas e produzindo a ação a ser tomada (veja a Figura 16-2). 5 Imagens (a), (c) e (d) são reproduzidas da Wikipedia. (a) e (d) estão no domínio público. (c) foi criada pelo usuá-rio Stevertigo e lançada pela Creative Commons BY-SA 2. 0 ( https://creativecommons. org/licenses/by-sa/2. 0/ ). (b) é uma captura de tela do jogo Ms. Pac-Man, copyright Atari (o autor acredita que o uso seja justo para este capítulo). (e) foi reproduzido a partir do Pixabay, lançado pela Creative Commons CC0 ( https://creative commons. org/publicdomain/zero/1. 0/ ). CG_MIOLO_Hands_On_Machine_Learning. indb 459 07/05/2019 17:10:19

Mãos à obra Aprendizado de máquina Aurelien Geron.pdf

460 | Capítulo 16: Aprendizado por Reforço Agente Ambiente Ações Recompensas + Obser vações Política Figura 16-2. Aprendizado por reforço utilizando uma política de rede neural A política pode ser qualquer algoritmo que você possa imaginar, e nem precisa ser determinista. Por exemplo, considere um aspirador de pó robótico cuja recompensa é a quantidade de poeira acumulada em 30 minutos. Sua política poderia ser avançar com alguma probabilidade p a cada segundo, ou girar aleatoriamente para a esquerda ou para a direita com probabilidade 1-p. O ângulo de rotação seria um ângulo alea-tório entre-r e +r. Como essa política envolve alguma aleatoriedade, ela é chamada de política estocástica. O robô terá uma trajetória errática, o que garante que ele eventual-mente chegará a qualquer lugar que possa alcançar e recolher toda a poeira. A questão é: quanto pó ele pegará em 30 minutos? Como você treinaria um robô desses? Existem apenas dois parâmetros de política que você pode ajustar: a probabilidade p e o intervalo do ângulo r. Um possível algoritmo de aprendizado poderia ser testar muitos valores diferentes para esses parâmetros e escolher a combinação que tenha o melhor desempenho (veja a Figura 16-3). Este é um exemplo de pesquisa de política, neste caso utilizando uma abordagem de força bruta. No entanto, encontrar um bom conjunto de parâmetros dessa maneira quando o espaço de política for muito grande (o que geralmente é o caso), é como procurar uma agulha em um gigantesco palheiro. Outra maneira de explorar o espaço da política seria utilizar algoritmos genéticos. Por exemplo, você poderia criar aleatoriamente uma primeira geração de 100 políticas e testá-las, depois “matar” as 80 piores políticas6 e fazer com que as 20 sobreviventes produzam 4 descendentes cada. Uma descendente é apenas uma cópia de seu genitor,7 além de alguma variação aleatória. As políticas sobreviventes e seus descendentes jun-6 Muitas vezes, é melhor dar aos participantes fracos uma pequena chance de sobrevivência, para preservar alguma “diversidade no pool genético”. 7 Se hou ver apenas um genitor, esse processo é chamado de reprodução assexuada. Com dois (ou mais) genito-res, é chamado de reprodução sexuada. O genoma de uma prole (neste caso, um conjunto de parâmetros de políticas) é composto aleatoriamente por partes dos genomas de seus pais. CG_MIOLO_Hands_On_Machine_Learning. indb 460 07/05/2019 17:10:19

Mãos à obra Aprendizado de máquina Aurelien Geron.pdf

Introdução ao Open AI Gym | 461tos constituem a segunda geração e é possível continuar iterando dessa maneira pelas gerações até encontrar uma boa política. Espaço da Política Comportamentos Resultantes Figura 16-3. Quatro pontos no espaço da política e o comportamento correspondente do agente Outra abordagem seria usar técnicas de otimização, avaliando os gradientes das recompensas com relação aos parâmetros da política e, então, ajustando esses parâmetros seguindo o gradiente na direção das recompensas mais altas ( gradiente ascendente ), abordagem chamada de gradien-tes de políticas (PG, do inglês) que discutiremos com mais detalhes mais adiante. Por exemplo, voltando ao robô aspirador de pó, você poderia aumentar um pouco p e avaliar se isso aumenta a quantidade de poeira captada pelo robô em 30 minutos; se isso acon-tecer, aumente p um pouco mais ou, então, o reduza. Com a utilização do Tensor Flow, implementaremos um algoritmo PG popular, mas antes precisamos criar um ambiente para o agente morar, então é hora de apresentar o Open AI gym. Introdução ao Open AI Gym Um dos desafios do Aprendizado por Reforço é que, para treinar um agente, você pri-meiro precisa ter um ambiente de trabalho. Você precisará de um simulador de jogos da Atari se quiser programar um agente que aprenderá a jogar um jogo de Atari. Se quiser programar um robô andante, então o ambiente é o mundo real e você pode treinar seu robô diretamente, mas isso tem seus limites: se o robô cair de um penhasco você não pode simplesmente clicar em “desfazer”. Você também não pode acelerar o tempo; adicionar mais poder de computação não fará com que o robô se mova mais rápido e, geralmente, é muito caro treinar 1 mil robôs em paralelo. Em suma, o treinamento é difícil e lento no mundo real, então você precisa de um ambiente simulado pelo menos para iniciar o treinamento. CG_MIOLO_Hands_On_Machine_Learning. indb 461 07/05/2019 17:10:19

Mãos à obra Aprendizado de máquina Aurelien Geron.pdf

462 | Capítulo 16: Aprendizado por Reforço O Open AI gym (https://gym. openai. com/ )8 é um kit de ferramentas que fornece uma ampla variedade de ambientes simulados (jogos de Atari, jogos de tabuleiro, simulações físicas em 2D e 3D e assim por diante) para que você possa treinar agentes, compará-los, ou desenvolver novos algoritmos de RL. Instalaremos o Open AI gym. Se você criou um ambiente isolado utilizando virtualenv, primeiro precisa ativá-lo: $ cd $ML_PATH # Seu diretório de AM (por ex., $HOME/ml) $ source env/bin/activate Em seguida, instale o Open AI Gym (se você não estiver utilizando um virtualenv, pre-cisará de direitos de administrador ou adicionar a opção--user ): $ pip3 install--upgrade gym Em seguida, abra um Python shell ou um notebook Jupyter e crie seu primeiro ambiente: >>> import gym >>> env = gym. make("Cart Pole-v0") [2017-08-27 11:08:05,742] Making new env: Cart Pole-v0 >>> obs = env. reset() >>> obs array([-0. 03799846,-0. 03288115, 0. 02337094, 0. 00720711]) >>> env. render() A função make() cria um ambiente, neste caso um ambiente Cart Pole. Esta é uma si-mulação 2D na qual um carrinho pode ser acelerado para a esquerda ou para a direita a fim de equilibrar um bastão posicionado sobre ele (veja a Figura 16-4). Depois que o ambiente é criado, devemos iniciá-lo utilizando o método reset(), o que retorna a primeira observação. As observações dependem do tipo de ambiente, cada uma delas é um array 1D Num Py que contém quatro floats para o ambiente Cart Pole: esses floats representam a posição horizontal do carrinho ( 0. 0 = centro), sua velocidade, o ângulo do bastão (0. 0 = vertical) e sua velocidade angular. Finalmente, o método render() exibe o ambiente como mostrado na Figura 16-4. Ângulo Velocidade angular Posição Velocidade Figura 16-4. O ambiente Cart Pole 8 A Open AI é uma empresa de pesquisa de inteligência artificial sem fins lucrativos financiada em parte por Elon Musk. Seu objetivo declarado é promover e desenvolver IAs amigáveis que beneficiem a humanidade (em vez de exterminá-la). CG_MIOLO_Hands_On_Machine_Learning. indb 462 07/05/2019 17:10:20

Mãos à obra Aprendizado de máquina Aurelien Geron.pdf

Introdução ao Open AI Gym | 463Ajuste o parâmetro mode para rgb_array se quiser que render() retorne a imagem renderizada como um array Num Py (note que outros ambientes podem suportar di-ferentes modos): >>> img = env. render(mode="rgb_array") >>> img. shape # altura, largura, canais (3=RGB) (400, 600, 3) Infelizmente, o Cart Pole (e alguns outros ambientes) renderiza a imagem na tela mesmo se você definir o modo como “rgb_array”. A única maneira de evitar isso é utilizar um servidor X falso como Xvfb ou Xdummy. Por exemplo, você pode instalar o Xvfb e iniciar o Python com o seguinte comando: xvfb-run-s “-screen 0 1400x900x24” python. Ou utilizar o pacote xvfbwrapper (https:// goo. gl/w R1o Jl). Perguntaremos ao ambiente quais ações são possíveis: >>> env. action_space Discrete(2) Discrete(2) significa que as ações possíveis são os inteiros 0 e 1 que representam a ace-leração à esquerda (0) ou à direita (1). Outros tipos de ações ou outros ambientes podem ter ações mais discretas (por exemplo, contínuas). Como o bastão está inclinado para a direita, aceleraremos o carrinho para a direita: >>> action = 1 # acelere bem >>> obs, reward, done, info = env. step(action) >>> obs array([-0. 03865608, 0. 16189797, 0. 02351508,-0. 27801135]) >>> reward 1. 0 >>> done False >>> info {} O método step() executa a dada ação e retorna quatro valores: obs Esta é a nova observação. O carrinho agora está se movendo para a direita ( obs[1]>0 ). O bastão ainda está inclinado para a direita ( obs[2]>0 ), mas sua velocidade angular agora é negativa ( obs[3]<0 ), provavelmente será inclinado para a esquerda após o próximo passo. reward Neste ambiente, você consegue uma recompensa de 1,0 a cada passo, não importa o que você faça, então o objetivo é continuar correndo o maior tempo possível. CG_MIOLO_Hands_On_Machine_Learning. indb 463 07/05/2019 17:10:21

Mãos à obra Aprendizado de máquina Aurelien Geron.pdf

464 | Capítulo 16: Aprendizado por Reforçodone Este valor será True quando o episode terminar, o que acontecerá quando o bastão se inclinar demais. Depois disso, o ambiente deve ser redefinido antes de poder ser usado novamente. info Este dicionário pode fornecer informações adicionais de depuração em outros am-bientes. Esses dados não devem ser utilizados para treinamento (isso seria trapaça). Programaremos uma política simples que acelera para a esquerda quando o bastão está inclinado para a esquerda, e para a direita quando está inclinado para a direita. Nós executaremos essa política para ver as recompensas médias que ele recebe em mais de 500 episódios: def basic_policy(obs): angle = obs[2] return 0 if angle < 0 else 1 totals = [] for episode in range(500): episode_rewards = 0 obs = env. reset() for step in range(1000): # no máximo mil passos, não queremos rodar para sempre action = basic_policy(obs) obs, reward, done, info = env. step(action) episode_rewards += reward if done: break totals. append(episode_rewards) Este código é autoexplicativo. Vejamos o resultado: >>> import numpy as np >>> np. mean(totals), np. std(totals), np. min(totals), np. max(totals) (42. 125999999999998, 9. 1237121830974033, 24. 0, 68. 0) Mesmo com 500 tentativas, essa política nunca conseguiu manter o bastão de pé por mais de 68 etapas consecutivas. Nada bom. Se você olhar para a simulação nos notebooks do Jupyter ( https://github. com/ageron/handson-ml ) verá que o carrinho oscila para a esquerda e para a direita mais e mais, até que o bastão se incline demais. Veremos se uma rede neural pode criar uma política melhor. Políticas de Rede Neural Criaremos uma política de rede neural e, assim como a política que codificamos anteriormente, essa rede neural tomará uma observação como entrada e exibirá a ação a ser executada. Mais precisamente, estimamos uma probabilidade para cada ação e, em seguida, selecionamos alea-CG_MIOLO_Hands_On_Machine_Learning. indb 464 07/05/2019 17:10:21

Mãos à obra Aprendizado de máquina Aurelien Geron.pdf

Políticas de Rede Neural | 465toriamente uma ação de acordo com as probabilidades estimadas (ver Figura 16-5). Há apenas duas ações possíveis no caso do ambiente Cart Pole (esquerda ou direita), então só precisamos de um neurônio de saída que exibirá a probabilidade p de ação 0 (esquerda), e, claro, a proba-bilidade da ação 1 (direita) será 1-p. Por exemplo, se ele exibir 0,7, então escolheremos a ação 0 com 70% de probabilidade e a ação 1 com 30% de probabilidade. Ação Amostragem multinomial Probabilidade da ação 0 (esquerda) Oculta Obser vações Figura 16-5. Política de Rede Neural Você pode se perguntar por que estamos escolhendo uma ação aleatória com base na probabilidade dada pela rede neural, em vez de apenas escolher a ação com a pontua-ção mais alta. Essa abordagem permite que o agente encontre o equilíbrio certo entre explorar novas ações e a exploração das ações que funcionam bem. Pense nesta analo-gia: suponha que você vá a um restaurante pela primeira vez e todos os pratos pareçam igualmente atraentes, assim você escolhe aleatoriamente um. Se for bom, você pode aumentar a probabilidade de pedi-lo na próxima vez, mas você não deve aumentar essa probabilidade até 100% ou então nunca experimentará os outros pratos, alguns dos quais podem ser ainda melhores do que aquele que você escolheu. Observe também que as ações e observações passadas podem ser ignoradas com segu-rança nesse ambiente específico, já que cada observação contém o estado completo do ambiente. Se houvesse algum estado oculto, talvez fosse necessário considerar ações e observações passadas também. Por exemplo, se o ambiente apenas revelou a posição do carro, mas não a sua velocidade, você teria que considerar não apenas a observação CG_MIOLO_Hands_On_Machine_Learning. indb 465 07/05/2019 17:10:21

Mãos à obra Aprendizado de máquina Aurelien Geron.pdf

466 | Capítulo 16: Aprendizado por Reforçoatual, mas também a observação anterior a fim de estimar a velocidade atual. Outro exemplo é quando as observações forem ruidosas; nesse caso, você geralmente quer usar as últimas observações para estimar o estado atual mais provável. O problema do Cart Pole é, portanto, extremamente simples: as observações são livres de ruído e contêm o estado completo do ambiente. Este é o código para construir esta política de rede neural usando o Tensor Flow: import tensorflow as tf # 1. Especifique a arquitetura da rede neural n_inputs = 4 # == env. observation_space. shape[0] n_hidden = 4 # é uma tarefas simples, não precisamos de mais neurônios ocultos n_outputs = 1 # só sai a probabilidade de aceleração faltante initializer = tf. contrib. layers. variance_scaling_initializer() # 2. Construa a rede neural X = tf. placeholder(tf. float32, shape=[None, n_inputs]) hidden = tf. layers. dense(X, n_hidden, activation=tf. nn. elu, kernel_initializer=initializer)logits = tf. layers. dense(hidden, n_outputs, kernel_initializer=initializer) outputs = tf. nn. sigmoid(logits) # 3. Selecione uma ação aleatória com base nas probabilidades estimadas p_left_and_right = tf. concat(axis=1, values=[outputs, 1-outputs]) action = tf. multinomial(tf. log(p_left_and_right), num_samples=1) init = tf. global_variables_initializer() Vamos entender esse código: 1. Apó s as importações, definimos a arquitetura da rede neural. O número de entra-das é o tamanho do espaço de observação (que no caso do Cart Pole é quatro), te-mos apenas quatro unidades ocultas e não há necessidade de mais, e temos apenas uma probabilidade de saída (a probabilidade de ir para a esquerda); 2. Em s eguida, construímos a rede neural. Neste exemplo, é um perceptron normal de várias camadas com uma única saída. Observe que a camada de saída utiliza a função de ativação logística (sigmoide) para gerar uma probabilidade de 0,0 a 1,0. Se houvesse mais de duas ações possíveis, haveria um neurônio de saída por ação e você utilizaria a função de ativação do softmax; 3. Por fim, chamamos a função multinomial() para escolher uma ação aleatória. Esta função, dada a probabilidade de log de cada inteiro, amostra um (ou mais) in-teiros. Por exemplo, se você a chamar com o array [np. log(0. 5), np. log(0. 2), np. log(0. 3)] e com num_samples=5, ela produzirá cinco inteiros, cada um dos quais terá 50% de probabilidade de ser 0, 20% de ser 1 e 30% de ser 2. No nos-so caso, precisamos apenas de um inteiro representando a ação a ser executada. Como o tensor outputs contém apenas a probabilidade de ir para a esquerda, de-CG_MIOLO_Hands_On_Machine_Learning. indb 466 07/05/2019 17:10:22

Mãos à obra Aprendizado de máquina Aurelien Geron.pdf

Avaliação das Ações: o Problema de Atribuição de Crédito | 467vemos primeiro concatenar 1-outputs para que ele tenha um tensor que contenha a probabilidade de ambas as ações, esquerda e direita. Observe que, se houvesse mais de duas ações possíveis, a rede neural teria que gerar uma probabilidade por ação para que você não precisasse da etapa de concatenação. Ok, agora temos uma política de rede neural com observações e ações de saída, mas como a treinamos? Avaliação das Ações: o Problema de Atribuição de Crédito Como de costume, se soubéssemos qual seria a melhor ação em cada etapa, poderíamos treinar a rede neural minimizando a entropia cruzada entre a probabilidade estimada e a probabilidade de destino. Seria apenas um aprendizado supervisionado comum, porém, no Aprendizado por Reforço, a única orientação que o agente recebe é por meio de recompensas, que são tipicamente escassas e atrasadas. Por exemplo, se o agente con-segue equilibrar o bastão por 100 etapas, como ele pode saber quais das 100 ações foram boas e quais delas foram ruins? Ele só sabe que o bastão caiu após a última ação, mas certamente ele não é inteiramente responsável por esta última ação, o que é chamado de problema de atribuição de crédito : quando o agente recebe uma recompensa, é difícil saber quais ações devem ser creditadas (ou culpadas) por isso. Pense em um cachorro que é recompensado horas depois de se comportar bem; ele entenderá por que é recompensado? Uma estratégia comum para resolver esse problema é avaliar uma ação com base na soma de todas as recompensas que vêm depois dela, geralmente aplicando uma taxa de desconto r em cada etapa. Por exemplo (veja a Figura 16-6), se um agente decide ir pela direita três vezes seguidas e recebe +10 de recompensa após o primeiro passo, 0 após o segundo passo, e finalmente-50 após o terceiro passo, então, assumindo que utilizamos uma taxa de desconto r = 0,8, a primeira ação terá uma pontuação total de 10 + r × 0 + r 2 × (-50) =-22. Se a taxa de desconto for próxima de 0, as recompensas futuras não serão muito importantes em comparação com as recompensas imediatas. Por outro lado, se a taxa de desconto for próxima de 1, as recompensas no futuro contarão quase tanto quanto as recompensas imediatas. As taxas de desconto típicas são 0,95 ou 0,99. As recompensas de 13 passos no futuro contam mais ou menos metade das recompensas imediatas (já que 0,9513 ≈ 0,5) com uma taxa de desconto de 0,95, enquanto com uma taxa de desconto de 0,99 por metade das recompensas imediatas ele terá uma recompensa de 69 etapas na contagem futura. No ambiente Cart Pole, as ações têm efeitos de curto prazo, portanto a escolha de uma taxa de desconto de 0,95 parece razoável. CG_MIOLO_Hands_On_Machine_Learning. indb 467 07/05/2019 17:10:22

Mãos à obra Aprendizado de máquina Aurelien Geron.pdf

468 | Capítulo 16: Aprendizado por Reforço Certa Taxa de Desconto Recompensas: Soma das recompensas descontadas:Certa Certa Ações: Figura 16-6. Recompensas descontadas É claro que uma boa ação pode ser seguida por várias ações ruins que fazem com que o bastão caia rapidamente, resultando em uma boa ação obtendo uma pontuação baixa (da mesma forma, um bom ator pode, às vezes, estrelar um filme terrível). No entanto, em média, as boas ações terão uma pontuação melhor do que as ruins se jogarmos bastante o jogo. Assim, para obter pontuações de ação bastante confiáveis, devemos executar muitos episódios e normalizar todas as pontuações da ação (subtraindo a média e di-vidindo pelo desvio padrão). Depois disso, podemos supor razoavelmente que as ações com pontuação negativa foram ruins, enquanto as ações com pontuação positiva foram boas. Perfeito — agora que temos uma forma de avaliar cada ação utilizando gradientes de política, estamos prontos para treinar nosso primeiro agente. Veremos como. Gradientes de Política Como discutido anteriormente, os algoritmos PG otimizam os parâmetros de uma po-lítica seguindo os gradientes em direção a recompensas mais altas. Uma classe popular de algoritmos PG, chamada REINFORCE algorithms, foi introduzida em 1992 ( https:// goo. gl/t Ue4Sh )9 por Ronald Williams. Uma variante comum é: 1. Primeiro, deixe a política da rede neural jogar o jogo várias vezes e, em cada etapa, calcule os gradientes que tornariam a ação escolhida ainda mais provável, mas não aplique-os ainda; 2. Dep ois de executar vários episódios, calcule a pontuação de cada ação (utilizando o método descrito no parágrafo anterior); 9 “Simple Statistical Gradient-Following Algorithms for Connectionist Reinforcement Learning”,R. Williams (1992). CG_MIOLO_Hands_On_Machine_Learning. indb 468 07/05/2019 17:10:22

Mãos à obra Aprendizado de máquina Aurelien Geron.pdf

Gradientes de Política | 4693. Se a pontuação da ação for positiva, significa que a ação foi boa e você deseja ap licar os gradientes calculados anteriormente para tornar a ação ainda mais pro-vável de ser escolhida no futuro. No entanto, se a pontuação for negativa, significa que a ação foi ruim e você deseja aplicar os gradientes opostos para tornar essa ação um pouco menos provável no futuro. A solução é simplesmente multiplicar cada vetor de gradiente pela pontuação da ação correspondente; 4. Por f im, calcule a média de todos os vetores de gradiente resultantes e a utilize para executar uma etapa de Gradiente Descendente. Implementaremos esse algoritmo utilizando o Tensor Flow e treinaremos a política de redes neurais que construímos anteriormente para que ela aprenda a equilibrar o bastão no carrinho. Começaremos concluindo a fase de construção que codificamos anteriormente para adicionar a probabilidade de destino, a função de custo e a operação de treinamento. Já que estamos agindo como se a ação escolhida fosse a melhor ação possível, se ela for a ação 0 (esquerda) a probabilidade de destino deve ser 1. 0, e se for a ação 1 (direita) será 0,0: y = 1.-tf. to_float(action) Agora que temos uma probabilidade de destino, podemos definir a função de custo (entropia cruzada) e calcular os gradientes: learning_rate = 0. 01 cross_entropy = tf. nn. sigmoid_cross_entropy_with_logits(labels=y, logits=logits) optimizer = tf. train. Adam Optimizer(learning_rate) grads_and_vars = optimizer. compute_gradients(cross_entropy) Observe que estamos chamando o método compute_gradients() do otimizador em vez do minimize() porque queremos ajustar os gradientes antes de aplicá-los. 10 O método compute_gradients() retorna uma lista de pares vetor/variável do gradiente (um par por variável treinável). Para que obter os seus valores seja mais conveniente, colocaremos todos os gradientes em uma lista: gradients = [grad for grad, variable in grads_and_vars] Ok, agora vem a parte complicada. Durante a fase de execução, o algoritmo executará a polí-tica e, em cada etapa, vai avaliar esses tensores do gradiente e armazenar seus valores. Como explicado anteriormente, depois de vários episódios, ele ajustará esses gradientes (ou seja, os multiplicará pelas pontuações de ação e os normalizará) e calculará a média dos gradientes ajustados. Em seguida, ele precisará alimentar os gradientes resultantes de volta ao oti-10 Nós já fizemos algo semelhante no Capítulo 11 quando discutimos o Recorte do Gradiente: primeiro calculamos os gradientes, depois recortamos e, finalmente, aplicamos os gradientes recortados. CG_MIOLO_Hands_On_Machine_Learning. indb 469 07/05/2019 17:10:23

Mãos à obra Aprendizado de máquina Aurelien Geron.pdf

470 | Capítulo 16: Aprendizado por Reforçomizador para que possa executar uma etapa de otimização porque precisamos de um placeholder por vetor do gradiente. Além disso, devemos criar a operação que aplicará os gradientes atualizados chamando a função do otimizador apply_gradients() que pega uma lista de pares vetores/variáveis do gradiente. Em vez de fornecer os vetores originais do gradiente, forneceremos uma lista contendo os gradientes atualizados (ou seja, os fornecidos pelos placeholders do gradiente): gradient_placeholders = [] grads_and_vars_feed = [] for grad, variable in grads_and_vars: gradient_placeholder = tf. placeholder(tf. float32, shape=grad. get_shape()) gradient_placeholders. append(gradient_placeholder) grads_and_vars_feed. append((gradient_placeholder, variable)) training_op = optimizer. apply_gradients(grads_and_vars_feed) Vamos recuar e dar uma olhada na fase completa de construção: n_inputs = 4 n_hidden = 4 n_outputs = 1 initializer = tf. contrib. layers. variance_scaling_initializer() learning_rate = 0. 01 X = tf. placeholder(tf. float32, shape=[None, n_inputs]) hidden = tf. layers. dense(X, n_hidden, activation=tf. nn. elu, kernel_initializer=initializer) logits = tf. layers. dense(hidden, n_outputs, kernel_initializer=initializer) outputs = tf. nn. sigmoid(logits) p_left_and_right = tf. concat(axis=1, values=[outputs, 1-outputs]) action = tf. multinomial(tf. log(p_left_and_right), num_samples=1) y = 1.-tf. to_float(action) cross_entropy = tf. nn. sigmoid_cross_entropy_with_logits( labels=y, logits=logits) optimizer = tf. train. Adam Optimizer(learning_rate) grads_and_vars = optimizer. compute_gradients(cross_entropy) gradients = [grad for grad, variable in grads_and_vars] gradient_placeholders = [] grads_and_vars_feed = [] for grad, variable in grads_and_vars: gradient_placeholder = tf. placeholder(tf. float32, shape=grad. get_shape()) gradient_placeholders. append(gradient_placeholder) grads_and_vars_feed. append((gradient_placeholder, variable)) training_op = optimizer. apply_gradients(grads_and_vars_feed) init = tf. global_variables_initializer() saver = tf. train. Saver() CG_MIOLO_Hands_On_Machine_Learning. indb 470 07/05/2019 17:10:23

Mãos à obra Aprendizado de máquina Aurelien Geron.pdf

Gradientes de Política | 471Rumo à fase de execução! Dadas as recompensas cruas, precisaremos de algumas funções para calcular as recompensas totais com desconto na fase de execução, e normalizar os resultados em múltiplos episódios: def discount_rewards(rewards, discount_rate): discounted_rewards = np. empty(len(rewards)) cumulative_rewards = 0 for step in reversed(range(len(rewards))): cumulative_rewards = rewards[step] + cumulative_rewards * discount_rate discounted_rewards[step] = cumulative_rewards return discounted_rewards def discount_and_normalize_rewards(all_rewards, discount_rate): all_discounted_rewards = [discount_rewards(rewards, discount_rate) for rewards in all_rewards] flat_rewards = np. concatenate(all_discounted_rewards) reward_mean = flat_rewards. mean() reward_std = flat_rewards. std() return [(discounted_rewards-reward_mean)/reward_std for discounted_rewards in all_discounted_rewards] Verificaremos se isso funciona: >>> discount_rewards([10, 0,-50], discount_rate=0. 8) array([-22.,-40.,-50. ])>>> discount_and_normalize_rewards([[10, 0,-50], [10, 20]], discount_rate=0. 8) [array([-0. 28435071,-0. 86597718,-1. 18910299]), array([ 1. 26665318, 1. 0727777 ])] A chamada para discount_rewards() retorna exatamente o que esperamos (veja a Figura 16-6). Verifique que a função discount_and_normalize_rewards() realmente retorna as pontuações normalizadas para cada ação em ambos os episódios. Observe que o pri-meiro episódio foi muito pior do que o segundo, então suas pontuações normalizadas são todas negativas; todas as ações do primeiro episódio seriam consideradas ruins e, inversamente, todas as ações do segundo episódio seriam consideradas boas: Temos agora tudo o que precisamos para treinar a política. n_iterations = 250 # número de iterações de treinamento n_max_steps = 1000 # etapas máximas por episódio n_games_per_update = 10 # treine a política a cada 10 episódios save_iterations = 10 # salve o modelo a cada 10 iterações de treinamento discount_rate = 0. 95 with tf. Session() as sess: init. run() for iteration in range(n_iterations): all_rewards = [] # todas as sequências de recompensas para cada episódio CG_MIOLO_Hands_On_Machine_Learning. indb 471 07/05/2019 17:10:24

Mãos à obra Aprendizado de máquina Aurelien Geron.pdf

472 | Capítulo 16: Aprendizado por Reforço all_gradients = [] # gradientes saçvos em cada etapa para cada episódio for game in range(n_games_per_update): current_rewards = [] # todas as recompensas do episódio atual current_gradients = [] # todos os gradientes do episódio atual obs = env. reset() for step in range(n_max_steps): action_val, gradients_val = sess. run( [action, gradients], feed_dict={X: obs. reshape(1, n_inputs)}) # uma obs obs, reward, done, info = env. step(action_val[0][0]) current_rewards. append(reward) current_gradients. append(gradients_val) if done: break all_rewards. append(current_rewards) all_gradients. append(current_gradients) # Aqui, rodamos a política em 10 episódios e estamos # prontos para uma atualização da política usando o algoritmo descrito anteriormente all_rewards = discount_and_normalize_rewards(all_rewards,discount_rate) feed_dict = {} for var_index, grad_placeholder in enumerate(gradient_placeholders): # multiplique todos os gradientes pela pontuação de ação e compute a média mean_gradients = np. mean( [reward * all_gradients[game_index][step][var_index] for game_index, rewards in enumerate(all_rewards) for step, reward in enumerate(rewards)], axis=0) feed_dict[grad_placeholder] = mean_gradients sess. run(training_op, feed_dict=feed_dict) if iteration % save_iterations == 0: saver. save(sess, ". /my_policy_net_pg. ckpt") Cada iteração do treinamento começa executando a política de 10 episódios (com o máximo de 1 mil etapas por episódio, para evitar a execução para sempre). Também cal-culamos os gradientes em cada etapa fingindo que a ação escolhida foi a melhor. Depois que esses 10 episódios foram executados, calculamos as pontuações de ação usando a função discount_and_normalize_rewards() ; passamos por cada variável treinável, em todos os episódios e passos, para multiplicar cada vetor gradiente por sua ação de pon-tuação correspondente, e calculamos a média dos gradientes resultantes. Finalmente, executamos a operação de treinamento alimentando esses gradientes médios (um por variável treinável). Também salvamos o modelo a cada 10 operações de treinamento. E terminamos! Este código treinará a política de rede neural e aprenderá com sucesso a equilibrar o bastão no carrinho (você pode testá-lo nos notebooks Jupyter). Observe que há duas maneiras de o agente perder o jogo: o mastro pode inclinar demais ou o carrinho pode sair completamente da tela. Com 250 iterações de treinamento, a política aprende a equilibrar bem o bastão, mas ainda não é boa o suficiente para evitar que saia da tela. Algumas centenas de iterações de treinamento consertarão isso. CG_MIOLO_Hands_On_Machine_Learning. indb 472 07/05/2019 17:10:24

Mãos à obra Aprendizado de máquina Aurelien Geron.pdf

Processos de Decisão de Markov | 473Os pesquisadores tentam encontrar algoritmos que funcionem bem mesmo quando o agente inicialmente não sabe nada sobre o ambien-te. Entretanto, a menos que você esteja escrevendo um artigo, você deve injetar o máximo de conhecimento prévio possível no agente, pois isso acelerará o treinamento drasticamente. Por exemplo, você pode adicionar recompensas negativas proporcionais à distância do centro da tela e ao ângulo do bastão. Além disso, se você já tiver uma política razoavelmente boa (por exemplo, codificada), vai que-rer treinar a rede neural para imitá-la antes de utilizar gradientes de política para aprimorá-la. Apesar de sua relativa simplicidade, esse algoritmo é bastante poderoso e é possível usá-lo para resolver problemas muito mais difíceis do que equilibrar um bastão em um carrinho. Na verdade, o Alpha Go foi baseado em um algoritmo PG similar (e o Monte Carlo Tree Search, que está além do escopo deste livro). Agora veremos outra família popular de algoritmos. Enquanto os algoritmos PG tentam otimizar diretamente a política para aumentar as recompensas, os algoritmos que veremos agora são menos diretos: o agente aprende a estimar a soma esperada de recompensas futu-ras descontadas para cada estado ou a soma esperada de recompensas futuras descontadas para cada ação em cada estado, então utiliza esse conhecimento para decidir como agir. Para entender esses algoritmos, devemos primeiro introduzir os processos de decisão de Markov (MDP, do inglês). Processos de Decisão de Markov No início do século XX o matemático Andrey Markov estudou processos estocásticos sem memória chamados cadeias de Markov. Esse processo tem um número fixo de es-tados e evolui aleatoriamente de um estado para outro em cada etapa. A probabilidade de evoluir de um estado s para um estado s ′ é fixa e depende apenas do par ( s, s′), não de estados passados (o sistema não tem memória). A Figura 16-7 mostra um exemplo de uma cadeia de Markov com quatro estados. Suponha que o processo comece no estado s 0, e haja uma chance de 70% de que ele permaneça nesse estado na próxima etapa. Eventualmente, ele é obrigado a deixar esse estado e nunca mais voltar, pois nenhum outro estado aponta para s 0. Se for para o estado s1, então provavelmente irá para o estado s 2 (90% de probabilidade) e, então, imediatamen-te de volta para o estado s 1 (com 100% de probabilidade). Pode alternar um número de CG_MIOLO_Hands_On_Machine_Learning. indb 473 07/05/2019 17:10:24

Mãos à obra Aprendizado de máquina Aurelien Geron.pdf

474 | Capítulo 16: Aprendizado por Reforçovezes entre estes dois estados, mas, eventualmente, cairá no estado s3 e permanecerá lá para sempre (este é um estado terminal ). As cadeias de Markov podem ter dinâmicas muito diferentes e são muito utilizadas em termodinâmica, química, estatística e muito mais. Figura 16-7. Exemplo de uma cadeia de Markov Os processos de decisão de Markov foram descritos pela primeira vez na década de 1950 por Richard Bellman (https://goo. gl/w ZTVIN)11 e se assemelham a cadeias de Markov, mas com uma variação: a cada passo, um agente pode escolher uma das várias ações possíveis e as probabilidades de transição dependem da ação escolhida. Além disso, algumas transições de estado retornam alguma recompensa (positiva ou negativa) e o objetivo do agente é encontrar uma política que maximize-as ao longo do tempo. Por exemplo, o MDP representado na Figura 16-8 possui três estados e até três possíveis ações discretas em cada etapa. Se começar no estado s0, o agente pode escolher entre as ações a0, a1, ou a2. Se escolher a ação a1, ele permanecerá no estado s0 com certeza, e sem recompensa alguma. Assim, se quiser, pode decidir ficar lá para sempre, mas, se escolher a ação a0, ele tem 70% de probabilidade de ganhar uma recompensa de +10, e permanecer no estado s0. Ele pode, então, tentar novamente por várias vezes para ganhar o máximo de recompensa possível, mas, em algum ponto, acabará no estado s1. No estado s1 ele tem somente duas ações possíveis: a0 ou a2, podendo escolher ficar parado selecionando repe-tidamente a ação a0, ou se mover para o estado s2 e obter uma recompensa negativa de-50 (ai!). No estado s2, ele não tem outra opção senão tomar a ação a1, o que provavelmente o levará de volta ao estado s0, ganhando uma recompensa de +40 no caminho. Você pegou o espírito. Ao olhar para esse MDP, você consegue adivinhar qual estratégia obterá mais recompensa ao longo do tempo? No estado s0, é claro que a ação a0 é a melhor opção e no estado s2 o agente não tem escolha a não ser tomar a ação a1, mas no estado s1 não é óbvio se o agente deve ficar parado ( a0) ou passar pelo fogo ( a2). 11 “A Markovian Decision Process”, R. Bellman (1957). CG_MIOLO_Hands_On_Machine_Learning. indb 474 07/05/2019 17:10:24

Mãos à obra Aprendizado de máquina Aurelien Geron.pdf

Processos de Decisão de Markov | 475 Figura 16-8. Exemplo de um processo de decisão de Markov Bellman encontrou uma forma de estimar o valor ideal do estado de qualquer estado s, descrito V*(s), que é a soma de todas as recompensas futuras descontadas que o agente pode esperar, em média, após atingir um estado s, supondo que ele atue de forma otimi-zada. Ele mostrou que, se o agente age de maneira ideal, então a Equação de Otimização de Bellman se aplica (veja Equação 16-1). Esta equação recursiva diz que, se o agente age de forma ideal, o valor ideal do estado atual é igual à recompensa que ele obterá, em média, após tomar uma ação otimizada mais o valor ideal esperado de todos os próximos estados possíveis que essa ação possa levar. Equação 16-1. Equação de Otimização de Bellman V*s=m axa∑s Ts,a,s Rs,a,s+γ. V*s para todo s T(s, a, s′) é a probabilidade de transição do estado s para o estado s′ dado que o agente escolheu a ação a; R(s, a, s′) é a rec ompensa que o agente obtém quando passa do estado s para o estado s′, dado que tenha escolhido a ação a; γ é a tax a de desconto. Essa equação leva diretamente a um algoritmo que pode estimar com precisão o valor do estado ideal de todos os estados possíveis: primeiro você inicializa todas as estimativas de valor de estado para zero e, utilizando o algoritmo de Iteração de Valor, as atualiza iterativamente (veja a Equação 16-2). Um resultado notável é que, com tempo suficiente, essas estimativas garantem convergir para os valores ótimos de estado, correspondendo à política otimizada. Equação 16-2. Algoritmo de Iteração de Valor Vk+1s maxa∑ s Ts,a,s Rs,a,s+γ. Vks para todo s CG_MIOLO_Hands_On_Machine_Learning. indb 475 07/05/2019 17:10:25

Mãos à obra Aprendizado de máquina Aurelien Geron.pdf

476 | Capítulo 16: Aprendizado por Reforço Vk(s) é o valor estimado do estado s na k-ésima iteração do algoritmo. Este algoritmo é um exemplo de Programação Dinâmica que divide um problema complexo (neste caso, estimando uma soma potencial-mente infinita de recompensas futuras descontadas) em subproble-mas tratáveis que podem ser abordados iterativamente (neste caso, encontrar a ação que maximiza a recompensa média mais o valor do próximo estado descontado). Conhecer os valores ideais de estado pode ser útil, principalmente para avaliar uma política, mas não informa ao agente explicitamente o que fazer. Felizmente, Bellman encontrou um algoritmo muito semelhante para estimar valores ótimos de estado-ação, geralmente chamados Q-Values. O ótimo Q-Value do par estado-ação ( s,a), identificado como Q*(s,a), é a soma das recompensas futuras descontadas que o agente pode esperar, em média, depois de atingir o estado s e escolher a ação a, mas antes de ver o resultado desta ação, supondo que ela funcione de maneira ideal após essa ação. Veja como funciona: mais uma vez, você começa inicializando todas as estimativas de Q-Value em zero e, em seguida, as atualiza com o algoritmo de Iteração Q-Value (veja a Equação 16-3). Equação 16-3. Algoritmo de Iteração Q-Value Qk+1(s, a) +γ. Σ s T(s, a, s )[R(s, a, s ) max a Qk(sa,)[para todo ( s, a) Definir a política ótima notada como π*(s), é trivial depois de ter os Q-Value s ideais: quando o agente está no estado s, ele deve escolher a ação com o Q-Value mais alto para esse estado: Aplicaremos este algoritmo ao MDP representado na Figura 16-8. Primeiro, precisamos defini-lo: nan = np. nan # representa ações impossíveis T = np. array([ # shape=[s, a, s'] [[0. 7, 0. 3, 0. 0], [1. 0, 0. 0, 0. 0], [0. 8, 0. 2, 0. 0]], [[0. 0, 1. 0, 0. 0], [nan, nan, nan], [0. 0, 0. 0, 1. 0]], [[nan, nan, nan], [0. 8, 0. 1, 0. 1], [nan, nan, nan]], ]) R = np. array([ # shape=[s, a, s'] [[10., 0. 0, 0. 0], [0. 0, 0. 0, 0. 0], [0. 0, 0. 0, 0. 0]], [[0. 0, 0. 0, 0. 0], [nan, nan, nan], [0. 0, 0. 0,-50. ]], [[nan, nan, nan], [40., 0. 0, 0. 0], [nan, nan, nan]], ]) possible_actions = [[0, 1, 2], [0, 2], [1]] CG_MIOLO_Hands_On_Machine_Learning. indb 476 07/05/2019 17:10:26

Mãos à obra Aprendizado de máquina Aurelien Geron.pdf

Aprendizado de Diferenças Temporais e Q-Learning | 477Agora, executaremos o algoritmo de Iteração Q-Value: Q = np. full((3, 3),-np. inf) #-inf para ações impossíveis for state, actions in enumerate(possible_actions): Q[state, actions] = 0. 0 # Valor inicial = 0. 0, para todas as ações possíveis discount_rate = 0. 95 n_iterations = 100 for iteration in range(n_iterations): Q_prev = Q. copy() for s in range(3): for a in possible_actions[s]: Q[s, a] = np. sum([ T[s, a, sp] * (R[s, a, sp] + discount_rate * np. max(Q_prev[sp])) for sp in range(3) ]) Os Q-Value s resultantes se parecem com isso: >>> Q array([[ 21. 89498982, 20. 80024033, 16. 86353093], [ 1. 11669335, -inf, 1. 17573546], [ -inf, 53. 86946068, -inf]]) >>> np. argmax(Q, axis=1) # ação ótima para cada estado array([0, 2, 1]) Temos, portanto, a política ideal para este MDP quando utilizarmos uma taxa de des-conto de 0,95: no estado s 0, escolha a ação a 0, no estado s 1 escolha a ação a 2 (passe pelo fogo!) e, no estado s 2, escolha a ação a 1 (a única ação possível). Curiosamente, a política ótima muda se você reduzir a taxa de desconto para 0,9: no estado s 1, a melhor ação se torna a0 (fique aí; não passe pelo fogo). Faz sentido porque, se você valoriza o presente muito mais que o futuro, então a perspectiva de recompensas futuras não vale a pena. Aprendizado de Diferenças Temporais e Q-Learning Problemas de Aprendizado por Reforço com ações discretas podem frequentemente ser modelados como processos de decisão de Markov, mas o agente inicialmente não tem ideia de quais são as probabilidades de transição ( T(s, a, s′)), e também não sabe quais serão as recompensas ( R(s, a, s′)). Ele deve experimentar cada estado e cada transição pelo menos uma vez para conhecer as recompensas, e deve experimentá-las várias vezes se quiser ter uma estimativa razoável das probabilidades de transição. O algoritmo Aprendizado por Diferença Temporal (TD Learning) é muito semelhante ao algoritmo de Iteração de Valor, mas é ajustado para levar em conta o fato de o agente ter conhecimento apenas parcial do MDP. Em geral, assumimos que o agente inicialmente CG_MIOLO_Hands_On_Machine_Learning. indb 477 07/05/2019 17:10:26

Mãos à obra Aprendizado de máquina Aurelien Geron.pdf

478 | Capítulo 16: Aprendizado por Reforçoconhece apenas os possíveis estados e ações, e nada mais. O agente utiliza uma política de exploração — por exemplo, uma política puramente aleatória — para explorar o MDP e, à medida que avança, o algoritmo TD Learning atualiza as estimativas dos valores de estado com base nas transições e recompensas realmente observadas (veja Equação 16-4). Equação 16-4. Algoritmo TD Learning Vk+1s 1-αVks+αr+γ. Vks' α é a taxa de aprendizado (por exemplo, 0,01). O TD Learning tem muitas semelhanças com o Gradiente Descendente Estocástico, em especial o fato de manipular uma amostra de cada vez. Assim como o SGD, ele só pode realmente convergir se você reduzir gradualmente a taxa de aprendizado (caso contrário, ele continuará saltando em torno do ótimo). Para cada estado s, além das recompensas que espera obter mais tarde (supondo que ele funcione de maneira ideal), este algoritmo simplesmente mantém o controle de uma média de execução das recompensas imediatas que o agente obtém ao sair desse estado. Da mesma forma, o algoritmo Q-Learning é uma adaptação do algoritmo de iteração Q-Value para a situação em que as probabilidades de transição e as recompensas são inicialmente desconhecidas (veja a Equação 16-5). Equação 16-5. Algoritmo Q-Learning Qk+1s,a 1-αQks,a+αr+γ. maxa'Qks',a' Para cada par estado-ação ( s, a), além das recompensas que ele espera obter mais tarde, esse algoritmo controla a média de execução das recompensas r que o agente obtém ao deixar o estado s com a ação a. Uma vez que a política-alvo agiria de maneira otimizada, tomamos o máximo das estimativas de Q-value para o próximo estado. O Q-Learning pode ser implementado assim: CG_MIOLO_Hands_On_Machine_Learning. indb 478 07/05/2019 17:10:27

Mãos à obra Aprendizado de máquina Aurelien Geron.pdf

Aprendizado de Diferenças Temporais e Q-Learning | 479learning_rate0 = 0. 05 learning_rate_decay = 0. 1 n_iterations = 20000 s = 0 # começa no estado 0 Q = np. full((3, 3),-np. inf) #-inf para ações impossíveis for state, actions in enumerate(possible_actions): Q[state, actions] = 0. 0 # Valor inicial = 0. 0, para todas as ações possíveis for iteration in range(n_iterations): a = np. random. choice(possible_actions[s]) # escolhe uma ação (aleatoriamente) sp = np. random. choice(range(3), p=T[s, a]) # escolhe o próximo estado usando T[s, a] reward = R[s, a, sp] learning_rate = learning_rate0 / (1 + iteration * learning_rate_decay) Q[s, a] = ((1-learning_rate) * Q[s, a] + learning_rate * (reward + discount_rate * np. max(Q[sp])) s = sp # muda para o próximo estado Com base em iterações suficientes, esse algoritmo convergirá para os Q-Values ideais, o que é chamado de algoritmo off-policy porque a política que está sendo treinada não é a que está sendo executada. É um pouco surpreendente que esse algoritmo seja capaz de aprender a política ótima observando um agente agir aleatoriamente (imagine aprender a jogar golfe quando seu professor é um macaco bêbado). Podemos melhorar? Políticas de Exploração É claro que o Q-Learning só funciona se a política de exploração explorar o MDP minu-ciosamente. Embora uma política de visita puramente aleatória muitas vezes seja garantida em todos os estados e todas as transições, pode levar um tempo extremamente longo para fazer isso. Portanto, uma melhor opção seria utilizar a ε-greedy policy : a cada passo, ela age aleatoriamente com probabilidade ε, ou avidamente (escolhendo a ação com o maior Q-Value) com probabilidade 1-ε. A vantagem da política ε-greedy (comparada a uma política completamente aleatória) é que ela gastará cada vez mais tempo explorando as partes interessantes do ambiente à medida que as estimativas de Q-Value ficarem me-lhores, enquanto ainda passa algum tempo visitando regiões desconhecidas do MDP. É bastante comum começar com um valor alto para ε (por exemplo, 1,0) e depois reduzi-lo gradualmente (por exemplo, até 0,05). Uma alternativa seria encorajar a política de exploração para tentar ações que ela não tentou antes, em vez de depender do acaso para a exploração, uma abordagem que pode ser implementada como um bônus adicionado às estimativas do Q-value, conforme mostrado na Equação 16-6. CG_MIOLO_Hands_On_Machine_Learning. indb 479 07/05/2019 17:10:27

Mãos à obra Aprendizado de máquina Aurelien Geron.pdf