Datasets:

pdf2dataset

/

9ef7e448f98c9c2dc5909bfe8f887c25

like 0

80 | Capítulo 2: Projeto de Aprendizado de Máquina de Ponta a Ponta Avalie Seu Sistema no Conjunto de Testes Depois de ajustar seus modelos por um tempo você terá um sistema que funciona sufi-cientemente bem. Agora é a hora de avaliar o modelo final no conjunto de teste. Não há nada de especial neste processo; apenas obtenha as previsões e os rótulos do seu conjunto de teste, execute full_pipeline para transformar os dados (chame transform(), não fit_transform() !) e avalie o modelo final no conjunto de teste: final_model = grid_search. best_estimator_ X_test = strat_test_set. drop("median_house_value", axis=1) y_test = strat_test_set["median_house_value"]. copy() X_test_prepared = full_pipeline. transform(X_test)final_predictions = final_model. predict(X_test_prepared)final_mse = mean_squared_error(y_test, final_predictions) final_rmse = np. sqrt(final_mse) # => avalia em 47,766. 0 O desempenho geralmente será um pouco pior do que o medido usando validação cruzada se você fez muitos ajustes de hiperparâmetro (porque o sistema acabou sendo ajustado para executar bem com dados de validação e provavelmente não funcionará tão bem em conjuntos desconhecidos de dados). Não é o caso neste exemplo, mas, quando isso acontece, você deve resistir à tentação de ajustar os hiperparâmetros para que os números fiquem mais atraentes no conjunto de teste; as melhorias não seriam genera-lizadas para novos dados. Agora, vem a fase de pré-lançamento do projeto: você precisa apresentar sua solução (destacando o que aprendeu, o que funcionou e o que não, quais pressupostos foram feitos e quais as limitações do seu sistema); documente tudo e crie apresentações detalhadas com visualizações claras e declarações que sejam fáceis de lembrar (por exemplo, “a renda média é o principal previsor dos preços do setor imobiliário”). Lance, Monitore e Mantenha seu Sistema Perfeito, você obteve aprovação para o lançamento! Você precisa preparar sua solução para a produção, principalmente conectando as fontes de dados de entrada da produção ao seu sistema e escrevendo testes. Você também precisa escrever o código de monitoramento para verificar o desempenho ao vivo em intervalos regulares do seu sistema e acionar alertas quando ele ficar offline. Isso é importante, não apenas para capturar uma quebra súbita, mas também a degra-dação do desempenho. Isso é bastante comum porque os modelos tendem a “deteriorar” CG_MIOLO_Hands_On_Machine_Learning. indb 80 07/05/2019 17:08:13

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

Experimente! | 81à medida que os dados evoluem ao longo do tempo, a menos que sejam regularmente treinados em novos dados. A avaliação do desempenho do seu sistema exigirá uma amostragem das previsões do sistema e sua avaliação. Isso geralmente requer uma análise humana. Esses analistas podem ser especialistas ou trabalhadores de uma plataforma de crowdsourcing (como a Amazon Mechanical Turk ou Crowd Flower). De qualquer forma, você precisará conectar o canal de avaliação humana ao seu sistema. Você também deve certificar-se de avaliar a qualidade de dados de entrada do sistema. Às vezes, o desempenho se deteriorará levemente por causa de um sinal de má qualidade (por exemplo, uma falha do sensor que envia valores aleatórios ou o resultado de outra equipe que se torna obsoleto), mas pode demorar até que o desempenho se degrade o suficiente para disparar um alerta. Você pode capturar isso antecipadamente se moni-torar suas entradas. O monitoramento das entradas é particularmente importante para os sistemas de aprendizado online. Finalmente, você deve treinar regularmente seus modelos com a utilização de novos dados. Esse processo deve ser automatizado tanto quanto possível. Se não for, a proba-bilidade é que você apenas o atualize a cada seis meses (na melhor das hipóteses), e o seu desempenho pode variar bastante ao longo do tempo. Se for um sistema de aprendizado online certifique-se de salvar capturas de tela do seu estado atual em intervalos regulares para que seja possível reverter facilmente para um estágio anterior do trabalho. Experimente! Esperamos que este capítulo tenha dado uma boa ideia do que é um projeto de Apren-dizado de Máquina e tenha mostrado algumas das ferramentas que você utilizará para treinar um grande sistema. Como você pode ver, grande parte do trabalho está na etapa de preparação dos dados, na construção de ferramentas de monitoramento, na criação de canais de avaliação humana e na automação do treinamento regular de um modelo. Os algoritmos de Aprendizado de Máquina também são importantes, é claro, mas é preferível ficar confortável com o processo geral e ter um bom conhecimento de três ou quatro algoritmos do que gastar todo o seu tempo explorando algoritmos avançados e não ter tempo suficiente para o processo como um todo. Então, se você ainda não o fez, agora é um bom momento para pegar um notebook, selecionar um conjunto de dados do seu interesse e tentar passar por todo o processo de A a Z. Um bom lugar para começar seria em um website de competição como o http://kaggle. com/ : você terá um conjunto de dados para utilização, um objetivo claro e pessoas com quem compartilhar a experiência. CG_MIOLO_Hands_On_Machine_Learning. indb 81 07/05/2019 17:08:13

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

82 | Capítulo 2: Projeto de Aprendizado de Máquina de Ponta a Ponta Exercícios Utilizando o conjunto de dados do setor imobiliário deste capítulo: 1. Exp erimente um regressor da Máquina de Vetores de Suporte ( sklearn. svm. SVR ), com vários hiperparâmetros, como kernel=“linear” (com vários valores para o hiper-parâmetro C) ou kernel=“rbf” (com vários valores para os hiperparâmetros C e gamma ). Não se preocupe com o significado desses hiperparâmetros por enquanto. Qual será o desempenho do melhor previsor da SVR? 2. Ten te substituir Grid Search CV por Randomized Search CV. 3. Ten te acrescentar um transformador no pipeline de preparação para selecionar apenas os atributos mais importantes. 4. Ten te criar um pipeline único que faça a preparação completa de dados mais a previsão final. 5. Exp lore automaticamente algumas opções de preparação utilizando o Grid Search CV. As soluções para estes exercícios estão disponíveis online nos notebooks Jupyter em https://github. com/ageron/handson-ml. CG_MIOLO_Hands_On_Machine_Learning. indb 82 07/05/2019 17:08:13

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

83Capítulo 3 Classificação No Capítulo 1, mencionamos que regressão (previsão de valores) e classificação (previsão de classes) são as tarefas de aprendizado supervisionado mais comuns. No Capítulo 2, utilizando diversos algoritmos como a Regressão Linear, Árvores de Decisão e Florestas Aleatórias (que será explicado em detalhes em capítulos posteriores), exploramos uma tarefa de regressão para prever preços do mercado imobiliário. Agora, voltaremos nossa atenção para os sistemas de classificação. MNIST Neste capítulo, utilizaremos o conjunto de dados MNIST, composto de 70 mil pequenas imagens de dígitos escritos a mão por estudantes do ensino médio e funcionários do US Census Bureau. Cada imagem é rotulada com o dígito que a representa. Este conjunto tem sido tão estudado que, muitas vezes, é chamado de o " Hello World" do Aprendizado de Máquina: sempre que as pessoas apresentam um novo algoritmo de classificação, elas têm curiosidade em ver como será seu desempenho no MNIST. Sempre que alguém estuda o Aprendizado de Máquina, mais cedo ou mais tarde lidará com o MNIST. O Scikit-Learn fornece muitas funções auxiliares para baixar conjuntos de dados po-pulares. O MNIST é um deles. O código a seguir se vale do conjunto de dados MNIST:1 >>> from sklearn. datasets import fetch_mldata >>> mnist = fetch_mldata('MNIST original') >>> mnist {'COL_NAMES': ['label', 'data'], 'DESCR': 'mldata. org dataset: mnist-original', 'data': array([[0, 0, 0,..., 0, 0, 0], [0, 0, 0,..., 0, 0, 0], 1 Por padrão, o Scikit-Learn armazena conjuntos de dados baixados em um diretório chamado $HOME/scikit_learn_data. CG_MIOLO_Hands_On_Machine_Learning. indb 83 07/05/2019 17:08:13

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

84 | Capítulo 3: Classificação [0, 0, 0,..., 0, 0, 0], ..., [0, 0, 0,..., 0, 0, 0], [0, 0, 0,..., 0, 0, 0], [0, 0, 0,..., 0, 0, 0]], dtype=uint8), 'target': array([ 0., 0., 0.,..., 9., 9., 9. ])} Os conjuntos de dados carregados pelo Scikit-Learn geralmente possuem uma estrutura similar ao dicionário, incluindo: Uma c have DESCR que descreve o conjunto de dados; Uma c have de dados que contém um array com uma linha por instância e uma coluna por característica; Uma c have alvo contendo um array com os rótulos. Vejamos estes arrays: >>> X, y = mnist["data"], mnist["target"] >>> X. shape(70000, 784) >>> y. shape (70000,) Há 70 mil imagens e cada imagem possui 784 características. Isso ocorre porque cada imagem tem 28 × 28 pixels, e cada característica representa a intensidade de um pixel, de 0 (branco) a 255 (preto). Vamos dar uma olhada em um dígito do conjunto de dados. Utilizando a função imshow() do Matplotlib, você só precisa pegar um vetor de carac-terística de uma instância, remodelá-lo para um array de 28 × 28 e exibi-lo: %matplotlib inline import matplotlibimport matplotlib. pyplot as plt some_digit = X[36000] some_digit_image = some_digit. reshape(28, 28) plt. imshow(some_digit_image, cmap = matplotlib. cm. binary, interpolation="nearest") plt. axis("off")plt. show() Isso parece um 5, e de fato é isso o que o rótulo nos diz: >>> y[36000] 5. 0 CG_MIOLO_Hands_On_Machine_Learning. indb 84 07/05/2019 17:08:14

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

MNIST| 85A Figura 3-1 mostra algumas outras imagens do conjunto de dados MNIST para dar a você uma ideia da complexidade da tarefa de classificação. Figura 3-1. Alguns dígitos do conjunto de dados MNIST Mas espere! Você sempre deve criar um conjunto de teste e deixá-lo de lado antes de inspecionar os dados de perto. O conjunto de dados MNIST na verdade já está dividido em um conjunto de treinamento (as primeiras 60 mil imagens) e um conjunto de teste (as últimas 10 mil imagens): X_train, X_test, y_train, y_test = X[:60000], X[60000:], y[:60000], y[60000:] Vamos embaralhar o conjunto de treinamento; isso garantirá que todos os subconjuntos da validação cruzada sejam semelhantes (assim você se certifica que nenhum subconjunto fique sem algum dígito). Além disso, alguns algoritmos de aprendizado são sensíveis à ordem das instâncias de treinamento, e, se obtiverem muitas instâncias similares, fun-cionarão mal. Embaralhar o conjunto de dados garante que isso não ocorra: 2 import numpy as np shuffle_index = np. random. permutation(60000) X_train, y_train = X_train[shuffle_index], y_train[shuffle_index] 2 O embaralhamento em alguns contextos pode ser uma má ideia — por exemplo, se você estiver trabalhando em dados de séries temporais (como preços no mercado de ações ou condições climáticas). Exploraremos isso nos próximos capítulos. CG_MIOLO_Hands_On_Machine_Learning. indb 85 07/05/2019 17:08:14

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

86 | Capítulo 3: Classificação Treinando um Classificador Binário Vamos simplificar o problema por ora e tentar apenas identificar um dígito — por exemplo, o número 5. Este “5-detector ” será um exemplo de classificador binário capaz de distinguir apenas entre duas classes: 5 e não 5. Vamos criar os vetores-alvo para esta tarefa de classificação: y_train_5 = (y_train == 5) # True for all 5s, False for all other digits. y_test_5 = (y_test == 5) Certo, agora vamos escolher um classificador e treiná-lo. Um bom lugar para começar é com um classificador de Gradiente Descendente Estocástico (SGD, do inglês) com a utilização da classe SGDClassifier do Scikit-Learn. Este classificador tem a vantagem de conseguir lidar eficientemente com conjuntos de dados muito grandes. Isso se deve, em parte, ao fato de o SGD lidar independentemente com instâncias de treinamento, uma de cada vez (o que tam-bém torna o SGD adequado para o aprendizado online ) como veremos mais adiante. Vamos criar um SGDClassifier e treiná-lo em todo o conjunto de treinamento: from sklearn. linear_model import SGDClassifier sgd_clf = SGDClassifier(random_state=42) sgd_clf. fit(X_train, y_train_5) O SGDClassifier depende da aleatoriedade durante o treina-mento (daí o nome “estocástico ”). Você deve definir o parâmetro random_state se desejar resultados reprodutíveis. Agora, você pode utilizá-lo para detectar imagens do número 5: >>> sgd_clf. predict([some_digit]) array([ True], dtype=bool) O classificador supõe que esta imagem representa um 5 ( True ). Parece que adivinhou corretamente neste caso! Agora, avaliaremos o desempenho desse modelo. Medições de Desempenho Avaliar um classificador é muitas vezes significativamente mais complicado do que avaliar um regressor, portanto, passaremos uma grande parte deste capítulo neste tó-pico. Existem muitas medições de desempenho disponíveis, então pegue outro café e prepare-se para aprender muitos novos conceitos e siglas! CG_MIOLO_Hands_On_Machine_Learning. indb 86 07/05/2019 17:08:15

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

Medições de Desempenho| 87Medição da Acurácia com a Utilização da Validação Cruzada Uma boa maneira de avaliar um modelo é utilizar a validação cruzada, assim como você fez no Capítulo 2. Implementando a Validação Cruzada Às vezes, você precisará ter mais controle sobre o processo de validação cruzada do que o Scikit-Learn pode fornecer. Nesses casos, você mesmo pode implementar a validação cruzada; na verdade, ela é bem descomplicada e simples de se entender. O código a seguir faz aproximadamente a mesma coisa que a função cross_val_score() do Scikit-Learn e imprime o mesmo resultado: from sklearn. model_selection import Stratified KFold from sklearn. base import clone skfolds = Stratified KFold(n_splits=3, random_state=42)for train_index, test_index in skfolds. split(X_train, y_train_5): clone_clf = clone(sgd_clf) X_train_folds = X_train[train_index] y_train_folds = y_train_5[train_index] X_test_fold = X_train[test_index] y_test_fold = y_train_5[test_index] clone_clf. fit(X_train_folds, y_train_folds) y_pred = clone_clf. predict(X_test_fold) n_correct = sum(y_pred == y_test_fold) print(n_correct / len(y_pred)) # prints 0. 9502, 0. 96565 and 0. 96495 A classe Stratified KFold executa a amostragem estratificada (como explicado no Capítulo 2) para produzir subconjuntos que contêm uma proporção representativa de cada classe. Em cada iteração, o código cria um clone do classificador, treina esse clone nas partes de treinamento e faz previsões na parte do teste. Então, conta o número de previsões corretas e entrega a proporção das previsões corretas. Utilizaremos a função cross_val_score() para avaliar o seu modelo SGDClassifier com a utilização da validação cruzada K-fold com três partes. Lembre-se de que a validação cruzada K-fold significa dividir o conjunto de treinamento em K-folds (neste caso, três), prever e avaliar as previsões em cada conjunto utilizando um modelo treinado em con-juntos restantes (ver Capítulo 2): >>> from sklearn. model_selection import cross_val_score >>> cross_val_score(sgd_clf, X_train, y_train_5, cv=3, scoring="accuracy") array([ 0. 9502, 0. 96565, 0. 96495]) CG_MIOLO_Hands_On_Machine_Learning. indb 87 07/05/2019 17:08:15

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

88 | Capítulo 3: Classificação Muito bom! Acima de 95% de acurácia (taxa das previsões corretas) em todas as partes da validação cruzada? É incrível, não? Bem, antes que você fique muito animado, veja-mos um classificador muito fraco que apenas classifica cada imagem na classe “não 5”: from sklearn. base import Base Estimator class Never5Classifier(Base Estimator): def fit(self, X, y=None): pass def predict(self, X): return np. zeros((len(X), 1), dtype=bool) Você consegue adivinhar a acurácia deste modelo? Vamos descobrir: >>> never_5_clf = Never5Classifier() >>> cross_val_score(never_5_clf, X_train, y_train_5, cv=3, scoring="accuracy") array([ 0. 909 , 0. 90715, 0. 9128 ]) Sim, tem mais de 90% de acurácia! Isso se dá simplesmente porque apenas cerca de 10% das imagens são “5”, então, se você sempre adivinhar que uma imagem não é um 5, você estará certo cerca de 90% das vezes. Ganharia até de Nostradamus. Isso demonstra por que a acurácia para os classificadores geralmente não é a medida preferencial de desempenho, especialmente quando você estiver lidando com conjuntos de dados assimétricos (ou seja, quando algumas classes forem muito mais frequentes do que outras). Matriz de Confusão Uma maneira de avaliar bem melhor o desempenho de um classificador é olhar para a matriz de confusão. A ideia geral é contar o número de vezes que as instâncias da classe A são classificadas como classe B. Por exemplo, para saber o número de vezes que o classificador confundiu imagens de “5” com “3”, você olharia na 5ª linha e 3ª coluna da matriz da confusão. Para calcular a matriz de confusão, primeiro você precisa ter um conjunto de previsões para que possam ser comparadas com os alvos reais. Você pode fazer previsões no conjunto de testes, mas vamos deixá-lo intocado por enquanto (lembre-se de que você vai querer utilizar o conjunto de testes apenas no final do seu projeto, quando tiver um classificador pronto para lançar). Em vez disso, utilize a função cross_val_predict() : from sklearn. model_selection import cross_val_predict y_train_pred = cross_val_predict(sgd_clf, X_train, y_train_5, cv=3) CG_MIOLO_Hands_On_Machine_Learning. indb 88 07/05/2019 17:08:15

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

Medições de Desempenho| 89Assim como a função cross_val_score(), cross_val_predict() desempenha a validação cruzada K-fold, mas, em vez de retornar as pontuações da avaliação, ela retorna as pre-visões feitas em cada parte do teste. Isso significa que você obtém uma previsão limpa para cada instância no conjunto de treinamento (“limpa”, significando que a previsão é feita por um modelo que nunca viu os dados durante o treinamento). Utilizando a função confusion_matrix(), agora você está pronto para obter a matriz de confusão. Apenas passe as classes-alvo ( y_train_5 ) e as classes previstas ( y_train_pred ): >>> from sklearn. metrics import confusion_matrix >>> confusion_matrix(y_train_5, y_train_pred) array([[53272, 1307], [ 1077, 4344]]) Cada linha em uma matriz de confusão representa uma classe real, enquanto cada coluna representa uma classe prevista. A primeira linha desta matriz considera imagens não 5 (a classe negativa ): 53. 272 delas foram corretamente classificadas como não 5 (elas são chamadas de verdadeiros negativos ), enquanto as restantes 1. 307 foram erroneamente classificadas como 5 ( falsos positivos ). A segunda linha considera as imagens dos 5 (a classe positiva ): 1. 077 foram classificadas erroneamente como não 5 ( falso negativos ), enquanto as restantes 4. 344 foram corretamente classificadas como 5 ( verdadeiros positivos ). Um classificador perfeito teria apenas verdadeiros positivos e verdadeiros negativos, então sua matriz de confusão teria valores diferentes de zero somente na sua diagonal principal (superior esquerda para inferior direita): >>> confusion_matrix(y_train_5, y_train_perfect_predictions) array([[54579, 0], [ 0, 5421]]) A matriz de confusão fornece muitas informações, mas às vezes pode ser que você pre-fira uma métrica mais concisa. Uma coisa interessante a ser observada é a acurácia das previsões positivas; que é chamada de precisão do classificador (Equação 3-1). Equação 3-1. Precisão precisão =TP TP+FP TP é o número de verdadeiros positivos, e FP é o número de falsos positivos. Uma maneira trivial de ter uma precisão perfeita é fazer uma única previsão positiva e garantir que ela seja correta (precisão = 1/1 = 100%). Isso não seria muito útil uma vez que o classificador ignoraria todas, exceto uma instância positiva. Portanto, a precisão é utilizada em conjunto com outra métrica chamada revocação, também conhecida como sensibilidade ou taxa de verdadeiros positivos (TPR, do inglês ): esta é a taxa de instâncias positivas que são corretamente detectadas pelo classificador (Equação 3-2). CG_MIOLO_Hands_On_Machine_Learning. indb 89 07/05/2019 17:08:16

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

90 | Capítulo 3: Classificação Equação 3-2. Revocação revocaçã o =TP TP+FN FN é, naturalmente, o número de falsos negativos. Se você estiver perdido com a matriz de confusão, a Figura 3-2 pode ajudar. TPTN FNFP Precisão (por ex empl o, 3 de 4) Revocação (por ex emplo, 3 de 5)Negativa Previsto Positiva Negativa Positiva Real Figura 3-2. Uma matriz de confusão ilustrada Precisão e Revocação O Scikit-Learn fornece várias funções para calcular métricas classificadoras, incluindo precisão e revocação: >>> from sklearn. metrics import precision_score, recall_score >>> precision_score(y_train_5, y_train_pred) # == 4344 / (4344 + 1307) 0. 76871350203503808 >>> recall_score(y_train_5, y_train_pred) # == 4344 / (4344 + 1077) 0. 80132816823464303 Agora, o seu 5-detector não parece tão brilhante como quando você analisou sua precisão. Quando ele afirma que uma imagem representa um 5, ele está correto apenas 77% das vezes. Além disso, ele só detecta 80% dos “5”. Muitas vezes, é conveniente combinar precisão e revocação em uma única métrica chamada pontuação F 1, principalmente se você precisar de uma forma simples de comparar dois classificadores. A pontuação F 1 é a média harmônica da precisão e revocação (Equação 3-3). Enquanto a média regular trata igualmente todos os valores, a média harmônica dá muito mais peso aos valores mais baixos. Como resultado, o classificador só obterá uma pontuação F1 alta se a revocação e a precisão forem altas. CG_MIOLO_Hands_On_Machine_Learning. indb 90 07/05/2019 17:08:16

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

Medições de Desempenho| 91Equação 3-3. Pontuação F 1 F1=2 1 precisão+1 revocação=2×precisão × revocação precisão +revocação=TP TP+FN+FP 2 Para calcular a pontuação F 1 chame a função f1_score() : >>> from sklearn. metrics import f1_score >>> f1_score(y_train_5, y_train_pred) 0. 78468208092485547 A pontuação F 1 favorece classificadores com precisão e revocação similares. Isso nem sempre é o que você quer: em alguns contextos, sua preocupação é principalmente com a precisão, e, em outros, você realmente se preocupa com a revocação. Por exemplo, se você treinou um classificador para detectar vídeos que são adequados para crianças, provavelmente prefe-riria um classificador que rejeitasse muitos bons vídeos (baixa revocação), mas mantivesse somente os adequados (alta precisão); em detrimento de um classificador que tivesse uma revocação bem mais alta, mas que permitiria que alguns vídeos realmente ruins aparecessem em seu produto (em tais casos, é necessário adicionar um pipeline humano para verificar a seleção do classificador de vídeo). Por outro lado, suponha que você treine um classificador para detectar bandidos nas imagens do sistema de segurança: é provavelmente tranquilo se seu classificador tiver uma precisão de apenas 30%, desde que tenha 99% de revocação (com certeza os guardas de segurança receberão alguns alertas falsos, mas quase todos os ladrões serão pegos). Infelizmente, não é possível ter os dois: aumentar a precisão reduz a revocação, e vice--versa. Isso é chamado de compensação da precisão/revocação. Compensação da Precisão/Revocação Para entender essa compensação, vejamos como o SGDClassifier toma suas decisões de classificação. Para cada instância, ele calcula uma pontuação baseada em uma função de decisão e, se essa pontuação for maior que um limiar, ele atribui a instância à classe posi-tiva, ou então a atribui à classe negativa. A Figura 3-3 mostra alguns dígitos posicionados a partir da pontuação inferior na esquerda para a pontuação mais alta à direita. Suponha que o limiar de decisão seja posicionado na seta central (entre os dois 5): você encontrará 4 verdadeiros positivos (5 reais) à direita desse limiar, e um falso positivo (na verdade, um 6). Portanto, a precisão é de 80% (4 de 5) com esse limiar. Mas a cada 6 dos 5 verdadeiros, o classificador só detecta 4, então a revocação é de 67% (4 de 6). Agora, se você aumentar o limiar (mova-o para a seta à direita) o falso positivo (o 6) torna-se um verdadeiro negativo, CG_MIOLO_Hands_On_Machine_Learning. indb 91 07/05/2019 17:08:17

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

92 | Capítulo 3: Classificaçãoaumentando assim a precisão (até 100% neste caso), mas um verdadeiro positivo torna-se um falso negativo, diminuindo a revocação para 50%. Assim, diminuir o limiar aumenta a revocação e reduz a precisão. Vários limiares Previsões negativas Precisão Revocação Previsões positivas Pontuação Figura 3-3. Limiar de decisão e compensação de precisão/revocação O Scikit-Learn não permite que você defina o limiar diretamente, mas lhe dá acesso às pontuações de decisão que ele utiliza para fazer previsões. Em vez de chamar o método predict() do classificador, você pode chamar o método decision_function(), que re-torna uma pontuação para cada instância e, em seguida, faz previsões com base nessas pontuações utilizando qualquer limiar desejado: >>> y_scores = sgd_clf. decision_function([some_digit]) >>> y_scores array([ 161855. 74572176]) >>> threshold = 0 >>> y_some_digit_pred = (y_scores > threshold) array([ True], dtype=bool) O SGDClassifier utiliza um limiar igual a 0, então o código anterior retorna o mesmo resultado que o método predict() (isto é, True ). Aumentaremos o limiar: >>> threshold = 200000 >>> y_some_digit_pred = (y_scores > threshold) >>> y_some_digit_pred array([False], dtype=bool) Isso confirma que aumentar o limiar diminui a revocação. A imagem realmente repre-senta um 5, e o classificador o detecta quando o limiar é 0, mas o perde quando o limiar sobe para 200 mil. Então, como você pode decidir qual limiar utilizar? Para isso, utilizando novamente a função cross_val_predict(), você precisará primeiro obter as pontuações de todas as instâncias no conjunto de treinamento, mas desta vez especificando que deseja que ela retorne as pontuações da decisão em vez das previsões: y_scores = cross_val_predict(sgd_clf, X_train, y_train_5, cv=3, method="decision_function") CG_MIOLO_Hands_On_Machine_Learning. indb 92 07/05/2019 17:08:17

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

Medições de Desempenho| 93Agora, utilizando a função precision_recall_curve() com essas pontuações, você pode calcular a precisão e a revocação para todos os limiares possíveis: from sklearn. metrics import precision_recall_curve precisions, recalls, thresholds = precision_recall_curve(y_train_5, y_scores) Finalmente, utilizando o Matplotlib (Figura 3-4), você pode plotar a precisão e a revo-cação como funções de valor do limiar: def plot_precision_recall_vs_threshold(precisions, recalls, thresholds): plt. plot(thresholds, precisions[:-1], "b--", label="Precision") plt. plot(thresholds, recalls[:-1], "g-", label="Recall") plt. xlabel("Threshold") plt. legend(loc="center left") plt. ylim([0, 1]) plot_precision_recall_vs_threshold(precisions, recalls, thresholds) plt. show() Limiar Precisão Revocação Figura 3-4. Precisão e revocação versus o limiar de decisão Você pode se perguntar por que a curva de precisão é mais irregular do que a curva de revocação na Figura 3-4. A razão é que a precisão às vezes pode diminuir quando você aumenta o limiar (embora em geral ela aumente). Para entender o porquê, veja a Figura 3-3 e ob-serve o que acontece quando você começa a partir do limiar central e o move apenas um dígito para a direita: a precisão passa de 4/5 (80%) para 3/4 (75%). Por outro lado, a revocação só diminuirá quando o limiar for aumentado, o que explica por que sua curva parece suave. Agora, você pode selecionar o valor do limiar que lhe dá a melhor compensação de pre-cisão/revocação para sua tarefa. Outra maneira de selecionar uma boa compensação de precisão/revocação é plotar a precisão diretamente contra a revocação, como mostrado na Figura 3-5. CG_MIOLO_Hands_On_Machine_Learning. indb 93 07/05/2019 17:08:18

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

94 | Capítulo 3: Classificação Precisão Revocação Figura 3-5. Precisão versus revocação É possível ver que a precisão realmente começa a diminuir acentuadamente em torno de 80% de revocação. Provavelmente você selecionará uma compensação de precisão/ revocação antes dessa queda — por exemplo, em torno de 60% de revocação. Mas, é claro, que a escolha depende do seu projeto. Então, vamos supor que você almeja 90% de precisão. Você procura a primeira plotagem (aproximando um pouco) e descobre que precisa utilizar um limiar de cerca de 70 mil. Em vez de chamar o método predict() do classificador, você pode apenas executar este código para fazer previsões (por ora, no conjunto de treinamento): y_train_pred_90 = (y_scores > 70000) Verificaremos a precisão e a revocação dessas previsões: >>> precision_score(y_train_5, y_train_pred_90) 0. 86592051164915484 >>> recall_score(y_train_5, y_train_pred_90) 0. 69931746910164172 Ótimo, você tem um classificador com precisão de 90% (ou próximo o suficiente)! Como você pode ver, é muito fácil criar um classificador com praticamente qualquer precisão que desejar: basta definir um limiar alto o suficiente, e pronto. Mas, não vamos tão rápido. Um classificador de alta precisão não terá muita utilidade se a revocação dele for muito baixa! Se alguém disser “vamos alcançar 99% de precisão”, você deve perguntar: “em qual revocação?" CG_MIOLO_Hands_On_Machine_Learning. indb 94 07/05/2019 17:08:19

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

Medições de Desempenho| 95A Curva ROC A curva das características operacionais do receptor (ROC, do inglês) é outra ferramenta comum utilizada com classificadores binários. É muito semelhante à curva de precisão/ revocação, mas, em vez de plotar a precisão versus a revocação, a curva ROC plota a taxa de verdadeiros positivos (TPR, do inglês) (outro nome para revocação) versus a taxa de falsos positivos (FPR, do inglês). O FP R é a razão de instâncias negativas incorretamente classificadas como positivas. É igual a 1 menos a taxa de verdadeiros negativos (TNR, do inglês), que é a razão de instâncias negativas que são corretamente classificadas como negativas. A TNR também é chamada de especificidade. Portanto, a curva ROC plota a sensibilidade (revocação) versus 1-especificidade. Para plotar a curva ROC primeiro você precisa calcular a TPR e FPR para vários valores de limiares usando a função roc_curve() : from sklearn. metrics import roc_curve fpr, tpr, thresholds = roc_curve(y_train_5, y_scores) E, então, você pode plotar a curva FPR versus TPR usando o Matplotlib. Este código produz a plotagem na Figura 3-6: def plot_roc_curve(fpr, tpr, label=None): plt. plot(fpr, tpr, linewidth=2, label=label) plt. plot([0, 1], [0, 1], 'k--') plt. axis([0, 1, 0, 1]) plt. xlabel('False Positive Rate') plt. ylabel('True Positive Rate') plot_roc_curve(fpr, tpr) plt. show() Taxa de Verdadeiros Positivos Taxa de Falsos Positivos Figura 3-6. Curva ROC CG_MIOLO_Hands_On_Machine_Learning. indb 95 07/05/2019 17:08:19

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

96 | Capítulo 3: Classificação Mais uma vez, existe uma compensação: quanto maior a revocação (TPR), mais falsos positivos (FPR) o classificador produz. A linha pontilhada representa a curva ROC de um classificador puramente aleatório; um bom classificador fica o mais distante dessa linha possível (em direção ao canto superior esquerdo). Uma maneira de comparar classificadores é medir a área abaixo da curva (AUC, do in-glês). Um classificador perfeito terá um ROC AUC igual a 1, enquanto um classificador puramente aleatório terá um ROC AUC igual a 0,5. O Scikit-Learn fornece uma função para calcular o ROC AUC: >>> from sklearn. metrics import roc_auc_score >>> roc_auc_score(y_train_5, y_scores) 0. 96244965559671547 Já que a curva ROC é tão semelhante à curva de precisão/revocação (PR), você pode se perguntar como decidir qual delas usar. Como regra geral, você deve preferir a curva PR sempre que a classe po-sitiva for rara ou quando se preocupar mais com os falsos positivos do que com os falsos negativos, e a curva ROC em caso contrário. Por exemplo, olhando a curva ROC anterior (e a pontuação ROC AUC), você pode pensar que o classificador é realmente bom. Mas isso acontece porque existem alguns aspectos positivos (5) em com-paração aos negativos (não 5). Em contraste, a curva PR deixa claro que o classificador pode melhorar (a curva poderia estar mais próxi-ma do canto superior direito). Vamos treinar um Random Forest Classifier e comparar sua curva ROC e a pontuação ROC AUC para o SGDClassifier. Primeiro, você precisa obter pontuações para cada ins-tância no conjunto de treinamento. Mas, devido ao modo como funciona (veja o Capítulo 7), a classe Random Forest Classifier não possui um método decision_function(). Em vez disso, ela possui um método predict_proba(). Os classificadores do Scikit-Learn geralmente têm um ou outro. O método predict_proba() retorna um array que contém uma linha por instância e uma coluna por classe, cada uma contendo a probabilidade de a instância dada pertencer à classe dada (por exemplo, 70% de chance de a imagem representar um 5): from sklearn. ensemble import Random Forest Classifier forest_clf = Random Forest Classifier(random_state=42) y_probas_forest = cross_val_predict(forest_clf, X_train, y_train_5, cv=3, method="predict_proba") Mas, para plotar uma curva ROC, você precisa de pontuação, não probabilidades. Uma solução simples é utilizar a probabilidade da classe positiva como a pontuação: y_scores_forest = y_probas_forest[:, 1] # pontuação = probabilidade de classe positiva fpr_forest, tpr_forest, thresholds_forest = roc_curve(y_train_5,y_scores_forest) CG_MIOLO_Hands_On_Machine_Learning. indb 96 07/05/2019 17:08:19

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

Classificação Multiclasse| 97Agora, você está pronto para plotar a curva ROC. É útil plotar a primeira curva ROC também para ver como elas se comparam (Figura 3-7): plt. plot(fpr, tpr, "b:", label="SGD") plot_roc_curve(fpr_forest, tpr_forest, "Random Forest") plt. legend(loc="lower right") plt. show() Taxa de Verdadeiros Positivos Taxa de Falsos Positivos SGD Floresta Aleatória Figura 3-7. Comparando curvas ROC Como você pode ver na Figura 3-7, a curva ROC do Random Forest Classifier parece bem melhor que a do SGDClassifier : ela se aproxima muito do canto superior esquerdo. Como resultado, sua pontuação ROC AUC também é significativamente melhor: >>> roc_auc_score(y_train_5, y_scores_forest) 0. 99312433660038291 Tente medir as pontuações da precisão e da revocação: você deve encontrar 98,5% de precisão e 82,8% de revocação. Nada mal! Provavelmente, agora você já sabe como treinar classificadores binários, escolher a métrica apropriada para sua tarefa, avaliar seus classificadores utilizando a validação cruzada, selecionar a compensação da precisão/revocação que corresponda às suas necessidades e comparar vários modelos utilizando as curvas ROC e pontuações ROC AUC. Agora, tentaremos detectar mais do que apenas os 5. Classificação Multiclasse Enquanto os classificadores binários se distinguem entre duas classes os classificadores multiclasses (também chamados classificadores multinomiais ) podem se distinguir entre mais de duas classes. CG_MIOLO_Hands_On_Machine_Learning. indb 97 07/05/2019 17:08:20

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

98 | Capítulo 3: Classificação Alguns algoritmos (como os classificadores de Floresta Aleatória ou classificadores Naive-Bayes) são capazes de lidar diretamente com múltiplas classes. Outros (como os classificadores Máquinas de Vetores de Suporte ou classificadores Lineares) são estrita-mente binários. Entretanto, existem várias estratégias que você pode utilizar para realizar a classificação multiclasse com classificadores binários múltiplos. Por exemplo, uma forma de criar um sistema que possa classificar as imagens numéricas em 10 classes (de 0 a 9) é treinar 10 classificadores binários, um para cada dígito (0-de-tector, 1-detector, 2-detector, e assim por diante). Então, quando você quiser classificar uma imagem, você obtém a pontuação de decisão de cada classificador para essa ima-gem e seleciona a classe cujo classificador produz a maior pontuação. Isso é chamado de estratégia um contra todos (Ov A, do inglês) (também chamada one-versus-the-rest ). Outra estratégia é treinar um classificador binário para cada par de dígitos: um para distinguir 0s e 1s, outro para distinguir 0s e 2s, outro para 1s e 2s, e assim por diante. Isto é chamado de estratégia um contra um (Ov O, do inglês). Se existirem N classes, você precisa treinar N × (N-1) / 2 classificadores. O que significa treinar 45 classificadores binários para o problema do MNIST! Quando classificamos uma imagem, devemos rodá-la por todos os 45 classificadores e ver qual classe vence o maior número de duelos. A principal vantagem do Ov O é que cada classificador precisa ser treinado somente para as duas classes que deve distinguir na parte do conjunto de treinamento. Alguns algoritmos (como os classificadores Máquinas de Vetores de Suporte ) escalam mal com o tamanho do conjunto de treinamento, então, para esses algoritmos, o Ov O é melhor, pois é mais rápido treinar muitos classificadores em pequenos conjuntos do que treinar alguns classificadores em grandes conjuntos. Entretanto, Ov A é o melhor para a maioria dos algoritmos de classificação binária. O Scikit-Learn detecta quando você tenta utilizar um algoritmo de classificação bi-nária para uma tarefa de classificação multiclasse, e automaticamente executa o Ov A (exceto para classificadores SVM, para os quais ele utiliza Ov O). Tentaremos isso com o SGDClassifier : >>> sgd_clf. fit(X_train, y_train) # y_train, não y_train_5 >>> sgd_clf. predict([some_digit]) array([ 5. ]) Essa foi fácil! Este código treina o SGDClassifier no conjunto de treinamento uti-lizando as classes-alvo originais de 0 a 9 ( y_train ) em vez das classes-alvo 5 contra todos (y_train_5 ). Então, ele faz uma previsão (correta, neste caso). Nos bastidores, o Scikit-Learn, na verdade, treinou 10 classificadores binários, obteve sua pontuação de decisão para a imagem e selecionou a classe com a maior pontuação. CG_MIOLO_Hands_On_Machine_Learning. indb 98 07/05/2019 17:08:20

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

Classificação Multiclasse| 99Para ver que este é realmente o caso, chamaremos o método decision_function(). Em vez de retornar apenas uma pontuação por instância, ele agora retorna 10 pontuações, uma por classe: >>> some_digit_scores = sgd_clf. decision_function([some_digit]) >>> some_digit_scores array([[-311402. 62954431,-363517. 28355739,-446449. 5306454, -183226. 61023518,-414337. 15339485, 161855. 74572176, -452576. 39616343,-471957. 14962573,-518542. 33997148, -536774. 63961222]]) A pontuação mais alta é realmente aquela que corresponde à classe 5: >>> np. argmax(some_digit_scores) 5 >>> sgd_clf. classes_ array([ 0., 1., 2., 3., 4., 5., 6., 7., 8., 9. ]) >>> sgd_clf. classes_[5] 5. 0 Quando um classificador é treinado, ele armazena a lista das clas-ses-alvo em seu atributo classes_ em ordem de valor. Nesse caso, o índice de cada classe no array classes_ combina convenientemente com a própria classe (por exemplo, a classe no índice 5 também é a classe 5), mas, no geral, você não terá tanta sorte. Se você quiser forçar o Scikit-Learn a utilizar um contra um ou um contra todos, você pode utilizar a classe One Vs One Classifier ou a One Vs Rest Classifier. Crie uma instância e passe um classificador binário para seu construtor. Por exemplo, utilizando a estratégia Ov O, com base no SGDClassifier, este código cria um classificador multiclasse: >>> from sklearn. multiclass import One Vs One Classifier >>> ovo_clf = One Vs One Classifier(SGDClassifier(random_state=42)) >>> ovo_clf. fit(X_train, y_train) >>> ovo_clf. predict([some_digit]) array([ 5. ]) >>> len(ovo_clf. estimators_) 45 Treinar um Random Forest Classifier é muito fácil: >>> forest_clf. fit(X_train, y_train) >>> forest_clf. predict([some_digit]) array([ 5. ]) Desta vez, o Scikit-Learn não precisou executar Ov A ou Ov O porque os classificadores da Floresta Aleatória podem classificar instâncias diretamente em múltiplas classes. Você pode chamar o predict_proba() para obter a lista de probabilidades que o classificador atribuiu a cada instância para cada classe: CG_MIOLO_Hands_On_Machine_Learning. indb 99 07/05/2019 17:08:21

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

100 | Capítulo 3: Classificação>>> forest_clf. predict_proba([some_digit]) array([[ 0. 1, 0., 0., 0. 1, 0., 0. 8, 0., 0., 0., 0. ]]) Podemos ver que o classificador está bastante confiante sobre sua previsão: o 0,8 no 5º índice no array significa que o modelo estima uma probabilidade de 80% de a imagem representar um 5. Ele também acha que a imagem poderia ser um 0 ou um 3 (10% de chance cada). Agora, é claro que você deve avaliar esses classificadores. Como de costume, utilize a validação cruzada. Vamos avaliar a precisão do SGDClassifier utilizando a função cross_val_score() : >>> cross_val_score(sgd_clf, X_train, y_train, cv=3, scoring="accuracy") array([ 0. 84063187, 0. 84899245, 0. 86652998]) Ele consegue acima de 84% em todas as partes do teste. Se você utilizar um classificador aleatório, obterá 10% de precisão, então não é uma pontuação tão ruim, mas você ainda pode melhorar. Por exemplo, dimensionar as entradas aumenta a precisão em mais de 90% (como discutido no Capítulo 2): >>> from sklearn. preprocessing import Standard Scaler >>> scaler = Standard Scaler() >>> X_train_scaled = scaler. fit_transform(X_train. astype(np. float64)) >>> cross_val_score(sgd_clf, X_train_scaled, y_train, cv=3, scoring="accuracy") array([ 0. 91011798, 0. 90874544, 0. 906636 ]) Análise de Erro Claro, se este fosse um projeto real, você seguiria as etapas da sua lista de verificação do projeto de Aprendizado de Máquina (consulte o Apêndice B): explorar opções de preparação de dados, testar vários modelos, selecionar os melhores e ajustar seus hi-perparâmetros utilizando o Grid Search CV e automatizando o máximo possível, como você fez no capítulo anterior. Aqui, assumiremos que você achou um modelo promissor e quer encontrar maneiras de melhorá-lo. Uma maneira de fazer isso é analisar os tipos de erros que ele comete. Primeiro, olhe para a matriz de confusão. Você precisa fazer as previsões com a função cross_val_predict(), então chamar a função confusion_matrix(), assim como fez anteriormente: CG_MIOLO_Hands_On_Machine_Learning. indb 100 07/05/2019 17:08:21

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

Análise de Erro| 101>>> y_train_pred = cross_val_predict(sgd_clf, X_train_scaled, y_train, cv=3) >>> conf_mx = confusion_matrix(y_train, y_train_pred) >>> conf_mx array([[5725, 3, 24, 9, 10, 49, 50, 10, 39, 4], [ 2, 6493, 43, 25, 7, 40, 5, 10, 109, 8], [ 51, 41, 5321, 104, 89, 26, 87, 60, 166, 13], [ 47, 46, 141, 5342, 1, 231, 40, 50, 141, 92], [ 19, 29, 41, 10, 5366, 9, 56, 37, 86, 189], [ 73, 45, 36, 193, 64, 4582, 111, 30, 193, 94], [ 29, 34, 44, 2, 42, 85, 5627, 10, 45, 0], [ 25, 24, 74, 32, 54, 12, 6, 5787, 15, 236], [ 52, 161, 73, 156, 10, 163, 61, 25, 5027, 123], [ 43, 35, 26, 92, 178, 28, 2, 223, 82, 5240]]) São muitos números. Utilizando a função matshow() do Matplotlib, será mais conveniente olhar para uma representação da imagem na matriz de confusão: plt. matshow(conf_mx, cmap=plt. cm. gray) plt. show() Essa matriz de confusão parece muito boa, já que a maioria das imagens está na diago-nal principal, o que significa que foram classificadas corretamente. Os 5 parecem um pouco mais escuros do que os outros dígitos, o que poderia significar que existem menos imagens de 5 no conjunto de dados ou que o classificador não funcionou tão bem nos 5 quanto em outros dígitos. Na verdade, você pode comprovar que ambos são o caso. Focaremos a plotagem nos erros. Primeiro, você precisa dividir cada valor na matriz de confusão pelo número de imagens na classe correspondente para que possa comparar as taxas de erro em vez do número absoluto de erros (o que tornaria as classes mais frequentes parecerem injustamente mal arrumadas): row_sums = conf_mx. sum(axis=1, keepdims=True) norm_conf_mx = conf_mx / row_sums CG_MIOLO_Hands_On_Machine_Learning. indb 101 07/05/2019 17:08:22

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

102 | Capítulo 3: Classificação Agora, preencheremos a diagonal com zeros para manter apenas os erros e plotar o resultado: np. fill_diagonal(norm_conf_mx, 0) plt. matshow(norm_conf_mx, cmap=plt. cm. gray) plt. show() Aqui, você pode ver claramente os tipos de erros que o classificador comete. Lembre-se de que as linhas representam as classes reais, enquanto as colunas representam as classes previstas. As colunas para as classes 8 e 9 são bastante brilhantes, o que informa que muitas imagens são erroneamente classificadas como 8 ou 9. Da mesma forma, as linhas para as classes 8 e 9 também são muito brilhantes, informando que 8 e 9 geralmente são confundidos com outros dígitos. Por outro lado, algumas linhas são bastante escuras, como a linha 1: isso significa que a maioria dos 1 são classificados corretamente (poucos são confundidos com 8). Observe que os erros não são perfeitamente simétricos; por exemplo, há mais 5 classificados erroneamente como 8 do que o inverso. Analisar a matriz de confusão lhe dá informações sobre maneiras de melhorar seu classificador. Olhando para esta plotagem, percebemos que seus esforços devem focar a melhoria da classificação de 8 e 9, bem como corrigir a confusão específica do 3/5. Por exemplo, você poderia tentar reunir mais dados de treinamento para esses dígitos. Ou criar novas características que ajudassem o classificador — por exemplo, escrevendo um algoritmo para contar o número de curvas fechadas (por exemplo, o 8 tem dois, o 6 tem um, 5 não tem nenhum). Ou você poderia pré-processar as imagens (utilizando, por exemplo, o Scikit-Image, Pillow ou Open CV) para que alguns padrões se destaquem mais, como os loops fechados. Analisar erros individuais também pode ser uma boa maneira de obter informações sobre o que o seu classificador está fazendo e por que ele está falhando, mas é mais di-fícil e demorado. Por exemplo, vamos plotar exemplos de 3 e 5 (a função plot_digits() utiliza apenas a função imshow() do Matplotlib; confira o notebook do Jupyter deste capítulo para mais detalhes): CG_MIOLO_Hands_On_Machine_Learning. indb 102 07/05/2019 17:08:22

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

Análise de Erro| 103cl_a, cl_b = 3, 5 X_aa = X_train[(y_train == cl_a) & (y_train_pred == cl_a)] X_ab = X_train[(y_train == cl_a) & (y_train_pred == cl_b)] X_ba = X_train[(y_train == cl_b) & (y_train_pred == cl_a)] X_bb = X_train[(y_train == cl_b) & (y_train_pred == cl_b)] plt. figure(figsize=(8,8)) plt. subplot(221); plot_digits(X_aa[:25], images_per_row=5) plt. subplot(222); plot_digits(X_ab[:25], images_per_row=5) plt. subplot(223); plot_digits(X_ba[:25], images_per_row=5) plt. subplot(224); plot_digits(X_bb[:25], images_per_row=5) plt. show() Os dois blocos 5 × 5 à esquerda mostram dígitos classificados como 3, e os dois blocos 5 × 5 à direita mostram imagens classificadas como 5. Alguns dos dígitos que o classifica-dor errou (ou seja, nos blocos inferior esquerdo e superior direito) estão tão mal escritos que mesmo um ser humano teria problemas para classificá-los (por exemplo, o 5 na 8ª linha e 1ª coluna realmente parece com um 3). No entanto, a maioria das imagens mal classificadas parecem erros óbvios para nós, e é difícil entender por que o classificador cometeu estes erros 3. A razão é que usamos um SGDClassifier simples, que é um mode-lo linear. Tudo o que ele faz é atribuir um peso por classe a cada pixel, e, quando ele vê uma nova imagem, apenas resume as intensidades dos pixels analisados para obter uma pontuação para cada classe. Então, como os 3 e 5 diferem apenas em alguns pixels, esse modelo facilmente os confundirá. 3 Lembre-se, porém, que nosso cérebro é um sistema de reconhecimento de padrões fantástico, e nosso sistema visual faz um pré-processamento complexo antes que qualquer informação chegue à nossa consciência, então o fato disso parecer simples não significa que de fato seja. CG_MIOLO_Hands_On_Machine_Learning. indb 103 07/05/2019 17:08:22

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

104 | Capítulo 3: Classificação A principal diferença entre 3 e 5 é a posição da pequena linha que une a linha superior ao arco inferior. Se você desenhar um 3 com a junção ligeiramente deslocada para a esquerda, o classificador pode classificá-lo como um 5, e vice-versa. Em outras palavras, esse classificador é bastante sensível à mudança de imagem e sua rotação. Portanto, uma forma de reduzir a confusão do 3/5 seria pré-processar as imagens para garantir que elas estejam bem centradas e não rotacionadas demais. Isso provavelmente ajudará a reduzir outros erros também. Classificação Multilabel Até agora, nós sempre atribuímos cada instância a apenas uma classe. Em alguns casos, pode ser que você queira que seu classificador emita várias classes para cada instância. Por exemplo, considere um classificador de reconhecimento facial: o que ele deve fazer se reconhecer várias pessoas na mesma imagem? Claro que ele deve anexar um rótulo por pessoa reconhecida. Digamos que o classificador foi treinado para reconhecer três faces: Alice, Bob e Charlie; então, quando mostramos uma imagem de Alice e Charlie, ele deve mostrar [1, 0, 1] (que significa “Alice sim, Bob não, Charlie sim"). Esse sistema de classificação que mostra vários rótulos binários é chamado de sistema de classificação multilabel. Nós ainda não entraremos no reconhecimento facial, mas vejamos um exemplo mais simples apenas para fins de ilustração: from sklearn. neighbors import KNeighbors Classifier y_train_large = (y_train >= 7) y_train_odd = (y_train % 2 == 1) y_multilabel = np. c_[y_train_large, y_train_odd] knn_clf = KNeighbors Classifier() knn_clf. fit(X_train, y_multilabel) Este código cria um array y_multilabel contendo dois rótulos-alvo para cada imagem numérica: o primeiro indica se o dígito é ou não é grande (7, 8 ou 9) e o segundo indica se é ou não é ímpar. As próximas linhas criam uma instância do KNeighbors Classifier (que aceita a classificação multilabel, mas nem todos os classi-ficadores aceitam) utilizando o array de múltiplos destinos e nós a treinamos. Agora, você pode fazer uma previsão e perceber que ela mostra dois rótulos: >>> knn_clf. predict([some_digit]) array([[False, True]], dtype=bool) E ela acertou! O dígito 5 realmente não é grande ( False ) e é ímpar ( True ). CG_MIOLO_Hands_On_Machine_Learning. indb 104 07/05/2019 17:08:23

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

Classificação Multioutput| 105Há muitas maneiras de avaliar um classificador multilabel, e selecionar a métrica certa depende realmente do seu projeto. Por exemplo, uma abordagem seria medir a pontuação F1 para cada rótulo individual (ou qualquer outra métrica classificadora binária discutida anteriormente), então simplesmente calcular a pontuação média. Esse código calcula a pontuação média F1 em todos os rótulos: >>> y_train_knn_pred = cross_val_predict(knn_clf, X_train, y_multilabel, cv=3) >>> f1_score(y_multilabel, y_train_knn_pred, average="macro") 0. 97709078477525002 Isso pressupõe que todos os rótulos são igualmente importantes, o que pode não ser o caso. Por exemplo, se você tem muito mais fotos de Alice do que de Bob ou Charlie, pode ser que você queira dar mais peso a fotos da Alice na pontuação do classificador. Uma opção simples é dar a cada rótulo um peso igual ao seu suporte (ou seja, o número de instâncias com aquele rótulo-alvo). Para fazer isso, basta definir average="weighted" no código anterior. 4 Classificação Multioutput O último tipo de tarefa de classificação que discutiremos aqui é chamado de classificação multioutput-multiclass (ou simplesmente classificação multioutput ). É simplesmente uma generalização da classificação multilabel em que cada rótulo pode ser multiclasse (ou seja, pode ter mais de dois valores possíveis). Para ilustrar isso, construiremos um sistema que remova o ruído das imagens. Ele to-mará como entrada uma imagem numérica ruidosa, e mostrará (espero) uma imagem numérica limpa, representada como um array de intensidade de pixels assim como as imagens MNIST. Observe que a saída do classificador é multilabel (um rótulo por pi-xel) e cada rótulo pode ter vários valores (a intensidade dos pixels varia de 0 a 255). É, portanto, um exemplo de um sistema de classificação multioutput. Os limites entre classificação e regressão podem não ser muito cla-ros, como é o caso descrito. Provavelmente, a previsão da intensida-de do pixel é mais parecida com a regressão do que com a classifica-ção. Além disso, os sistemas multioutput não se limitam às tarefas de classificação; é possível até ter um sistema que mostra vários rótulos por instância, incluindo rótulos de classe e de valor. 4 O Scikit-Learn oferece algumas outras opções de média e métricas do classificador multilabel ; vej a a docu-mentação para mais detalhes. CG_MIOLO_Hands_On_Machine_Learning. indb 105 07/05/2019 17:08:23

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

106 | Capítulo 3: Classificação Começaremos criando os conjuntos de treinamento e testes pegando as imagens MNIST e adicionando ruído às suas intensidades de pixel por meio da função randint() do Num Py. As imagens-alvo serão as imagens originais: noise = np. random. randint(0, 100, (len(X_train), 784)) X_train_mod = X_train + noise noise = np. random. randint(0, 100, (len(X_test), 784)) X_test_mod = X_test + noise y_train_mod = X_train y_test_mod = X_test Vamos dar uma olhada em uma imagem do conjunto de testes (sim, estes são os dados de teste, então você deve estar franzindo a testa agora): À esquerda temos a imagem confusa de entrada, e à direita está a imagem-alvo limpa. Agora, treinaremos o classificador para fazer com que ele limpe esta imagem: knn_clf. fit(X_train_mod, y_train_mod) clean_digit = knn_clf. predict([X_test_mod[some_index]]) plot_digit(clean_digit) Parece bem próxima da imagem-alvo! Isso conclui nosso tour de classificação. Espera-mos que agora você saiba como selecionar boas métricas para as tarefas de classificação, escolher a compensação apropriada da precisão/revocação, comparar classificadores e, no geral, criar bons sistemas de classificação para uma variedade de tarefas. CG_MIOLO_Hands_On_Machine_Learning. indb 106 07/05/2019 17:08:23

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

Exercícios| 107Exercícios 1. Tente construir um classificador para o conjunto de dados do MNIST que obtenha uma ac urácia acima de 97% no conjunto de teste. Dica: o KNeighbors Classifier funciona muito bem para esta tarefa; você só precisa encontrar bons valores do hiperparâmetro (experimente uma grid search nos pesos e hiperparâmetros n_neighbors ). 2. Esc reva uma função que possa mudar uma imagem do MNIST em qualquer direção (esquerda, direita, para cima ou para baixo) em um pixel. 5 Então, para cada imagem no conjunto de treinamento, crie quatro cópias deslocadas (uma por direção) e as adicione ao conjunto de treinamento. Finalmente, treine seu melhor modelo neste conjunto expandido de treinamento e meça sua acurácia no conjunto de teste. Você notará que seu modelo funciona ainda melhor agora! Esta técnica de cresci-mento artificial do conjunto de treinamento é chamada de data augmentation ou expansão do conjunto de treinamento 3. Enc are o conjunto de dados Titanic. Um ótimo lugar para começar é no Kaggle (https://www. kaggle. com/c/titanic ). 4. Con strua um classificador de spam (um exercício mais desafiador): Bai xe exemplos de spam e e-mails normais dos conjuntos públicos de dados do Apache Spam Assassin ( https://spamassassin. apache. org/old/publiccorpus/ ); Des compacte os conjuntos de dados e procure se familiarizar com o formato dos dados; Divi da os conjuntos de dados em um conjunto de treinamento e um conjunto de testes; Esc reva um pipeline de preparação de dados para converter cada e-mail em um ve-tor de características. Seu pipeline de preparação deve transformar um e-mail em um vetor (esparso) que indica a presença ou ausência de cada palavra possível. Por exemplo, se todos os e-mails contiverem apenas quatro palavras, “Hello”, “how”, “are”, “you”, então o e-mail “Hello you Hello Hello you” seria convertido em um vetor [1, 0, 0, 1] (significando que “Hello” está presente, “how” está ausente, “are” está ausente e “you” está presente), ou [3, 0, 0, 2] se você preferir contar o número de ocorrências de cada palavra; 5 Você pode usar a função shift() do m ódulo scipy. ndimage. interpolation. Por exemplo, shift(image, [2, 1], cval=0) desloca a imagem 2 pixels para baixo e 1 pixel para a direita. CG_MIOLO_Hands_On_Machine_Learning. indb 107 07/05/2019 17:08:23

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

108 | Capítulo 3: Classificação Pode ser que você queira adicionar hiperparâmetros ao seu pipeline de prepa-ra ção para controlar se deseja ou não retirar os cabeçalhos de e-mail, converter cada e-mail em minúsculas, remover pontuação, substituir todas as URLs por “URL”, substituir todos os números por “NUMBER” ou mesmo reduzir, ou seja, cortar as finalizações de palavras. Existem bibliotecas Python disponíveis para fazer isso; Em se guida, experimente vários e veja se consegue construir um bom classifi-cador de spam com revocação e precisão altas. As soluções para estes exercícios estão disponíveis online nos notebooks do Jupyter em https://github. com/ageron/handson-ml. CG_MIOLO_Hands_On_Machine_Learning. indb 108 07/05/2019 17:08:23

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

109Capítulo 4 Treinando Modelos Até agora, temos tratado os modelos de Aprendizado de Máquina e seus algoritmos ba-sicamente como caixas pretas. Se você fez alguns dos exercícios nos capítulos anteriores, deve ter ficado surpreso com o quanto você consegue fazer sem nenhum conhecimento sobre o que acontece nos bastidores: você otimizou um sistema de regressão, melhorou um classificador de imagens de dígitos e até mesmo construiu um filtro de spam do zero, tudo isso sem saber como eles funcionam. De fato, em várias situações você não precisa realmente saber os detalhes da implementação. Entretanto, ter uma boa compreensão de como as coisas funcionam pode ajudá-lo a rapi-damente focar o modelo apropriado, o algoritmo de treinamento correto a ser usado e um bom conjunto de hiperparâmetros para sua tarefa. Entender o que acontece nos bastidores também ajudará a depurar problemas e executar de forma mais eficiente a análise de erro. Por fim, a maioria dos tópicos discutidos neste capítulo será essencial para a compreensão, construção e treinamento das redes neurais (discutidas na Parte II deste livro). Neste capítulo, começaremos avaliando o modelo de Regressão Linear, um dos modelos mais simples existentes. Discutiremos duas formas bem diferentes de treiná-lo: Uti lizando uma equação direta de “forma fechada”, que calcula diretamente os pa-râmetros do modelo que melhor se encaixam no conjunto de treinamento (ou seja, os parâmetros do modelo que minimiza a função de custo em relação ao conjunto de treinamento); Uti lizando uma abordagem iterativa de otimização chamada Gradiente Descen-dente (GD), que gradualmente pega os parâmetros-modelo para minimizar a função custo no conjunto de treinamento, às vezes convergindo-o para o mesmo conjunto de parâmetros do primeiro método. Abordaremos algumas variantes do Gradiente Descendente que utilizaremos muitas vezes quando estudarmos as redes neurais na Parte II: Batch GD, Mini batch GD e Stochastic GD. CG_MIOLO_Hands_On_Machine_Learning. indb 109 07/05/2019 17:08:23

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

110 | Capítulo 4: Treinando Modelos Em seguida, abordaremos a Regressão Polinomial, um modelo mais complexo que pode se ajustar em conjuntos de dados não lineares. Como este modelo tem mais parâmetros do que a Regressão Linear ele é mais propenso ao sobreajuste dos dados de treinamento, então veremos como detectar se isso acontece ou não, utilizando curvas de aprendizado, e, depois, abordaremos técnicas de regularização que podem reduzir o risco de sobrea-juste no conjunto. Finalmente, estudaremos mais dois modelos que são comumente utilizados para as tarefas de classificação: Regressão Logística e Regressão Softmax. Teremos algumas equações matemáticas neste capítulo que utilizam noções básicas de cálculo e álgebra linear. Para entender essas equa-ções, você precisará saber o que são vetores e matrizes, como trans-pô-las, o que é o produto escalar, o que é a matriz inversa e o que são derivadas parciais. Se você não estiver familiarizado com esses conceitos, por favor acompanhe os tutoriais introdutórios de álgebra linear e cálculo disponíveis como notebooks do Jupyter no material suplementar online [em inglês]. Para aqueles verdadeiramente alér-gicos à matemática, é recomendável ver este capítulo mesmo assim e pular as equações; espero que o texto seja suficiente para ajudar você a entender a maioria dos conceitos. Regressão Linear No Capítulo 1, abordamos um modelo simples de regressão sobre a satisfação de vida: life_satisfaction = θ0 + θ1 × GDP_per_capita. Este modelo é apenas uma função linear da característica de entrada GDP_per_capita. θ0 e θ1 são os parâmetros do modelo. Geralmente, um modelo linear faz uma previsão calculando uma soma ponderada das características de entrada, mais uma constante chamada de termo de polarização (tam-bém chamada coeficiente linear ), como mostrado na Equação 4-1. Equação 4-1. Previsão do modelo de Regressão Linear y=θ0+θ1x1+θ2x2+ +θnxn ŷ é o valor previsto; n é o núm ero de características; xi é o valor da i-ésima característica; CG_MIOLO_Hands_On_Machine_Learning. indb 110 07/05/2019 17:08:24

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

Regressão Linear | 111 θj é o parâmetro do modelo j (incluindo o termo de polarização θ0 e os pesos das características θ1, θ2, ⋯, θ n). Isso pode ser escrito de maneira muito mais concisa usando uma forma vetorial, como mostrado na Equação 4-2. Equação 4-2. Previsão do modelo de Regressão Linear (forma vetorizada) y=hθx=θT·x θ é o vetor d e parâmetro do modelo, que contém o termo de polarização θ 0 e os pesos das características θ 1 a θn; θT é a transposição de θ (um vetor linha em vez de um vetor coluna); x é o vet or de características da instância, que contém x 0 a xn, com x 0 sempre igual a 1; θT · x é o produto escalar de θT e x; hθ é a função de hipótese, que utiliza os parâmetros do modelo θ. Certo, este é o modelo de Regressão Linear, mas e agora, como o treinamos? Bem, lem-bre-se que treinar um modelo significa configurar seus parâmetros para que tenham o melhor ajuste no conjunto de treinamento. Para este propósito, é preciso primeiro de uma medida de quão bem (ou mal) o modelo se adaptará aos dados de treinamento. No Capítulo 2, vimos que a medida de desempenho mais comum de um modelo de regressão é a Raiz do Erro Quadrático Médio (RMSE) (Equação 2-1). Portanto, para treinar um modelo de Regressão Linear, você deve encontrar o valor de θ que minimize o RMSE. Na prática, é mais simples minimizar o Erro Quadrático Médio (MSE) do que a RMSE, e leva ao mesmo resultado (porque o valor que minimiza uma função também minimiza sua raiz quadrada). 1 O MSE de uma hipótese h θ de Regressão Linear em um conjunto de treinamento X é calculado usando a Equação 4-3. Equação 4-3. Função MSE de custo para um modelo de Regressão Linear MSE X,hθ=1 m∑ i=1m θT·xi-yi2 1 Não raro um algoritmo de aprendizagem tenta otimizar uma função diferente da medida de desempenho usada para avaliar o modelo final. Em geral, isso se dá porque é mais fácil computar essa função, por possuir propriedades de diferenciação úteis que a medida de desempenho não tem ou por querermos restringir o modelo durante o treinamento, como veremos quando discutirmos sobre regularização. CG_MIOLO_Hands_On_Machine_Learning. indb 111 07/05/2019 17:08:24

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

112 | Capítulo 4: Treinando Modelos A maioria destas notações foi apresentada no Capítulo 2 (veja “Notações” no Capítulo 2). A única diferença é que escrevemos hθ em vez de h para deixar claro que o modelo é parametrizado pelo vetor θ. Para simplificar as anotações, escreveremos apenas MSE( θ) em vez de MSE( X, hθ). Método dos Mínimos Quadrados Para encontrar o valor de θ, que minimiza a função de custo, existe uma solução de forma fechada — em outras palavras, uma equação matemática que dá o resultado diretamente. Isto é chamado de Método dos Mínimos Quadrados (Equação 4-4). 2 Equação 4-4. Método dos Mínimos Quadrados θ=XT·X-1·XT·y é o valor de θ que minimiza a função de custo. y é o vet or dos valores do alvo contendo y(1) a y(m). Geraremos alguns dados de aparência linear para testar esta equação (Figura 4-1): import numpy as np X = 2 * np. random. rand(100, 1) y = 4 + 3 * X + np. random. randn(100, 1) Figura 4-1. Conjunto de dados lineares gerado aleatoriamente 2 A demonstração de que isso retorna o valor de θ que minimiza a função de custo está fora do escopo deste livro. CG_MIOLO_Hands_On_Machine_Learning. indb 112 07/05/2019 17:08:25

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

Regressão Linear | 113Agora, calcularemos ^θ usando o Método dos Mínimos Quadrados. Utilizaremos a função inv() do módulo de Álgebra Linear do Num Py ( np. linalg ) para calcular o inverso de uma matriz, e o método dot() para a multiplicação da matriz: X_b = np. c_[np. ones((100, 1)), X] # adiciona x0 = 1 a cada instância theta_best = np. linalg. inv(X_b. T. dot(X_b)). dot(X_b. T). dot(y) A função vigente que usamos para gerar os dados é y = 4 + 3 x1 + ruído gaussiano. Vamos ver o que a equação encontrou: >>> theta_best array([[ 4. 21509616], [ 2. 77011339]]) Esperávamos por θ0 = 4 e θ1 = 3 em vez de θ0 = 4,215 e θ1 = 2,770. Perto o suficiente, mas o ruído tornou impossível recuperar os parâmetros exatos da função original. Agora, você pode fazer previsões utilizando ^θ: >>> X_new = np. array([[0], [2]]) >>> X_new_b = np. c_[np. ones((2, 1)), X_new] # adiciona x0 = 1 a cada instância >>> y_predict = X_new_b. dot(theta_best) >>> y_predict array([[ 4. 21509616], [ 9. 75532293]]) Vamos plotar as previsões deste modelo (Figura 4-2): plt. plot(X_new, y_predict, "r-") plt. plot(X, y, "b. ") plt. axis([0, 2, 0, 15]) plt. show() Previsões Figura 4-2. Previsões do modelo de Regressão Linear CG_MIOLO_Hands_On_Machine_Learning. indb 113 07/05/2019 17:08:25

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

114 | Capítulo 4: Treinando Modelos O código equivalente utilizando o Scikit-Learn se parece com isso:3 >>> from sklearn. linear_model import Linear Regression >>> lin_reg = Linear Regression() >>> lin_reg. fit(X, y) >>> lin_reg. intercept_, lin_reg. coef_ (array([ 4. 21509616]), array([[ 2. 77011339]])) >>> lin_reg. predict(X_new) array([[ 4. 21509616], [ 9. 75532293]]) Complexidade Computacional O Método dos Mínimos Quadrados calcula o inverso de XT · X, que é a matriz n × n (em que n é o número de características). A complexidade computacional de inverter tal matriz é tipicamente de O (n2,4) a O (n3) (dependendo da implementação). Em outras palavras, se dobrar o número de características, você multiplica o tempo de computação por aproximadamente 22,4 = 5,3 para 23 = 8. O Método dos Mínimos Quadrados fica muito lento quando o nú-mero de características cresce muito (por exemplo, 100 mil). Encarando pelo lado positivo, esta equação é linear em relação ao número de instâncias no conjunto de treinamento (ela é O (m)), de modo que lida eficientemente com grandes conjuntos de treinamento, desde que possam caber na memória. Além disso, ao treinar seu modelo de Regressão Linear (utilizando o Método dos Mí-nimos Quadrados ou qualquer outro algoritmo), suas previsões ficam muito rápidas: a complexidade computacional é linear no que se refere ao número de instâncias em que você deseja fazer previsões e ao número de características. Em outras palavras, fazer previsões em duas vezes mais instâncias (ou o dobro de recursos) levará aproximada-mente o dobro do tempo. Agora, veremos maneiras muito diferentes de treinar um modelo de Regressão Linear, mais adequado para casos em que haja um grande número de recursos ou muitas ins-tâncias de treinamento para caber na memória. 3 Observe que o Scikit-Learn separa o termo de polarização (intercept_) do s pesos da característica (coef_). CG_MIOLO_Hands_On_Machine_Learning. indb 114 07/05/2019 17:08:25

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

Gradiente Descendente | 115Gradiente Descendente Gradiente Descendente é um algoritmo de otimização muito genérico capaz de encontrar ótimas soluções para uma ampla gama de problemas. A ideia geral do Gradiente Des-cendente é ajustar iterativamente os parâmetros para minimizar uma função de custo. Suponha que você esteja perdido nas montanhas em um denso nevoeiro; você só consegue sentir a inclinação do solo sob seus pés. Uma boa estratégia para chegar rapidamente ao fundo do vale é descer em direção à encosta mais íngreme. Isso é exatamente o que o Gradiente Descendente faz: ele mede o gradiente local da função de erro em relação ao vetor de parâmetro θ, e vai na direção do gradiente descendente. Quando o gradiente for zero, você atingiu um mínimo! Concretamente, você começa preenchendo θ com valores aleatórios (isto é chamado inicialização aleatória ), e então o melhora gradualmente, dando um pequeno passo por vez, cada passo tentando diminuir a função de custo (por exemplo, o MSE), até que o algoritmo convirja para um mínimo (veja Figura 4-3). Valor inicial aleatório Mínimo Passo de aprendizado Custo Figura 4-3. Gradiente Descendente O tamanho dos passos é um parâmetro importante do Gradiente Descendente, deter-minado pelo hiperparâmetro taxa de aprendizado. Se a taxa de aprendizado for muito pequena, o algoritmo terá que passar por muitas iterações para convergir, o que demorará muito (veja a Figura 4-4). CG_MIOLO_Hands_On_Machine_Learning. indb 115 07/05/2019 17:08:26

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

116 | Capítulo 4: Treinando Modelos Custo Início Figura 4-4. Taxa de aprendizado muito pequena Por outro lado, se a taxa de aprendizado for muito alta, você pode atravessar o vale e acabar do outro lado, possivelmente até mais alto do que estava antes. Isso pode tornar o algoritmo divergente com valores cada vez maiores, não encontrando uma boa solução (veja a Figura 4-5). Custo Início Figura 4-5. Taxa de aprendizado muito grande Finalmente, nem todas as funções de custo se parecem com tigelas regulares. Podem haver buracos, cumes, planaltos e todo tipo irregular de terreno fazendo com que a con-vergência ao mínimo seja muito difícil. A Figura 4-6 mostra os dois principais desafios do Gradiente Descendente: se a inicialização aleatória iniciar o algoritmo à esquerda, ela converge para um mínimo local, o que não é tão bom quanto o mínimo global. Se começar pela direita, então demorará muito para atravessar o planalto e, se você parar cedo demais, nunca alcançará o mínimo global. CG_MIOLO_Hands_On_Machine_Learning. indb 116 07/05/2019 17:08:26

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

Gradiente Descendente | 117 Custo Mínimo local Mínimo global Platô Figura 4-6. Armadilhas do Gradiente Descendente Felizmente, a função de custo do MSE para um modelo de Regressão Linear é uma função convexa, o que significa que, se você escolher quaisquer dois pontos na curva, o segmento de linha que os une nunca a cruza. Isso implica que não há mínimos lo-cais, apenas um mínimo global. É também uma função contínua com uma inclinação que nunca se altera abruptamente. 4 Estes dois fatos geram uma ótima consequência: o Gradiente Descendente tem a garantia de se aproximar arbitrariamente do mínimo global (se você esperar o tempo suficiente e se a taxa de aprendizado não for muito alta). Na verdade, a função de custo tem a forma de uma tigela, mas, se as características tiverem escalas muito diferentes, pode ter a forma de uma tigela alongada. A Figura 4-7 mostra o Gradiente Descendente em um conjunto de treinamento em que as carac-terísticas 1 e 2 têm a mesma escala (à esquerda) e em um conjunto de treinamento em que a característica 1 tem valores muito menores do que a característica 2 (à direita). 5 Custo Figura 4-7. Gradiente Descendente com e sem escalonamento das características 4 Tecnicamente, sua derivada é a Lipschitz contínua. 5 Uma ve z que a característica 1 é menor, é preciso uma mudança maior em θ1 para afetar a função de custo, razão pela qual a tigela é alongada ao longo do eixo θ1. CG_MIOLO_Hands_On_Machine_Learning. indb 117 07/05/2019 17:08:27

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

118 | Capítulo 4: Treinando Modelos Como você pode ver à esquerda, o algoritmo do Gradiente Descendente vai diretamente para o mínimo, atingindo-o rapidamente, enquanto à direita primeiro avança em sen-tido quase ortogonal em direção ao mínimo global e termina com uma longa marcha em um vale quase plano. Eventualmente ele alcançará o mínimo, mas demorará muito. Ao utilizar o Gradiente Descendente, você deve garantir que todas as características tenham uma escala similar (por exemplo, utilizando a classe Standard Scaler do Scikit-Learn), ou então demorará muito mais para convergir. Este diagrama também ilustra o fato de que treinar um modelo significa procurar uma combinação de parâmetros do modelo que minimizem uma função de custo (em relação ao conjunto de treinamento). É uma pesquisa no espaço de parâmetro do modelo: quanto mais parâmetros um modelo possui, mais dimensões este espaço tem, e mais difícil será a busca: procurar por uma agulha em um palheiro de 300 dimensões é muito mais complicado do que em três dimensões. Felizmente, como no caso da Regressão Linear a função de custo é convexa, a agulha simplesmente está na parte inferior da tigela. Gradiente Descendente em Lote Para implementar o Gradiente Descendente, é preciso calcular o gradiente da função de custo em relação a cada parâmetro do modelo θj. Em outras palavras, você precisa cal-cular quanto mudará a função de custo se você modificar somente um pouco do θj. Isto é chamado derivada parcial. É como perguntar: “qual é a inclinação de uma montanha sob meus pés se eu apontar para o leste?”, e, então, fazer a mesma pergunta apontando para o norte (e assim por diante para todas as outras dimensões, se puder imaginar um universo com mais de três). A Equação 4-5 calcula a derivada parcial da função de custo em relação ao parâmetro θj, notado por MSE ( θ). Equação 4-5. Derivadas parciais da função de custo ∂ ∂θj MSE θ=2 m∑ i=1m θT·xi-yixji Em vez de calcular individualmente essas derivadas parciais, você pode utilizar a Equa-ção 4-6 para calculá-las de uma só vez. O vetor gradiente, descrito ∇θMSE( θ), contém todas as derivadas parciais da função de custo (uma para cada parâmetro do modelo). CG_MIOLO_Hands_On_Machine_Learning. indb 118 07/05/2019 17:08:27

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

Gradiente Descendente | 11 9Equação 4-6. Vetor gradiente da função de custo θMSE θ=∂ ∂θ0MSE θ ∂ ∂θ1MSE θ ∂ ∂θn MSE θ=2 m XT·X·θ-y Observe que esta fórmula envolve cálculos em cada etapa do Gra-diente Descendente sobre o conjunto completo de treinamento X! É por isso que o algoritmo é chamado de Gradiente Descendente em Lote: ele utiliza todo o lote de dados em cada etapa. Como resultado, ele é terrivelmente lento para grandes conjuntos (em breve veremos algoritmos de gradiente descendente muito mais rápidos). No entan-to, o Gradiente Descendente se dimensiona bem com a quantidade de características; treinar um modelo de Regressão Linear, quando há centenas de milhares de características, será muito mais rápido se utilizarmos o Gradiente Descendente do que se utilizarmos o Método dos Mínimos Quadrados. Uma vez que você tenha o vetor gradiente, que aponta para cima, basta ir na direção oposta para descer. Isto significa subtrair ∇ θMSE( θ) de θ. É aqui que a taxa de aprendi-zado η entra em cena:6 multiplicar o vetor gradiente por η para determinar o tamanho do passo para baixo (Equação 4-7). Equação 4-7. Passo do Gradiente Descendente θnext step=θ-ηθMSE θ Vejamos uma implementação rápida desse algoritmo: eta = 0. 1 # taxa de aprendizado n_iterations = 1000 m = 100 theta = np. random. randn(2,1) # inicialização aleatória for iteration in range(n_iterations): gradients = 2/m * X_b. T. dot(X_b. dot(theta)-y) theta = theta-eta * gradients 6 Eta (η) é a 7a letra do alfabeto Grego. CG_MIOLO_Hands_On_Machine_Learning. indb 119 07/05/2019 17:08:27

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

120 | Capítulo 4: Treinando Modelos Isto não foi muito difícil! Observe o theta resultante: >>> theta array([[ 4. 21509616], [ 2. 77011339]]) É exatamente isso que o Método dos Mínimos Quadrados encontrou! O Gradiente Descen-dente funcionou perfeitamente. Mas, e se você tivesse utilizado uma taxa de aprendizado eta diferente? Utilizando três taxas de aprendizado diferentes, a Figura 4-8 mostra os primeiros 10 passos do Gradiente Descendente (a linha tracejada representa o ponto inicial). Figura 4-8. O Gradiente Descendente com várias taxas de aprendizado A taxa de aprendizado à esquerda é muito baixa: o algoritmo acabará por alcançar a solução, mas demorará muito. No meio, a taxa de aprendizado parece muito boa: com apenas algumas iterações já convergiu para a solução. À direita, a taxa de aprendizado é muito alta: o algoritmo diverge, pulando por todo o lado e, de fato, ficando cada vez mais longe da solução. Você pode utilizar a grid search para encontrar uma boa taxa de aprendizado (veja o Capítulo 2). No entanto, talvez seja melhor limitar o número de iterações para que a grid search possa eliminar modelos que demoram muito para convergir. Você deve estar se perguntando como é possível configurar o número de iterações. Se esse número for muito baixo, você ainda estará longe da solução ideal quando o algo-ritmo parar, mas, se for muito alto, perderá tempo quando os parâmetros do modelo não mudarem mais. Uma solução simples é definir um grande número de iterações para interromper o algoritmo quando o vetor do gradiente se tornar pequeno, ou seja, quando sua norma se tornar menor do que o minúsculo número ϵ (chamado tolerância ), porque isso acontece quando o Gradiente Descendente (quase) atinge o mínimo. CG_MIOLO_Hands_On_Machine_Learning. indb 120 07/05/2019 17:08:28

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

Gradiente Descendente | 12 1Taxa de Convergência Quando a função de custo for convexa e sua inclinação não mudar abruptamente (como é o caso da função de custo MSE), o Gradiente Descendente em Lote com uma taxa fixa de aprendizado convergirá para a solução ideal, mas talvez seja necessário esperar um pouco: pode levar O(1/ ϵ) iterações para atingir o melhor dentro de um intervalo de ϵ dependendo da forma da função de custo. Se você dividir a tolerância por 10 para ter uma solução mais precisa, o algoritmo terá que correr cerca de 10 vezes mais. Gradiente Descendente Estocástico O principal problema com o Gradiente Descendente em Lote é o fato de que ele utiliza todo o conjunto de treinamento para calcular os gradientes em cada passo, o que o torna muito lento quando o conjunto for grande. No extremo oposto, o Gradiente Descendente Estocástico (SGD) escolhe uma instância aleatória no conjunto de treinamento em cada etapa e calcula os gradientes baseado apenas nesta única instância. Obviamente, isso torna o algoritmo muito mais rápido, pois tem poucos dados para manipular em cada iteração. Também permite treinar em grandes conjuntos de treinamento, uma vez que apenas uma instância precisa estar na memória a cada iteração (o SGD pode ser imple-mentado como um algoritmo out-of-core. 7) Por outro lado, devido a sua natureza estocástica (ou seja, aleatória), esse algoritmo é bem menos regular do que o Gradiente Descendente em Lote: em vez de diminuir sua-vemente até atingir o mínimo, a função de custo vai subir e descer, diminuindo apenas na média. Ao longo do tempo, ele acabará muito perto do mínimo, mas, ao chegar lá, ele continuará a rebater, nunca se estabilizando (veja a Figura 4-9). Assim, quando o algoritmo para, os valores dos parâmetros finais serão bons, mas não ótimos. Custo Figura 4-9. Gradiente Descendente Estocástico 7 Algoritmos out-of-core são discutidos no Capítulo 1. CG_MIOLO_Hands_On_Machine_Learning. indb 121 07/05/2019 17:08:28

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

122 | Capítulo 4: Treinando Modelos Quando a função de custo é muito irregular (como na Figura 4-6), isso pode, na verdade, ajudar o algoritmo a pular fora do mínimo local, de modo que o Gradiente Descendente Estocástico terá uma chance maior de encontrar o mínimo global do que o Gradiente Descendente em Lote. Desta forma, a aleatoriedade é boa para escapar do ótimo local, mas ruim porque significa que o algoritmo nunca pode se estabelecer no mínimo. Uma solução para este dilema é reduzir gradualmente a taxa de aprendizado. As etapas começam grandes (o que ajuda a fazer rápidos progressos e a escapar dos mínimos locais) e depois diminuem, permitindo que o algoritmo se estabeleça no mínimo global. Este processo é chamado recozimento simulado, porque se assemelha ao processo de recozimento na metalurgia no qual o metal fundido é resfriado lentamente. A função que determina a taxa de aprendizado em cada iteração é chamada de cronograma de aprendizado. Se a taxa de aprendizado for reduzida rapidamente, você pode ficar preso em um mínimo local, ou mesmo acabar congelado a meio caminho do mínimo. Se a taxa de aprendizado for reduzida lentamente, você pode saltar em torno do mínimo por um longo período de tempo e acabar com uma solução insuficiente se parar de treinar muito cedo. Utilizando um simples cronograma de aprendizado, este código implementa o Gradiente Descendente Estocástico: n_epochs = 50 t0, t1 = 5, 50 # hiperparâmentros de aprendizado def learning_schedule(t): return t0 / (t + t1) theta = np. random. randn(2,1) # inicialização aleatória for epoch in range(n_epochs): for i in range(m): random_index = np. random. randint(m) xi = X_b[random_index:random_index+1] yi = y[random_index:random_index+1] gradients = 2 * xi. T. dot(xi. dot(theta)-yi) eta = learning_schedule(epoch * m + i) theta = theta-eta * gradients Por convenção, replicamos por rodadas de m iterações; cada rodada é chamada de época. Enquanto o código Gradiente Descendente em Lote replica mil vezes pelo conjunto de treinamento, este código passa apenas 50 vezes pelo conjunto e atinge uma boa solução: >>> theta array([[ 4. 21076011], [ 2. 74856079]]) CG_MIOLO_Hands_On_Machine_Learning. indb 122 07/05/2019 17:08:28

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

Gradiente Descendente | 123A Figura 4-10 mostra os primeiros 10 passos do treinamento (repare na irregularidade deles). Figura 4-10. Os primeiros 10 passos do Gradiente Descendente Estocástico Observe que, como as instâncias são escolhidas aleatoriamente, algumas poderão ser escolhidas várias vezes por época, enquanto outras podem nem ser escolhidas. Outra abordagem seria minimizar o conjunto de treinamento, passar instância por instância, embaralhar novamente, e assim por diante, se quiser ter certeza de que o algoritmo passará em cada época por todas as instâncias. No entanto, isso geralmente diminuirá a convergência. Para executar a Regressão Linear usando SGD com Scikit-Learn, você pode aplicar a classe SGDRegressor, que otimiza o padrão da função de custo de erro quadrático. O código a seguir roda 50 épocas, iniciando com uma taxa de aprendizado de 0,1 ( eta0=0. 1 ), usando o cronograma padrão de aprendizado (diferente do anterior) e dispensando qualquer regularização ( penalty=None ; mais detalhes em breve): from sklearn. linear_model import SGDRegressor sgd_reg = SGDRegressor(n_iter=50, penalty=None, eta0=0. 1) sgd_reg. fit(X, y. ravel()) Mais uma vez, você encontra uma solução muito próxima da retornada pelo Método dos Mínimos Quadrados: >>> sgd_reg. intercept_, sgd_reg. coef_ (array([ 4. 16782089]), array([ 2. 72603052])) CG_MIOLO_Hands_On_Machine_Learning. indb 123 07/05/2019 17:08:29

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

124 | Capítulo 4: Treinando Modelos Gradiente Descendente em Minilotes O último algoritmo do Gradiente Descendente que analisaremos é denominado Gradiente Descendente em Minilotes. É fácil entender esse algoritmo quando se sabe Gradiente Des-cendente em Lotes e Estocástico: em vez de calcular os gradientes a cada etapa com base no conjunto completo de treinamento (como o GD em Lotes) ou com base em apenas uma instância (como em GD Estocástico), o GD em Minilotes faz o cálculo dos gradientes em pequenos conjuntos aleatórios de instâncias chamados de minilotes. A principal vantagem do GD em Minilotes em relação ao GD Estocástico é que você pode obter um ganho de desempenho na otimização de hardware das operações da matriz, especialmente quando são utilizadas GPUs. O progresso do algoritmo no espaço dos parâmetros é menos errático do que com o SGD, especialmente com minilotes bem grandes. Como resultado, o GD em Minilotes ficará um pouco mais perto do mínimo que o SGD. Mas, por outro lado, pode ser mais difícil escapar do mínimo local (no caso dos problemas que sofrem do mínimo local, ao contrário da Regressão Linear, como vimos anteriormente). A Figura 4-11 mostra os caminhos seguidos pelos três algoritmos do Gradiente Descendente no espaço do parâmetro durante o treinamento. Todos terminam perto do mínimo, mas o caminho do GD em Lote realmente para no mínimo, enquanto tanto o GD Estocástico como o GD Minilote continuam a caminhar. No entanto, não se esqueça de que o GD em Lote demora muito para dar cada passo e o GD Estocástico e o GD Minilote também atingi-riam o mínimo se você utilizasse uma boa programação de aprendizado. Estocástico Minilote Lote Figura 4-11. Caminhos do Gradiente Descendente no espaço de parâmetro CG_MIOLO_Hands_On_Machine_Learning. indb 124 07/05/2019 17:08:29

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

Regressão Polinomial | 125Compararemos os algoritmos que discutimos até agora para a Regressão Linear 8 (lem-bre-se de que m é o número de instâncias de treinamento e n é o número de caracterís-ticas); veja a Tabela 4-1. Tabela 4-1. Comparação de algoritmos para a Regressão Linear. Algoritmo Grande m Suporte out-of-core Grande n Hiperparâmetros Escalonamento requerido Scikit-Learn Método dos Mínimos Quadrados Rápido Não Lento 0 Não Linear Re-gression GD Lote Lento Não Rápido 2 Sim n/a GD Estocástico Rápido Sim Rápido ≥2 Sim SGDRegressor GD Minilote Rápido Sim Rápido ≥2 Sim SGDRegressor Quase não há diferença após o treinamento: todos estes algorit-mos acabam com modelos muito semelhantes e fazem previsões exatamente da mesma maneira. Regressão Polinomial E se seus dados forem realmente mais complexos do que uma simples linha reta? Surpreendentemente, você pode utilizar um modelo linear para acomodar dados não lineares. Uma maneira simples de fazer isso é acrescentar potências de cada característica como novas características e, em seguida, treinar um modelo linear neste conjunto estendido de características. Esta técnica é chamada de Regressão Polinomial. Vejamos um exemplo. Primeiro, vamos gerar algum dado não linear baseado em uma simples equação quadrática 9 (mais algum ruído; veja a Figura 4-12): m = 100 X = 6 * np. random. rand(m, 1)-3 y = 0. 5 * X**2 + X + 2 + np. random. randn(m, 1) 8 Enquanto o Método dos Mínimos Quadrados só pode executar a Regressão Linear, os algoritmos de Gradiente Descendente podem ser usados para treinar muitos outros modelos, como veremos. 9 Uma e quação quadrática é da forma y = ax2 + bx + c. CG_MIOLO_Hands_On_Machine_Learning. indb 125 07/05/2019 17:08:29

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

126 | Capítulo 4: Treinando Modelos Figura 4-12. Conjunto gerado de dados não lineares e ruidosos Claramente, uma linha reta nunca acomodará esses dados corretamente. Então, utili-zaremos a classe Polynomial Features do Scikit-Learn para transformar nossos dados de treinamento adicionando o quadrado (polinômio de 2º grau) de cada característica como novas no conjunto de treinamento (neste caso, há apenas uma característica): >>> from sklearn. preprocessing import Polynomial Features >>> poly_features = Polynomial Features(degree=2, include_bias=False) >>> X_poly = poly_features. fit_transform(X) >>> X[0] array([-0. 75275929]) >>> X_poly[0] array([-0. 75275929, 0. 56664654]) X_poly agora contém a característica original de X mais o quadrado desta característica. Agora, você pode acomodar um modelo Linear Regression a estes dados estendidos de treinamento (Figura 4-13): >>> lin_reg = Linear Regression() >>> lin_reg. fit(X_poly, y) >>> lin_reg. intercept_, lin_reg. coef_ (array([ 1. 78134581]), array([[ 0. 93366893, 0. 56456263]])) CG_MIOLO_Hands_On_Machine_Learning. indb 126 07/05/2019 17:08:30

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

Curvas de Aprendizado | 127 Previsões Figura 4-13. Previsões do modelo de Regressão Polinomial Nada mal: o modelo estima ŷ = 0. 56 x2 1 + 0. 93 x1 + 1. 78 quando na verdade a função original era y = 0. 5 x2 1 + 1. 0 x1 + 2. 0 + Ruído Gaussiano. Observe que, quando existirem várias características, a Regressão Polinomial é capaz de encontrar relações entre elas (algo que um modelo simples de Regressão Linear não pode fazer). Isto é possível porque a Polynomial Features também adiciona todas as combinações de características até o grau fornecido. Por exemplo, se houvesse duas ca-racterísticas Polynomial Features, a e b, com degree=3, elas não apenas adicionariam as características a2, a3, b2, e b3, mas também as combinações ab, a2b e ab2. Polynomial Features(degree=d) transforma um array que contém n características em um que contém características, sendo n! o fatorial de n, igual a 1 × 2 × 3 × ⋯ × n. Cuidado com a explosão combinatória do número de características ! Curvas de Aprendizado Ao executar a Regressão Polinomial de alto grau, provavelmente você acomodará os dados de treinamento muito melhor do que com a Regressão Linear simples. Por exem-plo, a Figura 4-14 aplica um modelo polinomial de 300 graus aos dados de treinamento anteriores e compara o resultado com um modelo linear puro e um modelo quadrático (polinômio de 2º grau). Observe como o modelo polinomial de 300 graus se move para se aproximar o máximo possível das instâncias de treinamento. CG_MIOLO_Hands_On_Machine_Learning. indb 127 07/05/2019 17:08:30

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

128 | Capítulo 4: Treinando Modelos Figura 4-14. Regressão Polinomial de Grau Elevado Naturalmente, esse modelo de Regressão Polinomial de Grau Elevado está se sobrea-justando excessivamente aos dados de treinamento, enquanto o modelo linear está se subajustando a ele. O modelo que generalizará melhor neste caso é o modelo quadrático Isso faz sentido porque os dados foram gerados com a utilização de um modelo quadrá-tico, mas, em geral, você não saberá qual função gerou os dados, então como você pode decidir a complexidade de seu modelo? Como você pode dizer que seu modelo está se sobreajustando ou subajustando aos dados? No Capítulo 2, você utilizou a validação cruzada para obter uma estimativa do de-sempenho da generalização de um modelo. Se um modelo funciona bem nos dados de treinamento, mas generaliza mal de acordo com as métricas da validação cruzada, seu modelo é sobreajustado. Se ele funciona mal em ambos, então é subajustado. Esta é uma forma de saber quando um modelo é muito simples ou muito complexo. Outra maneira seria olhar para as curvas de aprendizado : são plotagens de desempenho do modelo no conjunto de treinamento e no conjunto de validação como uma função do tamanho do conjunto de treinamento (ou a iteração de treinamento). Para gerar as plotagens, basta treinar o modelo várias vezes em subconjuntos de tamanhos diferentes no conjunto de treinamento. O código a seguir define uma função que plota as curvas de aprendizado de alguns dados de treinamento em um dado modelo: CG_MIOLO_Hands_On_Machine_Learning. indb 128 07/05/2019 17:08:30

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

Curvas de Aprendizado | 129from sklearn. metrics import mean_squared_error from sklearn. model_selection import train_test_split def plot_learning_curves(model, X, y): X_train, X_val, y_train, y_val = train_test_split(X, y, test_size=0. 2) train_errors, val_errors = [], [] for m in range(1, len(X_train)): model. fit(X_train[:m], y_train[:m]) y_train_predict = model. predict(X_train[:m]) y_val_predict = model. predict(X_val) train_errors. append(mean_squared_error(y_train_predict, y_train[:m])) val_errors. append(mean_squared_error(y_val_predict, y_val)) plt. plot(np. sqrt(train_errors), "r-+", linewidth=2, label="train") plt. plot(np. sqrt(val_errors), "b-", linewidth=3, label="val") Vejamos as curvas de aprendizado do modelo de Regressão Linear Simples (uma linha reta, Figura 4-15): lin_reg = Linear Regression() plot_learning_curves(lin_reg, X, y) Conjunto de treinamento Conjunto de validação Tamanho do conjunto de treinamento RMSE Figura 4-15. Curvas de Aprendizado Isso merece uma explicação. Primeiro, vejamos o desempenho nos dados de treinamento: quando há apenas uma ou duas instâncias no conjunto de treinamento, o modelo se ajusta perfeitamente, e é por isso que a curva começa em zero. Mas, ao adicionarmos novas instâncias, torna-se impossível que o modelo se ajuste perfeitamente, seja porque são dados ruidosos ou porque não são dados lineares. Assim, esse erro subirá até atingir um platô, um momento em que adicionar novas instâncias ao conjunto de treinamento não tornará o erro médio muito melhor ou pior. Agora, vejamos a performance do modelo nos CG_MIOLO_Hands_On_Machine_Learning. indb 129 07/05/2019 17:08:31

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

130 | Capítulo 4: Treinando Modelosdados de validação. Quando o modelo é treinado em poucas instâncias de treinamento, é incapaz de generalizar adequadamente e é por isso que o erro de validação é inicial-mente bem grande. Então, à medida que apresentamos mais exemplos de treinamento, o modelo aprende, e, assim, o erro de validação diminui lentamente. No entanto, mais uma vez, uma linha reta não consegue fazer um bom trabalho na modelagem dos dados, então o erro acaba em um platô muito próximo da outra curva. Essas curvas de aprendizado são típicas de um modelo subajustado. Ambas atingiram um platô; estão próximas e bastante altas. Se o seu modelo estiver subajustando os dados de treinamento, não adiantará acrescentar mais exemplos de treinamento. Você precisa utilizar um modelo mais complexo ou obter melhores características. Agora, vejamos as curvas de aprendizado de um modelo polinomial de 10º grau nos mesmos dados (Figura 4-16): from sklearn. pipeline import Pipeline polynomial_regression = Pipeline([ ("poly_features", Polynomial Features(degree=10, include_bias=False)), ("lin_reg", Linear Regression()), ]) plot_learning_curves(polynomial_regression, X, y) Essas curvas de aprendizado se parecem com as anteriores, mas há duas diferenças muito importantes: O err o nos dados de treinamento é muito inferior ao encontrado no modelo de Regressão Linear; Há um a lacuna entre as curvas. Isso significa que o modelo tem um desempe-nho significativamente melhor nos dados de treinamento do que nos dados de validação, marca registrada de um modelo sobreajustado. No entanto, se você utilizasse um conjunto de treinamento muito maior, as duas curvas continua-riam se aproximando. CG_MIOLO_Hands_On_Machine_Learning. indb 130 07/05/2019 17:08:31

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

Curvas de Aprendizado | 131 Conjunto de treinamento Conjunto de validação Tamanho do conjunto de treinamento RMSE Figura 4-16. Curvas de Aprendizado para o modelo polinomial Uma maneira de melhorar um modelo de sobreajuste é alimentá-lo com mais dados de treinamento até que o erro de validação atinja o erro de treinamento. A Compensação do Viés/Variância Um importante resultado teórico das estatísticas e do Aprendizado de Máquina é o fato de que o erro de generalização de um modelo pode ser expresso como a soma de três erros muito diferentes: Viés Esta parte do erro de generalização deve-se a hipóteses erradas, como assumir que os dados são lineares quando, na verdade, são quadráticos. Um modelo com viés elevado provavelmente se subajustará aos dados de treinamento. 10 Variância Esta parte deve-se à sensibilidade excessiva do modelo a pequenas variações nos da-dos de treinamento. Um modelo com muitos graus de liberdade (como um modelo polinomial de alto grau) provavelmente terá uma alta variação e, portanto, se sobrea-justará aos dados de treinamento. 10 Essa noção de viés não deve ser confundida com o termo encontrado em modelos lineares. CG_MIOLO_Hands_On_Machine_Learning. indb 131 07/05/2019 17:08:31

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

132 | Capítulo 4: Treinando Modelos Erro Irredutível Esta parte deve-se ao ruído dos dados em si. A única maneira de reduzir essa parte do erro é limpar os dados (por exemplo, corrigir as fontes de dados, como sensores quebrados, ou detectar e remover outliers). Aumentar a complexidade de um modelo geralmente aumentará sua variância e reduzirá seu viés. Por outro lado, reduzir a complexidade de um modelo aumenta seu viés e reduz sua variância. É por isso que se chama compensação. Modelos Lineares Regularizados Como vimos nos Capítulos 1 e 2, uma boa maneira de reduzir o sobreajuste é regularizar o modelo (isto é, restringi-lo): quanto menor for o grau de liberdade, mais difícil será para sobreajustar os dados. Por exemplo, uma forma simples de regularizar um modelo polinomial é reduzir o número de graus polinomiais. Para um modelo linear, a regularização é normalmente alcançada ao restringir os pesos do modelo. Veremos a Regressão de Ridge, Regressão Lasso e Elastic Net, que implementam três maneiras diferentes de restringir os pesos. Regressão de Ridge A Regressão de Ridge (também chamada de Regularização de Tikhonov ) é uma versão regularizada da Regressão Linear: um termo de regularização igual a é adicio-nado à função de custo. Isso força o algoritmo de aprendizado a não apenas ajustar os dados, mas também manter os pesos do modelo o mais reduzidos possível. Observe que o termo de regularização só deve ser adicionado à função de custo durante o treinamento. Uma vez treinado o modelo, você deve avaliá-lo utilizando a medida de desempenho não regularizada. É bastante comum que a função de custo utilizada durante o trei-namento seja diferente da medida de desempenho utilizada para o teste. Além da regularização, outra razão pela qual elas podem ser diferentes é que uma boa função de custo de treinamento deve ter derivadas que aceitem bem a otimização, enquanto a medida de de-sempenho utilizada para testes deve ser o mais próxima possível do objetivo final. Um bom exemplo disso é um classificador treinado com uma função de custo, como a log loss (será discutida em breve), mas avaliada com a utilização de precisão/revocação. O hiperparâmetro α controla o quanto você quer regularizar o modelo. Se α = 0, então a Regressão de Ridge é apenas uma Regressão Linear. Se α for muito grande, então todos CG_MIOLO_Hands_On_Machine_Learning. indb 132 07/05/2019 17:08:31

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

Modelos Lineares Regularizados | 133os pesos acabarão próximos de zero e o resultado será uma linha plana que passa pela média dos dados. A Equação 4-8 apresenta a função de custo da Regressão de Ridge. 11 Equação 4-8. Função de custo da Regressão de Ridge Jθ= MSE θ+α1 2∑ i=1n θi2 Repare que o termo de polarização θ 0 não é regularizado (a soma começa em i = 1, não 0). Se definirmos w como o vetor de pesos das características ( θ1 a θn), então o termo de regularização é simplesmente igual a 1/2( ∥ w ∥2)2, em que ∥ · ∥2 representa a norma ℓ 2 do vetor de peso. 12 Para o Gradiente Descendente, adicione α w ao vetor gradiente MSE (Equação 4-6). É importante dimensionar os dados (por exemplo, utilizando um Standard Scaler ) antes de executar a Regressão de Ridge, pois ela é sensível à escala dos recursos de entrada. Isso é verdade para a maioria dos modelos regularizados. A Figura 4-17 mostra vários modelos Ridge treinados em alguns dados lineares com a utilização de diferentes valores de α. À esquerda, modelos simples de Ridge são utiliza-dos levando a previsões lineares. À direita, utilizando Polynomial Features(degree=10), os dados são primeiramente expandidos, então escalonados com Standard Scaler, e finalmente os modelos Ridge são aplicados às características resultantes: isto é uma Regressão Polinomial com regularização Ridge. Observe como o aumento de α leva a previsões mais planas (ou seja, menos extremas, mais razoáveis); isso reduz a variância do modelo, mas aumenta seu viés. Tal como acontece com a Regressão Linear, podemos executar a Regressão de Ridge por meio de uma equação em forma fechada ou pelo Gradiente Descendente. Os prós e contras são os mesmos. A Equação 4-9 mostra a solução de forma fechada ( A é a matriz13 de identidade n × n com exceção de um 0 na célula superior esquerda, correspondente ao termo de polarização). 11 É comum usar a notação J( θ) pa ra funções de custo que não possuem um nome curto; muitas vezes, usaremos essa notação ao longo deste livro. O contexto deixará claro qual função de custo é discutida. 12 Nor mas são abordadas no Capítulo 2. 13 Uma matriz quadrada cheia de “0” exceto pelo “1” na diagonal principal (superior esquerda até a inferior direita). CG_MIOLO_Hands_On_Machine_Learning. indb 133 07/05/2019 17:08:32

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

134 | Capítulo 4: Treinando Modelos Figura 4-17. Regressão de Ridge Equação 4-9. Solução em forma fechada de Regressão de Ridge θ=XT·X+αA-1·XT·y Veja como executar a Regressão de Ridge com Scikit-Learn utilizando uma solução de forma fechada (uma variante da Equação 4-9 utilizando uma técnica de fatoração de matriz de André-Louis Cholesky): >>> from sklearn. linear_model import Ridge >>> ridge_reg = Ridge(alpha=1, solver="cholesky") >>> ridge_reg. fit(X, y) >>> ridge_reg. predict([[1. 5]]) array([[ 1. 55071465]]) E utilizando Gradiente Descendente Estocástico:14 >>> sgd_reg = SGDRegressor(penalty="l2") >>> sgd_reg. fit(X, y. ravel()) >>> sgd_reg. predict([[1. 5]]) array([ 1. 13500145]) O hiperparâmetro penalty define o tipo de termo de regularização para uso. Especificar "l2" indica que você quer que o SGD adicione um termo de regularização à função de custo igual a metade do quadrado da norma ℓ 2 do vetor de peso: isto é simplesmente Regressão de Ridge. 14 Como alternativa, você pode utilizar a classe Ridge com o solucionador "sag". O GD Médio estocástico é uma variante da SGD. Para mais detalhes, veja a apresentação “Minimizing Finite Sums with the Stochastic Average Gradient Algorithm” ( http://goo. gl/vx Vy A2 ) por Mark Schmidt et al. da Universidade da Colúmbia Britânica. CG_MIOLO_Hands_On_Machine_Learning. indb 134 07/05/2019 17:08:32

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

Modelos Lineares Regularizados | 135Regressão Lasso Least Absolute Shrinkage and Selection Operator Regression (simplesmente chamada Regressão Lasso) é outra versão regularizada da Regressão Linear: como a Regressão de Ridge, ela adiciona um termo de regularização à função de custo, mas utiliza a norma ℓ1 do vetor de peso em vez da metade do quadrado da norma ℓ 2 (veja a Equação 4-10). Equação 4-10. Função de custo da Regressão Lasso Jθ= MSE θ+α∑ i=1n θi A Figura 4-18 mostra a mesma coisa que a Figura 4-17, mas substitui modelos Ridge por modelos Lasso e utiliza valores de α menores. Figura 4-18. Regressão Lasso Uma característica importante da Regressão Lasso é que ela tende a eliminar comple-tamente os pesos das características menos importantes (ou seja, ajustá-las para zero). Por exemplo, a linha pontilhada na plotagem à direita na Figura 4-18 (com α = 10-7) parece quadrática, quase linear: todos os pesos para as características polinomiais de alto grau são iguais a zero. Em outras palavras, a Regressão Lasso executa automaticamente a seleção de características e exibe um modelo esparso (ou seja, com poucos pesos de características diferentes de zero). Você pode ter uma ideia do porquê é esse o caso olhando a Figura 4-19: na plotagem à esquerda, os contornos de fundo (elipses) representam uma função de custo MSE não regulada (α = 0), e o círculo branco mostra o caminho do Gradiente Descendente em Lote com aquela função de custo. Os contornos do primeiro plano (diamantes) CG_MIOLO_Hands_On_Machine_Learning. indb 135 07/05/2019 17:08:32

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

136 | Capítulo 4: Treinando Modelosrepresentam a penalidade ℓ 1 e os triângulos mostram o caminho BGD apenas para esta penalidade ( α ∞). Observe como o caminho primeiro atinge θ1 = 0, então rola por uma calha até atingir θ 2 = 0. Na plotagem superior à direita, os contornos representam a mesma função de custo mais uma penalidade de ℓ 1 com α = 0,5. O mínimo global está no eixo θ 2 = 0. O BGD primeiro alcança θ 2 = 0, depois rola a calha até atingir o mínimo global. As duas plotagens de baixo mostram o mesmo, mas utilizam uma penalidade ℓ2 em vez disso. O mínimo regularizado está mais próximo de θ = 0 do que o mínimo não regulamentado, mas os pesos não são totalmente eliminados. Lasso Ridge Penalidade /uni2113₂ Penalidade /uni2113₁ Figura 4-19. Regularização Lasso versus Ridge Na função de custo Lasso, o caminho do BGD tende a saltar pela ca-lha para o final. Isso ocorre porque a inclinação muda abruptamente para θ 2 = 0. Você precisa reduzir gradualmente a taxa de aprendizado para realmente convergir para o mínimo global. A função de custo Lasso não é diferenciável em θ i = 0 (para i = 1, 2, ⋯, n), mas o Gradien-te Descendente ainda funciona bem se você utilizar um vetor subgradiente g15 quando qualquer θi for igual a 0. A Equação 4-11 mostra uma equação de vetor subgradiente que você pode utilizar para o Gradiente Descendente com a função de custo Lasso. 15 Você pode encarar um vetor subgradiente em um ponto não diferenciável como um vetor intermediário entre os vetores de gradiente em torno desse ponto. CG_MIOLO_Hands_On_Machine_Learning. indb 136 07/05/2019 17:08:33

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

Modelos Lineares Regularizados | 137Equação 4-11. Vetor subgradiente da Regressão Lasso gθ,J=θMSE θ+αsinal θ1 sinal θ2 sinal θnonde sinal θi=-1ifθi<0 0i fθi=0 +1ifθi>0 Veja um pequeno exemplo do Scikit-Learn utilizando a classe Lasso. Observe que você poderia utilizar o SGDRegressor(penalty=”l1”) em vez disso. >>> from sklearn. linear_model import Lasso >>> lasso_reg = Lasso(alpha=0. 1) >>> lasso_reg. fit(X, y) >>> lasso_reg. predict([[1. 5]]) array([ 1. 53788174]) Elastic Net Elastic Net é um meio termo entre a Regressão de Ridge e a Regressão Lasso. O termo de regularização é uma simples mistura dos termos de regularização Ridge e Lasso, e você pode controlar a taxa de mistura r. Quando r = 0, a Elastic Net é equivalente à Regressão de Ridge, e, quando r = 1, ela é equivalente à Regressão Lasso (veja a Equação 4-12). Equação 4-12. Função de custo Elastic Net Jθ= MSE θ+rα∑ i=1n θi+1-r 2α∑ i=1n θi2 Então, quando utilizar uma simples Regressão Linear (por exemplo, sem qualquer re-gularização), Ridge, Lasso ou Elastic Net? Quase sempre é preferível ter pelo menos um pouco de regularização, então geralmente você deve evitar uma simples Regressão Linear. Ridge é um bom padrão, mas, se você suspeitar que apenas algumas características são úteis, deve preferir Lasso ou Elastic Net, pois elas tendem a reduzir a zero os pesos das características inúteis, conforme discutido. No geral, a Elastic Net é preferida à Lasso porque esta pode se comportar erraticamente quando o número de características for maior que o número de instâncias de treinamento ou quando várias características estiverem fortemente correlacionadas. Segue um breve exemplo utilizando o Elastic Net do Scikit-Learn ( l1_ratio corres-ponde à taxa de mixagem r ): >>> from sklearn. linear_model import Elastic Net >>> elastic_net = Elastic Net(alpha=0. 1, l1_ratio=0. 5) >>> elastic_net. fit(X, y) >>> elastic_net. predict([[1. 5]]) array([ 1. 54333232]) CG_MIOLO_Hands_On_Machine_Learning. indb 137 07/05/2019 17:08:34

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

138 | Capítulo 4: Treinando Modelos Parada Antecipada Uma maneira bem diferente de regularizar algoritmos de aprendizado iterativos como os Gradientes Descendentes é interromper o treinamento assim que o erro de validação atingir um mínimo. Isto é chamado de parada antecipada. A Figura 4-20 mostra um modelo complexo (neste caso, um modelo de Regressão Polinomial de alto grau) sendo treinado com o uso do Grandiente Descendente em Lote. Conforme as épocas ocorrem, o algoritmo aprende e seu erro de previsão (RMSE) no conjunto de treinamento natu-ralmente decai, assim como seu erro de previsão no conjunto de validação. Entretanto, após um tempo, o erro de validação para de decair e começa a subir, indicando que o modelo começou a se sobreajustar aos dados de treinamento. Com a parada antecipada você para o treinamento assim que o erro de validação atingir o mínimo. É uma técnica de regularização tão simples e eficiente que Geoffrey Hinton a chamou de “ lindo almoço grátis ”. RMSEMelhor modelo Conjunto de validação Conjunto de treinamento Período Figura 4-20. Regularização da Parada Antecipada Com o Gradiente Descendente Estocástico e o Minilote, as curvas não são tão suaves, e pode ser difícil saber se você atingiu o mínimo ou não. Uma solução seria parar somente após o erro de validação ficar acima do mínimo por um período (quando você tiver certeza que o modelo não ficará melhor), então retroceda seus parâmetros ao ponto onde o erro de validação estava no mínimo. Esta é uma implementação básica de parada antecipada: CG_MIOLO_Hands_On_Machine_Learning. indb 138 07/05/2019 17:08:34

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

Regressão Logística | 139# prepare os dados poly_scaler = Pipeline([ ("poly_features", Polynomial Features(degree=90, include_bias=False)), ("std_scaler", Standard Scaler()) ]) X_train_poly_scaled = poly_scaler. fit_transform(X_train) X_val_poly_scaled = poly_scaler. transform(X_val) sgd_reg = SGDRegressor(n_iter=1, warm_start=True, penalty=None, learning_rate="constant", eta0=0. 0005) minimum_val_error = float("inf") best_epoch = None best_model = Nonefor epoch in range(1000): sgd_reg. fit(X_train_poly_scaled, y_train) # continua de onde parou y_val_predict = sgd_reg. predict(X_val_poly_scaled) val_error = mean_squared_error(y_val_predict, y_val) if val_error < minimum_val_error: minimum_val_error = val_error best_epoch = epoch best_model = clone(sgd_reg)from sklearn. base import clone # prepare os dados poly_scaler = Pipeline([ ("poly_features", Polynomial Features(degree=90, include_bias=False)), ("std_scaler", Standard Scaler()) ]) X_train_poly_scaled = poly_scaler. fit_transform(X_train) X_val_poly_scaled = poly_scaler. transform(X_val) sgd_reg = SGDRegressor(n_iter=1, warm_start=True, penalty=None, learning_rate="constant", eta0=0. 0005) minimum_val_error = float("inf") best_epoch = None best_model = Nonefor epoch in range(1000): sgd_reg. fit(X_train_poly_scaled, y_train) # continua de onde parou y_val_predict = sgd_reg. predict(X_val_poly_scaled) val_error = mean_squared_error(y_val_predict, y_val) if val_error < minimum_val_error: minimum_val_error = val_error best_epoch = epoch best_model = clone(sgd_reg)from sklearn. base import clone Note que, com warm_start=True, quando chama o método fit(), ele apenas continua o treinamento onde foi deixado em vez de recomeçar do início. Regressão Logística Como discutimos no Capítulo 1, alguns algoritmos de regressão também podem ser utilizados para classificação (e vice-versa). A Regressão Logística (também chamada de Regressão Logit ) é comumente utilizada para estimar a probabilidade de uma instância pertencer a uma determinada classe (por exemplo, qual é a probabilidade desse e-mail ser spam?). Se a probabilidade estimada for maior que 50%, então o modelo prevê que a instância pertence a essa classe (chamada de classe positiva, rotulada como “1”), ou então ela prevê que não (isto é, pertence à classe negativa, rotulada “0”). Isso o transforma em um classificador binário. Estimando Probabilidades Então, como funciona? Assim como um modelo de Regressão Linear, um modelo de Regressão Logística calcula uma soma ponderada das características de entrada (mais um termo de polarização), mas, em vez de gerar o resultado diretamente como o modelo de Regressão Linear, gera a logística desse resultado (veja a Equação 4-13). CG_MIOLO_Hands_On_Machine_Learning. indb 139 07/05/2019 17:08:34

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

140 | Capítulo 4: Treinando Modelos Equação 4-13. Modelo de regressão logística probabilidade estimada (forma vetorizada) p=hθx=σθT·x A logística — também chamada de logit, subscrita σ(·) — é uma função sigmóide (ou seja, formato-S) que mostra um número entre 0 e 1. É definida como mostrado na Equação 4-14 e Figura 4-21. Equação 4-14. Função Logística σt=1 1+exp-t Figura 4-21. Função Logística Uma vez que o modelo de Regressão Logística estimou a probabilidade ^p= hθ(x) que a instância x pertence à classe positiva, ela pode fazer facilmente sua previsão ŷ (veja a Equação 4-15). Equação 4-15. Previsão do modelo de regressão logística y=0se p<0. 5, 1sep≥0. 5. Observe que σ(t) < 0,5 quando t < 0, e σ(t) ≥ 0,5 quando t ≥ 0, então um modelo de Regressão Logística prevê 1 se θT · x for positivo, e 0 se for negativo. Treinamento e Função de Custo Agora, você já sabe como um modelo de Regressão Logística estima as probabilidades e faz previsões. Mas como ele é treinado? O objetivo do treinamento é definir o vetor do parâmetro θ para que o modelo estime altas probabilidades para instâncias positivas ( y =1) e baixas probabilidades para instâncias negativas ( y = 0). A função de custo incor-pora essa ideia mostrada na Equação 4-16 para uma instância de treinamento única x. CG_MIOLO_Hands_On_Machine_Learning. indb 140 07/05/2019 17:08:35

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

Regressão Logística | 141Equação 4-16. Função de custo de uma instância de treinamento única cθ=-log p sey=1,-log 1-psey=0. Esta função de custo faz sentido porque-log( t) cresce muito quando t se aproxima de 0, então o custo será maior se o modelo estimar uma probabilidade próxima a 0 para uma instância positiva, e também será muito maior se o modelo estimar uma probabilidade próxima a 1 para uma instância negativa. Por outro lado,-log( t) é próximo a 0 quando t for próximo de 1, então o custo será próximo de 0 se a probabilidade estimada for próxima de 0 para uma instância negativa ou próxima de 1 para uma instância positiva, que é exatamente o que queremos. A função de custo em relação a todo o conjunto de treinamento é simplesmente o custo médio em relação a todas as instâncias de treinamento. Ela pode ser escrita em uma simples expressão (como você pode verificar facilmente), chamada log loss, mostrada na Equação 4-17. Equação 4-17. Função de custo de Regressão Logística (log loss) Jθ=-1 m∑ i=1m yilogpi+1-yilog1-pi A má notícia é que não há equação de forma fechada conhecida para calcular o valor de θ que minimize esta função de custo (não há uma equivalente do Método dos Mínimos Quadrados). Mas a boa notícia é que esta função de custo é convexa, então o Gradiente Descendente (ou qualquer outro algoritmo de otimização) se certifica de encontrar o mínimo global (se a taxa de aprendizado não for muito grande e se você esperar o suficiente). As derivadas parciais da função de custo com relação ao j-ésimo modelo do parâmetro θj é dada pela Equação 4-18. Equação 4-18. Derivada parcial da função de custo logística ∂ ∂θj Jθ=1 m∑ i=1m σθT·xi-yixji Esta equação se parece muito com a Equação 4-5: ela calcula o erro de previsão para cada instância, o multiplica pelo valor da j-ésima característica, e então calcula a média em relação a todas as instâncias de treinamento. Uma vez que tenha o vetor de gradiente contendo todas as derivadas parciais, você pode utilizá-las no algoritmo do Gradiente Descendente. É isso: agora você já sabe como treinar um modelo de Regressão Logística. Para o GD Estocástico, você poderia pegar uma instância por vez, e para o GD Minilote você poderia utilizar um minilote por vez. CG_MIOLO_Hands_On_Machine_Learning. indb 141 07/05/2019 17:08:35

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

142 | Capítulo 4: Treinando Modelos Fronteiras de Decisão Utilizaremos o conjunto de dados da íris para ilustrar a Regressão Logística. Este é um conjunto de dados famoso que contêm o comprimento e a largura das sépalas e pétalas de 150 flores de íris de três espécies diferentes: Iris-Setosa, Iris-Versicolor e Iris-Virginica (veja a Figura 4-22). Virginica Pétala Versicolor Setosa Sépala Figura 4-22. Flores de três espécies de plantas de íris 16 Tentaremos construir um classificador para detectar o tipo Iris-Virginica baseado so-mente na característica do comprimento da pétala. Primeiro carregaremos os dados: >>> from sklearn import datasets >>> iris = datasets. load_iris() >>> list(iris. keys()) ['data', 'target_names', 'feature_names', 'target', 'DESCR'] >>> X = iris["data"][:, 3:] # largura da pétala >>> y = (iris["target"] == 2). astype(np. int) # 1 se for Iris Virgínica, caso contrário, 0 Agora, treinaremos um modelo de Regressão Logística: from sklearn. linear_model import Logistic Regression log_reg = Logistic Regression() log_reg. fit(X, y) Vejamos as probabilidades estimadas do modelo para flores com larguras de pétalas variando de 0 a 3 cm (Figura 4-23): 16 Fotos reproduzidas a partir das páginas correspondentes da Wikipédia. Foto da Iris-Virginica de Frank Mayfield (Creative Commons BY-SA 2. 0 (https://creativecommons. org/licenses/by-sa/2. 0/)), foto da Iris-Ver-sicolor de D. Gordon E. Robertson (Creative Commons BY-SA 3. 0 (https://creativecommons. org/licenses/ by-sa/3. 0/)), e a foto Iris-Setosa é de domínio público. CG_MIOLO_Hands_On_Machine_Learning. indb 142 07/05/2019 17:08:36

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

Regressão Logística | 143X_new = np. linspace(0, 3, 1000). reshape(-1, 1) y_proba = log_reg. predict_proba(X_new) plt. plot(X_new, y_proba[:, 1], "g-", label="Iris-Virginica") plt. plot(X_new, y_proba[:, 0], "b--", label="Not Iris-Virginica") # mais código Matplotlib para deixar a imagem bonita Largura da pétala (cm)decisão Iris-Virginica Não Iris-Virginica Probabilidade Fronteira de Figura 4-23. Probabilidades estimadas e limites da decisão A largura da pétala das flores Iris-Virginica (representada por triângulos) varia de 1,4cm a 2,5cm, enquanto as outras íris (representadas por quadrados) geralmente têm uma largura menor de pétala, variando de 0,1cm a 1,8cm. Observe que há um pouco de sobreposição. Quando está acima de cerca de 2cm, o classificador confia muito que seja uma flor Iris-Virginica (ele mostra uma alta probabilidade para essa classe), e se estiver abaixo de 1cm ele é muito confiante de que não é uma Iris-Virginica (alta probabilidade para a classe “Não Iris-Virginica”). Entre estes extremos, o classificador não tem tanta certeza. No entanto, se você pedir que ele preveja a classe (utilizando o método predict() em vez do método predict_proba() ), ele retornará a classe que for mais provável. Portanto, existe uma fronteira de decisão, em torno de 1,6cm, na qual ambas as probabilidades são iguais a 50%: se a largura da pétala for superior a 1,6 cm, o classificador preverá que a flor é uma Iris-Virginica, ou então que não é (mesmo que não esteja muito confiante): >>> log_reg. predict([[1. 7], [1. 5]]) array([1, 0]) A Figura 4-24 mostra o mesmo conjunto de dados, mas desta vez exibindo duas caracte-rísticas: largura e comprimento da pétala. Uma vez treinado, o classificador de Regressão Logística pode estimar a probabilidade de uma nova flor ser uma Iris-Virginica com base nessas duas características. A linha tracejada representa os pontos onde o modelo estima uma probabilidade de 50%: esta é a fronteira de decisão do modelo. Observe que é uma fronteira linear. 17 Cada linha paralela representa os pontos onde o modelo produz uma probabilidade específica, de 15% (inferior esquerda) a 90% (superior direita). Todas as 17 É o conjunto de pontos x tal que θ0 + θ1x1 + θ2x2 = 0 define uma linha reta. CG_MIOLO_Hands_On_Machine_Learning. indb 143 07/05/2019 17:08:36

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

144 | Capítulo 4: Treinando Modelosflores além da linha superior direita têm mais de 90% de chance de serem Iris-Virginica, de acordo com o modelo. Não Iris-Virginica Comprimento da Pétala Iris-Virginic a Largura da Pétala Figura 4-24. Fronteiras de decisão linear Assim como outros modelos lineares, os modelos de Regressão Logística podem ser regulari-zados usando as penalidades ℓ 1 ou ℓ 2. O Scitkit-Learn adiciona uma penalidade ℓ 2 por padrão. O hiperparâmetro que controla a força de regularização de um mo-delo Logistic Regression do Scikit-Learn não é alfa (como em outros modelos lineares), mas seu inverso: C. Quanto maior o valor de C, menos o modelo é regularizado. Regressão Softmax O modelo de Regressão Logística pode ser generalizado para suportar múltiplas classes diretamente sem a necessidade de treinar e combinar vários classificadores binários (como discutido no Capítulo 3). Isso é chamado Regressão Softmax, ou Regressão Logís-tica Multinomial. A ideia é bem simples: quando dada uma instância x, o modelo de Regressão Softmax primeiro calcula uma pontuação sk(x) para cada classe k, então estima a probabilidade de cada classe aplicando a função softmax (também chamada exponencial normalizada ) às pontuações. A equação para calcular sk(x) deve ser familiar, pois é exatamente como a equação de previsão da Regressão Linear (veja a Equação 4-19). Equação 4-19. Pontuação Softmax para a classe k skx=θk T·x Observe que cada classe tem seu próprio vetor de parâmetro dedicado θ(k). Todos esses vetores são armazenados tipicamente como linhas na matriz de parâmetro Θ. CG_MIOLO_Hands_On_Machine_Learning. indb 144 07/05/2019 17:08:37

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

Regressão Logística | 145Uma vez calculada a pontuação de cada classe para a instância x, você pode estimar a probabilidade pk=σsxk=exp skx ∑j=1Kexp sjx de a instância pertencer à classe k ao executar as pontuações através da função softmax (Equação 4-20): ela calcula a exponencial de cada pontuação e a normaliza (dividindo pela soma de todas as exponenciais). Equação 4-20. Função Softmax pk=σsxk=exp skx ∑j=1Kexp sjx K é o número de classes; s(x) é um ve tor que contém as pontuações de cada classe para a instância x; σ(s(x))k é a probabilidade estimada de que a instância x pertença à classe k dadas as pontuações de cada classe para aquela instância. Assim como o classificador de Regressão Logística, o classificador de Regressão Softmax prevê a classe com a maior probabilidade estimada (que é simplesmente a classe com a maior pontuação), como mostrado na Equação 4-21. Equação 4-21. Previsão do classificador de Regressão Softmax y=argmax kσsxk=argmax kskx= argmax kθk T·x O operador argmax re torna o valor de uma variável que maximiza uma função. Nes-ta equação ele retorna o valor de k, que maximiza a probabilidade estimada σ (s(x))k. O classificador da Regressão Softmax prevê apenas uma classe de cada vez (ou seja, ele é multiclasse, não multioutput), portanto, deve ser usado apenas com classes mutuamente exclusivas, como diferen-tes tipos de plantas. Você não pode usá-lo para reconhecer várias pessoas em uma única imagem. Agora que você sabe como o modelo estima as probabilidades e faz previsões, vamos dar uma olhada no treinamento. O objetivo é ter um modelo que estime uma alta probabi-lidade para a classe-alvo (e consequentemente uma baixa probabilidade para as outras). Minimizar a função de custo mostrada na Equação 4-22, denominada entropia cruzada, deve levar a esse objetivo porque penaliza o modelo quando ele calcula uma baixa proba-bilidade para uma classe-alvo. A entropia cruzada é frequentemente utilizada para medir a qualidade da combinação de um conjunto de probabilidades de classe estimadas com as classes-alvo (vamos utilizá-la muitas vezes nos capítulos seguintes). CG_MIOLO_Hands_On_Machine_Learning. indb 145 07/05/2019 17:08:37

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

146 | Capítulo 4: Treinando Modelos Equação 4-22. Função de custo de entropia cruzada JΘ=-1 m∑ i=1m ∑ k=1K ykilogpki é igual a 1 se a classe-alvo para a instância i-ésima for k; caso contrário, será igual a 0. Observe que, quando há apenas duas classes ( K = 2), essa função de custo é equivalente à função de custo da Regressão Logística ( log loss ; veja a Equação 4-17). Entropia Cruzada A entropia cruzada originou-se da teoria da informação. Suponha que você deseja trans-mitir informações sobre o clima de forma eficiente todos os dias. Se houver oito opções (ensolarado, chuvoso, etc. ), você poderia programar cada opção utilizando 3 bits desde que 23 = 8. No entanto, se você acha que será ensolarado quase todos os dias, seria muito mais eficiente programar “ensolarado” com apenas um bit (0) e as outras sete opções com 4 bits (começando com 1). A entropia cruzada mede o número médio de bits por opção que você realmente envia. Se a sua suposição for perfeita, a entropia cruzada será ape-nas igual à entropia do próprio clima (ou seja, sua imprevisibilidade intrínseca). Mas, se seus pressupostos estiverem errados (por exemplo, se chover com frequência), a entropia cruzada será melhor por uma quantidade chamada divergência Kullback-Leibler. A entropia cruzada entre duas distribuições de probabilidade p e q é definida como (pelo menos quando as distribuições são discretas). O vetor gradiente desta função de custo com relação à θ(k) é dado pela Equação 4-23: Equação 4-23. Vetor gradiente de entropia cruzada para classe k θk JΘ=1 m∑ i=1m pki-ykixi Agora, você pode calcular o vetor de gradiente para cada classe e, em seguida, utilizar o Gradiente Descendente (ou qualquer outro algoritmo de otimização) para encontrar a matriz de parâmetro Θ que minimiza a função de custo. Utilizaremos a Regressão Softmax para classificar as íris nas três classes. O Logistic Regression do Scikit-Learn utiliza um contra todos automaticamente quando você o treina em mais de duas classes, mas você também pode configurar o hiperparâmetro multi_class para “multinomial ” a fim de alternar para a Regressão Softmax. Você também deve especificar um solucionador que suporte a Regressão Softmax, como o solucionador “lbfgs ” (veja a documentação do Scikit-Learn para mais detalhes). Ele também aplica a regularização ℓ2 por padrão, que você pode controlar utilizando o hiperparâmetro C. CG_MIOLO_Hands_On_Machine_Learning. indb 146 07/05/2019 17:08:38

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

Exercícios | 147X = iris["data"][:, (2, 3)] # comprimento da pétala, largura da pétala y = iris["target"] softmax_reg = Logistic Regression(multi_class="multinomial",solver="lbfgs", C=10) softmax_reg. fit(X, y) Então, na próxima vez que você encontrar uma íris com pétalas de 5cm de comprimento e 2cm de largura, você pode pedir ao seu modelo para lhe dizer que tipo de íris é, e ele responderá Iris-Virginica (classe 2) com 94,2% de probabilidade (ou Iris-Versicolor com 5,8% de probabilidade): >>> softmax_reg. predict([[5, 2]]) array([2]) >>> softmax_reg. predict_proba([[5, 2]])array([[ 6. 33134078e-07, 5. 75276067e-02, 9. 42471760e-01]]) A Figura 4-25 mostra os limites de decisão resultantes, representados pelas cores de fundo. Observe que as fronteiras de decisão entre duas classes são lineares. A figura também mostra as probabilidades para a classe Iris-Versicolor, representada pelas linhas curvas (por exemplo, a linha marcada com 0,450 representa o limite de probabilidade de 45%). Observe que o modelo pode prever uma classe que tenha uma probabilidade estimada abaixo de 50%. Por exemplo, no ponto em que todos os limites da decisão se encontram, todas as classes têm uma mesma probabilidade estimada de 33%. Iris-Virginic a Iris-Versicolour Iris-Set osa Largura da Pétala Comprimento da Pétala Figura 4-25. As fronteiras de decisão da Regressão Softmax Exercícios 1. Qual algoritmo de treinamento de Regressão Linear podemos utilizar se tivermos um c onjunto de treinamento com milhões de características? 2. Sup onha que as características do seu conjunto de treinamento tenham escalas muito diferentes. Que algoritmos podem sofrer com isso, e como? O que você pode fazer a respeito? CG_MIOLO_Hands_On_Machine_Learning. indb 147 07/05/2019 17:08:38

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

148 | Capítulo 4: Treinando Modelos3. O Gradiente Descendente pode ficar preso em um mínimo local ao treinar um mo delo de Regressão Logística? 4. Se t odos os algoritmos do Gradiente Descendente forem executados com tempo suficiente, eles o levarão ao mesmo modelo? 5. Sup onha que você utilize o Gradiente Descendente em Lote e plote seu erro de validação em cada época. Se você notar que o erro de validação sempre aumenta, o que provavelmente está acontecendo? Como consertar isso? 6. É uma b oa ideia parar o Gradiente Descendente em Minilote imediatamente quando o erro de validação aumentar? 7. Qua l algoritmo Gradiente Descendente (entre aqueles que discutimos) se aproxi-mará mais rapidamente da solução ideal? Qual realmente convergirá? Como você pode fazer os outros convergirem também? 8. Sup onha que esteja utilizando a Regressão Polinomial. Você plota as curvas de aprendizado e percebe que existe um grande hiato entre o erro de treinamento e o de validação. O que está acontecendo? Quais são as três maneiras de resolver isso? 9. Sup onha que você esteja utilizando a Regressão de Ridge e perceba que o erro de treinamento e o de validação são quase iguais e bastante altos. Você diria que o modelo sofre de um viés elevado ou de alta variância? Devemos aumentar o hiperparâmetro α ou reduzi-lo? 10. Por q ue você utilizaria: Reg ressão de Ridge em vez de Regressão Linear simples (ou seja, sem qualquer regularização)? Las so em vez de Regressão de Ridge? Ela stic Net em vez de Lasso? 11. Sup onha que você deseja classificar fotos como exteriores/interiores e dia/noite. Você deve implementar dois classificadores de Regressão Logística ou um de Re-gressão Softmax? 12. Imp lemente o Gradiente Descendente em Lote com parada antecipada para a Regressão Softmax (sem utilizar o Scikit-Learn). Soluções dos exercícios disponíveis no Apêndice A. CG_MIOLO_Hands_On_Machine_Learning. indb 148 07/05/2019 17:08:38

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

149Capítulo 5 Máquinas de Vetores de Suporte Uma Máquina de Vetores de Suporte (SVM) é um modelo muito poderoso e versátil de Aprendizado de Máquina capaz de realizar classificações lineares ou não lineares, de regressão e até mesmo detecção de outliers. É um dos modelos mais populares no Aprendizado de Máquina e qualquer pessoa interessada no tema deve tê-lo em sua caixa de ferramentas. As SVM são particularmente adequadas para a classificação de conjuntos de dados complexos, porém de pequeno ou médio porte. Este capítulo explicará seus conceitos básicos, como utilizá-las e como funcionam. Classificação Linear das SVM A ideia fundamental por trás das SVM é melhor explicada com algumas imagens. A Figura 5-1 mostra parte do conjunto de dados da íris que foi introduzido no final do Capítulo 4. As duas classes podem ser separadas facilmente com uma linha reta (elas são separadas linearmente ). A plotagem à esquerda mostra os limites de decisão de três possíveis classificadores lineares. O modelo cujo limite de decisão é representado pela linha tracejada é tão ruim que nem sequer consegue separar as classes corretamente. Os outros dois modelos funcionam perfeitamente neste conjunto, mas seus limites de decisão chegam tão perto das instâncias que provavelmente não funcionarão tão bem em novas instâncias. Em contraste, a linha contínua na plotagem à direita representa o limite de decisão de um classificador SVM; esta linha não somente separa as duas classes, mas também fica o mais longe possível das instâncias de treinamento mais próximas. Você pode pensar em um classificador SVM como o preenchimento da via mais larga possível entre as classes (representada pelas linhas tracejadas paralelas). Isso é chamado de classificação de margens largas. CG_MIOLO_Hands_On_Machine_Learning. indb 149 07/05/2019 17:08:38

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

150 | Capítulo 5: Máquinas de Vetores de Suporte Largura da Pétala Comprimento da Pétala Comprimento da Pétala Figura 5-1. Classificação de margens largas Observe que adicionar mais instâncias de treinamento “fora da via” não afeta o limite de decisão: ele está totalmente determinado (ou “suportado”) pelas instâncias locali-zadas na borda da via. Essas instâncias são chamadas de vetores de suporte (elas estão circuladas na Figura 5-1). As SVM são sensíveis às escalas das características, como você pode ver na Figura 5-2: na plotagem à esquerda, a escala vertical é muito maior do que a horizontal, então a via mais larga possível está pró-xima da horizontal. Após o escalonamento das características (por exemplo, ao utilizarmos o Standard Scaler do Scikit-Learn), o limite de decisão parece bem melhor (na plotagem à direita). Sem escalonamento Com escalonamento Figura 5-2. Sensitividade ao escalonamento das características Classificação de Margem Suave Se impusermos estritamente que todas as instâncias estejam fora da via e do lado direito, estaremos aplicando uma classificação de margem rígida, que possui duas questões prin-cipais. Primeiro, ela só funciona se os dados forem linearmente separáveis e, segundo, ela é bastante sensível a outliers. A Figura 5-3 mostra o conjunto de dados da íris com apenas um outlier adicional: à esquerda, é impossível encontrar uma margem rígida e, à direita, a fronteira de decisão termina bem diferente do que vimos na Figura 5-1 sem o outlier, e provavelmente não generalizará tão bem. CG_MIOLO_Hands_On_Machine_Learning. indb 150 07/05/2019 17:08:39

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

Classificação Linear das SVM | 151 Largura da Pétala Comprimento da Pétala Comprimento da Pétala Outlie r Outlie r Impossível! Figura 5-3. Sensibilidade da margem rígida aos outliers É preferível utilizar um modelo mais flexível a fim de evitar esses problemas. O objeti-vo é encontrar um bom equilíbrio entre manter a via o mais larga possível e limitar as violações de margem (ou seja, as instâncias que acabam no meio da via ou mesmo do lado errado). Isto é chamado classificação de margem suave. Nas classes SVM do Scikit-Learn você controla esse equilíbrio ao utilizar o hiperparâmetro C: um valor menor de C leva a uma via mais larga, mas com mais violações das margens. A Figura 5-4 mostra os limites de decisão e as margens de dois classificadores SVM de margem suave em um conjunto de dados não linearmente separáveis. À esquerda, ao utilizar um alto valor de C, o classificador faz menos violações na margem, mas fica com uma margem menor. À direita, ao utilizar um baixo valor de C, a margem fica muito maior, mas muitas instâncias ficam na via. No entanto, parece provável que o segundo classificador generalizará melhor: na verdade, mesmo neste conjunto de treinamento ele comete menos erros de previsão já que a maioria das violações da margem está do lado correto do limite de decisão. Largura da P étala Comprimento da Pétala Comprimento da Pétala Iris-Virginica Iris-Versicolour Figura 5-4. Menos violações de margem versus grandes margens Se seu modelo SVM está sobreajustado, você pode tentar regularizá--lo reduzindo o valor de C. O código do Scikit-Learn a seguir carrega o conjunto de dados da íris, escalona as carac-terísticas e treina um modelo SVM linear (utilizando a classe Linear SVC com C = 1 e a CG_MIOLO_Hands_On_Machine_Learning. indb 151 07/05/2019 17:08:39

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

152 | Capítulo 5: Máquinas de Vetores de Suportefunção hinge loss descrita brevemente) para detectar as flores Iris-Virginica. O modelo resultante está representado à direita da Figura 5-4. import numpy as np from sklearn import datasets from sklearn. pipeline import Pipelinefrom sklearn. preprocessing import Standard Scaler from sklearn. svm import Linear SVC iris = datasets. load_iris() X = iris["data"][:, (2, 3)] # comprimento da pétala, largura da pétala y = (iris["target"] == 2). astype(np. float64) # Iris Virgínica svm_clf = Pipeline([ ("scaler", Standard Scaler()), ("linear_svc", Linear SVC(C=1, loss="hinge")), ]) svm_clf. fit(X, y) Então, como de costume, você pode utilizar o modelo para fazer previsões: >>> svm_clf. predict([[5. 5, 1. 7]]) array([ 1. ]) Ao contrário dos classificadores de Regressão Logística, os classifica-dores SVM não apresentam probabilidades para cada classe. Como alternativa, você poderia utilizar a classe SVC ao aplicar SVC(kernel="linear", C=1), mas ela é muito mais lenta, principalmente em grandes conjuntos de treinamento, portanto não é recomendável. Outra opção seria utilizar a classe SGDClassifier com SGDClassifier(loss="hinge", alpha=1/(m*C)), o que aplicará o Gradiente Descendente Estocástico regular (ver Capítulo 4) no treinamento de um classificador linear SVM. Ele não converge tão rápido quanto a classe Linear SVC, mas pode ser útil para manipular grandes conjuntos de dados que não cabem na memória (treinamento out-of-core), ou para manipular tarefas de classificação online. A classe Linear SVC regulariza o termo de polarização, então você deve centrar primeiro o conjunto de treinamento subtraindo sua média. Este processo é automatizado se você escalonar os dados uti-lizando o Standard Scaler. Além disso, certifique-se de configurar o hiperparâmetro loss para "hinge", pois ele não é o valor padrão. Finalmente, para um melhor desempenho, você deve configurar o hiperparâmetro dual para False, a menos que existam mais carac-terísticas do que instâncias de treinamento (discutiremos a dualida-de ainda neste capítulo). CG_MIOLO_Hands_On_Machine_Learning. indb 152 07/05/2019 17:08:40

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

Classificação SVM Não Linear | 153Classificação SVM Não Linear Embora os classificadores lineares SVM sejam eficientes e funcionem surpreendentemente bem em muitos casos, muitos conjuntos de dados nem sequer estão próximos de serem linearmente separáveis. Adicionar mais características, como as polinomiais (como você fez no Capítulo 4) é uma abordagem válida para lidar com os conjuntos de dados não lineares; em alguns casos, isso pode resultar em um conjunto de dados linearmente separável. Considere a plotagem à esquerda na Figura 5-5: ela representa um conjunto de dados simples com apenas uma característica x1. Como você pode ver, este conjunto de dados não é linearmente separável. Mas, se adicionarmos uma segunda característica, x2 = (x1)2, o conjunto de dados 2D resultante será perfeitamente separável linearmente. Figura 5-5. Adicionando características para tornar um conjunto de dados linearmente separável Para implementar esta ideia usando o Scikit-Learn, criamos um Pipeline contendo um transformador Polynomial Features (discutido em “ Regressão Polinomial” na página 123), seguido por uma Standard Scaler e uma Linear SVC. Testaremos isso no conjunto de dados em formato de luas (veja a Figura 5-6): from sklearn. datasets import make_moons from sklearn. pipeline import Pipeline from sklearn. preprocessing import Polynomial Features polynomial_svm_clf = Pipeline([ ("poly_features", Polynomial Features(degree=3)), ("scaler", Standard Scaler()), ("svm_clf", Linear SVC(C=10, loss="hinge")) ]) polynomial_svm_clf. fit(X, y) CG_MIOLO_Hands_On_Machine_Learning. indb 153 07/05/2019 17:08:40

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

154 | Capítulo 5: Máquinas de Vetores de Suporte Figura 5-6. Classificador Linear SVM com a utilização de características polinomiais Kernel Polinomial Implementar a adição de características polinomiais é simples e pode funcionar bem em todos os tipos de algoritmos de Aprendizado de Máquina (não apenas as SVMs), mas com um baixo grau polinomial não podemos lidar com conjuntos de dados muito complexo, e com um alto grau polinomial criamos um grande número de características, o que torna o modelo muito mais lento. Felizmente, ao utilizar as SVM, aplicamos uma técnica matemática quase milagrosa cha-mada truque do kernel (que já será explicado). Isso permite obter o mesmo resultado como se você adicionasse inúmeras características polinomiais, mesmo com polinômios de alto grau, sem realmente precisar adicioná-las. Portanto, não há nenhuma explosão combinatória da quantidade de características, pois não adicionamos nenhuma na verdade. Este truque é implementado pela classe SVC. Vamos testá-lo no conjunto de dados em formato de luas: from sklearn. svm import SVC poly_kernel_svm_clf = Pipeline([ ("scaler", Standard Scaler()), ("svm_clf", SVC(kernel="poly", degree=3, coef0=1, C=5)) ]) poly_kernel_svm_clf. fit(X, y) Ao utilizar um kernel polinomial de 3º grau, este código treina um classificador SVM. Ele está representado à esquerda da Figura 5-7. À direita, temos outro classificador SVM utilizando um kernel polinomial de 10º grau. Obviamente, se o seu modelo estiver se sobreajustando é necessário reduzir seu grau polinomial. Por outro lado, se estiver se subajustando, é preciso tentar aumentá-lo. O hiperparâmetro coef0 controla o quanto o modelo é influenciado por polinômios de alto grau versus polinômios de baixo grau. CG_MIOLO_Hands_On_Machine_Learning. indb 154 07/05/2019 17:08:40

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

Classificação SVM Não Linear | 155 Figura 5-7. Classificadores SVM com um kernel polinomial Uma abordagem comum para encontrarmos os valores corretos do hiperparâmetro é utilizar a busca em grade (consulte o Capítulo 2). Muitas vezes é mais rápido fazer uma grid search grosseira e depois uma grid search mais refinada em torno dos melhores valores en-contrados. Ter bom senso sobre o que cada hiperparâmetro real-mente faz também pode ajudar você a procurar na parte certa do espaço do hiperparâmetro. Adicionando Características de Similaridade Outra técnica para se resolver problemas não lineares é a adição de características cal-culadas ao utilizar uma função de similaridade, que mede o quanto cada instância se assemelha a um ponto de referência específico. Por exemplo, vamos pegar o conjunto de dados unidimensional discutido anteriormente e adicionar dois pontos de referência em x1 =-2 e x 1 = 1 (veja a plotagem à esquerda na Figura 5-8). A seguir, definimos a função de similaridade como Função de Base Radial (RBF, em inglês) Gaussiana com γ = 0,3 (veja a Equação 5-1). Equação 5-1. RBF Gaussiana /uni03D5γx,/uni2113= exp-γx-/uni21132 É uma função em forma de sino que varia de 0 (muito longe do ponto de referência) a 1 (no ponto de referência). Agora estamos prontos para calcular as novas características. Por exemplo, observe a instância x 1 =-1: localizada a uma distância de 1 do primeiro ponto de referência e 2 do segundo. Portanto, suas novas características são x 2 = exp (-0,3 × 12) ≈ 0,74 e x 3 = exp (-0,3 × 22) ≈ 0,30. A plotagem à direita da Figura 5-8 mostra o conjunto de dados transformado (descartando as características originais). Como você pode ver, agora ele é linearmente separável. CG_MIOLO_Hands_On_Machine_Learning. indb 155 07/05/2019 17:08:41

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

156 | Capítulo 5: Máquinas de Vetores de Suporte Similaridade Figura 5-8. Características de similaridade utilizando a RBF Gaussiana Você deve estar se perguntando como podemos selecionar os pontos de referência. A abordagem mais simples seria criar um ponto na localização de cada instância no con-junto de dados. Isso criará muitas dimensões e aumentará as chances de o conjunto de treinamento transformado ser linearmente separável. A desvantagem é que um conjunto de treinamento com m instâncias e n características se transforma em um conjunto de treinamento com m instâncias e m características (assumindo que você descarte as características originais). Se o conjunto for muito grande, você ficará com um número igualmente grande de características. Kernel RBF Gaussiano Assim como o método de características polinomiais, o método de características de similaridade pode ser útil com qualquer algoritmo do Aprendizado de Máquina, mas poderá ter um custo computacional elevado para calcular todas as características adi-cionais, especialmente em grandes conjuntos de treinamento. No entanto, mais uma vez, o truque do kernel faz sua mágica na SVM: possibilita a obtenção de um resultado semelhante, como se você tivesse adicionado muitas características de similaridade sem realmente precisar adicioná-las. Vamos tentar o kernel RBF Gaussiano com a utilização da classe SVC: rbf_kernel_svm_clf = Pipeline([ ("scaler", Standard Scaler()), ("svm_clf", SVC(kernel="rbf", gamma=5, C=0. 001)) ]) rbf_kernel_svm_clf. fit(X, y) Este modelo está representado na parte inferior esquerda da Figura 5-9. As outras plota-gens mostram modelos treinados com diferentes valores dos hiperparâmetros gamma (γ) e C. Aumentar gamma estreitará a curva em forma de sino (veja a plotagem à esquerda da Figura 5-8), e como resultado cada raio de influência da instância será menor: mexer CG_MIOLO_Hands_On_Machine_Learning. indb 156 07/05/2019 17:08:41

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

Classificação SVM Não Linear | 157ao redor de instâncias individuais torna a fronteira de decisão mais irregular. Por outro lado, um pequeno valor de gamma torna a curva em forma de sino mais ampla, de modo que as instâncias ficam com um maior raio de influência e o limite de decisão fica mais suave. Então γ age como um hiperparâmetro de regularização: se seu modelo estiver sobreajustado você deve reduzi-lo e, se estiver subajustado, você deve aumentá-lo (como o hiperparâmetro C). Figura 5-9. Classificadores SVM utilizando o kernel RBF Existem outros kernels, mas eles são utilizados muito mais raramente. Por exemplo, alguns kernels são especializados em estruturas de dados específicas. Algumas vezes, string kernels são utilizados na classificação de documentos de textos ou sequências de DNA (por exemplo, ao utilizar o string subsequence kernel ou kernels baseados em distância Levenshtein ). Com tantos kernels para escolher, como decidir qual deles utilizar? Como regra geral, devemos sempre tentar o kernel linear primeiro (lembre-se de que o Linear SVC é muito mais rápido do que o SVC (kernel="linear") ), especialmente se o conjunto de treinamento for muito grande ou se tiver muitas características. Se o conjunto de treinamento não for muito grande, você também deve tentar o kernel RBF Gaussiano; ele funciona bem na maioria dos casos. Se tiver tempo livre e poder de computação, experimente também al-guns outros kernels que utilizam a validação cruzada e a grid search, especialmente se houver kernels especializados para a estrutura de dados do seu conjunto de treinamento. CG_MIOLO_Hands_On_Machine_Learning. indb 157 07/05/2019 17:08:41

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

158 | Capítulo 5: Máquinas de Vetores de Suporte Complexidade Computacional A classe Linear SVC é baseada na biblioteca liblinear, que implementa um algoritmo otimi-zado ( http://goo. gl/R635CH ) para o SVM linear. 1 Ele não suporta o truque do kernel, mas escalona quase linearmente com o número de instâncias de treinamento e o número de características: sua complexidade de tempo de treinamento é mais ou menos O (m × n). O algoritmo demorará mais se você precisar de uma precisão muito alta. Isso é contro-lado pelo hiperparâmetro de tolerância ϵ (chamado tol no Scikit-Learn). Na maioria das tarefas de classificação, a tolerância padrão é suficiente. A classe SVC é baseada na biblioteca libsvm, que implementa um algoritmo ( http://goo. gl/a8Hk E3 ) que suporta o truque do kernel. 2 A complexidade do período de treinamen-to geralmente está entre O(m2 × n) e O (m3 × n). Infelizmente, isso significa que ele fica terrivelmente lento quando o número de instâncias de treinamento cresce (por exemplo, centenas de milhares de instâncias). Este algoritmo é perfeito para conjuntos de treina-mento complexos, sejam eles pequenos ou médios. No entanto, ele se escalona bem com o número de características, especialmente com características esparsas (ou seja, quando cada instância possui poucas características diferentes de zero). Neste caso, o algoritmo dimensiona grosseiramente com o número médio de características diferentes de zero por instância. A Tabela 5-1 compara as classes de classificação SVM do Scikit-Learn. T abela 5-1. Comparação das classes do Scikit-Learn para a classificação SVM Classe Complexidade do período Suporte out-of-core Escalonamento requerido Truque do kernel requerido Linear SVC O(m × n) Não Sim Não SGDClassifier O(m × n) Sim Sim Não SVC O(m ² × n ) to O( m³ × n) Não Sim Sim Regressão SVM Como mencionamos anteriormente, o algoritmo SVM é bastante versátil: ele não só suporta a classificação linear e não linear, mas também a Regressão Linear e não linear. O truque é reverter o objetivo: ao invés de tentar preencher a maior via possível entre duas classes, limitando as violações da margem, a Regressão SVM tenta preencher o maior número possível de instâncias na via limitando as violações da margem (ou seja, instâncias fora 1 “A Dual Coordinate Descent Method for Large-scale Linear SVM”, Lin et al. (2 008). 2 “Se quential Minimal Optimization (SMO)”, J. Platt (1998). CG_MIOLO_Hands_On_Machine_Learning. indb 158 07/05/2019 17:08:41

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

Regressão SVM | 159da via). A largura da via é controlada por um hiperparâmetro ϵ. A Figura 5-10 mostra dois modelos SVM de Regressão Linear treinados em algum dado linear aleatório, um com uma margem larga ( ϵ = 1,5) e o outro com uma margem pequena ( ϵ = 0,5). Figura 5-10. Regressão SVM Adicionar mais instâncias de treinamento dentro da margem não afeta as previsões do modelo; assim, o modelo é chamado de ϵ-insensitive. Você pode utilizar a classe Linear SVR do Scikit-Learn para executar a regressão SVM linear. O código a seguir produz o modelo representado à esquerda na Figura 5-10 (os dados de treinamento devem ser escalonados e centrados primeiro): from sklearn. svm import Linear SVR svm_reg = Linear SVR(epsilon=1. 5) svm_reg. fit(X, y) Para enfrentar tarefas de regressão não linear você pode utilizar um modelo SVM kernelizado. Por exemplo, a Figura 5-11 mostra a Regressão SVM em um conjunto de treinamento quadrático aleatório utilizando um kernel polinomial de 2º grau. Existe pouca regularização na plotagem à esquerda (isto é, um grande valor C) e muito mais regularização na plotagem à direita (isto é, um pequeno valor C). Grau Grau Figura 5-11. Regressão SVM utilizando um kernel polinomial de 2º grau CG_MIOLO_Hands_On_Machine_Learning. indb 159 07/05/2019 17:08:42

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

160 | Capítulo 5: Máquinas de Vetores de Suporte O código a seguir produz o modelo representado à esquerda da Figura 5-11 usando a classe SVR do Scikit-Learn (que suporta o truque do kernel). A classe SVR é o equivalente de regressão da classe SVC, e a classe Linear SVR é o equivalente de regressão da classe Linear SVC. A classe Linear SVR escalona linearmente com o tamanho do conjunto de treinamento (assim como a classe Linear SVC ), enquanto a classe SVR fica muito mais lenta à medida que o conjunto de treinamento cresce (assim como a classe SVC). from sklearn. svm import SVR svm_poly_reg = SVR(kernel="poly", degree=2, C=100, epsilon=0. 1) svm_poly_reg. fit(X, y) As SVM também podem ser utilizadas para a detecção de outliers; veja a documentação do Scikit-Learn para mais detalhes. Nos Bastidores Esta seção explica como as SVM fazem previsões e como funcionam seus algoritmos de treinamento, começando com classificadores SVM lineares. Você pode ignorá-la e seguir direto para os exercícios no final deste capítulo se estiver apenas começando com o Aprendizado de Máquina, e voltar mais tarde quando quiser obter uma compreensão mais profunda das SVM. Primeiro, uma palavra sobre notações: no Capítulo 4 utilizamos a convenção de colocar todos os parâmetros dos modelos em um vetor θ, incluindo o termo de polarização θ 0 e o peso da característica de entrada de θ1 a θn, e adicionamos uma entrada de polarização x0 = 1 para todas instâncias. Neste capítulo, utilizaremos uma convenção diferente, que é mais conveniente (e mais comum) ao lidarmos com as SVM: o termo de polarização será chamado b e o vetor do peso das características será chamado w. Nenhuma característica de polarização será adicionada aos vetores das características de entrada. Função de Decisão e Previsões O modelo de classificador SVM linear prevê a classe de uma nova instância x calculando a função de decisão w T · x + b = w1 x1 + ⋯ + wn xn + b: se o resultado for positivo, a classe prevista ŷ será a classe positiva (1), ou então será a classe negativa (0); veja a Equação 5-2. CG_MIOLO_Hands_On_Machine_Learning. indb 160 07/05/2019 17:08:42

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

Nos Bastidores | 161Equação 5-2. Previsão do classificador SVM linear y=0sew T·x+b<0, 1sew T·x+b≥0 A Figura 5-12 mostra a função de decisão que corresponde ao modelo à direita da Figura 5-4: é um plano bidimensional, uma vez que este conjunto de dados tem duas caracte-rísticas (largura e comprimento da pétala). O limite de decisão é o conjunto de pontos no qual a função de decisão é igual a 0: é a interseção de dois planos, que é uma linha reta (representada pela linha sólida espessa). 3 Função de decisão h Comprimento da pétala Largura da pétala Figura 5-12. Função de decisão para o conjunto de dados da íris As linhas tracejadas representam os pontos nos quais a função de decisão é igual a 1 ou a-1: são paralelas e na mesma distância da fronteira de decisão, formando uma margem ao seu redor. Treinar um classificador SVM linear significa encontrar os valores de w e b que tornam esta margem o mais ampla possível ao mesmo tempo em que evitam violações de margem ( margem rígida ) ou as limitam ( margem suave ). Objetivo do Treinamento Considere a inclinação da função de decisão: ela é igual à norma do vetor de peso, ∥ w ∥. Se dividirmos esta inclinação por 2, os pontos em que a função de decisão é igual a ± 1 estarão duas vezes mais distantes da fronteira de decisão. Em outras palavras, dividir a 3 De uma forma mais geral, quando houver n ca racterísticas, a função de decisão será um hiperplano n-dimen-sional, e o limite de decisão será um hiperplano ( n-1) dimensional. CG_MIOLO_Hands_On_Machine_Learning. indb 161 07/05/2019 17:08:42

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

162 | Capítulo 5: Máquinas de Vetores de Suporteinclinação por 2 multiplicará a margem por 2. Talvez seja mais fácil visualizar em 2D na Figura 5-13. Quanto menor o vetor de peso w, maior a margem. Figura 5-13. Um vetor de peso menor resulta em uma margem maior Então, queremos minimizar ∥ w ∥ para obter uma margem maior. Entretanto, se tam-bém quisermos evitar qualquer violação da margem ( margem rígida ), precisamos que a função de decisão seja maior que 1 para todas as instâncias positivas de treinamento e menor que-1 para as instâncias negativas. Se definirmos t(i) =-1 para instâncias nega-tivas (se y(i) = 0) e t(i) = 1 para instâncias positivas (se y(i) = 1), então poderemos expressar esta restrição como t(i)(w T · x(i) + b) ≥ 1 para todas as instâncias. Podemos, portanto, expressar o objetivo do classificador SVM linear com margem rígida como o problema de otimização restrita na Equação 5-3. Equação 5-3. Objetivo do classificador SVM linear com margem rígida minimizar w,b1 2w T·w sujeito a tiw T·xi+b≥1 para i=1,2,,m Estamos minimizando , que é igual a , em vez de minimizar ∥ w ∥. Isto se dá porque obteremos o mesmo resultado (uma vez que os valores de w e b que minimizam um valor também minimizam metade do seu quadrado), mas tem uma de-rivada simples (apenas w) enquanto ∥ w ∥ não é diferenciável em w = 0. Algoritmos de otimização funcionam bem melhor em funções diferenciáveis. CG_MIOLO_Hands_On_Machine_Learning. indb 162 07/05/2019 17:08:43

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

Nos Bastidores | 163Para obtermos o objetivo da margem suave, precisamos introduzir uma variável de folga ζ(i) ≥ 0 para cada instância: 4 ζ(i) mede quanto a i-ésima instância pode violar a margem. Agora, temos dois objetivos conflitantes: tornar as variáveis de folga o menor possível para reduzir as violações da margem, e tornar o menor possível para aumentar a margem. É aqui que o hiperparâmetro C entra em ação: ele nos permite definir a troca entre esses dois objetivos, que nos dá o problema de otimização restrita na Equação 5-4. Equação 5-4. Objetivo do classificador SVM linear de margem suave minimizar w,b,ζ1 2w T·w+C∑ i=1m ζi sujeito atiw T·xi+b≥1-ζieζi≥0 para i=1,2,,m Programação Quadrática Os problemas de margem rígida e margem suave são ambos de otimização quadrática convexa com restrições lineares. Esses problemas são conhecidos como problemas de programação quadrática (QP, em inglês). Muitos solucionadores off-the-shelf que usam técnicas fora do escopo deste livro estão disponíveis para resolver problemas de progra-mação quadrática. 5 A formulação geral do problema é dada pela Equação 5-5. Equação 5-5. Problema da programação quadrática Minimize p1 2p T·H·p +f T·p sujeito a A·p≤b sendo quepéum vetor dimensional ( np= Héuma np×npmatriz féumvetor Aéuma matriz ( nc= béum vetor dimensionalnúmero de parâmetros), número de restrições),,np np nc×np nc---dimensio nal Note que a expressão A · p ≤ b na verdade define nc restrições: p T · a(i) ≤ b(i) para i = 1, 2, ⋯, nc, sendo a(i) o vetor que contém os elementos da i-ésima linha de A e b(i) é o i-ésimo elemento de b. 4 Zeta (ζ) é a sexta letra do alfabeto Grego. 5 Para saber mais sobre a Programação Quadrática, você pode começar lendo Stephen Boyd e Lieven Vandenberghe, Convex Optimization ( http://goo. gl/FGXu Lw ) (Cambridge, Reino Unido: Cambridge University Press, 2004) ou assistindo à série de conferências em vídeo de Richard Brown ( http://goo. gl/r To3Af ). CG_MIOLO_Hands_On_Machine_Learning. indb 163 07/05/2019 17:08:43

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

164 | Capítulo 5: Máquinas de Vetores de Suporte Você pode verificar facilmente que, se você definir os parâmetros QP da maneira a seguir, obterá o objetivo do classificador SVM linear com margem rígida: np = n + 1, sendo que n é o número de características (o +1 é para o termo de polarização); nc = m, sendo que m é o número de instâncias de treinamento; H é a ma triz de identidade n p × np, exceto com um zero na célula acima à esquerda (para ignorar o termo de polarização); f = 0, um ve tor n p-dimensional cheio de 0s; b = 1, um ve tor n c-dimensional cheio de 1s; a(i) =-t(i) x˙ (i) sendo que x˙ (i) é igual a x(i) com uma característica de viés extra x ˙ 0 = 1. Portanto, uma forma de treinar um classificador SVM linear com margem rígida é apenas utilizar um solucionador de QP off-the-shelf passando-lhe os parâmetros anteriores. O vetor resultante p conterá o termo de polarização b = p0 e os pesos das características w i = pi para i = 1, 2, ⋯, m. Você também pode utilizar um solucionador QP para resolver o problema da margem suave (veja os exercícios no final do capítulo). Entretanto, para utilizar o truque do kernel, analisaremos um problema diferente de otimização restrita. O Problema Dual Dado um problema de otimização restrita, conhecido como o problema primal, é possível expressar um problema diferente, porém intimamente relacionado, chamado problema dual. A solução para o problema dual tipicamente fornece um limite menor para a solução do problema primal, mas em algumas condições pode ter as mesmas soluções do problema primal. Felizmente, o problema da SVM atende essas condições,6 então você pode optar por resolver o problema primal ou o problema dual, pois ambos terão a mesma solução. A equação 5-6 mostra a forma dual do objetivo da SVM linear (se você estiver interessado em saber como derivar o problema dual do problema primal, consulte o Apêndice C). Equação 5-6. Forma dual do objetivo SVM linear minimizeα1 2∑ i=1m ∑ j=1m αiαjtitjxi T·xj-∑ i=1m αi sujeito a αi≥0 para i=1,2,,m 6 A função objetiva é convexa, e as restrições de desigualdade são funções continuamente diferenciáveis e convexas. CG_MIOLO_Hands_On_Machine_Learning. indb 164 07/05/2019 17:08:44

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

Nos Bastidores | 165Uma vez encontrado o vetor α que minimiza esta equação (utilizando um solucionador de QP), você pode calcular ŵ e utilizando a Equação 5-7, que minimiza o problema primal. Equação 5-7. Da solução dual à solução primal w=∑ i=1m αitixi b=1 ns∑ i=1 αi>0m ti-w T·xi É mais rápido resolver o problema dual do que o primal quando o número de instâncias de treinamento for menor que o número de características. Mais importante, possibilita o truque do kernel, já o primal, não. Então, o que é esse truque do kernel, afinal? SVM Kernelizado Suponha que você deseja aplicar uma transformação polinomial de 2º grau para um con-junto de treinamento bidimensional (como o conjunto de treinamento em formato de luas) e, em seguida, treinar um classificador SVM linear no conjunto transformado. A Equação 5-8 mostra a função de mapeamento polinomial de 2º grau ϕ que você deseja aplicar. Equação 5-8. Mapeamento polinomial de segundo grau /uni03D5x=/uni03D5x1 x2=x12 2x1x2 x22 Observe que o vetor transformado é tridimensional em vez de bidimensional. Agora, vejamos o que acontece com um par de vetores bidimensionais, a e b, se aplicarmos este mapeamento polinomial de segundo grau e depois calcularmos o produto escalar dos vetores transformados (veja a Equação 5-9). Equação 5-9. Truque do Kernel para um mapeamento polinomial de 2º grau /uni03D5a T·/uni03D5b =a12 2a1a2 a22T ·b12 2b1b2 b22=a12b12+2a1b1a2b2+a22b22 =a1b1+a2b22=a1 a2T ·b1 b22 =a T·b2 CG_MIOLO_Hands_On_Machine_Learning. indb 165 07/05/2019 17:08:44

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

166 | Capítulo 5: Máquinas de Vetores de Suporte Que tal? O produto escalar dos vetores transformados é igual ao quadrado do produto escalar dos vetores originais: ϕ(a)T · ϕ(b) = ( a T · b)2. Esta é a visão chave: se você aplicar a transformação ϕ para todas as instâncias de trei-namento, então o problema dual (veja Equação 5-6) conterá o produto escalar ϕ(x(i))T · ϕ(x(j)). Mas, se ϕ for a transformação polinomial de segundo grau definida na Equação 5-8, então você pode substituir este produto escalar de vetores transformados simples-mente por . Você não precisa realmente transformar as instâncias de treinamento: apenas substitua o produto escalar por seu quadrado na Equação 5-6. O resultado será estritamente o mesmo que seria se você passasse pelo problema de realmente transformar o conjunto de treinamento e então ajustar um algoritmo SVM linear, mas esse truque torna todo o processo muito mais eficiente computacionalmente. Esta é a essência do truque do kernel. A função K(a, b) = ( a T · b)2 é chamada de kernel polinomial de 2º grau. No Aprendizado de Máquina, um kernel é uma função capaz de calcular o produto escalar ϕ(a)T · ϕ(b) com base somente nos vetores originais a e b sem ter que calcular (ou mesmo saber) a transformação ϕ. A equação 5-10 lista alguns dos kernels mais utilizados. Equação 5-10. Kernels comuns Linear: Ka,b=a T·b Polinomial :Ka,b=γa T·b+rd RBF Gaussiano: Ka,b= exp-γa-b2 Sigmóide: Ka,b= tanh γa T·b+r Teorema de Mercer De acordo com o Teorema de Mercer, se uma função K(a, b) respeita algumas condições matemáticas chamadas condições de Mercer (K deve ser contínuo, simétrico em seus argu-mentos, de modo que K(a, b) = K(b, a), etc. ), então existe uma função ϕ que mapeia a e b em outro espaço (possivelmente com dimensões muito maiores) tal que K(a, b) = ϕ(a)T · ϕ(b). Então, você pode utilizar K como um kernel já que você sabe que ϕ existe, mesmo não sabendo o que ϕ é. No caso do kernel RBF Gaussiano, pode-se mostrar que ϕ,na verdade, mapeia cada instância de treinamento para um espaço de dimensões infinitas, por isso é bom que você não precise realmente executar o mapeamento! Observe que alguns kernels utilizados com frequência (como o kernel Sigmóide) não respeitam todas as condições de Mercer, mas geralmente funcionam bem na prática. Ainda há uma extremidade solta que devemos amarrar. A Equação 5-7 mostra como passar da solução dual para a solução primal no caso de um classificador SVM linear, mas CG_MIOLO_Hands_On_Machine_Learning. indb 166 07/05/2019 17:08:45

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

Nos Bastidores | 167se você aplicar o truque do kernel ficará com equações que incluem ϕ( x(i)). Na verdade, w deve ter o mesmo número de dimensões que ϕ(x(i)), que pode ser enorme ou mesmo infinito, então você não consegue calculá-lo. Mas como você pode fazer previsões sem conhecer w? Bem, a boa notícia é que você pode inserir a fórmula da Equação 5-7 em w na função de decisão para uma nova instância x(n) e obterá uma equação apenas com pro-dutos escalares entre vetores de entrada, possibilitando a utilização do truque do kernel mais uma vez (Equação 5-11). Equação 5-11. Fazendo previsões com um SVM kernelizado h W,b/uni03D5xn=WT·/uni03D5xn+b=∑ i=1m αiti/uni03D5xi T ·/uni03D5xn+b =∑ i=1m αiti/uni03D5xi T·/uni03D5xn+b =∑ i=1 αi>0m αiti Kxi,xn+b Note que, uma vez que α(i) ≠ 0 apenas para vetores de suporte, fazer previsões envolve o cálculo do produto escalar do novo vetor de entrada x(n) com apenas os vetores de suporte e não todas as instâncias de treinamento. Claro, você também precisa calcular o termo de polarização b utilizando o mesmo truque (Equação 5-12). Equação 5-12. Calculando o termo de polarização por meio do truque do kernel b=1 ns∑ i=1 αi>0m 1-tiw T·/uni03D5xi=1 ns∑ i=1 αi>0m 1-ti∑ j=1m αjtj/uni03D5xj T ·/uni03D5xi =1 ns∑ i=1 αi>0m 1-ti∑ j=1 αj>0m αjtj Kxi,xj Se você já está começando a ter dores de cabeça, saiba que isto é perfeitamente normal: é um efeito colateral infeliz do truque do kernel. SVM Online Antes de concluir este capítulo, daremos uma rápida olhada nos classificadores de SVM online (lembre-se de que o aprendizado online significa aprender de forma incremental, tipicamente quando chegam novas instâncias). CG_MIOLO_Hands_On_Machine_Learning. indb 167 07/05/2019 17:08:45

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

168 | Capítulo 5: Máquinas de Vetores de Suporte Um método para minimizar a função de custo na Equação 5-13, que é derivada do problema primal, é utilizar o Gradiente Descendente (por exemplo, utilizando o SGDClassifier ) para os classificadores SVM lineares. Infelizmente, ele converge muito mais lentamente do que os métodos baseados em QP. Equação 5-13. Função de custo do classificador SVM linear Jw,b=1 2w T·w +C∑ i=1m max 0,1-tiw T·xi+b A primeira soma na função de custo levará o modelo a ter um pequeno vetor de peso w, aumentando a margem. A segunda soma calcula o total de todas as violações da margem. A violação da margem de uma instância é igual a 0 se estiver localizada fora da via e no lado correto, ou então é proporcional à distância ao lado correto da via. Minimizar esse termo garante que o modelo diminua o tamanho e a quantidade de violações da margem o máximo possível. Hinge Loss A função max (0, 1-t) é chamada de função hinge loss [perda de articulação, em tradução livre] (representada abaixo). É igual a 0 quando t ≥ 1. Sua derivada (inclinação) é igual a-1 se t < 1 e 0 se t > 1. Ela não é diferenciável em t = 1, mas, assim como para a Regressão Lasso (veja “Regressão Lasso” no Capítulo 4), utilizando qualquer subderivada em t = 1, você ainda pode utilizar o Gradiente Descendente (ou seja, qualquer valor entre-1 e 0). max (0, 1 — t) Também é possível implementar SVM kernelizadas online, por exemplo, utilizando “Incremental and Decremental SVM Learning” ( http://goo. gl/JEq Vui )7 ou “Fast Kernel Classifiers with Online and Active Learning” ( https://goo. gl/hso UHA ). 8 No entanto, es-tes são implementados em Matlab e C ++. Para problemas não lineares em larga escala, considere o uso de redes neurais (ver Parte II). 7 “Incremental and Decremental Support Vector Machine Learning”, G. Cauwenberghs, T. Poggio (2001). 8 “Fast Kernel Classifiers with Online and Active Learning”, A. Bordes, S. Ertekin, J. Weston, L. Bottou (2005). CG_MIOLO_Hands_On_Machine_Learning. indb 168 07/05/2019 17:08:46

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

Exercícios | 169Exercícios 1. Qual é a ideia fundamental por trás das Máquinas de Vetores de Suporte (SVM)? 2. O que é u m vetor de suporte? 3. Por q ue é importante dimensionar as entradas ao utilizar SVM? 4. Um cl assificador SVM pode produzir uma pontuação de confiança quando classifica uma instância? E quanto a uma probabilidade? 5. Voc ê deve utilizar a forma primal ou dual do problema SVM no treinamento de um modelo em um conjunto de treinamento com milhões de instâncias e cente-nas de características? 6. Dig amos que você treinou um classificador SVM com o kernel RBF. Parece que ele se subajusta ao conjunto de treinamento: você deve aumentar ou diminuir γ (gamma )? E quanto ao C? 7. Com o você deve configurar os parâmetros QP ( H, f, A, e b ) utilizando um solucionador de QP off-the-shelf para resolver o problema do classificador SVM linear de margem suave? 8. Trei ne um Linear SVC em um conjunto de dados linearmente separável. Depois, treine o SVC e um SGDClassifier no mesmo conjunto de dados. Veja se você con-segue fazer com que eles produzam aproximadamente o mesmo modelo. 9. Tre ine um classificador SVM no conjunto de dados MNIST. Uma vez que os classifi-cadores SVM são classificadores binários, você precisará utilizar um contra todos para classificar todos os 10 dígitos. Ajuste os hiperparâmetros utilizando pequenos conjun-tos de validação para acelerar o processo. Qual acurácia você pode alcançar? 10. Tre ine um regressor SVM no conjunto de dados imobiliários da Califórnia. As soluções para estes exercícios estão disponíveis no Apêndice A. CG_MIOLO_Hands_On_Machine_Learning. indb 169 07/05/2019 17:08:46

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

CG_MIOLO_Hands_On_Machine_Learning. indb 170 07/05/2019 17:08:46

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

171Capítulo 6 Árvores de Decisão Como as SVM, as Árvores de Decisão são algoritmos versáteis de Aprendizado de Máquina que podem executar tarefas de classificação, regressão e, até mesmo, tarefas multioutput. São algoritmos muito poderosos capazes de moldar conjuntos complexos de dados. Por exemplo, no Capítulo 2, ajustando-o perfeitamente (na verdade, sobrea-justando), você treinou um modelo Decision Tree Regressor no conjunto de dados imobiliários da Califórnia. As Árvores de Decisão também são os componentes fundamentais das Florestas Aleató-rias (veja o Capítulo 7), que estão entre os algoritmos de Aprendizado de Máquina mais poderosos disponíveis atualmente. Neste capítulo, começaremos discutindo como treinar, visualizar e fazer previsões com as Árvores de Decisão. Então, passaremos pelo algoritmo de treinamento CART utilizado pelo Scikit-Learn e discutiremos como regularizar árvores e utilizá-las para tarefas de regressão. Finalmente, discutiremos algumas das limitações das Árvores de Decisão. Treinando e Visualizando uma Árvore de Decisão Para entender as Árvores de Decisão, vamos construir uma e dar uma olhada em como ela faz previsões. O código a seguir treina um Decision Tree Classifier no conjunto de dados da íris (consulte o Capítulo 4): from sklearn. datasets import load_iris from sklearn. tree import Decision Tree Classifier iris = load_iris() X = iris. data[:, 2:] # comprimento e largura das pétalas y = iris. target tree_clf = Decision Tree Classifier(max_depth=2) tree_clf. fit(X, y) CG_MIOLO_Hands_On_Machine_Learning. indb 171 07/05/2019 17:08:46

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

172 | Capítulo 6: Árvores de Decisão Você pode visualizar a Árvore de Decisão usando o método export_graphviz() para ter como saída um arquivo de definição de grafo chamado iris_tree. dot : from sklearn. tree import export_graphviz export_graphviz( tree_clf, out_file=image_path("iris_tree. dot"), feature_names=iris. feature_names[2:], class_names=iris. target_names, rounded=True, filled=True ) E, então, você pode converter esse arquivo. dot em uma variedade de formatos, como PDF ou PNG, utilizando a ferramenta de linha de comando dot do pacote graphviz. 1 Esta linha de comando converte o arquivo. dot para um arquivo de imagem. png : $ dot-Tpng iris_tree. dot-o iris_tree. png Sua primeira Árvore de Decisão ficará como a da Figura 6-1. pental length (cm) <= 2. 45 gini = 0. 6667 samples = 150 value = [50, 50, 50] class = setosa gini = 0. 0 samples = 50 value = [50, 0, 0] class = setosapental width (cm) <= 1. 75 gini = 0. 5 samples = 100 value = [0, 50, 50] class = versicolor gini = 0. 168 samples = 54 value = [0, 49, 5] class = versicolorgini = 0. 0425 samples = 46 value = [0, 1, 45] class = virginica Falso Verdadeiro Figura 6-1. Árvore de Decisão da íris 1 O Graphviz é um pacote de software de visualização de grafos de código aberto, disponível em http://www. graphviz. org/. CG_MIOLO_Hands_On_Machine_Learning. indb 172 07/05/2019 17:08:47

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

Fazendo Previsões | 17 3Fazendo Previsões Veja como a árvore representada na Figura 6-1 faz previsões. Suponha que você encontre uma flor da íris e deseje classificá-la. Você começa no nó da raiz (profundidade 0, na parte superior): este nó pergunta se o comprimento da pétala da flor é menor do que 2,45cm. Se for, então você se desloca para o nó filho esquerdo da raiz (profundidade 1, esquerda). Neste caso, é um nó da folha (isto é, não tem nenhum nó filho), por isso não faz nenhu-ma pergunta: você pode simplesmente olhar a classe prevista para esse nó e a Árvore de Decisão preverá que sua flor é uma Iris-Setosa ( class=setosa ). Agora, suponha que você encontre outra flor, mas, desta vez, o comprimento da pétala é maior do que 2,45cm. Você deve se mover para baixo, para o nó filho direito da raiz (profundidade 1, direita), que não é um nó da folha, então ele faz outra pergunta: a largura da pétala é menor que 1,75cm? Se for, então sua flor é provavelmente uma Iris-Versico-lor (profundidade 2, esquerda). Caso contrário, é provável que seja uma Iris-Virginica (profundidade 2, direita). É simples assim. Uma das muitas qualidades das Árvores de Decisão é que elas exi-gem pouca preparação de dados. Em particular, elas não exigem o escalonamento ou a centralização das características. O atributo samples de um nó conta a quantidade de instâncias de treinamento a que se aplica. Por exemplo, 100 instâncias de treinamento têm um comprimento de pétala maior que 2,45cm (profundidade 1, direita) dentre as quais 54 têm uma largura de pé-tala menor que 1,75cm (profundidade 2, esquerda). O atributo value de um nó lhe diz a quantas instâncias de treinamento de cada classe este nó se aplica: por exemplo, o nó inferior direito se aplica a 0 Iris-Setosa, 1 Iris-Versicolor e 45 Iris-Virginica. Finalmente, o atributo gini de um nó mede sua impureza : um nó é “puro” ( gini=0 ) se todas as ins-tâncias de treinamento pertencem à mesma classe a qual se aplica. Por exemplo, uma vez que o nó esquerdo de profundidade 1 aplica-se apenas às instâncias de treinamento de Iris-Setosa, ele é puro e sua pontuação gini é 0. A Equação 6-1 mostra como o algoritmo de treinamento calcula a pontuação G i do i-ésimo nó. Por exemplo, o nó esquerdo de profundidade 2 tem uma pontuação gini igual a 1-(0/54)2-(49/54)2-(5/54)2 ≈ 0. 168. Outra medida de impureza será discutida brevemente. Equação 6-1. Coeficiente de Gini Gi=1-∑ k=1n pi,k2 pi,k é a média das instâncias da classe k entre as instâncias de treinamento no nó i. CG_MIOLO_Hands_On_Machine_Learning. indb 173 07/05/2019 17:08:47

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

174 | Capítulo 6: Árvores de Decisão O Scikit-Learn utiliza o algoritmo CART, que produz somente árvores binárias : os nós sem folhas sempre têm dois filhos (ou seja, as perguntas somente terão respostas sim/não). Entretanto, outros algoritmos, como o ID3, podem produzir Árvores de Decisão com nós que têm mais de dois filhos. A Figura 6-2 mostra as fronteiras de decisão da Árvore de Decisão. A linha vertical grossa representa a fronteira de decisão do nó raiz (profundidade 0): comprimento da pétala = 2,45cm. Uma vez que a área esquerda é pura (apenas Iris-Setosa), ela não pode ser dividida ainda mais. No entanto, a área direita é impura, então o nódulo direito de profundidade 1 a divide na largura da pétala = 1,75cm (representada pela linha tracejada). Como o max_depth foi definido como 2, a Árvore de Decisão para ali. No entanto, se você definir max_depth como 3, os dois nós de profundidade 2 adicionarão uma outra fronteira de decisão (representada pelas linhas pontilhadas). (Profundidade = 2)Largura da Pétala Comprimento da P étala Profundidade = 1 Profundidade = 0 Figura 6-2. Fronteiras de decisão da Árvore de Decisão Interpretação do Modelo: Caixa Branca versus Caixa Preta Como você pode ver, as Árvores de Decisão são bastante intuitivas e é fácil interpre-tar suas decisões. Esses modelos são geralmente chamados de modelos de caixa branca. Em contraste, como veremos, as Florestas Aleatórias ou as redes neurais são, geralmente, consideradas modelos de caixa preta. Elas fazem grandes previsões e você pode verificar facilmente os cálculos realizados para a obtenção delas; no entanto, é difícil explicar em termos simples por que essas previsões foram feitas. Por exemplo, se uma rede neural diz que uma pessoa específica aparece em uma imagem, é difícil saber o que realmente contribuiu para essa previsão: o modelo reconheceu os olhos dessa pessoa? Sua boca? Seu nariz? Os sapatos? Ou mesmo o sofá em que ela estava sentada? Por outro lado, as Árvo-res de Decisão fornecem regras simples de classificação que podem ser aplicadas mesmo manualmente se necessário (por exemplo, para a classificação de uma flor). CG_MIOLO_Hands_On_Machine_Learning. indb 174 07/05/2019 17:08:47

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

Estimando as Probabilidades de Classes | 175 Estimando as Probabilidades de Classes Uma Árvore de Decisão também pode estimar a probabilidade de uma instância per-tencer a uma classe específica k : primeiro ela atravessa a árvore para encontrar o nó da folha para esta instância e, em seguida, retorna a taxa das instâncias de treinamento da classe k neste nó. Por exemplo, suponha que ela tenha encontrado uma flor cujas pétalas têm 5cm de comprimento e 1,5cm de largura. O nó da folha correspondente é o nó esquerdo de profundidade 2, portanto a Árvore de Decisão deve exibir as seguintes probabilidades: 0% para Iris-Setosa (0/54), 90,7% para Iris-Versicolor (49/54) e 9,3% para Iris-Virginica (5/54). E, claro, se você pedir que ela preveja a classe, ela deve exibir Iris-Versicolor (classe 1), pois é a que tem a maior probabilidade. Verificaremos isso: >>> tree_clf. predict_proba([[5, 1. 5]]) array([[ 0., 0. 90740741, 0. 09259259]]) >>> tree_clf. predict([[5, 1. 5]]) array([1]) Perfeito! Repare que as probabilidades estimadas seriam idênticas em qualquer outro lugar no retângulo inferior direito da Figura 6-2 — por exemplo, se as pétalas tivessem 6cm de comprimento e 1,5cm de largura (mesmo que pareça óbvio que provavelmente seria uma Iris-Virginica neste caso). O Algoritmo de Treinamento CART O Scikit-Learn utiliza o algoritmo da Árvore de Classificação e Regressão (CART, em inglês) para treinar árvores de decisão (também chamadas de árvores “ em crescimen-to”). A ideia é realmente bastante simples: o algoritmo primeiro divide o conjunto de treinamento em dois subconjuntos utilizando uma única característica k e um limiar t k (por exemplo, “comprimento da pétala ≤ 2,45cm”). Como ele escolhe k e tk? Ele busca pelo par ( k, tk) que produz os subconjuntos mais puros (ponderados pelo tamanho). A função de custo que o algoritmo tenta minimizar é dada pela Equação 6-2. Equação 6-2. Função de custo CART para classificação Jk,tk=mesquerda m Gesquerda+mdireita m Gdireita sendo que Gesquerda/direita mesquerda/direitaé o número de instâncias no subconjunto esquerdo/direito. mede a impureza do subconjunto esquerdo/direito, Depois de dividir com sucesso o conjunto de treinamento em dois, ele divide os sub-conjuntos utilizando a mesma lógica, depois os subsubconjuntos e assim por diante, recursivamente. Ele para de recarregar uma vez que atinge a profundidade máxima CG_MIOLO_Hands_On_Machine_Learning. indb 175 07/05/2019 17:08:48

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

176 | Capítulo 6: Árvores de Decisão(definida pelo hiperparâmetro max_depth ) ou se não consegue encontrar uma divisão que reduza a impureza. Alguns outros hiperparâmetros (que já serão descritos) con-trolam as condições adicionais de parada ( min_samples_split, min_samples_leaf, min_weight_fraction_leaf e max_leaf_nodes ). Como você pode ver, o algoritmo CART é um algoritmo ganancioso: ele busca gananciosamente uma divisão otimizada no nível superior e, em seguida, repete o processo em cada nível. Ele não verifica se a divisão irá ou não resultar na menor impureza possível nos vários níveis abaixo. Um algoritmo ganancioso geralmente produz uma solução razoavelmente boa, mas não é garantia de uma solução ideal. Infelizmente, encontrar a árvore ideal é conhecido por ser um problema NP-Completo :2 ele requer tempo O (exp( m)), tornando o problema intratável mesmo para conjuntos de treinamento muito pequenos. É por isso que devemos nos contentar com uma solução “razoavelmente boa”. Complexidade Computacional Fazer previsões requer percorrer a Árvore de Decisão da raiz até uma folha. Em geral, as árvores de decisão são equilibradas, de modo que percorrê-la requer passar por aproximadamente O(log 2(m)) nós. 3 Uma vez que cada nó exige apenas a verificação do valor de uma característica, a complexidade geral da previsão será apenas O (log 2(m)), independentemente do número de características. Então, as previsões são muito rápidas mesmo se tratando de grandes conjuntos de treinamento. No entanto, o algoritmo de treinamento compara todas as características (ou menos, se max_features estiver definido) em todas as amostras a cada nó. Isto resulta em uma complexidade de treinamento O (n × m log (m)). Ao pré-selecionar os dados para pequenos conjuntos (menos de algumas milhares de instâncias), o Scikit-Learn pode acelerar o treinamento (defina presort = True ), mas isso diminui significativamente o treinamento para conjuntos maiores. 2 P é o conjunto dos problemas que pode ser resolvido em tempo polinomial. NP é o conjunto de problemas cujas soluções podem ser verificadas em tempo polinomial. Um problema NP-Hard é um problema para o qual qualquer problema NP pode ser reduzido em tempo polinomial. Um problema NP-Completo é tanto o NP quanto o NP-Hard. Uma grande questão matemática aberta é se P = NP, ou não. Se P ≠ NP (o que parece provável), nenhum algoritmo polinomial será encontrado para qualquer problema NP-Completo (exceto, talvez, em um computador quântico). 3 log2 é o logaritmo binário. É igual a log2(m) = log(m) / log (2). CG_MIOLO_Hands_On_Machine_Learning. indb 176 07/05/2019 17:08:48

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

Coeficiente de Gini ou Entropia? | 177Coeficiente de Gini ou Entropia? A medida do coeficiente de Gini é aplicada por padrão, mas você pode selecionar a medida de impureza da entropia ao configurar o hiperparâmetro criterion para “entropy ”. O conceito de entropia originou-se na termodinâmica como uma medida da desordem molecular: a entropia aproxima-se de zero quando as moléculas ainda estão paradas e bem ordenadas. Mais tarde, se espalhou em uma ampla variedade de campos do co-nhecimento, incluindo a Teoria da Informação de Shannon, na qual mede o conteúdo médio de informação de uma mensagem:4 a entropia é zero quando todas as mensagens são idênticas. No Aprendizado de Máquina, ela é frequentemente utilizada como uma medida do coeficiente: a entropia de um conjunto é zero quando contém instâncias de apenas uma classe. A Equação 6-3 mostra a definição da entropia do i-ésimo nó. Por exemplo, o nó esquerdo de profundidade 2 na Figura 6-1 possui uma entropia igual a Equação 6-3. Entropia Hi=-∑ k=1 pi,k≠0n pi,klog pi,k Então, nesse caso, você deve utilizar o coeficiente de Gini ou a entropia? A verdade é que, na maioria das vezes, não faz muita diferença: elas levam a árvores semelhantes. O coeficiente de Gini é um pouco mais rápido para calcular, então é um bom padrão. No entanto, quando elas diferem, o coeficiente de Gini tende a isolar a classe mais fre-quente em seu próprio ramo da árvore, enquanto a entropia tende a produzir árvores ligeiramente mais equilibradas. 5 Hiperparâmetros de Regularização As Árvores de Decisão fazem poucos pressupostos sobre os dados de treinamento (ao contrário dos modelos lineares, que obviamente assumem que os dados são lineares, por exemplo). Se for deixada sem restrições, a estrutura da árvore se adaptará aos dados de treinamento muito de perto, provavelmente se sobreajustando. Tal modelo geralmente é chamado de modelo não paramétrico, não porque ele não tenha quaisquer parâmetros (geralmente ele têm bastante), mas porque o número de parâmetros não é determinado antes do treinamento, então a estrutura do modelo é livre para ficar próxima aos dados. 4 Uma redução da entropia geralmente é chamada de ganho de informação. 5 Veja a análise interessante de Sebastian Raschka para obter mais detalhes ( http://goo. gl/Und Tr O ). CG_MIOLO_Hands_On_Machine_Learning. indb 177 07/05/2019 17:08:48

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

178 | Capítulo 6: Árvores de Decisão Em contraste, um modelo paramétrico, como um modelo linear, tem um número pre-determinado de parâmetros, então seu grau de liberdade é limitado, reduzindo o risco de sobreajuste (mas aumentando o risco de subajuste). Para evitar o sobreajuste nos dados de treinamento, você precisa restringir a liberdade da Árvore de Decisão durante este treinamento. Como você sabe, isso é chamado de re-gularização. Os hiperparâmetros de regularização dependem do algoritmo utilizado, mas geralmente você pode, pelo menos, restringir a profundidade máxima da Árvore de Decisão. No Scikit-Learn, isto é controlado pelo hiperparâmetro max_depth (o valor padrão é None, que significa ilimitado). Reduzir max_depth regularizará o modelo e reduzirá, assim, o risco de sobreajuste. A classe Decision Tree Classifier tem alguns outros parâmetros que restringem de forma semelhante a forma da Árvore de Decisão: min_samples_split (o número mínimo de amostras que um nó deve ter antes que possa ser dividido), min_samples_leaf (o número mínimo de amostras que um nó da folha deve ter), min_weight_fraction_leaf (o mesmo de min_samples_leaf, mas expressa como uma fração do número total de instâncias ponderadas), max_leaf_nodes (número máximo de nós da folha) e max_features (nú-mero máximo de características que são avaliadas para divisão em cada nó). Aumentar os hiperparâmetros min_* ou reduzir os hiperparâmetros max_* regularizará o modelo. Outros algoritmos funcionam primeiro treinando a Árvore de De-cisão sem restrições, depois podando (eliminando) nós desneces-sários. Um nó cujos filhos são todos nós da folha é considerado desnecessário caso a melhoria da pureza que ele fornece não seja es-tatisticamente significante. Os testes estatísticos padrão, como o teste χ 2, são utilizados para estimar a probabilidade de que a melhora seja puramente o resultado do acaso (que é chamada de hipótese nula ). Se essa probabilidade, denominada p-value, for superior a um deter-minado limiar (geralmente 5%, controlado por um hiperparâmetro), então o nó é considerado desnecessário e seus filhos são excluídos. A poda continua até que todos os nós desnecessários tenham sido eliminados. A Figura 6-3 mostra duas Árvores de Decisão treinadas no conjunto de dados de luas (introduzido no Capítulo 5). À esquerda, a Árvore de Decisão é treinada com os hiper-parâmetros padrão (ou seja, sem restrições) e, à direita, a Árvore de Decisão é treinada com min_samples_leaf = 4. É bastante óbvio que o modelo à esquerda está sobreajustado e o modelo à direita provavelmente generalizará melhor. CG_MIOLO_Hands_On_Machine_Learning. indb 178 07/05/2019 17:08:48

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

Regressão | 179 min_sampes_leaf = 4 Sem restrições Figura 6-3. Regularização utilizando min_samples_leaf Regressão As Árvores de Decisão também desempenham tarefas de regressão. Construiremos uma árvore de regressão utilizando a classe Decision Tree Regressor do Scikit-Learn e treiná-la em um conjunto de dados quadrático confuso com max_depth=2 : from sklearn. tree import Decision Tree Regressor tree_reg = Decision Tree Regressor(max_depth=2) tree_reg. fit(X, y) A árvore resultante está representada na Figura 6-4. x1 mse samples value x1 mse samples valuex1 mse samples value mse samples valuemse samples valuemse samples valuemse samples value Falso Verdadeiro Figura 6-4. Uma Árvore de Decisão para regressão Esta árvore se parece muito com a árvore de classificação que você criou anteriormente. A principal diferença é que, em vez de prever uma classe em cada nó, ela prevê um valor. Por exemplo, suponha que você queira fazer uma previsão para uma nova instância com CG_MIOLO_Hands_On_Machine_Learning. indb 179 07/05/2019 17:08:49

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