text
stringlengths 0
3.9k
| source
stringclasses 1
value |
|---|---|
180 | Capítulo 6: Árvores de Decisãox1 = 0,6. Você atravessa a árvore começando na raiz e, eventualmente, alcança o nó da folha que prevê um value=0,1106. Esta previsão é simplesmente o valor-alvo médio das 110 instâncias de treinamento associadas a este nó da folha. Esta previsão resulta em um erro quadrático médio (MSE) igual a 0,0151 sobre essas 110 instâncias. As previsões deste modelo estão representadas à esquerda da Figura 6-5. Se você definir max_depth=3, obterá as previsões representadas à direita. Observe como o valor previsto para cada região é sempre o valor-alvo médio das instâncias presentes nela. O algoritmo divide cada região de uma forma, o que faz com que a maior parte das instâncias de treinamento se aproxime o máximo possível desse valor previsto. max_depth=2 max_depth=3 Profundidade=0Profundidade=1 Profundidade= 1Profundidade=1 Figura 6-5. Previsões de dois modelos de regressão da Árvore de Decisão O algoritmo CART funciona mais ou menos da mesma forma, exceto que, em vez de tentar dividir o conjunto de treinamento de forma a minimizar a impureza, ele agora tenta dividi-lo de forma a minimizar o MSE. A Equação 6-4 mostra a função de custo que o algoritmo tenta minimizar. Equação 6-4. A função CART de custo para regressão Jk,tk=mesquerda m MSEesquerda+mdireita m MSEdireitasendo que MSEnó=∑ inóynó-yi2 ynó=1 mnó∑ inóyi Assim como para tarefas de classificação, as Árvores de Decisão são propensas a so-breajustes quando se trata de tarefas de regressão. Sem nenhuma regularização (ou seja, utilizando os hiperparâmetros padrão), você obtém as previsões à esquerda da Figura 6-6. É óbvio que o conjunto de treinamento está muito sobreajustado. Se configurarmos o min_samples_leaf=10, resultará em um modelo muito mais razoável, representado à direita da Figura 6-6. CG_MIOLO_Hands_On_Machine_Learning. indb 180 07/05/2019 17:08:49 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
Instabilidade | 181 min_sampes_leaf = 10 Sem restrições Figura 6-6. Regularizando um regressor da Árvore de Decisão Instabilidade Espero que você esteja convencido de que as Árvores de Decisão têm muitas vantagens: são fáceis de entender, interpretar, usar, e são versáteis e poderosas. No entanto, elas têm algumas limitações. Primeiro, como você pode ter percebido, as Árvores de Deci-são adoram fronteiras ortogonais de decisão (todas as divisões são perpendiculares a um eixo), o que as torna sensíveis à rotação do conjunto de treinamento. Por exemplo, a Figura 6-7 mostra um simples conjunto de dados linearmente separável: à esquerda, uma Árvore de Decisão pode dividi-lo facilmente, enquanto à direita, após o conjunto de dados girar em 45°, a fronteira de decisão parece desnecessariamente retorcida. Embora ambas as árvores de decisão se moldem perfeitamente ao conjunto de treinamento, é muito provável que o modelo à direita não generalize bem. Uma maneira de limitar esse problema é utilizar o PCA (consulte o Capítulo 8), o que, muitas vezes, resulta em uma melhor orientação dos dados de treinamento. Figura 6-7. Sensibilidade à rotação no conjunto de treinamento De um modo mais geral, o principal problema com as Árvores de Decisão é que elas são muito sensíveis a pequenas variações nos dados de treinamento. Por exemplo, se você remover a Iris-Versicolor mais larga do conjunto de treinamento da íris (aquela com CG_MIOLO_Hands_On_Machine_Learning. indb 181 07/05/2019 17:08:49 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
182 | Capítulo 6: Árvores de Decisãopétalas de 4,8cm de comprimento e 1,8cm de largura) e treinar uma nova Árvore de Decisão, pode ser que você obtenha o modelo representado na Figura 6-8. Como você pode ver, é muito diferente da Árvore de Decisão anterior (Figura 6-2). Na verdade, uma vez que o algoritmo de treinamento utilizado pelo Scikit-Learn é estocástico 6, você pode obter modelos muito diferentes mesmo nos mesmos dados de treinamento (a menos que você defina o hiperparâmetro random_state ). Largura da Pétala Comprimento da P étala Profundidade = 1 Profundidade = 0 Figura 6-8. Sensibilidade aos detalhes no conjunto de treinamento As Florestas Aleatórias podem limitar essa instabilidade provendo previsões sobre muitas árvores, como veremos no próximo capítulo. Exercícios 1. Qual é a profundidade aproximada de uma Árvore de Decisão treinada (sem re strições) em um conjunto com 1 milhão de instâncias? 2. O coe ficiente Gini de um nó geralmente é menor ou maior do que o dos seus pais? Ele é geralmente menor/maior, ou sempre menor/maior? 3. É um a boa ideia tentar diminuir seu max_depth se uma Árvore de Decisão estiver se sobreajustando ao conjunto de treinamento? 4. É uma boa ideia tentar dimensionar as características de entrada se uma Árvore de Decisão estiver se subajustando ao conjunto de treinamento? 6 Seleciona aleatoriamente o conjunto de características a ser avaliado em cada nó. CG_MIOLO_Hands_On_Machine_Learning. indb 182 07/05/2019 17:08:50 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
Exercícios | 1835. Se treinar uma Árvore de Decisão em um conjunto de treinamento contendo 1 mi lhão de instâncias demora 1 hora, aproximadamente quanto tempo demorará para treinar outra Árvore de Decisão em um conjunto de treinamento contendo 10 milhões de instâncias? 6. Se o seu conjunto de treinamento contém 100 mil instâncias, a configuração presort=True acelerará o treinamento? 7. Tre ine e ajuste uma Árvore de Decisão para o conjunto de dados de luas. a. Ger e um conjunto de dados de luas utilizando make_moons(n_samples=10000, noise=0. 4). b. Com a u tilização do train_test_split(), divida em um conjunto de treina-mento e um conjunto de testes. c. Uti lize a pesquisa de grade com validação cruzada (com a ajuda da clas-se Grid Search CV ) para encontrar bons valores de hiperparâmetros para um Decision Tree Classifier. Dica: tente vários valores para max_leaf_nodes. d. Tre ine-o no conjunto completo de treinamento utilizando estes hiperparâme-tros e meça o desempenho do seu modelo no conjunto de teste. Você deve obter aproximadamente 85% a 87% de acurácia. 8. Cult ive uma floresta. a. Con tinuando o exercício anterior, gere mil subconjuntos do conjunto de trei-namento, cada um contendo 100 instâncias selecionadas aleatoriamente. Dica: você pode utilizar a classe Shuffle Split do Scikit-Learn para isso. b. Tre ine uma Árvore de Decisão em cada subconjunto utilizando os melhores va-lores do hiperparâmetro encontrados acima. Avalie essas mil Árvores de Decisão no conjunto de testes. Uma vez treinadas em conjuntos menores, essas Árvores de Decisão provavelmente terão um desempenho pior do que a primeira, alcançando apenas 80% de acurácia. c. Ago ra vem a mágica. Gere as previsões das mil Árvores de Decisão e mante-nha apenas a previsão mais frequente para cada instância do conjunto de testes (você pode utilizar a função mode() do Sci Py para isso). Isso lhe dá previsões dos votos majoritários sobre o conjunto de testes. d. Ava lie estas previsões no conjunto de teste: você deve obter uma acurácia ligeiramente maior que o seu primeiro modelo (cerca de 0,5 a 1,5% a mais). Parabéns, você treinou um classificador de Floresta Aleatória! As soluções para esses exercícios estão disponíveis no Apêndice A. CG_MIOLO_Hands_On_Machine_Learning. indb 183 07/05/2019 17:08:50 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
CG_MIOLO_Hands_On_Machine_Learning. indb 184 07/05/2019 17:08:50 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
185Capítulo 7 Ensemble Learning e Florestas Aleatórias Vamos supor que você faça uma pergunta complexa a milhares de pessoas aleatórias e, então, reúna suas respostas. Em muitos casos, você verá que esta resposta agregada é melhor do que a resposta de um especialista, o que é chamado de sabedoria das multi-dões. Da mesma forma, se você agregar as previsões de um conjunto de previsores (como classificadores ou regressores), muitas vezes obterá melhores previsões do que com o melhor previsor individual. Um conjunto de previsores é chamado de ensemble ; assim, esta técnica é chamada Ensemble Learning, e um algoritmo de Ensemble Learning é chamado de Ensemble method. Por exemplo, você pode treinar um conjunto de classificadores de Árvores de Decisão, cada um em um subconjunto aleatório diferente do conjunto de treinamento. Para fa-zer previsões, devemos obtê-las de todas as árvores individuais e, então, prever a classe que obtém a maioria dos votos (veja o último exercício no Capítulo 6). Esse ensemble de Árvores de Decisão é chamado de Floresta Aleatória e, apesar da sua simplicidade, é um dos mais poderosos algoritmos de Aprendizado de Máquina disponível atualmente. Além disso, como discutimos no Capítulo 2, você frequentemente utilizará os Ensemble methods perto da conclusão de um projeto, uma vez que já tenha construído alguns bons previsores, com o objetivo de combiná-los em um ainda melhor. De fato, as soluções vencedoras nas competições de Aprendizado de Máquina muitas vezes envolvem vários Ensemble methods (com maior notoriedade nas competições do Prêmio Netflix; http://netflixprize. com/ ). Neste capítulo discutiremos os Ensemble methods mais populares, incluindo bagging, boosting, stacking e outros. Também exploraremos as Florestas Aleatórias. CG_MIOLO_Hands_On_Machine_Learning. indb 185 07/05/2019 17:08:50 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
186 | Capítulo 7: Ensemble Learning e Florestas Aleatórias Classificadores de Votação Suponha que você tenha treinado alguns classificadores, cada um alcançando uma pre-cisão de aproximadamente 80%. Você pode ter um classificador de Regressão Logística, um de SVM, um de Floresta Aleatória, um K-Nearest Neighbors e, talvez, mais alguns (veja a Figura 7-1). Regr essão Logística Classi/f_icador SVMClassi/f_icador Floresta Aleatória Outro... Previsores Diversos Figura 7-1. Treinando diversos classificadores Uma maneira bem simples de criar um classificador ainda melhor seria reunir as previsões de cada classificador e prever a classe que obtém a maioria dos votos. Este classificador de votos majoritários é chamado de classificador hard voting (veja a Figura 7-2). Previsão do Ensemble (por ex emplo, voto majoritário ) Previsões Previsores diversos Nova instância Figura 7-2. Previsões do classificador hard voting Um tanto surpreendente, este classificador de votação geralmente consegue uma maior precisão do que o melhor classificador no ensemble. Na verdade, mesmo que cada classi-ficador seja um aprendiz fraco (o que significa que sua classificação é apenas um pouco CG_MIOLO_Hands_On_Machine_Learning. indb 186 07/05/2019 17:08:50 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
Classificadores de Votação | 187melhor do que adivinhações aleatórias), o conjunto ainda pode ser um forte aprendiz (alcançando alta acurácia) desde que haja um número suficiente de aprendizes fracos e que sejam suficientemente diferentes. Como isto é possível? A analogia a seguir pode ajudar a esclarecer esse mistério. Supo-nha que você tenha uma moeda ligeiramente tendenciosa que tem 51% de chance de dar cara e 49% de chance dar coroa. Se você jogar mil vezes, obterá mais ou menos 510 caras e 490 coroas, portanto, uma maioria de caras. Se você fizer o cálculo, verá que a probabilidade de obter a maioria de caras após mil jogadas é próxima de 75%. Quanto mais você jogar a moeda, maior a probabilidade (por exemplo, com 10 mil lançamentos, a probabilidade sobe mais de 97%). Isto deve-se à lei dos grandes números : ao continuar jogando a moeda, a proporção das caras fica cada vez mais próxima da sua probabi-lidade (51%). A Figura 7-3 mostra 10 séries de lançamentos induzidos de moedas. À medida que o número de lançamentos aumenta, a proporção das caras se aproxima de 51%. Eventualmente, todas as 10 séries terminam tão perto de 51% que sempre estarão consistentemente acima de 50%. Número de lançamentos de moedas Taxa de Cara s Figura 7-3. A lei dos grandes números Da mesma forma, suponha que você crie um conjunto contendo mil classificadores que estão individualmente corretos em apenas 51% do tempo (um pouco melhor do que a previsão aleatória). Se você prever a classe votada majoritariamente, é possível obter até 75% de acurácia! No entanto, isso só se dá se todos os classificadores forem perfei-tamente independentes, gerando erros não correlacionados, o que claramente não é o caso, pois eles são treinados nos mesmos dados. É provável que produzam os mesmos tipos de erros, então haverá muitos votos majoritários para a classe errada, reduzindo a acurácia do ensemble. CG_MIOLO_Hands_On_Machine_Learning. indb 187 07/05/2019 17:08:51 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
188 | Capítulo 7: Ensemble Learning e Florestas Aleatórias Os métodos Ensemble funcionam melhor quando os previsores são o mais independente dos outros quanto possível. Uma maneira de obter classificadores diversos seria treiná-los utilizando algoritmos bem diferentes. Isso aumenta a chance de cometerem tipos de erros muito diferentes, melhorando a acurácia do ensemble. O código a seguir cria e treina um classificador de votação no Scikit-Learn composto por três classificadores diversos (o conjunto de treinamento é o conjunto de dados de luas introduzido no Capítulo 5): from sklearn. ensemble import Random Forest Classifier from sklearn. ensemble import Voting Classifier from sklearn. linear_model import Logistic Regression from sklearn. svm import SVC log_clf = Logistic Regression() rnd_clf = Random Forest Classifier() svm_clf = SVC() voting_clf = Voting Classifier( estimators=[('lr', log_clf), ('rf', rnd_clf), ('svc', svm_clf)], voting='hard')voting_clf. fit(X_train, y_train) Vejamos a acurácia de cada classificador no conjunto de testes: >>> from sklearn. metrics import accuracy_score >>> for clf in (log_clf, rnd_clf, svm_clf, voting_clf):... clf. fit(X_train, y_train)... y_pred = clf. predict(X_test)... print(clf. __class__. __name__, accuracy_score(y_test, y_pred))... Logistic Regression 0. 864 Random Forest Classifier 0. 872 SVC 0. 888 Voting Classifier 0. 896 Aí está! O classificador de votação supera ligeiramente todos os classificadores individuais. Se todos os classificadores são capazes de estimar as probabilidades da classe (ou seja, possuem um método predict_proba() ), então você pode pedir ao Scikit-Learn para prever a classe com a maior probabilidade na média sobre todos os classificadores indi-viduais. Isto é chamado soft voting. Muitas vezes, ele consegue um desempenho maior do que o hard voting, pois dá mais peso aos votos altamente confiantes. Você só precisa substituir voting=“hard” por voting=“soft” e assegurar que todos os classificadores possam estimar as probabilidades da classe. Por padrão, este não é o caso da classe SVC, então você precisa configurar seu hiperparâmetro probability para True (isso fará com que a classe SVC utilize a validação cruzada para estimar as probabilidades da CG_MIOLO_Hands_On_Machine_Learning. indb 188 07/05/2019 17:08:51 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
Bagging e Pasting | 189classe, diminuindo o treinamento e adicionando um método predict_proba() ). Se você modificar o código anterior para utilizar o soft voting, descobrirá que o classificador de votação atingirá mais de 91% de acurácia! Bagging e Pasting Como discutimos, uma forma de obter um conjunto diversificado de classificadores é utilizar algoritmos de treinamento muito diferentes. Outra abordagem seria utilizar o mesmo algoritmo de treinamento para cada previsor, mas treiná-los em diferentes subconjuntos aleatórios do conjunto de treinamento. Quando a amostragem é realizada com substituição, este método é chamado bagging (http://goo. gl/o42tml )1 (abreviação para bootstrap aggregating 2). Quando a amostragem é realizada sem substituição, é chamado pasting (http://goo. gl/BXm0pm ). 3 Em outras palavras, tanto bagging quanto pasting permitem que as instâncias de trei-namento sejam amostradas várias vezes por meio de múltiplos previsores, mas somente bagging permite que as instâncias de treinamento sejam amostradas diversas vezes pelo mesmo previsor. Este processo de amostragem e treinamento está representado na Figura 7-4. Previsão (por exemplo, classi/f_icadores) Treinamento Conjunto de treinamento Amostragem aleatória (com reposição = bootstrap) Figura 7-4. Conjunto de treinamento e amostragem pasting/bagging Uma vez que todos os previsores são treinados, o ensemble pode fazer previsão para uma nova instância simplesmente agregando as previsões de todos os previsores. A função de agregação é tipicamente o modo estatística (ou seja, a previsão mais frequente, assim 1 “Bagging Predictors”, L. Breiman (1996). 2 Reamostrar com substituição é chamado bootstrapping em estatística. 3 “Pasting small votes for classification in large databases and online”, L. Breiman (1999). CG_MIOLO_Hands_On_Machine_Learning. indb 189 07/05/2019 17:08:51 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
190 | Capítulo 7: Ensemble Learning e Florestas Aleatóriascomo um classificador hard voting) para a classificação ou a média para a regressão. Cada previsor individual tem um viés mais alto do que se fosse treinado no conjunto original, mas a agregação reduz tanto o viés quanto a variância. 4 Geralmente, o resultado em rede é que o conjunto tem um viés semelhante, mas uma variância inferior do que um previsor único treinado no conjunto de treinamento original. Como você pode ver na Figura 7-4, os previsores podem ser treinados em paralelo com diferentes núcleos de CPU ou mesmo servidores diferentes. Da mesma forma, as previ-sões podem ser feitas em paralelo. Esta é uma das razões pelas quais bagging e pasting são métodos tão populares: eles escalonam muito bem. Bagging e Pasting no Scikit-Learn O Scikit-Learn oferece uma API simples tanto para bagging quanto para pasting com a classe Bagging Classifier (ou Bagging Regressor para a regressão). O código a seguir treina um conjunto de 500 classificadores de Árvores de Decisão,5 cada um treinado em 100 instâncias de treinamento amostradas aleatoriamente com substituição no conjunto de treinamento (este é um exemplo de bagging, mas, se você quiser utilizar pasting, configure bootstrap=False ). O parâmetro n_jobs informa ao Scikit-Learn o número de núcleos de CPU a serem utilizados para treinamento e previsões (-1 informa ao Scikit-Learn para utilizar todos os núcleos disponíveis): from sklearn. ensemble import Bagging Classifier from sklearn. tree import Decision Tree Classifier bag_clf = Bagging Classifier( Decision Tree Classifier(), n_estimators=500, max_samples=100, bootstrap=True, n_jobs=-1) bag_clf. fit(X_train, y_train) y_pred = bag_clf. predict(X_test) O Bagging Classifier executa automaticamente um soft voting em vez de um hard voting se o classificador de base puder es-timar as probabilidades da classe (ou seja, se tiver um método predict_proba()), como nos classificadores das Árvores de Decisão. A Figura 7-5 compara a fronteira de decisão de uma única Árvore de Decisão com a fronteira de decisão de um bagging ensemble de 500 árvores (do código anterior), ambos treinados no conjunto de dados em formato de luas. Como você pode ver, as previsões 4 Viés e variância introduzidos no Capítulo 4. 5 max _samples pode, alternativamente, ser configurado para flutuar entre 0,0 e 1,0, no caso em que o número máximo de instâncias a serem amostradas é igual ao tamanho do conjunto de treinamento vezes max_samples. CG_MIOLO_Hands_On_Machine_Learning. indb 190 07/05/2019 17:08:52 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
Bagging e Pasting | 191do ensemble provavelmente generalizarão bem melhor do que as previsões da Árvore de Decisão: o ensemble tem um viés comparável, mas uma variância menor (faz com que o mesmo número de erros ocorra no conjunto de treinamento, mas a fronteira de decisão é menos irregular). Árvore de D ecisão Árvore de D ecisão com Bagging Figura 7-5. Uma Árvore de Decisão única versus um bagging ensemble de 500 árvores O bootstrapping introduz um pouco mais de diversidade nos subconjuntos em que cada previsor é treinado, então bagging acaba com um viés ligeiramente mais alto do que pasting, mas isto também significa que os previsores acabam sendo menos correlatos, portanto a variância do ensemble é reduzida. Em geral, bagging resulta em melhores modelos, o que explica por que em geral é escolhido. Entretanto, se você tiver tempo livre e poder de CPU, utilize a validação cruzada para avaliar tanto o bagging quanto o pasting e selecione o que funcionar melhor. Avaliação Out-of-Bag Com o bagging, algumas instâncias podem ser amostradas muitas vezes em qual-quer previsor, enquanto outras podem simplesmente não serem amostradas. Por pa-drão, um Bagging Classifier amostra m instâncias de treinamento com substituição (bootstrap=True ), sendo m o tamanho do conjunto. Isto significa que somente 63% das instâncias de treinamento são amostradas na média para cada previsor. 6 Os 37% restan-tes das instâncias que não são amostradas são chamadas de instâncias out-of-bag (oob). Observe que elas não são os mesmos 37% para todos os previsores. Como um previsor nunca vê as instâncias oob durante o treinamento, ele pode ser avaliado nessas instâncias sem a necessidade de um conjunto de validação separado ou de validação cruzada. Você pode avaliar o ensemble em si com a média das avaliações oob de cada previsor. 6 À medida que m cr esce, esta taxa se aproxima de 1-exp(-1) ≈ 63,212%. CG_MIOLO_Hands_On_Machine_Learning. indb 191 07/05/2019 17:08:52 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
192 | Capítulo 7: Ensemble Learning e Florestas Aleatórias Você pode configurar oob_score=True no Scikit-Learn ao criar um Bagging Classifier para requerer uma avaliação oob automática após o treinamento. O código a seguir demonstra isto. A pontuação da avaliação resultante está disponível na variável oob_score_ : >>> bag_clf = Bagging Classifier(... Decision Tree Classifier(), n_estimators=500,... bootstrap=True, n_jobs=-1, oob_score=True)... >>> bag_clf. fit(X_train, y_train) >>> bag_clf. oob_score_ 0. 90133333333333332 De acordo com esta avaliação oob, este Bagging Classifier parece obter uma acurácia de aproximadamente 90,1% no conjunto de teste. Verificaremos: >>> from sklearn. metrics import accuracy_score >>> y_pred = bag_clf. predict(X_test) >>> accuracy_score(y_test, y_pred) 0. 91200000000000003 Conseguimos 91,2% de acurácia no conjunto de teste — quase lá! A função de decisão oob para cada instância de treinamento também está disponível através da variável oob_decision_function_. Neste caso (como o estimador base tem um método predict_proba() ), a função de decisão retorna as probabilidades da classe para cada instância de treinamento. Por exemplo, a avaliação oob estima que a primeira instância de treinamento tem uma probabilidade de 68,25% de pertencer à classe positiva (e 31,75% de pertencer à classe negativa): >>> bag_clf. oob_decision_function_ array([[ 0. 31746032, 0. 68253968], [ 0. 34117647, 0. 65882353], [ 1. , 0. ], ... [ 1. , 0. ], [ 0. 03108808, 0. 96891192], [ 0. 57291667, 0. 42708333]]) Patches Aleatórios e Subespaços Aleatórios A classe Bagging Classifier também permite a amostragem das características, que é controlada pelos dois hiperparâmetros: max_features e bootstrap_features. Eles trabalham da mesma forma que max_samples e bootstrap, mas para a amostragem da característica, não para a da instância. Assim, cada previsor será treinado em um subconjunto aleatório das características da entrada. Isso é particularmente útil quando você lida com entradas de alta dimensionalidade (como imagens). A amostragem das instâncias de treinamento e das características é chamada CG_MIOLO_Hands_On_Machine_Learning. indb 192 07/05/2019 17:08:52 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
Florestas Aleatórias | 19 3de método Random Patches (http://goo. gl/B2Ec M2 ). 7 Quando mantemos todas as instân-cias de treinamento (por exemplo, bootstrap = False e max_samples = 1. 0 ), exceto as características de amostragem (ou seja, bootstrap_features=True e/ou max_features menores que 1,0), são chamadas de método Random Subspaces ( http://goo. gl/NPi5v H ). 8 As características da amostragem resultam em uma maior diversidade dos previsores, negociando um pouco mais de viés por uma menor variância. Florestas Aleatórias Como discutimos, uma Floresta Aleatória (http://goo. gl/z VOGQ1 ) 9 é um ensemble de Árvo-res de Decisão, geralmente treinado pelo método bagging (ou algumas vezes pasting) com max_samples ajustada ao tamanho do conjunto de treinamento. Em vez de construir um Bagging Classifier e passá-lo por um Decision Tree Classifier, você pode utilizar a classe Random Forest Classifier, que é mais conveniente e otimizada para Árvores de Decisão 10 (igualmente, existe uma classe Random Forest Regressor para tarefas de regressão). O código a seguir treina um classificador de Floresta Aleatória com 500 árvores (cada uma limitada a 16 nós no máximo) com a utilização de todos os núcleos de CPU disponíveis: from sklearn. ensemble import Random Forest Classifier rnd_clf = Random Forest Classifier(n_estimators=500, max_leaf_nodes=16, n_jobs=-1) rnd_clf. fit(X_train, y_train)y_pred_rf = rnd_clf. predict(X_test) Com poucas exceções, um Random Forest Classifier tem todos os hiperparâmetros de um Decision Tree Classifier (para controlar como as árvores se desenvolvem) mais todos os hiperparâmetros de um Bagging Classifier para controlar o próprio ensemble. 11 O algoritmo Floresta Aleatória introduz uma aleatoriedade extra ao desenvolver árvo-res; em vez de buscar a melhor característica ao dividir um nó (veja o Capítulo 6), ele a busca entre um subconjunto aleatório dessas características, resultando em uma grande diversidade da árvore, que (mais uma vez) troca um alto viés por uma baixa variância, 7 “Ensembles on Random Patches”, G. Louppe and P. Geurts (2012). 8 “Th e random subspace method for constructing decision forests”, Tin Kam Ho (1998). 9 “Ra ndom Decision Forests”, T. Ho (1995). 10 A cla sse Bagging Classifier permanece útil se você quiser um bag de algo em vez de Árvores de Decisão. 11 Exi stem algumas exceções notáveis: splitter está ausente (forçado para “random” ), presort está ausente (forçado para False ), max_samples está ausente (forçado para 1. 0), e base_estimator está ausente (forçado para Decision Tree Classifier com os hiperparâmetros fornecidos). CG_MIOLO_Hands_On_Machine_Learning. indb 193 07/05/2019 17:08:53 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
194 | Capítulo 7: Ensemble Learning e Florestas Aleatóriasgeralmente produzindo um melhor modelo no geral. O Bagging Classifier a seguir é equivalente ao Random Forest Classifier anterior: bag_clf = Bagging Classifier( Decision Tree Classifier(splitter="random", max_leaf_nodes=16), n_estimators=500, max_samples=1. 0, bootstrap=True, n_jobs=-1) Árvores-Extras Ao desenvolver uma árvore em uma Floresta Aleatória, consideramos somente um subconjunto aleatório para a divisão das características em cada nó (como discutido anteriormente). É possível tornar as árvores ainda mais aleatórias ao utilizarmos tam-bém os limiares aleatórios para cada característica em vez de buscar pelo melhor limiar possível (como fazem as Árvores de Decisão regulares). Uma floresta de árvores aleatórias tão extremas é chamada simplesmente de ensemble de Árvores Extremamente Aleatorizadas ( http://goo. gl/RHGEA4 )12 (ou Árvores-Extras na abreviação). Mais uma vez, isto troca mais viés por uma variância menor. Também torna o treinamento das Árvores-Extras mais rápido do que as Florestas Aleatórias regulares, já que encontrar o melhor limiar possível para cada característica em cada nó é uma das tarefas que mais demandam tempo no desenvolvimento de uma árvore. Você pode criar um classificador Árvores-Extras usando a classe Extra Trees Classifier do Scikit-Learn. Sua API é idêntica à classe Random Forest Classifier. Igualmente, a classe Extra Trees Regressor tem a mesma API da classe Random Forest Regressor. A priori, é difícil dizer se um Random Forest Classifier terá um de-sempenho melhor ou pior que um Extra Trees Classifier. Geral-mente, a única maneira de saber é tentar com ambos e compará--los utilizando a validação cruzada (e ajustando os hiperparâmetros utilizando a grid search). Importância da Característica Outra grande qualidade das Florestas Aleatórias é que elas facilitam a medição da im-portância relativa de cada característica. O Scikit-Learn mede a importância de uma característica analisando o quanto os nós da árvore que a utilizam reduzem, na média, a impureza (através de todas as árvores na floresta). Mais precisamente, é uma média ponderada em que o peso de cada nó é igual ao número de amostras treinadas que são associadas a ela (veja o Capítulo 6). 12 “Extremely randomized trees”, P. Geurts, D. Ernst, L. Wehenkel (2005). CG_MIOLO_Hands_On_Machine_Learning. indb 194 07/05/2019 17:08:53 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
Florestas Aleatórias | 19 5O Scikit-Learn calcula automaticamente esta pontuação para cada característica após o treinamento, então dimensiona os resultados para que a soma de todas as importâncias seja igual a 1. Você pode acessar o resultado utilizando a variável feature_importances_. Por exemplo, o código a seguir treina um Random Forest Classifier no conjunto de dados da íris (introduzido no Capítulo 4) e exibe cada importância desta característica. Parece que as características mais importantes são o comprimento da pétala (44%) e a largura (42%), enquanto, comparativamente, o comprimento e a largura da sépala são menos importantes (11% e 2%, respectivamente). >>> from sklearn. datasets import load_iris >>> iris = load_iris() >>> rnd_clf = Random Forest Classifier(n_estimators=500, n_jobs=-1) >>> rnd_clf. fit(iris["data"], iris["target"]) >>> for name, score in zip(iris["feature_names"], rnd_clf. feature_importances_):... print(name, score)... sepal length (cm) 0. 112492250999 sepal width (cm) 0. 0231192882825petal length (cm) 0. 441030464364 petal width (cm) 0. 423357996355 Da mesma forma, se você treinar um classificador Floresta Aleatória no conjunto de dados MNIST (introduzido no Capítulo 3) e plotar cada importância do pixel terá a imagem representada na Figura 7-6. Muito impor tante Não impor tante Figura 7-6. Importância do pixel MNIST (de acordo com um classificador Floresta Aleatória) As Florestas Aleatórias são muito úteis para entender rapidamente quais características realmente importam, principalmente se você precisar executar sua seleção. CG_MIOLO_Hands_On_Machine_Learning. indb 195 07/05/2019 17:08:53 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
196 | Capítulo 7: Ensemble Learning e Florestas Aleatórias Boosting Boosting (originalmente chamado de hypothesis boosting ) se refere a qualquer método Ensemble que combina vários aprendizes fracos em um forte. A ideia geral da maioria dos métodos boosting é treinar sequencialmente os previsores, cada um tentando corrigir seu antecessor. Existem muitos métodos boosting disponíveis, mas os mais populares são Ada Boost (http://goo. gl/OIdu RW )13 (abreviação de Adaptive Boosting ) e Gradient Boosting. Começaremos com o Ada Boost. Ada Boost Uma forma de o novo previsor corrigir seu antecessor é prestar um pouco mais de aten-ção às instâncias de treinamento que seu antecessor subajustou. Isto resulta em novos previsores focando mais e mais cases difíceis. Esta técnica é utilizada pelo Ada Boost. Por exemplo, para construir um classificador Ada Boost, treinamos um classificador de primeira base (como uma Árvore de Decisão) e o utilizamos para fazer previsões no conjunto de treinamento. O peso relativo das instâncias de treinamento classificadas erroneamente é aumentado. Um segundo classificador é treinado com a utilização dos pesos atualizados e novamente ele faz previsões no conjunto de treinamento, os pesos são atualizados e assim por diante (veja Figura 7-7). Figura 7-7. Treinamento sequencial Ada Boost com atualizações de peso das instâncias 13 “A Decision-Theoretic Generalization of On-Line Learning and an Application to Boosting”, Yoav Freund, Ro bert E. Schapire (1997). CG_MIOLO_Hands_On_Machine_Learning. indb 196 07/05/2019 17:08:53 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
Boosting | 197A Figura 7-8 mostra as fronteiras de decisão de cinco previsores consecutivos no conjun-to de dados em formato de luas (neste exemplo, cada previsor é um classificador SVM altamente regularizado com um kernel RBF )14. O primeiro classificador obtém muitas instâncias erradas, o que faz seus pesos serem aumentados. O segundo classificador, entretanto, faz um trabalho melhor nessas instâncias, e assim por diante. A plotagem à direita representa a mesma sequência de previsores, exceto que a taxa de aprendizado é reduzida pela metade (ou seja, os pesos das instâncias classificadas erroneamente são aumentados pela metade a cada iteração). Como você pode ver, esta técnica de aprendizado sequencial tem algumas semelhanças com o Gradiente Descendente, com a exceção de que, em vez de ajustar os parâmetros de um único previsor para minimizar uma função de custo, o Ada Boost adiciona previsores ao ensemble, tornando-o gradualmente melhor. learning_rate = 0 learning_rate = 0. 5 Figura 7-8. Fronteiras de decisão de previsores consecutivos Quando todos os previsores estão treinados, o ensemble faz previsões muito parecidas com o bagging ou pasting, mas os previsores têm pesos diferentes dependendo da sua precisão geral no conjunto de treinamento ponderado. Existe uma desvantagem importante para esta técnica de aprendiza-do sequencial: ela não pode ser paralelizada (ou apenas parcialmente) uma vez que cada previsor só pode ser treinado após o previsor ante-rior ter sido treinado e avaliado. Como resultado, ele não escalona tão bem quanto o bagging ou o pasting. Vamos dar uma olhada no algoritmo Ada Boost. Cada peso w(i) da instância é inicial-mente definido em . Um primeiro previsor é treinado e sua taxa de erro ponderado r1 é calculada no conjunto de treinamento; veja a Equação 7-1. 14 Apenas para fins ilustrativos. Os SVM geralmente não são bons previsores de base para o Ada Boost, porque são lentos e tendem a ser instáveis com o Ada Boost. CG_MIOLO_Hands_On_Machine_Learning. indb 197 07/05/2019 17:08:54 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
198 | Capítulo 7: Ensemble Learning e Florestas Aleatórias Equação 7-1. Taxa de erro ponderada do j-ésimo previsor rj=∑ i=1 yji≠yim wi ∑ i=1m wisendo queyjiéaj-ésima previsão do previsor para ai-ésima instância. Utilizando a Equação 7-2, o peso αj do previsor é calculado, sendo que η é o hiperparâ-metro da taxa de aprendizado (o padrão é 1). 15 Quanto mais preciso for o previsor, mais alto será seu peso. Se ele apenas estimar aleatoriamente, então seu peso será próximo de zero. No entanto, se ele errar com mais frequência (ou seja, com menos acurácia do que a estimativa aleatória), então seu peso será negativo. Equação 7-2. Peso do previsor αj=ηlog1-rj rj Os pesos das instâncias são atualizados usando a Equação 7-3: as instâncias classificadas erroneamente são aumentadas. Equação 7-3. Regra da atualização do peso para i=1,2,,m wiwiseyji=yi wiexp αjseyji≠yi Então todos os pesos das instâncias são normalizados (ou seja, divididos por ). Finalmente, um novo previsor é treinado usando os pesos atualizados e todo o processo é repetido (o novo peso do previsor é calculado, os pesos das instâncias são atualizados então outro previsor é treinado, e assim por diante). O algoritmo para quando o número de previsões desejado é alcançado, ou quando é encontrado um previsor perfeito. Para fazer previsões, o Ada Boost simplesmente calcula as previsões de todos os previ-sores e os pondera usando os pesos αj dos previsores. A classe do previsor é aquela que recebe a maioria dos votos ponderados (veja a Equação 7-4). 15 O algoritmo original Ada Boost não utiliza um hiperparâmetro da taxa de aprendizado. CG_MIOLO_Hands_On_Machine_Learning. indb 198 07/05/2019 17:08:54 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
Boosting | 19 9Equação 7-4. Previsões Ada Boost yx= argmax k∑ j=1 yjx=k N αjsendo que Néonúmero de previsores. Na verdade, o Scikit-Learn utiliza uma versão multiclasse do Ada Boost chamada SAMME (http://goo. gl/Eji2v R )16 (que significa Stagewise Additive Modeling using a Multi-class Exponential loss function ). O SAMME é equivalente ao Ada Boost quando existem apenas duas classes. Além do mais, se os previsores puderem estimar probabilidades da classe (ou seja, se eles tiverem um método predict_proba() ), o Scikit-Learn pode utilizar uma variante do SAMME chamada SAMME. R (o R significa “Real”) que se baseia nas probabilidades da classe em vez de previsões, e geralmente tem um melhor desempenho. O código a seguir treina um classificador Ada Boost baseado em 200 Decision Stumps usando a classe Ada Boost Classifier do Scikit-Learn (como esperado, existe também uma classe Ada Boost Regressor ). Uma Decision Stump é uma Árvore de Decisão com max_depth=1 — em outras palavras, uma árvore composta de um só nó de decisão mais dois nós de folhas. Está é a estimativa base padrão para a classe Ada Boost Classifier : from sklearn. ensemble import Ada Boost Classifier ada_clf = Ada Boost Classifier( Decision Tree Classifier(max_depth=1), n_estimators=200, algorithm="SAMME. R", learning_rate=0. 5) ada_clf. fit(X_train, y_train) Se o seu ensemble Ada Boost estiver se sobreajustando ao conjunto de treinamento, você pode tentar reduzir o número de estimadores ou regularizar mais fortemente o estimador base. Gradient Boosting Outro algoritmo Boosting bem popular é o Gradient Boosting ( http://goo. gl/Ezw4j L ). 17 Assim como o Ada Boost, o Gradient Boosting adiciona previsores sequencialmente a um conjunto, cada um corrigindo seu antecessor. No entanto, em vez de ajustar os pe-sos da instância a cada iteração como o Ada Boost faz, este método tenta ajustar o novo previsor aos erros residuais feitos pelo previsor anterior. 16 Para mais detalhes, veja “Multi-Class Ada Boost”, J. Zhu et al. (2006). 17 Int roduzido primeiro em “Arcing the Edge”, L. Breiman (1997). CG_MIOLO_Hands_On_Machine_Learning. indb 199 07/05/2019 17:08:55 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
200 | Capítulo 7: Ensemble Learning e Florestas Aleatórias Analisaremos um exemplo de regressão simples utilizando as Árvores de Decisão como previsores base (claro que o Gradient Boosting também trabalha muito bem com as tarefas de regressão). Isso é chamado Gradient Tree Boosting, ou Gradient Boosted Regression Trees (GBRT). Primeiro, ajustaremos um Decision Tree Regressor ao conjunto de treinamento (por exemplo, um conjunto de treinamento quadrático ruidoso): from sklearn. tree import Decision Tree Regressor tree_reg1 = Decision Tree Regressor(max_depth=2) tree_reg1. fit(X, y) Agora treine um segundo Decision Tree Regressor nos erros residuais cometidos pelo primeiro previsor: y2 = y-tree_reg1. predict(X) tree_reg2 = Decision Tree Regressor(max_depth=2) tree_reg2. fit(X, y2) Em seguida treinaremos um terceiro regressor nos erros residuais cometidos pelo segundo previsor: y3 = y2-tree_reg2. predict(X) tree_reg3 = Decision Tree Regressor(max_depth=2) tree_reg3. fit(X, y3) Agora, temos um ensemble contendo três árvores. Ele pode fazer previsões em uma nova instância adicionando as previsões de todas as árvores: y_pred = sum(tree. predict(X_new) for tree in (tree_reg1, tree_reg2, tree_reg3)) A Figura 7-9 representa as previsões dessas três árvores em sua coluna à esquerda e as previsões do ensemble na coluna da direita. Na primeira linha, o ensemble tem apenas uma árvore, então suas previsões são exatamente as mesmas que as previsões da primeira árvore. Na segunda linha, uma nova árvore é treinada nos erros residuais da primeira. À direita, é possível ver que as previsões do ensemble são iguais à soma das previsões das duas primeiras árvores. Da mesma forma, na terceira fila outra árvore é treinada nos erros residuais da segunda árvore. À medida que as árvores são adicionadas ao ensemble, verificamos que suas previsões melhoram gradualmente Uma maneira mais simples de treinar ensembles GBRT seria com a utiliza-ção da classe Gradient Boosting Regressor do Scikit-Learn. Tal como a classe Random Forest Regressor, ela tem hiperparâmetros para controlar o crescimento das Árvores de Decisão (por exemplo, max_depth, min_samples_leaf e assim por diante), bem como hiperparâmetros para controlar o treinamento do ensemble, como o número de árvores ( n_estimators ). O código a seguir cria o mesmo ensemble que o anterior: CG_MIOLO_Hands_On_Machine_Learning. indb 200 07/05/2019 17:08:55 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
Boosting | 201from sklearn. ensemble import Gradient Boosting Regressor gbrt = Gradient Boosting Regressor(max_depth=2, n_estimators=3, learning_rate=1. 0) gbrt. fit(X, y) Residuais e previsões de ár vore s Previsões do C onjunto Training set Residuais Conjunto de treinament o Conjunto de treinamento Figura 7-9. Gradient Boosting O hiperparâmetro learning_rate escalona a contribuição de cada árvore. Se você con-figurá-lo para um valor baixo, como 0,1, precisará de mais árvores no ensemble para se ajustar ao conjunto de treinamento, mas as previsões normalmente generalizarão melhor. Esta é uma técnica de regularização chamada encolhimento. A Figura 7-10 mostra dois ensembles GBRT treinados com uma baixa taxa de aprendizado: o do lado esquerdo não possui árvores suficientes para se ajustarem ao conjunto de treinamento, enquanto o do lado direito possui muitas árvores e se sobreajusta ao conjunto de treinamento. CG_MIOLO_Hands_On_Machine_Learning. indb 201 07/05/2019 17:08:56 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
202 | Capítulo 7: Ensemble Learning e Florestas Aleatórias Previsões do ensemblelearning_rate= 0. 1, n_estimators=3 learning_rate= 0. 1, n_estimators=200 Figura 7-10. Ensembles GBRT com previsores insuficientes (à esquerda) e demais (à direita) Você pode utilizar uma parada antecipada para encontrar o número ideal de árvores (veja o Capítulo 4). Uma maneira simples de implementar isto é com a utilização do método staged_predict() : ele retorna um iterador em cada estágio do treinamento sobre as previsões feitas pelo ensemble (com uma árvore, duas árvores, etc. ). O código a seguir treina um ensemble GBRT com 120 árvores e mede o erro de validação em cada estágio do treinamento para encontrar o número ideal de árvores e, utilizando o número ideal de árvores, finalmente treina outro ensemble GBRT: import numpy as np from sklearn. model_selection import train_test_split from sklearn. metrics import mean_squared_error X_train, X_val, y_train, y_val = train_test_split(X, y) gbrt = Gradient Boosting Regressor(max_depth=2, n_estimators=120) gbrt. fit(X_train, y_train) errors = [mean_squared_error(y_val, y_pred) for y_pred in gbrt. staged_predict(X_val)] bst_n_estimators = np. argmin(errors) gbrt_best = Gradient Boosting Regressor(max_depth=2,n_estimators=bst_n_estimators) gbrt_best. fit(X_train, y_train) Os erros de validação estão representados à esquerda da Figura 7-11, e as previsões do melhor modelo estão representadas à direita. CG_MIOLO_Hands_On_Machine_Learning. indb 202 07/05/2019 17:08:56 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
Boosting | 203 Mínimo Melhor modelo (55 ár vores) Erro de validação Número de ár vore s Figura 7-11. Ajustando o número de árvores utilizando uma parada antecipada Também é possível implementar uma parada antecipada interrompendo antecipadamente o treinamento (em vez de treinar primeiro um grande número de árvores e em seguida olhar para trás para encontrar o número ideal). Você pode fazer isso configurando warm_start=True, o que faz com que o Scikit-Learn mantenha as árvores existentes quando recorrer ao método fit(), permitindo seu treinamento incremental. O código a seguir deixa de treinar quando o erro de validação não melhora por cinco iterações seguidas: gbrt = Gradient Boosting Regressor(max_depth=2, warm_start=True) min_val_error = float("inf") error_going_up = 0 for n_estimators in range(1, 120): gbrt. n_estimators = n_estimators gbrt. fit(X_train, y_train) y_pred = gbrt. predict(X_val) val_error = mean_squared_error(y_val, y_pred) if val_error < min_val_error: min_val_error = val_error error_going_up = 0 else: error_going_up += 1 if error_going_up == 5: break # parada antecipada A classe Gradient Boosting Regressor também suporta um hiperparâmetro subsample, que especifica a fração das instâncias de treinamento a serem usadas para treinar cada árvore. Por exemplo, se subsample=0. 25, cada árvore será treinada em 25% das instâncias de treinamento selecionadas aleatoriamente. Como você já deve ter adivinhado, isso troca um viés mais alto por uma variância inferior. Também acelera consideravelmente o treinamento. Esta técnica é chamada de Stochastic Gradient Boosting. É possível utilizar o Gradient Boosting com outras funções de custo. Isso é controlado pelo hiperparâmetro loss (consulte a documenta-ção do Scikit-Learn para mais detalhes). CG_MIOLO_Hands_On_Machine_Learning. indb 203 07/05/2019 17:08:56 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
204 | Capítulo 7: Ensemble Learning e Florestas Aleatórias Stacking O último Ensemble method que discutiremos neste capítulo é chamado stacking (abre-viação de stacked generalization) (http://goo. gl/9I2NBw ). 18 Baseia-se em uma ideia simples: em vez de utilizar funções triviais (como hard voting) para agregar as previsões de todos os previsores em um conjunto, por que não treinamos um modelo para agregá-las? A Figura 7-12 mostra esse ensemble executando uma tarefa de regressão em uma nova instância. Cada um dos três previsores abaixo prevê um valor diferente (3,1, 2,7 e 2,9) e, em seguida, o previsor final (chamado de blender ou um meta learner ) escolhe essas previsões como entradas e faz a previsão final (3. 0). Blending Mistura Previsões Previsão Nova instância Figura 7-12. Agregando previsões com um previsor blender Uma abordagem comum é utilizar um conjunto hold-out para treinar o blender. 19 Veremos como isso funciona. Primeiro, o conjunto de treinamento é dividido em dois subconjuntos. O primeiro subconjunto é utilizado para treinar os previsores na primeira camada (veja a Figura 7-13). 18 “Stacked Generalization”, D. Wolpert (1992). 19 Com o alternativa, é possível usar previsões out-of-fold. Em alguns contextos, isso é chamado de stacking, enquanto o uso de um conjunto de hold-out é chamado de blending. No entanto, para muitas pessoas, esses termos são sinônimos. CG_MIOLO_Hands_On_Machine_Learning. indb 204 07/05/2019 17:08:57 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
Stacking | 205 Subconjunto 2Treinar Subconjunto 1 Dividir Conjunto de Treinamento Figura 7-13. Treinando a primeira camada Em seguida, os previsores da primeira camada são utilizados para fazer previsões no segundo conjunto (hold-out) (veja a Figura 7-14), o que garante que as previsões sejam “limpas”, uma vez que os previsores nunca viram essas instâncias durante o treina-mento. Agora, existem três valores previstos para cada instância no conjunto hold-out e utilizando-os como características de entrada, podemos criar um novo conjunto de treinamento (o que torna este novo conjunto tridimensional) e manter os valores de destino. O blender é treinado neste novo conjunto de treinamento, aprendendo a prever o valor do alvo dadas as previsões da primeira camada. Treinar (para combinar previões)Blender Conjunto de treinamento da mistura Previsões Previsão Subconjunto 2 Figura 7-14. Treinando o blender CG_MIOLO_Hands_On_Machine_Learning. indb 205 07/05/2019 17:08:57 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
206 | Capítulo 7: Ensemble Learning e Florestas Aleatórias Na verdade, é possível treinar vários blenders diferentes dessa maneira (por exemplo, em um utilizando Regressão Linear, em outro utilizando Regressão de Floresta Aleatória, e assim por diante), obtendo, desta forma, uma camada completa de blenders. O truque é dividir o conjunto de treinamento em três subconjuntos: o primeiro para treinar a primeira camada, o segundo para criar o conjunto de treinamento usado para treinar a segunda camada (utilizando as previsões feitas pelos previsores da primeira camada), e o terceiro para criar o conjunto de treinamento para treinar a terceira camada (utilizando previsões feitas pelos previsores da segunda camada). Uma vez feito isso, podemos fazer uma previsão para uma nova instância passando sequencialmente por cada camada, como mostrado na Figura 7-15. Camada 3 Camada 2 Camada 1 Nova instância Figura 7-15. Previsões em um ensemble stacking de multicamadas Infelizmente, o Scikit-Learn não suporta stacking diretamente, mas não é muito difícil introduzir sua própria implementação (veja os seguintes exercícios). Como alternativa, você pode utilizar uma implementação de código aberto como o brew (disponível em https://github. com/viisar/brew ). CG_MIOLO_Hands_On_Machine_Learning. indb 206 07/05/2019 17:08:58 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
Exercícios | 207Exercícios 1. Se você treinou cinco modelos diferentes com exatamente os mesmos dados de tr einamento e todos conseguem uma precisão de 95%, existe alguma chance de você combinar esses modelos para obter melhores resultados? Em caso afirmati-vo, como? Se não, por quê? 2. Qua l a diferença entre os classificadores de votação hard e soft? 3. É pos sível acelerar o treinamento de um bagging ensemble distribuindo-o por vários servidores? E com pasting ensembles, boosting ensembles, florestas aleatórias, ou stacking ensembles? 4. Qua l é o benefício da avaliação out-of-bag? 5. O que t orna as Árvores-Extras mais aleatórias do que as Florestas Aleatórias comuns? Como esta aleatoriedade extra pode ajudar? As Árvores-Extras são mais lentas ou mais rápidas do que as Florestas Aleatórias regulares? 6. Se o seu e nsemble Ada Boost se subajusta aos dados de treinamento, quais hiper-parâmetros você deve ajustar e como? 7. Se o seu e nsemble Gradient Boosting se sobreajusta ao conjunto de treinamento, você deve aumentar ou diminuir a taxa de aprendizado? 8. Car regue os dados MNIST (introduzido no Capítulo 3) e o divida em um conjunto de treinamento, um conjunto de validação e um conjunto de teste (por exemplo, utilize 40 mil instâncias para treinamento, 10 mil para validação e 10 mil para teste). Em se-guida, treine vários classificadores como um classificador Floresta Aleatória, um clas-sificador Árvores-extra e um SVM. Em seguida, utilizando um classificador de vota-ção soft ou hard, tente combiná-los em um ensemble que supere todos no conjunto de validação. Uma vez tendo encontrado o ensemble, teste-o no conjunto de teste. Qual é a melhoria de desempenho em comparação com os classificadores individuais? 9. Exe cute os classificadores individuais do exercício anterior para fazer previsões no conjunto de validação e crie um novo conjunto de treinamento com as previ-sões resultantes: cada instância de treinamento é um vetor que contém o conjunto de previsões de todos os seus classificadores para uma imagem e o alvo é a classe da imagem. Parabéns, você acabou de treinar um blender, e, junto com os classi-ficadores, eles formam um stacking ensemble! Agora, avaliaremos o conjunto no conjunto de testes. Para cada imagem no conjunto de teste, faça previsões com todos os seus classificadores, então forneça as previsões ao blender para obter as previsões do ensemble. Como ela se compara ao classificador de votação que você treinou anteriormente? As soluções para estes exercícios estão disponíveis no Apêndice A. CG_MIOLO_Hands_On_Machine_Learning. indb 207 07/05/2019 17:08:58 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
CG_MIOLO_Hands_On_Machine_Learning. indb 208 07/05/2019 17:08:58 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
209Capítulo 8 Redução da Dimensionalidade Muitos problemas de Aprendizado de Máquina envolvem milhares ou mesmo milhões de características para cada instância de treinamento. Como veremos, isso não só torna o treinamento extremamente lento, mas também torna muito mais difícil encontrar uma boa solução. Este problema muitas vezes é referido como a maldição da dimensionalidade. Felizmente, é possível transformar um problema insolúvel em um problema tratável no mundo real ao reduzir consideravelmente o número de características abordadas. Por exemplo, considere as imagens do MNIST (introduzidas no Capítulo 3): os pixels nas bordas da imagem são quase sempre brancos, então você pode descartá-los completa-mente do conjunto de treinamento sem perder muita informação. A Figura 7-6 confirma que esses pixels não têm importância alguma para a tarefa de classificação. Além disso, dois pixels vizinhos são muitas vezes altamente correlacionados: se você mesclá-los em um único pixel (por exemplo, tomando a média das duas intensidades dos pixels), não perderá muita informação. Ao reduzir a dimensionalidade, perdemos alguma informação (as-sim como a compressão de uma imagem para JPEG pode degradar sua qualidade), por isso, embora acelere o treinamento, também pode fazer com que seu sistema funcione um pouco pior. Isso tam-bém torna seus pipelines um pouco mais complexos e, portanto, mais difíceis de manter. Você deve primeiro tentar treinar seu siste-ma com os dados originais antes de considerar a redução da dimen-sionalidade caso o treinamento esteja muito lento. Em alguns casos, no entanto, reduzir a dimensionalidade dos dados de treinamento poderá filtrar algum ruído e detalhes desnecessários, e resultar em melhor desempenho (mas em geral isso não acontecerá; apenas ace-lerará o treinamento). Além de acelerar o treinamento, a redução da dimensionalidade também é extremamente útil para visualização de dados (ou Data Viz ). Reduzir o número de dimensões para duas (ou três) permite plotar em um grafo um conjunto de treinamento de alta dimensão, e CG_MIOLO_Hands_On_Machine_Learning. indb 209 07/05/2019 17:08:58 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
210 | Capítulo 8: Redução da Dimensionalidademuitas vezes obter alguns insights importantes por meio da detecção visual de padrões, como os clusters. Neste capítulo, discutiremos a maldição da dimensionalidade e teremos uma noção do que se passa no espaço da alta dimensão. Apresentaremos as duas abordagens principais para a redução da dimensionalidade (projeção e Manifold Learning) e passaremos por três das técnicas mais populares da redução de dimensionalidade: PCA, Kernel PCA e LLE. A Maldição da Dimensionalidade Estamos tão acostumados a viver em três dimensões1 que nossa intuição falha quando tentamos imaginar um espaço de alta dimensão. Nossa mente tem uma dificuldade ex-trema de projetar até mesmo um hipercubo básico 4D (veja a Figura 8-1), que dirá uma elipsoide de 200 dimensões dobrada em um espaço de mil dimensões. #Dim Figura 8-1. Ponto, segmento, quadrado, cubo e tesserato (hipercubos 0D a 4D)2 Acontece que muitas coisas se comportam de forma bem diferente no espaço da alta dimensão. Por exemplo, se você escolher um ponto aleatório em um quadrado unitário (um quadrado 1 × 1), ele terá apenas 0,4% de chance de estar localizado a menos de 0,001 de uma borda (em outras palavras, é muito improvável que um ponto aleatório seja “extremo” ao longo de qualquer dimensão). Mas, em um hipercubo de 10 mil dimensões (um cubo 1 × 1 × ⋯ × 1, com dez mil 1s), esta probabilidade é maior que 99,999999%. A maioria dos pontos em um hipercubo de alta dimensão está muito próxima da borda. 3 1 Bem, quatro dimensões se você contar o tempo, e algumas mais se você concordar com a teoria das cordas. 2 Assista a um tesserato rotativo projetado no espaço 3D em http://goo. gl/OM7kt J. Imagem da Wikipédia dispo-nibilizada pelo usuário Nerd Boy1392 (Creative Commons BY-SA 3. 0 ( https://creativecommons. org/licenses/ by-sa/3. 0/ )). Reproduzido em https://en. wikipedia. org/wiki/Tesseract. 3 Fato divertido: qualquer um que você conheça provavelmente é um extremista em pelo menos uma dimensão (por exemplo, quanto açúcar eles colocam em seu café), se você considerar dimensões suficientes. CG_MIOLO_Hands_On_Machine_Learning. indb 210 07/05/2019 17:08:58 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
Principais Abordagens para a Redução da Dimensionalidade | 211Eis uma diferença mais problemática: se você escolher dois pontos aleatoriamente em um quadrado, a distância entre esses dois pontos será, na média, aproximadamente 0,52. Se você escolher dois pontos aleatórios em um cubo 3D, a distância média será de aproximadamente 0,66. Mas e quanto a dois pontos escolhidos aleatoriamente em um hipercubo de 1 milhão de dimensões? Bem, a distância média, acredite ou não, será de mais ou menos 408,25 (aproximadamente 1. 000. 000/6)! ), o que é bastante contraintuiti-vo: como dois pontos podem ser tão distantes quando ambos ficam dentro do mesmo hipercubo? Esse fato implica que os conjuntos de dados de alta dimensão correm o risco de serem muito escassos: a maioria das instâncias de treinamento provavelmente estará longe uma da outra. Claro, isso também significa que uma nova instância provavelmente estará longe de qualquer outra instância de treinamento, tornando as previsões muito menos confiáveis do que nas dimensões inferiores, uma vez que serão baseadas em ex-trapolações muito maiores. Em suma, quanto mais dimensões o conjunto de treinamento tiver, maior o risco de sobreajustá-lo. Na teoria, uma solução para a maldição da dimensionalidade poderia ser aumentar o tamanho do conjunto de treinamento para atingir uma densidade suficiente de instâncias. Infelizmente, na prática, o número de instâncias de treinamento necessárias para atingir uma determinada densidade cresce exponencialmente com o número de dimensões. Com apenas 100 características (muito menos do que no problema da MNIST), você precisaria de mais instâncias de treinamento do que os átomos no universo observável para que essas instâncias estivessem a 0,1 de cada uma em média, assumindo que esti-vessem espalhadas uniformemente em todas as dimensões. Principais Abordagens para a Redução da Dimensionalidade Antes de mergulharmos em algoritmos específicos de redução da dimensionalidade, veremos as duas principais abordagens para reduzi-la: Projeção e Manifold Learning. Projeção Na maioria dos problemas do mundo real, as instâncias de treinamento não se espalham uniformemente em todas as dimensões. Muitas características são quase constantes, enquanto outras estão altamente correlacionadas (como discutido anteriormente no MNIST). Como resultado, todas as instâncias de treinamento estão realmente dentro (ou perto) de um subespaço de dimensão bem menor no espaço de alta dimensão, mas como isto parece muito abstrato, vejamos um exemplo. Na Figura 8-2, podemos ver um conjunto de dados 3D representado pelos círculos. CG_MIOLO_Hands_On_Machine_Learning. indb 211 07/05/2019 17:08:58 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
212 | Capítulo 8: Redução da Dimensionalidade Figura 8-2. Um conjunto de dados 3D perto de um subespaço 2D Observe que todas as instâncias de treinamento estão próximas de um plano: este é um subespaço (2D) de dimensões inferiores em um espaço de alta dimensão (3D). Agora, se projetarmos perpendicularmente cada instância de treinamento a este subespaço (como representado pelas linhas curtas que conectam as instâncias ao plano), obtemos o novo conjunto de dados 2D mostrado na Figura 8-3. Sim! Acabamos de reduzir a dimensionalidade do conjunto de dados de 3D para 2D. Observe que os eixos correspondem às novas características z1 e z2 (as coordenadas das projeções no plano). Figura 8-3. O novo conjunto de dados 2D após a projeção No entanto, a projeção nem sempre é a melhor abordagem para a redução da dimensionali-dade. Em muitos casos, o subespaço pode torcer e girar como no famoso conjunto de dados em rolo suíço representado na Figura 8-4. CG_MIOLO_Hands_On_Machine_Learning. indb 212 07/05/2019 17:08:59 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
Principais Abordagens para a Redução da Dimensionalidade | 213 Figura 8-4. Conjunto de dados do rolo suíço Simplesmente projetar em um plano (por exemplo, descartando x3) comprimiria dife-rentes camadas do rolo suíço, como mostrado à esquerda na Figura 8-5. No entanto, o que você realmente quer é desenrolar o rolo para obter o conjunto de dados 2D à direita na Figura 8-5. Figura 8-5. Esmagar o rolo ao projetá-lo em um plano (esquerda) versus desenrolar o rolo suíço (direita) Manifold Learning O rolo suíço é um exemplo de um manifold 2D. Simplificando, um manifold 2D é uma forma 2D que pode ser dobrada e torcida em um espaço de dimensões maiores. Geralmente, um manifold d-dimensional é uma parte de um espaço n-dimensional (em que d < n) que se assemelha localmente a um hiperplano d-dimensional. No caso do rolo suíço, d = 2 e n = 3: ele se assemelha localmente a um plano 2D, mas é enrolado na terceira dimensão. CG_MIOLO_Hands_On_Machine_Learning. indb 213 07/05/2019 17:08:59 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
214 | Capítulo 8: Redução da Dimensionalidade Muitos algoritmos da redução de dimensionalidade funcionam modelando-se o manifold onde estão as instâncias de treinamento; isso é chamado Manifold Learning. Baseia-se na manifold assumption, também chamada de manifold hypothesis, que sustenta que a maioria dos conjuntos de dados de alta dimensão do mundo real está próxima de um manifold muito mais baixo. Esta suposição frequentemente é observada empiricamente. Mais uma vez, pense no conjunto de dados do MNIST: todas as imagens manuscritas dos dígitos têm algumas semelhanças. Elas são feitas de linhas conectadas, as bordas são brancas, elas estão mais ou menos centradas, e assim por diante. Se você as gerou aleatoriamente, apenas uma fração minúscula delas seria semelhante a dígitos escritos a mão. Em outras palavras, os graus de liberdade disponíveis quando se tenta criar uma imagem numérica são dramaticamente inferiores aos graus de liberdade que você teria se pudesse gerar outra imagem qualquer. Essas restrições tendem a comprimir o conjunto de dados em um manifold de dimensão inferior. A manifold assumption é muitas vezes acompanhada por outra suposição implícita: a tarefa em questão (por exemplo, classificação ou regressão) será mais simples se for expressa em um espaço de dimensão inferior do manifold. Por exemplo, na linha supe-rior da Figura 8-6, o rolo suíço é dividido em duas classes: no espaço 3D (à esquerda), a fronteira de decisão seria bastante complexa, mas no espaço manifold 2D desenrolado (à direita ), a fronteira de decisão é uma linha reta simples. No entanto, essa suposição nem sempre é válida. Por exemplo, na linha inferior da Figura 8-6, a fronteira de decisão está localizada em x 1 = 5. Esta fronteira de decisão parece muito simples no espaço 3D original (um plano vertical), mas parece mais complexa no manifold desenrolado (uma coleção de quatro segmentos de linha independentes). Em resumo, se você reduzir a dimensionalidade em seu conjunto de treinamento antes de treinar um modelo, ele definitivamente acelerará o treinamento, mas nem sempre poderá levar a uma solução melhor ou mais simples; tudo depende do conjunto de dados. Espero que você tenha agora uma boa noção do que é a maldição da dimensionalidade e como seus algoritmos de redução da dimensionalidade podem lutar contra ela, espe-cialmente quando a manifold assumption se sustenta. O restante deste capítulo aborda alguns dos algoritmos mais populares. CG_MIOLO_Hands_On_Machine_Learning. indb 214 07/05/2019 17:08:59 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
PCA | 215 Figura 8-6. A fronteira de decisão nem sempre é mais simples com dimensões inferiores PCA A Análise dos Componentes Principais (PCA) é, de longe, o algoritmo de redução de dimen-sionalidade mais popular. Primeiro, ele identifica o hiperplano que se encontra mais próximo dos dados e, então, projeta os dados sobre ele. Preservando a Variância Antes de projetar o conjunto de treinamento em um hiperplano de dimensões inferiores, é preciso escolher o hiperplano correto. Por exemplo, um simples conjunto de dados 2D é representado à esquerda da Figura 8-7 juntamente com três eixos diferentes (ou seja, hiperplanos unidimensionais). À direita está o resultado da projeção do conjunto de dados em cada um desses eixos. Como você pode ver, a projeção na linha sólida preserva a variância máxima, enquanto a projeção na linha pontilhada preserva pouca variância e a projeção na linha tracejada preserva uma variância intermediária. CG_MIOLO_Hands_On_Machine_Learning. indb 215 07/05/2019 17:08:59 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
216 | Capítulo 8: Redução da Dimensionalidade Figura 8-7. Selecionando o subespaço no qual projetar Parece razoável selecionar o eixo que preserva a quantidade máxima de variância, pois provavelmente ela perderá menos informações do que as outras projeções. O fato de o eixo minimizar a distância quadrática média entre o conjunto original de dados e sua projeção nesse eixo é outra maneira de justificar essa escolha. Esta é a ideia simples por trás do PCA ( http://goo. gl/gb No1D ). 4 Componentes Principais O PCA identifica o eixo que representa a maior quantidade de variância no conjunto de treinamento. É a linha sólida na Figura 8-7. Ela também encontra um segundo eixo ortogonal ao primeiro, que representa a maior quantidade remanescente de variância. Neste exemplo 2D, não há escolha: é a linha pontilhada. Se fosse um conjunto de dados de dimensão mais alta, o PCA também encontraria um terceiro eixo ortogonal aos dois eixos anteriores, e um quarto, um quinto, e assim por diante — tantos eixos quanto o número de dimensões no conjunto de dados. O vetor da unidade que define o i-ésimo eixo é chamado de i-ésimo componente principal (PC). Na Figura 8-7, o 10 PC é c1 e o 20 PC é c2. Na Figura 8-2, os dois primeiros PC estão representados no plano pelas setas ortogonais e o terceiro PC seria ortogonal ao plano (apontando para cima ou para baixo). 4 “Onlines and Planes of Closest Fit to Systems of Points in, K. Pearson (1901). CG_MIOLO_Hands_On_Machine_Learning. indb 216 07/05/2019 17:08:59 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
PCA | 217A direção dos componentes principais não é estável: se você pertur-bar ligeiramente o conjunto de treinamento e executar o PCA nova-mente, alguns dos novos PC podem apontar na direção oposta dos PC originais. No entanto, eles ainda permanecem nos mesmos eixos. Em alguns casos, um par de PC pode até girar ou trocar, mas o plano que eles definem geralmente permanece o mesmo. Então, como é possível encontrar os principais componentes de um conjunto de trei-namento? Felizmente, existe uma técnica padrão de fatoração da matriz chamada De-composição em Valores Singulares (SVD, em inglês) que pode decompor a matriz X do conjunto de treinamento em um produto escalar de três matrizes U · Σ · VT, sendo que V contém todos os componentes principais que buscamos, como mostrado na Equação 8-1. Equação 8-1. Matriz dos componentes principais V=c1c2cn O seguinte código Python utiliza a função svd() do Num Py para obter todos os compo-nentes principais do conjunto de treinamento e, em seguida, extrai os dois primeiros PC: X_centered = X-X. mean(axis=0) U, s, Vt = np. linalg. svd(X_centered) c1 = Vt. T[:, 0] c2 = Vt. T[:, 1] O PCA assume que o conjunto de dados está centrado em torno da origem. Como veremos, as classes PCA do Scikit-Learn cuidam de centrar os dados para você. No entanto, se implementarmos o PCA por conta própria (como no exemplo anterior), ou se utilizarmos outras bibliotecas, não podemos esquecer de centralizar os dados primeiro. Projetando para d Dimensões Assim que você identificar todos os componentes principais, pode reduzir a dimensio-nalidade do conjunto de dados a d dimensões projetando no hiperplano definido pelos d primeiros componentes principais. Selecionar este hiperplano garante que a projeção preservará a maior quantidade possível de variância. Por exemplo, na Figura 8-2, o con-junto de dados 3D é projetado no plano 2D definido pelos dois primeiros componentes principais, preservando uma grande parte da variância do conjunto de dados. Como resultado, a projeção 2D se parece muito com o conjunto de dados 3D original. CG_MIOLO_Hands_On_Machine_Learning. indb 217 07/05/2019 17:09:00 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
218 | Capítulo 8: Redução da Dimensionalidade Para projetar o conjunto de treinamento no hiperplano, simplesmente calcule o produto escalar da matriz X do conjunto de treinamento pela matriz W d, definida como a ma-triz que contém os primeiros componentes principais d (isto é, a matriz composta das primeiras colunas d de V), como mostrado na Equação 8-2. Equação 8-2. Projetando o conjunto de treinamento para d dimensões Xd/uni2010proj=X·Wd O seguinte código Python projeta o conjunto de treinamento no plano definido pelos dois primeiros componentes principais: W2 = Vt. T[:, :2] X2D = X_centered. dot(W2) Aí está! Agora você sabe como reduzir a dimensionalidade de qualquer conjunto de dados para qualquer número de dimensões preservando a maior quantidade possível de variância. Utilizando o Scikit-Learn A classe PCA do Scikit-Learn implementa o PCA com a utilização da decomposição SVD como fizemos antes. O código a seguir aplica o PCA para reduzir a dimensionali-dade a duas dimensões no conjunto de dados (observe que ela automaticamente cuida da centralização dos dados): from sklearn. decomposition import PCA pca = PCA(n_components = 2) X2D = pca. fit_transform(X) Após ajustar o transformador PCA ao conjunto de dados utilizando a variável components_, acesse os componentes principais (observe que ela contém os PC como vetores horizontais; então, por exemplo, o primeiro componente principal é igual a pca. components_. T[:, 0] ). Taxa de Variância Explicada Outra informação útil é a taxa de variância explicada de cada componente principal, disponível na variável explained_variance_ratio_. Ela indica a proporção da variância do conjunto de dados que se encontra ao longo do eixo de cada componente principal. Por exemplo, vejamos as taxas de variância explicadas dos dois primeiros componentes do conjunto de dados 3D representado na Figura 8-2: >>> pca. explained_variance_ratio_ array([ 0. 84248607, 0. 14631839]) CG_MIOLO_Hands_On_Machine_Learning. indb 218 07/05/2019 17:09:00 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
PCA | 219Isso indica que 84,2% da variância do conjunto de dados está ao longo do primeiro eixo e 14,6% situa-se ao longo do segundo eixo. Isso deixa menos de 1,2% para o terceiro eixo, por isso é razoável supor que ele provavelmente carrega pouca informação. Escolhendo o Número Certo de Dimensões Em vez de escolher arbitrariamente o número de dimensões a serem reduzidas, é preferível escolher o número de dimensões que adicionam uma porção suficientemente grande de variância (por exemplo, 95%). A menos que, claro, você esteja reduzindo a dimensionali-dade para a visualização de dados — nesse caso, reduza a dimensionalidade para 2 ou 3. O código a seguir calcula o PCA sem reduzir a dimensionalidade e, em seguida, cal-cula o número mínimo de dimensões necessárias para preservar 95% da variância no conjunto de treinamento: pca = PCA() pca. fit(X_train) cumsum = np. cumsum(pca. explained_variance_ratio_) d = np. argmax(cumsum >= 0. 95) + 1 Você poderia ajustar n_components=d e executar novamente o PCA. No entanto, existe uma opção bem melhor: em vez de especificar o número de componentes principais que você quer preservar, ajuste n_components para flutuar entre 0. 0 e 1. 0, indicando a taxa de variância que você quer preservar: pca = PCA(n_components=0. 95) X_reduced = pca. fit_transform(X_train) Outra opção seria plotar a variância explicada como uma função do número de dimen-sões (simplesmente plote cumsum, veja a Figura 8-8). Geralmente haverá um cotovelo na curva no qual a variância explicada rapidamente deixa de crescer. Você pode pensar nisso como a dimensionalidade intrínseca do conjunto de dados. Neste caso, você verá que a redução da dimensionalidade para cerca de 100 dimensões não perderia muito da variância explicada. Variância explicada Cotovelo Dimensões Figura 8-8. Variação explicada como uma função do número de dimensões CG_MIOLO_Hands_On_Machine_Learning. indb 219 07/05/2019 17:09:01 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
220 | Capítulo 8: Redução da Dimensionalidade PCA para a Compressão É óbvio que, após a redução da dimensionalidade, o conjunto de treinamento ocupa muito menos espaço. Por exemplo, tente aplicar o PCA no conjunto de dados MNIST preservando 95% de sua variação. Você verá que cada instância terá pouco mais de 150 características em vez das 784 originais. Assim, enquanto a maior parte da variância é preservada, o conjunto de dados está agora com menos de 20% do seu tamanho original! Esta é uma taxa de compressão razoável e você verá como isso pode acelerar tremenda-mente um algoritmo de classificação (como o classificador SVM). Também é possível descomprimir o conjunto de dados reduzido de volta para 784 dimensões aplicando a transformação inversa da projeção PCA. Claro que isso não trará de volta os dados originais, uma vez que a projeção perde um pouco de informação (dentro da variância de 5% que foi descartada), mas provavelmente será bastante próxima dos dados originais. A distân-cia quadrática média entre os dados originais e os dados reconstruídos (comprimidos e depois descomprimidos) é chamada de erro de reconstrução. Por exemplo, o código a seguir comprime o conjunto de dados MNIST para 154 dimensões, depois utiliza o método inverse_transform() para descomprimi-lo de volta para 784 dimensões. A Figura 8-9 mostra alguns dígitos do conjunto de treinamento original (à esquerda) e os dígitos correspondentes após a compressão e a descompressão. Veja que há uma ligeira perda de qualidade da imagem, mas os dígitos ainda estão intactos. pca = PCA(n_components = 154) X_reduced = pca. fit_transform(X_train) X_recovered = pca. inverse_transform(X_reduced) Original Comprimido Figura 8-9. Compressão do MNIST preservando 95% da variância CG_MIOLO_Hands_On_Machine_Learning. indb 220 07/05/2019 17:09:01 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
PCA | 221A transformação inversa é mostrada na Equação 8-3. Equação 8-3. Transformação inversa do PCA de volta ao número original de dimensões Xrecovered=Xd/uni2010proj·Wd T PCA Incremental Um problema com a implementação do PCA anterior é que ele exige que todo o conjunto de treinamento caiba na memória para que o algoritmo SVD seja executado. Felizmente, foram desenvolvidos os algoritmos PCA Incremental (IPCA): você pode dividir o conjunto de treinamento em minilotes e alimentar um algoritmo de IPCA com um minilote por vez. Isso é útil para grandes conjuntos de treinamento e também para aplicar o PCA online (ou seja, em tempo real, à medida que chegam novas instâncias). O código a seguir divide o conjunto de dados MNIST em 100 minilotes (utilizando a função do Num Py array_split() ), os fornece à classe Incremental PCA do Scikit-Learn (http://goo. gl/Fmdh UP )5 e reduz a dimensionalidade do conjunto de dados MNIST para 154 dimensões (como antes). Chame o método partial_fit() em cada minilote em vez do método fit() para todo o conjunto de treinamento: from sklearn. decomposition import Incremental PCA n_batches = 100 inc_pca = Incremental PCA(n_components=154) for X_batch in np. array_split(X_train, n_batches): inc_pca. partial_fit(X_batch) X_reduced = inc_pca. transform(X_train) Alternativamente, você pode utilizar a classe memmap do Num Py, que permite a manipu-lação de um grande array armazenado em um arquivo binário no disco como se estivesse inteiramente na memória; a classe carrega na memória somente os dados de que precisa, quando precisa. Como a classe Incremental PCA utiliza apenas uma pequena parte do array em um dado momento, o uso da memória permanece sob controle. Isto possibilita chamar ao método usual fit(), como podemos ver no código a seguir: X_mm = np. memmap(filename, dtype="float32", mode="readonly", shape=(m, n)) batch_size = m // n_batches inc_pca = Incremental PCA(n_components=154, batch_size=batch_size)inc_pca. fit(X_mm) 5 O Scikit-Learn utiliza o algoritmo descrito em “Incremental Learning for Robust Visual Tracking”, D. Ross et al. (2007). CG_MIOLO_Hands_On_Machine_Learning. indb 221 07/05/2019 17:09:01 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
222 | Capítulo 8: Redução da Dimensionalidade PCA Randomizado O Scikit-Learn oferece ainda outra opção para executar o PCA, o algoritmo chamado PCA Randomizado. Este é um algoritmo estocástico que rapidamente encontra uma aproximação dos primeiros componentes principais d. Sua complexidade computacional é O(m × d2) + O (d3), em vez de O (m × n2) + O (n3), portanto é dramaticamente mais rápida do que os algoritmos anteriores quando d é muito menor do que n. rnd_pca = PCA(n_components=154, svd_solver="randomized") X_reduced = rnd_pca. fit_transform(X_train) Kernel PCA No Capítulo 5, discutimos o truque do kernel, uma técnica matemática que implicitamente mapeia instâncias em um espaço de alta dimensão (chamado de espaço de caracterís-ticas ), permitindo a classificação não linear e a regressão com as Máquinas de Vetores de Suporte. Lembre-se de que uma fronteira de decisão linear em uma característica de espaço de alta dimensão corresponde a uma fronteira complexa de decisão não linear no espaço original. Acontece que o mesmo truque pode ser aplicado ao PCA, possibilitando a realização de projeções não lineares complexas para a redução da dimensionalidade. Isso é chamado de Kernel PCA (k PCA) ( http://goo. gl/5l QT5Q ). 6 Ele frequentemente é eficaz na preser-vação de grupos de instâncias após a projeção, ou às vezes até mesmo para desenrolar conjuntos de dados que estão próximos a um manifold retorcido. Por exemplo, o código a seguir utiliza a classe Kernel PCA do Scikit-Learn para realizar o k PCA com o kernel RBF (veja o Capítulo 5 para mais detalhes sobre o kernel RBF e os outros kernels): from sklearn. decomposition import Kernel PCA rbf_pca = Kernel PCA(n_components = 2, kernel="rbf", gamma=0. 04) X_reduced = rbf_pca. fit_transform(X) A Figura 8-10 mostra o rolo suíço reduzido a duas dimensões com a utilização de um kernel linear (equivalente a simplesmente utilizar a classe PCA), um kernel RBF e um kernel sigmóide (Logística). 6 “Kernel Principal Component Analysis,” B. Schölkopf, A. Smola, K. Müller (1999). CG_MIOLO_Hands_On_Machine_Learning. indb 222 07/05/2019 17:09:02 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
Kernel PCA | 223 Kernel sigmóid e Kernel RBF Kernel linear Figura 8-10. Rolo suíço reduzido para 2D utilizando k PCA com vários kernels Selecionando um Kernel e Ajustando Hiperparâmetros Como o k PCA é um algoritmo de aprendizado não supervisionado, não existe uma medida de desempenho óbvia para ajudá-lo a selecionar os melhores valores de kernel e hiperparâmetros. No entanto, a redução da dimensionalidade muitas vezes é um passo de preparação para uma tarefa de aprendizado supervisionado (por exemplo, a classi-ficação), então você pode simplesmente usar a grid search para selecionar o kernel e os hiperparâmetros que conduzam ao melhor desempenho dessa tarefa. Por exemplo, o código a seguir cria um pipeline de duas etapas, primeiro reduzindo a dimensionalidade para duas dimensões com a utilização do k PCA, e em seguida aplicando a Regressão Logística para a classificação. Então, ele utiliza o Grid Search CV para encontrar o melhor valor do kernel e de gama para o k PCA a fim de obter a melhor acurácia de classificação ao final do pipeline: from sklearn. decomposition import Kernel PCA rbf_pca = Kernel PCA(n_components = 2, kernel="rbf", gamma=0. 04) X_reduced = rbf_pca. fit_transform(X) from sklearn. model_selection import Grid Search CV from sklearn. linear_model import Logistic Regression from sklearn. pipeline import Pipeline clf = Pipeline([ ("kpca", Kernel PCA(n_components=2)), ("log_reg", Logistic Regression()) ]) param_grid = [{ "kpca__gamma": np. linspace(0. 03, 0. 05, 10), "kpca__kernel": ["rbf", "sigmoid"] }] grid_search = Grid Search CV(clf, param_grid, cv=3) grid_search. fit(X, y) CG_MIOLO_Hands_On_Machine_Learning. indb 223 07/05/2019 17:09:02 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
224 | Capítulo 8: Redução da Dimensionalidade Os melhores kernel e hiperparâmetros estão disponíveis pela variável best_params_ : >>> print(grid_search. best_params_) {'kpca__gamma': 0. 043333333333333335, 'kpca__kernel': 'rbf'} Outra abordagem, desta vez inteiramente não supervisionada, é a seleção do kernel e dos hiperparâmetros que produzem o menor erro de reconstrução. No entanto, a reconstrução não é tão fácil quanto com o PCA linear. V eja o porquê. A Figura 8-11 mostra o conjunto de dados 3D original do rolo suíço (superior esquerdo) e o conjunto de dados 2D resultante utilizando um Kernel RBF após o k PCA ser aplicado (canto superior direito). Graças ao truque do kernel, isto é matematicamente equivalente ao mapeamento do conjunto de treinamento para um espaço de características de dimensão infinita (à direita, abaixo) com a utilização do mapa de características φ, em seguida projetando o conjunto de trei-namento transformado para 2D com o PCA linear. Observe que, se pudéssemos inverter o passo do PCA linear para uma determinada instância no espaço reduzido, o ponto reconstruído ficaria no espaço de característica e não no espaço original (por exemplo, como o representado por um x no diagrama). Uma vez que o espaço de característica é de dimensões infinitas, não podemos calcular o ponto reconstruído e, portanto, não podemos calcular o verdadeiro erro de reconstrução. Felizmente, é possível encontrar um ponto no espaço original que possa mapear perto do ponto reconstruído, o que é chamado de reconstrução da pré-imagem. Depois de ter esta pré-imagem, podemos medir sua distância ao quadrado para a instância original. Podemos, então, selecionar o kernel e os hiperparâmetros que minimizam este erro de reconstrução da pré-imagem. (implícito)Espaço reduzido Espaço original Erro da pré-imagem Reconstrução da pré-imagem Espaço de carac terística Reconstrução Figura 8-11. Kernel PCA e o erro de reconstrução da pré-imagem CG_MIOLO_Hands_On_Machine_Learning. indb 224 07/05/2019 17:09:02 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
LLE | 225Você pode estar se perguntando como realizar essa reconstrução. Uma solução seria treinar um modelo de regressão supervisionado com as instâncias projetadas como o conjunto de treinamento e as instâncias originais como alvos. O Scikit-Learn fará isso automaticamente se você configurar fit_inverse_transform=True, conforme mostrado no código a seguir:7 rbf_pca = Kernel PCA(n_components = 2, kernel="rbf", gamma=0. 0433, fit_inverse_transform=True)X_reduced = rbf_pca. fit_transform(X) X_preimage = rbf_pca. inverse_transform(X_reduced) Por padrão, fit_inverse_transform=False e Kernel PCA não possuem o método inverse_transform(). Este método somente é criado quando você configura fit_inverse_transform=True. Você pode, então, calcular o erro de reconstrução da pré-imagem: >>> from sklearn. metrics import mean_squared_error >>> mean_squared_error(X, X_preimage)32. 786308795766132 Agora, você pode utilizar a grid search com validação cruzada para encontrar o kernel e os hiperparâmetros que minimizem esse erro de reconstrução da pré-imagem. LLE Locally Linear Embedding (LLE)8 (https://goo. gl/i A9bns ) é outra técnica muito pode-rosa de redução da dimensionalidade não linear (NLDR, em inglês). É uma técnica de Manifold Learning que não depende de projeções como os algoritmos anteriores. Em poucas palavras, o LLE trabalha primeiro medindo como cada instância de treinamento se relaciona linearmente com suas vizinhas mais próximas (c. n., em inglês) e, em seguida, procura uma representação de dimensão inferior do conjunto de treinamento na qual esses relacionamentos locais são melhor preservados (mais detalhes em breve). Isso faz com que seja particularmente bom para desenrolar manifolds torcidos, especialmente quando não há muito ruído. Por exemplo, o código a seguir utiliza a classe Locally Linear Embedding do Scikit-Learn para desenrolar o rolo suíço. O conjunto de dados 2D resultante é mostrado na Figura 8-12. Como você pode ver, o rolo suíço é completamente desenrolado e as distâncias 7 O Scikit-Learn utiliza o algoritmo baseado na Regressão de Ridge do Kernel descrito em Gokhan H. Bakır, Jason Weston e Bernhard Scholkopf, “Learning to Find Pre-images” ( http://goo. gl/d0yd Y6 ) (Tubingen, Ale-manha: Max Planck Institute for Biological Cybernetics, 2004). i 8 “Non linear Dimensionality Reduction by Locally Linear Embedding”, S. Roweis, L. Saul (2000). CG_MIOLO_Hands_On_Machine_Learning. indb 225 07/05/2019 17:09:03 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
226 | Capítulo 8: Redução da Dimensionalidadeentre instâncias são bem preservadas localmente. No entanto, em uma escala maior, as distâncias não são preservadas: a parte esquerda desenrolada do rolo suíço é comprimida, enquanto a parte direita está esticada. Porém, o LLE fez um ótimo trabalho na modelagem do manifold. from sklearn. manifold import Locally Linear Embedding lle = Locally Linear Embedding(n_components=2, n_neighbors=10) X_reduced = lle. fit_transform(X) Rolo suíço desenrolado utilizando LLE Figura 8-12. Rolo suíço desenrolado com a utilização do LLE Veja como funciona o LLE: primeiro, para cada instância de treinamento x(i), o algo-ritmo identifica seus k-nearest neighbors mais próximos (no código anterior k = 10) e tenta reconstruir x(i) como uma função linear desses vizinhos. Mais especificamente, ele encontra os pesos wi,j tais que a distância quadrada entre x(i) e seja a menor possível, assumindo que wi,j= 0 se x(j) não seja um dos k-nearest neighbors de x(i). Assim, o primeiro passo do LLE é o problema da otimização restrita descrito na Equação 8-4 em que W é a matriz de peso contendo todos os pesos wi,j. A segunda restrição simplesmente normaliza os pesos para cada instância de treinamento x(i). Equação 8-4. LLE passo 1: modelagem linear de relacionamentos locais W= argmin W∑ i=1m xi-∑ j=1m wi,jxj2 sujeito awi,j=0 sexjnão é um dos kc. n. dexi ∑ j=1m wi,j=1 para i=1,2,,m CG_MIOLO_Hands_On_Machine_Learning. indb 226 07/05/2019 17:09:03 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
Outras Técnicas de Redução da Dimensionalidade | 227Após este passo, a matriz de peso W(que contém os pesos wi, j) codifica as relações lineares locais entre as instâncias de treinamento. Agora, o segundo passo consiste em mapear as instâncias de treinamento em um espaço d-dimensional (em que d < n) preservando essas relações locais ao máximo. Se z(i) é a imagem de x(i) neste espaço d-dimensional, então queremos que a distância ao quadrado entre z(i) e seja a menor possível. Essa ideia leva ao problema da otimização sem restrições descrito na Equação 8-5. Parece muito semelhante ao primeiro passo, mas, em vez de manter as instâncias corrigidas e encontrar os pesos ideais, estamos fazendo o inverso: mantendo os pesos fixos e encontrando a posição ideal das imagens das instâncias no espaço de dimensão inferior. Observe que Z é a matriz que contém todo z(i). Equação 8-5. LLE passo 2: reduz a dimensionalidade enquanto preserva os relacio-namentos Z=argmin Z∑ i=1m zi-∑ j=1m wi,jzj2 As implementação do LLE do Scikit-Learn têm a seguinte complexidade computacional: O(m log(m)n log(k)) para encontrar o k-nearest neighbors, O(mnk3) para otimizar os pesos e O(dm2) para a construção das representações de dimensão inferior. Infelizmente, o m2 no último termo faz com que este algoritmo escalone mal em conjuntos de dados muito grandes. Outras Técnicas de Redução da Dimensionalidade Existem muitas outras técnicas de redução da dimensionalidade, várias das quais estão disponíveis no Scikit-Learn. Veja algumas das mais populares: Escalonamento Multidimentional (MDS, em inglês) reduz a dimensionalidade enquanto tenta preservar as distâncias entre as instâncias (veja a Figura 8-13). Isomap cria um grafo conectando cada instância aos seus k-nearest neighbors, então reduz a dimensionalidade enquanto tenta preservar as distâncias geodésicas9 entre as instâncias. t-Distributed Stochastic Neighbor Embedding (t-SNE) reduz a dimensionalidade ao tentar manter as instâncias semelhantes próximas e instâncias de diferentes tipos separadas. É utilizado principalmente para a visualização, em particular para clusters de instâncias em um espaço de alta dimensão (por exemplo, para visualizar as imagens MNIST em 2D). 9 A distância geodésica entre dois nós em um grafo é o número de nós no caminho mais curto entre esses nós. CG_MIOLO_Hands_On_Machine_Learning. indb 227 07/05/2019 17:09:04 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
228 | Capítulo 8: Redução da Dimensionalidade Análise Discriminante Linear (LDA, em inglês) é, na verdade, um algoritmo de classificação, mas ele assimila os eixos mais discriminativos entre as classes durante o treinamento de forma que esses eixos possam, então, ser utilizados na definição de um hiperplano no qual serão projetados os dados. O benefício é que a projeção manterá as classes o mais distantes possível, então o LDA é uma boa técnica para reduzir a dimensionalidade antes de executar outro algoritmo de classificação, como um classificador SVM. MDS Isoma pt-SNE Figura 8-13. Reduzindo o rolo suíço para 2D com a utilização de várias técnicas Exercícios 1. Quais são as principais motivações para reduzir a dimensionalidade de um conjunto de dados? Quais são as principais desvantagens? 2. O que é a m aldição da dimensionalidade? 3. Uma v ez reduzida a dimensionalidade de um conjunto de dados, é possível reverter a operação? Em caso afirmativo, como? Se não, por quê? 4. O PC A pode ser utilizado para reduzir a dimensionalidade de um conjunto de dados altamente não linear? 5. Suponha que você execute um PCA em um conjunto de dados de mil dimen-sões, definindo a taxa de variância explicada em 95%. Quantas dimensões o conjunto de dados resultante terá? 6. Em qu e casos você usaria o PCA normal, PCA incremental, PCA randomizado ou Kernel PCA? 7. Com o você pode avaliar o desempenho de um algoritmo de redução da dimensio-nalidade em seu conjunto de dados? 8. Faz a lgum sentido juntar dois algoritmos diferentes de redução da dimensionalidade? CG_MIOLO_Hands_On_Machine_Learning. indb 228 07/05/2019 17:09:04 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
Exercícios | 2299. Carregue o conjunto de dados MNIST (introduzido no Capítulo 3) e o divida em um co njunto de treinamento e um conjunto de teste (pegue as primeiras 60 mil instân-cias para treinamento e os 10 mil restantes para teste). Treine um classificador Floresta Aleatória no conjunto de dados, cronometre quanto tempo ele demora, e avalie o mo-delo resultante no conjunto de teste. Em seguida, utilize o PCA para reduzir a dimen-sionalidade no conjunto de dados com uma taxa de variância explicada de 95%. Treine um novo classificador Floresta Aleatória no conjunto de dados reduzido e veja quanto tempo demorou. O treinamento foi muito mais rápido? Em seguida, avalie o classifica-dor no conjunto de testes: como ele se compara ao classificador anterior? 10. Uti lize o t-SNE para reduzir o conjunto de dados MNIST para duas dimensões e plotar o resultado com a utilização do Matplotlib. Você pode utilizar um gráfico de dispersão com dez cores diferentes para representar a classe de destino de cada imagem. Alternativamente, escreva dígitos coloridos no local de cada instância ou até mesmo plote versões reduzidas das próprias imagens dos dígitos (se plotar todos os dígitos sua visualização será muito confusa, então desenhe uma amostra aleatória ou plote uma instância apenas se nenhuma outra já tiver sido plotada a uma distância próxima). Você deve obter uma boa visualização com grupos de dígitos bem separados. Tente utilizar outros algoritmos de redução da dimensio-nalidade como o PCA, LLE ou MDS e compare as visualizações resultantes. Soluções para estes exercícios estão disponíveis no Apêndice A. CG_MIOLO_Hands_On_Machine_Learning. indb 229 07/05/2019 17:09:04 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
CG_MIOLO_Hands_On_Machine_Learning. indb 230 07/05/2019 17:09:04 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
Parte II Redes Neurais e Aprendizado Profundo CG_MIOLO_Hands_On_Machine_Learning. indb 231 07/05/2019 17:09:04 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
CG_MIOLO_Hands_On_Machine_Learning. indb 232 07/05/2019 17:09:04 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
233Capítulo 9 Em Pleno Funcionamento com o Tensor Flow O Tensor Flow é uma poderosa biblioteca de software para cálculo numérico de código aberto especialmente adequada e ajustada para o Aprendizado de Máquina em larga escala. Seu princípio básico é simples: primeiro, você define um grafo de cálculos para executar em Python (por exemplo, o da Figura 9-1) e, em seguida, o Tensor Flow pega esse grafo e o executa de forma eficiente utilizando um código C++ otimizado. Variá vel C onstant e Operação Figura 9-1. Um grafo de cálculo simples Mas o mais importante é ser possível dividir o grafo em vários pedaços e executá-los em paralelo em várias CPUs ou GPUs (como mostrado na Figura 9-2). O Tensor Flow também suporta a computação distribuída para que você possa treinar redes neurais colossais em gigantescos conjuntos de treinamento dividindo os cálculos por centenas de servidores em um período de tempo razoável (veja o Capítulo 12). O Tensor Flow pode treinar uma rede com milhões de parâmetros em um conjunto de treinamento composto por bilhões de instâncias com milhões de características cada. Isso não deve ser uma surpresa, já que o Tensor Flow foi desenvolvido pela equipe do Google Brain e alimenta muitos dos serviços em grande escala do Google, como Google Cloud Speech, Google Fotos e o Google Search. CG_MIOLO_Hands_On_Machine_Learning. indb 233 07/05/2019 17:09:04 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
234 | Capítulo 9: Em Pleno Funcionamento com o Tensor Flow GPU 2 GPU 1 Figura 9-2. Computação paralela em várias CPUs/GPUs/servidores Quando o código do Tensor Flow foi aberto em novembro de 2015, já existiam muitas bibliotecas populares de código aberto para o Aprendizado Profundo (a Tabela 9-1 lista algumas), e, para ser sincero, a maioria dos recursos do Tensor Flow já existiam em uma ou outra biblioteca. No entanto, seu design limpo, a escalabilidade, a flexibilidade1 e uma ótima documentação (sem mencionar o nome do Google) rapidamente o alçaram ao topo da lista. Em suma, o Tensor Flow foi projetado para ser flexível, escalável e pronto para produção, e os frameworks existentes, sem dúvida, atingiram apenas dois dos três itens citados. Estes são alguns destaques do Tensor Flow: Ele r oda não apenas no Windows, Linux e Mac OS, mas também em dispositivos móveis, incluindo i OS e Android; Ele f ornece uma API Python muito simples chamada TF. Learn2 (tensorflow. con trib. learn ) compatível com o Scikit-Learn. Como você verá, com apenas algumas linhas de código ele poderá ser utilizado para treinar vários tipos de redes neurais. Anteriormente, era um projeto independente chamado Scikit Flow (ou skflow ); 1 O Tensor Flow não se limita às redes neurais ou mesmo ao Aprendizado de Máquina; você poderia executar simulações de física quântica se quisesse. 2 Não c onfundir com a biblioteca TFLearn, que é um projeto independente. CG_MIOLO_Hands_On_Machine_Learning. indb 234 07/05/2019 17:09:04 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
Em Pleno Funcionamento com o Tensor Flow | 235 Ele também fornece outra API simples chamada TF-slim (tensorflow. contrib. slim ) para simplificar a construção, o treinamento e a avaliação de redes neurais; Vár ias outras APIs de alto nível foram construídas independentemente com base no Tensor Flow, como o Keras (http://keras. io ) (disponível em tensorflow. con trib. keras ) ou o P ret ty Tensor (https://github. com/google/prettytensor/ ); Sua p rincipal API do Python oferece muito mais flexibilidade (ao custo da maior complexidade) para criar vários tipos de cálculos, incluindo qualquer arquitetura de rede neural em que você possa pensar; Ele i nclui implementações C++ altamente eficientes de muitas operações do AM, par-ticularmente aquelas necessárias para construir redes neurais. Há também uma API C++ para definir suas próprias operações de alto desempenho; Ele f ornece vários nós de otimização avançados para procurar por parâmetros que minimizam uma função de custo. Usá-los é muito fácil, uma vez que o Tensor Flow cuida automaticamente do cálculo dos gradientes das funções que você define. Isto é chamado diferenciação automática (ou autodiff ). Ele também vem com uma grande ferramenta de visualização chamada Tensor Board que permite navegar pelo grafo de computação, ver curvas de apren-dizado e muito mais; O Go ogle também lançou um serviço em nuvem para rodar os grafos do Tensor Flow ( https://cloud. google. com/ml ); Por ú ltimo, mas não menos importante, ele tem uma equipe dedicada de desen-volvedores apaixonados e colaborativos, e uma comunidade crescente, que con-tribuem para melhorá-lo. É um dos projetos de código aberto mais populares no Git Hub, e cada vez mais estão sendo construídos grandes projetos a partir dele (para exemplos, confira as páginas de recursos em https://www. tensorf low. org/, ou https://github. com/jtoy/awesome-tensorflow ). Para questões técnicas, você deve usar http://stackoverflow. com/ e marcar sua pergunta com “tensorflow”. No Git Hub, você pode arquivar erros e solicitações de recursos. Para discussões gerais, junte-se ao grupo do Google ( http://goo. gl/N7k RF9 ). Neste capítulo, analisaremos os conceitos básicos do Tensor Flow, desde a instalação até a criação, execução, gravação e visualização de grafos de cálculos simples. É importante o domínio desses princípios antes de construir sua primeira rede neural (o que faremos no próximo capítulo). CG_MIOLO_Hands_On_Machine_Learning. indb 235 07/05/2019 17:09:05 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
236 | Capítulo 9: Em Pleno Funcionamento com o Tensor Flow Tabela 9-1. Bibliotecas de Aprendizado Profundo de código aberto (não é uma lista completa) Biblioteca API Plataformas Iniciado por Ano Caffe Python, C++, Matlab Linux, mac OS, Windows Y. Jia, UC Berkeley (BVLC) 2013 Deeplearning4j Java, Scala, Clojure Linux, mac OS, Windows, Android A. Gibson, J. Patterson 2014 H2O Python, R Linux, mac OS, Windows H2O. ai 2014 MXNet Python, C++, others Linux, mac OS, Windows, i OS, Android DMLC 2015 Tensor Flow P y thon, C++ Linux, mac OS, Windows, i OS, Android Google 2015 Theano Python Linux, mac OS, i OS Universidade de Montreal 2010 Torch C++, Lua Linux, mac OS, i OS, Android R. Collobert, K. Kavukcuoglu, C. Farabet2002 Instalação Vamos começar! Supondo que, seguindo as instruções de instalação no Capítulo 2, você instalou o Jupyter e o Scikit-Learn, você pode simplesmente utilizar o pip para instalar o Tensor Flow. Criou-se um ambiente isolado utilizando o virtualenv, primeiro você precisa ativá-lo: $ cd $ML_PATH # O diretório de seu AM (por ex., $HOME/ml)$ source env/bin/activate Em seguida, instale o Tensor Flow (se você não estiver utilizando um virtualenv, precisará de direitos de administrador ou adicionar a opção--user ): $ pip3 install--upgrade tensorflow Para o suporte a GPU, você precisa instalar o tensorflow-gpu em vez do tensorflow. Consulte o Capítulo 12 para obter mais detalhes. Para testar sua instalação, digite o comando abaixo, que deve exibir a versão do Tensor Flow que você instalou. $ python3-c 'import tensorflow; print(tensorflow. __version__)'1. 3. 0 CG_MIOLO_Hands_On_Machine_Learning. indb 236 07/05/2019 17:09:05 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
Criando Seu Primeiro Grafo e o Executando em uma Sessão | 237Criando Seu Primeiro Grafo e o Executando em uma Sessão O código a seguir cria o grafo representado na Figura 9-1: import tensorflow as tf x = tf. Variable(3, name="x") y = tf. Variable(4, name="y") f = x*x*y + y + 2 E isso é tudo por enquanto! O mais importante a se entender é que este código na verdade não realiza cálculo algum, embora pareça fazê-lo (especialmente a última linha). Ele apenas cria um grafo de cálculo. Na verdade, mesmo as variáveis ainda não foram inicializadas. Para avaliar este grafo, você precisa abrir uma sessão do Tensor Flow e utilizá-la para inicializar as variáveis e avaliar f. Uma sessão do Tensor Flow trata de colocar as operações em dispositivos como CPUs e GPUs e executá-las, e contém todos os valores das variáveis. 3 O código a seguir cria uma sessão, inicializa as variáveis, as avalia, e então f encerra a sessão (o que libera recursos): >>> sess = tf. Session() >>> sess. run(x. initializer) >>> sess. run(y. initializer) >>> result = sess. run(f)>>> print(result) 42 >>> sess. close() Ter que repetir sess. run() todas as vezes é um pouco complicado, mas felizmente há uma forma melhor: with tf. Session() as sess: x. initializer. run() y. initializer. run() result = f. eval() A sessão é configurada como padrão dentro do bloco with. Chamar x. initializer. run() é equivalente a chamar tf. get_default_session(). run(x. initia-lizer), assim como f. eval() é equivalente a chamar tf. get_default_session(). run(f), facilitando a leitura do código. Além do mais, a sessão é encerrada automaticamente ao final do bloco. Você pode utilizar a função global_variables_initializer() em vez de executar ma-nualmente o inicializador para cada variável. Observe que ela não executa a inicialização imediatamente, mas cria um nó no grafo que inicializará todas as variáveis quando esta for executada: 3 No Tensor Flow distribuído os valores das variáveis são armazenados nos servidores em vez de na sessão, como veremos no Capítulo 12. CG_MIOLO_Hands_On_Machine_Learning. indb 237 07/05/2019 17:09:06 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
238 | Capítulo 9: Em Pleno Funcionamento com o Tensor Flowinit = tf. global_variables_initializer() # prepara um nó init with tf. Session() as sess: init. run() # na verdade, inicializa todas as variáveis result = f. eval() Dentro do Jupyter, ou dentro de um shell do Python, você pode preferir criar uma Interactive Session. Sua única diferença em relação a uma Session regular é que, quando é criada, ela automaticamente se configura como uma sessão padrão, então você não precisa de um bloco with (mas é necessário encerrar a sessão manualmente ao terminar): >>> sess = tf. Interactive Session() >>> init. run()>>> result = f. eval()>>> print(result) 42 >>> sess. close() Um programa Tensor Flow normalmente é dividido em duas partes: a primeira cria um gráfico de cálculo (isto é chamado de fase de construção ), e a segunda o executa (esta é a fase de execução ). A fase de construção geralmente constrói um grafo de cálculo que representa o modelo AM e os cálculos necessários para treiná-lo. A fase de execução geralmente executa um loop que avalia repetidamente um passo do treinamento (por exemplo, um passo por minilote), melhorando gradualmente os parâmetros do modelo. Veremos um exemplo em breve. Gerenciando Grafos Qualquer nó que você crie é adicionado automaticamente ao grafo padrão: >>> x1 = tf. Variable(1) >>> x1. graph is tf. get_default_graph() True Na maioria dos casos isso é bom, mas, às vezes, pode ser que você queira gerenciar vá-rios grafos independentes, o que pode ser feito por meio da criação de um novo Graph tornando-o temporariamente o grafo padrão dentro de um bloco with : >>> graph = tf. Graph() >>> with graph. as_default():... x2 = tf. Variable(2)... >>> x2. graph is graph True >>> x2. graph is tf. get_default_graph() False CG_MIOLO_Hands_On_Machine_Learning. indb 238 07/05/2019 17:09:06 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
Ciclo de Vida de um Valor do Nó | 239No Jupyter (ou em uma shell do Python), é comum executar os mes-mos comandos mais de uma vez durante a fase de experimentação. Como resultado, você pode acabar com um grafo padrão contendo muitos nós duplicados. Uma soluç ão é reiniciar o kernel Jupyter (ou o shell do Python), mas uma solução mais conveniente é resetar o grafo padrão executando tf. reset_default_graph(). Ciclo de Vida de um Valor do Nó Quando você avalia um nó, o Tensor Flow determina automaticamente o conjunto de nós dependentes e os avalia primeiro. Por exemplo, considere o código a seguir: w = tf. constant(3) x = w + 2 y = x + 5 z = x * 3 with tf. Session() as sess: print(y. eval()) # 10 print(z. eval()) # 15 Primeiro, este código define um grafo muito simples. Em seguida, ele inicia uma sessão e executa o grafo para avaliar y: o Tensor Flow automaticamente detecta que y depende de x, que depende de w, então ele primeiro avalia w, então x, depois y, e retorna o valor de y. Finalmente, o código executa o grafo para avaliar z. Mais uma vez, o Tensor Flow detecta que ele deve primeiro avaliar w e x. É importante notar que ele não reutilizará o resultado das avaliações prévias de w e x. Em suma, o código anterior avalia duas vezes w e x. Todos os valores do nó são descartados entre as execuções dos grafos, exceto os valores das variáveis que são mantidas na sessão pela execução dos grafos (queues e readers também mantêm algum estado, como veremos no Capítulo 12). Uma variável começa sua vida quando seu inicializador é executado e termina quando a sessão é encerrada. Se você quiser avaliar y e z eficientemente, sem avaliar w e x duas vezes como no có-digo anterior, deve pedir ao Tensor Flow para avaliar tanto y quanto z em apenas uma execução do grafo, como mostrado no código a seguir: with tf. Session() as sess: y_val, z_val = sess. run([y, z]) print(y_val) # 10 print(z_val) # 15 CG_MIOLO_Hands_On_Machine_Learning. indb 239 07/05/2019 17:09:06 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
240 | Capítulo 9: Em Pleno Funcionamento com o Tensor Flow Em um processo único do Tensor Flow, as múltiplas sessões não compartilham de nenhum estado, mesmo se reutilizarem grafos similares (cada sessão teria sua própria cópia de cada variável). No Tensor Flow distribuído (ver Capítulo 12), o estado da variável é armazenado nos servidores, não nas sessões, então as múltiplas sessões podem compartilhar as mesmas varáveis. Regressão Linear com o Tensor Flow As operações do Tensor Flow (também chamadas de ops) podem pegar quaisquer nú-meros de entradas e produzir quaisquer números de saídas. Por exemplo, as operações de adição e multiplicação tomam duas entradas e produzem uma saída. Constantes e variáveis não tomam nenhuma entrada (elas são chamadas de source ops ). A s entradas e saídas são arrays multidimensionais chamados tensores (daí o nome “fluxo do tensor”, tradução literal de tensor flow ). Assim como os arrays Num Py, os tensores têm um tipo e uma forma. Na verdade, os tensores da API do Python são simplesmente representados por arrays Num Py. Eles geralmente contêm floats, mas você também pode utilizá-los para carregar strings (arrays de bytes arbitrários). Nos exemplos vistos, os tensores apenas continham um único valor escalar, mas você pode, obviamente, executar cálculos em arrays de qualquer forma. Por exemplo, o código a seguir manipula arrays 2D para executar a Regressão Linear no conjunto de dados imobiliários da Califórnia (introduzido no Capítulo 2). Começa pela busca do conjunto de dados; então adiciona uma característica de entrada de viés extra ( x0 = 1) a todas as instâncias de treinamento utilizando o Num Py para que possa ser executado imediatamente; então cria dois nós constantes do Tensor Flow, X e y, para segurar estes dados e os alvos,4 e utiliza algumas das operações da matriz fornecidas pelo Tensor Flow para definir theta. Essas funções de matriz — transpose(), matmul() e matrix_inver-se() — são autoexplicativas, mas, como de costume, elas não realizam nenhum cálculo imediatamente; em vez disso, elas criam nós no grafo que irão executá-las quando este for executado. Você deve reconhecer que a definição de theta corresponde ao Método dos Mínimos Quadrados ( θ= (XT · X)-1 · XT · y; veja o Capítulo 4). Finalmente, o código cria uma sessão e a utiliza para avaliar theta. 4 Note que h ousing. target é um array 1D, mas precisamos remodelá-lo para um vetor de coluna para calcular theta. Recorde que a função reshape() do Num Py aceita-1 (significando “unspecified”) para uma das dimensões: essa dimensão será calculada com base no comprimento do array e nas demais dimensões. CG_MIOLO_Hands_On_Machine_Learning. indb 240 07/05/2019 17:09:07 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
Implementando o Gradiente Descendente | 241import numpy as np from sklearn. datasets import fetch_california_housing housing = fetch_california_housing() m, n = housing. data. shape housing_data_plus_bias = np. c_[np. ones((m, 1)), housing. data] X = tf. constant(housing_data_plus_bias, dtype=tf. float32, name="X") y = tf. constant(housing. target. reshape(-1, 1), dtype=tf. float32, name="y") XT = tf. transpose(X) theta = tf. matmul(tf. matmul(tf. matrix_inverse(tf. matmul(XT, X)), XT), y) with tf. Session() as sess: theta_value = theta. eval() O principal benefício deste código em relação ao Método dos Mínimos Quadrados di-retamente no Num Py é que o Tensor Flow executará isso automaticamente no seu cartão GPU, se você tiver um (desde que tenha instalado o Tensor Flow com suporte a GPU, é claro, veja o Capítulo 12 para mais detalhes). Implementando o Gradiente Descendente Tentaremos usar o Gradiente Descendente em Lote (introduzido no Capítulo 4) em vez do Método dos Mínimos Quadrados. Primeiro, faremos isso calculando manualmente os gradientes, então utilizaremos o recurso autodiff para permitir que o Tensor Flow calcule os gradientes automaticamente e, finalmente, utilizaremos alguns otimizadores inusitados do Tensor Flow. Ao utilizar o Gradiente Descendente, lembre-se que é importante primeiro normalizar os vetores das características de entrada, ou o treinamento pode ficar muito mais lento. V ocê pode fazer isso utili-zando o Tensor Flow, Num Py, Standard Scaler do Scikit-Learn, ou qualquer outra solução que você preferir. O código a seguir assume que esta normalização já foi feita. Calculando Manualmente os Gradientes O código a seguir deve ser bem autoexplicativo, exceto por alguns novos elementos: A fun ção random_uniform() cria um nó no grafo que gerará um tensor contendo valores aleatórios, dado sua forma e faixa de valor, bem parecido com a função rand() do Num Py; A fun ção assign() cria um nó que atribuirá um novo valor a uma variável. Neste caso, ela implementa o passo θ(next step) = θ-η∇θMSE( θ) do Gradiente Descendente em Lote; CG_MIOLO_Hands_On_Machine_Learning. indb 241 07/05/2019 17:09:07 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
242 | Capítulo 9: Em Pleno Funcionamento com o Tensor Flow O loop principal executa o passo de treinamento repetidamente ( n_epochs vezes), e a cada 100 iterações imprime o Erro Médio Quadrado atual ( mse). Você deve ver o MSE diminuir a cada iteração. n_epochs = 1000 learning_rate = 0. 01 X = tf. constant(scaled_housing_data_plus_bias, dtype=tf. float32, name="X") y = tf. constant(housing. target. reshape(-1, 1), dtype=tf. float32, name="y") theta = tf. Variable(tf. random_uniform([n + 1, 1],-1. 0, 1. 0), name="theta") y_pred = tf. matmul(X, theta, name="predictions") error = y_pred-y mse = tf. reduce_mean(tf. square(error), name="mse") gradients = 2/m * tf. matmul(tf. transpose(X), error) training_op = tf. assign(theta, theta-learning_rate * gradients) init = tf. global_variables_initializer() with tf. Session() as sess: sess. run(init) for epoch in range(n_epochs): if epoch % 100 == 0: print("Epoch", epoch, "MSE =", mse. eval()) sess. run(training_op) best_theta = theta. eval() Utilizando o autodiff O código anterior funciona bem, mas requer uma derivação matemática dos gradientes da função de custo (MSE). No caso da Regressão Linear, é razoavelmente fácil, mas provocaria muitas dores de cabeça se você tivesse que fazer isso com redes neurais profundas: seria tedioso e propenso a erros. Você poderia utilizar a diferenciação simbólica para encontrar automaticamente as equações para as derivadas parciais, mas o código resultante não seria necessariamente muito eficiente. Para entender o porquê, considere a função f (x)= exp(exp(exp( x))). Se você conhece cál-culo, pode descobrir sua derivada f ′(x) = exp( x) × exp(exp( x)) × exp(exp(exp( x))). Se você codificar separadamente f (x) e f′(x) exatamente como elas aparecem, seu código não será tão eficiente como poderia ser. Uma solução mais eficiente seria escrever uma função que calcule primeiro exp( x), depois exp(exp( x)), depois exp(exp(exp( x))), e retorne todas as três. Isto lhe dá diretamente f(x) (o terceiro termo), e, se você precisar da derivada, pode apenas multiplicar os três termos e pronto. Com uma naive approach, você precisaria chamar a função exp nove vezes para o cálculo de f (x) e f′(x). Com esta abordagem, você precisa chamá-la apenas três vezes. CG_MIOLO_Hands_On_Machine_Learning. indb 242 07/05/2019 17:09:07 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
Implementando o Gradiente Descendente | 243Isto piora quando sua função for definida por algum código arbitrário. Você consegue encontrar a equação (ou o código) para calcular as derivadas parciais da seguinte fun-ção? Dica: nem tente. def my_func(a, b): z = 0 for i in range(100): z = a * np. cos(z + i) + z * np. sin(b-i) return z Felizmente, o recurso autodiff do Tensor Flow vem ao resgate: ele pode calcular au-tomática e eficientemente os gradientes para você. Simplesmente substitua a linha gradients =... no código do Gradiente Descendente na sessão anterior pela seguinte linha e o código continuará a funcionar bem: gradients = tf. gradients(mse, [theta])[0] A função gradients() pega uma op (neste caso mse) e uma lista de variáveis (neste caso apenas theta ), e cria uma lista de ops (uma por variável) para calcular os gradientes de op com relação a cada variável. Assim, o nó gradients calculará o vetor gradiente do MSE com relação à theta. Existem quatro abordagens principais para o cálculo automático de gradientes. Elas estão resumidas na Tabela 9-2. O Tensor Flow utiliza reverse-mode autodiff, que é perfeito (eficiente e preciso) quando existem muitas entradas e poucas saídas, como geralmente é o caso nas redes neurais. Ele calcula todas as derivadas parciais das saídas em relação a todas as entradas em apenas noutputs + 1 travessias em grafo. Tabela 9-2. Principais soluções para calcular gradientes automaticamente Técnica Nº de travessias em grafo para calcular todos os gradientes Acurácia Suporta código arbitrário Comentário Diferenciação Numérican inputs + 1 Baixa Sim Implementação trivial Difere nciaç ão Simbólica N/A Alta Não Constrói um grafo muito diferente Modo Avançado autodiffn inputs Alta Sim Utiliza dual numbers Modo reverso autodiffn outputs + 1 Alto Sim Implementado pelo Tensor Flow Se vo cê se interessa em saber como funciona esta mágica, verifique o Apêndice D. CG_MIOLO_Hands_On_Machine_Learning. indb 243 07/05/2019 17:09:08 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
244 | Capítulo 9: Em Pleno Funcionamento com o Tensor Flow Utilizando um Otimizador O Tensor Flow calcula os gradientes para você. Mas fica ainda mais fácil: ele também fornece uma série de otimizadores inusitados, incluindo um otimizador de Gradiente Descendente. Você pode simplesmente substituir as linhas anteriores gradients =... e training_op =... pelo código a seguir e, mais uma vez, tudo funcionará bem: optimizer = tf. train. Gradient Descent Optimizer(learning_rate=learning_rate) training_op = optimizer. minimize(mse) Se você deseja utilizar um tipo diferente de otimizador, basta alterar uma linha. Por exemplo, utilize um otimizador momentum (que, muitas vezes, converge bem mais rá-pido do que o Gradiente Descendente, veja o Capítulo 11) definindo o otimizador assim: optimizer = tf. train. Momentum Optimizer(learning_rate=learning_rate, momentum=0. 9) Fornecendo Dados ao Algoritmo de Treinamento Tentaremos modificar o código anterior para implementar o Gradiente Descendente em Minilote. Para isso, precisamos de uma forma de substituir X e y em cada iteração com o próximo minilote. A maneira mais simples de fazer isso é utilizar nós placeholders. Esses nós são especiais porque eles, na verdade, não executam nenhum cálculo, apenas exibem os dados que você os manda exibir em tempo de execução. Eles geralmente são utilizados durante o treinamento para passar os dados de treinamento para o Tensor Flow. Se você não especificar um valor para um placeholder em tempo de execução, terá uma exceção. Para criar um nó placeholder, você precisa chamar a função placeholder() e especificar o tipo de saída dos dados do tensor. Como opção, você também pode especificar sua forma se quiser reforçá-la. Especificar None para uma dimensão significa “qualquer tamanho”. Por exemplo, o código a seguir cria um nó placeholder A e também um nó B = A + 5. Quando avaliamos B, passamos um método feed_dict para o método eval(), que especifica o valor de A. Observe que A deve ter classificação 2 (ou seja, ele deve ser bidimensional) e deve ter três colunas (ou então uma exceção é levantada), mas pode ter qualquer número de linhas. >>> A = tf. placeholder(tf. float32, shape=(None, 3)) >>> B = A + 5 >>> with tf. Session() as sess:... B_val_1 = B. eval(feed_dict={A: [[1, 2, 3]]})... B_val_2 = B. eval(feed_dict={A: [[4, 5, 6], [7, 8, 9]]})... >>> print(B_val_1) [[ 6. 7. 8. ]]>>> print(B_val_2)[[ 9. 10. 11. ] [ 12. 13. 14. ]] CG_MIOLO_Hands_On_Machine_Learning. indb 244 07/05/2019 17:09:08 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
Salvando e Restaurando Modelos | 245Você pode fornecer o resultado de quaisquer operações, não apenas placeholders. Neste caso, o Tensor Flow não tenta avaliar essas ope-rações; ele utiliza os valores que você fornece. Para implementar o Gradiente Descendente em Minilote, só precisamos ajustar ligei-ramente o código existente. Primeiro, altere a definição de X e y na fase de construção para torná-los nós placeholders: X = tf. placeholder(tf. float32, shape=(None, n + 1), name="X") y = tf. placeholder(tf. float32, shape=(None, 1), name="y") Em seguida, defina o tamanho do lote e calcule o número total de lotes: batch_size = 100 n_batches = int(np. ceil(m / batch_size)) Finalmente, na fase de execução, pegue os minilotes um a um e forneça o valor de X e y por meio do parâmetro feed_dict ao avaliar um nó que dependa deles. def fetch_batch(epoch, batch_index, batch_size): [... ] # carrega os dados do disco return X_batch, y_batch with tf. Session() as sess: sess. run(init) for epoch in range(n_epochs): for batch_index in range(n_batches): X_batch, y_batch = fetch_batch(epoch, batch_index, batch_size) sess. run(training_op, feed_dict={X: X_batch, y: y_batch}) best_theta = theta. eval() Não precisamos passar o valor de X e y ao avaliar theta já que ela não depende de nenhum deles. Salvando e Restaurando Modelos Depois de ter treinado seu modelo, você deve salvar seus parâmetros no disco para que possa voltar a eles sempre que quiser utilizá-los em outro programa, compará-los com outros modelos e assim por diante. Além disso, é importante salvar pontos de verificação em intervalos regulares durante o treinamento, de modo que, se o seu computador travar durante o treinamento, você poderá continuar a partir do último ponto de verificação em vez de começar de novo. CG_MIOLO_Hands_On_Machine_Learning. indb 245 07/05/2019 17:09:08 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
246 | Capítulo 9: Em Pleno Funcionamento com o Tensor Flow É muito fácil salvar e restaurar um modelo no Tensor Flow. Basta criar um nó Saver no final da fase de construção (após a criação de todos os nós de variáveis); em seguida, chamar seu método save() sempre que quiser salvar o modelo, passando a sessão e o caminho do arquivo do ponto de verificação na fase de execução: [... ] theta = tf. Variable(tf. random_uniform([n + 1, 1],-1. 0, 1. 0), name="theta") [... ] init = tf. global_variables_initializer() saver = tf. train. Saver() with tf. Session() as sess: sess. run(init) for epoch in range(n_epochs): if epoch % 100 == 0: # checkpoint every 100 epochs save_path = saver. save(sess, "/tmp/my_model. ckpt") sess. run(training_op) best_theta = theta. eval() save_path = saver. save(sess, "/tmp/my_model_final. ckpt")[... ] theta = tf. Variable(tf. random_uniform([n + 1, 1],-1. 0, 1. 0), name="theta") [... ] init = tf. global_variables_initializer() saver = tf. train. Saver() with tf. Session() as sess: sess. run(init) for epoch in range(n_epochs): if epoch % 100 == 0: # checkpoint every 100 epochs save_path = saver. save(sess, "/tmp/my_model. ckpt") sess. run(training_op) best_theta = theta. eval() save_path = saver. save(sess, "/tmp/my_model_final. ckpt") Restaurar um modelo é fácil: como anteriormente, você cria um Saver ao final da fase de construção, mas, utilizando o nó init no início da fase de execução, você chama o método restore() do objeto Saver em vez de inicializar as variáveis: with tf. Session() as sess: saver. restore(sess, "/tmp/my_model_final. ckpt") [... ] Por padrão, um Saver salva e restaura todas as variáveis com seu próprio nome, mas, se você precisar de mais controle, pode especificar quais as variáveis a serem salvas ou restauradas e quais nomes utilizar. Por exemplo, o Saver a seguir vai salvar ou restaurar somente a variável theta com o nome weights : saver = tf. train. Saver({"weights": theta}) Por padrão, o método save() também salva a estrutura do grafo em um segundo ar-quivo com o mesmo nome mais a extensão. meta. Você pode carregar esta estrutura do grafo utilizando tf. train. import_meta_graph(), adicionando o grafo ao grafo padrão e retornando uma instância Saver que você pode utilizar para restaurar o estado do grafo (ou seja, os valores das variáveis): saver = tf. train. import_meta_graph("/tmp/my_model_final. ckpt. meta") with tf. Session() as sess: saver. restore(sess, "/tmp/my_model_final. ckpt") [... ] Isso permite que você restaure completamente um modelo salvo, incluindo a estrutura do grafo e os valores das variáveis sem ter que procurar o código que o construiu. CG_MIOLO_Hands_On_Machine_Learning. indb 246 07/05/2019 17:09:09 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
Visualização do Grafo e Curvas de Treinamento com o Tensor Board | 247Visualização do Grafo e Curvas de Treinamento com o Tensor Board Agora temos um grafo de cálculo que treina um modelo de Regressão Linear utilizan-do o Gradiente Descendente em Minilotes, e estamos salvando pontos de verificação em intervalos regulares. Soa sofisticado, não? No entanto, ainda confiamos na função print() para visualizar o progresso durante o treinamento. Existe um jeito melhor: digite Tensor Board, que exibirá visualizações interativas agradáveis dessas estatísticas em seu navegador (por exemplo, curvas de aprendizado) se você fornecer algumas estatísticas de treinamento. Você também pode fornecer a definição do grafo e ele lhe dará uma ótima interface para navegação, o que é muito útil para identificar erros no grafo, encontrar pontos de estrangulamento e assim por diante. O primeiro passo é ajustar um pouco seu programa para que ele escreva a definição do grafo e algumas estatísticas de treinamento — por exemplo, o erro de treinamento (MSE) — para um diretório de logs que o Tensor Board lerá. Você precisa utilizar um dire-tório de log diferente a cada vez que executa o programa senão o Tensor Board mesclará estatísticas a cada execução diferente, o que bagunçará as visualizações. A solução mais simples é incluir um timestamp no nome do diretório do log. Adicione o código a seguir no início do programa: from datetime import datetime now = datetime. utcnow(). strftime("%Y%m%d%H%M%S") root_logdir = "tf_logs" logdir = "{}/run-{}/". format(root_logdir, now) A seguir, adicione o código abaixo no final da fase de construção: mse_summary = tf. summary. scalar('MSE', mse) file_writer = tf. summary. File Writer(logdir, tf. get_default_graph()) A primeira linha cria um nó no grafo que avaliará o valor MSE e o escreverá em uma string de log binário chamada de summary, compatível com o Tensor Board. A segunda linha cria um File Writer que utilizaremos para escrever resumos nos arquivos de log no diretório de logs. O primeiro parâmetro indica o caminho do diretório de log (neste caso, algo como tf_logs/run-20160906091959/, relativo ao diretório atual). O segundo parâmetro (opcional) é o grafo que você visualizará. Na criação, o File Writer cria o diretório de log caso ele ainda não exista (e seus diretórios pais, se necessário), e escreve a definição do grafo em um arquivo de log binário chamado de events file. Depois, durante o treinamento, você precisa atualizar a fase de execução para avaliar regularmente o nó mse_summary (por exemplo, a cada 10 minilotes). Isso produzirá um CG_MIOLO_Hands_On_Machine_Learning. indb 247 07/05/2019 17:09:09 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
248 | Capítulo 9: Em Pleno Funcionamento com o Tensor Flowresumo do que você pode, então, escrever no arquivo de eventos usando o file_writer. Veja o código atualizado: for batch_index in range(n_batches): X_batch, y_batch = fetch_batch(epoch, batch_index, batch_size) if batch_index % 10 == 0: summary_str = mse_summary. eval(feed_dict={X: X_batch, y: y_batch}) step = epoch * n_batches + batch_index file_writer. add_summary(summary_str, step) sess. run(training_op, feed_dict={X: X_batch, y: y_batch}) [... ] Evite registrar estatísticas de treinamento em cada etapa de treina-mento pois isso reduzirá sua velocidade significativamente. Finalmente, encerre o File Writer ao final do programa: file_writer. close() Agora, execute-o: ele criará o diretório de log e escreverá um arquivo de eventos nele contendo a definição do grafo e os valores MSE. Abra uma shell e vá até seu diretório de trabalho e digite ls-l tf _ logs/run* para listar o conteúdo do diretório de logs: $ cd $ML_PATH # Seu diretório do AM (por ex., $HOME/ml) $ ls-l tf_logs/run* total 40-rw-r--r--1 ageron staff 18620 Sep 6 11:10 events. out. tfevents. 1472553182. mymac Se você executar o programa uma segunda vez, você deve encontrar um segundo diretório no diretório tf_logs/ : $ ls-l tf_logs/ total 0 drwxr-xr-x 3 ageron staff 102 Sep 6 10:07 run-20160906091959 drwxr-xr-x 3 ageron staff 102 Sep 6 10:22 run-20160906092202 Muito bem! Agora é hora de abrir o servidor do Tensor Board. Você precisa ativar o seu ambiente virtualenv caso tenha criado um, então iniciar o servidor executando o comando tensor board apontando para o diretório raiz do log, e assim iniciando o servidor web Tensor Board pela porta 6006 (que é “goog” escrito de cabeça para baixo): $ source env/bin/activate $ tensorboard--logdir tf_logs/ Starting Tensor Board on port 6006 (You can navigate to http://0. 0. 0. 0:6006) A seguir, abra um navegador e digite http://0. 0. 0. 0:6006/ (ou http://localhost:6006/ ). Bem vindo ao Tensor Board! Na aba Events, você deve ver o MSE à direita. Ao clicar nele, verá uma plotagem do MSE durante o treinamento para ambas as execuções (Figura 9-3). Vo cê CG_MIOLO_Hands_On_Machine_Learning. indb 248 07/05/2019 17:09:10 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
Visualização do Grafo e Curvas de Treinamento com o Tensor Board | 249pode marcar ou desmarcar as execuções que queira visualizar, dar um zoom in ou out, passar o cursor sobre a curva para obter detalhes, e assim por diante. Figura 9-3. Visualizando estatísticas de treinamento utilizando o Tensor Board Agora, clique na aba Graphs. Você deve ver o grafo mostrado na Figura 9-4. Para reduzir a confusão, os nós que têm muitas bordas (ou seja, conexões para outros nós) são separados em uma área auxiliar à direita (você pode mover um nó para frente e para trás entre o grafo principal e a área auxiliar clicando nele com o botão direito do mouse). Algumas partes do grafo também são colapsadas por padrão. Por exemplo, tente passar o mouse pelo nó gradients, clique no ícone ⊕ para expandir este subgrafo. A seguir, neste subgrafo, tente expandir o subgrafo mse_grad. Figura 9-4. Visualizando o grafo com a utilização do Tensor Board CG_MIOLO_Hands_On_Machine_Learning. indb 249 07/05/2019 17:09:10 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
250 | Capítulo 9: Em Pleno Funcionamento com o Tensor Flow Se quiser dar uma olhada no grafo diretamente dentro do Jupyter, utili-ze a função show_graph() disponível no notebook para este capítulo. Ela foi escrita originalmente por A. Mordvintsev em seu grande tutorial de notebook ( http://goo. gl/Et CWUc ). Outra opção é instalar a ferramenta de debug do Tensor Flow de E. Jang ( https://github. com/ericjang/tdb ) que inclui uma extensão do Jupyter para a visualização de grafos (e mais). Escopos do Nome O grafo pode facilmente ficar confuso com os milhares de nós ao lidar com modelos mais complexos como as redes neurais. Para evitar isso, crie escopos do nome para agrupar nós relacionados. Por exemplo, vamos modificar o código anterior para definir o ops error e mse dentro de um escopo do nome chamado “loss” : with tf. name_scope("loss") as scope: error = y_pred-y mse = tf. reduce_mean(tf. square(error), name="mse") O nome de cada op definido dentro do escopo agora é prefixado com “loss/” : >>> print(error. op. name) loss/sub >>> print(mse. op. name) loss/mse Os nós mse e error aparecem agora dentro do escopo de nomes loss no Tensor Board, que aparece colapsado por padrão (Figura 9-5). gradiente s perdatheta theta Gradiente... 6 tensors Previsões Figura 9-5. Um escopo do nome colapsado no Tensor Board CG_MIOLO_Hands_On_Machine_Learning. indb 250 07/05/2019 17:09:11 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
Modularidade | 25 1Modularidade Suponha que você queira criar um grafo que adicione a saída de duas unidades lineares retificadas (Re LU). Um Re LU calcula uma função linear das entradas e exibe o resultado se for positivo, e 0 caso contrário, como mostrado na Equação 9-1. Equação 9-1. Unidade linear retificada hw,b X= max X·w+b,0 O código a seguir cumpre esta função, mas é bem repetitivo: n_features = 3 X = tf. placeholder(tf. float32, shape=(None, n_features), name="X") w1 = tf. Variable(tf. random_normal((n_features, 1)), name="weights1") w2 = tf. Variable(tf. random_normal((n_features, 1)), name="weights2") b1 = tf. Variable(0. 0, name="bias1") b2 = tf. Variable(0. 0, name="bias2") z1 = tf. add(tf. matmul(X, w1), b1, name="z1") z2 = tf. add(tf. matmul(X, w2), b2, name="z2") relu1 = tf. maximum(z1, 0., name="relu1") relu2 = tf. maximum(z1, 0., name="relu2") output = tf. add(relu1, relu2, name="output") Além de ser de difícil manutenção, este código repetitivo é propenso a erros (na verdade, este código contém um erro de copia e cola, você viu?). Seria ainda pior se você qui-sesse adicionar mais algumas Re LUs. Felizmente, o Tensor Flow permite que você evite repetições: simplesmente criando uma função para desenvolver uma Re LU. O código a seguir cria cinco Re LUs e exibe sua soma (observe que add_n() cria uma operação que calculará a soma de uma lista de tensores): def relu(X): w_shape = (int(X. get_shape()[1]), 1) w = tf. Variable(tf. random_normal(w_shape), name="weights") b = tf. Variable(0. 0, name="bias") z = tf. add(tf. matmul(X, w), b, name="z") return tf. maximum(z, 0., name="relu") n_features = 3 X = tf. placeholder(tf. float32, shape=(None, n_features), name="X") relus = [relu(X) for i in range(5)] output = tf. add_n(relus, name="output") Observe que, quando você cria um nó, o Tensor Flow verifica se seu nome já existe e, se existir, ele anexa um sublinhado seguido de um índice para tornar o nome exclusivo. Portanto, a primeira Re LU contém nós denominados “weights”, “bias”, “z” e “relu” CG_MIOLO_Hands_On_Machine_Learning. indb 251 07/05/2019 17:09:11 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
252 | Capítulo 9: Em Pleno Funcionamento com o Tensor Flow(mais muitos outros nós com seu nome padrão, como “Mat Mul” ); a segunda Re LU contém nós denominados “weights_1”, “bias_1”, e assim por diante; a terceira Re LU contém nós denominados “weights_2”, “bias_2”, e assim por diante. O Tensor Board identifica estas séries e as recolhe para reduzir a bagunça (como você pode ver na Figura 9-6). bias bias_1 bias_2 bias_3 bias_4 weights weights_... weights_... weights_... weights_... 5 tensores 5 tensores 5 tensoressaída Figura 9-6. Séries de nós colapsados Utilizando escopos do nome, o grafo fica muito mais limpo. Basta mover todo o conteúdo da função relu() dentro de um escopo do nome. A Figura 9-7 mostra o grafo resultante. Observe que o Tensor Flow também dá nomes exclusivos aos escopos do nome anexando _1, _2, e assim por diante. def relu(X): with tf. name_scope("relu"): [... ] saída relu relu_1 relu_2 relu_3 relu_4 Figura 9-7. Um grafo mais claro utilizando unidades com escopos do nome CG_MIOLO_Hands_On_Machine_Learning. indb 252 07/05/2019 17:09:12 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
Compartilhando Variáveis | 25 3Compartilhando Variáveis Se você quiser compartilhar uma variável entre vários componentes do seu grafo, uma op-ção simples é criá-la primeiro e depois passá-la como um parâmetro para as funções que a necessitam. Por exemplo, suponha que você deseja controlar o limiar da Re LU (atualmente codificado para 0) utilizando uma variável threshold compartilhada para todas as Re LUs. Você poderia simplesmente criar essa variável primeiro e depois passá-la para a função relu() : def relu(X, threshold): with tf. name_scope("relu"): [... ] return tf. maximum(z, threshold, name="max") threshold = tf. Variable(0. 0, name="threshold") X = tf. placeholder(tf. float32, shape=(None, n_features), name="X")relus = [relu(X, threshold) for i in range(5)] output = tf. add_n(relus, name="output") Isso funciona bem: agora você pode controlar o limiar para todas as Re LUs utilizando a variável threshold. No entanto, se houver muitos parâmetros compartilhados como esse, será doloroso ter que passá-las como parâmetros o tempo todo. Muitas pessoas criam um dicionário de Python em seu modelo contendo todas as variáveis e as passam para todas as funções. Outras criam uma classe para cada módulo (por exemplo, uma classe Re LU utilizando variáveis de classe para lidar com o parâmetro compartilhado). Outra opção seria definir a variável compartilhada como um atributo da função relu() na primeira chamada, dessa maneira: def relu(X): with tf. name_scope("relu"): if not hasattr(relu, "threshold"): relu. threshold = tf. Variable(0. 0, name="threshold") [... ] return tf. maximum(z, relu. threshold, name="max") O Tensor Flow oferece outra opção, o que pode levar a um código ligeiramente mais limpo e mais modular do que as soluções anteriores. 5 É um pouco complicado entender essa solução no início, mas, como é muito utilizada no Tensor Flow, vale a pena entrar em detalhes. A ideia é utilizar a função get_variable() para criar a variável compartilhada se ela ainda não existir, ou reutilizá-la se ela já existe. O comportamento desejado (criando ou reutilizando) é controlado por um atributo do variable_scope(). Por exemplo, o código a seguir criará uma variável chamada “relu/threshold” (como um escalar, já que shape=(), e utilizando 0. 0 como o valor inicial): with tf. variable_scope("relu"): threshold = tf. get_variable("threshold", shape=(), initializer=tf. constant_initializer(0. 0)) 5 Criar uma classe Re LU é indiscutivelmente a opção mais limpa, mas é bem pesado. CG_MIOLO_Hands_On_Machine_Learning. indb 253 07/05/2019 17:09:12 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
254 | Capítulo 9: Em Pleno Funcionamento com o Tensor Flow Note que, se a variável já tiver sido criada por uma chamada anterior a get_variable(), esse código criará uma exceção. Este comportamento impede a reutilização de variáveis por engano. Se você quiser reutilizar uma variável, você precisa explicitamente dizer isso definindo o atributo reuse da variável para True (assim não é necessário especificar a forma ou o inicializador): with tf. variable_scope("relu", reuse=True): threshold = tf. get_variable("threshold") Este código buscará a variável “relu/threshold” existente ou criará uma exceção se esta não existir, ou se não foi criada utilizando get_variable(). Como alternativa, você pode definir o atributo reuse como True dentro do bloco chamando o método do escopo reuse_variables() : with tf. variable_scope("relu") as scope: scope. reuse_variables() threshold = tf. get_variable("threshold") Uma vez que reuse for definido para True, ele não pode ser ajus-tado novamente para False dentro do bloco. Além disso, se você definir outros escopos de variáveis dentro deste bloco, eles herdarão automaticamente reuse=True. Por fim, apenas variáveis criadas por get_variable() podem ser reutilizadas desta forma. Agora você tem todas as peças que precisa para fazer a função relu() acessar a variável threshold sem ter que fazê-la passar por um parâmetro: def relu(X): with tf. variable_scope("relu", reuse=True): threshold = tf. get_variable("threshold") # reúsa variável existente [... ] return tf. maximum(z, threshold, name="max") X = tf. placeholder(tf. float32, shape=(None, n_features), name="X") with tf. variable_scope("relu"): # cria a variável threshold = tf. get_variable("threshold", shape=(), initializer=tf. constant_initializer(0. 0)) relus = [relu(X) for relu_index in range(5)] output = tf. add_n(relus, name="output") Este código primeiro define a função relu(), então cria a variável relu/threshold (como um escalar que será inicializado mais tarde para 0. 0) e constrói cinco Re LUs chamando a função relu(). A função relu() reutiliza a variável relu/threshold e cria os outros nós Re LU. CG_MIOLO_Hands_On_Machine_Learning. indb 254 07/05/2019 17:09:13 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
Compartilhando Variáveis | 25 5As variáveis criadas utilizando get_variable() são sempre nomea-das utilizando o nome de seus variable_scope como um prefixo (por exemplo, “relu/threshold” ), mas, para todos os outros nós (incluindo as variáveis criadas com tf. Variable() ), o escopo da va-riável atua como um novo escopo de nome. Principalmente se um escopo do nome com um nome idêntico já tiver sido criado, então um sufixo é adicionado para tornar o nome único. Por exemplo, to-dos os nós criados no código anterior (exceto a variável threshold ) têm um nome prefixado com “relu_1/” para “relu_5/”, como mostrado na Figura 9-8. saída relu_1 relu_2 relu_3 relu_4 relu_5relu relu relu relu relu thresholdrelu relu_1 relu_2 relu_3 relu_4 relu_5 Figura 9-8. Cinco Re LUs compartilhando a variável threshold É um tanto triste que a variável threshold deva ser definida fora da função relu(), na qual reside todo o resto do código Re LU. Para corrigir isso, o código a seguir cria a variável threshold dentro da função relu() na primeira chamada e, em seguida, a reutiliza nas cha-madas subsequentes. Agora, a f unção relu() não tem que se preocupar com escopos de nomes ou variáveis compartilhadas: ela apenas chama get_variable(), que criará ou reutilizará a variável threshold (ela não precisa saber qual é o caso). O restante do código chama relu() por cinco vezes, certificando-se de definir para reuse=False na primeira chamada e reuse=True para as outras chamadas. def relu(X): threshold = tf. get_variable("threshold", shape=(), initializer=tf. constant_initializer(0. 0)) [... ] return tf. maximum(z, threshold, name="max") X = tf. placeholder(tf. float32, shape=(None, n_features), name="X") relus = [] for relu_index in range(5): with tf. variable_scope("relu", reuse=(relu_index >= 1)) as scope: relus. append(relu(X)) output = tf. add_n(relus, name="output") CG_MIOLO_Hands_On_Machine_Learning. indb 255 07/05/2019 17:09:13 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
256 | Capítulo 9: Em Pleno Funcionamento com o Tensor Flow O grafo resultante é ligeiramente diferente do anterior, uma vez que a variável compar-tilhada vive dentro da primeira Re LU (veja a Figura 9-9). relu_4 relu_3 relu_2 relu_1 relu relu relu relu relurelu_1 relu_3relu_2 relu_4saída Figura 9-9. Cinco Re LUs compartilhando a variável threshold Concluímos aqui esta introdução ao Tensor Flow. Discutiremos tópicos mais avançados à medida que passarmos pelos próximos capítulos, em particular operações relacionadas a redes neurais profundas, convolutivas e recorrentes, bem como expandir o Tensor Flow com a utilização do multithreading, queues, múltiplas GPUs e vários servidores. Exercícios 1. Quais são os principais benefícios de se criar um grafo de cálculo em vez de ex ecutar diretamente os cálculos? Quais são as principais desvantagens? 2. A decl aração a_val = a. eval(session=sess) é equivalente a a_ v a l = s e s s. run(a) ? 3. A decl aração a_val, b_val = a. eval(session=sess), b. eval(session=sess) é equivalente a a_val, b_val = sess. run([a, b]) ? 4. É pos sível executar dois grafos na mesma sessão? 5. Se vo cê criar um grafo g contendo uma variável w, então iniciar dois segmentos e abrir uma sessão em cada, ambos utilizando o mesmo grafo g, cada sessão terá sua própria cópia da variável w ou esta será compartilhada? 6. Qua ndo uma variável é inicializada? Quando é destruída? 7. Qua l é a diferença entre um placeholder e uma variável? 8. O que a contece quando você executa o grafo para avaliar uma operação que depende de um placeholder, mas você não fornece seu valor? O que acontece se a operação não depender do placeholder? 9. Qua ndo você executa um grafo, você pode fornecer o valor de saída de qualquer operação ou apenas o valor dos placeholders? CG_MIOLO_Hands_On_Machine_Learning. indb 256 07/05/2019 17:09:13 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
Exercícios | 25710. Como você pode definir uma variável para qualquer valor desejado (durante a fa se de execução)? 11. Qua ntas vezes o autodiff de modo reverso precisa percorrer o gráfico para calcular os gradientes da função de custo em relação a dez variáveis? E quanto ao autodiff de modo avançado? E a diferenciação simbólica? 12. Imp lemente a Regressão Logística com o Gradiente Descendente com Minilotes utilizando o Tensor Flow. Treine-o e o avalie no conjunto de dados em formato de luas (introduzido no Capítulo 5). Tente adicionar todas as características extras: Def ina o grafo dentro da função logistic_regression(), que pode ser facil-mente reutilizada; Salv e pontos de verificação com a utilização de um Saver em intervalos regu-lares durante o treinamento e salve o modelo final ao término do treinamento; Res taure o último ponto de verificação após a inicialização caso o treinamento seja interrompido; Def ina o grafo com a utilização de escopos do nome para que pareça bem no Tensor Board; Adi cione resumos para visualizar as curvas de aprendizado no Tensor Board; Ten te ajustar alguns hiperparâmetros, como a taxa de aprendizado ou o tamanho do minilote e veja a forma da curva de aprendizado. As soluções para estes exercícios estão disponíveis no Apêndice A CG_MIOLO_Hands_On_Machine_Learning. indb 257 07/05/2019 17:09:13 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
CG_MIOLO_Hands_On_Machine_Learning. indb 258 07/05/2019 17:09:13 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
259Capítulo 10 Introdução às Redes Neurais Artificiais As aves nos inspiraram a voar, a planta bardana inspirou a criação do velcro e a natu-reza inspirou muitas outras invenções. Parece lógico, então, olhar para a arquitetura do cérebro para obter a inspiração sobre como construir uma máquina inteligente. Esta é a ideia-chave que inspirou as redes neurais artificiais (RNA). No entanto, embora os aviões tenham sido inspirados por pássaros, eles não têm que bater suas asas. Igualmente, as RNA gradualmente têm se tornado bem diferentes de seus primos biológicos. Alguns pesquisadores até argumentam que devemos descartar completamente a analogia bio-lógica (por exemplo, ao dizer “unidades” em vez de “neurônios”) para não restringir nossa criatividade com relação a sistemas biologicamente plausíveis. 1 As RNA estão no cerne do Aprendizado Profundo. Elas são versáteis, poderosas e escaláveis, tornando-as ideais para lidar com grandes tarefas altamente complexas do Aprendizado de Máquina, como classificar bilhões de imagens (por exemplo, as do Google), alimentar serviços de reconhecimento da fala (por exemplo, a Siri da Apple), recomendar os melhores vídeos para centenas de milhões de usuários todos os dias (como o You Tube), ou aprender a derrotar o campeão mundial no jogo Go, examinando milhões de jogos passados e depois jogando contra si mesmo (Alpha Go da Deep Mind). Neste capítulo, introduziremos redes neurais artificiais começando por um breve tour pelas primeiras arquiteturas RNA. Em seguida, apresentaremos as Perceptrons Multicamadas (MLPs, do inglês) e como implementá-las com a utilização do Tensor Flow para resolver o problema da classificação de dígito do MNIST (introduzido no Capítulo 3). 1 Você pode ter o melhor dos dois mundos encarando abertamente inspirações biológicas sem ter medo de criar modelos biologicamente não realistas, desde que funcionem bem. CG_MIOLO_Hands_On_Machine_Learning. indb 259 07/05/2019 17:09:13 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
260 | Capítulo 10: Introdução às Redes Neurais Artificiais De Neurônios Biológicos a Neurônios Artificiais Surpreendentemente, as RNA existem há muito tempo: elas foram introduzidas pela primeira vez em 1943 pelo neurofisiologista Warren Mc Culloch e pelo matemático Walter Pitts. Em seu artigo de referência ( https://goo. gl/Ul4mx W ),2 “Logical Calculus of Ideas Immanent in Nervous Activity” [“Cálculo lógico de ideias inerentes na atividade nervosa”, em tradução livre], Mc Culloch e Pitts apresentaram um modelo computacional simplificado utilizando lógica proposicional de como os neurônios biológicos podem trabalhar juntos em cérebros de animais na realização de cálculos complexos. Esta foi a primeira arquitetura de rede neural artificial. Desde então, muitas outras foram inventadas, como veremos. Os primeiros sucessos das RNA até a década de 1960 levaram à crença generalizada de que, em breve, estaríamos conversando com máquinas verdadeiramente inteligentes. Quando ficou claro que essa promessa não seria cumprida (pelo menos por um bom tempo), o financiamento minguou e as RNA entraram em um longo e obscuro período. No início dos anos 1980, à medida que novas arquiteturas de rede foram inventadas e melhores técnicas de treinamento foram desenvolvidas, houve um ressurgimento do interesse nas RNA. Mas, na década de 1990, as técnicas avançadas do Aprendizado de Máquina, como Máquinas de Vetores de Suporte (veja o Capítulo 5), foram favorecidas pela maioria dos pesquisadores, pois pareciam oferecer melhores resultados e bases teóricas mais fortes. Finalmente, estamos testemunhando mais uma onda de interesse nas RNA. Essa onda morrerá como as anteriores? Existem algumas boas razões para acreditar que esta é diferente e terá um impacto muito mais profundo em nossas vidas: Tem os, atualmente, uma grande quantidade de dados disponível para treinar redes neurais, e as RNA superam com frequência outras técnicas de AM em problemas muito grandes e complexos; O tre mendo aumento do poder de computação desde a década de 1990 agora permite treinar grandes redes neurais em um período razoável de tempo. Isto se deve em parte à Lei de Moore, mas também graças à indústria dos jogos, que tem produzido poderosos GPU aos milhões; Os al goritmos de treinamento foram melhorados. Para ser sincero, eles são apenas um pouco diferentes dos usados na década de 1990, mas esses ajustes relativamente pequenos têm um enorme impacto positivo; Alg umas limitações teóricas das RNA tornaram-se benignas na prática. Por exemplo, muitas pessoas pensavam que os algoritmos de treinamento RNA es-tavam condenados porque provavelmente poderiam ficar presos em um local 2 “A Logical Calculus of Ideas Immanent in Nervous Activity”, W. Mc Culloch e W. Pitts (1943). CG_MIOLO_Hands_On_Machine_Learning. indb 260 07/05/2019 17:09:13 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
De Neurônios Biológicos a Neurônios Artificiais | 261optimum, mas resultou que, na prática, isso é bastante raro (ou quando é o caso, geralmente são muito próximos do global optimum); As RN A parecem ter entrado em um círculo virtuoso de financiamento e pro-gresso. Produtos surpreendentes baseados em RNA estão regularmente nas manchetes, que atraem cada vez mais atenção e financiamento, resultando em mais progressos e produtos ainda mais incríveis. Neurônios Biológicos Antes de discutirmos neurônios artificiais, daremos uma rápida olhada em um neurônio biológico (representado na Figura 10-1). É uma célula de aparência incomum encontra-da principalmente no córtex cerebral animal (por exemplo, seu cérebro), composto de um corpo celular contendo o núcleo e a maioria dos componentes complexos da célula e muitas extensões de ramificação chamadas dendritos, além de uma extensão muito longa chamada de axônio. O comprimento do axônio pode ser apenas algumas vezes mais longo do que o corpo da célula, ou até dezenas de milhares de vezes maior. Perto de sua extremidade, o axônio divide-se em muitos ramos chamados de telodendros, e na ponta desses ramos estão estruturas minúsculas chamadas terminais sinápticos (ou simplesmente sinapses ) que estão conectadas aos dendritos (ou diretamente ao corpo celular) de outros neurônios. Os neurônios biológicos recebem curtos impulsos elétricos de outros neurônios através dessas sinapses chamadas sinais. Quando um neurônio recebe um número suficiente de sinais de outros neurônios em alguns milissegundos, ele dispara seus próprios sinais. Retículo endoplasmático Mitocôndria Ramos dendríticos Dendrito Cone axonal Aparato de Golgi Terminais sinápticos Telodendro Axônio Corpo da célula Núcleo Figura 10-1. Neurônio Biológico 3 3 Imagem por Bruce Blaus (Creative Commons 3. 0 ( https://creativecommons. org/licenses/by/3. 0/) ). Reproduzida de https://en. wikipedia. org/wiki/Neuron. CG_MIOLO_Hands_On_Machine_Learning. indb 261 07/05/2019 17:09:14 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
262 | Capítulo 10: Introdução às Redes Neurais Artificiais Assim sendo, os neurônios biológicos individuais parecem se comportar de uma forma bastante simples, mas estão organizados em uma vasta rede de bilhões de neurônios, cada um normalmente conectado a milhares de outros. Cálculos altamente complexos podem ser realizados por uma vasta rede de neurônios bem simples, muito parecida com um formigueiro complexo que surge dos esforços combinados de simples formigas. A arquitetura das redes neurais biológicas (RNB)4 ainda é objeto de pesquisa ativa, mas algumas partes do cérebro foram mapeadas e parece que os neurônios muitas vezes são organizados em camadas consecutivas, como mostrado na Figura 10-2. Figura 10-2. Múltiplas camadas em uma rede neural biológica (córtex humano) 5 Cálculos Lógicos com Neurônios Warren Mc Culloch e Walter Pitts propuseram um modelo simples de neurônio biológico, mais tarde conhecido como neurônio artificial : este possui uma ou mais entradas binárias (ligado/desligado) e uma saída binária. O neurônio artificial ativa sua saída quando mais do que certo número de suas entradas estão ativas. Mc Culloch e Pitts demonstraram que mesmo com um modelo tão simplificado é possível construir uma rede de neurônios artificiais que calcula qualquer proposta lógica desejada. Por exemplo, construiremos algumas RNA que realizam vários cálculos lógicos (veja a Figura 10-3) assumindo que um neurônio seja ativado quando pelo menos duas de suas entradas estiverem ativas. Conexão Neurônios E OU NÃO Figura 10-3. RNA realizando cálculos lógicos simples 4 No contexto do Aprendizado de Máquina, a frase “redes neurais” generalmente se refere às RNA, não às RNB. 5 Desenho de uma laminação cortical por S. Ramon y Cajal (domínio público). Reproduzido de https://en. wikipe dia. org/wiki/Cerebral_cortex. CG_MIOLO_Hands_On_Machine_Learning. indb 262 07/05/2019 17:09:14 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
De Neurônios Biológicos a Neurônios Artificiais | 263 A primeira rede à esquerda é a função de identidade: se o neurônio A estiver ativado, o neurônio C também será ativado (uma vez que ele recebe dois sinais de entrada do neurônio A), mas, se o neurônio A estiver desligado, o neurônio C também estará; A seg unda rede executa um E lógico: o neurônio C é ativado somente quando ambos os neurônios A e B são ativados (um único sinal de entrada não é sufi-ciente para ativar o neurônio C); A terc eira rede executa um OU lógico: o neurônio C é ativado se o neurônio A ou o neurônio B estiverem ativados (ou ambos); Finalmente, se supormos que uma conexão de entrada pode inibir a atividade do neurônio (o que é o caso dos neurônios biológicos), então a quarta rede cal-cula uma proposição lógica ligeiramente mais complexa: o neurônio C é ativado somente se o neurônio A estiver ativo e se o neurônio B estiver desligado. Se o neurônio A estiver ativo o tempo todo, então você obtém um NÃO lógico: o neurônio C está ativo quando o neurônio B está desligado e vice-versa. Você pode imaginar facilmente como essas redes podem ser combinadas para calcular expressões lógicas complexas (veja os exercícios no final do capítulo). O Perceptron Inventado em 1957 por Frank Rosenblatt, o Perceptron é uma das mais simples arquite-turas RNA. Ela é baseada em um neurônio artificial ligeiramente diferente (veja a Figura 10-4) chamado de unidade linear com threshold (LTU, do inglês): as entradas e a saída agora são números (em vez de valores binários ligado/desligado) e cada conexão de entrada está associada a um peso. A LTU calcula uma soma ponderada de suas entradas ( z = w1 x1 + w2 x2 + ⋯ + wn xn = w T · x), então aplica uma função degrau a esta soma e exibe o resultado: hw(x) = step ( z) = step ( w T · x). Saída: step Função degrau: step(z) Soma ponderada Pesos Entradas Figura 10-4. Unidade Linear com Threshold CG_MIOLO_Hands_On_Machine_Learning. indb 263 07/05/2019 17:09:14 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
264 | Capítulo 10: Introdução às Redes Neurais Artificiais A função degrau mais comum utilizada nos Perceptrons é a função de Heaviside (veja Equação 10-1). Algumas vezes é utilizada a função sinal. Equação 10-1. Funções degrau comuns utilizadas em Perceptrons heavisid ez=0 z<0 1 z≥0sgn z=-1sez<0 0 z=0 +1 z>0se sese se Uma única LTU pode ser utilizada para classificação binária linear simples. Ela calcula uma combinação linear das entradas e, se o resultado exceder um limiar, exibe a classe positiva ou então negativa (como um classificador de Regressão Logística ou um SVM linear). Por exemplo, com base no comprimento e largura da pétala, você poderia utilizar uma única LTU para classificar as flores da íris (adicionando também uma característi-ca extra de viés x0 = 1, assim como fizemos em capítulos anteriores). Treinar uma LTU significa encontrar os valores corretos para w0, w1 e w2 (o algoritmo de treinamento será discutido em breve). Um Perceptron é composto por uma única camada de LTUs,6 com cada neurônio conec-tado a todas as entradas. Essas conexões são representadas geralmente com a utilização de neurônios de passagem especiais chamados de neurônios de entrada : eles apenas dão saída para qualquer entrada fornecida. Além disso, geralmente é adicionada uma carac-terística extra de viés ( x0 = 1), que é representada quando utilizamos um tipo especial de neurônio chamado neurônio de viés, que todas as vezes só exibe 1. Um Perceptron com duas entradas e três saídas está representado na Figura 10-5. Este Perceptron pode classificar simultaneamente as instâncias em três classes binárias di-ferentes, o que o torna um classificador multioutput. Neurônio de entrada (passagem)Neurônio de viés (sempre saída 1)LTUSaídas Camada de saída Camada de entrada Entradas Figura 10-5. Diagrama Perceptron 6 O nome Perceptron algumas vezes é utilizado para representar uma pequena rede com uma única LTU. CG_MIOLO_Hands_On_Machine_Learning. indb 264 07/05/2019 17:09:15 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
De Neurônios Biológicos a Neurônios Artificiais | 265Então, como um Perceptron é treinado? O algoritmo de treinamento do Perceptron proposto por Frank Rosenblatt foi amplamente inspirado pela regra de Hebb. Em seu livro The Organization of Behavior [A Organização do Comportamento, em tradução livre] publicado em 1949, Donald Hebb sugeriu que, quando um neurônio biológico desencadeia outro neurônio com frequência, a conexão entre esses dois neurônios fica mais forte. Essa ideia foi resumida mais tarde por Siegrid Löwel nesta frase cativante: “Cells that fire together, wire together ” [Células que disparam juntas permanecem co-nectadas, em tradução livre]. Esta regra tornou-se conhecida como a regra de Hebb (ou aprendizado Hebbiano ); isto é, o peso da conexão entre dois neurônios é aumentado sempre que eles obtêm o mesmo resultado. Perceptrons são treinados com a utilização de uma variante desta regra que leva em consideração o erro produzido pela rede; não reforçando as conexões que levam à saída errada. Mais especificamente, o Perceptron é alimentado por uma instância de treinamento de cada vez e faz suas previsões para cada uma delas. Para cada neurônio de saída que produziu uma previsão incorreta, ele reforçará os pesos de conexão das entradas que contribuíram para a previsão correta. A regra é mostrada na Equação 10-2. Equação 10-2. Regra de Aprendizado do Perceptron (atualização do peso) wi,jpróximodegrau=wi,j+ηyj-yjxi wi, j é o peso de conexão entre o i-ésimo neurônio de entrada e o j-ésimo neurônio de saída; xi é o valor da i-ésima entrada da instância de treinamento atual; ŷj é a j-ésima saída do neurônio de saída para a instância de treinamento atual; yj é a j-ésima saída alvo do neurônio de saída para a instância de treinamento atual; η é a tax a de aprendizado. A fronteira de decisão de cada neurônio de saída é linear, então os Perceptrons são inca-pazes de aprender padrões complexos (como os classificadores de Regressão Logística). No entanto, se as instâncias de treinamento forem linearmente separáveis, Rosenblatt demonstrou que esse algoritmo convergiria para uma solução,7 o que é chamado de Teorema de convergência do Perceptron. O Scikit-Learn fornece uma classe Perceptron que implementa uma rede LTU simples. Ele pode ser utilizado praticamente como seria de esperar — por exemplo, no conjunto de dados da íris (introduzido no Capítulo 4): 7 Note que esta solução geralmente não é única: em geral, quando os dados são linearmente separáveis, há uma in finidade de hiperplanos que podem separá-los. CG_MIOLO_Hands_On_Machine_Learning. indb 265 07/05/2019 17:09:15 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
266 | Capítulo 10: Introdução às Redes Neurais Artificiaisimport numpy as np from sklearn. datasets import load_iris from sklearn. linear_model import Perceptron iris = load_iris() X = iris. data[:, (2, 3)] # comprimento da pétala, largura da pétala y = (iris. target == 0). astype(np. int) # Iris Setosa? per_clf = Perceptron(random_state=42) per_clf. fit(X, y) y_pred = per_clf. predict([[2, 0. 5]]) Você pode ter reconhecido que o algoritmo de aprendizado Perceptron se assemelha fortemente ao Gradiente Descendente Estocástico. Na verdade, a classe Perceptron do Scikit-Learn é equivalente à utilização do SGDClassifier com os seguintes hiperparâmetros: loss=“perceptron”, learning_rate=“constant”, eta0=1 (a taxa de aprendizado) e penalty=None (sem regularização). Observe que, contrariamente aos classificadores de Regressão Logística, os Perceptrons não produzem uma probabilidade de classe; em vez disso, apenas fazem previsões com base em um rígido limiar. Esta é uma das boas razões para preferir a Regressão Logística em relação aos Perceptrons. Em sua monografia de 1969 intitulada Perceptrons, Marvin Minsky e Seymour Papert destacaram um número de sérias fraquezas dos Perceptrons, em particular o fato de serem incapazes de resolver alguns problemas triviais (por exemplo, o problema de classifica-ção Exclusive OR (XOR); veja o lado esquerdo da Figura 10-6). Claro que isso também é verdade para qualquer outro modelo de classificação linear (como os classificadores de Regressão Logística), mas os pesquisadores esperavam muito mais dos Perceptrons e seu desapontamento foi grande: como resultado, muitos pesquisadores descartaram completamente o conexionismo (ou seja, o estudo de redes neurais) em favor de problemas de alto nível como lógica, resolução de questões e buscas. Entretanto, algumas das suas limitações podem ser eliminadas ao empilharmos vários Perceptrons. A RNA resultante é chamada de Perceptron Multicamada (MLP). Em particular, como você pode verificar, a MLP pode resolver o problema XOR calculando a saída MLP representada à direita da Figura 10-6 para cada combinação de entradas: com as entradas (0, 0) ou (1, 1) a rede exibe 0, e com as entradas (0, 1) ou (1, 0) exibe 1. CG_MIOLO_Hands_On_Machine_Learning. indb 266 07/05/2019 17:09:15 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
De Neurônios Biológicos a Neurônios Artificiais | 267 Figura 10-6. Problema de classificação XOR e um MLP que o soluciona Perceptron Multicamada e Retropropagação Um MLP é composto de uma camada de entrada ( passthrough ), uma ou mais camadas LTUs chamadas de camadas ocultas e uma camada final LTU chamada de camada de saída (veja a Figura 10-7). Toda camada, exceto a camada de saída, inclui um neurônio de viés e está totalmente conectada à próxima camada. Quando uma RNA possui duas ou mais camadas ocultas, é chamada de rede neural profunda (DNN, do inglês). Camada de entrada Camada de saída Camada oculta Figura 10-7. Multicamada Perceptron Durante muitos anos, os pesquisadores esforçaram-se para encontrar uma forma de treinar MLPs, sem sucesso. Mas, em 1986, D. E. Rumelhart et al. publicaram um artigo inovador ( https://goo. gl/Wl7Xyc )8 apresentando o algoritmo de treinamento da retropro-pagação. 9 Hoje, o descreveríamos como o Gradiente Descendente utilizando autodiff 8 “Learning Internal Representations by Error Propagation”, D. Rumelhart, G. Hinton, R. Williams (1986). 9 Este algoritmo foi inventado várias vezes por vários pesquisadores em diferentes campos, começando com P. Werbos em 1974. CG_MIOLO_Hands_On_Machine_Learning. indb 267 07/05/2019 17:09:16 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
268 | Capítulo 10: Introdução às Redes Neurais Artificiaisem modo reverso (o Gradiente Descendente foi introduzido no Capítulo 4 e autodiff foi discutido no Capítulo 9). O algoritmo alimenta cada instância de treinamento para a rede e calcula a saída de cada neurônio em cada camada consecutiva (este é o forward pass, assim como ao fa-zer previsões). Em seguida, ele mede o erro de saída da rede (isto é, a diferença entre a saída desejada e a saída real da rede) e calcula o quanto cada neurônio contribuiu para o erro de cada neurônio de saída na última camada oculta. Em seguida, passa a medir a quantidade dessas contribuições de erro provenientes de cada neurônio na camada oculta anterior, e assim por diante até o algoritmo alcançar a camada de entrada. Esta passagem reversa mede eficientemente o gradiente de erro em todos os pesos de conexão na rede, propagando para trás o gradiente de erro na rede (daí o nome do algoritmo). Se você verificar o algoritmo reverse-mode autodiff no Apêndice D descobrirá que as passagens de retropropagação forward e reverse simplesmente executam o autodiff no modo reverso. O último passo do algoritmo de retropropagação é um incremento do Gradiente Descendente com a utilização dos gradientes de erro medidos anteriormente em todos os pesos de conexão na rede. Vamos encurtar ainda mais essa história: para cada instância de treinamento, o algo-ritmo de retropropagação primeiro faz uma previsão (forward pass), mede o erro, então passa por cada camada no reverso para medir a contribuição do erro em cada conexão (reverse pass) e, finalmente, ajusta os pesos da conexão para reduzir o erro (etapa Gradiente Descendente). Para que este algoritmo funcione adequadamente, os autores fizeram uma mudan-ça-chave na arquitetura do MLP: substituíram a função degrau pela função logística, σ(z) = 1 / (1 + exp(-z)), o que foi essencial porque a função degrau contém apenas segmentos planos, portanto não há gradiente com o qual trabalhar (o Gradiente Descendente não pode se mover sobre uma superfície plana), enquanto a função logística possui uma derivada não zero bem definida em todos os lugares, permitindo que o Gradiente Descendente faça progresso a cada etapa. Em vez da função logística, o algoritmo de retropropagação pode ser utilizado com outras funções de ativação, das quais duas populares são: A função tangente hiperbólica tanh (z) = 2σ(2z)-1 Assim como a função logística, ela tem o formato de S, é contínua e diferenciável, mas seu valor de saída varia de-1 a 1 no início do treinamento (não de 0 a 1, como no caso da função logística), o que tende a tornar cada saída da camada mais ou menos normalizada (ou seja, centrada em torno de 0), ajudando frequentemente a acelerar a convergência. CG_MIOLO_Hands_On_Machine_Learning. indb 268 07/05/2019 17:09:16 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
De Neurônios Biológicos a Neurônios Artificiais | 269A função Re LU (introduzida no Capítulo 9) Re LU ( z) = max (0, z). É contínua, mas infelizmente não é diferenciável em z = 0 (a inclinação muda abruptamente, o que pode fazer com que o Gradiente Descendente salte). No entanto, na prática, ela funciona muito bem e tem a vantagem de o cálculo ser rápido. Mais importante ainda, o fato dela não possuir um valor máximo de saída também ajuda na redução de alguns problemas durante o Gradiente Descendente (vol-taremos a isso no Capítulo 11). Estas funções de ativação populares e suas derivadas estão representadas na Figura 10-8. Funções de ativação Derivadas Step Logit Tang Re Lu Figura 10-8. Funções de Ativação e suas derivadas Um MLP com cada saída correspondente a uma classe binária diferente é frequentemente utilizado para classificação (por exemplo, spam/não spam, urgente/não urgente, etc. ). A camada de saída normalmente é modificada ao substituir as funções de ativação indi-viduais por uma função softmax compartilhada (veja a Figura 10-9) quando as classes são exclusivas (por exemplo, classes 0 a 9 para classificação de imagem de dígitos). A função softmax foi introduzida no Capítulo 4. A saída de cada neurônio corresponde à probabilidade estimada da classe correspondente. Observe que o sinal flui apenas em uma direção (das entradas para as saídas), então esta arquitetura é um exemplo de uma rede neural feedforward (FNN, do inglês). Camada de entrada Softmax Camada de saída Softmax Camada oculta (por ex emplo, Re LU) Figura 10-9. Um MLP moderno para a classificação (incluindo Re LU e softmax) CG_MIOLO_Hands_On_Machine_Learning. indb 269 07/05/2019 17:09:16 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
270 | Capítulo 10: Introdução às Redes Neurais Artificiais Os neurônios biológicos parecem implementar uma função de ati-vação aproximadamente sigmoide (em forma de S), de modo que os pesquisadores as mantiveram por muito tempo. Mas acontece que a função de ativação Re LU geralmente funciona melhor nas RNA. Este é um dos casos em que a analogia biológica foi enganosa. Treinando um MLP com a API de Alto Nível do Tensor Flow A maneira mais simples de treinar um MLP com o Tensor Flow é utilizar a API TF. Learn de alto nível, que oferece uma API compatível com o Scikit-Learn. A classe DNNClassifier facilita o treinamento de uma rede neural profunda independentemente do número de camadas ocultas, com uma camada de saída softmax para exibir probabilidades estimadas da classe. Por exemplo, o código a seguir treina uma DNN para classificação com duas camadas ocultas (uma com 300 neurônios e outra com 100 neurônios) e uma camada de saída softmax com 10 neurônios: import tensorflow as tf feature_cols = tf. contrib. learn. infer_real_valued_columns_from_input(X_train) dnn_clf = tf. contrib. learn. DNNClassifier(hidden_units=[300,100], n_classes=10, feature_columns=feature_cols) dnn_clf = tf. contrib. learn. SKCompat(dnn_clf) # se Tensor Flow >= 1. 1 dnn_clf. fit(X_train, y_train, batch_size=50, steps=40000) Primeiro o código do conjunto de treinamento cria um conjunto de colunas de valor real (outros tipos de colunas, como colunas categóricas, estão disponíveis). Em segui-da, criamos o DNNClassifier e o envolvemos em um auxiliar de compatibilidade do Scikit-Learn. Finalmente, executamos 40. 000 iterações de treinamento com a utilização de lotes de 50 instâncias. Se você executar este código no conjunto de dados MNIST (depois de escaloná-lo, por exemplo, utilizando o Standard Scaler do Scikit-Learn), obterá um modelo que consegue cerca de 98,2% de acurácia no conjunto de teste! Isso é mais do que o melhor modelo que treinamos no Capítulo 3: >>> from sklearn. metrics import accuracy_score >>> y_pred = dnn_clf. predict(X_test) >>> accuracy_score(y_test, y_pred['classes']) 0. 98250000000000004 O pacote tensorflow. contrib contém muitas funções úteis, mas é um lugar de experimentação em código que ainda não evoluiu a ponto de fazer parte da API principal do Tensor Flow. Então, a classe DNNClassifier (e qualquer outro código contrib ) pode mudar sem aviso prévio no futuro. CG_MIOLO_Hands_On_Machine_Learning. indb 270 07/05/2019 17:09:17 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
Treinando um DNN Utilizando um Tensor Flow Regular | 271Nos bastidores, a classe DNNClassifier cria todas as camadas de neurônios com base na função de ativação Re LU (podemos mudar isso ajustando o hiperparâmetro activation_fn ). A camada de saída depende da função softmax e a função de custo é entropia cruzada (introduzida no Capítulo 4). Treinando um DNN Utilizando um Tensor Flow Regular Se você quiser mais controle sobre a arquitetura da rede, você vai preferir utilizar a API Python de nível inferior do Tensor Flow (introduzida no Capítulo 9). Nesta seção, construiremos o mesmo modelo feito antes de utilizarmos esta API e implementaremos o Gradiente Descendente de Minilotes para treiná-lo no conjunto de dados MNIST. O primeiro passo é a fase de construção do grafo do Tensor Flow. O segundo passo é a fase de execução, na qual executamos o grafo para treinar o modelo. Fase de Construção Vamos começar. Primeiro, precisamos importar a biblioteca tensorflow. Então, de-vemos especificar o número de entradas e saídas e configurar o número de neurônios escondidos em cada camada: import tensorflow as tf n_inputs = 28*28 # MNIST n_hidden1 = 300 n_hidden2 = 100 n_outputs = 10 Em seguida, utilize os nós placeholders para representar os dados de treinamento e metas, assim como você fez no Capítulo 9. A forma de X é definida parcialmente. Sabemos que será um tensor 2D (ou seja, uma matriz), com instâncias ao longo da primeira dimensão e características ao longo da segunda dimensão, e sabemos que o número de características será 28 x 28 (uma por pixel), mas ainda não sabemos quantas instâncias cada lote de treinamento conterá. Então, a forma de X será (None, n_inputs). Igualmente, sabemos que y é um tensor 1D com uma entrada por instância, mas, novamente, não sabemos o tamanho do lote de treinamento neste ponto, então o formato é (None). X = tf. placeholder(tf. float32, shape=(None, n_inputs), name="X") y = tf. placeholder(tf. int64, shape=(None), name="y") Agora, criaremos a rede neural real. O placeholder X agirá como a camada de entrada; durante a fase de execução será substituído por um lote de treinamento por vez (observe que todas as instâncias de um lote de treinamento serão processadas simultaneamente CG_MIOLO_Hands_On_Machine_Learning. indb 271 07/05/2019 17:09:17 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
272 | Capítulo 10: Introdução às Redes Neurais Artificiaispela rede neural). Agora você precisa criar as duas camadas ocultas e a camada de saí-da. As duas camadas ocultas são quase idênticas: diferem apenas das entradas às quais estão conectadas e pelo número de neurônios que contêm. A camada de saída também é muito semelhante, mas utiliza uma função de ativação softmax em vez de uma função de ativação Re LU. Criaremos uma função neuron_layer() que utilizaremos para criar uma camada por vez, e que precisará de parâmetros para especificar as entradas, o número de neurônios, a função de ativação e o nome da camada: def neuron_layer(X, n_neurons, name, activation=None): with tf. name_scope(name): n_inputs = int(X. get_shape()[1]) stddev = 2 / np. sqrt(n_inputs + n_neurons) init = tf. truncated_normal((n_inputs, n_neurons), stddev=stddev) W = tf. Variable(init, name="kernel") b = tf. Variable(tf. zeros([n_neurons]), name="bias") Z = tf. matmul(X, W) + b if activation is not None: return activation(Z) else: return Z Analisaremos este código linha por linha: 1. Primeiro criamos um escopo do nome utilizando o nome da camada: ele conterá todos os nós de computação para esta camada de neurônios. Isso é opcional, mas o grafo ficará muito mais agradável no Tensor Board se seus nós estiverem bem orga-nizados; 2. Em se guida, obtemos o número de entradas (a primeira dimensão é para as ins-tâncias) procurando a forma da matriz de entrada e obtendo o tamanho da se-gunda dimensão; 3. As pr óximas três linhas criam uma variável W que armazenará a matriz dos pesos (geralmente chamada de kernel da camada). Será um tensor 2D contendo todos os pesos de conexão entre cada entrada e cada neurônio; consequentemente, sua forma será (n_inputs, n_neurons). Com a utilização de uma distribuição nor-mal (Gaussiana) truncada,10 ela será inicializada aleatoriamente com um desvio padrão de O uso deste desvio padrão específico ajuda o algo-ritmo a convergir muito mais rápido (discutiremos isso mais adiante no Capítulo 11; este é um desses pequenos ajustes nas redes neurais que tiveram um tremendo impacto em sua eficiência). É importante inicializar os pesos de conexão alea-10 Usar uma distribuição normal truncada em vez de uma distribuição normal regular garante que não haverá pesos grandes, o que poderia retardar o treinamento. CG_MIOLO_Hands_On_Machine_Learning. indb 272 07/05/2019 17:09:17 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
Treinando um DNN Utilizando um Tensor Flow Regular | 273toriamente para todas as camadas ocultas para evitar quaisquer simetrias que o algoritmo Gradiente Descendente não seja capaz de quebrar;11 4. A próxima linha cria uma variável b para os vieses inicializados em 0 (sem pro-blema de simetria neste caso) com um parâmetro de viés por neurônio; 5. Ent ão, criamos um subgrafo para calcular Z = X · W + b. Esta implementação vetorizada calculará eficientemente, de uma só vez, as somas ponderadas das en-tradas mais o termo de polarização para cada neurônio da camada para todas as instâncias do lote. Observe que adicionar um array 1D ( b) em uma matriz 2D com o mesmo número de colunas ( X. W) resulta na adição do array 1D em cada linha da matriz: isso é chamado de broadcasting ; 6. Fin almente, o código retorna activation(Z), ou então ele retorna apenas Z se for fornecido um parâmetro activation como o tf. nn. relu (isto é, max (0, Z)). Certo, então, agora você tem uma função para a criação de uma camada de neurônio. Vamos utilizá-la para criar a rede neural profunda! A primeira camada oculta toma X como entrada. A segunda toma como entrada a saída da primeira camada oculta. E finalmente, a camada de saída toma como entrada a saída da segunda camada oculta. with tf. name_scope("dnn"): hidden1 = neuron_layer(X, n_hidden1, name="hidden1", activation=tf. nn. relu) hidden2 = neuron_layer(hidden1, n_hidden2, name="hidden2", activation=tf. nn. relu) logits = neuron_layer(hidden2, n_outputs, name="outputs") Observe que, mais uma vez, usamos escopos do nome para maior clareza. Repare também que logits é a saída da rede neural antes de passar pela função de ativação softmax: por razões de otimização, lidaremos com o cálculo softmax mais tarde. Como esperado, o Tensor Flow vem com muitas funções úteis para criar camadas pa-drão de redes neurais, portanto nem sempre é necessário definir sua própria função neuron_layer() como acabamos de fazer. Por exemplo, a função tf. layers. dense() do Tensor Flow (anteriormente chamada tf. contrib. layers. fully_connected() ) cria uma camada totalmente conectada em que todas as entradas estão conectadas a todos os neurônios da camada. Utilizando a estratégia de inicialização apropriada, ela cuida da criação das variáveis de pesos e polarizações denominadas kernel e bias, respectivamen-te, e você pode definir a função de ativação utilizando o argumento activation. Como 11 Por exemplo, se você definir todos os pesos como 0, todos os neurônios produzirão 0 e o gradiente de erro será o mesmo para todos os neurônios em uma determinada camada oculta. A etapa do Gradiente Descendente atualizará todos os pesos exatamente da mesma maneira em cada camada para que todos permaneçam iguais. Em outras palavras, apesar de ter centenas de neurônios por camada, seu modelo atuará como se houvesse apenas um neurônio por camada. Não vai acelerar. CG_MIOLO_Hands_On_Machine_Learning. indb 273 07/05/2019 17:09:18 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
274 | Capítulo 10: Introdução às Redes Neurais Artificiaisveremos no Capítulo 11, ela suporta também parâmetros de regularização. Ajustaremos o código anterior para utilizar a função dense() em vez da nossa função neuron_layer(). Basta substituir a sessão de construção dnn pelo código a seguir: with tf. name_scope("dnn"): hidden1 = tf. layers. dense(X, n_hidden1, name="hidden1", activation=tf. nn. relu) hidden2 = tf. layers. dense(hidden1, n_hidden2, name="hidden2", activation=tf. nn. relu) logits = tf. layers. dense(hidden2, n_outputs, name="outputs") Agora que já temos o modelo de rede neural, precisamos definir a função de custo para treiná-lo. Assim como fizemos na Regressão Softmax no Capítulo 4, utilizaremos a entropia cruzada. Como discutimos anteriormente, a entropia cruzada penalizará os modelos que estimam uma baixa probabilidade para a classe-alvo. O Tensor Flow fornece várias funções para calcular a entropia cruzada. Usaremos sparse_soft max_cross_entropy_with_lo-gits(), que calcula a entropia cruzada com base em “logits” (ou seja, a saída da rede antes de passar pela função de ativação softmax) e espera os rótulos na forma de números inteiros que variam de 0 ao número de classes menos 1 (no nosso caso, de 0 a 9). Isso nos dará um tensor 1D que contém a entropia cruzada de cada instância. Podemos, então, utilizar a função reduce_mean() do Tensor Flow para calcular a entropia cruzada média em todas as instâncias. with tf. name_scope("loss"): xentropy = tf. nn. sparse_softmax_cross_entropy_with_logits(labels=y, logits=logits) loss = tf. reduce_mean(xentropy, name="loss") A função sparse_softmax_cross_entropy_with_logits() é equi-valente a aplicar a função de ativação softmax e calcular a entropia cruzada, mas é mais eficiente e cuida adequadamente dos casos dos laterais: quando os logits são volumosos, os erros de arredondamen-to do ponto flutuante podem fazer com que a saída softmax seja exatamente igual a 0 ou 1 e, neste caso, a equação da entropia cru-zada conteria um termo log(0), igual a infinito negativo. A função sparse_soft max_cross_ entropy_with_logits() resolve este problema calculando log(ε), sendo que ε é um pequeno número positivo. É por isso que não aplicamos a função de ativação softmax anteriormente. Existe também outra função chamada softmax_ cross_entropy_with_logits(), que leva os rótulos na forma de vetores one-hot (em vez de ints de 0 ao número de classes menos 1). Nós temos o modelo de rede neural, temos a função de custo e agora precisamos definir um Gradient Descent Optimizer que ajustará os parâmetros do modelo e minimizará a função de custo. Nada de novo; é exatamente como fizemos no Capítulo 9: CG_MIOLO_Hands_On_Machine_Learning. indb 274 07/05/2019 17:09:18 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
Treinando um DNN Utilizando um Tensor Flow Regular | 275learning_rate = 0. 01 with tf. name_scope("train"): optimizer = tf. train. Gradient Descent Optimizer(learning_rate) training_op = optimizer. minimize(loss) O último passo importante na fase de construção é especificar como avaliar o modelo, e nós utilizaremos a acurácia como medida de desempenho. Primeiro, determine se a previsão da rede neural está correta para cada instância verificando se o logit mais alto corresponde ou não à classe-alvo. Para isto, você pode utilizar a função in_top_k(). Ela retorna um tensor 1D cheio de valores booleanos, então precisamos fazer casting desses booleanos para float e, em seguida, calcular a média, gerando a acurácia geral da rede. with tf. name_scope("eval"): correct = tf. nn. in_top_k(logits, y, 1) accuracy = tf. reduce_mean(tf. cast(correct, tf. float32)) E, como de costume, precisamos criar um nó para inicializar todas as variáveis e também um Saver para salvar nossos parâmetros treinados do modelo para o disco: init = tf. global_variables_initializer() saver = tf. train. Saver() Ufa! Isso conclui a fase de construção. Estamos falando de menos de 40 linhas de códi-go, mas foi bastante intenso: criamos placeholders para as entradas e os alvos, criamos uma função para construir uma camada de neurônio, a utilizamos para criar a DNN, definimos a função de custo, criamos um otimizador e, finalmente, definimos a medida de desempenho. Agora, vamos à fase de execução. Fase de Execução Esta parte é bem mais curta e simples. Primeiro carregaremos o MNIST. Poderíamos utilizar o Scikit-Learn para isso, como fizemos em capítulos anteriores, mas o Tensor Flow oferece seu próprio ajudante que obtém os dados, os escalona (entre 0 e 1), os embaralha e fornece uma função simples para carregar um minilote por vez. Além disso, os dados já estão divididos em um conjunto de treinamento (55. 000 instâncias), um de validação (5. 000 instâncias) e um de testes (10. 000 instâncias). Então, utilizaremos esse ajudante: from tensorflow. examples. tutorials. mnist import input_data mnist = input_data. read_data_sets("/tmp/data/") Agora, definimos o número de épocas que queremos rodar, bem como o tamanho dos minilotes: n_epochs = 40 batch_size = 50 CG_MIOLO_Hands_On_Machine_Learning. indb 275 07/05/2019 17:09:19 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
276 | Capítulo 10: Introdução às Redes Neurais Artificiais A seguir podemos treinar o modelo: 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, feed_dict={X: X_batch, y: y_batch}) acc_train = accuracy. eval(feed_dict={X: X_batch, y: y_batch}) acc_val = accuracy. eval(feed_dict={X: mnist. validation. images, y: mnist. validation. labels}) print(epoch, "Train accuracy:", acc_train, "Val accuracy:", acc_val) save_path = saver. save(sess, ". /my_model_final. ckpt") Este código abre uma sessão Tensor Flow e executa o nó init que inicializa todas as variáveis. Em seguida, ele executa o loop principal de treinamento: em cada época, o código itera através de vários minilotes que correspondem ao tamanho do conjunto de treinamento. Cada minilote é buscado pelo método next_batch() e, então, o código executa a operação de treinamento fornecendo os dados de entrada de minilotes atuais e alvos. Em seguida, ao final de cada época, o código avalia o modelo no último minilote no conjunto completo de validação e imprime o resultado. Finalmente, os parâmetros do modelo são salvos no disco. Utilizando a Rede Neural Agora que a rede neural está treinada, você pode usá-la para fazer previsões. Para isso, reutilize a mesma fase de construção, mas mude a fase de execução desta forma: with tf. Session() as sess: saver. restore(sess, ". /my_model_final. ckpt") X_new_scaled = [... ] # algumas novas imagens (escaladas de 0 a 1) Z = logits. eval(feed_dict={X: X_new_scaled}) y_pred = np. argmax(Z, axis=1) Primeiro, o código carrega os parâmetros do modelo a partir do disco. Em seguida, carrega algumas novas imagens que classificará. Lembre-se de aplicar o mesmo escalo-namento de características, assim como os dados de treinamento (neste caso, escalone-o de 0 a 1). Em seguida, o código avalia o nó logits. Você aplicaria a função softmax() aos logits se quisesse conhecer todas as probabilidades estimadas das classes, mas, se quisesse apenas prever uma classe, escolheria a que possui o maior valor de logit (a função argmax() cumpre essa tarefa). CG_MIOLO_Hands_On_Machine_Learning. indb 276 07/05/2019 17:09:19 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
Ajustando os Hiperparâmetros da Rede Neural | 277Ajustando os Hiperparâmetros da Rede Neural A flexibilidade das redes neurais também é uma das suas principais desvantagens: há muitos hiperparâmetros para ajustar. Você pode não apenas utilizar qualquer topologia de rede imaginável (como os neurônios estão interconectados), mas mesmo em um MLP simples você pode alterar seu número de camadas, o número de neurônios por camada, o tipo de função de ativação utilizado em cada camada, o peso da lógica de inicialização e muito mais. Como saber qual seria a melhor combinação de hiperparâmetros para sua tarefa? Claro que você pode utilizar a grid search com validação cruzada para encontrar os hiperparâmetros corretos, como feito em capítulos anteriores, mas existem muitos hiperparâmetros a serem ajustados, e, como o treinamento de uma rede neural em um grande conjunto de dados demora muito, você só poderá explorar uma pequena parcela do espaço de hiperparâmetro em uma quantidade razoável de tempo. É bem melhor utilizar a busca aleatória ( https://goo. gl/QFj MKu ), como discutimos no Capítulo 2. Outra opção seria utilizar uma ferramenta como o Oscar ( http://oscar. calldesk. ai/ ), que implementa algoritmos mais complexos para ajudá-lo na busca de um bom conjunto de hiperparâmetros rapidamente. Ter uma ideia de quais valores seriam razoáveis para cada hiperparâmetro é útil a fim de restringir o espaço de busca. Começaremos com o número de camadas ocultas. Número de Camadas Ocultas Em vários problemas é possível começar com uma única camada oculta e obter resulta-dos razoáveis. Ficou demonstrado que um MLP com apenas uma camada oculta pode modelar até as funções mais complexas desde que tenha neurônios suficientes. Durante muito tempo, esses fatos convenceram os pesquisadores de que não havia necessidade de investigar redes neurais mais profundas. No entanto, foi ignorado o fato de que as redes profundas têm uma eficiência de parâmetro muito maior do que as rasas: utilizando exponencialmente menos neurônios do que as redes superficiais, elas podem modelar funções complexas, tornando seu treinamento muito mais rápido. Para entender o porquê, suponha que você seja convidado a desenhar uma floresta com a utilização de algum software de ilustração, mas está proibido de usar o copiar/colar. Você precisaria desenhar cada árvore individualmente, ramo por ramo, folha por folha. Se, em vez disso, você pudesse desenhar uma folha, copiar/colar para desenhar um ramo, copiar/colar esse ramo para criar uma árvore e, finalmente, copiar/colar esta árvore para criar uma floresta, você terminaria muito mais rápido. Os dados do mundo real CG_MIOLO_Hands_On_Machine_Learning. indb 277 07/05/2019 17:09:19 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
278 | Capítulo 10: Introdução às Redes Neurais Artificiaismuitas vezes são estruturados de maneira bem hierárquica e as DNNs se aproveitam automaticamente desse fato: camadas ocultas inferiores modelam as estruturas de baixo nível (por exemplo, segmentos de linha de várias formas e orientações), camadas ocultas intermediárias combinam essas estruturas de baixo nível para modelar estruturas de nível intermediário (por exemplo, quadrados e círculos), e, para modelar estruturas de alto nível (por exemplo, rostos), as camadas ocultas mais altas e a camada de saída combinam essas estruturas intermediárias. Essa arquitetura hierárquica não só ajuda as DNNs a convergir mais rapidamente para uma boa solução, mas também melhora sua capacidade de generalizar para novos con-juntos de dados. Por exemplo, se você já treinou um modelo para reconhecer rostos em imagens e agora você deseja treinar uma nova rede neural para reconhecer penteados, então você pode iniciar o treinamento reutilizando as camadas inferiores da primeira rede. Em vez de inicializar aleatoriamente os pesos e as polarizações das primeiras camadas da nova rede neural, você pode inicializá-los no valor dos pesos e viéses das camadas inferiores da primeira rede. Desta forma, a rede não terá que aprender do zero todas as estruturas presentes na maioria das imagens; só terá que aprender aquelas do nível superior (por exemplo, penteados). Em resumo, comece com apenas uma ou duas camadas ocultas e ela funcionará muito bem para muitos problemas (por exemplo, você pode facilmente alcançar uma acurácia acima de 97% no conjunto de dados MNIST utilizando uma única camada oculta com poucas centenas de neurônios, e acima de 98% de acurácia com a utilização de duas camadas ocultas com a mesma quantidade de neurônios, em aproximadamente a mes-ma quantidade de tempo de treinamento). Para problemas mais complexos, você pode aumentar gradualmente o número de camadas ocultas até começar a sobreajustar o con-junto de treinamento. Tarefas muito complexas, como a classificação de grandes imagens, ou o reconhecimento de voz, normalmente requerem redes com dezenas de camadas (ou mesmo centenas, mas não totalmente conectadas, como veremos no Capítulo 13) e elas precisam de uma enorme quantidade de dados de treinamento. No entanto, você raramente terá que treinar essas redes do zero: é muito mais comum reutilizar partes de uma rede pré-treinada de última geração que execute uma tarefa similar. O treinamento será muito mais rápido e exigirá muito menos dados (discutiremos isso no Capítulo 11). Número de Neurônios por Camada Oculta Obviamente, o número de neurônios nas camadas de entrada e saída é determinado pelo tipo de entrada e saída que sua tarefa requer. Por exemplo, a tarefa MNIST requer 28 x 28 = 784 neurônios de entrada e 10 neurônios de saída. Quanto às camadas ocultas, uma prática comum é dimensioná-las para formar um funil com cada vez menos neurônios CG_MIOLO_Hands_On_Machine_Learning. indb 278 07/05/2019 17:09:19 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
Ajustando os Hiperparâmetros da Rede Neural | 279em cada camada, sendo o raciocínio que muitas características de baixo nível podem se unir em muito menos características de alto nível. Por exemplo, uma rede neural típica para o MNIST pode ter duas camadas ocultas, a primeira com 300 neurônios e a segunda com 100. No entanto, esta prática não é tão comum agora e você pode simplesmente utilizar o mesmo tamanho para todas as camadas ocultas — por exemplo, todas as ca-madas ocultas com 150 neurônios significa ajustar apenas um hiperparâmetro em vez de um por camada. Assim como para o número de camadas, você pode tentar aumen-tar o número de neurônios gradualmente até que a rede comece a se sobreajustar. Em geral, você obterá mais vantagem aumentando o número de camadas do que o número de neurônios por camada. Infelizmente, como você pode ver, encontrar a quantidade perfeita de neurônios ainda requer um pouco de magia. Uma abordagem mais simples seria escolher um modelo com mais camadas e neurônios do que você realmente precisa e, em seguida, utilizar uma parada antecipada para impedir que ele seja sobreajustado (e outras técnicas de regularização, especialmente o dropout, como veremos no Capítulo 11). Isso foi apelidado de abordagem “calça elástica”:12 em vez de perder tempo procurando por calças que sejam perfeitamente do seu tamanho, basta utilizar calças grandes que encolherão para o tamanho certo. Funções de Ativação Na maioria dos casos, você pode utilizar a função de ativação Re LU nas camadas ocul-tas (ou uma de suas variantes, como veremos no Capítulo 11). É um pouco mais rápida para calcular do que outras funções de ativação e o Gradiente Descendente não fica tão preso em platôs graças ao fato de que ele não satura para grandes valores de entrada (em oposição à função logística ou à função tangente hiperbólica, que satura em 1). Quando as classes são mutuamente exclusivas, a função de ativação softmax geralmente é uma boa opção para as tarefas de classificação na camada de saída. Quando não são (ou quando existem apenas duas classes), utilize a função logística. Nas tarefas de regressão, você pode simplesmente não utilizar nenhuma função de ativação para a camada de saída. Concluímos, então, esta introdução às redes neurais artificiais. Nos capítulos seguintes, discutiremos técnicas para treinar redes muito profundas e distribuiremos treinamentos em vários servidores e GPUs. Então exploraremos outras arquiteturas de redes neurais populares: convolutivas, recorrentes e autoencoders. 13 12 Stretch pants, po r Vincent Vanhoucke em sua aula de Aprendizado Profundo ( https://goo. gl/Y5TFqz ) no Udacity. com. 13 Out ras Arquiteturas Populares ANN são apresentadas no Apêndice E CG_MIOLO_Hands_On_Machine_Learning. indb 279 07/05/2019 17:09:19 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |