text
stringlengths 0
3.9k
| source
stringclasses 1
value |
|---|---|
280 | Capítulo 10: Introdução às Redes Neurais Artificiais Exercícios 1. Desenhe uma RNA com a utilização dos neurônios artificiais originais (como os d a Figura 10-3) que calcule A ⊕ B (sendo que ⊕ representa a operação XOR). Dica: A ⊕ B = (A ∧ ¬ B) ∨ (¬ A ∧ B). 2. Por que geralmente é preferível utilizar um classificador de Regressão Logísti-ca em vez de um Perceptron clássico (ou seja, uma única camada de unidades lineares com threshold treinadas com a utilização do algoritmo de treinamento Perceptron)? Como você pode ajustar um Perceptron para torná-lo equivalente a um classificador de Regressão Logística? 3. Por q ue a função de ativação logística foi um ingrediente-chave na formação dos primeiros MLPs? 4. Nom eie três funções de ativação populares. Consegue desenhá-las? 5. Sup onha que você tenha um MLP composto de uma camada de entrada com 10 neurônios de passagem, seguido de uma camada oculta com 50 neurônios arti-ficiais e, finalmente, uma camada de saída com 3 neurônios artificiais. Todos os neurônios artificiais utilizam a função de ativação Re LU. Qua l é a forma da matriz de entrada X? O que d izer da forma do vetor de peso da camada oculta W h, e da forma de seus vetores de polarização b h? Qua l é a forma do vetor de peso W o, da camada de saída e seu vetor de pola-rização bo? Qua l é a forma da saída de rede da matriz Y ? Esc reva a equação que calcule a saída de rede da matriz Y como uma função de X, Wh, bh, Wo e bo. 6. De qu antos neurônios você precisa na camada de saída se quiser classificar o e-mail como spam ou não spam? Que função de ativação você deve utilizar na camada de saída? Se, em vez disso, você quiser abordar o MNIST, de quantos neurônios você precisa utilizando qual função de ativação na camada de saída? Responda as mesmas perguntas para fazer sua rede prever os preços imobiliários, como no Capítulo 2. 7. O que é r etropropagação e como isso funciona? Qual é a diferença entre retropro-pagação e autodiff de modo reverso? CG_MIOLO_Hands_On_Machine_Learning. indb 280 07/05/2019 17:09:19 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
Exercícios | 2818. Você consegue listar todos os hiperparâmetros que podem ser ajustados em um ML P? Se o MLP se sobreajusta aos dados de treinamento, como ajustar esses hiperparâmetros para tentar resolver o problema? 9. Tre ine um MLP profundo no conjunto de dados MNIST e veja se você consegue obter mais de 98% de precisão. Assim como no último exercício do Capítulo 9, tente adicio-nar todos os extras (ou seja, salve os pontos de verificação, restaure o último ponto de verificação em caso de interrupção, adicione resumos, plote as curvas de aprendizado com a utilização do Tensor Board e assim por diante). As soluções para estes exercícios estão disponíveis no Apêndice A. CG_MIOLO_Hands_On_Machine_Learning. indb 281 07/05/2019 17:09:19 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
CG_MIOLO_Hands_On_Machine_Learning. indb 282 07/05/2019 17:09:19 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
283Capítulo 11 Treinando Redes Neurais Profundas No Capítulo 10, introduzimos as redes neurais artificiais e treinamos nossa primeira rede neural profunda. Mas era uma DNN muito rasa, com apenas duas camadas ocultas. E, se você precisar resolver um problema muito mais complexo, como detectar cente-nas de tipos de objetos em imagens de alta resolução? Talvez você precise treinar uma DNN muito mais profunda, com (digamos) 10 camadas cada uma contendo centenas de neurônios, conectadas por centenas de milhares de conexões, o que não seria nada fácil: Primeiro, você enfrentaria o complicado problema dos vanishing gradients (ou o pr oblema relacionado com os exploding gradients ) que afeta as redes neurais profundas e faz com que seja muito difícil treinar as camadas inferiores; Seg undo, o treinamento seria extremamente lento em uma rede tão grande; Ter ceiro, um modelo com milhões de parâmetros poderia colocar em risco o sobreajuste do conjunto de treinamento. Neste capítulo, passaremos por cada um desses problemas e apresentaremos técnicas para resolvê-los. Vamos começar por explicar o problema dos vanishing gradients e ex-plorar algumas das soluções mais populares para ele. Em seguida, analisaremos vários otimizadores que podem acelerar tremendamente o treinamento de grandes modelos em comparação com o Gradiente Descendente regular. Finalmente, passaremos por algumas técnicas populares de regularização para grandes redes neurais. Com estas ferramentas, você poderá treinar redes muito profundas: bem-vindo ao Aprendizado Profundo! Problemas dos Gradientes: Vanishing/Exploding Conforme discutimos no Capítulo 10, o algoritmo de retropropagação funciona quando passa da camada de saída para a camada de entrada, propagando o gradiente de erro no caminho. Uma vez que o algoritmo tenha calculado o gradiente da função de custo CG_MIOLO_Hands_On_Machine_Learning. indb 283 07/05/2019 17:09:19 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
284 | Capítulo 11: Treinando Redes Neurais Profundasem relação a cada parâmetro na rede, ele utiliza esses gradientes para atualizar cada parâmetro com uma etapa do Gradiente Descendente. Infelizmente, os gradientes geralmente ficam cada vez menores à medida que o algo-ritmo avança para as camadas inferiores. Como resultado, a atualização do Gradiente Descendente deixa os pesos de conexão da camada inferior praticamente inalterados e o treinamento nunca converge para uma boa solução. Este é o chamado problema dos vanishing gradients. Em alguns casos, o contrário pode acontecer: os gradientes podem crescer cada vez mais, as camadas recebem atualizações de peso insanamente grandes e o algoritmo diverge, o que é o problema dos exploding gradients, encontrados principalmente em redes neurais recorrentes (veja o Capítulo 14). No geral, as redes neurais profundas sofrem de gradientes instáveis; diferentes camadas podem aprender em velocidades muito diferentes. Embora durante muito tempo este comportamento infeliz tenha sido observado empiri-camente (foi uma das razões pelas quais as redes neurais profundas foram abandonadas por muito tempo), somente por volta de 2010 é que foi feito um progresso significativo para sua compreensão. Um artigo intitulado “Understanding the Difficulty of Training Deep Feedforward Neural Networks” ( http://goo. gl/1rh Aef ) por Xavier Glorot e Yoshua Bengio1 encontrou alguns suspeitos, incluindo a combinação da popular função de ativação sigmoidal logística e a técnica de inicialização do peso que foi mais popular na época, ou seja, a inicialização aleatória, quando utilizamos uma distribuição normal com uma média de 0 e um desvio padrão de 1. Em suma, eles mostraram que, com esta função de ativação e esse esquema de inicialização, a variância das saídas de cada camada era muito maior do que a variância de suas entradas. Ao avançar na rede, a variância continua aumentando após cada camada até que a função de ativação sature nas camadas superiores. Isso fica pior pelo fato de a função logística ter uma média de 0,5, não 0 (a função tangente hiperbólica tem uma média de 0 e se comporta um pouco melhor em redes profundas do que a função logística). Olhando para a função de ativação logística (veja a Figura 11-1), você verá que, quando as entradas se tornam grandes (negativas ou positivas), a função satura em 0 ou 1 com uma derivada extremamente próxima de 0. Assim, quando a retropropagação entra em ação, ela praticamente não tem um gradiente para se propagar de volta através da rede, e o pouco gradiente existente continua diluindo à medida que a retropropagação avança através das camadas superiores, de forma a não sobrar praticamente nada para as camadas inferiores. 1 “Understanding the Difficulty of Training Deep Feedforward Neural Networks”, X. Glorot, Y Bengio (2010). CG_MIOLO_Hands_On_Machine_Learning. indb 284 07/05/2019 17:09:19 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
Problemas dos Gradientes: Vanishing/Exploding | 285 Função de ativação sigmóide Linear Saturando Saturando Figura 11-1. Saturação da função de ativação logística Inicialização Xavier e Inicialização He Glorot e Bengio propõem em seu artigo uma forma de aliviar significativamente esse problema. Precisamos que o sinal flua corretamente em ambas as direções: na direção forward quando fizer previsões e na direção reverse ao retropropagar gradientes. Nós não queremos que o sinal desapareça, nem queremos que ele exploda e sature. Para que o sinal flua corretamente, os autores argumentam que a variância das saídas de cada camada deve ser igual à variância de suas entradas,2 e também que os gradientes tenham igual variância antes e depois de fluir na direção reversa através de uma camada (verifique o artigo se você está interessado nos detalhes matemáticos). Na verdade, não é possível garantir ambos, a menos que a camada tenha um número igual de conexões de entrada e saída, mas o que eles propuseram funciona muito bem na prática: os pesos de conexão devem ser inicializados aleatoriamente, conforme descrito na Equação 11-1, em que nentradas e nsaídas são o número de conexões de entrada e saída para a camada cujos pesos estão sendo inicializados (também chamado de fan-in e fan-out ). Esta estratégia de inicialização é chamada Inicialização Xavier (homenageando o primeiro nome do autor), ou algumas vezes Inicialização Glorot. 2 Leia a analogia: se você ajustar o botão do amplificador de microfone muito perto de zero, as pessoas não ouvirão sua voz, mas, se ajustar bem perto do máximo, sua voz ficará saturada e as pessoas não entenderão o que você está dizendo. Agora, imagine uma cadeia de tais amplificadores: todos precisam ser configurados adequadamente para que sua voz saia alta e clara no final da corrente. Sua voz deve sair de cada amplificador com a mesma amplitude que entrou. CG_MIOLO_Hands_On_Machine_Learning. indb 285 07/05/2019 17:09:20 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
286 | Capítulo 11: Treinando Redes Neurais Profundas Equação 11-1. Inicialização Xavier (quando se utiliza a função de ativação logística) Normal Distribuição com média0 e desvio padrão σ=2 nentradas+nsaídas Ou uma distribuição uniforme entre /uni2010r e +r, com r=6 nentradas+nsaídas Quando o número de conexões de entrada é aproximadamente igual ao número de co-nexões de saída, você obtém equações mais simples3 (por exemplo, σ=1/nentradas ou r=3/nsaídas). O uso da estratégia da inicialização Xavier pode acelerar consideravelmente o treinamento e é um dos truques que levaram ao sucesso atual do Aprendizado Profundo. Alguns artigos recentes ( http://goo. gl/VHP3p B )4 forneceram estratégias semelhantes para diferentes funções de ativação, conforme mostrado na Tabela 11-1. A estratégia de inicialização para a função de ativação Re LU (e suas variantes, incluindo a ativação ELU descrita brevemente) às vezes é chamada de Inicialização He (sobrenome do autor). Esta é a es-tratégia que utilizamos no Capítulo 10. Tabela 11-1. Parâmetros de inicialização para cada tipo de função de ativação Função de ativação Distribuição uniforme [-r, r] Distribuição normal Logística r=6 nentradas+nsaídasσ=2 nentradas+nsaídas r=46 nentradas+nsaídasσ=42 nentradas+nsaídas r= 26 nentradas+nsaídasσ= 22 nentradas+nsaídas Tangente Hiperbólica Re LU (e suas variantes) Por padrão, a função tf. layers. dense() (introduzida no Capítulo 10) utiliza a inicializa-ção Xavier (com uma distribuição uniforme), mas é possível mudar para a inicialização He usando a função variance_scaling_initializer() desta forma: he_init = tf. contrib. layers. variance_scaling_initializer() hidden1 = tf. layers. dense(X, n_hidden1, activation=tf. nn. relu, kernel_initializer=he_init, name="hidden1") 3 Esta estratégia simplificada já foi proposta anteriormente — por exemplo, no livro de 1998 Neural Networks: Tr icks of the Trade de Genevieve Orr e Klaus-Robert Muller (Springer). 4 Tal c omo “Delving Deep into Rectifiers: Surpassing Human-Level Performance on Image Net Classification”, K. He et al. (2015). CG_MIOLO_Hands_On_Machine_Learning. indb 286 07/05/2019 17:09:20 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
Problemas dos Gradientes: Vanishing/Exploding | 287A inicialização He considera somente o fan-in, não a média entre fan-in e fan-out, como na inicialização Xavier. Este t ambém é o padrão para a função variance_scaling_initializer(), mas você pode mudar isso configurando o argumento mode="FAN_AVG". Funções de Ativação Não Saturadas Uma das ideias no artigo de 2010 de Glorot e Bengio dizia que os problemas dos gra-dientes vanishing/exploding aconteceram em parte devido a uma má escolha da função de ativação. Até então, a maioria das pessoas tinha assumido que, se a Mãe Natureza escolheu utilizar funções de ativação mais ou menos sigmoides em neurônios biológicos, esta deveria ser a escolha certa. Mas, acontece que outras funções de ativação se com-portam muito melhor em redes neurais profundas, em particular a função de ativação Re LU, principalmente porque esta não fica saturada com valores positivos (e também porque sua computação é muito rápida). Infelizmente, a função de ativação Re LU não é perfeita. Ela sofre de um problema conhecido como dying Re LUs : durante o treinamento, alguns neurônios efetivamente morrem, o que significa que deixam de exibir algo que não seja 0. Em alguns casos, parece que a metade dos neurônios da sua rede está morta, especialmente quando foi utilizada uma grande taxa de aprendizado. Se os pesos de um neurônio forem atualizados durante o treinamento de modo que a soma ponderada das entradas seja negativa, ele começará a exibir 0. Quando isso acontecer, será improvável que ele volte à vida útil uma vez que o gradiente da função Re LU será 0 quando sua entrada for negativa. Para resolver este problema, utilizamos uma variante da função Re LU, como a leaky Re LU, definida como Leaky Re LU α(z) = max( αz, z) (veja a Figura 11-2). O hiperparâmetro α de-fine o quanto a função “vaza”: z < 0 é a inclinação da função, e é tipicamente configurada para 0,01. Esta pequena inclinação garante que as leaky Re LUs nunca morram; elas podem entrar em um coma profundo, mas têm a chance de eventualmente acordar. Um artigo recente ( https://goo. gl/B1xh Kn )5 comparou diversas variantes da função de ativação Re LU e uma de suas conclusões foi que as variantes vazantes sempre superaram a rígida função de ativação Re LU. De fato, configurar α =0,2 (grande vazamento) parece resultar em um melhor desempenho do que α = 0,01 (pequeno vazamento). Eles também avaliaram a randomized leaky Re LU (RRe LU), em que α é escolhido aleatoriamente em um determinado intervalo durante o treinamento, e corrigido para um valor médio durante o teste. Esta função também teve um bom desempenho e pareceu agir como um regularizador (reduzindo 5 “Empirical Evaluation of Rectified Activations in Convolution Network”, B. Xu et al. (2015). CG_MIOLO_Hands_On_Machine_Learning. indb 287 07/05/2019 17:09:21 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
288 | Capítulo 11: Treinando Redes Neurais Profundaso risco de se sobreajustar ao conjunto de treinamento). Finalmente, eles também avaliaram a parametric leaky Re LU (PRe LU), em que α está autorizado a ser aprendido durante o treinamento (em vez de ser um hiperparâmetro, ele se torna um parâmetro que pode ser modificado por retropropagação como qualquer outro parâmetro). Isso supera o Re LU em conjuntos de dados com grandes imagens, mas em conjuntos de dados menores ele corre o risco de se sobreajustar ao conjunto de treinamento. Função de ativação Leak y Re LU Vazamento Figura 11-2. Leaky Re LU Por último, mas não menos importante, um artigo de 2015 ( http://goo. gl/Sdl2P7 ) por Djork-Arné Clevert et al. 6 propôs uma nova função de ativação chamada exponential linear unit (ELU), que superou todas as variantes Re LU em suas experiências: o tempo de treina-mento foi reduzido e a rede neural ficou melhor no conjunto de testes. Ela está representada na Figura 11-3 e a Equação 11-2 mostra sua definição. Equação 11-2. Função de ativação ELU ELUαz=αexp z-1 ifz<0 z ifz≥0 Função de ativação ELU Figura 11-3. Função de ativação ELU 6 “Fast and Accurate Deep Network Learning by Exponential Linear Units (ELU)”, D. Clevert, T. Unterthiner, S. H ochreiter (2015). CG_MIOLO_Hands_On_Machine_Learning. indb 288 07/05/2019 17:09:21 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
Problemas dos Gradientes: Vanishing/Exploding | 289Ela se parece muito com a função Re LU, mas tem algumas diferenças importantes: Pri meiro, ela assume valores negativos quando z < 0, o que permite que a unida-de tenha uma saída média mais próxima de 0, ajudando a aliviar o problema dos vanishing gradients, como discutido anteriormente. O hiperparâmetro α define o valor de aproximação da função ELU quando z for um grande número negati-vo. Normalmente, ele é configurado em 1, mas você pode ajustá-lo como qualquer outro hiperparâmetro, se quiser; Seg undo, ela tem um gradiente diferente de zero para z < 0, o que evita o proble-ma das unidades mortas; Ter ceiro, a função é suave em todas as partes, incluindo quando está próxima de z = 0, o que ajuda a acelerar o Gradiente Descendente uma vez que não rebate tanto a esquerda e a direita de z = 0. A principal desvantagem da função de ativação ELU é que seu cálculo é mais lento do que o da Re LU e suas variantes (devido ao uso da função exponencial), mas, durante o treinamento, isso é compensado pela taxa de convergência mais rápida. No entanto, no período de teste, uma rede ELU será mais lenta do que uma rede Re LU. Então, qual função de ativação devemos utilizar para as camadas ocultas de redes neurais profundas? Embora a sua velocidade va-rie, no geral ELU > leaky Re LU (e suas variantes) > Re LU > tanh > logistic. Se você se importa muito com o desempenho em tempo de execução, prefira as leaky Re LUs em relação às ELUs. Se você não quiser ajustar mais um outro hiperparâmetro, pode utilizar os valores padrão de α sugeridos anteriormente (0,01 para a leaky Re LU e 1 para ELU). Se você tiver tempo livre e poder de computação, utilize a validação cruzada na avaliação de outras funções de ativação, em particular RRe LU, se a sua rede estiver sobreajustada, ou PRe LU, se tiver um conjunto de treinamento enorme. O Tensor Flow oferece a função elu() que pode ser utilizada na construção de sua rede neural. Configure o argumento activation desta forma ao chamar a função dense() : hidden1 = tf. layers. dense(X, n_hidden1, activation=tf. nn. elu, name="hidden1") O Tensor Flow não possui uma função predefinida para leaky Re LUs, mas é fácil definir: def leaky_relu(z, name=None): return tf. maximum(0. 01 * z, z, name=name) hidden1 = tf. layers. dense(X, n_hidden1, activation=leaky_relu, name="hidden1") CG_MIOLO_Hands_On_Machine_Learning. indb 289 07/05/2019 17:09:22 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
290 | Capítulo 11: Treinando Redes Neurais Profundas Normalização em Lote Embora a utilização da inicialização He juntamente com ELU (ou qualquer variante de Re LU) possa reduzir significativamente os problemas dos gradientes vanishing /exploding no início do treinamento, isto não garante que eles não retornem durante o treinamento. Em um artigo de 2015 ( https://goo. gl/g A4GSP ),7 Sergey Ioffe e Christian Szegedy pro-puseram uma técnica para endereçar os problemas dos gradientes vanishing/exploding chamada Normalização em Lote (BN, em inglês) e, de uma forma geral, o problema da mudança da distribuição das entradas de cada camada durante o treinamento à medi-da que mudam os parâmetros das camadas anteriores (que eles chamam de problema Internal Covariate Shift ). A técnica consiste em adicionar uma operação no modelo imediatamente antes da função de ativação de cada camada, ao simplesmente centralizar em zero e normalizar as entradas, e então escalonar e deslocar o resultado utilizando dois novos parâmetros por camada (um para dimensionamento, outro para deslocamento). Em outras palavras, esta operação permite que o modelo aprenda a escala ideal e a média das entradas para cada camada. O algoritmo precisa estimar a média e o desvio padrão das entradas para centralizar em zero e normalizá-las, que ele faz ao avaliar o desvio padrão e a média das entradas em relação ao minilote atual (daí o nome “Normalização em Lote"). Toda esta operação está resumida na Equação 11-3. Equação 11-3. Algoritmo de normalização em lote 1. B=1 m B∑ i=1m B xi 2. σB2=1 m B∑ i=1m B xi-B2 3. xi=xi-B σB2+ 4. zi=γxi+β /uni03F5 μB é a média empírica avaliada em todo o minilote B; σB é o desvio padrão empírico também avaliado em relação a todo o minilote; 7 “Batch Normalization: Accelerating Deep Network Training by Reducing Internal Covariate Shift”, S. Ioffe an d C. Szegedy (2015). CG_MIOLO_Hands_On_Machine_Learning. indb 290 07/05/2019 17:09:22 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
Problemas dos Gradientes: Vanishing/Exploding | 291 m B é o número de instâncias no minilote; 1. B=1 m B∑ i=1m B xi 2. σB2=1 m B∑ i=1m B xi-B2 3. xi=xi-B σB2+ 4. zi=γxi+β /uni03F5 (i) é a entrada normalizada e centralizada em zero; γ é o parâ metro de escala para a camada; β é o parâ metro de deslocamento ( offset ) para a camada; ϵ é um número minúsculo para evitar a divisão por zero (tipicamente 10-5), chamado smoothing term ; z(i) é a saída da operação BN: é uma versão escalonada e deslocada das entradas. No período de teste, não há minilote para calcular a média empírica e o desvio padrão, então utilizamos a média e o desvio padrão do conjunto de treinamento. Estes geralmente são calculados eficientemente durante o treinamento com a utilização de uma média móvel. No total, quatro parâmetros são aprendidos para cada camada normalizada em lote: γ (escala), β (deslocamento), μ (média), e σ (desvio padrão). Os autores demonstraram que esta técnica melhorou consideravelmente todas as redes neurais profundas experimentadas. O problema dos vanishing gradients foi reduzido drasticamente, ao ponto em que eles poderiam utilizar funções de ativação saturadas como a tanh e até mesmo a de ativação logística. As redes também eram muito menos sensíveis à inicialização do peso. Eles puderam utilizar taxas de aprendizado bem maiores, acelerando significativamente o processo de aprendizado. Especificamente, eles observam que “Aplicada a um modelo de classificação de imagem de última geração, a Normalização em Lote atinge a mesma precisão com 14 vezes menos etapas de treinamento e supera o modelo original por uma margem significativa. [... ] Ao utilizarmos um ensemble de redes normalizadas por lotes, desenvolvemos ainda mais o melhor resultado publicado na classificação Image Net: atingindo um erro de validação de 4,9% no top5 (e de 4,8% no teste de erro), superando a precisão dos avaliadores humanos. ” Finalmente, como um brinde, a Normalização em Lote também funciona como um regulador, reduzindo a necessidade de outras técnicas de regularização (como o dropout, descrito mais adiante no capítulo). No entanto, a normalização em lote adiciona um tanto de complexidade ao modelo (embora remova a necessidade de normalizar os dados de entrada, pois a primeira camada oculta cuidará disso, desde que seja normalizada em lote). Além disso, há uma penalidade em tempo de execução: a rede neural faz previsões mais lentas devido aos cálculos extras necessários em cada camada. Então, se você precisa que as previsões sejam rápidas, verifique o desempenho da ELU + inicialização He antes de brincar com a Normalização em Lote. CG_MIOLO_Hands_On_Machine_Learning. indb 291 07/05/2019 17:09:22 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
292 | Capítulo 11: Treinando Redes Neurais Profundas Você pode achar que o treinamento é bem lento no início, enquanto o Gradiente Descendente estiver procurando os melhores escalonamentos e deslocamentos para cada camada, mas ele acelera ao encontrar valores razoavelmente bons. Implementando a Normalização em Lote com o Tensor Flow O Tensor Flow fornece uma função tf. nn. batch_normalization() que centra e norma-liza as entradas, mas você deve calcular a média e o desvio padrão (baseado nos dados em minilotes durante o treinamento ou no conjunto completo de dados durante o teste, como discutido) e passá-los como parâmetros para esta função, além de lidar também com a criação dos parâmetros de escalonamento e deslocamento (e passá-los para esta função). Não é a abordagem mais conveniente, mas é possível. Em vez disso, utilize a função tf. layers. batch_normalization(), que cuida de tudo isso para você, como no código a seguir: import tensorflow as tf n_inputs = 28 * 28 n_hidden1 = 300n_hidden2 = 100 n_outputs = 10 X = tf. placeholder(tf. float32, shape=(None, n_inputs), name="X")training = tf. placeholder_with_default(False, shape=(), name='training')hidden1 = tf. layers. dense(X, n_hidden1, name="hidden1") bn1 = tf. layers. batch_normalization(hidden1, training=training, momentum=0. 9) bn1_act = tf. nn. elu(bn1) hidden2 = tf. layers. dense(bn1_act, n_hidden2, name="hidden2") bn2 = tf. layers. batch_normalization(hidden2, training=training, momentum=0. 9) bn2_act = tf. nn. elu(bn2)logits_before_bn = tf. layers. dense(bn2_act, n_outputs, name="outputs")logits = tf. layers. batch_normalization(logits_before_bn, training=training, momentum=0. 9) Acompanharemos este código. Até definirmos o placeholder training, as pri-meiras linhas são autoexplicativas: durante o treinamento, vamos configurá--lo para True, senão o padrão será False. Isto será utilizado para dizer à função tf. layers. batch_normalization() se ela deve utilizar a média atual dos minilotes e desvio padrão (durante o treinamento) ou a média de todo o conjunto de treinamento e desvio padrão (durante o teste). Em seguida, alternamos camadas totalmente conectadas e camadas de normalização em lote: quando utilizamos a função tf. layers. dense(), as camadas totalmente conectadas são criadas, assim como fizemos no Capítulo 10. Observe que não especificamos nenhu-CG_MIOLO_Hands_On_Machine_Learning. indb 292 07/05/2019 17:09:23 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
Problemas dos Gradientes: Vanishing/Exploding | 293ma função de ativação para as camadas totalmente conectadas porque queremos aplicar a função de ativação após cada camada de normalização de lote. 8 Com a utilização da função tf. layers. batch_normalization(), criamos as camadas de normalização em lote configurando seus parâmetros training e momentum. O algoritmo BN utiliza o decaimento exponencial para calcular as médias em execução, razão pela qual requer o parâmetro momentum : dado um novo valor v, a média em execução v é atualizada pela equação: v v×momentum + v×1-momentum Um bom valor para o momentum seria próximo de 1 — por exemplo, 0,9, 0,99, ou 0,999 (coloque mais “9” para conjuntos maiores e minilotes menores). Você deve ter notado que o código é bem repetitivo, com os mesmos parâmetros de nor-malização em lote se repetindo. Para evitar esta repetição, utilizamos a função partial() do módulo functools (parte da biblioteca padrão do Python), que cria um invólucro fino em torno de uma função e permite definir valores padrão para alguns parâmetros. A criação das camadas da rede no código anterior pode ser modificada desta forma: from functools import partial my_batch_norm_layer = partial(tf. layers. batch_normalization, training=training, momentum=0. 9) hidden1 = tf. layers. dense(X, n_hidden1, name="hidden1") bn1 = my_batch_norm_layer(hidden1) bn1_act = tf. nn. elu(bn1) hidden2 = tf. layers. dense(bn1_act, n_hidden2, name="hidden2") bn2 = my_batch_norm_layer(hidden2) bn2_act = tf. nn. elu(bn2) logits_before_bn = tf. layers. dense(bn2_act, n_outputs, name="outputs")logits = my_batch_norm_layer(logits_before_bn) Pode não parecer muito melhor do que antes neste pequeno exemplo, mas esse truque tornará seu código muito mais legível se você tiver 10 camadas e quiser utilizar a mes-ma função de ativação, o mesmo inicializador, o mesmo regularizador, etc., em todas as camadas. O resto da fase de construção é o mesmo do Capítulo 10: definir a função de custo, criar um otimizador, instruí-lo a minimizar a função de custo, definir as operações de avaliação, criar um inicializador de variáveis, criar um Saver e assim por diante. A fase de execução também é praticamente a mesma com duas exceções. Primeiro, durante o treinamento, você precisa definir o placeholder training para True sempre que executar uma operação que depende da camada batch_normalization(). Segundo, 8 Muitos pesquisadores argumentam que é tão bom quanto, ou até melhor, colocar as camadas de normalização de lote após (e não antes) as ativações. CG_MIOLO_Hands_On_Machine_Learning. indb 293 07/05/2019 17:09:23 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
294 | Capítulo 11: Treinando Redes Neurais Profundasa função batch_normalization() cria algumas operações que devem ser avaliadas em cada etapa durante o treinamento a fim de atualizar as médias móveis (lembre-se de que essas médias móveis são necessárias na avaliação da média e desvio padrão do conjunto de treinamento). Essas operações são adicionadas automaticamente à coleção UPDATE_OPS, então apenas precisamos obter a lista de operações nessa coleção e executá-las em cada iteração do treinamento: extra_update_ops = tf. get_collection(tf. Graph Keys. UPDATE_OPS) 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) sess. run([training_op, extra_update_ops], feed_dict={training: True, X: X_batch, y: y_batch}) accuracy_val = accuracy. eval(feed_dict={X: mnist. test. images, y: mnist. test. labels}) print(epoch, "Test accuracy:", accuracy_val) save_path = saver. save(sess, ". /my_model_final. ckpt") Isso é tudo! Neste pequeno exemplo com apenas duas camadas, é improvável que a Nor-malização em Lote tenha um impacto muito positivo, mas para redes mais profundas pode fazer uma grande diferença. Gradient Clipping Uma técnica popular para diminuir o problema das explosões dos gradientes é limitá-los durante a retropropagação, de modo que nunca excedam um limiar (isto é útil para redes neurais recorrentes, veja o Capítulo 14), e é chamada de Gradient Clipping ( http://goo. gl/d RDAaf ). 9 Em geral, as pessoas preferem a Normalização em Lote, mas ainda é útil conhecer o Gradient Clipping e como implementá-lo. A função minimize() do otimizador cuida de calcular e aplicar os gradientes no Tensor Flow, então você deve, em vez disso, chamar o primeiro método do otimizador compute_gradients(), criar uma operação para limitar os gradientes com a utilização da função clip_by_value() e, finalmente, criar uma operação para aplicar os limiares nos gradientes com a utilização do método apply_gradients() do otimizador: threshold = 1. 0 optimizer = tf. train. Gradient Descent Optimizer(learning_rate) grads_and_vars = optimizer. compute_gradients(loss) capped_gvs = [(tf. clip_by_value(grad,-threshold, threshold), var) for grad, var in grads_and_vars] training_op = optimizer. apply_gradients(capped_gvs) 9 “On the difficulty of training recurrent neural networks” R. Pascanu et al. (2013). CG_MIOLO_Hands_On_Machine_Learning. indb 294 07/05/2019 17:09:23 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
Reutilizando Camadas Pré-Treinadas | 295Como de costume, você executaria então este training_op em cada etapa de treinamento e ele calculará os gradientes, os limitará entre-1. 0 e 1. 0 e os aplicará. O limiar é um hiperparâmetro ajustável. Reutilizando Camadas Pré-Treinadas Geralmente, não é uma boa ideia iniciar o treinamento do zero em uma DNN muito grande: em vez disso, tente sempre encontrar uma rede neural existente que realize uma tarefa similar à que você está tentando implementar, e então reutilize as camadas inferiores desta rede. Esta técnica é denominada transfer learning, e não só acelerará consideravelmente o treinamento, mas também exigirá muito menos dados de treinamento. Por exemplo, suponha que você tenha acesso a uma DNN que tenha sido treinada para classificar imagens em 100 categorias diferentes, incluindo animais, plantas, veículos e objetos do cotidiano. Agora, você deseja treinar uma DNN para classificar tipos especí-ficos de veículos. Essas tarefas são muito semelhantes, então você deve tentar reutilizar partes da primeira rede (veja a Figura 11-4). Pesos treináveis Pesos /f_ixos Novo DNN para tarefa similar BDNN Existente para tarefa AReuso Saída Oculta 4 Oculta 3 Oculta 2 Oculta 1 Input laye r Oculta 3 Oculta 2 Oculta 1 Input laye r Oculta 4Oculta 5Saída Figura 11-4. Reutilizando camadas pré-treinadas Se as imagens de entrada da sua nova tarefa não tiverem o mesmo tamanho das usadas na tarefa original, você terá que adicionar uma etapa de pré-processamento para redimensioná-las para o tamanho esperado pelo modelo original. De forma mais geral, a transferência de aprendizado só funcionará bem se as entradas tiverem caracterís-ticas de baixo nível semelhantes. CG_MIOLO_Hands_On_Machine_Learning. indb 295 07/05/2019 17:09:24 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
296 | Capítulo 11: Treinando Redes Neurais Profundas Reutilizando um Modelo do Tensor Flow Se o modelo original foi treinado com o Tensor Flow, você pode restaurá-lo e treiná-lo na nova tarefa. Utilizamos a função import_meta_graph() para importar as operações para o grafo padrão, como discutido no Capítulo 9, retornando um Saver que pode ser utilizado mais tarde para carregar o estado do modelo: saver = tf. train. import_meta_graph(". /my_model_final. ckpt. meta") Lidaremos com as operações e os tensores necessários para o treinamento por meio dos métodos do grafo get_operation_by_name() e get_tensor_by_name(). O nome de um tensor é o nome da operação que o produz seguido por :0 (ou :1 se for a segunda saída, :2 se for a terceira, e assim por diante): X = tf. get_default_graph(). get_tensor_by_name("X:0") y = tf. get_default_graph(). get_tensor_by_name("y:0") accuracy = tf. get_default_graph(). get_tensor_by_name("eval/accuracy:0") training_op = tf. get_default_graph(). get_operation_by_name("Gradient Descent") Teremos que explorar o grafo para encontrar os nomes das operações necessárias se o modelo pré-treinado não estiver bem documentado. Neste caso, podemos explorar o grafo utilizando o Tensor Board (para isso você deve primeiro exportar o grafo utilizando um File Writer, conforme discutido no Capítulo 9) ou você pode utilizar o método get_operations() do grafo para listar todas as operações: for op in tf. get_default_graph(). get_operations(): print(op. name) Se você é o autor do modelo original, documentar e nomear as operações de forma bem clara facilita o trabalho das pessoas que reutilizarão seu modelo. Outra abordagem seria a criação de uma coleção com todas as operações importantes para que as pessoas possam ter conhecimento: for op in (X, y, accuracy, training_op): tf. add_to_collection("my_important_ops", op) Desta forma, as pessoas que reutilizam seu modelo poderão escrever simplesmente: X, y, accuracy, training_op = tf. get_collection("my_important_ops") Você pode, então, restaurar o estado do modelo e continuar o treinamento com seus próprios dados utilizando o Saver : with tf. Session() as sess: saver. restore(sess, ". /my_model_final. ckpt") [... ] # treine o modelo com seus próprios dados Como alternativa, se você tiver acesso ao código Python que criou o grafo original, você pode usá-lo em vez de import_meta_graph(). CG_MIOLO_Hands_On_Machine_Learning. indb 296 07/05/2019 17:09:24 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
Reutilizando Camadas Pré-Treinadas | 297No geral, você reutilizará apenas parte do modelo original, tipicamente as camadas inferiores. Se você utilizar o import_meta_graph() para restaurar o grafo, ele carregará todo o grafo original, mas nada o impede de ignorar as camadas nas quais você não tem interesse. Por exemplo, como mostrado na Figura 11-4, você poderia construir novas camadas (por exemplo, uma camada oculta e uma camada de saída) no topo de uma ca-mada pré-treinada (por exemplo, camada oculta pré-treinada 3). Você também precisaria calcular a perda para esta nova saída e criar um otimizador para minimizá-la. Se você tem acesso ao código Python do grafo pré-treinado, poderá reutilizar apenas as partes necessárias e cortar o resto. Neste caso, você precisa de um Saver para restaurar o modelo pré-treinado (especificando as variáveis que deseja restaurar, caso contrário o Tensor Flow reclamará que os grafos não coincidem) e outro Saver para salvar o novo modelo. Por exemplo, o código a seguir restaura apenas as camadas ocultas 1, 2 e 3: [... ] # construa o novo modelo com as mesmas camadas ocultas 1-3 como antes reuse_vars = tf. get_collection(tf. Graph Keys. GLOBAL_VARIABLES, scope="hidden[123]") # expressão regularreuse_vars_dict = dict([(var. op. name, var) for var in reuse_vars]) restore_saver = tf. train. Saver(reuse_vars_dict) # para restaurar camadas 1-3 init = tf. global_variables_initializer() # para iniciar todas as variáveis, velhas e novas saver = tf. train. Saver() # para salvar o novo modelo with tf. Session() as sess: init. run() restore_saver. restore(sess, ". /my_model_final. ckpt") [... ] # treine o modelo save_path = saver. save(sess, ". /my_new_model_final. ckpt") Primeiro, criamos o nosso modelo certificando-nos de copiar as camadas ocultas de 1 a 3 do modelo original. Depois, utilizando a expressão regular " hidden[123] ", obtemos a lista de todas as variáveis nas camadas ocultas de 1 a 3 e criamos um dicionário que ma-peará o nome de cada variável com seu nome no novo modelo (geralmente você manterá os mesmos nomes), no modelo original. Em seguida, criamos um Saver que restaurará apenas essas variáveis. Também criamos uma operação para inicializar todas as variáveis, não apenas as camadas 1 a 3 (antigas e novas) e um segundo Saver para salvar o novo modelo. Em seguida, iniciamos uma sessão, inicializamos todas as variáveis no modelo e restauramos os valores da variável das camadas 1 a 3 do modelo original. Finalmente, treinamos e salvamos o modelo na nova tarefa. Quanto mais semelhantes forem as tarefas, mais camadas você reu-tilizará (começando com as camadas inferiores). Para tarefas muito semelhantes, você pode tentar manter todas as camadas ocultas e substituir apenas a camada de saída. CG_MIOLO_Hands_On_Machine_Learning. indb 297 07/05/2019 17:09:25 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
298 | Capítulo 11: Treinando Redes Neurais Profundas Reutilizando Modelos de Outras Estruturas Você precisará carregar manualmente os parâmetros do modelo se ele foi treinado com a utilização de outra estrutura (por exemplo, utilizar o código Theano se for treinado com Theano) e então os atribuir às variáveis apropriadas, trabalho que pode ser bem tedioso. Por exemplo, o código a seguir mostra como você copiaria o peso e os vieses da primeira camada oculta de um modelo treinado em outra estrutura: original_w = [... ] # carregue os pesos do outro modelo original_b = [... ] # carregue os vieses do outro modelo X = tf. placeholder(tf. float32, shape=(None, n_inputs), name="X") hidden1 = tf. layers. dense(X, n_hidden1, activation=tf. nn. relu, name="hidden1") [... ] # Construa o resto do modelo # Entenda os nós de atribuição para as variáveis ocultas 1 graph = tf. get_default_graph() assign_kernel = graph. get_operation_by_name("hidden1/kernel/Assign") assign_bias = graph. get_operation_by_name("hidden1/bias/Assign")init_kernel = assign_kernel. inputs[1] init_bias = assign_bias. inputs[1] init = tf. global_variables_initializer() with tf. Session() as sess: sess. run(init, feed_dict={init_kernel: original_w, init_bias: original_b}) # [... ] Treine o modelo em sua nova tarefa Nesta implementação, primeiro carregamos o modelo pré-treinado na outra estrutura (não mostrada aqui) e extraímos os parâmetros do modelo que queremos reutilizar. Então construímos nosso modelo do Tensor Flow como de costume. Em seguida, vem a parte complicada: cada variável do Tensor Flow tem uma operação de atribuição associada que é utilizada em sua inicialização. Começamos por nos aprofundar nessas operações de atribuição, que têm o mesmo nome que a variável, além de " /Assign". Também nos aprofundaremos na segunda entrada da operação de atribuição que corresponde ao valor que será atribuído à variável, que neste caso é o valor de inicialização da variável. Uma vez iniciada a sessão, executamos a operação de inicialização de sempre, mas, desta vez, alimentamos os valores que queremos para as variáveis que queremos reutilizar. Como alternativa, poderíamos criar novas operações de atribuição, placeholders e utilizá-los para definir os valores das variáveis após a inicialização. Mas por que criar novos nós no grafo quando tudo o que precisamos já está lá? Congelando as Camadas Inferiores É provável que as camadas inferiores da primeira DNN tenham aprendido a detectar carac-terísticas de baixo nível em imagens para as reutilizarmos do jeito que estão, o que será útil em ambas as tarefas de classificação. Geralmente, é uma boa ideia “congelar” seus pesos ao CG_MIOLO_Hands_On_Machine_Learning. indb 298 07/05/2019 17:09:25 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
Armazenamento em Cache das Camadas Congeladas | 299treinar a nova DNN: se os pesos da camada inferior forem fixos, será mais fácil treinar os pesos da camada superior (porque não terão que aprender com um alvo em movimento). Uma solução para congelar as camadas inferiores durante o treinamento é dar ao otimizador a lista de variáveis a serem treinadas, excluindo as das camadas inferiores: train_vars = tf. get_collection(tf. Graph Keys. TRAINABLE_VARIABLES, scope="hidden[34]|outputs") training_op = optimizer. minimize(loss, var_list=train_vars) A primeira linha obtém a lista de todas as variáveis treináveis nas camadas ocultas 3 e 4 e na camada de saída, deixando de fora as variáveis nas camadas ocultas 1 e 2. Em seguida, fornecemos esta lista restrita de variáveis treináveis para a função minimize() do otimizador. É isso! As camadas 1 e 2 estão congeladas: elas não se moverão durante o treinamento e, por isso, geralmente são chamadas de frozen layers. Outra opção seria adicionar uma camada stop_gradient() ao grafo. Qualquer camada abaixo dela será congelada: with tf. name_scope("dnn"): hidden1 = tf. layers. dense(X, n_hidden1, activation=tf. nn. relu, name="hidden1") # reutilizado, congelado hidden2 = tf. layers. dense(hidden1, n_hidden2, activation=tf. nn. relu, name="hidden2") # reutilizado, congelado hidden2_stop = tf. stop_gradient(hidden2) hidden3 = tf. layers. dense(hidden2_stop, n_hidden3, activation=tf. nn. relu, name="hidden3") # reutilizado, descongelado hidden4 = tf. layers. dense(hidden3, n_hidden4, activation=tf. nn. relu, name="hidden4") # novo! logits = tf. layers. dense(hidden4, n_outputs, name="outputs") # novo! Armazenamento em Cache das Camadas Congeladas É possível armazenar em cache a saída da camada congelada mais alta para cada instância de treinamento uma vez que as camadas congeladas não mudam. Como o treinamento passa muitas vezes por todo o conjunto de dados, isso lhe dará um enorme ganho de velocidade, pois você só precisa passar por camadas congeladas uma vez por instância de treinamento (em vez de uma vez por época). Por exemplo, você pode primeiro executar todo o conjunto de treinamento pelas camadas inferiores (supondo que você tenha memória RAM suficiente) e, então, durante o treinamento, em vez de construir lotes de instâncias de treinamento, criar lotes de saídas da camada oculta 2 e alimentá-los para a operação de treinamento: CG_MIOLO_Hands_On_Machine_Learning. indb 299 07/05/2019 17:09:25 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
300 | Capítulo 11: Treinando Redes Neurais Profundasimport numpy as np n_batches = mnist. train. num_examples // batch_sizewith tf. Session() as sess: init. run() restore_saver. restore(sess, ". /my_model_final. ckpt") h2_cache = sess. run(hidden2, feed_dict={X: mnist. train. images}) for epoch in range(n_epochs): shuffled_idx = np. random. permutation(mnist. train. num_examples) hidden2_batches = np. array_split(h2_cache[shuffled_idx], n_batches) y_batches = np. array_split(mnist. train. labels[shuffled_idx], n_batches) for hidden2_batch, y_batch in zip(hidden2_batches, y_batches): sess. run(training_op, feed_dict={hidden2:hidden2_batch, y:y_batch}) save_path = saver. save(sess, ". /my_new_model_final. ckpt") A última linha do loop de treinamento executa a operação de treinamento definida anteriormente (que não toca as camadas 1 e 2) e alimenta um lote de saídas da segunda camada oculta (assim como os alvos para esse lote). Como fornecemos a saída da camada oculta 2 ao Tensor Flow, ele não tenta avaliá-la (ou qualquer nó que dependa dela). Ajustando, Descartando ou Substituindo as Camadas Superiores A camada de saída do modelo original geralmente deve ser substituída, pois é provável que não seja útil para a nova tarefa e talvez nem tenha o número certo de saídas para tanto. Da mesma forma, as camadas ocultas superiores do modelo original são menos propen-sas a ser tão úteis quanto as camadas inferiores, uma vez que as características de alto nível que são mais úteis para a nova tarefa podem diferir significativamente daquelas que foram mais úteis para a tarefa original. Desejamos encontrar o número certo de camadas para serem reutilizadas. Primeiro, tente congelar todas as camadas copiadas, depois treine seu modelo e veja como ele funciona. Em seguida, tente descongelar uma ou duas das camadas ocultas mais altas para permitir que a retropropagação as altere e veja se o desempenho melhora. Quanto mais dados de treinamento você tiver, mais camadas poderá descongelar. Caso não consiga um bom desempenho e ainda possua poucos dados de treinamento, tente descartar a(s) camada(s) oculta(s) superior(es) e congelar novamente todas as cama-das ocultas restantes. Você pode iterar até encontrar o número certo de camadas para a reutilização. Caso possua muitos dados de treinamento, pode tentar substituir as camadas ocultas superiores em vez de descartá-las e até mesmo adicionar mais camadas ocultas. CG_MIOLO_Hands_On_Machine_Learning. indb 300 07/05/2019 17:09:26 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
Armazenamento em Cache das Camadas Congeladas | 301Zoológicos de Modelos Onde você pode encontrar uma rede neural treinada para uma tarefa semelhante à que você quer executar? O primeiro lugar a pesquisar é obviamente o seu próprio catálogo de modelos. Esta é uma boa razão para salvar todos os seus modelos e organizá-los para recuperá-los mais facilmente. Outra opção é buscar em um Zoológico de Modelos. Muitas pessoas treinam modelos de Aprendizado de Máquina para várias tarefas e liberam seus modelos pré-treinados para o público. O Tensor Flow tem seu próprio zoológico de modelos disponível em https://github. com/ tensorflow/models, que contém a maioria das redes de classificação de imagens de última geração como a VGG, Inception e Res Net (veja o Capítulo 13, e verifique o diretório models/slim ), incluindo os códigos, os modelos pré-treinados e as ferramentas para baixar conjuntos de dados de imagens populares. Outro zoológico de modelos popular é o Caffe's Model Zoo ( https://goo. gl/XI02X3 ). Ele também possui muitos modelos de visão computacional (por exemplo, Le Net, Alex Net, ZFNet, Goog Le Net, VGGNet, Inception) treinados em vários conjuntos de dados (por exemplo, Image Net, Places Database, CIFAR10, etc. ). Saumitro Dasgupta projetou um conversor que está disponível em https:// github. com/ethereon/caffe-tensorflow. Pré-treinamento Não Supervisionado Suponha que você queira enfrentar uma tarefa complexa para a qual não tenha mui-tos dados rotulados de treinamento e infelizmente não consiga encontrar um modelo treinado em uma tarefa similar. Não perca a esperança! Em primeiro lugar, você deve naturalmente tentar reunir mais dados rotulados de treinamento, mas se isso for muito difícil, ou muito caro, você ainda pode realizar um pré-treinamento não supervisiona-do (veja a Figura 11-5). Ou seja, se você tem uma abundância de dados de treinamento não rotulados, pode tentar treinar as camadas uma a uma, começando com a camada inferior e então subir, com a utilização de um algoritmo detector de características sem supervisão como as Máquinas Restritas de Boltzmann (RBMs, ver Apêndice E) ou autoen-coders (veja o Capítulo 15). Cada camada é treinada na saída das camadas previamente treinadas (todas as camadas estão congeladas, exceto a que está sendo treinada). Uma vez que todas as camadas foram treinadas dessa forma, você pode ajustar a rede utilizando o aprendizado supervisionado (isto é, com retropropagação). Este é um processo bastante longo e tedioso, mas muitas vezes funciona bem; na ver-dade, é essa técnica que Geoffrey Hinton e sua equipe utilizaram em 2006 e que levou ao renascimento das redes neurais e ao sucesso do Aprendizado Profundo. Até 2010, o CG_MIOLO_Hands_On_Machine_Learning. indb 301 07/05/2019 17:09:26 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
302 | Capítulo 11: Treinando Redes Neurais Profundaspré-treinamento não supervisionado (utilizando-se RBMs) era a norma para redes pro-fundas, e foi somente após o problema do vanishing gradient ter sido amenizado que se tornou mais comum treinar DNNs com a utilização da retropropagação. No entanto, o pré-treinamento não supervisionado (com a utilização de autoencoders em vez de RBMs) ainda é uma boa opção quando temos uma tarefa complexa para resolver na ausência de um modelo similar que possa ser reutilizado, ou poucos dados de treinamento rotulados com muitos dados de treinamento não rotulados. Oculta 1Oculta 2Oculta 3 Oculta 1Oculta 2Oculta 3Saíd a Camada de entrad a Camada de entrad a Camada de entrad a Camada de entrad a Oculta 1 Oculta 1Oculta 2 Dado não rotulado Dado rotulado Não supervisionado (exemplo: autoencoders) Supervisionado (backprop) e ajuste as camadas superiores Treine a camada de saída Treine a camada 1T reine a camada 2T reine a camada 3 Figura 11-5. Pré-treinamento sem supervisão Pré-treinamento em uma Tarefa Auxiliar Uma última opção seria treinar uma primeira rede neural em uma tarefa auxiliar para a qual você pode facilmente obter ou gerar dados rotulados e depois reutilizar as cama-das inferiores dessa rede para sua tarefa real. As primeiras camadas inferiores da rede neural aprenderão a detectar características que provavelmente serão reutilizáveis pela segunda rede neural. Por exemplo, se você quer criar um sistema para reconhecer rostos e tem somente al-gumas fotos de cada indivíduo, claramente isto não é suficiente para treinar um bom classificador. Não seria prático reunir centenas de imagens de cada pessoa. No entanto, você pode reunir muitas fotos aleatórias de pessoas na internet e treinar a primeira rede neural para detectar se duas fotos diferentes apresentam ou não a mesma pessoa. Essa CG_MIOLO_Hands_On_Machine_Learning. indb 302 07/05/2019 17:09:26 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
Otimizadores Velozes | 303rede teria bons detectores de características de rostos, portanto, reutilizar suas cama-das inferiores permitiria que você formasse um bom classificador de rostos utilizando poucos dados de treinamento. Normalmente, reunir exemplos de treinamento não rotulados é barato, mas rotulá-los é bem caro. Uma técnica comum nessa situação é rotular todos os seus exemplos de treinamento como “bom", em seguida gerar várias novas instâncias de treinamento corrompendo as boas e rotulando essas instâncias corrompidas como “ruim". Então você pode treinar uma primeira rede neural a fim de classificar instâncias como boas ou ruins. Por exemplo, você pode baixar milhões de frases, rotulá-las como “boas” e, então, alterar aleatoriamente uma palavra em cada frase e rotular as frases resultantes como “ruim". Se uma rede neural consegue dizer que “ O cachorro dorme ” é uma boa sentença, mas “ O cachorro eles ” é ruim, provavelmente ela sabe muito sobre linguagem. Muitas tarefas do processamento de idiomas podem se beneficiar com a reutilização de suas camadas inferiores. Outra abordagem seria treinar uma primeira rede para produzir uma pontuação para cada instância de treinamento e utilizar uma função de custo que garanta que a pon-tuação de uma boa instância seja maior que a pontuação de uma ruim, com pelo menos alguma margem, o que é chamado de max margin learning. Otimizadores Velozes Treinar uma enorme rede neural profunda pode ser um processo lentíssimo. Até agora, vimos quatro maneiras de acelerar o treinamento (e alcançar uma solução melhor): aplicar uma boa estratégia de inicialização para os pesos da conexão, utilizar uma boa função de ativação, utilizar a Normalização em Lote e reutilizar partes de uma rede pré-treinada. Outro grande impulso na velocidade vem do uso de um otimizador mais veloz do que o otimizador regular do Gradiente Descendente. Nesta seção, apresenta-remos os mais populares: otimização Momentum, Gradiente Acelerado de Nesterov, Ada Grad, RMSProp, e finalmente otimização Adam. Otimização Momentum Imagine uma bola de boliche rolando em um declive suave em uma superfície lisa: sua rolagem iniciará lentamente, mas rapidamente pegará impulso até que chegue à velocidade final (se houver algum atrito ou resistência ao ar). Esta é a ideia bem simples por trás da otimização Momentum proposta por Boris Polyak em 1964 ( https://goo. gl/Fl SE8c ). 10 Em 10 “Some methods of speeding up the convergence of iteration methods”, B. Polyak (1964). CG_MIOLO_Hands_On_Machine_Learning. indb 303 07/05/2019 17:09:26 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
304 | Capítulo 11: Treinando Redes Neurais Profundascontraste, o Gradiente Descendente regular dará pequenos passos regulares em direç ão à inclinação, então demorará muito mais tempo para chegar ao fundo. Lembre-se que o Gradiente Descendente simplesmente atualiza os pesos θ subtraindo diretamente o gradiente da função de custo J(θ) com relação aos pesos ( ∇θJ(θ)) mul-tiplicados pela taxa de aprendizado η. A eq uação é: θ ← θ-η∇θJ(θ). Ele não se importa com os gradientes anteriores e irá bem devagar se o gradiente local for pequeno. A otimização Momentum se preocupa muito com os gradientes anteriores: a cada iteração, ela subtrai o gradiente local do vetor momentum m (multiplicado pela taxa de aprendizado η) e atualiza os pesos adicionando esse vetor momentum (veja a Equação 11-4). Em outras palavras, o gradiente é utilizado como aceleração, não como velocidade. Para simular algum tipo de mecanismo de fricção e evitar que o momentum cresça muito, o algoritmo introduz um novo hiperparâmetro β chamado simplesmente de momentum que deve ser ajustado entre 0 (alta fricção) e 1 (sem fricção). Um valor típico do momentum é 0,9. Equação 11-4. Algoritmo Momentum 1. m βm-ηθJθ 2. θ θ+m Verificamos facilmente que, se o gradiente permanece constante, a velocidade terminal (ou seja, o tamanho máximo das atualizações do peso) será igual ao gradiente mul-tiplicado pela taxa de aprendizado η multiplicada por (ignorando o sinal). Por exemplo, se β = 0,9, então a velocidade terminal é igual a 10 vezes o gradiente vezes a taxa de aprendizado e a otimização Momentum acaba 10 vezes mais rápida do que Gradiente Descendente, permitindo que ela escape de platôs com muito mais rapidez do que o Gradiente Descendente. Em particular, vimos no Capítulo 4 que, quando as entradas têm escalas muito diferentes da função de custo, elas têm a aparência de uma tigela alongada (veja a Figura 4-7). O Gradiente Descendente desce a encosta íngreme muito rapidamente, mas demora muito para descer o vale. Em contrapartida, a otimização Momentum rolará para o fundo do vale cada vez mais rápido até chegar ao seu destino (o ótimo). As camadas superiores geralmente têm entradas em redes neurais profundas com escalas muito diferentes que não utilizam a Normalização em Lote, então utilizar a otimização Momentum ajuda muito, além de poder auxiliar a superar o local optimum. Devido ao momentum, o otimizador pode ultrapassar um pouco, então voltar, ultrapassar novamente, e oscilar assim por muitas vezes antes de se estabilizar no mínimo. Esta é uma das razões pelas quais é bom termos um pouco de fricção no sistema: ele se livra dessas oscilações e assim acelera a convergência. CG_MIOLO_Hands_On_Machine_Learning. indb 304 07/05/2019 17:09:26 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
Otimizadores Velozes | 305É muito fácil implementar a otimização Momentum no Tensor Flow: substitua o Gradient Descent Optimizer pelo Momentum Optimizer e, então, relaxe e aproveite! optimizer = tf. train. Momentum Optimizer(learning_rate=learning_rate, momentum=0. 9) Sua única desvantagem é que ela ainda adiciona outro hiperparâmetro que deve ser configurado. No entanto, o valor de 0,9 do momentum geralmente funciona bem na prática e quase sempre é mais rápido do que o Gradiente Descendente. Gradiente Acelerado de Nesterov Uma pequena variante da otimização Momentum proposta por Yurii Nesterov em 1983 (https://goo. gl/V011v D ),11 quase sempre é mais rápida do que a otimização Momentum normal. A ideia da otimização Momentum de Nesterov, ou Gradiente Acelerado de Nesterov (NAG, em inglês) é medir o gradiente da função de custo, não na posição local, mas ligeiramente à frente, na direção do momentum (ver Equação 11-5). A única diferença da otimização Momentum normal é que o gradiente é medido em θ + βm em vez de θ. Equação 11-5. Algoritmo Gradiente Acelerado de Nesterov 1. m βm-ηθJθ+βm 2. θ θ+m Este pequeno ajuste funciona porque em geral o vetor momentum estará apontando na di-reção certa (ou seja, em direção ao optimum), então ele será um pouco mais preciso quando utilizarmos o gradiente medido ligeiramente mais adiante nessa direção em vez de usar o gradiente na posição original, como você pode ver na Figura 11-6 (em que ∇ 1 representa o gradiente da função de custo medida no ponto inicial θ, e ∇2 representa o gradiente no ponto localizado em θ + βm). Como podemos ver, a atualização Nesterov termina um pouco mais próxima do optimum e, depois de um tempo, essas pequenas melhorias se somam e o NAG acaba sendo significativamente mais rápido do que a otimização Momentum. Além disso, note que, quando o momentum empurra os pesos por um vale, ∇ 1 continua a avançar ainda mais, enquanto ∇ 2 puxa para trás em direção ao fundo do vale, ajudando a reduzir as oscilações e assim convergir mais rapidamente. Em comparação com a otimização Momentum, o NAG quase sempre acelerará o trei-namento. Para utilizá-la, ao criar o Momentum Optimizer configure use_nesterov=True : optimizer = tf. train. Momentum Optimizer(learning_rate=learning_rate, momentum=0. 9, use_nesterov=True) 11 “A Method for Unconstrained Convex Minimization Problem with the Rate of Convergence O(1/k2)”, Yurii Nesterov (1983). CG_MIOLO_Hands_On_Machine_Learning. indb 305 07/05/2019 17:09:27 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
306 | Capítulo 11: Treinando Redes Neurais Profundas Ponto inicial Atualização do momentum regular Atualização de Nesterov Ótimo Figura 11-6. Otimização Regular versus otimização Momentum de Nesterov Ada Grad Considere novamente o problema da tigela alongada: o Gradiente Descendente começa a descer a encosta mais íngreme rapidamente para depois descer mais lentamente em direção ao fundo do vale. Seria bom se o algoritmo pudesse detectar isso antecipadamente e corrigir sua direção para apontar um pouco mais para o global optimum. O algoritmo Ada Grad (http://goo. gl/4Tyd4j )12 consegue isso escalonando o vetor gradiente na dimensão mais íngreme (veja a Equação 11-6): Equação 11-6. Algoritmo Ada Grad 1. s s+θJθθJθ 2. θ θ-ηθJθ s+ O primeiro passo acumula o quadrado dos gradientes no vetor s (o símbolo ⊗ representa a multiplicação elemento por elemento). Esta forma vetorizada é equivalente a calcular si ← si + (∂ J(θ) / ∂ θi) para cada elemento si do vetor s; em outras palavras, cada si acumula os quadrados da derivada parcial da função de custo com relação ao pa-râmetro θi. Se a função de custo for íngreme ao longo da i-ésima dimensão, então si ficará cada vez maior a cada iteração. O segundo passo é quase idêntico ao Gradiente Descendente, mas com uma grande diferença: o vetor gradiente é reduzido por um fator de (o símbolo ⊘ representa a divisão elemento por elemento, e ϵ é um termo de suavização para evitar a divisão por zero, tipicamente ajustada para 10-10). Esta forma vetorizada é equivalente a calcular para todos os parâmetros θi (simultaneamente). Em suma, este algoritmo degrada a taxa de aprendizado, mas com mais rapidez para dimensões íngremes do que para dimensões com declividade mais suave, o que é chamado 12 “Adaptive Subgradient Methods for Online Learning and Stochastic Optimization”, J. Duchi et al. (2011). CG_MIOLO_Hands_On_Machine_Learning. indb 306 07/05/2019 17:09:28 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
Otimizadores Velozes | 307de taxa de aprendizado adaptativa. Ele ajuda a apontar mais diretamente as atualizações resultantes em direção ao global optimum (veja a Figura 11-7), além de ter o ben efício adicional de requerer muito menos ajuste da taxa de aprendizado do hiperparâmetro η. (dimensão íngreme) Gradiente Descendente Ada Grad Custo (dimensão mais plana) Figura 11-7. Ada Grad versus Gradiente Descendente Ada Grad geralmente funciona bem para problemas quadráticos simples mas, infeliz-mente, muitas vezes ele para muito cedo quando treinamos redes neurais. A taxa de aprendizado diminui tanto que o algoritmo acaba parando completamente antes de atingir o global optimum. Embora o Tensor Flow tenha o Adagrad Optimizer, você não deve utilizá-lo no treinamento de redes neurais profundas (embora seja eficiente para tarefas mais simples, como a Regressão Linear). RMSProp Embora o Ada Grad fique devagar muito rapidamente e nunca convirja para o global optimum, o algoritmo RMSProp 13 corrige isto acumulando somente os gradientes das iterações mais recentes (em vez de todos os gradientes desde o início do treinamento) por meio do decaimento exponencial no primeiro passo (veja a Equação 11-7). Equação 11-7. Algoritmo RMSProp 1. s βs+1-βθJθθJθ 2. θ θ-ηθJθ s+ A taxa de degradação β é ajustada para 0,9. Sim, mais uma vez é um novo hiperparâmetro, mas esse valor padrão geralmente funciona bem, então você não precisa sincronizá-lo. 13 Este algoritmo foi criado por Tijmen Tieleman e Geoffrey Hinton em 2012 e apresentado por Geoffrey Hinton em sua aula no Coursera sobre redes neurais (slides: http://goo. gl/Rs Qeis; video: https://goo. gl/XUb Iy J ). Surpreendentemente, uma vez que os autores não escreveram um artigo para descrevê-lo, os pesquisadores frequentemente citam “slide 29 da aula 6” em seus artigos. CG_MIOLO_Hands_On_Machine_Learning. indb 307 07/05/2019 17:09:28 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
308 | Capítulo 11: Treinando Redes Neurais Profundas Como era de se esperar, o Tensor Flow tem uma classe RMSProp Optimizer : optimizer = tf. train. RMSProp Optimizer(learning_rate=learning_rate, momentum=0. 9, decay=0. 9, epsilon=1e-10) Exceto em problemas muito simples, esse otimizador quase sempre funciona muito me-lhor do que o Ada Grad. Na verdade, foi o algoritmo de otimização preferido de muitos pesquisadores até surgir a Otimização de Adam. Otimização Adam Adam (https://goo. gl/Un8Axa ),14 que significa estimativa de momento adaptativo [adap-tive moment estimation ], combina as ideias de otimização Momentum e RMSProp: assim como a otimização Momentum, ela acompanha uma média exponencialmente decadente de gradientes passados, e, assim como o RMSProp, controla uma média exponencialmente decadente de gradientes quadrados passados (veja a Equação 11-8). 15 Equação 11-8. Algoritmo Adam 1. m β1m-1-β1 θJθ 2. s β2s+1-β2 θJθθJθ 3. mm 1-β1t 4. ss 1-β2t 5. θ θ+ηm s+ t representa o número da iteração (começando em 1). Se você visualizar as etapas 1, 2 e 5, notará a semelhança de Adam com a otimização Momentum e RMSProp. A única diferença é que o passo 1 calcula a média exponen-cialmente decadente em vez da soma exponencialmente decadente, mas essas são equi-valentes, exceto por um fator constante (a média decadente é apenas 1-β 1 vezes a soma decadente). Os passos 3 e 4 são detalhes técnicos: uma vez que m e s são inicializados em 0, serão polarizados em direção a 0 no início do treinamento, então essas duas etapas ajudarão a impulsionar m e s neste momento inicial. 14 “Adam: A Method for Stochastic Optimization”, D. Kingma, J. Ba (2015). 15 Est as são estimativas da variância média (não centralizada) dos gradientes. A média é frequentemente cha-mada de primeiro momento, enquanto a variância é frequentemente chamada de segundo momento, daí o nome do algoritmo. CG_MIOLO_Hands_On_Machine_Learning. indb 308 07/05/2019 17:09:28 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
Otimizadores Velozes | 309O hiperparâmetro β 1 de decaimento de momentum é tipicamente inicializado em 0,9, enquanto o hiperparâmetro β 2 de decaimento escalonado é inicializado em 0,999. Como anteriormente, o termo de suavização ε é inicializado com um número minúsculo, como 10-8. Estes são os valores padrão para a classe Adam Optimizer do Tensor Flow, então você pode utilizar: optimizer = tf. train. Adam Optimizer(learning_rate=learning_rate) De fato, como o Adam é um algoritmo de taxa de aprendizado adaptativa (como o Ada Grad e RMSProp) ele requer menos ajuste do hiperparâmetro de taxa de aprendizado η, portanto, você pode utilizar o valor padrão η = 0,001, fazendo com que a utilização de Adam seja ainda mais fácil do que a do Gradiente Descendente. 16 Este livro inicialmente recomendava o uso da otimização de Adam porque ela era considerada mais rápida e melhor do que outros mé-todos. No entanto, um artigo de 2017 (https://goo. gl/NAk WIa) 16 de Ashia C. Wilson et al. mostrou que os métodos de otimização adap-tativa (ou seja, Ada Grad, RMSProp e otimização de Adam) podem levar a soluções que generalizam mal em alguns conjuntos de dados. Então, é melhor manter a otimização do Momentum ou Gradiente Acelerado de Nesterov por enquanto até que os pesquisadores te-nham uma melhor compreensão desta questão. Todas as técnicas de otimização discutidas até agora somente se basearam nas derivadas parciais de primeira ordem ( Jacobianas ). A literatura de otimização contém algoritmos surpreendentes com base nas derivadas parciais de segunda ordem (as Hessianas ), mas, infelizmente, é muito difícil aplicá-los às redes neurais profundas porque há n2 Hessianas por saída (sendo que n é o número de parâmetros), ao contrário de apenas n Jacobianas por saída. Como as DNNs normalmente possuem dezenas de milhares de parâmetros, os algoritmos de otimização de segunda ordem muitas vezes nem cabem na memória, e, mesmo quando o fazem, o cálculo para as Hessianas é muito lento. Treinando Modelos Esparsos Todos os algoritmos de otimização que acabamos de apresentar produzem modelos densos, o que significa que a maioria dos parâmetros será diferente de zero. Se você precisa de um modelo muito rápido em tempo de execução, ou se precisar de menos memória, talvez seja melhor usar um modelo esparso. 16 “The Marginal Value of Adaptive Gradient Methods in Machine Learning,” A. C. Wilson et al. (2017). CG_MIOLO_Hands_On_Machine_Learning. indb 309 07/05/2019 17:09:29 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
310 | Capítulo 11: Treinando Redes Neurais Profundas Uma maneira trivial de conseguir isso é treinar o modelo como de costume e depois livrar-se dos pesos muito pequenos (configure-os para 0). Outra opção é aplicar uma forte regularização ℓ1 durante o treinamento, pois ele empurra o otimizador para zerar o máximo de pesos possível (como discutido no Capítulo 4 sobre a Regressão Lasso). No entanto, em alguns casos, essas técnicas podem ser insuficientes. Uma última opção se-ria aplicar Dual Averaging, chamado Follow The Regularized Leader (FTRL), uma técnica proposta por Y urii Nesterov ( https://goo. gl/x SQD4C ). 17 Quando utilizada com a regulari-zação ℓ1, esta técnica leva a modelos muito esparsos. O Tensor Flow implementa uma va-riante FTRL chamada FTRL-Proximal (https://goo. gl/bxme2B )18 na classe FTRLOptimizer. 1718Cronograma da Taxa de Aprendizado Pode ser complicado encontrar uma boa taxa de aprendizado. Configurando-a alta demais, o treinamento pode, na verdade, divergir (como discutimos no Capítulo 4). Se configurá-la muito baixa, o treinamento acabará por convergir para o optimum, mas demorará muito. Ao configurá-la um pouco alta, ela avançará muito rapidamente no início, mas acabará dançando em torno do optimum, nunca se estabelecendo (a menos que você utilize um algoritmo de otimização da taxa de aprendizado adaptativo como o Ada Grad, RMSProp ou Adam, mas, mesmo assim, pode demorar para se estabelecer). Se você tiver um orçamento computacional limitado, talvez seja necessário interromper o treinamento antes que ele possa convergir corretamente, resultando em uma solução subótima (veja a Figura 11-8). Perda alto demais: diverge muito alto: subótimomuito pequeno: lento na medida Comece com uma alta taxa de aprendizado e então a reduza: perfeito!Época Figura 11-8. Curvas de aprendizado para várias taxas de aprendizado η 17 “Primal-Dual Subgradient Methods for Convex Problems,” Yurii Nesterov (2005). 18 “Ad C lick Prediction: a View from the Trenches,” H. Mc Mahan et al. (2013). CG_MIOLO_Hands_On_Machine_Learning. indb 310 07/05/2019 17:09:29 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
Otimizadores Velozes | 311Talvez seja possível encontrar uma taxa de aprendizado muito boa ao treinar sua rede várias vezes durante apenas algumas épocas utilizando diversas taxas de aprendizado e comparando suas curvas. A taxa de aprendizado ideal aprenderá rapidamente e con-vergirá para uma boa solução. No entanto, tem uma opção melhor do que a taxa de aprendizado constante: se você começar com uma alta taxa de aprendizado e em seguida reduzi-la quando deixar de fazer progresso rápido, alcançará mais rapidamente uma boa solução do que com a taxa constante ideal de aprendizado. Existem muitas estratégias diferentes para reduzir a taxa de aprendizado durante o treinamento, chamadas cronogramas de aprendizado (introduzimos brevemente esse conceito no Capítulo 4), as mais comuns são: Taxa de aprendizado constante por partes predeterminadas Por exemplo, configure a taxa de aprendizado para η 0 = 0,1, então para η 1 = 0,001 após 50 épocas. Embora esta solução possa funcionar muito bem, muitas vezes requererá que a alteremos para descobrirmos as taxas de aprendizado e quando utilizá-las corretamente. Agendamento de Desempenho Meça o erro de validação a cada N passos (assim como para a parada antecipada) e reduza a taxa de aprendizado por um fator λ quando o erro parar de cair. Agendamento Exponencial Defina a taxa de aprendizado para uma função do número da iteração t : η(t) = η 0 10-t/r. Isso funciona muito bem, mas requer ajuste em η 0 e r. A taxa de aprendizado cairá com um fator de 10 a cada r passos. Agendamento de Energia Defina a taxa de aprendizado em η( t) = η 0 (1 + t /r)-c. O hiperparâmetro c normal-mente é ajustado em 1. É parecido com o agendamento exponencial, mas a taxa de aprendizado cai bem mais lentamente. Um artigo de 2013 ( http://goo. gl/Hu6Zyq )19 escrito por Andrew Senior et al. comparou o desempenho de alguns dos cronogramas de aprendizado mais populares para o reco-nhecimento da fala ao treinar redes neurais profundas com a utilização da otimização Momentum. Os autores concluíram que, nesta configuração, tanto o agendamento de desempenho quanto o agendamento exponencial tiveram um bom desempenho, mas preferiram o agendamento exponencial porque é mais fácil de implementar e de ajustar, e convergiu um pouco mais rápido para a solução ótima. 19 “An Empirical Study of Learning Rates in Deep Neural Networks for Speech Recognition”, A. Senior et al. (2013). CG_MIOLO_Hands_On_Machine_Learning. indb 311 07/05/2019 17:09:29 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
312 | Capítulo 11: Treinando Redes Neurais Profundas Implementar um cronograma de aprendizado com o Tensor Flow é fácil: initial_learning_rate = 0. 1 decay_steps = 10000 decay_rate = 1/10 global_step = tf. Variable(0, trainable=False, name="global_step") learning_rate = tf. train. exponential_decay(initial_learning_rate, global_step, decay_steps, decay_rate) optimizer = tf. train. Momentum Optimizer(learning_rate, momentum=0. 9) training_op = optimizer. minimize(loss, global_step=global_step) Depois de configurar os valores dos hiperparâmetros, criamos uma variável não trei-nável global_step (inicializada em 0) para acompanhar o número atual da iteração de treinamento. Então definimos uma taxa de aprendizado de decaimento exponencial (com η0 = 0,1 e r = 10. 000) usando a função exponential_decay() do Tensor Flow. A seguir, criamos um otimizador (neste exemplo, um Momentum Optimizer ) usando esta taxa de aprendizado decadente. Finalmente, criamos a operação de treinamento chamando o método minimize() do otimizador, desde que passemos a variável global_step, ele cuidará de incrementá-la. É isso! Já que Ada Grad, RMSProp e a otimização Adam reduzem automaticamente a taxa de aprendizado durante o treinamento, não é necessário adicionar um cronograma de aprendizado extra. O uso do decaimento exponencial ou programação de desempenho pode acelerar consideravelmente a convergência para outros algoritmos de otimização. Evitando o Sobreajuste Por Meio da Regularização Com quatro parâmetros, eu coloco um elefante e com cinco eu consigo fazê-lo balançar sua tromba. —John von Neumann, citado por Enrico Fermi em Nature 427 As redes neurais profundas geralmente possuem dezenas de milhares de parâmetros, às vezes até milhões. Com tantos parâmetros, a rede tem uma incrível quantidade de liberdade e pode conter uma grande variedade de conjuntos de dados complexos. Mas essa grande flexibilidade também significa que está propensa a sobreajustar o conjunto de treinamento. Com milhões de parâmetros, você consegue colocar todo o zoológico. Nesta seção, apresentaremos algumas das técnicas de regularização mais populares para as redes neurais e como implementá-las com o Tensor Flow: parada antecipada, regularização ℓ 1 e ℓ 2, dropout, regularização max-norm e aumento de dados. CG_MIOLO_Hands_On_Machine_Learning. indb 312 07/05/2019 17:09:29 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
Evitando o Sobreajuste Por Meio da Regularização | 313Parada Antecipada Para evitar o sobreajuste do conjunto de treinamento, uma excelente solução é a parada antecipada (introduzida no Capítulo 4): basta interromper o treinamento quando seu desempenho no conjunto de validação começa a cair. Uma forma de implementar isso com o Tensor Flow seria avaliar o modelo em um conjunto de validação posto em intervalos regulares (por exemplo, a cada 50 etapas) e salvar um snapshot “vencedor” se ele superar os snapshots vencedores anteriores. Conte o número de etapas desde o último “vencedor” salvo e interrompa o treinamento quan-do esse número atingir um limite (por exemplo, 2. 000 passos). Em seguida, restaure o último snapshot “vencedor". Embora a parada antecipada funcione muito bem na prática, você pode obter um de-sempenho bem melhor de sua rede combinando-a com outras técnicas de regularização. Regularização ℓ1 e ℓ2 Você pode utilizar a regularização ℓ 1 e ℓ 2 para restringir os pesos da conexão de uma rede neural (mas não suas polarizações), assim como você fez no Capítulo 4 para os modelos lineares mais simples. Uma maneira de fazer isso é adicionar os termos de regularização adequados à sua função de custo ao utilizar o Tensor Flow. Por exemplo, digamos que você tem apenas uma camada oculta com peso W1 e uma camada oculta de saída com peso W2, então você pode aplicar a regularização ℓ 1 desta forma: [... ] # construa a rede neural W1 = tf. get_default_graph(). get_tensor_by_name("hidden1/kernel:0") W2 = tf. get_default_graph(). get_tensor_by_name("outputs/kernel:0") scale = 0. 001 # hiperparânetro de regularização l1 with tf. name_scope("loss"): xentropy = tf. nn. sparse_softmax_cross_entropy_with_logits(labels=y, logits=logits) base_loss = tf. reduce_mean(xentropy, name="avg_xentropy") reg_losses = tf. reduce_sum(tf. abs(W1)) + tf. reduce_sum(tf. abs(W2)) loss = tf. add(base_loss, scale * reg_losses, name="loss") No entanto, essa abordagem não será muito conveniente se houver muitas camadas. Fe-lizmente, o Tensor Flow oferece uma opção melhor. Muitas funções que criam variáveis (como a get_variable() ou tf. layers. dense() ) aceitam um argumento *_regularizer CG_MIOLO_Hands_On_Machine_Learning. indb 313 07/05/2019 17:09:30 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
314 | Capítulo 11: Treinando Redes Neurais Profundaspara cada variável criada (por exemplo, kernel_regularizer ). Você pode passar qualquer função que toma pesos como argumento e retorna a perda correspondente de regularização. As funções l1_regularizer(), l2_regularizer(), e l1_l2_regularizer() retornam essas funções. O código a seguir junta tudo isso: my_dense_layer = partial( tf. layers. dense, activation=tf. nn. relu, kernel_regularizer=tf. contrib. layers. l1_regularizer(scale)) with tf. name_scope("dnn"): hidden1 = my_dense_layer(X, n_hidden1, name="hidden1") hidden2 = my_dense_layer(hidden1, n_hidden2, name="hidden2") logits = my_dense_layer(hidden2, n_outputs, activation=None, name="outputs") Este código cria uma rede neural com duas camadas ocultas e uma camada de saída e também cria nós no gráfico para calcular a perda de regularização ℓ 1 correspondente aos pesos de cada camada. O Tensor Flow adiciona automaticamente esses nós a uma coleção especial que contém todas as perdas de regularização e você só precisa adicionar essas perdas à sua perda geral, desta forma: reg_losses = tf. get_collection(tf. Graph Keys. REGULARIZATION_LOSSES) loss = tf. add_n([base_loss] + reg_losses, name="loss") Não se esqueça de adicionar as perdas de regularização à sua perda geral, ou então elas simplesmente serão ignoradas. Dropout A técnica de regularização mais popular para redes neurais profundas é indiscutivel-mente o dropout [descarte]. Ela foi proposta ( https://goo. gl/PMj Vn G )20 por G. E. Hinton em 2012, detalhada em um artigo ( http://goo. gl/DNKZo1 )21 por Nitish Srivastava et al., e provou ser altamente bem-sucedida: com a adição do dropout, até mesmo as redes neurais de última geração tiveram um aumento de 1-2% na acurácia. Isso pode não pa-recer muito, mas, quando um modelo já possui 95% de acurácia, obter um aumento de acurácia de 2% significa reduzir sua taxa de erro em quase 40% (passando de 5% para aproximadamente 3%). 20 “Improving neural networks by preventing co-adaptation of feature detectors”, G. Hinton et al. (2012). 21 “Dr opout: A Simple Way to Prevent Neural Networks from Overfitting”, N. Srivastava et al. (2014). CG_MIOLO_Hands_On_Machine_Learning. indb 314 07/05/2019 17:09:30 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
Evitando o Sobreajuste Por Meio da Regularização | 315É um algoritmo bastante simples: em cada etapa do treinamento, cada neurônio (in-cluindo os neurônios de entrada, mas excluindo os de saída) tem uma probabilidade p de ser temporariamente “descartado", o que significa que ele será totalmente ignorado durante esta etapa do treinamento, mas poderá estar ativo durante a próxima (veja a Figura 11-9). O hiperparâmetro p é chamado de taxa de dropout e normalmente é ajustado em 50% e os neurônios não são mais descartados após o treinamento. Isso é tudo (exceto por um detalhe técnico que discutiremos momentaneamente). Desca rtado Figura 11-9. Regularização Dropout Inicialmente, é surpreendente que esta técnica brutal funcione. Será que uma empresa funcionaria melhor se seus funcionários fossem solicitados a jogar uma moeda para o alto todas as manhãs para decidir se deveriam ou não trabalhar? Bem, quem sabe; talvez funcionasse! A empresa obviamente seria forçada a adaptar sua organização; não seria mais possível passar para uma única pessoa a responsabilidade de colocar pó na máquina de café ou executar outras tarefas críticas, então essa habilidade teria que ser distribuída entre várias pessoas. Os funcionários teriam que aprender a cooperar com muitos de seus colegas de trabalho, não apenas alguns deles. A empresa se tornaria muito mais resiliente. Se uma pessoa saísse, não faria muita diferença. Não está claro se essa ideia realmente fun-cionaria para as empresas, mas certamente funciona para as redes neurais. Os neurônios treinados com o dropout não podem coadaptar com seus neurônios vizinhos; eles devem ser o mais úteis possível por conta própria. Eles também não podem confiar excessivamente CG_MIOLO_Hands_On_Machine_Learning. indb 315 07/05/2019 17:09:30 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
316 | Capítulo 11: Treinando Redes Neurais Profundasem apenas alguns neurônios de entrada, devendo prestar atenção a cada um deles, o que torna-os menos sensíveis a pequenas mudanças nas entradas. No final, você obtém uma rede mais robusta que generaliza melhor. Outra maneira de entender o poder do dropout é perceber que uma rede neural única é gerada em cada etapa do treinamento. Há um total de 2 N redes possíveis (sendo que N é o número total de neurônios descartados) uma vez que cada neurônio pode estar presente ou ausente. Este é um número tão grande que é praticamente impossível que a mesma rede neural seja amostrada duas vezes. Após ter executado 10 mil passos do treinamento, você treinou basicamente 10 mil redes neurais diferentes (cada uma com apenas uma instância de treinamento). Essas redes neurais obviamente não são independentes, pois compartilham muitos de seus pesos, no entanto, são diferentes. A rede neural resultante pode ser vista como um conjunto das médias de todas essas redes neurais menores. Há um pequeno, mas importante, detalhe técnico. Supondo que p = 50% no caso de um teste no qual um neurônio é conectado ao dobro de neurônios de entrada (na média) em relação ao treinamento, precisamos multiplicar os pesos da conexão de entrada de cada neurônio por 0,5 após o treinamento para compensar esse fato. Se não o fizermos, cada neurônio receberá um sinal total de entrada quase duas vezes maior do que a rede em que ele foi treinado, e é improvável que ele tenha um bom desempenho. Geralmente, após o treinamento, precisamos multiplicar cada peso da conexão de entrada pela keep probability (1-p ). Como alternativa, podemos dividir a saída de cada neurônio pela keep probability durante o treinamento (essas alternativas não são perfeitamente equivalentes, mas funcionam igualmente bem). Quando utilizamos o Tensor Flow para implementar o dropout, aplicamos a função tf. layers. dropout() à camada de entrada e/ou à saída de qualquer camada oculta que você quiser. Esta função descarta alguns itens aleatoriamente durante o treina-mento (configurando-os para 0) e divide os restantes pela keep probability. Após o treinamento, esta função não faz nada. O código a seguir aplica a regularização dropout em nossa rede neural de três camadas: [... ] training = tf. placeholder_with_default(False, shape=(), name='training') dropout_rate = 0. 5 # == 1-keep_prob X_drop = tf. layers. dropout(X, dropout_rate, training=training) with tf. name_scope("dnn"): hidden1 = tf. layers. dense(X_drop, n_hidden1, activation=tf. nn. relu, name="hidden1") hidden1_drop = tf. layers. dropout(hidden1, dropout_rate, training=training) CG_MIOLO_Hands_On_Machine_Learning. indb 316 07/05/2019 17:09:30 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
Evitando o Sobreajuste Por Meio da Regularização | 317 hidden2 = tf. layers. dense(hidden1_drop, n_hidden2, activation=tf. nn. relu, name="hidden2") hidden2_drop = tf. layers. dropout(hidden2, dropout_rate, training=training) logits = tf. layers. dense(hidden2_drop, n_outputs, name="outputs") Utilize a função tf. layers. dropout(), não a função tf. nn. dro-pout(). A primeira desliga (no-op) quando não está treinando, o que é o que você quer, enquanto a segunda não desliga. Claro, assim como você fez antes para a Normalização em Lotes, você precisa configurar training para True para treinar e deixar o valor padrão False para testar. Se você notar que o modelo está se sobreajustando, tente aumentar a taxa de dropout e, por outro lado, se o modelo se subajustar ao conjunto de treinamento, você deve tentar diminuí-la. Também pode ajudar se aumentarmos a taxa de dropout para grandes ca-madas e reduzi-la para as menores. Quando ajustado corretamente, o dropout tende a reduzir significativamente a con-vergência, mas geralmente resulta em um modelo muito melhor. Então, vale a pena o tempo extra e o esforço. Dropconnect é uma variante do dropout em que conexões indivi-duais são descartadas aleatoriamente em vez de neurônios inteiros. No geral, o dropout tem um desempenho melhor. Regularização Max-Norm Outra técnica de regularização bastante popular para as redes neurais é chamada de re-gularização max-norm : restringe o peso w das conexões de entrada de tal modo para cada neurônio que ∥ w ∥2 ≤ r sendo que r é o hiperparâmetro max-norm e ∥. ∥2 é a norma ℓ 2. Tipicamente implementamos essa restrição calculando ∥w∥2 após cada passo do treinamento e limitando w se necessário . A redução de r aumenta a quantidade de regularização e ajuda a reduzir o sobreajuste. A regularização max-norm também pode ajudar a aliviar os problemas dos gradientes vanishing/exploding (se você não estiver utilizando a Normalização em Lote). O Tensor Flow não tem um regulador max-norm disponível, mas não é muito difícil de implementar. O código a seguir obtém um controle sobre os pesos da primeira camada oculta, então ele utiliza a função clip_by_norm() para criar uma operação que cortará CG_MIOLO_Hands_On_Machine_Learning. indb 317 07/05/2019 17:09:31 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
318 | Capítulo 11: Treinando Redes Neurais Profundasos pesos ao longo do segundo eixo para que cada vetor de linha fique com uma norma máxima de 1,0. A última linha cria uma operação de atribuição dos pesos limitados às variáveis de peso: threshold = 1. 0 weights = tf. get_default_graph(). get_tensor_by_name("hidden1/kernel:0") clipped_weights = tf. clip_by_norm(weights, clip_norm=threshold, axes=1) clip_weights = tf. assign(weights, clipped_weights) Então, basta aplicar esta operação após cada etapa de treinamento, assim: sess. run(training_op, feed_dict={X: X_batch, y: y_batch}) clip_weights. eval() Em geral, você faria isso para cada camada oculta. Embora esta solução funcione bem, ela é um pouco confusa e uma ideia mais limpa seria criar uma função max_norm_regularizer() e utilizá-la como a função anterior l1_regularizer() : def max_norm_regularizer(threshold, axes=1, name="max_norm", collection="max_norm"): def max_norm(weights): clipped = tf. clip_by_norm(weights, clip_norm=threshold, axes=axes) clip_weights = tf. assign(weights, clipped, name=name) tf. add_to_collection(collection, clip_weights) return None # não há um termo de perda de regularização return max_norm Esta função retorna uma função parametrizada max_norm() que você pode utilizar como qualquer outro regularizador: max_norm_reg = max_norm_regularizer(threshold=1. 0) with tf. name_scope("dnn"): hidden1 = tf. layers. dense(X, n_hidden1, activation=tf. nn. relu, kernel_regularizer=max_norm_reg, name="hidden1") hidden2 = tf. layers. dense(hidden1, n_hidden2, activation=tf. nn. relu, kernel_regularizer=max_norm_reg, name="hidden2") logits = tf. layers. dense(hidden2, n_outputs, name="outputs") Observe que a regularização max-norm não requer a adição de um termo de perda de regularização à sua função de perda geral, e é por isso que a função max_norm() retorna None. Mas você ainda precisa ser capaz de executar as operações clip_weights após cada etapa do treinamento, então você tem que poder alterá-las. É por isso que a função max_norm() adiciona a operação clip_weights a uma coleção de operações max-norm de recortes. Você precisa buscar essas operações de limitação e executá-las após cada etapa de treinamento: clip_all_weights = tf. get_collection("max_norm") with tf. Session() as sess: init. run() for epoch in range(n_epochs): for iteration in range(mnist. train. num_examples // batch_size): CG_MIOLO_Hands_On_Machine_Learning. indb 318 07/05/2019 17:09:31 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
Evitando o Sobreajuste Por Meio da Regularização | 319 X_batch, y_batch = mnist. train. next_batch(batch_size) sess. run(training_op, feed_dict={X: X_batch, y: y_batch}) sess. run(clip_all_weights) Um código bem mais limpo, não? Data Augmentation Uma última técnica de regularização, o data augmentation, consiste na geração de novas instâncias de treinamento a partir das já existentes, aumentando artificialmente o tama-nho do conjunto de treinamento, o que reduzirá o sobreajuste, tornando-a uma técnica de regularização. O truque é gerar instâncias de treinamento realistas; normalmente um humano não deve ser capaz de dizer quais instâncias foram geradas e quais não foram. Além disso, simplesmente adicionar o ruído branco não ajudará; as modificações que você aplicar devem ser aprendidas (o ruído branco não). Por exemplo, se o seu modelo for destinado a classificar imagens de cogumelos, você pode mover ligeiramente, girar e redimensionar cada imagem no conjunto de treinamento por vários valores e adicionar as imagens resultantes ao conjunto (veja a Figura 11-10), forçando o modelo a ser mais tolerante quanto ao posicionamento, orientação e tamanho dos cogumelos na imagem. Se você deseja que o modelo seja mais tolerante às condições de iluminação, também pode gerar muitas imagens com diferentes contrastes. Supondo que os cogumelos são simétricos, você também pode virar as fotos horizontalmente. Ao combinar essas transformações, você aumenta consideravelmente o tamanho do seu conjunto de treinamento. Figura 11-10. Gerando novas instâncias de treinamento a partir das já existentes CG_MIOLO_Hands_On_Machine_Learning. indb 319 07/05/2019 17:09:32 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
320 | Capítulo 11: Treinando Redes Neurais Profundas Normalmente é preferível gerar instâncias de treinamento durante o treinamento em vez de desperdiçar espaço de armazenamento e banda da rede de internet. O Tensor Flow oferece várias operações de manipulação de imagem, como transposição (deslocamento), rotação, redimensionamento, recorte e corte, bem como o ajuste do brilho, contraste, saturação e matiz (consulte a documentação da API para obter mais detalhes). Isso facilita a implementação do aumento de dados para conjuntos de dados com imagens. Outra técnica poderosa para treinar redes neurais profundas é adi-cionar skip connections (uma skip connection é a adição da entrada de uma camada à saída de uma camada superior). Exploraremos essa ideia no Capítulo 13, quando falarmos sobre redes residuais profundas. Diretrizes Práticas Neste capítulo, cobrimos uma ampla gama de técnicas e você deve estar se perguntando quais deveria utilizar. A configuração na Tabela 11-2 funciona bem na maioria dos casos. Tabela 11-2. Configuração Padrão da DNN Inicialização Inicialização He Função de Ativação ELU Normalização Normalização em Lote Regularização Dropout Otimizador Gradiente Acelerado de Nesterov Cronograma da taxa de aprendizado Nenhum Claro, se conseguir encontrar uma que resolva um problema semelhante, você deve tentar reutilizar partes de uma rede neural pré-treinada. Essa configuração padrão pode precisar ser ajustada: Se vo cê não conseguir encontrar uma boa taxa de aprendizado (a convergência foi muito lenta, então você aumentou a taxa de treinamento e agora a convergência é rápida, mas a precisão da rede é subótima), tente adicionar um cronograma de apren-dizado como o decaimento exponencial; Se o co njunto de treinamento for pequeno, implemente o data augmentation; Adic ione alguma regularização ℓ 1 à mistura se precisar de um modelo esparso (e zere opcionalmente os pequenos pesos após o treinamento). Tente utilizar a FTRL em vez da otimização Adam em conjunto com a regularização ℓ 1 se preci-sar de um modelo ainda mais esparso; CG_MIOLO_Hands_On_Machine_Learning. indb 320 07/05/2019 17:09:32 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
Exercícios | 321 Se você precisar de um modelo com tempo de execução extremamente rápido, des carte a Normalização de Lote e possivelmente substitua a função de ativação ELU pela leaky Re LU. Ter um modelo esparso também pode ajudar. Com estas orientações, você está pronto para treinar redes muito profundas — bem, isto é, se você for muito paciente! Se você utiliza apenas uma única máquina, talvez seja necessá-rio esperar por dias ou até meses para a conclusão do treinamento. No próximo capítulo, discutiremos como utilizar o Tensor Flow distribuído para treinar e executar modelos em vários servidores e GPUs. Exercícios 1. É correto inicializarmos todos os pesos no mesmo valor desde que esse valor seja sel ecionado aleatoriamente usando a inicialização He? 2. É c orreto inicializarmos os termos de polarização em 0? 3. Nom eie três vantagens da função de ativação ELU em relação à Re LU. 4. Em qu ais casos você utilizaria cada uma das seguintes funções de ativação: ELU, leaky Re LU (e suas variantes), Re LU, tanh, logistic, e softmax? 5. O que p ode acontecer se você ajustar o hiperparâmetro momentum muito próximo de 1 (por exemplo, 0,99999) quando utilizar um Momentum Optimizer ? 6. Nom eie três maneiras de produzir um modelo esparso. 7. O dro pout retarda o treinamento? Isso retarda a inferência (ou seja, fazer previ-sões em novas instâncias)? 8. Apre ndizado Profundo. a. Cri e uma DNN com cinco camadas ocultas de 100 neurônios cada, inicializa-ção He e a função de ativação ELU. b. Uti lizando a otimização de Adam e a parada antecipada, tente treiná-lo no MNIST, mas apenas nos dígitos de 0 a 4, pois utilizaremos o aprendizado de transferência para os dígitos 5 a 9 no próximo exercício. Você precisará de uma camada de saída softmax com cinco neurônios e, como sempre, assegure-se de salvar os pontos de verificação em intervalos regulares e salvar o modelo final para que você possa reutiliza-lo mais tarde. c. Aju ste os hiperparâmetros utilizando a validação cruzada e veja que nível de precisão você consegue atingir. d. Ago ra tente adicionar a Normalização de Lote e compare as curvas de aprendiza-do: ela está convergindo mais rápido que antes? Ela produz um modelo melhor? CG_MIOLO_Hands_On_Machine_Learning. indb 321 07/05/2019 17:09:32 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
322 | Capítulo 11: Treinando Redes Neurais Profundase. O modelo está se sobreajustando ao conjunto de treinamento? Tente adicionar dr opout a cada camada e tente novamente. Isso ajuda? 9. Apr endizado de transferência. a. Cri e uma nova DNN que reutilize todas as camadas ocultas pré-treinadas do modelo anterior, congele e substitua a camada de saída softmax por uma nova. b. Tre ine esta nova DNN nos dígitos 5 a 9 utilizando apenas 100 imagens por dígito e cronometre quanto tempo leva. Apesar do pequeno número de exem-plos, você consegue atingir uma alta precisão? c. Ten te pegar as camadas congeladas e treine o modelo novamente: quão mais rápido ele está agora? d. Ten te novamente reutilizando apenas quatro camadas ocultas em vez de cinco. Você consegue atingir uma precisão mais alta? e. Ago ra, descongele as duas camadas ocultas mais altas e continue treinando. Você consegue fazer com que o modelo tenha um desempenho ainda melhor? 10. Pré-treinamento em uma tarefa auxiliar. a. Nes te exercício, você construirá uma DNN que compara duas imagens de dí-gitos do MNIST e prevê se elas representam o mesmo dígito ou não. Então você reutilizará as camadas inferiores desta rede para treinar um classificador MNIST que utiliza poucos dados de treinamento. Comece construindo duas DNNs (vamos chamá-las DNN A e B), ambas similares à que você construiu anteriormente, mas sem a camada de saída: cada DNN deve ter cinco camadas ocultas de 100 neurônios cada, inicialização He e ativação ELU. A seguir, adi-cione mais uma camada oculta com 10 unidades no topo de ambas as DNNs. Para fazer isso, você deve utilizar a função concat() do Tensor Flow com axis=1 para concatenar as saídas de ambas as DNNs para cada instância e alimentar o resultado para a camada oculta. Finalmente, adicione uma camada de saída com um único neurônio usando a função de ativação logística. b. Divi da o conjunto de treinamento MNIST em dois: o conjunto #1 deve conter 55 mil imagens, e o conjunto #2 deve conter 5 mil imagens. Crie uma função que gere um lote de treinamento em que cada instância é um par de imagens MNIST escolhidas a partir do conjunto #1. A metade das instâncias de trei-namento deve ter pares de imagens que pertencem à mesma classe, enquanto a outra metade deve conter imagens de diferentes classes. Para cada par, se as imagens forem da mesma classe, o label de treinamento deve ser 0, ou 1, se forem de classes diferentes. CG_MIOLO_Hands_On_Machine_Learning. indb 322 07/05/2019 17:09:32 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
Exercícios | 323c. Treine a DNN neste conjunto de treinamento. Para cada par de imagens, você ali-me nta simultaneamente a primeira imagem na DNN A e a segunda imagem na DNN B. Toda a rede aprenderá gradualmente se duas imagens pertencem à mesma classe ou não. d. Ago ra, crie uma nova DNN reutilizando e congelando as camadas ocultas da DNN A e adicione uma camada de saída softmax com 10 neurônios no topo. Treine esta rede no conjunto #2 e veja se pode alcançar um alto desempenho apesar de ter apenas 500 imagens por classe. As soluções para estes exercícios estão disponíveis no Apêndice A. CG_MIOLO_Hands_On_Machine_Learning. indb 323 07/05/2019 17:09:32 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
CG_MIOLO_Hands_On_Machine_Learning. indb 324 07/05/2019 17:09:32 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
325Capítulo 12 Distribuindo o Tensor Flow Por Dispositivos e Servidores No Capítulo 11, discutimos várias técnicas que podem acelerar consideravelmente o treinamento: melhorar a inicialização do peso, a Normalização em Lote, otimizadores sofisticados e assim por diante. No entanto, mesmo com todas essas técnicas, o treina-mento de uma grande rede neural em uma única máquina com uma única CPU pode levar dias ou até mesmo semanas. Neste capítulo, veremos como utilizar o Tensor Flow para distribuir cálculos em vários dispositivos (CPUs e GPUs) e executá-los em paralelo (veja a Figura 12-1). Em primeiro lugar, distribuiremos cálculos através de vários dispositivos em apenas uma máquina, depois em vários dispositivos em várias máquinas. Figura 12-1. Executando um grafo do Tensor Flow em múltiplos dispositivos paralelos CG_MIOLO_Hands_On_Machine_Learning. indb 325 07/05/2019 17:09:32 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
326 | Capítulo 12: Distribuindo o Tensor Flow Por Dispositivos e Servidores O suporte do Tensor Flow ao cálculo distribuído é um dos principais destaques em com-paração com outras estruturas de redes neurais. Ele oferece controle total sobre como dividir (ou replicar) seu gráfico de cálculo entre dispositivos e servidores, e permite paralelizar e sincronizar operações de formas flexíveis para que você possa escolher entre todos os tipos de abordagens de paralelização. Examinaremos algumas das abordagens mais populares para paralelizar a execução e o treinamento de uma rede neural. Em vez de esperar semanas para que um algoritmo de treinamento seja concluído, pode ser que você só precise aguardar algumas horas. Isso não apenas economiza uma quantidade enorme de tempo, mas também permite que você experimente vários modelos com muito mais facilidade e, com frequência, treine novamente seus modelos em novos dados. Outros ótimos casos de uso de paralelização incluem a exploração de um espaço de hiperparâmetro muito maior para ajustar seu modelo e a execução eficiente de grandes ensembles de redes neurais. Mas precisamos aprender a caminhar antes de correr. Começaremos paralelizando grafos simples através de várias GPUs em uma única máquina. Múltiplos Dispositivos em uma Única Máquina Você pode obter um grande aumento de desempenho adicionando placas GPU a uma única máquina. De fato, em muitos casos isso será suficiente e não será necessário utilizar várias máquinas. Por exemplo, você pode treinar uma rede neural com a mesma rapidez utilizando 8 GPUs em uma única máquina em vez de 16 GPUs em várias máquinas (devido ao atraso extra imposto pelas comunicações de rede em uma configuração de várias máquinas). Nesta seção, veremos como configurar seu ambiente para que o Tensor Flow possa utilizar várias placas GPU em uma máquina. Em seguida, veremos como você pode distribuir as operações pelos dispositivos disponíveis e executá-las em paralelo. Instalação Para executar o Tensor Flow em várias placas GPU, você precisa primeiro certificar-se de que suas placas têm NVidia Compute Capability (maior ou igual a 3. 0). Isso inclui as placas Titan, Titan X, K20 e K40 da Nvidia (caso tenha outra placa, verifique sua compatibilidade em https://developer. nvidia. com/cuda-gpus ). CG_MIOLO_Hands_On_Machine_Learning. indb 326 07/05/2019 17:09:32 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
Múltiplos Dispositivos em uma Única Máquina | 327Se você não possui placas GPU, pode utilizar um serviço de hospe-dagem com capacidade de GPU, como o Amazon AWS. As instru-ções detalhadas para configurar o Tensor Flow 0. 9 com o Python 3. 5 em uma instância de GPU da Amazon AWS estão disponíveis na publicação do blog de Žiga Avsec (http://goo. gl/kbge5b). Não deve ser difícil atualizá-la para a versão mais recente do Tensor Flow. O Google também lançou um serviço em nuvem chamado Cloud Machine Learning (https://cloud. google. com/ml) para executar grafos do Tensor Flow. Em maio de 2016, a empresa anunciou que sua pla-taforma agora inclui servidores equipados com unidades de proces-samento do tensor (TPUs), processadores especializados em Apren-dizado de Máquina que são muito mais rápidos do que as GPUs para muitas das tarefas do AM. Claro, outra opção seria comprar sua própria GPU. Tim Dettmers escreveu uma excelente postagem no blog (https://goo. gl/p Ct SAn) para ajudar você a escolhê-la, e a atuali-za com bastante regularidade. Baixe e instale a versão apropriada das bibliotecas CUDA e cu DNN (CUDA 8. 0 e cu DNN v6 se estiver utilizando a instalação binária do Tensor Flow 1. 3) e defina algumas variáveis de ambiente para que o Tensor Flow saiba onde encontrar CUDA e cu DNN. As instruções detalhadas de instalação estão suscetíveis a mudanças constantes, por isso é melhor que você siga as instruções no site do Tensor Flow. A biblioteca da Nvidia Compute Unified Device Architecture (CUDA) permite que desen-volvedores utilizem GPUs CUDA-enabled para todos os tipos de cálculos (não apenas aceleração gráfica). A biblioteca da Nvidia CUDA Deep Neural Network (cu DNN) é uma biblioteca GPU-accelerated para DNNs primitivas. Ela fornece implementações otimi-zadas para cálculos comuns da DNN, tais como camadas de ativação, normalização, contornos avançados e atrasados e agrupamento (consulte o Capítulo 13). Ela faz parte do Aprendizado Profundo SDK da Nvidia (requer a criação de uma conta de desenvolvedor Nvidia para efetuar o download). O Tensor Flow utiliza CUDA e cu DNN para controlar as placas GPU e acelerar os cálculos (veja a Figura 12-2). CG_MIOLO_Hands_On_Machine_Learning. indb 327 07/05/2019 17:09:32 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
328 | Capítulo 12: Distribuindo o Tensor Flow Por Dispositivos e Servidores Tensor Flow cu DNN CUDA Figura 12-2. O Tensor Flow utiliza CUDA e cu DNN para controlar GPUs e aumentar as DNNs Você pode utilizar o comando nvidia-smi para verificar se CUDA está instalado de acordo, pois ele lista os cartões GPU disponíveis e processa a execução em cada um: $ nvidia-smi Wed Sep 16 09:50:03 2016+------------------------------------------------------+| NVIDIA-SMI 352. 63 Driver Version: 352. 63 | |-------------------------------+----------------------+----------------------+ | GPU Name Persistence-M| Bus-Id Disp. A | Volatile Uncorr. ECC | | Fan Temp Perf Pwr:Usage/Cap| Memory-Usage | GPU-Util Compute M. | |===============================+======================+======================| | 0 GRID K520 Off | 0000:00:03. 0 Off | N/A | | N/A 27C P8 17W / 125W | 11Mi B / 4095Mi B | 0% Default | +-------------------------------+----------------------+----------------------+ +-----------------------------------------------------------------------------+ | Processes: GPU Memory | | GPU PID Type Process name Usage ||=============================================================================| | No running processes found |+-----------------------------------------------------------------------------+ Finalmente, você deve instalar o Tensor Flow com suporte a GPU. Se criou um ambiente isolado com o virtualenv, primeiro você precisa ativá-lo: $ cd $ML_PATH # Seu diretório de AM (por ex., $HOME/ml) $ source env/bin/activate Instale a versão GPU-enabled apropriada do Tensor Flow: $ pip3 install--upgrade tensorflow-gpu Agora, você pode abrir um Python shell e verificar se o Tensor Flow detecta e utiliza CUDA e cu DNN corretamente ao importar e criar uma sessão no Tensor Flow: CG_MIOLO_Hands_On_Machine_Learning. indb 328 07/05/2019 17:09:33 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
Múltiplos Dispositivos em uma Única Máquina | 329>>> import tensorflow as tf I [... ]/dso_loader. cc:108] successfully opened CUDA library libcublas. so locally I [... ]/dso_loader. cc:108] successfully opened CUDA library libcudnn. so locally I [... ]/dso_loader. cc:108] successfully opened CUDA library libcufft. so locally I [... ]/dso_loader. cc:108] successfully opened CUDA library libcuda. so. 1 locally I [... ]/dso_loader. cc:108] successfully opened CUDA library libcurand. so locally >>> sess = tf. Session() [... ] I [... ]/gpu_init. cc:102] Found device 0 with properties: name: GRID K520 major: 3 minor: 0 memory Clock Rate (GHz) 0. 797pci Bus ID 0000:00:03. 0Total memory: 4. 00Gi B Free memory: 3. 95Gi B I [... ]/gpu_init. cc:126] DMA: 0 I [... ]/gpu_init. cc:136] 0: Y I [... ]/gpu_device. cc:839] Creating Tensor Flow device (/gpu:0)-> (device: 0, name: GRID K520, pci bus id: 0000:00:03. 0) Parece ok! O Tensor Flow detectou as bibliotecas CUDA e cu DNN e utilizou a biblioteca CUDA para detectar o cartão GPU (neste caso, um cartão Nvidia Grid K520). Gerenciando a RAM da GPU Por padrão, na primeira vez que você executa um grafo, o Tensor Flow captura automa-ticamente toda a RAM em todas as GPUs disponíveis, então você não conseguirá iniciar um segundo programa do Tensor Flow enquanto o primeiro ainda estiver em execução. Se tentar, receberá o seguinte erro: E [... ]/cuda_driver. cc:965] failed to allocate 3. 66G (3928915968 bytes) from device: CUDA_ERROR_OUT_OF_MEMORY Uma solução seria executar cada processo em diferentes cartões GPU. Para fazer isso, a opção mais simples é configurar a variável de ambiente CUDA_VISIBLE_DEVICES para que cada processo veja somente os cartões GPU apropriados. Por exemplo, você poderia iniciar dois programas assim: $ CUDA_VISIBLE_DEVICES=0,1 python3 program_1. py # e em outro terminal: $ CUDA_VISIBLE_DEVICES=3,2 python3 program_2. py O programa #1 somente verá os cartões GPU 0 e 1 (numerados 0 e 1, respectivamente), e o programa #2 somente verá os cartões GPU 2 e 3 (numerados 1 e 0, respectivamente). Tudo funcionará de acordo (veja a Figura 12-3). CG_MIOLO_Hands_On_Machine_Learning. indb 329 07/05/2019 17:09:34 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
330 | Capítulo 12: Distribuindo o Tensor Flow Por Dispositivos e Servidores Programa #1 Programa #2 Figura 12-3. Cada programa pega duas GPUs para si Outra opção seria dizer ao Tensor Flow que capture apenas uma fração da memória. Por exemplo, crie um objeto Config Proto para fazer o Tensor Flow capturar apenas 40% da memória de cada GPU, ajuste sua opção gpu_options. per_process_gpu_memory_frac-tion para 0. 4 e crie a sessão utilizando esta configuração: config = tf. Config Proto() config. gpu_options. per_process_gpu_memory_fraction = 0. 4 session = tf. Session(config=config) Agora dois programas como este podem rodar em paralelo usando as mesmas GPU (mas não três, pois 3 × 0,4 > 1). Veja a Figura 12-4. Programa #1 Programa #2 Figura 12-4. Cada programa captura todas as quatro GPUs, mas somente com 40% da RAM cada uma Se executar o comando nvidia-smi enquanto ambos os programas estão rodando, verificará que cada processo utiliza mais ou menos 40% da RAM total de cada cartão: $ nvidia-smi [... ] +-----------------------------------------------------------------------------+ | Processes: GPU Memory | | GPU PID Type Process name Usage | |=============================================================================| | 0 5231 C python 1677Mi B | | 0 5262 C python 1677Mi B | | 1 5231 C python 1677Mi B | | 1 5262 C python 1677Mi B | [... ] CG_MIOLO_Hands_On_Machine_Learning. indb 330 07/05/2019 17:09:34 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
Múltiplos Dispositivos em uma Única Máquina | 331Outra opção é dizer ao Tensor Flow que capture memória somente quando precisar dela. Para fazer isso, você deve configurar config. gpu_options. allow_growth como True. No entanto, uma vez que a tenha capturado, o Tensor Flow nunca liberará memória (para evitar a fragmentação), então você ainda poderá ficar sem memória depois de um tempo. Garantir um comportamento determinista ao utilizar esta opção pode ser mais difícil, portanto, utilize uma das opções anteriores. Ok, agora você tem uma instalação GPU-enabled funcional do Tensor Flow. Vejamos como utilizá-la! Colocando Operações em Dispositivos O whitepaper do Tensor Flow ( http://goo. gl/v Sj A14 )1 apresenta um algoritmo de posiciona-mento dinâmico amigável que distribui automaticamente operações em todos os dispo-sitivos disponíveis levando em consideração itens como o tempo de cálculo medido em execuções anteriores do gráfico, estimativas do tamanho dos tensores de entrada e saída para cada operação, a quantidade de RAM disponível em cada dispositivo, o atraso de comunicação ao transferir dados dentro e fora dos dispositivos, sugestões e restrições do usuário, e muito mais. Infelizmente, este algoritmo sofisticado é interno do Google; não foi lançado na versão open source do Tensor Flow. A razão pela qual foi deixado de fora parece ser que, na prática, um pequeno conjunto de regras, especificadas pelo usuário, realmente resulta em um posicionamento mais eficiente do que do dynamic placer. No entanto, a equipe do Tensor Flow está trabalhando para melhorar este dynamic placer, e talvez um dia ele esteja bom o bastante para ser lançado. Até então, o Tensor Flow depende de um posicionador simples, o qual (como seu nome sugere) é muito básico. Posicionamento simples Sempre que você executar um grafo, se o Tensor Flow precisar avaliar um nó que ainda não esteja posicionado em um dispositivo, ele utilizará o posicionamento simples para posicioná-lo juntamente com todos os outros nós que ainda não foram posicionados. O posicionamento simples respeita as seguintes regras: Se um n ó já foi posicionado em um dispositivo em uma execução anterior do grafo, ele é deixado neste dispositivo; Cas o contrário, se o usuário fixou um nó em um dispositivo (descrito a seguir), o posicionador o coloca neste dispositivo; 1 “Tensor Flow: Large-Scale Machine Learning on Heterogeneous Distributed Systems,” Google Research (2015). CG_MIOLO_Hands_On_Machine_Learning. indb 331 07/05/2019 17:09:34 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
332 | Capítulo 12: Distribuindo o Tensor Flow Por Dispositivos e Servidores Caso contrário, ele padroniza para GPU #0 ou para CPU se não houver GPU. Co mo você pode ver, posicionar as operações no dispositivo apropriado depende prin-cipalmente de você. Caso não faça nada, todo o grafo será posicionado no dispositivo padrão, portanto, você deve criar um bloco de dispositivo com a função device() para posicionar os nós em um dispositivo. Por exemplo, o código a seguir posiciona a variável a e a constante b na CPU, mas o nó de multiplicação c não está fixado em nenhum dispositivo, então será posicionado no dispositivo padrão: with tf. device("/cpu:0"): a = tf. Variable(3. 0) b = tf. constant(4. 0) c = a * b O dispositivo “ /cpu:0” agrega todas as CPUs em um sistema multi-CPU. Atualmente, não há como fixar nós em CPUs específicas ou utilizar apenas um subconjunto de todas as CPUs. Registro dos Posicionamentos Verificaremos se o posicionamento simples respeita as restrições de posicionamento que acabamos de definir. Para isso, você pode definir a opção log_device_placement para True ; que leva o posicionador a registrar uma mensagem sempre que posicionar um nó. Por exemplo: >>> config = tf. Config Proto() >>> config. log_device_placement = True >>> sess = tf. Session(config=config)I [... ] Creating Tensor Flow device (/gpu:0)-> (device: 0, name: GRID K520,pci bus id: 0000:00:03. 0) [... ] >>> a. initializer. run(session=sess) I [... ] a: /job:localhost/replica:0/task:0/cpu:0 I [... ] a/read: /job:localhost/replica:0/task:0/cpu:0 I [... ] mul: /job:localhost/replica:0/task:0/gpu:0 I [... ] a/Assign: /job:localhost/replica:0/task:0/cpu:0 I [... ] b: /job:localhost/replica:0/task:0/cpu:0 I [... ] a/initial_value: /job:localhost/replica:0/task:0/cpu:0 >>> sess. run(c) 12 As linhas que começam com “I” de Info são as mensagens de registro. Quando criamos uma sessão, o Tensor Flow grava uma mensagem para nos avisar que encontrou uma GPU (neste caso, o cartão Grid K520). Então, na primeira vez que rodamos o grafo (neste caso quando inicializamos a variável a ), o posicionador simples é executado e coloca cada nó no dispositivo ao qual foi atribuído. Como esperado, as mensagens do log mostram que CG_MIOLO_Hands_On_Machine_Learning. indb 332 07/05/2019 17:09:35 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
Múltiplos Dispositivos em uma Única Máquina | 333todos os nós estão posicionados em “/cpu:0”, exceto o nó de multiplicação que acaba no dispositivo padrão “/gpu:0” (por ora você pode ignorar com segurança o prefixo /job:localhost/replica:0/task:0 ; em breve falaremos a respeito). Observe que, ao executarmos o grafo pela segunda vez (para computar c), o posicionador não é utilizado, pois todos os nós que o Tensor Flow precisa para calcular c já estão posicionados. Função de posicionamento dinâmico Ao criar um bloco de dispositivo, você pode especificar uma função em vez de um nome para o dispositivo. O Tensor Flow chamará essa função para cada operação necessária no bloco e a função deve retornar o nome do dispositivo que a operação será fixada. Por exemplo, o código a seguir posiciona todos os nós das variáveis em “/cpu:0” (neste caso, apenas a variável a) e todos os outros nós em “/gpu:0” : def variables_on_cpu(op): if op. type == "Variable": return "/cpu:0" else: return "/gpu:0" with tf. device(variables_on_cpu): a = tf. Variable(3. 0) b = tf. constant(4. 0) c = a * b Você pode implementar algoritmos mais complexos em um estilo round-robin, como o posicionamento de variáveis através das GPUs. Operações e kernels Para que uma operação do Tensor Flow seja executada em um dispositivo, ela precisa ter uma implementação para ele; isso é chamado de kernel. Muitas operações possuem kernels para CPUs e GPUs, mas não todas. Por exemplo, o Tensor Flow não possui um kernel GPU para variáveis inteiras, então o código a seguir falhará quando o Tensor Flow tentar anexar a variável i na GPU #0: >>> with tf. device("/gpu:0"):... i = tf. Variable(3) [... ] >>> sess. run(i. initializer) Traceback (most recent call last): [... ] tensorflow. python. framework. errors. Invalid Argument Error: Cannot assign a device to node 'Variable': Could not satisfy explicit device specification Observe que o Tensor Flow infere que a variável deve ser do tipo int32, uma vez que o valor de inicialização é um número inteiro. Se você alterar o valor de inicialização para CG_MIOLO_Hands_On_Machine_Learning. indb 333 07/05/2019 17:09:35 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
334 | Capítulo 12: Distribuindo o Tensor Flow Por Dispositivos e Servidores 3,0 em vez de 3 ou se configurar explicitamente dtype=tf. float32 ao criar a variável, tudo trabalhará de acordo. Posicionamento suave Por padrão, se tentar inserir uma operação em um dispositivo para o qual não possua kernel, você obterá a exceção mostrada anteriormente quando o Tensor Flow tentar po-sicionar a operação no dispositivo. Se preferir que o Tensor Flow retroceda para a CPU, configure a opção allow_soft_placement como True : with tf. device("/gpu:0"): i = tf. Variable(3) config = tf. Config Proto() config. allow_soft_placement = True sess = tf. Session(config=config) sess. run(i. initializer) # Executa o posicionamento e volta para a posição anterior Até agora discutimos como posicionar nós em diferentes dispositivos. Agora, veremos como o Tensor Flow executará esses nós em paralelo. Execução em Paralelo Quando o Tensor Flow executa um grafo, ele começa descobrindo a lista de nós que pre-cisam ser avaliados e conta quantas dependências cada um tem. O Tensor Flow, então, começa a avaliar os nós com dependências zero (ou seja, nós de origem). Se esses nós forem posicionados em dispositivos separados, obviamente serão avaliados em paralelo. Caso forem posicionados no mesmo dispositivo, serão avaliados em diferentes threads para que também possam ser executadas em paralelo (em threads de GPU separadas ou núcleos de CPU). O Tensor Flow gerencia um pool de threads em cada dispositivo para paralelizar ope-rações (veja Figura 12-5), chamadas de inter-op thread pools. Algumas operações têm kernels multithreaded, que podem utilizar outros pools de threads (um por dispositivo) chamados intra-op thread pools. CG_MIOLO_Hands_On_Machine_Learning. indb 334 07/05/2019 17:09:35 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
Múltiplos Dispositivos em uma Única Máquina | 335 inter-op intra-op Figura 12-5. Execução paralela de um grafo do Tensor Flow Por exemplo, na Figura 12-5 as operações A, B e C são source ops, então podem ser avaliadas imediatamente. As operações A e B são posicionadas em GPU #0, enviadas a este pool de threads inter-op do dispositivo e imediatamente avaliadas em paralelo. A operação A passa a ter um kernel multithread; seus cálculos, que são executados em paralelo pelo pool de threads inter-op, são divididos em três partes. A operação C vai para o pool de threads inter-op de GPU #1. Os contadores de dependência das operações D e E serão diminuídos assim que terminar a operação C, e ambos alcançarão 0 de modo que as duas operações serão enviadas para o conjunto de threads inter-op a ser executado. Você pode controlar o número de threads pelo pool inter-op defi-nindo a opção inter_op_parallelism_threads. Observe que a primeira sessão iniciada cria os pools de threads inter-op. Todas as outras sessões apenas os reutilizarão, a menos que você configure a opção use_per_session_threads como True. Você pode con-trolar o número de threads por grupo intra-op definindo a opção intra_op_parallelism_threads. Dependências de Controle Mesmo que todas as operações dependentes sejam executadas, em alguns casos pode ser aconselhável adiar a avaliação de uma operação. Por exemplo, se ela utiliza muita memória, mas seu valor é necessário apenas mais tarde no grafo, seria melhor avaliá-la no último momento, evitando assim ocupar a RAM que outras operações podem ne-cessitar. Outro exemplo é um conjunto de operações que depende de dados localizados fora do dispositivo. Se todos rodam ao mesmo tempo, podem saturar a largura de banda CG_MIOLO_Hands_On_Machine_Learning. indb 335 07/05/2019 17:09:36 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
336 | Capítulo 12: Distribuindo o Tensor Flow Por Dispositivos e Servidores da comunicação do dispositivo e acabarão todos aguardando em I/O. Outras operações que precisam comunicar dados também serão bloqueadas. Seria preferível executar se-quencialmente essas operações pesadas de comunicação permitindo que o dispositivo execute outras operações em paralelo. Uma solução simples seria adicionar dependências de controle para adiar a avaliação de alguns nós. Por exemplo, o código a seguir pede ao Tensor Flow para avaliar x e y somente após avaliar a e b: a = tf. constant(1. 0) b = a + 2. 0 with tf. control_dependencies([a, b]): x = tf. constant(3. 0) y = tf. constant(4. 0) z = x + y Obviamente, como z depende de x e y, avaliar z também implica esperar que a e b sejam avaliados, embora não esteja explícito no bloco control_dependencies(). Também, como b depende de a, poderíamos simplificar o código anterior criando apenas uma dependência de controle em [b] em vez de [a, b], mas, em alguns casos, “explícito é melhor que implícito”. Ótimo! Agora você sabe: Com o inserir operações em vários dispositivos da maneira que desejar; Com o essas operações são executadas em paralelo; Com o criar dependências de controle para otimizar a execução em paralelo. É hora de distribuir os cálculos pelos múltiplos servidores! Vários Dispositivos em Vários Servidores Para executar um grafo em vários servidores, você precisa primeiro definir um cluster. Um cluster é composto por um ou mais servidores do Tensor Flow espalhados em vá-rias máquinas chamadas tasks (veja a Figura 12-6). Cada task pertence a um job. Um job é apenas um grupo de tarefas que tem um papel comum, como manter o controle dos parâmetros do modelo (este job é denominado “ps” parameter server ), ou executar cálculos (este job é nomeado “worker ”). CG_MIOLO_Hands_On_Machine_Learning. indb 336 07/05/2019 17:09:36 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
Vários Dispositivos em Vários Servidores | 337 Máquina A Máquina BMaster Worker Worker Master Worker Master Cliente Servidor TF Servidor TF Servidor TFTarefa 0 Tarefa 0job “ps” job “worker” Tarefa 1 Figura 12-6. Cluster do Tensor Flow A seguinte especificação de cluster define dois jobs, “ps” e “worker ” contendo uma e duas tasks respectivamente. Neste exemplo, a máquina A hospeda dois servidores do Tensor Flow (isto é, tasks) escutando em diferentes portas: uma faz parte do job “ ps” e a outra faz parte do job “ worker ”. A máquina B apenas hospeda um servidor do Tensor Flow, parte do job “ worker ”. cluster_spec = tf. train. Cluster Spec({ "ps": [ "machine-a. example. com:2221", # /job:ps/task:0 ], "worker": [ "machine-a. example. com:2222", # /job:worker/task:0 "machine-b. example. com:2222", # /job:worker/task:1 ]}) Passando a especificação do cluster, você deve criar um objeto Server para iniciar um servidor do Tensor Flow (para que ele possa se comunicar com outros servidores) e seu próprio nome de job e o número da task. Por exemplo, para iniciar a primeira task worker, você executaria o seguinte código na máquina A: server = tf. train. Server(cluster_spec, job_name="worker", task_index=0) Costuma ser mais simples executar uma tarefa por máquina, mas o exemplo anterior demonstra que o Tensor Flow permite que você execute várias tarefas, se desejar, na mesma máquina. 2 Se tiver vários servidores em uma máquina, é necessário garantir que eles não consumam toda a RAM de cada GPU, conforme explicado anteriormente. Por 2 Você pode até iniciar várias tarefas no mesmo processo. Pode ser útil para testes, mas não é recomendado na produção. CG_MIOLO_Hands_On_Machine_Learning. indb 337 07/05/2019 17:09:37 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
338 | Capítulo 12: Distribuindo o Tensor Flow Por Dispositivos e Servidores exemplo, na Figura 12-6, a tarefa “ps” não enxerga os dispositivos GPU, pois presumi-velmente seu processo foi disparado com CUDA_VISIBLE_DEVICES=””. Observe que a CPU é compartilhada por todas as tarefas localizadas na mesma máquina. Se você quiser que o processo não faça nada além de executar o servidor do Tensor Flow, bloqueie o thread principal pedindo para que ele espere que o servidor termine de utilizar o método join() (caso contrário, o servidor estará desabilitado assim que finalizar sua thread principal). Como atualmente ainda não é possível parar o servidor, isso realmente bloqueará para sempre: server. join() # bloqueia até que o servidor pare (ou se ja, nunca) Abrindo uma Sessão Uma vez que todas as tarefas estejam sendo executadas (ainda não fazendo nada), você pode abrir uma sessão em qualquer um dos servidores, de um cliente localizado em qualquer processo em qualquer máquina (mesmo de um processo rodando uma das tarefas) e utilizar essa sessão como uma sessão local normal. Por exemplo: a = tf. constant(1. 0) b = a + 2 c = a * 3 with tf. Session("grpc://machine-b. example. com:2222") as sess: print(c. eval()) # 9. 0 Este código do cliente primeiro cria um grafo simples, então abre uma sessão no servi-dor do Tensor Flow localizado na máquina B (que chamaremos master ), e o instrui para avaliar c. O master começa a inserir as operações nos dispositivos apropriados. Neste exemplo, uma vez que não posicionamos nenhuma operação em nenhum dispositivo, o master simplesmente os posiciona em seu próprio dispositivo padrão — neste caso, o dispositivo GPU da máquina B. Então, ele apenas avalia c conforme instruído pelo cliente e retorna o resultado. Os Serviços Master e Worker O cliente utiliza o protocolo g RPC (Google Remote Procedure Call ) para se comunicar com o servidor. Esta é uma estrutura eficiente de código aberto para chamar funções remotas e obter suas saídas em uma variedade de plataformas e linguagens. 3 É baseado 3 É a próxima versão do serviço interno Stubby do Google que foi utilizado com sucesso por mais de uma década. Veja http://grpc. io/ para mais detalhes. CG_MIOLO_Hands_On_Machine_Learning. indb 338 07/05/2019 17:09:37 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
Vários Dispositivos em Vários Servidores | 339no HTTP2, que abre uma conexão e a deixa aberta durante toda a sessão, permitindo uma comunicação bidirecional eficiente assim que a conexão for estabelecida. Os dados são transmitidos na forma de protocol buffers, outra tecnologia de código aberto do Google, que é um formato intercambiável de dados binários leves. Todos os servidores em um cluster do Tensor Flow podem se comu-nicar com qualquer outro servidor, portanto, assegure-se de abrir as portas apropriadas em seu firewall. Todo o servidor do Tensor Flow oferece dois serviços: o master service e o worker service. O master service permite que clientes abram sessões e as utilizem para rodar grafos, além de coordenar os cálculos nas tarefas confiando no service worker para realmente executar cálculos em outras tarefas e obter seus resultados. Esta arquitetura oferece muita flexibilidade. Um cliente pode se conectar a vários servi-dores abrindo várias sessões em diferentes threads. Um servidor pode lidar com várias sessões simultaneamente de um ou mais clientes. Você pode rodar um cliente por tarefa (normalmente dentro do mesmo processo), ou apenas um cliente para controlar todas as tarefas. Todas as opções são possíveis. Fixando Operações em Tarefas Você pode utilizar blocos do dispositivo para inserir operações em qualquer dispositivo gerenciado por qualquer tarefa especificando o nome do job, o índice da task, o tipo de dispositivo e o índice do dispositivo. Por exemplo, o código a seguir fixa a na CPU da primeira tarefa no job “ps” (esta é a CPU da máquina A), e fixa b na segunda GPU gerenciada pela primeira tarefa do job “worker” (esta é a GPU #1 da máquina A). Finalmente, c não é fixada em dispositivo algum, então o master a posiciona em seu próprio dispositivo padrão (o dispositivo da máquina B GPU #0). with tf. device("/job:ps/task:0/cpu:0"): a = tf. constant(1. 0) with tf. device("/job:worker/task:0/gpu:1"): b = a + 2 c = a + b Como anteriormente, se você omitir o tipo e o índice do dispositivo, o Tensor Flow utilizará o dispositivo padrão para a task; por exemplo, fixar uma operação em “/job:ps/task:0” irá inseri-la no dispositivo padrão da primeira tarefa do job “ps” (CPU da máquina A). Se CG_MIOLO_Hands_On_Machine_Learning. indb 339 07/05/2019 17:09:37 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
340 | Capítulo 12: Distribuindo o Tensor Flow Por Dispositivos e Servidores você também omitir o índice da task (por exemplo, “/job:ps” ), o Tensor Flow padroniza em “/task:0” e, se você omitir o nome do job e o índice da task, o Tensor Flow padroniza para o master task da sessão. Particionando Variáveis em Múltiplos Servidores de Parâmetros Como veremos em breve, um padrão comum no treinamento de uma rede neural em uma instalação distribuída é armazenar os parâmetros do modelo em um conjunto de servidores de parâmetros (ou seja, as tarefas no job “ ps”), enquanto outras tarefas se concentram em cálculos (ou seja, as tarefas no job “worker ”). Para grandes modelos com milhões de parâmetros, vale a pena particionar estes parâmetros em vários servidores, a fim de reduzir o risco de saturação da placa de rede do servidor de parâmetro unitário. Seria bastante tedioso se você tivesse que inserir manualmente cada variável em um servidor diferente. Felizmente, o Tensor Flow fornece a função replica_device_setter() no formato round-robin, que distribui variáveis em todas as tarefas “ps”. Por exemplo, o código a seguir fixa cinco variáveis para dois servidores de parâmetros: with tf. device(tf. train. replica_device_setter(ps_tasks=2)): v1 = tf. Variable(1. 0) # pinned to /job:ps/task:0 v2 = tf. Variable(2. 0) # pinned to /job:ps/task:1 v3 = tf. Variable(3. 0) # pinned to /job:ps/task:0 v4 = tf. Variable(4. 0) # pinned to /job:ps/task:1 v5 = tf. Variable(5. 0) # pinned to / job:ps/task:0 Em vez de passar o número de ps_tasks, você pode passar a especificação do cluster clus ter=cluster_spec e o Tensor Flow contará o número de tarefas no job “ps”. O Tensor Flow fixa automaticamente em “/job:worker” se você criar outras operações no bloco além das variáveis, que será padrão para o primeiro dispositivo gerenciado pela primeira tarefa no job “worker”. Definindo o parâmetro worker_device, você pode fixá-lo em outro dispositivo, mas uma melhor abordagem seria utilizar blocos de dispositivos incorporados. Um bloco de dispositivo interno pode substituir o job, a tarefa ou o dispositivo definido em um bloco externo. Por exemplo: with tf. device(tf. train. replica_device_setter(ps_tasks=2)): v1 = tf. Variable(1. 0) # marcado em /job:ps/task:0 (+ padrão em /cpu:0) v2 = tf. Variable(2. 0) # marcado em /job:ps/task:1 (+ padrão em /cpu:0) v3 = tf. Variable(3. 0) # marcado em /job:ps/task:0 (+ padrão em /cpu:0) [... ] s = v1 + v2 # marcado em /job:worker (+ padrão em task:0/gpu:0) with tf. device("/gpu:1"): p1 = 2 * s # marcado em /job:worker/gpu:1 (+ padrão em /task:0) with tf. device("/task:1"): p2 = 3 * s # marcado em / job:worker/task:1/gpu:1 CG_MIOLO_Hands_On_Machine_Learning. indb 340 07/05/2019 17:09:38 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
Vários Dispositivos em Vários Servidores | 341Este exemplo pressupõe que os servidores de parâmetros são somen-te para a CPU, o que normalmente é o caso, pois eles só precisam armazenar e comunicar parâmetros, não realizar cálculos intensivos. Compartilhando Estado entre Sessões com a Utilização de Contêiner de Recursos Quando você utiliza uma sessão local comum (não do tipo distribuída), o estado de cada variável é gerenciado pela própria sessão; todos os valores variáveis são perdidos assim que acaba. Além disso, várias sessões locais não podem compartilhar nenhum estado, mesmo que ambos rodem o mesmo grafo; cada sessão tem sua própria cópia de cada variável (como discutimos no Capítulo 9). Em contraste, se você estiver usando sessões distribuídas, o estado da variável é gerenciado pelos contêineres de recursos localizados no próprio cluster, não pelas sessões. Então, se você criar uma variável chamada x uti-lizando uma sessão do cliente (mesmo que ambas as sessões estejam conectadas a um servidor diferente), ela estará automaticamente disponível para qualquer outra sessão no mesmo cluster. Por exemplo, considere o seguinte código do cliente: # simple_client. py import tensorflow as tf import sys x = tf. Variable(0. 0, name="x") increment_x = tf. assign(x, x + 1) with tf. Session(sys. argv[1]) as sess: if sys. argv[2:]==["init"]: sess. run(x. initializer) sess. run(increment_x) print(x. eval()) Suponhamos que você tenha um cluster do Tensor Flow instalado e rodando nas máquinas A e B, porta 2222. Você poderia iniciar o cliente, abrir uma sessão com o servidor na máquina A e informá-lo para inicializar a variável, incrementá-la e imprimir seu valor executando o seguinte comando: $ python3 simple_client. py grpc://machine-a. example. com:2222 init 1. 0 Agora, se você disparar o cliente com o seguinte comando, ele se conectará ao servidor na máquina B e reutilizará magicamente a mesma variável x (desta vez não pedimos ao servidor para inicializar a variável): CG_MIOLO_Hands_On_Machine_Learning. indb 341 07/05/2019 17:09:38 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
342 | Capítulo 12: Distribuindo o Tensor Flow Por Dispositivos e Servidores $ python3 simple_client. py grpc://machine-b. example. com:2222 2. 0 Este recurso tem vantagens e desvantagens: é ótimo se você deseja compartilhar variáveis em diversas sessões, mas, para executar cálculos completamente independentes no mesmo cluster, você terá que ter cuidado para não utilizar, por acidente, os mesmos nomes de variáveis. Uma maneira de garantir que você não terá conflitos de nomes seria envolver toda a sua fase de construção dentro de um escopo variável com um nome exclusivo para cada cálculo, por exemplo: with tf. variable_scope("my_problem_1"): [... ] # Fase de construção do problema Uma solução melhor seria utilizar um bloco de contêiner: with tf. container("my_problem_1"): [... ] # Fase de construção do problema Isso utilizará um contêiner dedicado ao problema #1 em vez do padrão (cujo nome é uma string vazia “ ”). Suas vantagens incluem o fato de os nomes das variáveis ficarem fáceis e curtos, e ser possível facilmente resetar um contêiner nomeado. Por exemplo, o comando a seguir se conectará ao servidor na máquina A e pedirá para resetar o con-têiner denominado “ my_problem_1 ”, que liberará todos os recursos que ele utilizou (e também fechará todas as sessões abertas no servidor). Qualquer variável gerenciada por este contêiner deve ser inicializada antes de ser utilizada novamente: tf. Session. reset("grpc://machine-a. example. com:2222", ["my_problem_1"]) Os contêineres de recursos facilitam de forma flexível o compartilhamento de variáveis entre as sessões. Por exemplo, a Figura 12-7 mostra quatro clientes que rodam gráficos diferentes no mesmo cluster, mas compartilham algumas variáveis. Os clientes A e B compartilham a mesma variável x gerenciada pelo contêiner padrão, enquanto os clien-tes C e D compartilham outra variável chamada x gerenciada pelo contêiner chamado “my_problem_1 ”. Observe que o cliente C utiliza as variáveis de ambos os contêineres. CG_MIOLO_Hands_On_Machine_Learning. indb 342 07/05/2019 17:09:38 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
Vários Dispositivos em Vários Servidores | 343 Cliente A Cliente B Cliente DCliente C Contêiner Cluster padrão Figura 12-7. Contêineres de recursos Os contêineres de recursos denominados filas e leitores também preservam o estado de outras operações com status. Daremos uma olhada em filas primeiro. Comunicação Assíncrona com a Utilização de Filas do Tensor Flow Filas são outra ótima maneira de trocar dados entre várias sessões; por exemplo, um caso de uso comum é ter um cliente que cria um grafo que carrega os dados de treinamento e os empurra para uma fila, enquanto outro cliente cria um grafo que puxa os dados da fila e treina um modelo (veja a Figura 12-8). Isso pode acelerar consideravelmente o trei-namento porque as operações não precisam esperar o próximo minilote em cada etapa. Cluster Client e Client e Entrada Treinar Treinar Entrada Fase de construção Fase deexecução Figura 12-8. Utilizando filas para carregar os dados de treinamento de forma assíncrona O Tensor Flow fornece vários tipos de filas e o mais simples deles é a fila first-in first-out (FIFO). Por exemplo, o código a seguir cria uma fila FIFO que pode armazenar até 10 tensores contendo dois valores de flutuação cada: CG_MIOLO_Hands_On_Machine_Learning. indb 343 07/05/2019 17:09:39 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
344 | Capítulo 12: Distribuindo o Tensor Flow Por Dispositivos e Servidores q = tf. FIFOQueue(capacity=10, dtypes=[tf. float32], shapes=[[2]], name="q", shared_name="shared_q") Para compartilhar variáveis entre as sessões, você só precisava espe-cificar o mesmo nome e contêiner nas duas extremidades. O Tensor-Flow não utiliza o atributo name em filas, mas sim o shared_name, portanto é importante especificá-lo (mesmo que seja o mesmo que o name ). E, claro, que utilize o mesmo contêiner. Enfileirando dados Para empurrar dados para uma fila, você deve criar uma operação enqueue. Por exemplo, o código a seguir empurra três instâncias de treinamento para a fila: # training_data_loader. py import tensorflow as tf q = tf. FIFOQueue(capacity=10, [... ], shared_name="shared_q") training_instance = tf. placeholder(tf. float32, shape=[2])enqueue = q. enqueue([training_instance]) with tf. Session("grpc://machine-a. example. com:2222") as sess: sess. run(enqueue, feed_dict={training_instance: [1., 2. ]}) sess. run(enqueue, feed_dict={training_instance: [3., 4. ]}) sess. run(enqueue, feed_dict={training_instance: [5., 6. ]}) Você pode enfileirar várias instâncias ao mesmo tempo em vez de enfileirá-las uma por uma utilizando a operação enqueue_many : [... ] training_instances = tf. placeholder(tf. float32, shape=(None, 2))enqueue_many = q. enqueue_many([training_instances]) with tf. Session("grpc://machine-a. example. com:2222") as sess: sess. run(enqueue_many, feed_dict={training_instances: [[1., 2. ], [3., 4. ], [5., 6. ]]}) Ambos os exemplos adicionam os mesmos três tensores à fila. Desenfileirando os dados Para retirar as instâncias da fila, do outro lado, você precisa utilizar a operação dequeue : # trainer. py import tensorflow as tf q = tf. FIFOQueue(capacity=10, [... ], shared_name="shared_q") dequeue = q. dequeue() with tf. Session("grpc://machine-a. example. com:2222") as sess: print(sess. run(dequeue)) # [1., 2. ] print(sess. run(dequeue)) # [3., 4. ] print(sess. run(dequeue)) # [5., 6. ] CG_MIOLO_Hands_On_Machine_Learning. indb 344 07/05/2019 17:09:40 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
Vários Dispositivos em Vários Servidores | 345Puxe um minilote inteiro ao mesmo tempo em vez de apenas uma instância por vez utilizando uma operação dequeue_many especificando o tamanho do minilote: [... ] batch_size = 2 dequeue_mini_batch = q. dequeue_many(batch_size) with tf. Session("grpc://machine-a. example. com:2222") as sess: print(sess. run(dequeue_mini_batch)) # [[1., 2. ], [4., 5. ]] print(sess. run(dequeue_mini_batch)) # bloqueado esperando por outra instância A operação enqueue [enfileiramento] será bloqueada até que os itens sejam removidos por uma operação dequeue [desenfileiramento] quando uma fila estiver cheia. Da mesma forma, quando uma fila está vazia (ou você está utilizando dequeue_many() e há menos itens do que o tamanho do minilote), a operação dequeue será bloqueada quando utili-zarmos uma operação enqueue até que itens suficientes sejam empurrados para a fila. Filas de tuplas Em vez de apenas um único tensor, cada item em uma fila pode ser uma tupla (lista orde-nada) de tensores (de vários tipos e formas). Por exemplo, a seguinte fila armazena pares de tensores, um do tipo int32 e formato (), e o outro do tipo float32 no formato [3,2] : q = tf. FIFOQueue(capacity=10, dtypes=[tf. int32, tf. float32], shapes=[[],[3,2]], name="q", shared_name="shared_q") À operação de enfileirar devem ser dados pares de tensores (observe que cada par representa apenas um item na fila): a = tf. placeholder(tf. int32, shape=()) b = tf. placeholder(tf. float32, shape=(3, 2)) enqueue = q. enqueue((a, b)) with tf. Session([... ]) as sess: sess. run(enqueue, feed_dict={a: 10, b:[[1., 2. ], [3., 4. ], [5., 6. ]]}) sess. run(enqueue, feed_dict={a: 11, b:[[2., 4. ], [6., 8. ], [0., 2. ]]}) sess. run(enqueue, feed_dict={a: 12, b:[[3., 6. ], [9., 2. ], [5., 8. ]]}) Por outro lado, a função dequeue() cria um par de operações de desenfileirar: dequeue_a, dequeue_b = q. dequeue() No geral, você deve executar essas operações em conjunto: with tf. Session([... ]) as sess: a_val, b_val = sess. run([dequeue_a, dequeue_b]) print(a_val) # 10 print(b_val) # [[1., 2. ], [3., 4. ], [5., 6. ]] CG_MIOLO_Hands_On_Machine_Learning. indb 345 07/05/2019 17:09:40 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
346 | Capítulo 12: Distribuindo o Tensor Flow Por Dispositivos e Servidores Se você executar dequeue_a por conta própria, vai desenfileirar um par e retornar apenas o primeiro elemento; o segundo será perdido (da mesma forma, se você rodar dequeue_b por conta própria, o primeiro elemento será perdido). A função dequeue_many() também retorna um par de operações: batch_size = dequeue_as, dequeue_bs = q. dequeue_many(batch_size) Você pode utilizá-la como esperado: with tf. Session([... ]) as sess: a, b = sess. run([dequeue_a, dequeue_b]) print(a) # [10, 11] print(b) # [[[1., 2. ], [3., 4. ], [5., 6. ]], [[2., 4. ], [6., 8. ], [0., 2. ]]] a, b = sess. run([dequeue_a, dequeue_b]) # bloqueado esperando por outro par Fechando uma fila É possível fechar uma fila para sinalizar para as outras sessões que os dados não serão mais enfileirados: close_q = q. close() with tf. Session([... ]) as sess: [... ] sess. run(close_q) As execuções subsequentes das operações enqueue ou enqueue_many levantarão uma exceção. Por padrão, a menos que você recorra a q. close(cancel_pending_enqueues=-True), qualquer requisição pendente enfileirada será atendida. As execuções subsequentes das operações dequeue ou dequeue_many continuarão a ser bem-sucedidas desde que haja itens na fila, mas falharão quando não houver itens restan-tes o suficiente. Se você utilizar a operação dequeue_many e houver algumas instâncias deixadas na fila, mas menos que o tamanho do minilote, elas serão perdidas. É melhor usar a operação dequeue_up_to, que se comporta exatamente como dequeue_many exceto quando uma fila é fechada e há menos destas do que instâncias batch_size deixadas na fila, caso em que apenas as retorna. Random Shuffle Queue O Tensor Flow também suporta mais alguns tipos de filas, incluindo a Random Shuffle Queue, que pode ser utilizada assim como o FIFOQueue, mas os itens são desenfileirados de forma aleatória, podendo ser úteis para embaralhar instâncias de treinamento em cada época durante o treinamento. Primeiro, criaremos a fila: CG_MIOLO_Hands_On_Machine_Learning. indb 346 07/05/2019 17:09:41 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
Vários Dispositivos em Vários Servidores | 347q = tf. Random Shuffle Queue(capacity=50, min_after_dequeue=10, dtypes=[tf. float32], shapes=[()], name="q", shared_name="shared_q") O min_after_dequeue especifica o número mínimo de itens que devem permanecer na fila após a operação dequeue para garantir que haverá instâncias suficientes na fila a ter aleatoriedade suficiente (assim que a fila é fechada, o limite min_after_dequeue é ignorado). Agora, suponha que você posicionou 22 itens nesta fila (flutua de 1. a 22. ). Veja como você pode desenfileirá-los: dequeue = q. dequeue_many(5) with tf. Session([... ]) as sess: print(sess. run(dequeue)) # [ 20. 15. 11. 12. 4. ] (faltam 17 itens) print(sess. run(dequeue)) # [ 5. 13. 6. 0. 17. ] (faltam 12 itens) print(sess. run(dequeue)) # 12-5 < 10: bloqueado esperando por mais 3 instâncias Padding Fifo Queue Um Padding FIFOQueue também pode ser utilizado como um FIFOQueue, só que ele aceita tensores de tamanhos variáveis ao longo de qualquer dimensão (mas com uma classi-ficação fixa). Ao desenfileirá-las em uma operação dequeue_many, ou dequeue_up_to, cada tensor é preenchido com zeros para torná-lo do mesmo tamanho que o maior tensor no minilote ao longo de cada dimensão variável. Por exemplo, você poderia enfileirar tensores 2D (matrizes) de tamanhos arbitrários: q = tf. Padding FIFOQueue(capacity=50, dtypes=[tf. float32], shapes=[(None, None)], name="q", shared_name="shared_q") v = tf. placeholder(tf. float32, shape=(None, None))enqueue = q. enqueue([v]) with tf. Session([... ]) as sess: sess. run(enqueue, feed_dict={v: [[1., 2. ], [3., 4. ], [5., 6. ]]}) # 3x2 sess. run(enqueue, feed_dict={v: [[1. ]]}) # 1x1 sess. run(enqueue, feed_dict={v: [[7., 8., 9., 5. ], [6., 7., 8., 9. ]]}) # 2x4 Se retirarmos um item por vez, teremos exatamente os mesmos tensores que foram enfi-leirados. Mas, se retirarmos vários itens de cada vez, a fila automaticamente preenche os tensores adequadamente (utilizando dequeue_many() ou dequeue_up_to() ). Por exemplo, se desenfileirarmos os três itens ao mesmo tempo, todos os tensores serão preenchidos com zeros para se tornarem 3 × 4, uma vez que o tamanho máximo para a primeira dimensão é 3 (primeiro item) e o tamanho máximo para a segunda dimensão é 4 (terceiro item). CG_MIOLO_Hands_On_Machine_Learning. indb 347 07/05/2019 17:09:41 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
348 | Capítulo 12: Distribuindo o Tensor Flow Por Dispositivos e Servidores >>> q = [... ] >>> dequeue = q. dequeue_many(3) >>> with tf. Session([... ]) as sess:... print(sess. run(dequeue))... [[[ 1. 2. 0. 0. ] [ 3. 4. 0. 0. ] [ 5. 6. 0. 0. ]] [[ 1. 0. 0. 0. ] [ 0. 0. 0. 0. ] [ 0. 0. 0. 0. ]] [[ 7. 8. 9. 5. ] [ 6. 7. 8. 9. ] [ 0. 0. 0. 0. ]]] Este tipo de fila pode ser útil quando você está lidando com entradas de comprimento variável como sequências de palavras (veja o Capítulo 14). Ok, agora pausaremos por um segundo: até aqui você aprendeu a distribuir cálculos em vários dispositivos e servidores, compartilhar variáveis entre as sessões e se comunicar de maneira assíncrona com a utilização de filas. No entanto, antes de começar a treinar redes neurais, há um último tópico que precisamos discutir: como carregar com eficiência os dados de treinamento. Carregando Dados Diretamente do Grafo Até agora, assumimos que, com a utilização de placeholders, os clientes carregariam os dados de treinamento e os forneceriam para o cluster. Isso é simples e funciona muito bem para configurações simples, mas, uma vez que transfere várias vezes os dados de treinamento, é bastante ineficiente: 1. Do si stema de arquivos para o cliente; 2. Do cl iente para a master task; 3. Pos sivelmente da master task para outras tasks nas quais os dados são necessários. Isso piora se você tiver vários clientes treinando várias redes neurais usando os mesmos dados de treinamento (por exemplo, para ajuste do hiperparâmetro): se cada cliente carregar simultaneamente os dados, você pode até saturar seu servidor de arquivos ou a largura de banda da rede. Pré-carregue os dados em uma variável Para conjuntos de dados que podem caber na memória, uma opção melhor é carregar os dados de treinamento uma vez, atribuí-los a uma variável e, então, utilizar essa variável CG_MIOLO_Hands_On_Machine_Learning. indb 348 07/05/2019 17:09:42 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
Vários Dispositivos em Vários Servidores | 349em seu grafo, o que é chamado de pré-carregamento do conjunto de treinamento. Desta forma, os dados serão transferidos apenas uma vez do cliente para o cluster (mas ainda podem ser movidos de uma task para outra, dependendo de quais operações necessita-rem dele). O código a seguir mostra como carregar o conjunto completo de treinamento em uma variável: training_set_init = tf. placeholder(tf. float32, shape=(None, n_features)) training_set = tf. Variable(training_set_init, trainable=False, collections=[], name="training_set") with tf. Session([... ]) as sess: data = [... ] # carregue os dados de treinamento do datastore sess. run(training_set. initializer, feed_dict={training_set_init: data}) Você deve configurar trainable=False para que os otimizadores não tentem ajustar esta variável. Você também deve configurar collections=[] para garantir que esta variável não seja adicionada à coleção Graph Keys. GLOBAL_VARIABLES, que é utilizada para salvar e restaurar pontos de verificação. Este exemplo assume que todo o seu conjunto de treinamento (in-cluindo os rótulos) consiste apenas de valores float32. Se esse não for o caso, você precisará de uma variável por tipo. Lendo os dados de treinamento diretamente do grafo Se o conjunto de treinamento não cabe na memória, uma boa solução seria utilizar as operações de leitura, que conseguem ler dados diretamente do sistema de arquivos. Des-sa forma, os dados de treinamento nunca precisam fluir pelos clientes. O Tensor Flow fornece leitores para vários formatos de arquivo: CSV; Reg istros binários de comprimento fixo; O for mato TFRecords do Tensor Flow, baseado em buffers de protocolo. Vejamos um exemplo simples de leitura de um arquivo CSV (para outros formatos, verifique a documentação da API). Suponha que você tenha um arquivo chamado my_test. csv, que contém instâncias de treinamento, e você quer criar operações para ler o arquivo. Suponha que ele tenha o seguinte conteúdo, com dois recursos flutuantes x1 e x2 e um inteiro target representando uma classe binária: x1, x2, target 1., 2., 0 4., 5 , 1 7., , 0 CG_MIOLO_Hands_On_Machine_Learning. indb 349 07/05/2019 17:09:42 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
350 | Capítulo 12: Distribuindo o Tensor Flow Por Dispositivos e Servidores Primeiro, criaremos um Text Line Reader para ler este arquivo. Um Text Line Reader abre um arquivo (uma vez que dizemos a ele qual abrir) e lê as linhas uma por uma. É uma operação dinâmica, como variáveis e filas: preserva seu estado em múltiplas execuções do grafo acompanhando qual arquivo está lendo atualmente e qual é sua posição atual neste arquivo. reader = tf. Text Line Reader(skip_header_lines=1) Em seguida, criamos uma fila que o leitor puxará para saber qual arquivo ler em seguida. Para enviar qualquer nome de arquivo que desejarmos para a fila, também criamos uma operação de enfileiramento, um placeholder e uma operação para fechar a fila quando não tivermos mais arquivos a serem lidos: filename_queue = tf. FIFOQueue(capacity=10, dtypes=[tf. string], shapes=[()]) filename = tf. placeholder(tf. string) enqueue_filename = filename_queue. enqueue([filename]) close_filename_queue = filename_queue. close() Agora estamos prontos para criar uma operação de leitura que lerá um registro (ou seja, uma linha) por vez e retornará um par chave/valor. A chave é o identificador exclusivo do registro — uma string composta do nome do arquivo, dois pontos ( :) e o número da linha — e o valor é uma string com o conteúdo da linha: key, value = reader. read(filename_queue) Temos tudo o que precisamos para ler o arquivo, linha por linha! Mas ainda não ter-minamos — precisamos analisar essa string para obter as características e o destino: x1, x2, target = tf. decode_csv(value, record_defaults=[[-1. ], [-1. ], [-1]]) features = tf. stack([x1, x2]) A primeira linha utiliza o parser CSV do Tensor Flow para extrair os valores da linha atual. Os valores padrão são utilizados quando um campo está ausente (neste exemplo, a característica x2 da terceira instância de treinamento) e também para determinar o tipo de cada campo (nesse caso, dois flutuantes e um inteiro). Finalmente, podemos empurrar essa instância de treinamento e seu alvo para um Random Shuffle Queue, que compartilharemos com o grafo de treinamento (para ex-trairmos minilotes), e criar uma operação para fechar essa fila quando terminarmos de empurrar as instâncias nela: instance_queue = tf. Random Shuffle Queue( capacity=10, min_after_dequeue=2, dtypes=[tf. float32, tf. int32], shapes=[[2],[]], name="instance_q", shared_name="shared_instance_q") enqueue_instance = instance_queue. enqueue([features, target])close_instance_queue = instance_queue. close() CG_MIOLO_Hands_On_Machine_Learning. indb 350 07/05/2019 17:09:43 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
Vários Dispositivos em Vários Servidores | 351Ufa! Isso foi muito trabalho para ler apenas um arquivo. Além disso, apenas criamos o grafo, então precisamos executá-lo: with tf. Session([... ]) as sess: sess. run(enqueue_filename, feed_dict={filename: "my_test. csv"}) sess. run(close_filename_queue) try: while True: sess. run(enqueue_instance) except tf. errors. Out Of Range Error as ex: pass # não há mais registros no arquivo atual e não há mais arquivos para ler sess. run(close_instance_queue) Primeiro, abrimos a sessão, enfileiramos o arquivo “my_test. csv” e imediatamente fecha-mos essa fila já que não enfileiraremos mais nomes de arquivos. Em seguida, executamos um loop infinito para enfileirar instâncias, uma a uma. A enqueue_instance depende que o leitor leia a próxima linha, então um novo registro é lido a cada iteração até chegar ao final do arquivo. Nesse ponto, ele tenta ler a fila filename para saber qual arquivo ler em seguida e, como a fila está fechada, lança uma exceção Out Of Range Error (se não fecharmos a fila, ela permanecerá bloqueada até que digitemos outro nome de arquivo ou a fechemos). Por fim, fechamos a fila de instâncias para que as operações de treinamento não sejam bloqueadas para sempre. A Figura 12-9 resume o que aprendemos; ela representa um grafo típico para ler instâncias de treinamento em um conjunto de arquivos CSV. Fila /f_ilename Pré-processo Fila de instância Arquivo atual Local atual Valor Chave(próxima gravação) Figura 12-9. Um grafo dedicado à leitura de instâncias de treinamento de arquivos CSV Você precisa criar a fila de instâncias compartilhadas e desenfileirar os minilotes no grafo do treinamento: CG_MIOLO_Hands_On_Machine_Learning. indb 351 07/05/2019 17:09:43 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
352 | Capítulo 12: Distribuindo o Tensor Flow Por Dispositivos e Servidores instance_queue = tf. Random Shuffle Queue([... ], shared_name="shared_instance_q") mini_batch_instances, mini_batch_targets = instance_queue. dequeue_up_to(2) [... ] # use as instâncias de minilote e alvos para criar o grafo de treinamento training_op = [... ] with tf. Session([... ]) as sess: try: for step in range(max_steps): sess. run(training_op) except tf. errors. Out Of Range Error as ex: pass # não há mais instâncias de treinamento Neste exemplo, o primeiro minilote conterá as duas primeiras instâncias do arquivo CSV e o segundo minilote conterá a última instância. As filas do Tensor Flow não lidam bem com tensores esparsos, por-tanto, se as instâncias de treinamento forem esparsas, você deverá analisar os registros após a fila de instâncias. Essa arquitetura utilizará apenas uma thread para ler registros e empurrá-los para a fila de instâncias. Você obtém uma taxa de transferência muito maior ao ter várias threads lidas simultaneamente com a utilização de vários leitores a partir de vários arquivos. Vejamos como. Leitores Multithreaded utilizando as classes Coordinator e Queue Runner Para que várias threads leiam instâncias simultaneamente, você pode criar threads Python (utilizando o módulo threading ) e gerenciá-las você mesmo. No entanto, o Tensor Flow fornece algumas ferramentas que facilitam isso: a classe Coordinator e a classe Queue Runner. Um Coordinator é um objeto muito simples cujo único propósito é coordenar a inter-rupção de várias threads. Primeiro você cria um Coordinator : coord = tf. train. Coordinator() Então você o fornece a todas as threads que precisam parar juntas, e seu loop principal se parecerá com isso: while not coord. should_stop(): [... ] # faça alguma coisa Ao recorrermos ao método Coordinator request_stop(), qualquer thread pode solicitar que todos os segmentos parem: coord. request_stop() CG_MIOLO_Hands_On_Machine_Learning. indb 352 07/05/2019 17:09:43 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
Vários Dispositivos em Vários Servidores | 353Cada thread será interrompida assim que terminar sua iteração atual e você pode esperar que todas finalizem ao chamar o método do Coordinator join() : coord. join(list_of_threads) Um Queue Runner executa várias threads, cada uma executando repetidamente uma operação de enfileiramento, preenchendo uma fila o mais rápido possível. Assim que a fila é fechada, a próxima thread que tenta enviar um item para a fila receberá um Out Of Range Error ; este segmento captura o erro e imediatamente informa outras threads para pararem de utilizar um Coordinator. O código a seguir mostra como você pode usar um Queue Runner para que cinco threads leiam instâncias simultaneamente e as empurrem para uma fila de instâncias: [... ] # mesma fase de construção de antes queue_runner = tf. train. Queue Runner(instance_queue, [enqueue_instance] * 5) with tf. Session() as sess: sess. run(enqueue_filename, feed_dict={filename: "my_test. csv"}) sess. run(close_filename_queue) coord = tf. train. Coordinator() enqueue_threads = queue_runner. create_threads(sess, coord=coord, start=True) A primeira linha cria o Queue Runner e pede que ele execute cinco threads, todas execu-tando repetidamente a mesma operação enqueue_instance. Então iniciamos uma sessão e enfileiramos o nome dos arquivos para a leitura (neste caso, apenas “my_test. csv” ). A seguir, como acabamos de explicar, criamos um Coordinator que o Queue Runner utili-zará para parar suavemente, conforme explicado. Finalmente, dizemos ao Queue Runner para criar as threads e iniciá-las. As threads lerão todas as instâncias de treinamento, as enviarão para a fila de instâncias e, em seguida, todas pararão. Isso será um pouco mais eficiente do que antes, mas podemos melhorar. Atualmente, todas as threads estão lendo do mesmo arquivo. Podemos fazê-las ler simultaneamente a partir de arquivos separados (veja a Figura 12-10) ao criar vários leitores (assumindo que os dados de treinamento são particionados em vários arquivos CSV). Fila /f_ilename Valor Valor Valor Fila de instância Pré-processo Figura 12-10. Leitura simultânea de vários arquivos CG_MIOLO_Hands_On_Machine_Learning. indb 353 07/05/2019 17:09:44 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
354 | Capítulo 12: Distribuindo o Tensor Flow Por Dispositivos e Servidores Para isso, precisamos escrever uma pequena função para criar um leitor e os nós que lerão e enviarão uma instância para a fila de instâncias: def read_and_push_instance(filename_queue, instance_queue): reader = tf. Text Line Reader(skip_header_lines=1) key, value = reader. read(filename_queue) x1, x2, target = tf. decode_csv(value, record_defaults=[[-1. ], [-1. ], [-1]]) features = tf. stack([x1, x2]) enqueue_instance = instance_queue. enqueue([features, target]) return enqueue_instance Em seguida, definimos as filas: filename_queue = tf. FIFOQueue(capacity=10, dtypes=[tf. string], shapes=[()]) filename = tf. placeholder(tf. string) enqueue_filename = filename_queue. enqueue([filename]) close_filename_queue = filename_queue. close() instance_queue = tf. Random Shuffle Queue([... ]) E, finalmente, criamos o Queue Runner, mas, desta vez, damos uma lista de diferentes operações de enfileiramento. Cada operação utilizará um leitor diferente para que as threads sejam lidas simultaneamente a partir de arquivos diferentes: read_and_enqueue_ops = read_and_push_instance(filename_queue, instance_queue) for i in range(5)] queue_runner = tf. train. Queue Runner(instance_queue, read_and_enqueue_ops) A fase de execução é a mesma de antes: primeiro inserimos os nomes dos arquivos para leitura, criamos um Coordinator e criamos e iniciamos as threads Queue Runner. Desta vez, todas lerão diferentes arquivos simultaneamente até que todos sejam lidos por completo e, então, o Queue Runner fechará a fila de instâncias para que outras operações puxando a partir dele não sejam bloqueadas. Outras funções de conveniências O Tensor Flow também oferece algumas funções convenientes para simplificar certas tarefas comuns na leitura de instâncias de treinamento. Veremos apenas alguns exemplos (consulte a documentação da API para obter a lista completa). O string_input_producer() utiliza um tensor 1D contendo uma lista de nomes de arquivos, cria uma thread que envia um nome de arquivo de cada vez para a fila dos nomes e a fecha. Se você especificar um número de épocas, ele percorrerá os nomes dos arquivos uma vez por época antes de fechar a fila. Por padrão, ele embaralha os nomes dos arquivos em cada época, cria um Queue Runner para gerenciar sua thread e o adiciona à coleção Graph Keys. QUEUE_RUNNERS. Para iniciar cada Queue Runner nesta coleção, você pode chamar a função tf. train. start_queue_runners(). Observe que, CG_MIOLO_Hands_On_Machine_Learning. indb 354 07/05/2019 17:09:44 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
Vários Dispositivos em Vários Servidores | 355se você se esquecer de iniciar o Queue Runner, a fila do nome do arquivo estará aberta e vazia, e seus leitores estarão bloqueados para sempre. Para executar uma operação de enfileiramento, existem algumas outras funções producer que, de maneira semelhante, criam uma fila e uma Queue Runner correspondente (por exemplo, input_producer(), range_input_producer(), e slice_input_producer() ). A função shuffle_batch() pega uma lista de tensores (por exemplo, [features, tar-get] ) e cria: Uma Random Shuffle Queue; Uma Queue Runner para enviar os tensores para a fila (adicionado a coleção Graph Keys. QUEUE_RUNNERS ); Uma o peração dequeue_many para extrair um minilote da fila. Isso facilita o gerenciamento em um processo único de um pipeline de entrada multithread alimentando uma fila e um pipeline de treinamento lendo minilotes dessa fila. Verifique também as funções batch(), batch_join() e shuffle_batch_join(), que fornecem funcionalidade semelhante. Ok! Agora você tem todas as ferramentas necessárias em um cluster do Tensor Flow para começar a treinar e executar redes neurais eficientemente em vários dispositivos e servidores. Vamos rever o que você aprendeu: Uti lizar vários dispositivos GPU; Con figurar e iniciar um cluster do Tensor Flow; Dis tribuir cálculos entre vários dispositivos e servidores; Com partilhar variáveis (e outras operações de estado como filas e leitores em sessões com a utilização de contêineres); Coo rdenar vários grafos trabalhando de forma assíncrona com a utilização de filas; Ler e ntradas eficientemente utilizando readers, queue runners e coordinators. Agora, utilizaremos tudo isso na paralelização das redes neurais! CG_MIOLO_Hands_On_Machine_Learning. indb 355 07/05/2019 17:09:45 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
356 | Capítulo 12: Distribuindo o Tensor Flow Por Dispositivos e Servidores Paralelizando Redes Neurais em um Cluster do Tensor Flow Nesta seção, primeiro veremos como paralelizar várias redes neurais posicionando cada uma em um dispositivo diferente. Em seguida, veremos um problema muito mais complicado ao treinar uma única rede neural em vários dispositivos e servidores. Uma Rede Neural por Dispositivo A maneira mais trivial de treinar e executar redes neurais em um cluster do Tensor Flow é pegar exatamente o mesmo código que você utilizaria para um único dispositivo em uma única máquina e especificar o endereço do servidor principal ao criar a sessão. É só isso! Seu código será executado no dispositivo padrão do servidor. Você pode alterar o dispositivo que executará seu grafo ao simplesmente posicionar a fase de construção do seu código em um bloco de dispositivo. Ao executar várias sessões do cliente em paralelo (em diferentes threads ou diferentes processos), você pode facilmente treinar ou executar muitas redes neurais em paralelo em todos os dispositivos e em todas as máquinas em seu cluster (veja a Figura 12-11) conectando-os a diferentes servidores e configurando-os para utilizar diferentes dispo-sitivos. A aceleração é quase linear4. Treinar 100 redes neurais em 50 servidores com 2 GPUs cada não levará muito mais tempo do que treinar apenas 1 rede neural em 1 GPU. Cliente Cliente Cliente Cluster Servidor TF Servidor TF Figura 12-11. Treinando uma rede neural por dispositivo Esta solução é perfeita para o ajuste do hiperparâmetro: cada dispositivo no cluster treinará um modelo diferente com seu próprio conjunto de hiperparâmetros. Quanto 4 Não é 100% linear se você esperar que todos os dispositivos terminem, já que o tempo total será o tempo gasto pe lo dispositivo mais lento. CG_MIOLO_Hands_On_Machine_Learning. indb 356 07/05/2019 17:09:45 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
Paralelizando Redes Neurais em um Cluster do Tensor Flow | 357mais poder de computação você tiver, maior será o espaço de hiperparâmetro que você pode explorar. Ela também funcionará perfeitamente se você hospedar um serviço da Web que receba um grande número de consultas por segundo (QPS) e precisar da rede neural para fazer uma previsão para cada consulta. Basta replicar a rede neural em todos os dispositivos no cluster e enviar consultas em todos os dispositivos. Ao adicionar mais servidores, você manipula um número ilimitado de QPS (no entanto, isso não reduzirá o tempo necessário para processar uma única solicitação pois ela ainda terá que esperar que uma rede neural faça uma previsão). Outra opção é utilizar o Tensor Flow Serving para atender suas re-des neurais. É um sistema de código aberto lançado pelo Google em fevereiro de 2016 projetado para atender a um grande volume de con-sultas a modelos de Aprendizado de Máquina (normalmente construído com o Tensor Flow). Ele lida com versões do modelo para que você pos-sa implantar facilmente uma nova versão de sua rede na produção ou experimentar com vários algoritmos sem interromper seu serviço, e ele pode sustentar uma carga pesada ao adicionarmos mais servidores. Para mais detalhes, confira https://www. tensorflow. org/serving/. Replicação em Grafo Versus Replicação Entre Grafos Você também pode paralelizar o treinamento de um grande ensemble de redes neurais colocando cada rede neural em um dispositivo diferente (os ensembles foram introdu-zidos no Capítulo 7). No entanto, quando você quiser executar o ensemble, precisará agregar as previsões individuais feitas por cada rede neural para produzir a previsão do ensemble, e isso requer um pouco de coordenação. Existem duas abordagens principais para lidar com um ensemble de redes neurais (ou qualquer outro grafo que contenha grandes blocos de cálculos independentes): Voc ê pode criar um grande grafo contendo cada rede neural, cada uma fixada em um dis-positivo diferente, além dos cálculos necessários para agregar as previsões individuais de todas as redes neurais (veja a Figura 12-12). Em seguida, basta criar uma sessão para qualquer servidor no cluster e deixar que ela cuide de tudo (incluindo aguardar que todas as previsões individuais estejam disponíveis antes de agregá-las). Essa abordagem é conhecida como in-graph replication. CG_MIOLO_Hands_On_Machine_Learning. indb 357 07/05/2019 17:09:45 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
358 | Capítulo 12: Distribuindo o Tensor Flow Por Dispositivos e Servidores Cliente Cluster Servidor TF Servidor TF Servidor TFsaída entrada Figura 12-12. In-graph replication Com o alternativa, você pode criar um grafo separado para cada rede neural e lidar com a sincronização entre esses grafos, abordagem esta chamada de between-graph replication. Coordenar a execução desses grafos com a utilização de filas é uma implementação típica (veja a Figura 12-13). Um conjunto de clientes manipula uma rede neural cada um, lendo a partir de sua fila de entrada dedi-cada e gravando em sua fila de previsão dedicada. Outro cliente é responsável por ler as entradas e mandá-las para todas as filas de entrada (copiando todas as entradas para cada fila). Finalmente, um último cliente é encarregado de ler uma previsão de cada fila de previsão e agregá-las para produzir a previsão do ensemble. Cluster Servidor TF Servidor TF Servidor TFCliente Cliente Saída Entrada Figura 12-13. Replicação entre grafos CG_MIOLO_Hands_On_Machine_Learning. indb 358 07/05/2019 17:09:46 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
Paralelizando Redes Neurais em um Cluster do Tensor Flow | 359Essas soluções têm seus prós e contras. A implimentação da in-graph replication é um pouco mais simples, pois você não precisa gerenciar vários clientes e filas. No entanto, é um pouco mais fácil de organizar em módulos bem delimitados e testar a replicação entre grafos. Além disso, oferece mais flexibilidade. Por exemplo, você poderia adicionar um timeout de desenfileiramento no cliente agregador para que o ensemble não falhasse, mesmo que um dos clientes da rede neural falhasse ou se uma delas demorasse demais para produzir sua previsão. O Tensor Flow permite que você especifique o timeout quando chama a função run() passando a Run Options com timeout_in_ms : with tf. Session([... ]) as sess: [... ] run_options = tf. Run Options() run_options. timeout_in_ms = 1000 # 1s timeout try: pred = sess. run(dequeue_prediction, options=run_options) except tf. errors. Deadline Exceeded Error as ex: [... ] # Houve um timeout na operação dequeue depois de 1s Outra forma de especificar um timeout seria definir a opção de configuração operation_time out_in_ms, mas, neste caso, a função run() expira se qualquer operação demorar mais do que o timeout delay: config = tf. Config Proto() config. operation_timeout_in_ms = 1000 # timeout de 1s para toda operação with tf. Session([... ], config=config) as sess: [... ] try: pred = sess. run(dequeue_prediction) except tf. errors. Deadline Exceeded Error as ex: [... ] # houve um timeout na operação dequeue depois de 1s Paralelismo do Modelo Até agora, rodamos cada rede neural em um único dispositivo. E se quisermos executar uma única rede neural em vários dispositivos? Isso requer que você recorte seu modelo em pedaços e execute cada um deles em um dispositivo diferente, o que é chamado de paralelismo do modelo. Infelizmente, é bem complicado, e depende muito da arquitetura de sua rede neural. Não há muito a ganhar com essa abordagem para redes totalmente conectadas (veja a Figura 12-14). Intuitivamente, pode parecer que uma forma fácil de dividir o modelo seria posicionar cada camada em um dispositivo diferente, mas isso não funciona, já que cada camada precisa esperar pela saída da camada anterior antes de poder fazer qualquer coisa. Então, talvez você pudesse fatiá-la verticalmente — por exemplo, com a metade esquerda de cada camada em um dispositivo e a direita em outro. Isso melhoraria um pouco, já que as duas metades de cada camada podem trabalhar em paralelo, mas o problema é que cada metade da próxima camada vai requerer a saída de CG_MIOLO_Hands_On_Machine_Learning. indb 359 07/05/2019 17:09:46 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
360 | Capítulo 12: Distribuindo o Tensor Flow Por Dispositivos e Servidores ambas as metades, portanto haverá muita comunicação entre dispositivos (representada pelas setas tracejadas). É provável que isso cancele completamente o benefício da com-putação paralela, já que a comunicação entre dispositivos é lenta (especialmente se for através de máquinas separadas). Rede neural totalmente conec tada Uma camada por dispositivo Ruim!Divisão ver tical Não muito boa... Figura 12-14. Divisão de uma rede neural totalmente conectada Como veremos no Capítulo 13, algumas arquiteturas de rede neural, como redes neurais convolucionais, contêm camadas que são conectadas apenas parcialmente às camadas inferiores, então têm muito mais facilidade de distribuir os pedaços entre dispositivos de uma forma eficiente. Divisão ve rtical Razoavelmente boa!Rede neural parcialmente conec tada Figura 12-15. Dividindo uma rede neural parcialmente conectada CG_MIOLO_Hands_On_Machine_Learning. indb 360 07/05/2019 17:09:47 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
Paralelizando Redes Neurais em um Cluster do Tensor Flow | 361Além disso, conforme veremos no Capítulo 14, algumas redes neurais recorrentes profundas são compostas de várias camadas de células de memória (veja o lado esquerdo da Figura 12-16). A saída de uma célula no momento t é realimentada para sua entrada no tempo t + 1 (como você pode ver mais claramente no lado direito da Figura 12-16). Se dividirmos tal rede horizontalmente, posicionando cada camada em um dispositivo diferente, então apenas um deles estará ativo no primeiro passo, no segundo passo dois estarão ativos, e, no momento em que o sinal se propaga para a camada de saída, todos os dispositivos estarão ativos simultaneamente. Ainda há muita comunicação acontecendo entre dis-positivos, mas, como cada célula pode ser bastante complexa, o benefício de executar várias células em paralelo geralmente supera o ônus da comunicação. Saídas Saídas... Entradas... Entradas Rede Neural Recorr ente Profunda Tempo Célula Célula Célula Célula Figura 12-16. Divisão de uma rede neural recorrente profunda Em suma, o paralelismo do modelo pode acelerar a execução ou o treinamento de alguns tipos de redes neurais, mas não de todos, e requer cuidados e ajustes especiais, como garantir que os dispositivos que precisam se comunicar com mais frequência sejam executados na mesma máquina. Paralelismo de Dados Outra forma de paralelizar o treinamento de uma rede neural é replicá-la em cada dis-positivo, executar simultaneamente uma etapa de treinamento utilizando um minilote diferente para cada uma e então agregar os gradientes para atualizar os parâmetros do modelo. Isto é chamado de paralelismo de dados (veja a Figura 12-17). CG_MIOLO_Hands_On_Machine_Learning. indb 361 07/05/2019 17:09:47 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
362 | Capítulo 12: Distribuindo o Tensor Flow Por Dispositivos e Servidores Minilotesparâmetrosatualizaçãomédiagradiente s gradiente s gradiente s perda perda perda Figura 12-17. Paralelismo de Dados Existem duas variantes desta abordagem: atualizações síncronas e atualizações assíncronas. Atualizações síncronas Com atualizações síncronas, o agregador espera que todos os gradientes estejam dis-poníveis antes de calcular a média e aplicar o resultado (isto é, utilizando os gradientes agregados para atualizar os parâmetros do modelo). Depois que uma réplica termina de calcular seus gradientes, ela deve aguardar a atualização dos parâmetros antes de prosseguir para o próximo minilote. A desvantagem é que alguns dispositivos podem ser mais lentos do que outros, então todos os outros dispositivos terão que esperar por eles a cada etapa. Além disso, os parâmetros serão copiados quase ao mesmo tempo para cada dispositivo (imediatamente após os gradientes serem aplicados), o que pode saturar a largura de banda dos servidores de parâmetros. 5 Para reduzir o tempo de espera em cada etapa, você poderia ignorar os gra-dientes em algumas réplicas mais lentas (normalmente ~ 10%). Por exemplo, você poderia executar 20 réplicas, mas agregar apenas os gradientes das 18 ré-plicas mais rápidas em cada etapa e simplesmente ignorar os gradientes das 2 últimas. Assim que os parâmetros forem atualizados, as primeiras 18 réplicas poderão começar a funcionar novamente de imediato, sem ter que esperar pelas 2 réplicas mais lentas. Essa configuração é descrita como tendo 18 réplicas mais 2 réplicas sobressalentes. 5 5 Esse nome é um pouco confuso, pois parece que algumas réplicas são especiais, sem fazer nada. Na realidade, todas as réplicas são equivalentes: todas trabalham duro para estarem entre as mais rápidas em cada etapa de treinamento, e os perdedores variam a cada passo de treinamento (a menos que alguns dispositivos sejam realmente mais lentos do que outros). CG_MIOLO_Hands_On_Machine_Learning. indb 362 07/05/2019 17:09:47 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
Paralelizando Redes Neurais em um Cluster do Tensor Flow | 363Atualizações assíncronas Com atualizações assíncronas, sempre que uma réplica termina de calcular os gradientes, ela os utiliza imediatamente para atualizar os parâmetros do modelo. Não há agregação (remova a etapa “média” na Figura 12-17) e não há sincronização. As réplicas funcionam independentemente e, como não há espera pelas outras réplicas, essa abordagem executa mais etapas de treinamento por minuto. Além disso, embora os parâmetros ainda precisem ser copiados para cada dispositivo em cada etapa, isso acontece em momentos diferentes para cada réplica, de modo que o risco de saturação da largura de banda é reduzido. O paralelismo de dados com atualizações assíncronas é uma opção atrativa devido à sua simplicidade, ausência de atraso na sincronização e melhor uso da largura de banda. No entanto, embora funcione razoavelmente bem, na prática é quase surpreendente que funcione! De fato, quando uma réplica termina de calcular os gradientes com base em alguns valores de parâmetros, esses parâmetros terão sido atualizados várias vezes por outras réplicas (em média, N-1 vezes se houver N réplicas) e não há garantia de que os gradientes ainda estarão apontando na direção certa (veja a Figura 12-18). Eles serão chamados de gradientes obsoletos quando estiverem severamente desatualizados: introduzindo efeitos de ruído e oscilação, podem retardar a convergência (a curva de aprendizado pode conter oscilações temporárias) ou até fazer com que o algoritmo de treinamento possa divergir. Custo Gradientes são calculados aqui...... mas eles são aplicados aqui Atualizações por outras réplicas Gradiente s obsoletos Oops, subida! Figura 12-18. Gradientes obsoletos quando utilizam atualizações assíncronas Existem algumas maneiras de reduzir o efeito dos gradientes obsoletos: Reduzir a taxa de aprendizado; Descartar gradientes obsoletos ou reduzi-los; Ajustar o tamanho do minilote; CG_MIOLO_Hands_On_Machine_Learning. indb 363 07/05/2019 17:09:48 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
364 | Capítulo 12: Distribuindo o Tensor Flow Por Dispositivos e Servidores Começar as primeiras épocas utilizando apenas uma réplica, isso é chamado de fas e de aquecimento. Gradientes obsoletos tendem a ser mais prejudiciais no início do treinamento, quando os gradientes são tipicamente grandes e os pa-râmetros ainda não se estabeleceram em um vale da função de custo, portanto réplicas diferentes podem empurrar os parâmetros em direções bem diferentes. Um artigo publicado pela equipe do Google Brain em abril de 2016 ( http://goo. gl/9GCi Pb ) comparou várias abordagens e descobriu que o paralelismo de dados, com atualizações síncronas que utilizam algumas réplicas sobressalentes, era o mais eficiente não apenas por convergir mais rápido, mas também por produzir um modelo melhor. No entanto, esta ainda é uma área ativa de pesquisa, portanto você ainda não deve descartar as atualizações assíncronas. Saturação da largura de banda Quer você utilize atualizações síncronas ou assíncronas, o paralelismo de dados ainda requer a comunicação dos parâmetros do modelo vindos dos servidores de parâmetros para cada réplica ao início de cada etapa de treinamento, e os gradientes na outra direção ao final de cada etapa. Infelizmente, isso significa que sempre haverá um ponto em que adicionar uma GPU extra não melhorará o desempenho, pois o tempo gasto movendo os dados para dentro e fora da GPU RAM (e possivelmente através da rede) será maior do que a aceleração obtida pela divisão da carga computacional. Nesse ponto, adicionar mais GPUs aumentará a saturação e retardará o treinamento. É melhor treinar alguns modelos, geralmente relativamente peque-nos e treinados em um conjunto de treinamento muito grande, em uma única máquina com uma única GPU. A saturação é mais severa para modelos grandes e densos, pois eles têm muitos parâ-metros e gradientes para transferir. Ela será menos severa para modelos pequenos (mas o ganho da paralelização é pequeno) e também em grandes modelos esparsos, já que os gradientes geralmente são zeros e podem ser comunicados de forma eficiente. Jeff Dean, iniciador e líder do projeto do Google Brain, relatou ( http://goo. gl/E4ypxo ) acelerações típicas de 25 a 40x ao distribuir cálculos em 50 GPUs para modelos densos, e uma ace-leração de 300x para modelos mais esparsos treinados em 500 GPUs. Como você pode ver, os modelos esparsos realmente escalonam melhor. Veja alguns exemplos concretos: Trad ução da máquina neural: aceleração de 6x em 8 GPUs; Inc eption/Image Net: aceleração de 32x em 50 GPUs; CG_MIOLO_Hands_On_Machine_Learning. indb 364 07/05/2019 17:09:48 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
Paralelizando Redes Neurais em um Cluster do Tensor Flow | 365 Rank Brain: 300x aceleração em 500 GPUs. Es ses números representam o que há de melhor no primeiro trimestre de 2016. Além de algumas dúzias de GPUs, a saturação entra em ação e o desempenho diminui para um modelo denso ou algumas centenas de GPUs para um modelo esparso. Há muitas pesqui-sas em andamento para resolver esse problema (explorando arquiteturas ponto a ponto em vez de servidores de parâmetros centralizados, utilizando compactação do modelo de perdas, otimizando quando e do que as réplicas precisam para se comunicar etc. ), portanto haverá muito progresso na paralelização de redes neurais nos próximos anos. Enquanto isso, siga estes simples passos para reduzir o problema da saturação: Agr upe suas GPUs em alguns servidores em vez de dispersá-los em vários, e isso evitará saltos desnecessários da rede; Par ticione os parâmetros em vários servidores de parâmetros (conforme discu-tido anteriormente); Tro que a precisão de flutuação dos parâmetros do modelo de 32 bits ( tf. float32 ) para modelos 16 bits ( tf. bfloat16 ), reduzindo pela metade a quantidade de dados a transferir sem muito impacto na taxa de convergência ou no desempe-nho do modelo. Embora a precisão de 16 bits seja o mínimo para treinar uma rede neural, você pode diminuir essa precisão para 8 bits após o treina-mento para reduzir o tamanho do modelo e acelerar os cálculos. Isso é chamado de quantizar a rede neural. É particularmente útil para implantar e executar modelos pré-treinados em telefones móveis. Veja o ótimo post de Pete Warden (http://goo. gl/09Cb6v) sobre o assunto. Implementação do Tensor Flow Ao utilizar o Tensor Flow para implementar o paralelismo de dados, você primeiro precisa escolher se deseja a replicação no grafo ou a replicação entre grafos e se deseja atualizações síncronas ou assíncronas. Vejamos como você implementaria cada combi-nação (veja os exercícios e os notebooks do Jupyter para exemplos completos de código). Com a replicação no grafo + atualizações síncronas, você constrói um grande grafo contendo todas as réplicas do modelo (posicionadas em diferentes dispositivos) e alguns nós para agregar todos os seus gradientes e fornecê-los para um otimizador. Seu código abre uma sessão para o cluster e executa a operação de treinamento repetidamente. CG_MIOLO_Hands_On_Machine_Learning. indb 365 07/05/2019 17:09:48 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
366 | Capítulo 12: Distribuindo o Tensor Flow Por Dispositivos e Servidores Com replicação no grafo + atualizações assíncronas, você também cria um grafo grande, mas com um otimizador por réplica, e roda uma thread por réplica, executando repe-tidamente o otimizador da réplica. Com replicação entre grafos + atualizações assíncronas, você executa vários clientes inde-pendentes (normalmente em processos separados), cada um treinando a réplica do modelo como se estivesse sozinho no mundo, mas os parâmetros são realmente compartilhados com outras réplicas (utilizando um contêiner de recursos). Com a replicação entre grafos + atualizações síncronas, mais uma vez você executa vários clientes, cada um treinando uma réplica de modelo com base em parâmetros compartilhados, mas, desta vez, você envolve o otimizador (por exemplo, um Momentu-m Optimizer ) em um Sync Replicas Optimizer. Cada réplica utiliza esse otimizador como utilizaria qualquer outro, mas nos bastidores ele envia os gradientes para um conjunto de filas (uma por variável) que é lido por um dos Sync Replicas Optimizer da réplica, chamado de chefe. O chefe agrega os gradientes e os aplica, em seguida grava um token em uma fila de tokens para cada réplica sinalizando que ele pode ir adiante e calcular os gradientes seguintes. Essa abordagem suporta réplicas sobressalentes. Se fizer os exercícios, você implementará cada uma dessas quatro soluções. Poderá facil-mente aplicar o que aprendeu para treinar grandes redes neurais profundas em dezenas de servidores e GPUs! Nos próximos capítulos, falaremos de algumas das arquiteturas de redes neurais mais importantes antes de abordar o Aprendizado por Reforço. Exercícios 1. O que provavelmente está acontecendo se você receber um CUDA_ERROR_OUT_OF_ME MORY ao iniciar seu Tensor Flow? O que pode ser feito em relação a isso? 2. Qua l é a diferença entre fixar uma operação em um dispositivo e posicionar uma operação em um dispositivo? 3. Se vo cê estiver executando uma instalação do Tensor Flow habilitada para GPU e utilizar apenas o posicionamento padrão, todas as operações serão posicionadas na primeira GPU? 4. Se v ocê fixar uma variável na “/gpu:0”, ela pode ser utilizada por operações posi-cionadas na /gpu:1 ? Ou por operações posicionadas na “/cpu:0” ? Ou por opera-ções fixadas em dispositivos localizados em outros servidores? 5. Dua s operações posicionadas no mesmo dispositivo podem rodar em paralelo? 6. O que é u ma dependência de controle e quando você a utiliza? CG_MIOLO_Hands_On_Machine_Learning. indb 366 07/05/2019 17:09:48 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
Exercícios | 3677. Suponha que você treine uma DNN por dias em um cluster do Tensor Flow e, im ediatamente após o término do seu programa de treinamento, percebe que es-queceu de salvar o modelo ao utilizar um Saver. Seu modelo treinado foi perdido? 8. Tre ine várias DNNs em paralelo em um cluster do Tensor Flow com a utilização de diferentes valores dos hiperparâmetros. Podem ser DNNs para classificação MNIST ou qualquer outra tarefa do seu interesse. A opção mais simples seria escrever um úni-co programa cliente que treine apenas uma DNN e execute esse programa em vários processos em paralelo com diferentes valores dos hiperparâmetros para cada cliente. O programa deve ter opções de linha de comando para controlar em qual servidor e dispositivo a DNN deve ser posicionada e quais contêineres de recursos e valores dos hiperparâmetros devem ser utilizados (certifique-se de utilizar um contêiner de recursos diferente para cada DNN). Utilize um conjunto de validação ou vali-dação cruzada para selecionar os três principais modelos. 9. Cri e um ensemble utilizando os três principais modelos do exercício anterior. Defina-o em um único grafo garantindo que cada DNN seja executada em um dispositivo diferente. Avalie no conjunto de validação: o ensemble tem um desem-penho melhor do que as DNNs individuais? 10. Tre ine uma DNN utilizando replicação entre grafos e paralelismo de dados com atu-alizações assíncronas, calculando quanto tempo leva para atingir um desempenho satisfatório. Em seguida, tente novamente utilizando atualizações síncronas. Atualiza-ções síncronas produzem um modelo melhor? O treinamento está mais rápido? Divida a DNN verticalmente, coloque cada fatia vertical em um dispositivo diferente e treine o modelo novamente. O treinamento ficou mais rápido? O desempenho ficou diferente? Soluções para estes exercícios estão disponíveis no Apêndice A. CG_MIOLO_Hands_On_Machine_Learning. indb 367 07/05/2019 17:09:48 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
CG_MIOLO_Hands_On_Machine_Learning. indb 368 07/05/2019 17:09:48 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
369Capítulo 13 Redes Neurais Convolucionais (CNN) Embora o supercomputador Deep Blue da IBM tenha vencido o campeão mundial de xadrez Garry Kasparov em 1996, até recentemente os computadores não conseguiam executar tarefas aparentemente triviais como detectar um filhote em uma foto ou re-conhecer palavras faladas de forma confiável. Por que essas tarefas são tão fáceis para nós humanos? A resposta está no fato de a percepção ocorrer em grande parte fora do domínio de nossa consciência, dentro de módulos sensoriais auditivos e visuais especia-lizados em nossos cérebros. Quando a informação sensorial chega à nossa consciência, ela já está adornada com características de alto nível; por exemplo, quando você olha para uma foto de um filhote fofo, você não pode escolher não ver o filhote ou não notar sua fofura, assim como também não consegue explicar como reconhece um filhote fofo; é apenas óbvio para você. Assim, não podemos confiar em nossa experiência subjetiva: a percepção não é nada trivial e, para entendê-la, devemos observar como os módulos sensoriais funcionam. As Redes Neurais Convolucionais (CNNs, em inglês) emergiram do estudo do córtex vi-sual do cérebro e têm sido utilizadas no reconhecimento de imagens desde os anos 1980. Nos últimos anos, graças ao aumento do poder computacional, a quantidade de dados de treinamento disponível e os truques apresentados no Capítulo 11 para treinamento de redes profundas, as CNNs conseguiram alcançar um desempenho sobre-humano em algumas tarefas visuais complexas. Elas fornecem serviços de pesquisa de imagens, carros autônomos, sistemas automáticos de classificação de vídeo e muito mais. Além disso, as CNNs não estão restritas à percepção visual: sendo também bem-sucedidas em outras tarefas, como reconhecimento de voz ou processamento de linguagem natural (PLN); no entanto, nos concentraremos apenas em aplicações visuais por enquanto. Neste capítulo, apresentaremos de onde vieram as CNNs, como são seus blocos de construção e como implementá-las com a utilização do Tensor Flow. Em seguida, apre-sentaremos algumas das melhores arquiteturas das CNNs. CG_MIOLO_Hands_On_Machine_Learning. indb 369 07/05/2019 17:09:48 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
370 | Capítulo 13: Redes Neurais Convolucionais (CNN) A Arquitetura do Córtex Visual David H. Hubel e Torsten Wiesel realizaram uma série de experimentos com gatos em 1958 ( http://goo. gl/VLx Xf9 )1 e 1959 ( http://goo. gl/OYu FUZ )2 (e alguns anos depois em macacos ( http://goo. gl/95F7QH )3), que proporcionou aprendizados cruciais sobre a estru-tura do córtex visual (os autores receberam o Prêmio Nobel de Fisiologia e Medicina em 1981 por seu trabalho). Em particular, eles mostraram que muitos neurônios no córtex visual têm um pequeno campo receptivo local, o que significa que eles reagem apenas a estímulos visuais localizados em uma região limitada do campo visual (veja a Figura 13-1, na qual os campos receptivos locais de cinco neurônios são representados por círculos tracejados). Os campos receptivos de diferentes neurônios podem se sobrepor e, juntos, formam todo o campo visual. Além disso, os autores mostraram que alguns neurônios reagem apenas a imagens nas linhas horizontais, enquanto outros reagem apenas a linhas com diferentes orientações (dois neurônios podem ter o mesmo campo receptivo, mas reagem a diferentes orientações da linha). Eles também notaram que alguns neurônios têm campos receptivos maiores e reagem a padrões mais complexos que são combinações dos padrões de nível inferior. Essas observações levaram à ideia de que os neurônios de nível superior são baseados nas saídas dos neurônios vizinhos de nível inferior (na Figura 13-1, observe que cada neurônio está conectado a apenas alguns neurônios da camada anterior). Esta poderosa arquitetura é capaz de detectar todos os tipos de padrões complexos em qualquer área do campo visual. Figura 13-1. Campos receptivos locais no córtex visual Esses estudos do córtex visual inspiraram o neocognitron, introduzido em 1980 ( http:// goo. gl/Xwi Xs9 )4, que gradualmente evoluiu para o que hoje chamamos de redes neurais 1 “Single Unit Activity in Striate Cortex of Unrestrained Cats,” D. Hubel e T. Wiesel (1958). 2 “Re ceptive Fields of Single Neurones in the Cat's Striate Cortex,” D. Hubel e T. Wiesel (1959). 3 “Re ceptive Fields and Functional Architecture of Monkey Striate Cortex,” D. Hubel e T. Wiesel (1968). 4 “Neocognitron: A Self-organizing Neural Network Model for a Mechanism of Pattern Recognition Unaffected by Shift in Position”, K. Fukushima (1980). CG_MIOLO_Hands_On_Machine_Learning. indb 370 07/05/2019 17:09:48 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
Camada Convolucional | 37 1convolucionais. Um marco importante foi um artigo de 1998 ( http://goo. gl/A347S4 )5 de Yann Le Cun, Léon Bottou, Yoshua Bengio e Patrick Haffner, que introduziu a famosa arquitetura Le Net-5 amplamente utilizada para reconhecer números em cheques ma-nuscritos. Essa arquitetura tem alguns blocos de construção que você já conhece, como camadas totalmente conectadas e funções de ativação sigmoide, mas também apresenta dois novos blocos de construção: camadas convolucionais e camadas de pooling. Vamos conhecê-las agora Por que não simplesmente utilizar uma rede neural profunda re-gular, com camadas totalmente conectadas, para tarefas de reco-nhecimento de imagem? Infelizmente, embora isso funcione bem para pequenas imagens (por exemplo, MNIST), falha em imagens maiores devido ao grande número de parâmetros necessários. Por exemplo, uma imagem 100 × 100 tem 10 mil pixels e, se a primeira camada tiver apenas 1 mil neurônios (o que já restringe severamente a quantidade de informações transmitidas para a próxima camada), isso significa um total de 10 milhões de conexões. E essa é apenas a primeira camada. As CNNs resolvem este problema ao utilizar camadas parcialmente conectadas. Camada Convolucional O bloco de construção mais importante de uma CNN é a camada convolucional:6 os neurônios na primeira camada convolucional não estão conectados a cada pixel na ima-gem de entrada (como estavam nos capítulos anteriores), mas apenas a pixels em seus campos receptivos (veja a Figura 13-2). Por sua vez, cada neurônio na segunda camada convolucional está conectado apenas a neurônios localizados dentro de um pequeno retângulo na primeira camada. Essa arquitetura permite que a rede se concentre em características de baixo nível na primeira camada oculta e, em seguida, os reúna em características de nível superior na próxima camada oculta, e assim por diante. Essa estrutura hierárquica é comum em imagens do mundo real, e é uma das razões pelas quais as CNNs funcionam tão bem para o reconhecimento de imagens. 5 “Gradient-Based Learning Applied to Document Recognition”, Y. Le Cun et al. (1998). 6 Uma c onvolução é uma operação matemática que desliza uma função sobre a outra e mede a integral da sua multiplicação pontual. Possui conexões profundas com a transformada de Fourier e a transformada de Laplace e é muito utilizada no processamento de sinais. As camadas convolucionais realmente utilizam correlações cruzadas, que são muito semelhantes às convoluções (consulte http://goo. gl/HAfx Xd para obter mais detalhes). CG_MIOLO_Hands_On_Machine_Learning. indb 371 07/05/2019 17:09:48 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
372 | Capítulo 13: Redes Neurais Convolucionais (CNN) Camada convolucional 2 Camada co nvolucional 1 Camada de entrada Figura 13-2. Camadas CNN com campos receptivos locais retangulares Até agora, todas as redes neurais multicamadas que analisamos ti-nham camadas compostas por uma longa linha de neurônios, e tive-mos que nivelar as imagens de entrada para 1D antes de fornecê-las à rede neural. Agora, cada camada é representada em 2D, o que facilita a combinação dos neurônios com suas entradas correspondentes. Um neurônio localizado na linha i, coluna j de uma determinada camada está conectado às saídas dos neurônios na camada anterior localizada nas linhas i a i + fh-1, colunas j a j + fw-1, sendo que fh e fw são a altura e a largura do campo receptivo (veja a Figura 13-3). É comum adicionar zeros ao redor das entradas para que uma camada tenha a mesma altura e largura da camada anterior, conforme mostrado no diagrama, o que é chamado de zero padding. Zero padding Figura 13-3. Conexões entre camadas e zero padding CG_MIOLO_Hands_On_Machine_Learning. indb 372 07/05/2019 17:09:49 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
Camada Convolucional | 373Também é possível conectar uma grande camada de entrada a uma camada muito menor ao espaçar os campos receptivos, como mostrado na Figura 13-4. A distância entre dois campos receptivos consecutivos é chamada de stride. No diagrama, uma camada de entrada 5 × 7 (mais preenchimento com zeros) é conectada a uma camada 3 × 4 usando campos receptivos 3 × 3 e um stride de 2 (neste exemplo, o stride é o mesmo em ambas as direções, mas não precisa ser assim). Um neurônio localizado na linha i, coluna j na camada superior está ligado às saídas dos neurônios na camada anterior localizada nas linhas i × sh a i × sh + fh-1, colunas j × sw a j × sw + fw-1, em que sh e sw são os strides verticais e horizontais. Figura 13-4. Reduzindo a dimensionalidade utilizando um stride de 2 Filtros Os pesos de um neurônio podem ser representados como uma pequena imagem do ta-manho do campo receptivo. Por exemplo, a Figura 13-5 mostra dois conjuntos possíveis de pesos chamados filtros (ou kernels de convolução ). O primeiro é representado como um quadrado preto com uma linha branca vertical no meio (é uma matriz 7 × 7 cheia de 0s, exceto pela coluna central, que é cheia de 1s); os neurônios que utilizam esses pesos ignorarão tudo em seu campo receptivo, exceto a linha vertical central (já que todas as entradas serão multiplicadas por 0 exceto aquelas localizadas na linha vertical central). O segundo filtro é um quadrado preto com uma linha branca horizontal no meio. Mais uma vez, os neurônios que utilizam esses pesos ignorarão tudo em seu campo receptivo, exceto a linha horizontal central. Agora, se todos os neurônios na camada utilizarem o mesmo filtro de linha vertical (e o mesmo termo de polarização), e se você alimentar a rede com a imagem de entrada mostrada na Figura 13-5, a camada exibirá a imagem superior esquerda. Observe que as CG_MIOLO_Hands_On_Machine_Learning. indb 373 07/05/2019 17:09:49 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
374 | Capítulo 13: Redes Neurais Convolucionais (CNN) linhas brancas verticais são aprimoradas enquanto o restante fica desfocado. Da mesma forma, se todos os neurônios utilizarem o filtro de linha horizontal, a imagem superior direita é o que você obtém; observe que as linhas brancas horizontais são aprimoradas enquanto o restante é desfocado. Assim, uma camada cheia de neurônios, com a utili-zação do mesmo filtro, fornece um mapa de características que destaca as áreas de uma imagem mais semelhantes ao filtro. Durante o treinamento, uma CNN encontra os filtros mais úteis para sua tarefa e aprende a combiná-los em padrões mais complexos (por exemplo, uma cruz é uma área em uma imagem em que o filtro vertical e o filtro horizontal estão ativos). Mapa de características 1Mapa decaracterísticas 2 Entrada Filtro ver tical Filtro horizontal Figura 13-5. Aplicando dois filtros diferentes para obter dois mapas de características Empilhando Múltiplos Mapas de Características Até agora, para simplificar, representamos cada camada convolucional como uma fina camada 2D, mas na realidade ela é composta por vários mapas de tamanhos iguais, então ela é representada com mais precisão em 3D (veja a Figura 13-6). Em um mapa de características, todos os neurônios compartilham os mesmos parâmetros (pesos e termos de polarização), mas diferentes mapas podem ter parâmetros diferentes. O campo receptivo de um neurônio é o mesmo conforme descrito anteriormente, e se estende a todos os mapas das camadas anteriores. Em suma, uma camada convolucional aplica simultaneamente vários filtros às suas entradas, tornando-a capaz de detectar várias características em qualquer lugar em suas entradas. CG_MIOLO_Hands_On_Machine_Learning. indb 374 07/05/2019 17:09:49 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
Camada Convolucional | 37 5O fato de que todos os neurônios em um mapa de características compartilham os mesmos parâmetros reduz drasticamente o núme-ro de parâmetros no modelo, mas o mais importante é que assim que uma CNN aprende a reconhecer um padrão em um local, ela poderá reconhecê-lo em qualquer outro local. Em contraste, uma vez que uma DNN normal aprende a reconhecer um padrão em um local, ela só consegue reconhecê-lo neste local específico. Além disso, as imagens de entrada também são compostas de múltiplas subcamadas: uma por canal de cor. Normalmente, existem três: vermelho, verde e azul (RGB). As imagens em escala de cinza têm apenas um canal, mas algumas podem ter muito mais, por exem-plo, imagens de satélite que capturam frequências extras de luz (como o infravermelho). Camada convolucional 2 Camada convolucional 1 Camada de entrada Canais Vermelho Verde Azul Filtros Mapa de Cara cterísticas 1 Mapa 2 Mapa 1 Mapa 2 Figura 13-6. Camadas de convolução com vários mapas de características e imagens com três canais Especificamente, um neurônio localizado na linha i, coluna j do mapa de característica k em uma determinada camada convolucional l está conectado às saídas dos neurônios na camada anterior l-1, localizado nas linhas i × sh a i × sh + fh-1 e colunas j × sw a j × sw + fw-1 em todos os mapas de características (na camada l-1). Note que todos os CG_MIOLO_Hands_On_Machine_Learning. indb 375 07/05/2019 17:09:50 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
376 | Capítulo 13: Redes Neurais Convolucionais (CNN) neurônios localizados na mesma linha i e coluna j, mas em mapas de características diferentes, são conectados às saídas dos mesmos neurônios da camada anterior. A Equação 13-1 resume as explicações precedentes em uma grande equação matemática que mostra como calcular a saída de um dado neurônio em uma camada convolucional. Devido aos diferentes índices, ela é um pouco estranha, mas tudo o que ela faz é calcular a soma ponderada de todas as entradas, mais o termo de polarização. Equação 13-1. Calculando a saída de um neurônio em uma camada convolucional zi,j,k=bk+∑ u=0fh-1 ∑ v=0fw-1 ∑ k=0fn-1 xi,j,k. wu,v,k,kcomi=i×sh+u j=j×sw+v zi, j, k é a saída do neurônio localizado na linha i, coluna j no mapa de caracterís-ticas k da camada convolucional (camada l); Com o explicado anteriormente, s h e sw são os strides verticais e horizontais, f h e fw são a altura e a largura do campo receptivo e f n′ é o número de mapas de caracte-rísticas na camada anterior (camada l-1); xi′, j′, k′ é a saída do neurônio localizado na camada l-1, linha i ′, coluna j ′, mapa de características k ′ (ou canal k ′ se a camada anterior for a camada de entrada); bk é o termo de polarização para o mapa de características k (na camada l). Você pode encarar isso como um botão que altera o brilho geral do mapa de características k; wu, v, k′, k é o peso da conexão entre qualquer neurônio no mapa de características k da camada l e sua entrada localizada na linha u, coluna v (relativa ao campo receptivo dos neurônios) e ao mapa de características k′. Implementação do Tensor Flow Cada imagem de entrada no Tensor Flow é representada como um tensor de formato 3D [height, width, channels] e um minilote é representado como um tensor de formato 4D [mini-batch size, height, width, channels]. Os pesos de uma camada convolu-cional são representados como um tensor de formato 4D [ fh, fw, fn′, fn], já seus termos de polarização são representados como um tensor de formato 1D [ fn]. Analisaremos um exemplo simples. O código a seguir carrega duas imagens de amostra do Scikit-Learn com a utilização do load_sample_images() (que carrega duas imagens coloridas, sendo uma de um templo chinês e outra de uma flor). Ele cria dois filtros 7 × 7 (um com uma linha branca vertical no meio e outro com uma linha branca horizon-tal no meio) e aplica a ambas as imagens usando uma camada convolucional construída CG_MIOLO_Hands_On_Machine_Learning. indb 376 07/05/2019 17:09:50 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
Camada Convolucional | 37 7utilizando a função tf. nn. conv2d() do Tensor Flow (com zero padding e um stride de 2). Por fim, plota um dos mapas de características resultantes (semelhante à imagem superior direita na Figura 13-5). import numpy as np from sklearn. datasets import load_sample_images # Carrega imagens amostrais china = load_sample_image("china. jpg") flower = load_sample_image("flower. jpg") dataset = np. array([china, flower], dtype=np. float32) batch_size, height, width, channels = dataset. shape # Cria 2 filtros filters = np. zeros(shape=(7, 7, channels, 2), dtype=np. float32) filters[:, 3, :, 0] = 1 # vertical line filters[3, :, :, 1] = 1 # horizontal line # Cria um grafo com entrada X mais uma camada convolucional aplicando os 2 filtros X = tf. placeholder(tf. float32, shape=(None, height, width, channels)) convolution = tf. nn. conv2d(X, filters, strides=[1,2,2,1], padding="SAME") with tf. Session() as sess: output = sess. run(convolution, feed_dict={X: dataset}) plt. imshow(output[0, :, :, 1], cmap="gray") # plota o mapa da segunda característica da primeira imagem plt. show() A maior parte deste código é autoexplicativa, mas a linha tf. nn. conv2d() merece uma pequena explicação: X é o minilote de entrada (um tensor 4D, como explicado anteriormente); filters é o conjunto de filtros a se aplicar (também um tensor 4D, como expli-cado anteriormente); strides é um array 1D de quatro elementos nos quais os dois elementos cen-trais são os strides vertical e horizontal ( sh e sw). O primeiro e o último elementos devem ser iguais a 1. Eles podem um dia ser utilizados para especificar um in-cremento em lote (para pular algumas instâncias) e um incremento do pipeline (para pular alguns dos mapas de características ou canais da camada anteriores); padding deve ser tanto “VALID” ou “SAME” : —Se configurada para “VALID”, a camada convolucional não utiliza o zero padding e pode ignorar algumas linhas e colunas na parte inferior e direita da imagem de entrada, dependendo do incremento, conforme mostrado na Figura 13-7 (para simplificar, apenas a dimensão horizontal é mostrada aqui, mas é claro que a mesma lógica se aplica à dimensão vertical); —Caso seja configurada para “SAME”, a camada convolucional utiliza o zero padding se necessário. Nesse caso, o número de neurônios de saída é igual ao número de neurônios de entrada dividido pelo stride, arredondado (neste CG_MIOLO_Hands_On_Machine_Learning. indb 377 07/05/2019 17:09:50 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
378 | Capítulo 13: Redes Neurais Convolucionais (CNN) exemplo, ceil (13/5) = 3). Os zeros são adicionados em torno das entradas o mais uniformemente possível. padding=“VALID” (isto é, sem padding) Ignorado padding=“SAME” (isto é, com zero padding ) Figura 13-7. Opções de padding — largura da entrada: 13, largura do filtro: 6, stride: 5 Criamos manualmente os filtros neste exemplo simples, mas em uma CNN real você permitiria que o algoritmo de treinamento descobrisse automaticamente os melhores filtros. O Tensor Flow tem uma função tf. layers. conv2d() que cria a variável de filtros para você (denominado kernel ) e a inicializa aleatoriamente, além de criar também a variável de polarização (denominada bias ) e a inicializar com zeros. Por exemplo, o código a seguir cria um placeholder de entrada seguido por uma camada convolucio-nal com dois mapas de características 7 × 7 usando strides 2 × 2 (note que esta função espera somente strides verticais e horizontais) e padding “SAME” : X = tf. placeholder(shape=(None, height, width, channels), dtype=tf. float32) conv = tf. layers. conv2d(X, filters=2, kernel_size=7, strides=[2,2], padding="SAME") Infelizmente, as camadas convolucionais têm muitos hiperparâmetros: você deve escolher o número de filtros, sua altura e largura, os incrementos e o tipo de padding. Como sempre, você pode utilizar a validação cruzada para encontrar os valores corretos do hiperparâ-metro, mas isso consome muito tempo. Discutiremos as arquiteturas de CNN comuns posteriormente para dar uma ideia de quais valores dos hiperparâmetros funcionam melhor na prática. CG_MIOLO_Hands_On_Machine_Learning. indb 378 07/05/2019 17:09:51 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
Camada Convolucional | 37 9Requisitos de Memória Outro problema com as CNNs é que as camadas convolucionais requerem uma quanti-dade enorme de RAM, especialmente durante o treinamento, porque o reverse pass da retropropagação requer todos os valores intermediários calculados durante o forward pass. Por exemplo, considere uma camada convolucional com filtros 5 × 5 produzindo 200 mapas de tamanho 150 × 100, com stride de 1 e padding SAME. Se a entrada for uma imagem RGB de 150 × 100 (três canais), então o número de parâmetros será (5 × 5 × 3 + 1) × 200 = 15. 200 (o +1 corresponde aos termos de polarização), o que é minúsculo se comparado com uma camada totalmente conectada. 7 No entanto, cada um dos 200 mapas contém 150 × 100 neurônios e cada um desses neurônios precisa calcular uma soma ponderada de suas 5 × 5 × 3 = 75 entradas: um total de 225 milhões de multiplicações de floats. Não é tão ruim quanto uma camada totalmente conectada, mas ainda bastante intensa em termos computacionais. Além disso, se os mapas forem representados utilizando floats de 32 bits, a saída da camada convolucional ocupará 200 × 150 × 100 × 32 = 96 milhões de bits (aproximadamente 11,4 MB) de RAM. 8 E isso somente para uma instância! Se um lote de treinamento contiver 100 instâncias, essa camada utilizará mais de 1 GB de RAM! A RAM ocupada por uma camada pode ser liberada assim que a próxima camada tiver sido calculada durante a inferência (ou seja, ao fazer uma previsão para uma nova instân-cia), portanto você somente precisará da quantidade máxima de RAM exigida por duas camadas consecutivas. Mas, durante o treinamento, tudo o que foi calculado ao longo do forward pass precisa ser preservado para o reverse pass, então a quantidade de RAM necessária é (pelo menos) a quantidade total de RAM requerida por todas as camadas. Se o treinamento falhar devido a um erro de falta de memória, você pode tentar reduzir o tamanho do minilote. Alternativas: reduzir a dimensionalidade utilizando um stride ou removendo algumas camadas; tentar utilizar floats de 16 bits em vez de 32 bits; distribuir a CNN por vários dispositivos. Agora veremos o segundo bloco comum de construção de CNNs: a camada pooling. 7 Uma camada totalmente conectada com 150 × 100 neurônios, cada um conectado a todas as entradas de 150 × 100 × 3, teria 1502 × 1002 × 3 = 675 milhões de parâmetros! 8 1 MB = 1, 024 k B = 1,024 × 1,024 bytes = 1,024 × 1,024 × 8 bits. CG_MIOLO_Hands_On_Machine_Learning. indb 379 07/05/2019 17:09:51 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |