text
stringlengths 0
3.9k
| source
stringclasses 1
value |
|---|---|
Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
|
Mãos à Obra: Aprendizado de Máquina com Scikit-Learn & Tensor Flow Conceitos, Ferramentas e Técnicas para a Construção de Sistemas Inteligentes Aurélien Géron Rio de Janeiro, 2019 CG_MIOLO_Hands_On_Machine_Learning. indb 1 07/05/2019 17:07:49 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
Mãos à Obra Aprendizado Máquina com Scikit-Learn e Tensor Flow Copyright © 2019 da Starlin Alta Editora e Consultoria Eireli. ISBN: 978-85-508-0902-1 (PDF) Translated from original Hands-On Machine Learning With Scikit-Learn and Tensor Flow © 2017 by Aurélien Géron. All rights re-served. ISBN 978-1-491-96229-9. This translation is published and sold by permission of O'Reilly Media, Inc the owner of all rights to pu blish and sell the same. PORTUGUESE language edition published by Starlin Alta Editora e Consultoria Eireli, Copyright © 2019 by Starlin Alta Editora e Consultoria E ireli. Todos os direitos estão reservados e protegidos por Lei. Nenhuma parte deste livro, sem autorização prévia por escrito da editora, poderá ser reproduzida ou transmitida. A violação dos Direitos Autorais é crime estabelecido na Lei nº 9. 610/98 e com punição de acordo com o artigo 184 do Código Penal. A editora não se responsabiliza pelo conteúdo da obra, formulada exclusivamente pelo(s) autor(es). Marcas Registradas : Todos os termos mencionados e reconhecidos como Marca Registrada e/ou Comercial são de responsa-bilidade de seus proprietários. A editora informa não estar associada a nenhum produto e/ou fornecedor apresentado no livro. Edição revisada conforme o Acordo Ortográfico da Língua Portuguesa de 2009. Publ ique seu livro com a Alta Books. Para mais informações envie um e-mail para autoria@altabooks. com. br Obra disponível para venda corporativa e/ou personalizada. Para mais informações, fale com projetos@altabooks. com. br Produção Editorial Editora Alta Books Gerência Editorial Anderson Vieira Produtor Editorial Juliana de Oliveira Thiê Alv es Assistente Editorial Adriano Barros Marketing Editorial marketing@altabooks. com. br Editor de Aquisição José Rugeri j. rugeri@altabooks. com. br Vendas Atacado e Varejo Daniele Fonseca Viviane Paiva comercial@altabooks. com. br Ouvidoria ouvidoria@altabooks. com. br Equipe Editorial Bianca Teodoro Ian Verçosa Illysabelle T rajano Kelry Oliveira Keyciane Botelho Maria de Lourdes Borges Paulo Gomes Thales Silva Thauan Gomes Tradução Rafael Contatori Copidesque Amanda Meirinho Revisão Gramatical Vivian Sbravatti Fernanda L utfi Revisão T écnica Gabriel Campos Engenheiro Eletrônico formado pelo Instituto Militar de Engenharia (IME)Diagramação Daniel Vargas Erratas e arquivos de apoio: No site da editora relatamos, com a devida correção, qualquer erro encontrado em nossos livros, bem como disponibilizamos arquivos de apoio se aplicáveis à obra em questão. Acesse o site www. altabooks. com. br e procure pelo título do livro desejado para ter acesso às erratas, aos arquivos de apoio e/ou a outros conteúdos aplicáveis à obra. Suporte Técnico: A obra é comercializada na forma em que está, sem direito a suporte técnico ou orientação pessoal/exclusiva ao leitor. A editora não se responsabiliza pela manutenção, atualização e idioma dos sites referidos pelos autores nesta obra. Rua Viúva Cláudio, 291 — Bairro Industrial do Jacaré CEP: 20. 970-031 — Rio de Janeiro (RJ)Tels. : (21) 3278-8069 / 3278-8419www. altabooks. com. br — altabooks@altabooks. com. br www. facebook. com/altabooks — www. instagram. com/altabooks Dados Internacionais de Catalo gação na Publicação (CIP) de acordo com ISBD G377m Géron, Aurélien Mãos à Obra Aprendizado de Máquina com Scikit-Learn & Tensor Flow : Conceitos, Ferramentas e Técnicas Para a Construção de Sistemas Inteligentes / Aurélien Gér on ; traduzido por Rafael Contatori.- Rio de Janeiro : Alta Books, 20 19. 576 p. : il. ; 42. 917 Kb. Tradução d e: Hands-On Machine Learning with Scikit-Learn &Tensor Flow Inclui índice e anexo. ISBN: 978-85-5 08-0902-1 (PDF) 1. Ciência da computação. 2. Aprendizado de Máquina. I. Contatori, Rafael. II. Título. 2019-594 CDD 004 CDU 004 Elaborado por Vagner Rodolfo da Sil va-CRB-8/9410 CG_MIOLO_Hands_On_Machine_Learning. indb 2 07/05/2019 17:07:50 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
iii Sumário Parte I. Os Fundamentos do Aprendizado de Máquina 1 1. O Cenário do Aprendizado de Máquinas ...................................................... 3 O que é o Aprendizado de Máquina? 4 Por q ue Utilizar o Aprendizado de Máquina? 5 Tip os de Sistemas do Aprendizado de Máquina 8 Apre ndizado Supervisionado/Não Supervisionado 8 Apre ndizado Supervisionado 8 Apr endizado Não Supervisionado 10 Ap rendizado Semi-supervisionado 13 Ap rendizado por Reforço 14 Ap rendizado Online e Em Lote 15 Ap rendizado baseado em Instância Versus Aprendizado baseado no Modelo 18 Pr incipais Desafios do Aprendizado de Máquina 23 Qu antidade Insuficiente de Dados de Treinamento 23 Dad os de Treinamento Não Representativos 25 Dad os de Baixa Qualidade 26 Ca racterísticas Irrelevantes 27 So breajustando os Dados de Treinamento 27 Suba justando os Dados de Treinamento 29 Vo ltando Atrás 30 Te stando e Validando 30 Ex ercícios 32 CG_MIOLO_Hands_On_Machine_Learning. indb 3 07/05/2019 17:07:50 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
iv | Sumário2. Projeto de Aprendizado de Máquina de Ponta a Ponta ............................... 35 Trabalhando com Dados Reais 35 Um O lhar no Quadro Geral 37 En quadre o Problema 37 Sel ecione uma Medida de Desempenho 39 Ve rifique as Hipóteses 42 Obte nha os Dados 42 Cr ie o Espaço de Trabalho 42 Ba ixe os Dados 45 Um a Rápida Olhada na Estrutura dos Dados 47 Cr ie um Conjunto de Testes 51 De scubra e Visualize os Dados para Obter Informações 55 Vi sualizando Dados Geográficos 55 Bu scando Correlações 58 Ex perimentando com Combinações de Atributo 60 Pr epare os Dados para Algoritmos do Aprendizado de Máquina 62 Li mpeza dos Dados 62 Ma nipulando Texto e Atributos Categóricos 65 Cu stomize Transformadores 67 Esca lonamento das Características 68 Pi pelines de Transformação 69 Sel ecione e Treine um Modelo 71 Tr einando e Avaliando no Conjunto de Treinamento 72 Av aliando Melhor com a Utilização da Validação Cruzada 73 Aj uste Seu Modelo 76 Gr id Search 76 Ra ndomized Search 78 Mé todos de Ensemble 78 An alise os Melhores Modelos e Seus Erros 79 Av alie Seu Sistema no Conjunto de Testes 80 La nce, Monitore e Mantenha seu Sistema 80 Ex perimente! 81 E xercícios 82 3. Classificação ............................................................................................ 83 MNIST 83 Tr einando um Classificador Binário 86 CG_MIOLO_Hands_On_Machine_Learning. indb 4 07/05/2019 17:07:50 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
Sumário | v Medições de Desempenho 86 Me dição da Acurácia com a Utilização da Validação Cruzada 87 Ma triz de Confusão 88 Pr ecisão e Revocação 90 Co mpensação da Precisão/Revocação 91 A Cu rva ROC 95 Cl assificação Multiclasse 97 An álise de Erro 100 C lassificação Multilabel 104 C lassificação Multioutput 105 E xercícios 10 7 4. Treinando Modelos ................................................................................ 109 Regressão Linear 110 M étodo dos Mínimos Quadrados 112 C omplexidade Computacional 114 G radiente Descendente 115 G radiente Descendente em Lote 118 G radiente Descendente Estocástico 121 G radiente Descendente em Minilotes 124 R egressão Polinomial 125 C urvas de Aprendizado 127 M odelos Lineares Regularizados 132 R egressão de Ridge 132 R egressão Lasso 135 E lastic Net 137 Par ada Antecipada 138 R egressão Logística 139 E stimando Probabilidades 140 T reinamento e Função de Custo 141 L imites de Decisão 142 R egressão Softmax 144 E xercícios 147 5. Máquinas de Vetores de Suporte (SVM) ................................................... 14 9 Classificação Linear dos SVM 149 C lassificação de Margem Suave 150 CG_MIOLO_Hands_On_Machine_Learning. indb 5 07/05/2019 17:07:50 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
vi | Sumário Classificação SVM Não Linear 153 K ernel Polinomial 154 A dicionando Características de Similaridade 155 K ernel RBF Gaussiano 156 C omplexidade Computacional 158 R egressão SVM 158 N os Bastidores 160 F unção de Decisão e Previsões 161 Ob jetivo do Treinamento 162 P rogramação Quadrática 163 O Pr oblema Dual 164 S VM Kernelizado 165 S VM Online 167 E xercícios 16 9 6. Árvores de Decisão ................................................................................. 17 1 Treinando e Visualizando uma Árvore de Decisão 171 F azendo Previsões 173 Est imando as Probabilidades de Classes 175 O A lgoritmo de Treinamento CART 175 C omplexidade Computacional 176 C oeficiente de Gini ou Entropia? 177 H iperparâmetros de Regularização 177 R egressão 17 9 Instabilidade 18 1 Exercícios 18 2 7. Ensemble Learning e Florestas Aleatórias ............................................... 185 Classificadores de Votação 186 B agging e Pasting 189 B agging e Pasting no Scikit-Learn 190 A valiação Out-of-Bag 191 P atches e Subespaços Aleatórios 192 F lorestas Aleatórias 193 Á rvores-Extras 19 4 Importância da Característica 194 CG_MIOLO_Hands_On_Machine_Learning. indb 6 07/05/2019 17:07:50 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
Sumário | vii Boosting 19 6 Ada Boost 19 6 Gradient Boosting 199 St acking 20 4 Exercícios 20 7 8. Redução da Dimensionalidade................................................................ 20 9 A Maldição da Dimensionalidade 210 P rincipais Abordagens para a Redução da Dimensionalidade 211 Pr ojeção 21 1 Manifold Learning 213 P CA 215 P reservando a Variância 215 C omponentes Principais 216 P rojetando para d Dimensões 217 U tilizando o Scikit-Learn 218 T axa de Variância Explicada 218 E scolhendo o Número Certo de Dimensões 219 P CA para a Compressão 220 P CA Incremental 221 P CA Randomizado 222 K ernel PCA 222 S elecionando um Kernel e Ajustando Hiperparâmetros 223 L LE 225 O utras Técnicas de Redução da Dimensionalidade 227 E xercícios 22 8 Parte II. Redes Neurais e Aprendizado Profundo 231 9. Em Pleno Funcionamento com o Tensor Flow ........................................... 23 3 Instalação 23 6 Criando Seu Primeiro Grafo e o Executando em uma Sessão 237 G erenciando Grafos 238 C iclo de Vida de um Valor do Nó 239 R egressão Linear com o Tensor Flow 240 CG_MIOLO_Hands_On_Machine_Learning. indb 7 07/05/2019 17:07:50 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
viii | Sumário Implementando o Gradiente Descendente 241 C alculando Manualmente os Gradientes 241 U tilizando o autodiff 242 U tilizando um Otimizador 244 F ornecendo Dados ao Algoritmo de Treinamento 244 S alvando e Restaurando Modelos 245 V isualização do Grafo e Curvas de Treinamento com o Tensor Board 247 E scopos do Nome 250 M odularidade 25 1 Compartilhando Variáveis 253 E xercícios 25 6 10. Introdução às Redes Neurais Artificiais ................................................... 259 De Neurônios Biológicos a Neurônios Artificiais 260 N eurônios Biológicos 261 C álculos Lógicos com Neurônios 262 O P erceptron 263 P erceptron Multicamada e Retropropagação 267 T reinando um MLP com a API de Alto Nível do Tensor Flow 270 T reinando um DNN Utilizando um Tensor Flow Regular 271 F ase de Construção 271 F ase de Execução 275 U tilizando a Rede Neural 276 A justando os Hiperparâmetros da Rede Neural 277 N úmero de Camadas Ocultas 277 N úmero de Neurônios por Camada Oculta 278 F unções de Ativação 279 E xercícios 28 0 11. Treinando Redes Neurais Profundas ........................................................ 283 Problemas dos Gradientes: Vanishing/Exploding 283 I nicialização Xavier e Inicialização He 285 F unções de Ativação Não Saturadas 287 N ormalização em Lote 290 I mplementando a Normalização em Lote com o Tensor Flow 292 Gr adient Clipping 294 CG_MIOLO_Hands_On_Machine_Learning. indb 8 07/05/2019 17:07:50 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
Sumário | ix Reutilizando Camadas Pré-Treinadas 295 R eutilizando um Modelo do Tensor Flow 296 R eutilizando Modelos de Outras Estruturas 298 C ongelando as Camadas Inferiores 298 A rmazenamento em Cache das Camadas Congeladas 299 A justando, Descartando ou Substituindo as Camadas Superiores 300 Z oológicos de Modelos 301 P ré-treinamento Não Supervisionado 301 P ré-treinamento em uma Tarefa Auxiliar 302 O timizadores Velozes 303 O timização Momentum 303 G radiente Acelerado de Nesterov 305 A da Grad 30 6 RMSProp 30 7 Otimização Adam 308 E vitando o Sobreajuste Por Meio da Regularização 312 P arada Antecipada 313 R egularização ℓ1 e ℓ2 313 Dr opout 314 Re gularização Max-Norm 317 Dat a Augmentation 319 D iretrizes Práticas 320 E xercícios 32 1 12. Distribuindo o Tensor Flow Por Dispositivos e Servidores .......................... 325 Múltiplos Dispositivos em uma Única Máquina 326 I nstalação 326 G erenciando a RAM do GPU 329 C olocando Operações em Dispositivos 331 P osicionamento Simples 331 R egistro dos Posicionamentos 332 F unção de Posicionamento Dinâmico 333 O perações e Kernels 333 P osicionamento Suave 334 E xecução em Paralelo 334 D ependências de Controle 335 V ários Dispositivos em Vários Servidores 336 A brindo uma Sessão 338 O s Serviços Master e Worker 338 CG_MIOLO_Hands_On_Machine_Learning. indb 9 07/05/2019 17:07:50 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
x | Sumário Fixando Operações em Tarefas 339 P articionando Variáveis em Múltiplos Servidores de Parâmetros 340 C ompartilhando Estado entre Sessões com a Utilização de Contêiner de Recursos 341 C omunicação Assíncrona com a Utilização de Filas do Tensor Flow 343 E nfileirando Dados 344 D esenfileirando os Dados 344 F ilas de Tuplas 345 F echando uma Fila 346 R andom Shuffle Queue 34 6 Padding Fifo Queue 34 7 Carregando Dados Diretamente do Grafo 348 P ré-carregue os Dados em uma Variável 348 L endo os Dados de Treinamento Diretamente do Grafo 349 L eitores Multithreaded Utilizando as Classes Coordinator e Queue Runner 352 O utras Funções de Conveniências 354 P aralelizando Redes Neurais em um Cluster do Tensor Flow 356 U ma Rede Neural por Dispositivo 356 R eplicação em Grafo Versus Replicação Entre Grafos 357 P aralelismo do Modelo 359 P aralelismo de Dados 361 E xercícios 36 6 13. Redes Neurais Convolucionais (CNN) ....................................................... 369 A Arquitetura do Córtex Visual 370 C amada Convolucional 371 F iltros 373 E mpilhando Múltiplos Mapas de Características 374 I mplementação do Tensor Flow 376 R equisitos de Memória 379 C amada Pooling 380 A rquiteturas CNN 381 L e Net-5 382 A lex Net 38 4 Goog Le Net 385 R es Net 38 9 Exercícios 39 3 CG_MIOLO_Hands_On_Machine_Learning. indb 10 07/05/2019 17:07:50 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
Sumário | xi14. Redes Neurais Recorrentes (RNN) ............................................................ 397 Neurônios Recorrentes 398 C élulas de Memória 400 S equências de Entrada e Saída 401 R NNs Básicas no Tensor Flow 402 D esenrolamento Estático Através do Tempo 403 D esenrolamento Dinâmico Através do Tempo 405 M anipulando Sequências de Entrada de Comprimento Variável 406 M anipulando Sequências de Saída de Comprimento Variável 407 T reinando RNNs 407 T reinando um Classificador de Sequência 408 T reinando para Prever Séries Temporais 410 R NN Criativa 415 R NNs Profundas 415 D istribuindo uma RNN Profunda Através de Múltiplas GPUs 416 A plicando o Dropout 418 A D ificuldade de Treinar sobre Muitos Intervalos de Tempo 419 C élula LSTM 420 C onexões Peephole 422 C élula GRU 423 P rocessamento de Linguagem Natural 424 W ord Embeddings 424 Um a Rede Codificador-Decodificador para Tradução de Máquina 426 E xercícios 42 9 15. Autoencoders ........................................................................................ 43 1 Representações Eficientes de Dados 432 E xecutando o PCA com um Autoencoder Linear Incompleto 433 A utoencoders Empilhados 435 I mplementação do Tensor Flow 436 A marrando Pesos 437 T reinando um Autoencoder Por Vez 438 V isualizando as Reconstruções 441 V isualizando as Características 441 P ré-treinamento Não Supervisionado Utilizando Autoencoders Empilhados 443 CG_MIOLO_Hands_On_Machine_Learning. indb 11 07/05/2019 17:07:50 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
Autoencoders de Remoção de Ruídos 444 I mplementando o Tensor Flow 445 A utoencoders Esparsos 446 I mplementando o Tensor Flow 448 A utoencoders Variacionais 449 G erando Dígitos 452 O utros Autoencoders 453 E xercícios 45 4 16. Aprendizado por Reforço ........................................................................ 457 Aprendendo a Otimizar Recompensas 458 P esquisa de Políticas 459 I ntrodução ao Open AI Gym 461 P olíticas de Rede Neural 464 A valiação das Ações: O Problema de Atribuição de Crédito 467 G radientes de Política 468 P rocessos de Decisão de Markov 473 A prendizado de Diferenças Temporais e Q-Learning 477 P olíticas de Exploração 479 Q-Learning Aproximado e Deep Q-Learning 480 A prendendo a Jogar Ms. Pac-Man com a Utilização do Algoritmo DQN 482 E xercícios 48 9 Obrigado! 491 A. Soluções dos Exercícios........................................................................... 49 3 B. Lis ta de Verificação do Projeto de Aprendizado de Máquina ..................... 521 C. Pro blema SVM Dual ............................................................................... 527 D. Aut odiff ................................................................................................ 53 1 E. Outr as Arquiteturas Populares RNA ......................................................... 539 Índ ice......................................................................................................... 549 CG_MIOLO_Hands_On_Machine_Learning. indb 12 07/05/2019 17:07:50 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
xiii Prefácio O Tsunami do Aprendizado de Máquina Em 2006, Geoffrey Hinton et al. publicou um artigo1 mostrando como treinar uma rede neural profunda capaz de reconhecer dígitos manuscritos com uma precisão de última geração (> 98%). A técnica foi rotulada como “Aprendizado Profundo” [ Deep Learning ]. Treinar uma rede neural profunda era considera-do uma tarefa impossível na época2 e, desde os anos 1990, que a maioria dos pesquisadores havia abandonado essa ideia. Este artigo reavivou o interesse da comunidade científica e, em pouco tempo, muitos novos trabalhos demonstraram que o Aprendizado Profundo não só era possível, mas capaz de feitos alucinantes que nenhuma outra técnica do Aprendizado de Máquina (AM) poderia esperar alcançar (com a ajuda do tremendo poder de computação e grandes quanti-dades de dados). Esse entusiasmo logo se estendeu a muitas outras áreas do Aprendizado de Máquina. Avançaremos dez anos para ver que o Aprendizado de Máquina conquistou a indús-tria e, atualmente, está nos holofotes dos produtos de alta tecnologia, classificando os resultados de pesquisas na web, potencializando o reconhecimento de voz do smartphone, recomendando vídeos e superando o campeão mundial no jogo Go. Antes que você perceba, estará dirigindo seu carro. O Aprendizado de Máquina em Seus Projetos Naturalmente você está eufórico com o Aprendizado de Máquina e adoraria participar da festa! 1 Disponível em http://www. cs. toronto. edu/~hinton/ (c onteúdo em inglês). 2 As re des neurais convolucionais de aprendizado profundo de Yann Lecun funcionavam bem para o reconhecimento de imagens desde a década de 1990, embora não fossem de propósito geral. CG_MIOLO_Hands_On_Machine_Learning. indb 13 07/05/2019 17:07:50 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
xiv | Prefácio Talvez seu robô caseiro pudesse ganhar um cérebro próprio? Talvez ele pudesse reco-nhecer rostos ou aprender a andar? Ou talvez sua companhia tenha toneladas de dados (financeiros, de produção, de sensores de máquinas, logs de usuários, estatísticas de hotline, relatórios de RH, etc. ) e, muito provavelmente, você descobriria algumas pepitas de ouro escondidas se soubesse onde procurar: Seg mentar clientes e encontrar a melhor estratégia de marketing para cada grupo; Rec omendar produtos para cada cliente com base no que clientes similares compraram; Dete ctar quais transações são susceptíveis de serem fraudulentas; Pre ver a receita do próximo ano; e mais ( https://www. kaggle. com/wiki/Data Science Use Cases ). 3 Seja qual for a razão, você decidiu se familiarizar com o Aprendizado de Máquina e implementá-lo em seus projetos. O que é uma grande ideia! Objetivo e Abordagem Este livro pressupõe que você não saiba quase nada sobre Aprendizado de Máquinas. Seu objetivo é fornecer os conceitos, as intuições e as ferramentas necessárias para im-plementar programas capazes de aprender com os dados. Abordaremos um grande número de técnicas, desde as mais simples às mais comu-mente utilizadas (como a Regressão Linear) e até algumas das técnicas do Aprendizado Profundo que ganham competições com frequência. Em vez de implementar nossas próprias versões de cada algoritmo, utilizaremos estru-turas Python prontas para produção: O Scik it-Learn ( http://scikit-learn. org/ ) é muito fácil de usar e implementa mui-tos algoritmos do AM de maneira eficiente, por isso é uma excelente porta de entrada para o Aprendizado de Máquinas. O Tens or Flow ( http://tensorflow. org/ ) é uma biblioteca complexa que utiliza grafos de fluxo de dados para o cálculo numérico distribuído. Distribuindo os 3 Todo o conteúdo dos websites citados está em inglês. A editora Alta Books não se responsabiliza pela manu-te nção desse conteúdo. CG_MIOLO_Hands_On_Machine_Learning. indb 14 07/05/2019 17:07:50 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
Prefácio | xvcálculos entre potencialmente milhares de servidores multi GPU, essa biblioteca torna possível treinar e executar de forma eficiente enormes redes neurais. O Tensor Flow foi criado no Google e suporta muitas das aplicações em larga escala do Apren-dizado de Máquina. Em novembro de 2015 ele se tornou de código aberto. O livro favorece uma abordagem prática, desenvolvendo uma compreensão intuitiva de Aprendizado de Máquina por meio de exemplos de trabalho concretos e apenas um pouco de teoria. Embora você possa ler este livro sem pegar seu notebook, é altamente recomendável que você treine com os notebooks Jupyter os exemplos de código dispo-níveis online em https://github. com/ageron/handson-ml. Pré-requisitos Este livro pressupõe que você tenha alguma experiência de programação em Python e que esteja familiarizado com as principais bibliotecas científicas do Python, princi-palmente Num Py ( http://numpy. org/ ), Pandas ( http://pandas. pydata. org/ ) e Matplotlib (http://matplotlib. org/ ). Além disso, você deve ter uma compreensão razoável da matemática em nível superior, (cálculo, álgebra linear, probabilidade e estatística) caso se importe com os bastidores. Se você ainda não conhece o Python, o http://learnpython. org/ é um ótimo lugar para começar. O tutorial oficial em python. org (https://docs. python. org/3/tutorial/ ) também é muito bom. Se você nunca usou o Jupyter, o Capítulo 2 o guiará na instalação e no básico: uma ótima ferramenta para ter sempre à mão. Caso você não esteja familiarizado com as bibliotecas científicas do Python, os notebooks Jupyter incluem alguns tutoriais. Há também um tutorial rápido de mate-mática para álgebra linear. Roteiro Este livro foi organizado em duas partes. Parte I, Os Fundamentos do Aprendizado de Máquina, cobre os seguintes tópicos: O que é A prendizado de Máquina? Que problemas ele tenta resolver? Quais são as principais categorias e conceitos fundamentais dos sistemas do Aprendizado de Máquina? Os pr incipais passos de um típico projeto de Aprendizado de Máquina; CG_MIOLO_Hands_On_Machine_Learning. indb 15 07/05/2019 17:07:50 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
xvi | Prefácio Aprender ajustando um modelo aos dados; Oti mizar a função de custo; Man ipular, limpar e preparar os dados; Sele cionar e desenvolver recursos; Sele cionar um modelo com a utilização da validação cruzada e ajustar hiperparâmetros; Os pr incipais desafios do Aprendizado de Máquina, especialmente o subajuste e o sobreajuste (a compensação do viés/variância); Red uzir a dimensionalidade dos dados de treinamento para combater a maldi-ção da dimensionalidade; Os al goritmos de aprendizado mais comuns: Regressão Linear e Polinomial, Re-gressão Logística, k-Nearest Neighbors, Máquinas de Vetores de Suporte [SVM], Árvores de Decisão, Florestas Aleatórias e Métodos de Ensemble. Parte II, Redes Neurais e Aprendizado Profundo, cobre os seguintes tópicos: O que s ão redes neurais? Servem para quê? Con struir e treinar redes neurais com a utilização do Tensor Flow; As ma is importantes arquiteturas de redes neurais: feedforward, convolucionais, recorrentes, LSTM ( long short-term memory ) e autoencoders ; Téc nicas para treinamento de redes neurais profundas; Esc alonar redes neurais para grandes conjuntos de dados; Apre nder por reforço. A primeira parte é baseada principalmente no Scikit-Learn, enquanto a segunda utiliza o Tensor Flow. Não mergulhe de cabeça logo de primeira: embora o Aprendizado Pro-fundo seja, sem dúvida, uma das áreas mais interessantes do Aprendizado de Máquina, primeiro você deve dominar os fundamentos. Além disso, a maioria dos problemas pode ser resolvida com técnicas mais simples, como os métodos Florestas Aleatórias e Ensemble (discutidos na Parte I). O Aprendizado Profundo é mais adequado para problemas comple-xos, como reconhecimento de imagem e de voz, ou processamento de linguagem natural, desde que você tenha dados, poder de computação e paciência suficientes. CG_MIOLO_Hands_On_Machine_Learning. indb 16 07/05/2019 17:07:51 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
Prefácio | xvii Outros Recursos Para saber mais sobre o Aprendizado de Máquina existem muitos recursos disponíveis. O curso de AM de Andrew Ng no Coursera ( https://www. coursera. org/learn/machine--learning/ ) e o curso de Geoffrey Hinton sobre redes neurais e Aprendizado Profundo (https://www. coursera. org/course/neuralnets ) são incríveis, embora ambos demandem um investimento significativo de tempo (estamos falando de meses). Há também muitos sites interessantes sobre o Aprendizado de Máquina, incluindo, claro, o excepcional Guia do Usuário do Scikit-Learn ( http://scikit-learn. org/stable/user_guide. html ). Você também pode desfrutar do Dataquest ( https://www. dataquest. io/ ), que oferece tutoriais interativos muito interessantes e blogs de AM, como aqueles listados no Quora (http://goo. gl/Gwt U3A ). Finalmente, o site do Aprendizado Profundo ( http://deeplearning. net/) tem uma boa lista de recursos para seguirmos aprendendo mais. Há também muitos outros livros introdutórios sobre o Aprendizado de Máquina: Dat a Science do Zero, de Joel Grus (Alta Books). Apresenta os fundamentos do Aprendizado de Máquina e implementa alguns dos principais algoritmos em Python puro (do zero, como o nome sugere); Mac hine Learning: An Algorithmic Perspective, de Stephen Marsland (Chapman and Hall). É uma ótima introdução ao Aprendizado de Máquina, cobrindo uma ampla gama de tópicos em profundidade, com exemplos de código em Python (também a partir do zero, mas utilizando o Num Py); Pyt hon Machine Learning, de Sebastian Raschka (Packt Publishing). É também uma ótima introdução ao Aprendizado de Máquina. Aproveita as bibliotecas de código aberto do Python (Pylearn 2 e Theano); Lea rning from Data, de Yaser S. Abu-Mostafa, Malik Magdon-Ismail e Hsuan-Tien Lin (AMLBook). Uma abordagem bastante teórica para o AM, este livro fornece insights profundos, principalmente sobre a compensação do viés/variância (ver Capítulo 4); Int eligência Artificial, 3ª Edição, de Stuart Russell e Peter Norvig (Campus). É um ótimo (e enorme) livro que aborda uma quantidade incrível de tópicos, in-cluindo o Aprendizado de Máquina. Ajudando a colocar o AM em perspectiva. Finalmente, uma ótima maneira de aprender é entrar em sites de competição como o Kaggle. com, que lhe permite praticar suas habilidades com problemas do mundo real com a ajuda e insights de alguns dos melhores profissionais de AM que existem por aí. CG_MIOLO_Hands_On_Machine_Learning. indb 17 07/05/2019 17:07:51 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
xviii | Prefácio Convenções Utilizadas neste Livro As seguintes convenções tipográficas são usadas neste livro: Itálicos Indica novos termos, URLs, endereços de e-mail, nomes de arquivos e extensões de arquivos. Fonte monoespaçada Usada para listagens de programas, bem como em parágrafos sobre elementos de programa, como nomes de variáveis ou funções, bancos de dados, tipos de dados, variáveis de ambiente, declarações e palavras-chave. Fonte monoespaçada em negrito Mostra comandos ou outro texto que deve ser literalmente digitado pelo usuário. Fonte monoespaçada em itálico Mostra o texto que deve ser substituído por valores fornecidos pelo usuário ou por valores determinados pelo contexto. Este elemento significa uma dica ou sugestão. Este significa uma nota geral. Este indica alerta ou cautela. CG_MIOLO_Hands_On_Machine_Learning. indb 18 07/05/2019 17:07:51 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
Prefácio | xix Utilizando Exemplos de Código O material suplementar (exemplos de códigos, exercícios, etc. ) está disponível para download em https://github. com/ageron/handson-ml e também no site da editora Alta Books. Entre em www. altabooks. com. br e procure pelo nome do livro. Este livro está aqui para ajudá-lo a fazer o que precisa ser feito. Em geral, se um código de exemplo for oferecido, você poderá utilizá-lo em seus programas e documentações. Não é necessário entrar em contato conosco para obter permissão de uso, a menos que esteja reproduzindo uma parte significativa do código. Por exemplo, escrever um pro-grama que utiliza vários trechos de código deste livro não requer permissão. Vender ou distribuir um CD-ROM com exemplos dos livros O'Reilly exigirá permissão. Responder uma pergunta citando este livro e citando um exemplo de código não requer permissão. Mas, a incorporação de uma quantidade significativa de exemplos de código deste livro na documentação do seu produto requer sim permissão. Agradecemos, mas não exigimos atribuições. Uma atribuição geralmente inclui o título, o autor, o editor e o ISBN. Por exemplo: “ Mãos à Obra: Aprendizado de Máquina com Scikit-Learn & Tensor Flow por Aurélien Géron (Alta Books). Copyright 2019 de Aurélien Géron, 978-85-508-0381-4. ” Agradecimentos Gostaria de agradecer aos meus colegas do Google, em especial à equipe de classificação de vídeos do You Tube, por me ensinarem muito sobre o Aprendizado de Máquina. Nunca teria iniciado este projeto sem eles. Agradecimentos especiais aos meus gurus pessoais do AM: Clément Courbet, Julien Dubois, Mathias Kende, Daniel Kitachewsky, James Pack, Alexander Pak, Anosh Raj, Vitor Sessak, Wiktor Tomczak, Ingrid von Glehn, Rich Washington e todos do You Tube de Paris. Sou incrivelmente grato a todas as pessoas maravilhosas que tiraram um tempo de suas vidas ocupadas para revisar meu livro com tantos detalhes. Agradeço a Pete Warden por responder todas as minhas perguntas sobre o Tensor Flow, revisar a Parte II, fornecer muitos insights interessantes e, claro, por fazer parte da equipe principal do Tensor Flow. Aconselho você a definitivamente acompanhar o blog dele ( https://petewarden. com/ )! Muito obrigado a Lukas Biewald por sua revisão completa da Parte II: ele não deixou pedra sobre pedra, testou todo o código (e pegou alguns erros), fez ótimas sugestões, e seu entusiasmo foi contagiante. Acompanhe o blog dele ( https://lukasbiewald. com/ ) e seus incríveis robôs (https://goo. gl/Eu5u28 )! Agradecimentos a Justin Francis, que também analisou muito detalhadamente a Parte II, pegando erros e fornecendo importantes insights, principal-mente no Capítulo 16. Confira suas postagens ( https://goo. gl/28ve8z ) sobre o Tensor Flow! CG_MIOLO_Hands_On_Machine_Learning. indb 19 07/05/2019 17:07:51 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
xx | Prefácio Muito obrigado também a David Andrzejewski, que revisou a Parte I identificando seções pouco claras e sugerindo como melhorá-las e forneceu um feedback incrivelmente útil. Confira o site dele ( http://www. david-andrzejewski. com/ )! Agradecimentos a Grégoire Mesnil, que revisou a Parte II e contribuiu com conselhos práticos muito interessantes sobre o treinamento de redes neurais. Agradeço também a Eddy Hung, Salim Sémaoune, Karim Matrah, Ingrid von Glehn, Iain Smears e Vincent Guilbeau por revisarem a Parte I e por fazerem muitas sugestões úteis. Também gostaria de agradecer ao meu sogro, Michel Tessier, ex-professor de matemática e agora um grande tradutor de Anton Tchekhov, por me ajudar a resolver algumas das matemáticas e anotações deste livro e rever o notebook do Jupyter de álgebra linear. E, claro, um “obrigado” gigantesco ao meu querido irmão Sylvain, que revisou cada capítulo, testou todas as linhas de código, forneceu feedback sobre praticamente todas as seções e me encorajou desde a primeira até a última linha. Amo você, irmãozinho! Muito obrigado também à fantástica equipe da O'Reilly, principalmente Nicole Tache, que me deu um feedback perspicaz, e foi sempre alegre, encorajadora e prestativa. Agradeço também a Marie Beaugureau, Ben Lorica, Mike Loukides e Laurel Ruma por acredita-rem neste projeto e me ajudarem a definir seu escopo. Obrigado a Matt Hacker e a toda a equipe da Atlas por responder todas as minhas questões técnicas sobre formatação, asciidoc e La Te X, e a Rachel Monaghan, Nick Adams e toda a equipe de produção pela revisão final e centenas de correções. Por último, mas não menos importante, sou infinitamente grato a minha amada esposa, Emmanuelle, e aos nossos três maravilhosos filhos, Alexandre, Rémi e Gabrielle, por me encorajarem a trabalhar muito neste livro, fazerem muitas perguntas (quem disse que não é possível ensinar redes neurais para uma criança de sete anos?) e até trazerem biscoitos e café. O que mais se pode sonhar? Aviso Para melhor entendimento as figuras coloridas estão disponíveis no site da editora Alta Books. Acesse: www. altabooks. com. br e procure pelo nome do livro ou ISBN. CG_MIOLO_Hands_On_Machine_Learning. indb 20 07/05/2019 17:07:51 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
Parte I Os Fundamentos do Aprendizado de Máquina CG_MIOLO_Hands_On_Machine_Learning. indb 1 07/05/2019 17:07:51 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
CG_MIOLO_Hands_On_Machine_Learning. indb 2 07/05/2019 17:07:51 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
3Capítulo 1 O Cenário do Aprendizado de Máquina A maioria das pessoas pensa em um robô quando ouve “Aprendizado de Máquina”: um mordomo confiável ou um Exterminador do Futuro, dependendo para quem você perguntar. Mas o Aprendizado de Máquina não é apenas uma fantasia futurista; ele já está entre nós. Na verdade, há algumas décadas o AM foi introduzido como Reco-nhecimento Ótico de Caracteres (OCR) em algumas publicações especializadas, mas o primeiro aplicativo que realmente ficou famoso e conquistou o mundo na década de 1990, melhorando a vida de centenas de milhões de pessoas, foi o filtro de spam. Não era exatamente um robô autoconsciente da Skynet, mas pode ser tecnicamente qualificado como Aprendizado de Máquina (uma máquina que aprendeu tão bem que raramente é necessário marcar um e-mail como spam). O filtro de spam foi seguido por centenas de aplicativos AM que agora, silenciosamente, fornecem centenas de produtos e recursos, de recomendações a buscas por voz, que você utiliza regularmente. Onde começa e onde termina o Aprendizado de Máquina? O que significa exatamente que uma máquina aprende alguma coisa? Se eu baixar uma cópia da Wikipédia, meu computador realmente “aprenderá” algo? Será que de repente ele fica mais esperto? Neste capítulo, começaremos esclarecendo o que é o Aprendizado de Máquina e por que você vai querer utilizá-lo. Então, antes de iniciarmos a exploração do mundo do Aprendizado de Máquina, anali-saremos seu mapa e conheceremos suas principais regiões e os cenários mais notáveis: aprendizado supervisionado versus não supervisionado, aprendizado online versus aprendizado em lote, aprendizado baseado em instâncias versus aprendizado baseado em modelo. Em seguida, analisaremos o fluxo de trabalho de um típico projeto de AM, discutiremos os principais desafios que você poderá enfrentar e mostraremos como avaliar e ajustar um sistema de Aprendizado de Máquina. Este capítulo apresenta muitos conceitos fundamentais (e jargões) que todo cientista de dados deve saber de cor. Será uma visão geral de alto nível (o único capítulo sem muito CG_MIOLO_Hands_On_Machine_Learning. indb 3 07/05/2019 17:07:51 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
4 | Capítulo 1: O Cenário do Aprendizado de Máquinacódigo), tudo bastante simples, mas você deve se certificar de que entendeu tudo antes de continuar. Então pegue um café e mãos à obra ! Se você já conhece todos os conceitos básicos do Aprendizado de Máquina, pule diretamente para o Capítulo 2. Se não tiver certeza, tente responder a todas as perguntas listadas no final do capítulo antes de seguir em frente. O que É o Aprendizado de Máquina? Aprendizado de Máquina é a ciência (e a arte) da programação de computadores para que eles possam aprender com os dados. Veja uma definição um pouco mais abrangente: [Aprendizado de Máquina é o] campo de estudo que dá aos computadores a habilidade de aprender sem ser explicitamente programado. —Arthur Samuel, 1959 E uma mais direcionada aos engenheiros: Diz-se que um programa de computador aprende pela experiência E em relação a algum tipo de tarefa T e alguma medida de desempenho P se o seu desempenho em T, conforme medido por P, melhora com a experiência E. —Tom Mitchell, 1997 Por exemplo, seu filtro de spam é um programa de Aprendizado de Máquina que pode aprender a assinalar e-mails como spam (por exemplo, os marcados pelos usuários) e como regulares (não spam, também chamados de “ham”). Os exemplos utilizados pelo sistema para o aprendizado são chamados de conjuntos de treinamentos. Cada exemplo de treinamento é chamado de instância de treinamento (ou amostra ). Nesse caso, assi-nalar novos e-mails como spam é a tarefa T, a experiência E é o dado de treinamento e a medida de desempenho P precisa ser definida; por exemplo, você pode utilizar a média de e-mails classificados corretamente. Esta medida de desempenho particular é chamada de acurácia e é utilizada frequentemente em tarefas de classificação. Se você baixou uma cópia da Wikipédia, seu computador terá muito mais dados, mas não terá repentinamente um melhor desempenho em nenhuma tarefa. Portanto, não é Aprendizado de Máquina. CG_MIOLO_Hands_On_Machine_Learning. indb 4 07/05/2019 17:07:51 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
Por que Utilizar o Aprendizado de Máquina? | 5Por que Utilizar o Aprendizado de Máquina? Considere como você escreveria um filtro de spam utilizando técnicas de programação tradicionais (Figura 1-1): 1. Pri meiro, identificaria as características do spam. Você nota que algumas palavras ou frases (termos em inglês como “4U”, “credit card”, “free” e “amazing”) tendem a aparecer muito no campo do assunto. Talvez você note outros padrões no nome do remetente, no corpo do e-mail, e assim por diante. 2. Seg undo, escreveria um algoritmo de detecção para cada um dos padrões observa-dos, e, se fossem detectados, seu programa marcaria esses e-mails como spam. 3. Por ú ltimo, você testaria seu programa, e repetiria os passos 1 e 2 até que esteja satisfatório. Estude o problema Lance! Analise os erro s Avalie Escreva regras Figura 1-1. A abordagem tradicional Como o problema não é trivial, seu programa provavelmente se tornará uma longa lista de regras complexas — com uma manutenção muito difícil. Em contrapartida, um filtro de spam baseado em técnicas de Aprendizado de Máquina aprende automaticamente quais palavras e frases são bons indicadores de spam, detectan-do padrões de palavras estranhamente frequentes em exemplos de spam se comparados aos exemplos dos e-mails “não spam” (Figura 1-2). O programa é muito menor, de mais fácil manutenção e, provavelmente, mais preciso. CG_MIOLO_Hands_On_Machine_Learning. indb 5 07/05/2019 17:07:51 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
6 | Capítulo 1: O Cenário do Aprendizado de Máquina Estude o problema Analise os erro s Treine o algoritmo AMAvalie a solução Lance! Dados Figura 1-2. Abordagem do Aprendizado de Máquina Além disso, se os spammers perceberem que todos os seus e-mails contendo “4U” são bloqueados, poderão começar a escrever “For U”. Um filtro de spam que utiliza técnicas de programação tradicionais precisaria ser atualizado para marcar os e-mails “For U”. Se os spammers continuam contornando seu filtro de spam, será preciso escrever novas regras para sempre. Em contrapartida, um filtro de spam baseado em técnicas de Aprendizado de Máquina percebe automaticamente que “For U” tornou-se frequente no spam marcado pelos usuários e começa a marcá-los sem a sua intervenção (Figura 1-3). Avalie a soluçao Dados Atualize os dados Lance! Pode ser automatizado Treine o algoritmo AM Figura 1-3. Adaptando-se automaticamente à mudança Outra área na qual o Aprendizado de Máquina se destaca é nos problemas muito com-plexos para abordagens tradicionais ou que não possuem um algoritmo conhecido. Por exemplo, considere o reconhecimento da fala: digamos que você deseja começar com o básico e escreve um programa capaz de distinguir as palavras “one” e “two”. Você deve CG_MIOLO_Hands_On_Machine_Learning. indb 6 07/05/2019 17:07:52 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
Por que Utilizar o Aprendizado de Máquina? | 7perceber que a palavra “Two” começa com um som agudo (“T”), então você codifica um algoritmo que mede a intensidade do som agudo e o utiliza para distinguir “One” e “Two”. Obviamente, esta técnica não se estenderá a milhares de palavras faladas por milhões de pessoas muito diferentes em ambientes confusos e em dezenas de idiomas. A melhor solução (pelo menos hoje) seria escrever um algoritmo que aprenda por si só por meio de muitas gravações de exemplos para cada palavra. Finalmente, o Aprendizado de Máquina pode ajudar os seres humanos a aprender (Figura 1-4): os algoritmos do AM podem ser inspecionados para que vejamos o que eles aprenderam (embora para alguns algoritmos isso possa ser complicado). Por exemplo, uma vez que o filtro foi treinado para o spam, ele pode facilmente ser inspecionado e revelar uma lista de palavras e combinações previstas que ele acredita serem as mais prováveis. Às vezes, isso revelará correlações não esperadas ou novas tendências, levando a uma melhor compreensão do problema. Aplicar técnicas do AM para se aprofundar em grandes quantidades de dados pode ajudar na descoberta de padrões que não eram aparentes. Isto é chamado de mineração de dados. Itere se necessário Estude o problema Inspecione a solução Entenda melhor o problema*Muitos* dados Treine o algoritmo AM Solução Figura 1-4. O Aprendizado de Máquina pode ajudar no ensino dos humanos Resumindo, o Aprendizado de Máquina é ótimo para: Problemas para os quais as soluções existentes exigem muita configuração manual ou longas listas de regras: um algoritmo de Aprendizado de Máquina geralmente simplifica e melhora o código; Problemas complexos para os quais não existe uma boa solução quando utilizamos uma abordagem tradicional: as melhores técnicas de Aprendizado de Máquina podem encontrar uma solução; CG_MIOLO_Hands_On_Machine_Learning. indb 7 07/05/2019 17:07:52 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
8 | Capítulo 1: O Cenário do Aprendizado de Máquina Ambientes flutuantes: um sistema de Aprendizado de Máquina pode se adaptar a no vos dados; Com preensão de problemas complexos e grandes quantidades de dados. Tipos de Sistemas do Aprendizado de Máquina Existem tantos tipos diferentes de sistemas de Aprendizado de Máquina que será útil classificá-los em extensas categorias com base em: Ser em ou não treinados com supervisão humana (supervisionado, não supervi-sionado, semissupervisionado e aprendizado por reforço); Se po dem ou não aprender rapidamente, de forma incremental (aprendizado online versus aprendizado por lotes); Se fu ncionam simplesmente comparando novos pontos de dados com pontos de dados conhecidos, ou se detectam padrões em dados de treinamento e criam um modelo preditivo, como os cientistas (aprendizado baseado em instâncias versus aprendizado baseado em modelo). Esses critérios não são exclusivos; você pode combiná-los da maneira que quiser. Por exemplo, um filtro de spam de última geração pode aprender rapidamente com a utiliza-ção de um modelo de rede neural profundo treinado com exemplos de spam e não spam, fazendo deste um sistema de aprendizado supervisionado online, baseado em modelos. Vejamos cada um desses critérios um pouco mais de perto. Aprendizado Supervisionado/Não Supervisionado Os sistemas de Aprendizado de Máquina podem ser classificados de acordo com a quantidade e o tipo de supervisão que recebem durante o treinamento. Existem quatro categorias principais de aprendizado: supervisionado, não supervisionado, semissupervisionado e por reforço. Aprendizado Supervisionado No aprendizado supervisionado, os dados de treinamento que você fornece ao algoritmo incluem as soluções desejadas, chamadas de rótulos (Figura 1-5). CG_MIOLO_Hands_On_Machine_Learning. indb 8 07/05/2019 17:07:52 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
Tipos de Sistemas do Aprendizado de Máquina | 9 Conjunto de treinamento Nova instância Rótulo Instância Figura 1-5. Um conjunto de treinamento rotulado para aprendizado supervisionado (por exemplo, classificação de spam) A classificação é uma tarefa típica do aprendizado supervisionado. O filtro de spam é um bom exemplo disso: ele é treinado com muitos exemplos de e-mails junto às classes (spam ou não spam) e deve aprender a classificar novos e-mails. Prever um alvo de valor numérico é outra tarefa típica, como o preço de um carro a partir de um conjunto de características (quilometragem, idade, marca, etc. ) denomi-nadas previsores. Esse tipo de tarefa é chamada de regressão (Figura 1-6)1. Para treinar o sistema, você precisa fornecer muitos exemplos de carros incluindo seus previsores e seus labels (ou seja, seus preços). No Aprendizado de Máquina, um atributo é um tipo de dado (por exemplo, “Quilometragem”), enquanto uma característica possui vários significados, dependendo do contexto, geralmente signifi-cando um atributo mais o seu valor (por exemplo, “Quilometragem = 15000”). Embora muitas pessoas utilizem as palavras atributo e característica intercambiavelmente. Valor? Nova instância Valor Cara cterística1 Figura 1-6. Regressão 1 Curiosidade: este nome estranho é um termo de estatística introduzido por Francis Galton, enquanto estudava o fato de que os filhos de pessoas altas tendem a ser mais baixos do que os pais. Como as crianças eram mais baixas, ele chamou essa alteração de regressão à média. Este nome foi aplicado aos métodos utilizados por ele para analisar as correlações entre variáveis. CG_MIOLO_Hands_On_Machine_Learning. indb 9 07/05/2019 17:07:53 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
10 | Capítulo 1: O Cenário do Aprendizado de Máquina Observe que alguns algoritmos de regressão também podem ser utilizados para clas-sificação, e vice-versa. Por exemplo, a Regressão Logística é comumente utilizada para classificação pois pode produzir um valor que corresponde à probabilidade de pertencer a uma determinada classe (por exemplo, 20% de chances de ser spam). Estes são alguns dos algoritmos mais importantes do aprendizado supervisionado (abordados neste livro): k-Ne arest Neighbours Regressão Linear Regr essão Logística Máq uinas de Vetores de Suporte (SVM) Árvores de Decisão e Florestas Aleatórias Rede s Neurais2 Aprendizado Não Supervisionado No aprendizado não supervisionado, como você pode imaginar, os dados de treinamento não são rotulados (Figura 1-7). O sistema tenta aprender sem um professor. Conjunto de treinamento Figura 1-7. Conjunto de treinamento não rotulado para aprendizado não supervisionado Eis alguns dos mais importantes algoritmos de aprendizado não supervisionado (fala-remos sobre a redução da dimensionalidade no Capítulo 8): 2 Algumas arquiteturas de redes neurais podem ser não supervisionadas, como autoencoders e má quinas de Boltzmann restritas. Elas também podem ser semi-supervisionadas, como redes de crenças profundas e pré-treino sem supervisão. CG_MIOLO_Hands_On_Machine_Learning. indb 10 07/05/2019 17:07:53 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
Tipos de Sistemas do Aprendizado de Máquina | 11 Clustering —k-Means —Clustering Hierárquico [HCA, do inglês] —Max imização da Expectativa Visualização e redução da dimensionalidade —Aná lise de Componentes Principais [PCA, do inglês] —Kernel PCA —Loca lly-Linear Embedding (LLE) —t-distributed Stochastic Neighbor Embedding (t-SNE) Aprendizado da regra da associação —Apri ori —Eclat Por exemplo, digamos que você tenha muitos dados sobre os visitantes do seu blog. Você quer executar um algoritmo de clustering para tentar detectar grupos de visitantes semelhantes (Figura 1-8). Em nenhum momento você diz ao algoritmo a qual grupo o visitante pertence: ele encontrará essas conexões sem sua ajuda. Por exemplo, ele pode notar que 40% dos seus visitantes são homens que adoram histórias em quadrinhos e geralmente leem seu blog à noite, enquanto 20% são jovens amantes de ficção científica e o visitam durante os finais de semana, e assim por diante. Se você utilizar um algoritmo de clustering hierárquico, ele também poderá subdividir cada grupo em grupos menores. O que pode ajudá-lo a segmentar suas postagens para cada um deles. Cara cterística 2 Cara cterística1 Figura 1-8. Clustering Os algoritmos de visualização também são bons exemplos de algoritmos de aprendizado não supervisionado: você os alimenta com muitos dados complexos e não rotulados e eles CG_MIOLO_Hands_On_Machine_Learning. indb 11 07/05/2019 17:07:53 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
12 | Capítulo 1: O Cenário do Aprendizado de Máquinaexibem uma representação 2D ou 3D de seus dados que podem ser facilmente plotados (Figura 1-9). Esses algoritmos tentam preservar o máximo da estrutura (por exemplo, tentam fazer com que os clusters no espaço de entrada que estão separados não se sobre-ponham na visualização) para que você possa entender como os dados estão organizados e talvez identificar padrões ignorados. automóvel aviãopássarogatosapo gato automóve l caminhão sapo navio avião cavalo pássaro cachorro cervocachorro cervo cavalo naviocaminhão Figura 1-9. Exemplo de uma visualização t-SNE destacando grupos semânticos3 A redução da dimensionalidade é uma tarefa relacionada na qual o objetivo é simplificar os dados sem perder muita informação. Uma maneira de fazer isso é mesclar várias ca-racterísticas correlacionadas em uma. Por exemplo, a quilometragem de um carro pode estar muito correlacionada com seu tempo de uso, de modo que o algoritmo da redução de dimensionalidade irá mesclá-los em uma característica que representa o desgaste do carro. Isso é chamado de extração de características. 3 Observe como os animais estão muito bem separados dos veículos, como os cavalos estão próximos aos cervos, mas longe dos pássaros, e assim por diante. Imagem reproduzida com permissão de Socher, Ganjoo, Manning e Ng (2013), “Visualização T-SNE do espaço da palavra semântica”. CG_MIOLO_Hands_On_Machine_Learning. indb 12 07/05/2019 17:07:54 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
Tipos de Sistemas do Aprendizado de Máquina | 13É uma boa ideia tentar reduzir a dimensão dos dados de treinamento com a utilização de um algoritmo de redução de dimensionalidade antes de fornecê-lo a outro algoritmo do Aprendizado de Máquina (como um algoritmo de aprendizado supervisionado). Este algoritmo será executa-do muito mais rapidamente, os dados ocuparão menos espaço em disco e na memória e, em alguns casos, podem rodar melhor também. Outra importante tarefa não supervisionada é a detecção de anomalias — por exemplo, a detecção de transações incomuns em cartões de crédito para evitar fraudes, detectar defeitos de fabricação ou remover automaticamente outliers de um conjunto de dados antes de fornecê-lo a outro algoritmo de aprendizado. O sistema é treinado com instâncias normais e, quando vê uma nova instância, pode dizer se ela parece normal ou se é uma provável anomalia (veja a Figura 1-10). Anomalia Cara cterística 2Novas instâncias Normal Treinando instâncias Cara cterística 1 Figura 1-10. Detecção da anomalia Finalmente, outra tarefa comum não supervisionada é o aprendizado de regras de associa-ção, cujo objetivo é se aprofundar em grandes quantidades de dados e descobrir relações interessantes entre atributos. Por exemplo, suponha que você possua um supermercado. Executar uma regra de associação em seus registros de vendas pode revelar que as pessoas que compram molho de churrasco e batatas fritas também tendem a comprar carnes. Desta forma, você vai querer colocar esses itens próximos uns dos outros. Aprendizado Semi-supervisionado Alguns algoritmos podem lidar com dados de treinamento parcialmente rotulados, uma grande quantidade de dados não rotulados e um pouco de dados rotulados. Isso é chamado de aprendizado semi-supervisionado (Figura 1-11). CG_MIOLO_Hands_On_Machine_Learning. indb 13 07/05/2019 17:07:54 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
14 | Capítulo 1: O Cenário do Aprendizado de Máquina Alguns serviços de hospedagem de fotos, como o Google Fotos, são bons exemplos disso. Ao carregar todas as suas fotos de família, o aplicativo reconhecerá automaticamente que a mesma pessoa (A) aparece nas fotos 1, 5 e 11 enquanto outra pessoa (B) aparece nas fotos 2, 5 e 7. Esta é a parte não supervisionada do algoritmo (agrupamento). Agora, o sistema apenas precisa que você diga quem são essas pessoas. Com apenas um rótulo por pessoa4 ele será capaz de nomear todos, o que é útil para pesquisar fotos. Cara cterística 2 Classe? Cara cterística 1 Figura 1-11. Aprendizado Semissupervisionado A maior parte dos algoritmos de aprendizado semissupervisionado é de combinações de algoritmos supervisionados e não supervisionados. Por exemplo, as redes neurais de crenças profundas [DBNs, do inglês] são baseadas em componentes não supervisionados, chamados máquinas restritas de Boltzmann [RBMs, do inglês], empilhados uns em cima dos outros. As RBMs são treinadas sequencialmente de forma não supervisionada, e então todo o sistema é ajustado utilizando-se técnicas de aprendizado supervisionado. Aprendizado por Reforço O aprendizado por eforço é um bicho muito diferente. O sistema de aprendizado, chamado de agente nesse contexto, pode observar o ambiente, selecionar e executar ações e obter recompensas em troca — ou penalidades na forma de recompensas negativas (Figura 1-12). Ele deve aprender por si só qual é a melhor estratégia, chamada de política, para obter o maior número de recompensas ao longo do tempo. Uma política define qual ação o agente deve escolher quando está em determinada situação. 4 Isso quando o sistema funciona perfeitamente. Na prática, muitas vezes ele cria alguns agrupamentos por pessoa e, às vezes, mistura duas pessoas parecidas, portanto, é necessário fornecer alguns rótulos por pessoa e limpar manualmente alguns clusters. CG_MIOLO_Hands_On_Machine_Learning. indb 14 07/05/2019 17:07:54 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
Tipos de Sistemas do Aprendizado de Máquina | 15 Ambiente Opa!-50 ponto s Da próxima vez, evit e. Ruim!Obser ve Selecione a ação utilizando a política Ação! Ganhe a recompensa ou a penalidade Atualize a política (etapa de aprendizado) Itere até encontra r uma boa política Agente Figura 1-12. Aprendizado por reforço Por exemplo, muitos robôs implementam algoritmos de aprendizado por reforço para aprender a andar. O programa Alpha Go da Deep Mind também é um bom exemplo de aprendizado por reforço: ele apareceu nas manchetes em maio de 2017 quando venceu o campeão mundial Ke Jie no jogo Go. Ele desenvolveu sua política vencedora analisando milhões de jogos e depois praticando muito contra si mesmo. Note que o aprendizado foi desativado durante os jogos contra o campeão; o Alpha Go apenas aplicou a política que aprendeu. Aprendizado Online e em Lote Outro critério utilizado para classificar os sistemas de Aprendizado de Máquina é se o sistema pode ou não aprender de forma incremental a partir de um fluxo de dados recebido. Aprendizado em lote No aprendizado em lote, o sistema é incapaz de aprender de forma incremental: ele deve ser treinado com a utilização de todos os dados disponíveis. Isso geralmente demandará muito tempo e recursos de computação, portanto, normalmente é feito offline. Primeiro, o sistema é treinado, em seguida, é lançado em produção, e roda sem aprender mais nada; apenas aplicando o que aprendeu. Isso é chamado de aprendizado offline. Se você quiser que um sistema de aprendizado em lote conheça novos dados (como um novo tipo de spam), é preciso treinar uma nova versão do sistema a partir do zero no conjunto completo de dados (não apenas os novos dados, mas também os antigos), então parar o sistema antigo e substituí-lo pelo novo. CG_MIOLO_Hands_On_Machine_Learning. indb 15 07/05/2019 17:07:54 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
16 | Capítulo 1: O Cenário do Aprendizado de Máquina Felizmente, todo o processo de treinamento, avaliação e lançamento de um sistema de Aprendizado de Máquina pode ser automatizado facilmente (como mostrado na Figura 1-3), então mesmo um sistema de aprendizado em lote pode se adaptar às mudanças. Basta atualizar os dados e treinar a partir do zero uma nova versão do sistema sempre que necessário. Esta solução é simples e geralmente funciona bem, mas, com a utilização do conjunto completo de dados, o treinamento pode demorar muitas horas, então você normalmente treinará um novo sistema apenas a cada 24 horas ou mesmo semanalmente. Se seu sistema precisa se adaptar a dados que mudam rapidamente (por exemplo, prever os preços das ações), você precisa de uma solução mais reativa. Além disso, o treinamento no conjunto completo de dados requer muitos recursos de computação (CPU, espaço de memória, espaço em disco, E/S do disco, E/S de rede, etc. ). Se você tem muitos dados e seu sistema é automatizado para treinar todos os dias a partir do zero, esse processo ficará muito caro. Se a quantidade de dados for enorme, talvez seja impossível utilizar um algoritmo de aprendizado em lote. Finalmente, se o seu sistema precisa ser capaz de aprender de forma autônoma e tem recursos limitados (por exemplo, um aplicativo de smartphone ou um rover em Marte), então, seria um grave erro carregar grandes quantidades de dados de treinamento e usar inúmeros recursos para treinar por horas todos os dias. Felizmente, uma opção melhor em todos esses casos seria utilizar algoritmos capazes de aprender de forma incremental. Aprendizado online No aprendizado online, você treina o sistema de forma incremental, alimentando sequencialmente as instâncias de dados individualmente ou em pequenos grupos, cha-mados de minilotes. Cada etapa do aprendizado é rápida e barata, então o sistema pode aprender rapidamente sobre os novos dados assim que eles chegam (veja Figura 1-13). Avalie a solução Dados Treine o algoritmo AMExecute e aprenda Novos dados (durante a ação ) Lance! Figura 1-13. Aprendizado online CG_MIOLO_Hands_On_Machine_Learning. indb 16 07/05/2019 17:07:55 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
Tipos de Sistemas do Aprendizado de Máquina | 17O aprendizado online é excelente para sistemas que recebem dados como um fluxo contínuo (por exemplo, preços das ações) e precisam se adaptar às mudanças rápida ou autonoma-mente. Também é uma boa opção se seus recursos de computação são limitados: uma vez que um sistema de aprendizado online aprendeu sobre as novas instâncias de dados, ele não precisa mais delas, então você pode descartá-las (a menos que queira reverter para um estágio anterior e “reproduzir” os dados). O que pode economizar muito espaço. Os algoritmos de aprendizado online também podem ser utilizados para treinar sistemas em grandes conjuntos de dados que não cabem na memória principal de uma máquina (isto é chamado de out-of-core learning ). O algoritmo carrega parte dos dados, executa uma etapa do treinamento nesses dados e repete o processo até que ele tenha sido exe-cutado em todos os dados (veja Figura 1-14). Todo esse processo geralmente é feito offline (ou seja, não no sistema ao vivo), então aprendizado online pode ser um nome confuso. Pense nisso como aprendizado incremental. Avalie a solução Lance ! Treine online o algoritmo AM *Muitos* dados Estude o problema Analise erro s Corte em pedaço s Figura 1-14. Utilizando aprendizado online para lidar com grandes conjuntos de dados Um parâmetro importante dos sistemas de aprendizado online é a rapidez com que eles devem se adaptar às mudanças dos dados: isto é chamado de taxa de aprendizado. Se você definir uma alta taxa de aprendizado, seu sistema se adaptará rapidamente aos novos dados, mas também tenderá a se esquecer rapidamente os antigos (você não quer que um filtro de spam sinalize apenas os tipos mais recentes de spam). Por outro lado, se você definir uma baixa taxa de aprendizado, o sistema terá mais inércia; isto é, aprenderá mais devagar, mas também será menos sensível ao apontar novos dados ou sequências de pontos de dados não representativos. CG_MIOLO_Hands_On_Machine_Learning. indb 17 07/05/2019 17:07:55 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
18 | Capítulo 1: O Cenário do Aprendizado de Máquina Um grande desafio no aprendizado online é que, se incluirmos dados ruins no sistema, seu desempenho diminuirá gradualmente. Se estamos falando de um sistema ao vivo, seus clientes perceberão. Por exemplo, dados ruins podem vir de um sensor com mau funcionamento em um robô, ou de alguém que envia um spam a um mecanismo de pesquisa para tentar se posicionar no topo. Para reduzir esse risco, você precisa moni-torar de perto o sistema e desligar o aprendizado rapidamente se detectar uma queda no desempenho (e possivelmente reverter para um estágio anterior de trabalho). Você também poderá monitorar os dados de entrada e reagir a dados anormais (por exemplo, com a utilização de um algoritmo de detecção de anomalias). Aprendizado Baseado em Instância Versus Aprendizado Baseado em Modelo Mais uma forma de categorizar os sistemas de Aprendizado de Máquina é por meio da generalização. A maioria das tarefas de Aprendizado de Máquina faz previsões. Isso significa que, dada uma série de exemplos de treinamento, o sistema precisa ser capaz de generalizar em exemplos que nunca viu antes. Ter uma boa medida do desempenho nos dados de treinamento é bom, mas insuficiente; o verdadeiro objetivo é ter um bom desempenho em novas instâncias. Existem duas abordagens principais para a generalização: aprendizado baseado em instâncias e aprendizado baseado em modelo. Aprendizado baseado em instância Possivelmente, a forma mais trivial de aprendizado é simplesmente decorar. Se você fosse criar um filtro de spam desta forma, ele apenas marcaria todos os e-mails que são idênticos em relação aos e-mails que já foram marcados pelos usuários — não seria a pior solução, mas certamente não é a melhor. Em vez de marcar apenas e-mails que são idênticos aos e-mails de spam conhecidos, seu filtro de spam pode ser programado para marcar também e-mails que são muito seme-lhantes aos e-mails conhecidos de spam. Isso requer uma medida de similaridade entre dois e-mails. Uma medida de similaridade (muito básica) entre dois e-mails poderia ser contar o número de palavras que eles têm em comum. O sistema marcaria um e-mail como spam se tivesse muitas palavras em comum com um e-mail de spam conhecido. Isso é chamado de aprendizado baseado em instância: o sistema aprende os exemplos por meio da memorização e, em seguida, generaliza para novos casos utilizando uma medida de similaridade (Figura 1-15). CG_MIOLO_Hands_On_Machine_Learning. indb 18 07/05/2019 17:07:55 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
Tipos de Sistemas do Aprendizado de Máquina | 19 Cara cterística 2 Nova instância Treinando instâncias Cara cterística 1 Figura 1-15. Aprendizado baseado em instância Aprendizado baseado em modelo Outra maneira de generalizar a partir de um conjunto de exemplos seria construir um modelo desses exemplos e utilizar esse modelo para fazer previsões. Isso é chamado de aprendizado baseado em modelo (Figura 1-16). Cara cterística 2 Cara cterística 1Nova instânci a Modelo Figura 1-16. Aprendizado baseado em modelo Por exemplo, suponha que você queira saber se o dinheiro faz as pessoas felizes; então você baixa os dados do Better Life Index no site da OCDE ( https://goo. gl/0Eht9W ), bem como as estatísticas sobre o PIB per capita no site do FMI ( http://goo. gl/j1MSKe ). Logo, você junta as tabelas e classifica pelo PIB per capita. A Tabela 1-1 exemplifica uma amostra do que você obtém. Tabela 1-1. O dinheiro torna as pessoas mais felizes? País PIB per capita (USD) Satisfação de vida Hungria 12. 240 4,9 Coreia 27. 195 5,8 França 37. 675 6,5 Austrália 50. 962 7, 3 Estados Unidos 55. 805 7, 2 CG_MIOLO_Hands_On_Machine_Learning. indb 19 07/05/2019 17:07:55 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
20 | Capítulo 1: O Cenário do Aprendizado de Máquina Vamos plotar os dados para alguns países aleatórios (Figura 1-17). Satisfação de vida PIB per capita Hungria Coreia França Austrália EUA Figura 1-17. Você vê uma tendência aqui? Parece haver uma tendência aqui! Embora os dados estejam ruidosos (ou seja, parcialmente aleatórios), parece que a satisfação de vida aumenta de forma mais ou menos linear à medida que aumenta o PIB per capita do país. Então você decide modelar a satisfação de vida [ life_satisfaction ] como uma função linear do PIB per capita [ GDP_per_capita ]. Esta etapa é chamada de seleção do modelo : você selecionou um modelo linear de satisfação de vida com apenas um atributo, o PIB per capita (Equação 1-1). Equação 1-1. Um simples modelo linear life_satisfaction = θ0 + θ1 × GDP_per_capita Este modelo tem dois parâmetros do modelo, θ₀ e θ. 5 Ao ajustar esses parâmetros, você pode fazer com que seu modelo represente qualquer função linear, como mostrado na Figura 1-18. Satisfação de vida PIB per capita Figura 1-18. Alguns modelos lineares possíveis 5 Por convenção, a letra grega θ (theta) é frequentemente utilizada para representar os parâmetros do modelo. CG_MIOLO_Hands_On_Machine_Learning. indb 20 07/05/2019 17:07:56 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
Tipos de Sistemas do Aprendizado de Máquina | 21Antes de poder utilizar seu modelo, você precisa definir os valores dos parâmetros θ0 e θ1. Como você pode saber quais valores farão seu modelo funcionar melhor? Para responder a esta pergunta, você precisa especificar uma medida de desempenho. Você pode definir uma função de utilidade (ou função fitness ) que mede o quão bom seu modelo é, ou uma função de custo, que mede o quão ruim ele é. Para problemas de regressão linear, as pes-soas geralmente utilizam uma função de custo que mede a distância entre as previsões do modelo linear e os exemplos de treinamento; o objetivo é minimizar essa distância. É aqui que o algoritmo de regressão linear entra: você o alimenta com seus exemplos de treinamento e ele encontra os parâmetros que tornam o modelo linear mais adequado aos seus dados. Isso é chamado de treinar o modelo. No nosso caso, o algoritmo descobre que os valores dos parâmetros otimizados são θ₀ = 4,85 e θ = 4,91 × 10-5. Agora, o modelo se ajusta o mais próximo possível dos dados do treinamento (para um modelo linear), como você pode ver na Figura 1-19. Satisfação de vida PIB per capita Figura 1-19. O modelo linear que melhor se ajusta aos dados de treinamento Você finalmente está pronto para executar o modelo e fazer previsões. Por exemplo, digamos que quer saber o nível de felicidade dos cipriotas, e os dados da OCDE não têm a resposta. Felizmente, você pode utilizar o seu modelo para fazer uma boa previsão: você olha para o PIB per capita do Chipre, encontra US$22. 587 e, em seguida, aplica seu modelo e verifica que a satisfação de vida estará provavelmente ao redor de 4,85 + 22. 587 × 4,91 × 10-5 = 5,96. Para estimular o seu apetite, o Exemplo 1-1 mostra o código Python que carrega os dados, os prepara,6 cria um diagrama de dispersão para visualização e, em seguida, treina um modelo linear e faz uma previsão. 7 6 O código assume que prepare_country_stats() já está definido: ele mescla os dados de PIB e de satisfação de vida em um único dataframe do Pandas. 7 Tudo bem se você não entender todo o código ainda; apresentaremos o Scikit-Learn nos próximos capítulos. CG_MIOLO_Hands_On_Machine_Learning. indb 21 07/05/2019 17:07:56 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
22 | Capítulo 1: O Cenário do Aprendizado de Máquina Exemplo 1-1. Treinando e executando um modelo linear utilizando o Scikit-Learn import matplotlib import matplotlib. pyplot as plt import numpy as np import pandas as pdimport sklearn # Carregue os dados oecd_bli = pd. read_csv("oecd_bli_2015. csv", thousands=',') gdp_per_capita = pd. read_csv("gdp_per_capita. csv",thousands=',',delimiter='\t', encoding='latin1', na_values="n/a") # Prepare os dados country_stats = prepare_country_stats(oecd_bli, gdp_per_capita) X = np. c_[country_stats["GDP per capita"]] y = np. c_[country_stats["Life satisfaction"]] # Visualize os dados country_stats. plot(kind='scatter', x="GDP per capita", y='Life satisfaction') plt. show() # Selecione um modelo linear model = sklearn. linear_model. Linear Regression() # Treine o modelo model. fit(X, y) # Faça uma predição para o Cyprus X_new = [[22587]] # Cyprus' GDP per capitaprint(model. predict(X_new)) # outputs [[ 5. 96242338]]import matplotlib import matplotlib. pyplot as plt import numpy as np import pandas as pdimport sklearn # Carregue os dados oecd_bli = pd. read_csv("oecd_bli_2015. csv", thousands=',') gdp_per_capita = pd. read_csv("gdp_per_capita. csv",thousands=',',delimiter='\t', encoding='latin1', na_values="n/a") # Prepare os dados country_stats = prepare_country_stats(oecd_bli, gdp_per_capita) X = np. c_[country_stats["GDP per capita"]] y = np. c_[country_stats["Life satisfaction"]] # Visualize os dados country_stats. plot(kind='scatter', x="GDP per capita", y='Life satisfaction') plt. show() # Selecione um modelo linear model = sklearn. linear_model. Linear Regression() # Treine o modelo model. fit(X, y) # Faça uma predição para o Cyprus X_new = [[22587]] # Cyprus' GDP per capitaprint(model. predict(X_new)) # outputs [[ 5. 96242338]] Se você tivesse optado por utilizar um algoritmo de aprendizado ba-seado em instâncias, teria visto que a Eslovênia tem o PIB per capita mais próximo do Chipre (US$20. 732), e, como os dados da OCDE nos dizem que a satisfação da vida dos eslovenos é 5,7, você teria pre-visto uma satisfação de vida de 5,7 para o Chipre. Se você reduzir um pouco e observar os dois países mais próximos, encontrará Portugal e Espanha com satisfações de vida de 5,1 e 6,5, respectivamente. Fa-zendo a média desses três valores, obtém-se 5,77, o que é bastante próximo da sua previsão baseada em modelo. Este algoritmo simples é chamado de regressão k-nearest neighbors (neste exemplo, k = 3). Para substituir o modelo de regressão linear com a regressão k-nearest neighbors no código anterior, simplesmente substitua esta linha: por esta: model = sklearn. linear_model. Linear Regression() model = sklearn. neighbors. KNeighbors Regressor(n_neighbors=3) CG_MIOLO_Hands_On_Machine_Learning. indb 22 07/05/2019 17:07:57 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
Principais Desafios do Aprendizado de Máquina | 23Se tudo correu bem, seu modelo fará boas previsões. Caso contrário, talvez seja necessário utilizar mais atributos (taxa de emprego, saúde, poluição do ar, etc. ), obter mais ou melhor qualidade dos dados de treinamento, ou talvez selecionar um modelo mais poderoso (por exemplo, um modelo de Regressão Polinomial). Em resumo: V oc ê estudou os dados; Sele cionou um modelo; Tre inou-o com os dados de treinamento (ou seja, o algoritmo de aprendizado pro-curou os valores dos parâmetros do modelo que minimizam uma função de custo); Fin almente, você aplicou o modelo para fazer previsões em novos casos (isto é chamado de Inferência ), na expectativa de que esse modelo generalize bem. Um projeto típico de Aprendizado de Máquina é assim. No Capítulo 2, você experimen-tará isso em primeira mão, de ponta a ponta em um projeto. Já caminhamos muito até aqui: agora você já sabe o que é realmente o Aprendizado de Máquina, por que ele é útil, quais são algumas das categorias mais comuns de sistemas do AM e como é um fluxo de trabalho típico do projeto. Agora, veremos o que pode dar errado no aprendizado e impedir que você faça previsões precisas. Principais Desafios do Aprendizado de Máquina Em suma, uma vez que a sua tarefa principal é selecionar um algoritmo de aprendizado e treiná-lo em alguns dados, as duas coisas que podem dar errado são: “ algoritmos ruins” e “dados ruins”. Comecemos com exemplos de dados ruins. Quantidade Insuficiente de Dados de Treinamento Para que uma criança aprenda o que é uma maçã, é preciso que você aponte para uma maçã e diga “maçã” (possivelmente repetindo algumas vezes esse procedimento). Agora, a criança consegue reconhecer maçãs em todos os tipos de cores e formas. Genial. O Aprendizado de Máquina ainda não está lá; é preciso uma grande quantidade de dados para que a maioria dos algoritmos de Aprendizado de Máquina funcione corretamente. Você precisará de milhares de exemplos mesmo para problemas muito simples, e para problemas complexos, como reconhecimento de imagem ou da fala, precisará de milhões de exemplos (a menos que possa reutilizar partes de um modelo existente). CG_MIOLO_Hands_On_Machine_Learning. indb 23 07/05/2019 17:07:57 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
24 | Capítulo 1: O Cenário do Aprendizado de Máquina A Eficácia Não Razoável dos Dados Em um artigo famoso ( http://goo. gl/R5en IE ) publicado em 2001, os pesquisadores da Microsoft Michele Banko e Eric Brill mostraram que, uma vez que dados suficientes foram fornecidos, algoritmos do aprendizado de máquina muito diferentes, mesmo os mais simples, tiveram um desempenho quase idêntico em um problema complexo de desambiguação8 (como você pode ver na Figura 1-20). Baseado em Memória Winnow Perceptron Naive Bayes Milhões de Palavras Teste de Precisão Figura 1-20. A importância dos dados versus algoritmos9 Como os autores afirmam: “esses resultados sugerem que talvez possamos reconsiderar o cus-to-benefício entre gastar tempo e dinheiro no desenvolvimento de algoritmos ou gastá-los no desenvolvimento de corpus. ” A ideia de que, para problemas complexos, os dados são mais importantes do que algorit-mos foi popularizada por Peter Norvig et al. em um artigo intitulado “The Unreasonable Effectiveness of Data” [“ A Eficácia Não Razoável dos Dados”, em tradução livre] ( http:// goo. gl/q6La Z8 ) publicado em outubro de 2009. 10 No entanto, vale notar que os conjuntos de dados de pequenas e médias dimensões ainda são muito comuns e nem sempre é fácil ou barato obter dados extras de treinamento, então não abandone os algoritmos ainda. 8 Por exemplo, em inglês, saber quando escrever "to", "two", ou "too" dependendo do contexto. 9 Figura reproduzida com permissão de Banko e Brill (2001), “Learning Curves for Confusion Set Disambiguation”. 10 “The Unreasonable Effectiveness of Data” Peter Norvig et al. (2009). CG_MIOLO_Hands_On_Machine_Learning. indb 24 07/05/2019 17:07:57 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
Principais Desafios do Aprendizado de Máquina | 25Dados de Treinamento Não Representativos A fim de generalizar bem, é crucial que seus dados de treinamento sejam representati-vos dos novos casos para os quais você deseja generalizar, não importa se você utiliza o aprendizado baseado em instâncias ou o aprendizado baseado em modelo. Por exemplo, o conjunto de países que utilizamos anteriormente para treinar o modelo linear não era perfeitamente representativo; faltavam alguns países. A Figura 1-21 mostra como ficam os dados quando os países que faltam são adicionados. Noruega Suíça Luxemburgo Satisfação de vida PIB per capita Brasil Méxic o Chile República Checa República Checa Chile Méxic o Brasil Figura 1-21. Uma amostra de treinamento mais representativa Se você treinar um modelo linear nesses dados, obterá a linha sólida, enquanto o modelo antigo está representado pela linha pontilhada. Como pode ser observado, adicionar alguns países faltantes não só altera significativamente o modelo, como deixa claro que um modelo linear tão simples provavelmente nunca funcionará bem. Parece que países muito ricos não são mais felizes do que países moderadamente ricos (na verdade, parecem mais infelizes) e, inversamente, alguns países pobres parecem ser mais felizes do que muitos países ricos. Ao utilizar um conjunto de treinamento não representativo, treinamos um modelo que dificilmente fará previsões precisas, especialmente para países muito pobres e muito ricos. É crucial utilizar um conjunto de treinamento representativo nos casos em que desejamos generalizar. Isso pode ser mais difícil do que parece: se a amostra for muito pequena, existirá um ruído de amostragem (ou seja, dados não representativos como resultado do acaso), mas mesmo as amostras muito grandes podem não ser representativas se o método de amostragem for falho. Isso é chamado de viés de amostragem. Um exemplo famoso de Viés de Amostragem Talvez o exemplo mais famoso de viés de amostragem tenha acontecido durante as eleições presidenciais dos EUA em 1936, na disputa de Landon contra Roosevelt: a Literary Digest con-duziu uma grande pesquisa enviando cartas pelo correio para cerca de 10 milhões de pessoas. Obteve um retorno de 2,4 milhões de respostas e previu com grande confiança que Landon deveria obter 57% dos votos. CG_MIOLO_Hands_On_Machine_Learning. indb 25 07/05/2019 17:07:57 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
26 | Capítulo 1: O Cenário do Aprendizado de Máquina Mas, na verdade, Roosevelt venceu as eleições com 62% dos votos. A falha aconteceu no mé-todo de amostragem da Literary Digest : Em pr imeiro lugar, ao obter os endereços para o envio das pesquisas, a Literary Digest utilizou listas telefônicas, de assinantes, de membros de clubes, dentre outras. Todas essas listas tendem a favorecer pessoas mais ricas, mais propensas a votar em republi-canos (daí Landon). Em se gundo lugar, menos de 25% das pessoas responderam à enquete. Novamente, ao descartar pessoas que não se importam muito com a política, pessoas que não gostam da Literary Digest e outros grupos-chave, é introduzido um viés de amostragem, chamado de viés de falta de resposta. Aqui temos outro exemplo: digamos que você deseja criar um sistema para o reconhe-cimento de vídeos de música funk. Uma forma de construí-lo seria pesquisar “música funk” no Y ou Tube e utilizar os vídeos resultantes. Mas isso pressupõe que o mecanismo de pesquisa do Y ou Tube retornará um conjunto de vídeos que representa todos os vídeos de música no Y ou Tube. Provavelmente, os artistas populares terão resultados tenden-ciosos na pesquisa (e, se você mora no Brasil, receberá muitos vídeos de “funk carioca” que não se parecem nada com James Brown). Por outro lado, de que outra forma você consegue obter um grande conjunto de treinamento? Dados de Baixa Qualidade Obviamente, se seus dados de treinamento estiverem cheios de erros, outliers e ruídos (por exemplo, devido a medições de baixa qualidade), o sistema terá mais dificuldade para detectar os padrões subjacentes, portanto, menos propício a um bom funciona-mento. Muitas vezes vale a pena perder um tempo limpando seus dados de treinamento. A verdade é que a maioria dos cientistas de dados gasta uma parte significativa de seu tempo fazendo exatamente isso. Por exemplo: Se al gumas instâncias são claramente outliers, isso pode ajudar a descartá-las ou tentar manualmente a correção dos erros; Se fa ltam algumas características para algumas instâncias (por exemplo, 5% dos seus clientes não especificaram sua idade), você deve decidir se deseja ignorar completa-mente esse atributo, se deseja ignorar essas instâncias, preencher os valores ausentes (por exemplo, com a média da idade), ou treinar um modelo com a característica e um modelo sem ela, e assim por diante. CG_MIOLO_Hands_On_Machine_Learning. indb 26 07/05/2019 17:07:57 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
Principais Desafios do Aprendizado de Máquina | 27Características Irrelevantes Como diz o ditado: entra lixo, sai lixo. Seu sistema só será capaz de aprender se os dados de treinamento contiverem características relevantes suficientes e poucas características irrelevantes. Uma parte crítica do sucesso de um projeto de Aprendizado de Máquina é criar um bom conjunto de características para o treinamento, processo chamado de feature engeneering que envolve: Seleção das características : selecionar as mais úteis para treinar entre as existentes; Extração das características : combinar características existentes para produzir uma mais útil (como vimos anteriormente, os algoritmos de redução de dimen-sionalidade podem ajudar); Criação de novas características ao coletar novos dados. Agora que examinamos vários exemplos ruins de dados, vejamos alguns exemplos ruins de algoritmos. Sobreajustando os dados de treinamento Digamos que você está visitando um país estrangeiro e o taxista o rouba. Você é tentado a dizer que todos os motoristas de táxi nesse país são ladrões. Generalizar é algo que nós humanos fazemos com muita frequência e, infelizmente, as máquinas podem cair na mesma armadilha se não tivermos cuidado. No Aprendizado de Máquina, isso é chamado de sobreajuste : significa que o modelo funciona bem nos dados de treinamento, mas não generaliza tão bem. A Figura 1-22 mostra um exemplo de um modelo polinomial de satisfação de vida de alto grau que se sobreajusta fortemente nos dados de treinamento. Você realmente confiaria em suas previsões, se o seu desempenho é muito melhor em dados de treinamento do que no modelo linear simples? Satisfação de vida PIB per capita Figura 1-22. Sobreajustando nos dados de treinamento CG_MIOLO_Hands_On_Machine_Learning. indb 27 07/05/2019 17:07:57 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
28 | Capítulo 1: O Cenário do Aprendizado de Máquina Modelos complexos como redes neurais profundas podem detectar padrões sutis nos dados, mas se o conjunto de treinamento é ruidoso ou se é muito pequeno (o que intro-duz ruído na amostragem), então o modelo provavelmente detectará padrões no próprio ruído. É óbvio que esses padrões não serão generalizados para novas instâncias. Por exemplo, digamos que você alimenta o seu modelo de satisfação de vida com muitos outros atributos, incluindo alguns não informativos, como o nome do país. Nesse caso, um modelo complexo poderia detectar padrões como o fato de que todos os países com um W em seu nome em inglês têm uma satisfação de vida superior a 7: New Zealand (7,3), Norway (7,4), Sweden (7,2) e Switzerland (7,5). Você confiaria nesta regra que também generalizará para países como Rwanda ou Zimbabwe? É evidente que esse padrão nos dados ocorreu por acaso, mas o modelo não tem como saber se um padrão é real ou simplesmente resultado de ruído nos dados. O sobreajuste acontece quando o modelo é muito complexo em rela-ção à quantidade e ao ruído dos dados de treinamento. As possíveis soluções são: Simplificar o modelo ao selecionar um com menos parâmetros (por exemplo, um modelo linear em vez de um modelo polino-mial de alto grau), reduzindo o número de atributos nos dados de treinamento ou restringindo o modelo; Col etar mais dados de treinamento; Red uzir o ruído nos dados de treinamento (por exemplo, corrigir erros de dados e remover outliers). Chamamos de regularização quando restringimos um modelo para simplificar e reduzir o risco de sobreajuste. Por exemplo, o modelo linear que definimos anteriormente possui dois parâmetros, θ 0 e θ1. Isso dá ao algoritmo de aprendizado dois graus de liberdade para adaptar o modelo aos dados de treinamento: ele pode ajustar tanto a altura ( θ0) quanto a inclinação ( θ1) da linha. Se forçássemos θ 1 = 0 o algoritmo teria apenas um grau de liberdade e teria muito mais dificuldade para ajustar os dados corretamente: ele apenas poderia mover a linha para cima ou para baixo para chegar o mais próximo possível das instâncias de treinamento e finalizar em torno da média. Este é um modelo muito simples! Mas, se permitirmos que o algoritmo modifique θ 1 e forçarmos para que ele se mantenha reduzido, então o algoritmo efetivamente terá algo entre um e dois graus de liberdade. Ele produzirá um modelo mais simples do que aquele com dois graus de liberdade, mas mais complexo do que o modelo com apenas um. Queremos encontrar o equilíbrio certo entre o ajuste perfeito dos dados e a necessidade de manter o modelo simples o suficiente para garantir que ele generalize bem. CG_MIOLO_Hands_On_Machine_Learning. indb 28 07/05/2019 17:07:58 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
Principais Desafios do Aprendizado de Máquina | 29A Figura 1-23 mostra três modelos: a linha pontilhada representa o modelo original que foi treinado com poucos países, a linha tracejada é o nosso segundo modelo trei-nado com todos os países, e a linha sólida é um modelo linear treinado com os mes-mos dados do primeiro modelo, mas com uma restrição de regularização. Veja que a regularização forçou o modelo a ter uma inclinação menor, o que faz com que tenha um ajuste menor dos dados no modelo treinado mas, na verdade, permite generalizar melhor em novos exemplos. Satisfação de vida PIB per capita Modelo linear em todos os dados Modelo linear em dados parciais Modelo linear regularizado em dados parciais Figura 1-23. A regularização reduz o risco de sobreajustes A quantidade de regularização a ser aplicada por um hiperparâmetro durante o apren-dizado pode ser controlada. Um hiperparâmetro é um parâmetro de um algoritmo de aprendizado (não do modelo). Como tal, não é afetado pelo próprio algoritmo de apren-dizado; deve ser definido antes do treinamento e permanecer constante durante ele. Se você configurar o hiperparâmetro de regularização para um valor muito alto, obterá um modelo quase plano (uma inclinação próxima a zero); o algoritmo de aprendizado certamente não se sobreajustará nos dados de treinamento, mas terá menos chances de encontrar uma boa solução. O ajuste dos hiperparâmetros é uma parte importante da construção de um sistema de Aprendizado de Máquina (você verá um exemplo detalhado no próximo capítulo). Subajustando os dados de Treinamento Como você pode ver, subajuste é o oposto de sobreajuste: ocorre quando seu modelo é muito simples para o aprendizado da estrutura subjacente dos dados. Por exemplo, um modelo linear de satisfação de vida é propenso a ser subajustado; a realidade é mais complexa do que o modelo, por isso suas previsões tendem a ser imprecisas mesmo nos exemplos de treinamento. As principais opções para resolver esses problemas são: Selecionar um modelo mais poderoso, com mais parâmetros; CG_MIOLO_Hands_On_Machine_Learning. indb 29 07/05/2019 17:07:58 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
30 | Capítulo 1: O Cenário do Aprendizado de Máquina Alimentar o algoritmo de aprendizado com melhores características ( fe ature engineering ); Red uzir as restrições no modelo (por exemplo, reduzindo o hiperparâmetro de regularização). Voltando Atrás Agora você já sabe muito sobre o Aprendizado de Máquina. No entanto, passamos por tantos conceitos que você pode estar se sentindo um pouco perdido, então vamos dar um passo atrás e olhar para o quadro geral: Apr endizado de Máquina é fazer com que as máquinas evoluam em algu-mas tarefas aprendendo com os dados, em vez de ter que programar as regras explicitamente; Exi stem muitos tipos diferentes de sistemas do AM: supervisionados ou não, em lote ou online, baseados em instâncias ou em modelos, e assim por diante; Em u m projeto do AM, você coleta dados em um conjunto de treinamento e os for-nece para um algoritmo de aprendizado. Se o algoritmo estiver baseado em modelo, ele ajusta alguns parâmetros para adequar o modelo ao conjunto de treinamento (ou seja, para fazer boas previsões no próprio conjunto de treinamento), e então, se tudo der certo, também poderá fazer boas previsões em novos casos. Se o algoritmo for baseado em instância, ele simplesmente decora os exemplos e utiliza uma medi-da de similaridade generalizando para novas instâncias; O sis tema não terá um bom funcionamento se o seu conjunto de treinamento for muito pequeno ou se os dados não forem representativos, ruidosos ou poluídos com características irrelevantes (entra lixo, sai lixo). Por último, o seu modelo não precisa ser nem simples demais (subajustado) nem muito complexo (superajustado). Abordaremos um último tópico importante: uma vez treinado um modelo, você não vai querer apenas “torcer” para que ele generalize para novos casos. Você vai querer avaliar e ajustar se necessário. Vejamos como. Testando e Validando A única maneira de saber o quão bem um modelo generalizará em novos casos é de fato testá-lo em novos casos. Uma forma de pôr isso em prática é colocar seu modelo em produção e monitorar a qualidade do seu desempenho. Isso funciona bem, mas, se seu modelo for muito ruim, seus usuários se queixarão — e esta não é a melhor ideia. CG_MIOLO_Hands_On_Machine_Learning. indb 30 07/05/2019 17:07:58 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
Testando e Validando | 31Uma opção melhor seria dividir seus dados em dois conjuntos: o conjunto de treinamento e o conjunto de teste. Como esses nomes implicam, você treina seu modelo utilizando o conjunto de treinamento e o testa utilizando o conjunto de teste. A taxa de erro em novos casos é chamada de erro de generalização (ou erro fora da amostra ) e, ao avaliar seu modelo no conjunto de teste, você obtém uma estimativa desse erro. O valor indica se o seu modelo terá um bom funcionamento em instâncias inéditas. Se o erro de treinamento for baixo (ou seja, seu modelo comete alguns erros no conjunto de treinamento), mas seu erro de generalização é alto, isso significa que seu modelo está se sobreajustando aos dados de treinamento. É comum utilizar 80% dos dados para treinamento e reservar 20% para o teste. É muito simples avaliar um modelo: basta utilizar um conjunto de teste. Agora, suponha que você hesite entre dois modelos (digamos um modelo linear e um modelo polinomial): como decidir? Uma opção será treinar ambos utilizando o conjunto de teste e comparar se eles generalizam bem. Agora, suponha que o modelo linear generalize melhor, mas você deseja aplicar algu-ma regularização para evitar o sobreajuste. A questão é: como você escolhe o valor do hiperparâmetro de regularização? Uma opção seria treinar 100 modelos diferentes utilizando 100 valores diferentes para este hiperparâmetro. Suponha que você encontre o melhor valor de hiperparâmetro que produza um modelo com o menor erro de gene-ralização, digamos, apenas 5% de erro. Então, você coloca esse modelo em produção, mas infelizmente ele não funciona tão bem quanto o esperado e produz 15% de erros. O que acabou de acontecer? O problema é que você mediu o erro de generalização por várias vezes no conjunto de teste e adaptou o modelo e os hiperparâmetros para produzir o melhor modelo para esse conjunto. Isso significa que o modelo provavelmente não funcionará tão bem com novos dados. Uma solução comum para este problema é ter um segundo conjunto de retenção chamado conjunto de validação. Você treina vários modelos com vários hiperparâmetros utilizando o conjunto de treinamento, seleciona o modelo e os hiperparâmetros que atuam melhor no conjunto de validação, e, quando estiver contente com seu modelo, executa um único teste final no conjunto de teste para obter uma estimativa do erro de generalização. CG_MIOLO_Hands_On_Machine_Learning. indb 31 07/05/2019 17:07:58 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
32 | Capítulo 1: O Cenário do Aprendizado de Máquina Para evitar “desperdiçar” muitos dados de treinamento em conjuntos de validação, uma técnica comum é utilizar a validação cruzada: o conjunto de treinamento é dividido em subconjuntos complementares e cada modelo é treinado com uma combinação diferente desses subconjuntos e validado em relação às partes restantes. Uma vez selecionados o tipo de modelo e os hiperparâmetros, um modelo final é treinado com a utilização desses hiperparâmetros no conjunto completo de treinamento e o erro generalizado é medido no conjunto de testes. Teorema do Não Existe Almoço Grátis Um modelo é uma versão simplificada das observações. As simplificações destinam-se a descartar os detalhes supérfluos que provavelmente não serão generalizados em novas instâncias. No entanto, para decidir quais dados descartar e quais manter, você deve fazer suposições. Por exemplo, um modelo linear supõe que os dados são fundamentalmente lineares e que a distância entre as instâncias e a linha reta é apenas o ruído, que pode ser ignorado com segurança. Em um famoso artigo de 1996 (https://goo. gl/dzp946), 11 David Wolpert demonstrou que, se você não fizer suposição alguma sobre os dados, então não há motivo para preferir um ou outro modelo. Isso é chamado de Teorema do Não existe almoço grátis (NFL, do inglês "no free lunch"). Para alguns conjuntos de dados, o melhor modelo é um modelo linear, enquanto para outros conjuntos será uma rede neural. Não existe um modelo que tenha a garantia de fun-cionar melhor a priori (daí o nome do teorema). A única maneira de saber com certeza qual seria o melhor modelo é a avaliação de todos. Como isso não é possível, na prática você parte de alguns pressupostos razoáveis sobre os dados e avalia apenas alguns modelos razoáveis. Por exemplo, para tarefas simples, você pode avaliar modelos lineares com vários níveis de regula-rização e, para um problema complexo, você pode avaliar várias redes neurais. Exercícios Neste capítulo, abordamos alguns dos conceitos mais importantes do Aprendizado de Máquina. Nos próximos, vamos mergulhar mais fundo e escrever mais código, mas, antes disso, certifique-se de responder as seguintes perguntas: 1. Com o você definiria o Aprendizado de Máquina? 2. Voc ê saberia nomear quatro tipos de problemas nos quais o AM se destaca? 3. O que é u m conjunto de treinamento rotulado? 4. Qua is são as duas tarefas supervisionadas mais comuns? 5. Voc ê consegue nomear quatro tarefas comuns sem supervisão? 11 “The Lack of A Priori Distinctions Between Learning Algorithms”, D. Wolperts (1996). CG_MIOLO_Hands_On_Machine_Learning. indb 32 07/05/2019 17:07:58 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
Exercícios | 336. Que tipo de algoritmo de Aprendizado de Máquina você utilizaria para permitir qu e um robô ande em vários terrenos desconhecidos? 7. Que ti po de algoritmo você utilizaria para segmentar seus clientes em vários grupos? 8. Voc ê enquadraria o problema da detecção de spam como um problema de aprendizado supervisionado ou sem supervisão? 9. O que é u m sistema de aprendizado online? 10. O que é o out-of-core learning ? 11. Que t ipo de algoritmo de aprendizado depende de uma medida de similaridade para fazer previsões? 12. Qua l a diferença entre um parâmetro de modelo e o hiperparâmetro do algoritmo de aprendizado? 13. O que o s algoritmos de aprendizado baseados em modelos procuram? Qual é a estratégia mais comum que eles utilizam para ter sucesso? Como fazem previsões? 14. Voc ê pode citar quatro dos principais desafios no Aprendizado de Máquina? 15. Se o seu m odelo é ótimo nos dados de treinamento, mas generaliza mal para no-vas instâncias, o que está acontecendo? Você pode nomear três soluções possíveis? 16. O que é u m conjunto de testes e por que você o utilizaria? 17. Qua l é o propósito de um conjunto de validação? 18. O que p ode dar errado se você ajustar os hiperparâmetros utilizando o conjunto de teste? 19. O que é v alidação cruzada e por que você preferiria usá-la ao invés de um conjunto de validação? As soluções para estes exercícios estão disponíveis no Apêndice A. CG_MIOLO_Hands_On_Machine_Learning. indb 33 07/05/2019 17:07:58 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
CG_MIOLO_Hands_On_Machine_Learning. indb 34 07/05/2019 17:07:58 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
35Capítulo 2 Projeto de Aprendizado de Máquina de Ponta a Ponta Neste capítulo você verá um exemplo de projeto de ponta a ponta na pele de um cientista de dados recentemente contratado por uma empresa do mercado imobiliário. 1 Você seguirá estes principais passos: 1. Olh ar para o quadro geral; 2. Obter o s dados; 3. Des cobrir e visualizar os dados para obter informações; 4. Pre parar os dados para os algoritmos do Aprendizado de Máquina; 5. Sele cionar e treinar um modelo; 6. Aju star o seu modelo; 7. Apre sentar sua solução; 8. Lan çar, monitorar e manter seu sistema. Trabalhando com Dados Reais É melhor experimentar com dados do mundo real e não apenas conjuntos de dados arti-ficiais ao estudar Aprendizado de Máquina. Felizmente, existem milhares de conjuntos de dados disponíveis a sua escolha, variando em todos os tipos de domínios. Você pode procurar em muitos lugares, tais quais: Rep ositórios Populares de open data : —UC Ir vine Machine Learning Repository ( http://archive. ics. uci. edu/ml/ ) 1 Este exemplo de projeto é completamente fictício. O objetivo é apenas ilustrar os níveis principais de um projeto de Aprendizado de Máquina, não aprender sobre o mercado imobiliário. CG_MIOLO_Hands_On_Machine_Learning. indb 35 07/05/2019 17:07:58 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
36 | Capítulo 2: Projeto de Aprendizado de Máquina de Ponta a Ponta —Conjunto de dados no Kaggle ( ht tps://www. kaggle. com/datasets ) —Con junto de Dados no AWS da A ma zon ( http://aws. amazon. com/fr/datasets/ ) Met a portais (eles listam repositórios open data ): —htt p://dataportals. org/ —htt p://opendatamonitor. eu/ —htt p://quandl. com/ Out ras páginas que listam muitos repositórios populares de open data : —Lista de conjuntos de dados de Aprendizado de Máquina do Wikipedia (https:// goo. gl/SJHN2k ) —Per gunta no Quora. com ( http://goo. gl/z DR78y ) —Con juntos de dados no Reddit ( https://www. reddit. com/r/datasets ) Neste capítulo, escolhemos o conjunto de dados do repositório Stat Lib referente a pre-ços do setor imobiliário na Califórnia2 (veja a Figura 2-1). Este conjunto de dados foi baseado no censo de 1990 na Califórnia. Não são dados recentes (naquela época, ainda era possível comprar uma casa agradável perto da Baía de São Francisco), mas possuem muitas qualidades para o aprendizado, então vamos fingir que são dados recentes. Também adicionamos um atributo categórico e removemos algumas características para fins de ensino. Latitude Longitude População Valor Médio das Casas Figura 2-1. Preços de casas na Califórnia 2 O conjunto de dados original figurou em R. Kelley Pace Ronald Barry, “Sparse Spatial Autoregressions”, Statistics & Probability Letters 33, nº 3 (1997): 291-297. CG_MIOLO_Hands_On_Machine_Learning. indb 36 07/05/2019 17:07:58 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
Um Olhar no Quadro Geral | 37Um Olhar no Quadro Geral Bem-vindo à Machine Learning Housing Corporation! A primeira tarefa que você executará será construir um modelo de preços do setor imobiliário utilizando os dados do censo da Califórnia. Esses dados têm métricas como população, renda média, preço médio do setor imobiliário e assim por diante para cada grupo de bairros. Os grupos de bairros são a menor unidade geográfica para a qual o US Census Bureau publica dados de amostra (um grupo de bairros geralmente tem uma população de 600 a 3 mil pessoas). Para abreviar, os chamaremos de “bairros”. Seu modelo deve aprender com esses dados e ser capaz de prever o preço médio em qualquer bairro, considerando todas as outras métricas. Como um cientista de dados bem organizado, a primeira coisa a fa-zer é obter sua lista de verificação do projeto. Você pode começar com a lista do Apêndice B, que deve funcionar razoavelmente bem para a maioria dos projetos de Aprendizado de Máquina, mas asse-gure-se de adaptá-la às suas necessidades. Neste capítulo, passaremos por muitos itens da lista de verificação, mas também ignoraremos alguns porque eles são autoexplicativos ou porque serão discutidos em capítulos posteriores. Enquadre o Problema A primeira pergunta a ser feita ao seu chefe é: qual é exatamente o objetivo comercial? Provavelmente construir um modelo não será o objetivo final. Como a empresa espera usar e se beneficiar deste modelo? Isso é importante porque determinará como você en-quadrará o problema, quais algoritmos selecionará, que medida de desempenho utilizará para avaliar seu modelo e quanto esforço você deve colocar nos ajustes. Seu chefe responde que o resultado do seu modelo (uma previsão do preço médio do setor imobiliário no bairro) será enviado para outro sistema de Aprendizado de Máquina (veja a Figura 2-2), juntamente com muitos outros sinais. 3 Esse sistema de downstream deter-minará se vale a pena investir em uma determinada área ou não. É fundamental acertar nessa etapa, uma vez que afetará diretamente a receita. 3 Dados fornecidos para um sistema de Aprendizado de Máquina são chamados de sinais em referência à teoria da informação de Shannon: você quer que a proporção sinal/ruído seja alta. CG_MIOLO_Hands_On_Machine_Learning. indb 37 07/05/2019 17:07:58 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
38 | Capítulo 2: Projeto de Aprendizado de Máquina de Ponta a Ponta Seu componente Outros sinais Preços do Bairro Investimento s Análise de Investimento Dados do Bairroascendente s Componente s Preços do Bairro Figura 2-2. Um pipeline de Aprendizado de Máquina para investimentos imobiliários Pipelines Uma sequência de componentes de processamento de dados é chamada de pipeline de dados. Os pipelines são muito comuns em sistemas do Aprendizado de Máquina, uma vez que exis-tem muitos dados para manipular e muitas transformações para aplicar neles. Os componentes normalmente rodam de forma assíncrona. Cada componente puxa uma grande quantidade de dados, os processa e envia o resultado para outro armazenador dados, e então, algum tempo depois, o próximo componente no pipeline puxa esses dados e envia sua própria saída, e assim por diante. Cada componente é bastante autônomo: a interface entre os componentes é simplesmente o armazenamento de dados. Isso faz com que entender o siste-ma seja bastante simples (com a ajuda de um grafo do fluxo de dados), e diferentes equipes podem se concentrar em diferentes componentes. Além disso, se um componente se romper, os componentes de downstream geralmente continuam a funcionar normalmente (pelo me-nos por um tempo), utilizando apenas a última saída do componente rompido. Isso torna a arquitetura bastante robusta. Por outro lado, se um monitoramento adequado não for implementado, um componente rompido pode passar despercebido por algum tempo. Os dados ficarão obsoletos e o desem-penho geral do sistema decairá. A próxima pergunta a ser feita é: qual é a solução no momento (se houver)? Muitas vezes a resposta lhe dará um desempenho de referência, bem como informações sobre como resolver o problema. Seu chefe responde que os preços das casas nos bairros são estimados manualmente por especialistas: uma equipe reúne informações atualizadas sobre um bairro e, quando não conseguem obter o preço médio, o estimam utilizando regras complexas. Este processo é caro e demorado, e suas estimativas não são boas; nos casos em que conseguem descobrir o preço médio real do setor imobiliário, geralmen-te percebem que suas estimativas ficaram mais de 10% abaixo do valor. É por isso que a empresa acha útil treinar um modelo a partir de outros dados sobre esse bairro para prever o preço médio do setor imobiliário. Os dados do recenseamento CG_MIOLO_Hands_On_Machine_Learning. indb 38 07/05/2019 17:07:59 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
Um Olhar no Quadro Geral | 39parecem um ótimo conjunto de dados para serem explorados com este propósito, pois incluem os preços médios de milhares de bairros, bem como outros dados. Bem, com toda essa informação você já está pronto para começar a projetar seu sistema. Primeiro, você precisa enquadrar o problema: será supervisionado, sem supervisão ou um Aprendizado por Reforço? Será uma tarefa de classificação, de regressão ou outra coisa? Você deve utilizar técnicas de aprendizado em lote ou online? Antes de ler, pause e tente responder para si estas perguntas. Você encontrou as respostas? Vamos ver: claramente temos uma tarefa típica de aprendi-zado supervisionado, uma vez que você recebe exemplos rotulados de treinamento (cada instância vem com o resultado esperado, ou seja, o preço médio do setor imobiliário do bairro). Além disso, também é uma tarefa típica de regressão, já que você é solicitado a prever um valor. Mais especificamente, trata-se de um problema de regressão multiva-riada, uma vez que o sistema utilizará múltiplas características para fazer uma previsão (ele usará a população do bairro, a renda média, etc. ). No primeiro capítulo, você previu níveis de satisfação de vida com base em apenas uma característica, o PIB per capita, de modo que era um problema de regressão univariante. Finalmente, não há um fluxo con-tínuo de dados entrando no sistema, não há uma necessidade em especial de se ajustar rapidamente à mudança de dados, e os dados são pequenos o suficiente para caber na memória, de modo que o aprendizado simples em lote deve funcionar bem. Se os dados fossem enormes, você poderia dividir seu trabalho de aprendizado em lotes em vários servidores (utilizando a técnica Map Reduce, como veremos mais adiante), ou poderia utilizar uma técnica de aprendizado online. Selecione uma Medida de Desempenho Seu próximo passo é selecionar uma medida de desempenho. Uma medida típica de desempenho para problemas de regressão é a Raiz do Erro Quadrático Médio (sigla RMSE, em inglês). Ela dá uma ideia da quantidade de erros gerados pelo sistema em suas previsões, com um peso maior para grandes erros. A Equação 2-1 mostra a fórmula matemática para calcular a RMSE. Equação 2-1. Raiz do Erro Quadrático Médio (RMSE) RMSE X,h=1 m∑ i=1m hxi-yi2 CG_MIOLO_Hands_On_Machine_Learning. indb 39 07/05/2019 17:07:59 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
40 | Capítulo 2: Projeto de Aprendizado de Máquina de Ponta a Ponta4z Notações Esta equação apresenta vários apontamentos muito comuns do Aprendizado de Máquina que usaremos ao longo deste livro: m é o núm ero de instâncias no conjunto de dados no qual você está medindo o RMSE. —Por exemplo, se estiver avaliando o RMSE em um conjunto de validação de 2 mil bairros, então m = 2 mil. x(i) é um vetor de todos os valores da característica (excluindo o rótulo ) da i-ésima instância conjunto de dados, e y(i) é seu rótulo (o valor desejado da saída para aquela instância). —Por exemplo, se o primeiro bairro no conjunto de dados estiver localizado na longitude-118,29°, latitude 33,91°, e ele tem 1. 416 habitantes com uma renda média de US$ 38. 372, e o valor médio da casa é de US$ 156. 400 (ignorando as outras características por ora), então, x1=-118,29 33,91 1416 38372 e y (1) = 156. 400 X é uma matriz que contém todos os valores da característica (excluindo rótulos) de todas as instâncias no conjunto de dados. Existe uma linha por instância e a i-ésima linha é igual a transposição de x(i), notado por ( x(i))T. 4 —Por exemplo, se o primeiro bairro for conforme descrito, então a matriz X fica assim: X=x1T x2T x1999 T x2000 T=-118,2 933,91 1416 38372 h é a função de previsão do seu sistema, também chamada de hipótese. Qu ando seu sis-tema recebe o vetor x(i) da característica de uma instância, ele exibe um valor previsto ŷ(i) = h(x(i)) para aquela instância ( ŷ se pronuncia “y-chapéu”). 4 Lembre-se de que o operador de transposição vira um vetor de coluna em um vetor de linha (e vice-versa). CG_MIOLO_Hands_On_Machine_Learning. indb 40 07/05/2019 17:07:59 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
Um Olhar no Quadro Geral | 41 —Por exemplo, se o seu sistema prevê que o preço médio no primeiro bairro é de US $ 158. 400, então ŷ(1) = h(x(1)) = 158. 400. A previsão de erro para este bairro é ŷ(1)-y(1) = 2. 000. RMSE( X,h) é a função de custo medida no conjunto de exemplos utilizando sua hipótese h. Usamos a fonte em itálico e caixa baixa para valores escalares (como m ou y(i)) e nomes de funções (como h), fonte em negrito e caixa baixa para vetores (como x(i)) e em negrito e caixa alta para matrizes (como X ). Embora a RMSE seja geralmente a medida de desempenho preferencial para tarefas de regressão, em alguns contextos você pode preferir utilizar outra função. Por exemplo, suponha que existam vários bairros outliers. Nesse caso, você pode considerar usar o Erro Médio Absoluto (sigla MAE, em inglês) (também chamado de Desvio Médio Ab-soluto; ver Equação 2-2): Equação 2-2. Erro Médio Absoluto MAE X,h=1 m∑ i=1m hxi-yi Tanto a RMSE quanto o MAE são formas de medir a distância entre dois vetores: o vetor das previsões e o vetor dos valores alvo. Várias medidas de distância, ou normas, são possíveis: Cal cular a raiz de uma soma de quadrados (RMSE) corresponde à norma eucli-diana: é a noção de distância que você conhece. Também chamado de norma ℓ2, notado por ∥ · ∥2 (ou apenas ∥ · ∥). Cal cular a soma de absolutos (MAE) corresponde à norma ℓ1, notado por ∥ · ∥1. Às vezes é chamado de norma Manhattan porque mede a distância entre dois pontos em uma cidade, se você só puder viajar ao longo de bairros ortogonais da cidade. Mai s genericamente, a norma ℓ k de um vetor v que contém n elementos é defi-nida como k=v0k+v1k+... +vnk1 k ∥ v ∥ · ℓ 0 apenas dá o número de elementos diferentes de zero no vetor, e ℓ∞ dá o valor máximo absoluto no vetor. Qua nto maior o índice da norma, mais ela se concentra em grandes valores e ne-gligencia os pequenos. É por isso que a RMSE é mais sensível a outliers do que o MAE. Mas, quando os outliers são exponencialmente raros (como em uma curva em forma de sino), a RMSE funciona muito bem, e geralmente é a preferida. CG_MIOLO_Hands_On_Machine_Learning. indb 41 07/05/2019 17:08:00 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
42 | Capítulo 2: Projeto de Aprendizado de Máquina de Ponta a Ponta Verifique as Hipóteses Por último, uma boa prática é listar e verificar as hipóteses que foram feitas até agora (por você ou outros); fica mais fácil pegar problemas sérios logo no início. Por exemplo, os preços dos bairros mostrados pelo seu sistema serão alimentados em um sistema downstream do Aprendizado de Máquina, e assumiremos que esses preços serão usados como tal. Mas, e se o sistema downstream converter os preços em categorias (por exemplo, “barato”, “médio” ou “caro”) e utilizar essas categorias em vez dos próprios preços? Neste caso, não é importante saber o preço exato se o seu sistema só precisa obter a categoria certa. Se for assim, então o problema deveria ter sido enquadrado como uma tarefa de classificação, não uma tarefa de regressão. Você não vai querer descobrir isso após trabalhar por meses em um sistema de regressão. Felizmente, depois de conversar com a equipe responsável pelo sistema downstream, você está confiante de que realmente precisa dos preços reais e não apenas das categorias. Ótimo! Você está pronto, as luzes estão verdes e você pode começar a programar agora! Obtenha os Dados É hora de colocar as mãos na massa. Não hesite em pegar seu laptop e acompanhar os seguintes exemplos de código em um notebook do Jupyter, que está disponível na íntegra em https://github. com/ageron/handson-ml. Crie o Espaço de Trabalho Primeiro, você precisará ter o Python instalado. Provavelmente ele já está instalado em seu sistema. Caso contrário, você pode baixá-lo em https://www. python. org/. 5 Em seguida, crie um diretório de trabalho para seu código e conjuntos de dados do Aprendizado de Máquina. Abra um terminal e digite os seguintes comandos (após o prompts $): $ export ML_PATH="$HOME/ml" # Mude o caminho se preferir $ mkdir-p $ML_PATH Você precisará de vários módulos Python: Jupyter, Num Py, Pandas, Matplotlib e Scikit-Learn. Se você já tem o Jupyter rodando com todos esses módulos instalados, pode pular com segurança para “Baixe os dados” na página 45. Se você ainda não tem, há várias 5 A versão mais recente do Python 3 é recomendada. O Python 2. 7+ também funcionará bem, mas está obsoleto. Se usar o Python 2, você deve adicionar from_future_import division, print_function, unicode_literals no início do seu código. CG_MIOLO_Hands_On_Machine_Learning. indb 42 07/05/2019 17:08:00 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
Obtenha os Dados | 43maneiras de instalá-los (e suas dependências). Você pode utilizar o sistema de empacota-mento do seu sistema (por exemplo, apt-get no Ubuntu, ou Mac Ports ou Home Brew no mac OS), instale uma distribuição científica do Python, como o Anaconda, e utilize seu sistema de empacotamento, ou utilize o sistema de empacotamento do Python, pip, que está incluído por padrão com os instaladores binários Python (desde a versão Python 2. 7. 9). 6 Você pode verificar se o pip está instalado digitando o seguinte comando: $ pip3--version pip 9. 0. 1 from [... ]/lib/python3. 5/site-packages (python 3. 5) Você deve se certificar de que tenha uma versão recente do pip instalada, pelo menos > 1. 4 para suportar a instalação do módulo binário (também conhecida como wheels). Para atualizar o módulo do pip, digite: 7 $ pip3 install--upgrade pip Collecting pip [... ] Successfully installed pip-9. 0. 1 Criando um Ambiente Isolado Se você quiser trabalhar em um ambiente isolado (o que é fortemente recomendado para que se possa trabalhar em projetos diferentes sem ter versões conflitantes de biblioteca), instale o virtualenv executando o seguinte comando pip: $ pip3 install--user--upgrade virtualenv Collecting virtualenv [... ] Successfully installed virtualenv Agora você pode criar um ambiente Python isolado digitando: $ cd $ML_PATH $ virtualenv env Using base prefix '[... ]' New python executable in [... ]/ml/env/bin/python3. 5 Also creating executable in [... ]/ml/env/bin/python Installing setuptools, pip, wheel... done. Agora, sempre que quiser ativar esse ambiente, basta abrir um terminal e digitar: $ cd $ML_PATH $ source env/bin/activate 6 Mostraremos a seguir os passos para a instalação usando pip em uma bash shell no L inux ou no mac OS. Talvez seja preciso adaptar estes comandos ao seu próprio sistema. Para o Windows, recomendamos a instalação do Anaconda. 7 Talvez seja necessário ter direitos de administrador para usar este comando; se for o caso, tente prefixá-lo com sudo. CG_MIOLO_Hands_On_Machine_Learning. indb 43 07/05/2019 17:08:01 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
44 | Capítulo 2: Projeto de Aprendizado de Máquina de Ponta a Ponta Qualquer pacote que você instalar utilizando pip será instalado neste ambiente isolado enquanto o ambiente estiver ativo, e o Python somente terá acesso a esses pacotes (se você também quiser acesso aos pacotes do sistema no site, deverá criar o ambiente uti-lizando a opção --system-site-packages do virtualenv). Confira a documentação do virtualenv para obter mais informações. Agora você pode instalar todos os módulos necessários e suas dependências utilizando este simples comando pip (se você não estiver utilizando um virtualenv, precisará de direitos de administrador ou adicionar a opção--user ): $ pip3 install--upgrade jupyter matplotlib numpy pandas scipy scikit-learn Collecting jupyter Downloading jupyter-1. 0. 0-py2. py3-none-any. whl Collecting matplotlib [... ] Para verificar sua instalação, tente importar todos os módulos assim: $ python3-c "import jupyter, matplotlib, numpy, pandas, scipy, sklearn" Não deve haver nenhuma saída e nenhum erro. Agora você pode iniciar o Jupyter digitando: $ jupyter notebook [I 15:24 Notebook App] Serving notebooks from local directory: [... ]/ml [I 15:24 Notebook App] 0 active kernels[I 15:24 Notebook App] The Jupyter Notebook is running at: http://localhost:8888/[I 15:24 Notebook App] Use Control-C to stop this server and shut down all kernels (twice to skip confirmation). Um servidor Jupyter está sendo executado agora pela porta 8888 em seu terminal. Você pode visitar este servidor abrindo seu navegador em http://localhost: 8888/ (isso geralmente acontece automaticamente quando o servidor é iniciado). Você deve ver seu diretório de trabalho vazio (contendo apenas o diretório env se você seguiu as instruções anteriores do virtualenv). Agora, crie um novo notebook Python clicando no botão New e selecionando a versão adequada do Python8 (veja a Figura 2-3). Isto faz três coisas: primeiro, cria um novo arquivo notebook chamado Untitled. ipynb em seu espaço de trabalho; segundo, inicia um Jupyter Python kernel para rodar este notebook ; e, terceiro, abre este notebook em uma nova guia. Você deve começar clicando em Untitled e digitando o novo nome, renomeando este notebook para “Housing” (isso mudará o arquivo automaticamente para Housing. ipynb ). 8 Note que o Jupyter pode lidar com várias versões do Python, e até muitas outras linguagens, como R ou Octave. CG_MIOLO_Hands_On_Machine_Learning. indb 44 07/05/2019 17:08:01 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
Obtenha os Dados | 45 Files Running Clusters Logout Sele ct items to per form actions on them. Upload New Text File Folder Terminal Notebooks Octa ve Python 2 Python 3env Figura 2-3. Seu espaço de trabalho no Jupyter Um notebook contém uma lista de células. Cada célula pode conter código executável ou texto formatado. No momento, o notebook contém apenas uma célula de código vazia, rotulada “In [1]:”. Tente digitar print(“Hello world!”) na célula, e clique no botão Reproduzir (veja a Figura 2-4) ou pressione Shift-Enter. Isso envia a célula atual para o kernel Python deste notebook, que o executa e retorna a saída. O resultado é exibido abaixo da célula, e, já que chegamos ao final do notebook, uma nova célula é automaticamente criada. Confira o User Interface Tour no menu de Ajuda do Jupyter para aprender o básico. Housing Figura 2-4. Notebook Python Hello world Baixe os Dados Em ambientes típicos, seus dados estariam disponíveis em um banco de dados relacional (ou algum outro armazenamento comum de dados) e espalhados por várias tabelas/ documentos/arquivos. Para acessá-lo, primeiro você precisaria obter suas credenciais e autorizações9 de acesso e familiarizar-se com o esquema de dados. Neste projeto, no en-tanto, as coisas são muito mais simples: você só vai baixar um único arquivo compactado, 9 Você também pode precisar verificar restrições legais, como campos privados que nunca devem ser copiados para armazenamentos inseguros de dados. CG_MIOLO_Hands_On_Machine_Learning. indb 45 07/05/2019 17:08:02 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
46 | Capítulo 2: Projeto de Aprendizado de Máquina de Ponta a Pontahousing. tgz, que contém um arquivo com valores separados por vírgulas (CSV) chamado housing. csv com todos os dados. Você poderia usar o navegador da Web para baixá-lo e executar o tar xzf housing. tgz para descompactá-lo e extrair o arquivo CSV, mas é preferível criar uma pequena função para fazer isso. Ela será útil, principalmente, se os dados mudarem regularmente, pois permite que você escreva um pequeno script que poderá ser executado sempre que pre-cisar para buscar os dados mais recentes (ou poderá configurar um trabalho agendado para fazer isso automaticamente em intervalos regulares). Também será útil automatizar o processo de busca caso você precise instalar o conjunto de dados em várias máquinas. Esta é a função para buscar os dados:10 import os import tarfile from six. moves import urllib DOWNLOAD_ROOT = "https://raw. githubusercontent. com/ageron/handson-ml/master/" HOUSING_PATH = os. path. join("datasets", "housing") HOUSING_URL = DOWNLOAD_ROOT + "datasets/housing/housing. tgz" def fetch_housing_data(housing_url=HOUSING_URL, housing_path=HOUSING_PATH): if not os. path. isdir(housing_path): os. makedirs(housing_path) tgz_path = os. path. join(housing_path, "housing. tgz") urllib. request. urlretrieve(housing_url, tgz_path) housing_tgz = tarfile. open(tgz_path) housing_tgz. extractall(path=housing_path) housing_tgz. close()import os import tarfile from six. moves import urllib DOWNLOAD_ROOT = "https://raw. githubusercontent. com/ageron/handson-ml/master/" HOUSING_PATH = os. path. join("datasets", "housing") HOUSING_URL = DOWNLOAD_ROOT + "datasets/housing/housing. tgz" def fetch_housing_data(housing_url=HOUSING_URL, housing_path=HOUSING_PATH): if not os. path. isdir(housing_path): os. makedirs(housing_path) tgz_path = os. path. join(housing_path, "housing. tgz") urllib. request. urlretrieve(housing_url, tgz_path) housing_tgz = tarfile. open(tgz_path) housing_tgz. extractall(path=housing_path) housing_tgz. close() Agora, quando chamamos fetch_housing_data(), ele cria um diretório datasets/housing no seu espaço de trabalho, baixa o arquivo housing. tgz e extrai o housing. csv neste diretório. Agora, vamos carregar os dados com o Pandas. Mais uma vez você deve escrever uma pequena função para carregá-los: import pandas as pd def load_housing_data(housing_path=HOUSING_PATH): csv_path = os. path. join(housing_path, "housing. csv") return pd. read_csv(csv_path) Esta função retorna um objeto Data Frame Pandas contendo todos os dados. 10 Em um projeto real, você salvaria este código em um arquivo Python, mas, por enquanto, você pode apenas es crevê-lo no seu notebook do Jupyter. CG_MIOLO_Hands_On_Machine_Learning. indb 46 07/05/2019 17:08:02 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
Obtenha os Dados | 47Uma Rápida Olhada na Estrutura dos Dados Utilizando o método head() do Data Frame, vejamos as cinco linhas superiores (veja Figura 2-5). Figura 2-5. As cinco linhas superiores no conjunto de dados Cada linha representa um bairro. Existem 10 atributos (você pode ver os primeiros seis na captura de tela): longitude, latitude, housing_median_age, total_rooms, total_bed rooms, population, households, median_income, median_house_value e ocean_proximity. O método info() é útil para a obtenção de uma rápida descrição dos dados, em especial o número total de linhas, o tipo de cada atributo e o número de valores não nulos (veja a Figura 2-6). Figura 2-6. Informações das Casas Existem 20. 640 instâncias no conjunto de dados, o que significa que é muito pequeno para os padrões de Aprendizado de Máquina, mas é perfeito para começar. Repare que o atributo total_bedrooms tem apenas 20. 433 valores não nulos, significando que 207 bairros não possuem esta característica. Cuidaremos disso mais tarde. CG_MIOLO_Hands_On_Machine_Learning. indb 47 07/05/2019 17:08:02 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
48 | Capítulo 2: Projeto de Aprendizado de Máquina de Ponta a Ponta Todos os atributos são numéricos, exceto o campo ocean_proximity. Seu tipo é object, então ele poderia conter qualquer tipo de objeto Python, mas, como você carregou esses dados de um arquivo CSV, você sabe que ele deve ser um atributo de texto. Quando você olhou para as cinco primeiras linhas, provavelmente percebeu que os valores na coluna ocean_proximity eram repetitivos, o que significa que é provavelmente um atributo categórico. Você pode descobrir quais categorias existem e quantos bairros pertencem a cada categoria utilizando o método value_counts() : >>> housing["ocean_proximity"]. value_counts() <1H OCEAN 9136 INLAND 6551 NEAR OCEAN 2658 NEAR BAY 2290 ISLAND 5 Name: ocean_proximity, dtype: int64 Vamos olhar para outros campos. O método describe() mostra um resumo dos atri-butos numéricos (Figura 2-7). Figura 2-7. Resumo de cada atributo numérico As linhas count, mean, min e max são autoexplicativas. Observe que os valores nulos são ignorados (então, por exemplo, count do total_bedrooms é 20. 433, não 20. 640). A linha std mostra o desvio padrão, que mede a dispersão dos valores. 11 As linhas 25%, 50% e 75% mostram os percentis correspondentes: um percentil indica o valor abaixo no qual uma dada porcentagem cai em um grupo de observações. Por exemplo, 25% dos bairros tem uma housing_median_age menor que 18, enquanto 50% é menor que 29, e 75% é menor que 37. Estes são frequentemente chamados de 25º percentil (ou 1º quartil ), a média e o 75º percentil (ou 3º quartil). 11 O desvio padrão é geralmente denotado σ (da letra grega sigma) e é a raiz quadrada da variância, que é a média do desvio quadrado da média. Quando uma característica tem uma distribuição normal em forma de sino (também chamada de distribuição Gaussiana ), que é muito comum, aplica-se a regra “68-95-99,7”: cerca de 68% dos valores se enquadram em 1σ da média, 95% dentro de 2σ e 99,7% dentro de 3σ. CG_MIOLO_Hands_On_Machine_Learning. indb 48 07/05/2019 17:08:02 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
Obtenha os Dados | 49Outro método rápido de perceber o tipo de dados com o qual você está lidando é traçar um histograma para cada atributo numérico. Um histograma mostra o número de ins-tâncias (no eixo vertical) que possuem um determinado intervalo de valores (no eixo horizontal). Você pode traçar esse único atributo por vez ou pode chamar o método hist() em todo o conjunto de dados e traçar um histograma para cada atributo numérico (veja a Figura 2-8). Por exemplo, você pode ver que pouco mais de 800 bairros possuem um median_house_value equivalente a mais ou menos US$ 100 mil. %matplotlib inline # somente no notebook Jupyter import matplotlib. pyplot as plt housing. hist(bins=50, figsize=(20,15)) plt. show() O método hist() depende do Matplotlib, que por sua vez depen-de de um backend gráfico especificado pelo usuário para figurar em sua tela. Então, antes que você consiga plotar qualquer coisa, é pre-ciso especificar qual backend o Matplotlib deve usar. A opção mais simples é usar o comando mágico do Jupyter %matplotlib inline. Isso leva o Jupyter a configurar o Matplotlib para que ele utilize seu próprio backend. As plotagens são então processadas dentro do próprio notebook. Observe que é opcional em um notebook do Jupyter chamar o show(), pois ele exibirá gráficos automaticamente sempre que uma célula for executada. householdshousing_median_agelatitude median_income median_house_value longitude population total_bedrooms total_rooms Figura 2-8. Um histograma para cada atributo numérico CG_MIOLO_Hands_On_Machine_Learning. indb 49 07/05/2019 17:08:03 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
50 | Capítulo 2: Projeto de Aprendizado de Máquina de Ponta a Ponta Preste atenção em alguns pontos destes histogramas: 1. Pri meiro, o atributo da renda média não parece estar expresso em dólares ame-ricanos (USD). Depois de verificar com a equipe de coleta de dados, você é infor-mado que os dados foram dimensionados e limitados em 15 (na verdade 15,0001) para a média dos maiores rendimentos, e em 0,5 (na verdade 0,4999) para a média dos rendimentos mais baixos. É comum trabalhar com atributos pré-processados no Aprendizado de Máquina e isto não é necessariamente um problema, mas você deve tentar entender como os dados foram calculados. 2. A idade m édia e o valor médio da casa também foram limitados. Este último pode ser um problema sério, pois é seu atributo alvo (seus rótulos). Os algoritmos de Aprendizado de Máquina podem aprender que os preços nunca ultrapassam esse limite. Você precisa verificar com a equipe do seu cliente (a equipe que usará a saída do seu sistema) para ver se isso é ou não um problema. Se eles disserem que precisam de previsões precisas mesmo acima de US$ 500 mil, então você terá duas opções: a. Col etar rótulos adequados para os bairros cujos rótulos foram limitados. b. Rem over esses bairro s do conjunto de treinamento (e também do conjunto de testes, já que seu sistema não deve ser responsabilizado por prever valores além de US$ 500 mil). 3. Ess es atributos têm escalas muito diferentes. Discutiremos isso mais adiante neste capítulo, quando explorarmos o escalonamento das características. 4. Fin almente, muitos histogramas têm um rastro alongado: eles se estendem muito mais à direita da média do que à esquerda. Isso pode dificultar a detecção de pa-drões em alguns algoritmos do Aprendizado de Máquina. Vamos tentar transfor-mar esses atributos mais tarde para conseguir mais distribuições na forma de sino. Espero que você tenha agora uma melhor compreensão do tipo de dados com os quais está lidando. Espere! Antes de analisar ainda mais os dados, você precisa criar um conjunto de teste, colocá-lo de lado e nunca checá-lo. CG_MIOLO_Hands_On_Machine_Learning. indb 50 07/05/2019 17:08:03 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
Obtenha os Dados | 51Crie um Conjunto de Testes Pode parecer estranho colocar de lado, voluntariamente, uma parte dos dados nesta fase. Afinal, você só deu uma rápida olhada nos dados e certamente precisa aprender muito mais a respeito antes de decidir quais algoritmos usar, certo? Isso é verdade, mas o seu cérebro é um incrível sistema de detecção de padrões, o que significa que é altamente propenso ao sobreajuste : se você olhar para o conjunto de teste, pode tropeçar em algum padrão aparentemente interessante nos dados de teste que o levará a selecionar um tipo particular de modelo do Aprendizado de Máquina. Quando você estima o erro de generalização utilizando o conjunto de teste, sua estimativa será muito otimista e você lançará um sistema que não funcionará tão bem quanto o esperado. Isso é chamado de data snooping bias. Criar um conjunto de testes é, teoricamente, bastante simples: basta escolher aleatoria-mente algumas instâncias, geralmente 20% do conjunto de dados, e colocá-las de lado: import numpy as np def split_train_test(data, test_ratio): shuffled_indices = np. random. permutation(len(data)) test_set_size = int(len(data) * test_ratio) test_indices = shuffled_indices[:test_set_size] train_indices = shuffled_indices[test_set_size:] return data. iloc[train_indices], data. iloc[test_indices] Você pode usar essa função assim: >>> train_set, test_set = split_train_test(housing, 0. 2) >>> print(len(train_set), "train +", len(test_set), "test") 16512 train + 4128 test Bem, isso funciona, mas não é perfeito: ao executar o programa novamente, será gerado um conjunto diferente de testes! Ao longo do tempo, você (ou seus algoritmos do Apren-dizado de Máquina) verá todo o conjunto de dados, o que deve ser evitado. Uma solução seria salvar o conjunto de testes na primeira execução e depois carregá-lo em execuções subsequentes. Outra opção é definir a semente do gerador de números alea-tórios (por exemplo, np. random. seed(42) )12 antes de chamar a np. random. permutation(), de modo que ele sempre gere os mesmos índices embaralhados. Mas ambas as soluções serão interrompidas na próxima vez que você buscar um conjunto de dados atualizado. Uma solução comum é utilizar o identificador de cada instância para decidir se ela deve ou não ir no conjunto de teste (supondo que as instâncias tenham um identificador único e imutável). Por exemplo, você pode calcular um hash do identi-12 Você verá com frequência pessoas colocarem a random seed em 42. Esse número não possui propriedade especial alguma além de ser A Resposta para a Vida, para o Universo e Tudo Mais. CG_MIOLO_Hands_On_Machine_Learning. indb 51 07/05/2019 17:08:03 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
52 | Capítulo 2: Projeto de Aprendizado de Máquina de Ponta a Pontaficador de cada instância, manter apenas o último byte do hash e colocar a instância no conjunto de teste se esse valor for menor ou igual a 51 (~20% de 256). Isso garante que o conjunto de teste permanecerá consistente em várias execuções, mesmo ao atualizar o conjunto de dados. O novo conjunto de testes conterá 20% das novas instâncias, mas não conterá nenhuma instância que já estivesse no conjunto de treinamento. Veja uma possível implementação: import hashlib def test_set_check(identifier, test_ratio, hash): return hash(np. int64(identifier)). digest()[-1] < 256 * test_ratio def split_train_test_by_id(data, test_ratio, id_column, hash=hashlib. md5): ids = data[id_column] in_test_set = ids. apply(lambda id_: test_set_check(id_, test_ratio, hash)) return data. loc[~in_test_set], data. loc[in_test_set] Infelizmente, o conjunto de dados do setor imobiliário não possui uma coluna de iden-tificação. A solução mais simples é utilizar o índice da linha como ID: housing_with_id = housing. reset_index() # adiciona uma coluna 'index` train_set, test_set = split_train_test_by_id(housing_with_id, 0. 2, "index") Se você utilizar o índice de linha como um identificador exclusivo, precisa se certificar de que novos dados sejam anexados ao final do conjunto de dados e que nenhuma linha seja excluída. Se isso não for possível, tente utilizar características mais estáveis para criar um identificador exclusivo. Por exemplo, a latitude e a longitude de um bairro serão certamente estáveis por alguns milhões de anos, então você pode combiná-las em um ID dessa forma: 13 housing_with_id["id"] = housing["longitude"] * 1000 + housing["latitude"] train_set, test_set = split_train_test_by_id(housing_with_id, 0. 2, "id") O Scikit-Learn fornece algumas funções para dividir conjuntos de dados em vários subconjuntos de diversas maneiras. A função mais simples é train_test_split, que faz praticamente o mesmo que a função split_train_test definida anteriormente, mas com alguns recursos adicionais. Primeiro, temos um parâmetro random_state que permite que você defina a semente do gerador de números aleatórios como explicado anteriormente e, em segundo lugar, você pode passar múltiplos conjuntos de dados com um número idêntico de linhas, e ele os dividirá nos mesmos índices (isso é muito útil se, por exemplo, você tiver um Data Frame separado para os rótulos): from sklearn. model_selection import train_test_split train_set, test_set = train_test_split(housing, test_size=0. 2, random_state=42) 13 A informação de localização é realmente bastante grosseira e, como resultado, muitos bairros terão exatamente a mesma identificação, acabando no mesmo conjunto ( test ou train ). Infelizmente, isso introduz algum viés de amostragem. CG_MIOLO_Hands_On_Machine_Learning. indb 52 07/05/2019 17:08:04 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
Obtenha os Dados | 53Até agora consideramos somente métodos de amostragem puramente aleatórios. Isso geralmente é bom se o seu conjunto de dados for suficientemente grande (especialmente em relação ao número de atributos), mas, se não for, corre o risco de apresentar um viés significativo de amostragem. Quando uma empresa de pesquisa decide ligar para mil pessoas e lhes fazer algumas perguntas, eles não escolhem aleatoriamente mil pessoas em uma lista telefônica. Eles tentam garantir que essas mil pessoas representem toda a população. Por exemplo, a população dos EUA é composta por 51,3% de pessoas do sexo feminino e 48,7% do sexo masculino, de modo que uma pesquisa bem conduzida tentaria manter essa proporção na amostragem: 513 mulheres e 487 homens. Isso é chamado de amostragem estratificada : a população é dividida em subgrupos homogêneos, chamados de estratos, e o número certo de instâncias de cada estrato é amostrado para garantir que o conjunto de testes seja representativo da população em geral. Se eles utilizassem amostragem puramente aleatória, haveria cerca de 12% de chance de amostrar um con-junto de teste distorcido, tanto com menos de 49% feminino quanto com mais de 54%. De qualquer forma, os resultados da pesquisa seriam significativamente tendenciosos. Suponha que você tenha conversado com especialistas que lhe disseram que a renda média é um atributo muito importante para estimar os preços médios. Você quer garantir que o conjunto de testes seja representativo das várias categorias de rendimentos em todo o conjunto de dados. Uma vez que a renda média é um atributo numérico contínuo, primeiro você precisa criar um atributo na categoria da renda. Vejamos mais de perto o histograma da renda média (de volta à Figura 2-8): a maioria dos valores médios da renda está agrupada em torno de US$ 20 mil-US$ 50 mil mas alguns rendimentos mé-dios ultrapassam os US$ 60 mil. É importante ter um número suficiente de instâncias para cada estrato em seu conjunto de dados, ou então a estimativa da importância do estrato poderá ser tendenciosa. Isso significa que você não deve ter muitos estratos, e cada estrato deve ser grande o suficiente. O código a seguir cria um atributo da categoria da renda dividindo a renda média por 1,5 (para limitar o número de categorias da renda) e arredondando com a utilização do ceil (para ter categorias discretas) e, em seguida, mesclando todas as categorias maiores que 5, na categoria 5: housing["income_cat"] = np. ceil(housing["median_income"] / 1. 5) housing["income_cat"]. where(housing["income_cat"] < 5, 5. 0, inplace=True) Essas categorias de renda estão representadas na (Figura 2-9): CG_MIOLO_Hands_On_Machine_Learning. indb 53 07/05/2019 17:08:04 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
54 | Capítulo 2: Projeto de Aprendizado de Máquina de Ponta a Ponta Figura 2-9. Histograma das categorias de renda Agora você está pronto para fazer uma amostragem estratificada com base na categoria da renda. Para isso você pode utilizar a classe Stratified Shuffle Split do Scikit-Learn: from sklearn. model_selection import Stratified Shuffle Split split = Stratified Shuffle Split(n_splits=1, test_size=0. 2, random_state=42) for train_index, test_index in split. split(housing, housing["income_cat"]): strat_train_set = housing. loc[train_index] strat_test_set = housing. loc[test_index] Vamos ver se isso funcionou como esperado. Você pode começar pela análise das pro-porções da categoria de renda no conjunto de testes: >>> strat_test_set["income_cat"]. value_counts() / len(strat_test_set) 3. 0 0. 350533 2. 0 0. 318798 4. 0 0. 176357 5. 0 0. 114583 1. 0 0. 039729 Name: income_cat, dtype: float64 Com um código similar, você pode medir as proporções da categoria de renda no con-junto completo de dados. A Figura 2-10 compara as proporções da categoria de renda no conjunto geral de dados, no conjunto de teste gerado com a amostragem estratificada e em um conjunto de testes gerado a partir da amostragem puramente aleatória. Como você pode ver, o conjunto de testes gerado com a utilização da amostragem estratifica-da tem proporções da categoria de renda quase idênticas às do conjunto completo de dados, enquanto o conjunto de testes gerado com amostragem puramente aleatória é bastante distorcido. CG_MIOLO_Hands_On_Machine_Learning. indb 54 07/05/2019 17:08:04 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
Descubra e Visualize os Dados para Obter Informações | 55 Figura 2-10. Comparação de viés de amostragem estratificada versus amostragem aleatória Agora, você deve remover o atributo income_cat para que os dados voltem ao seu estado original: for set_ in (strat_train_set, strat_test_set): set_. drop("income_cat", axis=1, inplace=True) Ficamos um tempo na geração de conjuntos de testes por uma boa razão: esta parte crítica é muitas vezes negligenciada em um projeto de Aprendizado de Máquina. Além disso, muitas dessas ideias serão úteis mais tarde quando discutirmos a validação cruzada. Agora, é hora de avançar para o próximo estágio: explorar os dados. Descubra e Visualize os Dados para Obter Informações Até aqui você deu apenas uma rápida olhada para ter uma compreensão geral do tipo de dados que está manipulando. Agora, o objetivo é aprofundar-se um pouco mais. Primeiro, certifique-se de colocar o teste de lado e apenas explorar o conjunto de treina-mento. Além disso, se o conjunto de treinamento for muito grande, talvez seja melhor experimentar um conjunto de exploração para fazer manipulações fácil e rapidamente. No nosso caso, o conjunto é muito pequeno, então você pode trabalhar diretamente no conjunto completo. Criaremos uma cópia para que você possa treinar com ela sem prejudicar o conjunto de treinamento: housing = strat_train_set. copy() Visualizando Dados Geográficos Como existem informações geográficas (latitude e longitude), é uma boa ideia criar um diagrama de dispersão para visualizar os dados de todos os bairros (Figura 2-11): housing. plot(kind="scatter", x="longitude", y="latitude") CG_MIOLO_Hands_On_Machine_Learning. indb 55 07/05/2019 17:08:04 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
56 | Capítulo 2: Projeto de Aprendizado de Máquina de Ponta a Ponta Latitude Longitude Figura 2-11. Um diagrama de dispersão geográfica dos dados Isso se parece com a Califórnia, mas, além disso, é difícil ver qualquer padrão específico. Definir a opção alpha em 0,1 facilita a visualização dos locais onde existe uma alta densidade de pontos de dados (Figura 2-12): housing. plot(kind="scatter", x="longitude", y="latitude", alpha=0. 1) Latitude Longitude Figura 2-12. Uma melhor visualização destacando áreas de alta densidade Agora já está melhor: é possível ver claramente as áreas de alta densidade, especificamente a Área da Baía de Los Angeles e San Diego, além de uma longa linha de alta densidade no Vale Central, principalmente ao redor de Sacramento e Fresno. CG_MIOLO_Hands_On_Machine_Learning. indb 56 07/05/2019 17:08:05 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
Descubra e Visualize os Dados para Obter Informações | 57No geral, nosso cérebro é muito bom em detectar padrões em imagens, mas talvez seja necessário brincar com parâmetros de visualização para que os padrões se destaquem. Agora, vejamos os preços do setor imobiliário (Figura 2-13). O raio de cada círculo re-presenta a população do bairro (opção s) e a cor representa o preço (opção c). Usaremos um mapa de cores pré-definido (opção cmap ) chamado jet, que varia do azul (valores baixos) para o vermelho (preços altos):14 housing. plot(kind="scatter", x="longitude", y="latitude", alpha=0. 4, s=housing["population"]/100, label="population", figsize=(10,7), c="median_house_value", cmap=plt. get_cmap("jet"), colorbar=True, ) plt. legend() Latitude Longitude Population median_house_value Figura 2-13. Preços das casas na Califórnia Esta imagem informa que os preços do setor imobiliário estão muito relacionados à localização (por exemplo, perto do oceano) e à densidade populacional, como prova-velmente você já sabia. Será útil utilizar um algoritmo de agrupamento para detectar os grupos principais e adicionar novas características que medem a proximidade com os centros de agrupamento. O atributo de proximidade do oceano também pode ser útil, embora na costa norte da Califórnia os preços não sejam muito altos, então essa não é uma regra simples. 14 Se você estiver lendo em escala de cinza, pegue uma caneta vermelha e rabisque na maior parte do litoral da Área da Baía até San Diego (como esperado). Você também pode acrescentar um trecho amarelo ao redor de Sacramento. CG_MIOLO_Hands_On_Machine_Learning. indb 57 07/05/2019 17:08:05 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
58 | Capítulo 2: Projeto de Aprendizado de Máquina de Ponta a Ponta Buscando Correlações Uma vez que o conjunto de dados não é muito grande, você pode calcular facilmente o coeficiente de correlação padrão (também chamado r de Pearson ) entre cada par de atributos utilizando o método corr() : corr_matrix = housing. corr() Agora, vejamos o quanto cada atributo se correlaciona com o valor médio da habitação: >>> corr_matrix["median_house_value"]. sort_values(ascending=False) median_house_value 1. 000000 median_income 0. 687170 total_rooms 0. 135231 housing_median_age 0. 114220 households 0. 064702 total_bedrooms 0. 047865 population -0. 026699 longitude -0. 047279 latitude -0. 142826 Name: median_house_value, dtype: float64 O coeficiente de correlação varia de-1 a 1. Quando está próximo de 1, significa que existe uma forte correlação positiva; por exemplo, o valor médio da habitação tende a aumentar quando a renda média aumenta. Quando o coeficiente está próximo de-1, significa que existe uma forte correlação negativa; é possível ver uma pequena correlação negativa entre a latitude e o valor médio da habitação (ou seja, os preços tendem a diminuir quando você vai para o norte). Finalmente, coeficientes próximos de zero significam que não há correlação linear. A Figura 2-14 mostra várias plotagens juntamente com o coeficiente de correlação entre seus eixos horizontal e vertical. Figura 2-14. Coeficiente de correlação padrão de vários conjuntos de dados (fonte: Wikipedia; imagem de domínio público) CG_MIOLO_Hands_On_Machine_Learning. indb 58 07/05/2019 17:08:06 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
Descubra e Visualize os Dados para Obter Informações | 59O coeficiente de correlação apenas mede correlações lineares (“se x sobe, então y geralmente sobe/desce”). Ele pode perder completa-mente as relações não lineares (por exemplo, “se x é próximo a zero, então, y, geralmente, sobe”). Observe como todas as plotagens da li-nha inferior têm um coeficiente de correlação igual a zero, apesar do fato de seus eixos claramente não serem independentes: são exem-plos de relações não lineares. Além disso, a segunda linha mostra exemplos em que o coeficiente de correlação é igual a 1 ou-1; obser-ve que isso não tem nada a ver com a inclinação. Por exemplo, sua altura em polegadas tem um coeficiente de correlação de 1 com sua altura em pés ou em nanômetros. Outra maneira de verificar a correlação entre atributos é utilizar a função scatter_matrix, do Pandas, que plota cada atributo numérico em relação a qualquer outro atributo numérico. Uma vez que existem 11 atributos numéricos, você obteria 112 = 121 plotagens, o que não caberia em uma página, então focaremos apenas em alguns atributos promissores que parecem mais correlacionados com o valor médio do setor imobiliário (Figura 2-15): from pandas. tools. plotting import scatter_matrix attributes = ["median_house_value", "median_income", "total_rooms", "housing_median_age"] scatter_matrix(housing[attributes], figsize=(12, 8)) median_house_value median_incometotal_roomshousing_median_age median_house_valuemedian_income total_roomshousing_median_age Figura 2-15. Matriz de dispersão CG_MIOLO_Hands_On_Machine_Learning. indb 59 07/05/2019 17:08:06 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
60 | Capítulo 2: Projeto de Aprendizado de Máquina de Ponta a Ponta A diagonal principal (superior esquerda até a parte inferior direita) seria cheia de linhas retas se o Pandas plotasse cada variável em relação a si mesma, o que não seria muito útil. Então, em vez disso, o Pandas exibe um histograma para cada atributo (outras opções estão disponíveis, veja a documentação do Pandas para mais detalhes). O atributo mais promissor para prever o valor médio da habitação é a renda média, então vamos observar o gráfico de dispersão de correlação (Figura 2-16): housing. plot(kind="scatter", x="median_income", y="median_house_value", alpha=0. 1) Esta plotagem revela algumas coisas. Primeiro, a correlação é realmente muito forte; é possível ver claramente a tendência ascendente, e os pontos não estão muito dispersos. Em segundo lugar, o limite de preços que percebemos anteriormente é claramente visível como uma linha horizontal em US$ 500 mil. Mas esta plotagem revela outras linhas retas menos óbvias: uma horizontal em torno de US$ 450 mil, outra em torno de US$ 350 mil, talvez uma em torno de US$ 280 mil, e mais algumas abaixo disso. Você pode tentar remover os bairros correspondentes para evitar que seus algoritmos apren-dam a reproduzir essas peculiaridades dos dados. median_house_value median_income Figura 2-16. Renda média versus valor médio da habitação Experimentando com Combinações de Atributo Esperamos que as seções anteriores tenham dado a você uma ideia de algumas maneiras de explorar os dados e obter informações. Você identificou algumas peculiaridades dos dados que talvez queira limpar antes de fornecê-los a um algoritmo de Aprendizado de Máquina, e também encontrou correlações interessantes entre atributos, especialmente CG_MIOLO_Hands_On_Machine_Learning. indb 60 07/05/2019 17:08:06 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
Descubra e Visualize os Dados para Obter Informações | 61com o atributo-alvo. Também foi possível perceber que alguns atributos têm um rastro de distribuição prolongado, então pode ser que você queira transformá-los (por exemplo, ao calcular seu logaritmo). Claro, o seu raio de ação variará consideravelmente a cada projeto, mas as ideias gerais são semelhantes. Uma última coisa que você pode querer fazer é tentar várias combinações de atributos antes de preparar os dados para os algoritmos de Aprendizado de Máquina. Por exemplo, o número total de cômodos em um bairro não terá muita utilidade se você não souber quantos domicílios existem. O que você realmente quer é o número de cômodos por domicílio. Da mesma forma, o número total de quartos por si só não é muito útil: você provavelmente vai querer compará-lo com o número de cômodos. E a população por domicílio também parece uma combinação de atributos interessante. Criaremos esses novos atributos: housing["rooms_per_household"] = housing["total_rooms"]/housing["households"] housing["bedrooms_per_room"] = housing["total_bedrooms"]/housing["total_rooms"] housing["population_per_household"]=housing["population"]/housing["households"] E, agora, vejamos a matriz de correlação novamente: >>> corr_matrix = housing. corr() >>> corr_matrix["median_house_value"]. sort_values(ascending=False) median_house_value 1. 000000 median_income 0. 687160 rooms_per_household 0. 146285 total_rooms 0. 135097 housing_median_age 0. 114110 households 0. 064506 total_bedrooms 0. 047689 population_per_household -0. 021985 population -0. 026920 longitude -0. 047432latitude -0. 142724 bedrooms_per_room -0. 259984 Name: median_house_value, dtype: float64 Ei, nada mal! O novo atributo bedrooms_per_room está muito mais correlacionado com o valor médio da habitação do que com o número total de cômodos ou quartos. Aparen-temente, habitações com uma baixa relação quarto/cômodo tendem a ser mais caras. O número de cômodos por família também é mais informativo do que o número total de cômodos em um bairro — obviamente, quanto maiores as habitações, mais caras elas serão. Esta rodada de exploração não precisa ser absolutamente minuciosa; o objetivo é co-meçar com o pé direito e rapidamente obter informações que o ajudarão a produzir um primeiro protótipo razoavelmente bom. Mas este é um processo iterativo: uma vez que você obtiver um protótipo funcional, poderá analisar sua saída para adquirir mais informações e voltar a este passo da exploração. CG_MIOLO_Hands_On_Machine_Learning. indb 61 07/05/2019 17:08:07 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
62 | Capítulo 2: Projeto de Aprendizado de Máquina de Ponta a Ponta Prepare os Dados para Algoritmos do Aprendizado de Máquina É hora de preparar os dados para seus algoritmos de Aprendizado de Máquina. Em vez de fazer isso manualmente, escreva funções, por vários bons motivos: Isso p ermitirá que você reproduza essas transformações facilmente em qualquer conjunto de dados (por exemplo, na próxima vez que você receber um novo con-junto de dados); Voc ê gradualmente construirá uma biblioteca de funções de transformação que poderão ser reutilizadas em projetos futuros; Voc ê pode usar essas funções em seu sistema ao vivo para transformar os novos dados antes de fornecê-lo aos seus algoritmos; Isso p ossibilitará que você tente várias transformações facilmente e veja qual combinação funciona melhor. Mas primeiro vamos reverter para um conjunto de treinamento limpo (copiando strat_ train_set mais uma vez), e vamos separar os previsores e os rótulos, uma vez que não queremos necessariamente aplicar as mesmas transformações às previsões e aos valo-res-alvo (observe que drop() cria uma cópia dos dados e não afeta strat_train_set ): housing = strat_train_set. drop("median_house_value", axis=1) housing_labels = strat_train_set["median_house_value"]. copy() Limpando os Dados A maioria dos algoritmos de Aprendizado de Máquina não pode funcionar com ca-racterísticas faltantes, então criaremos algumas funções para cuidar delas. Você notou anteriormente que o atributo total_bedrooms tem alguns valores faltantes, então vamos consertar isso. Há três opções: Livr ar-se dos bairros correspondentes; Livr ar-se de todo o atributo; Def inir valores para algum valor (zero, a média, intermediária, etc. ). Você pode fazer isso facilmente utilizando os métodos dropna(), drop() e fillna() do Data Frame : housing. dropna(subset=["total_bedrooms"]) # opção 1 housing. drop("total_bedrooms", axis=1) # opção 2 median = housing["total_bedrooms"]. median() # opção 3 housing["total_bedrooms"]. fillna(median, inplace=True) CG_MIOLO_Hands_On_Machine_Learning. indb 62 07/05/2019 17:08:07 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
Prepare os Dados para Algoritmos do Aprendizado de Máquina | 63Se você escolher a opção 3, deve calcular o valor médio no conjunto de treinamento e usá-lo para preencher os valores faltantes neste, mas não se esqueça de também salvar o valor médio que você calculou. Você precisará dele mais tarde para substituir os valores faltantes no conjunto de testes quando quiser avaliar seu sistema e também quando o sistema entrar em operação para substituir os valores faltantes nos novos dados. O Scikit-Learn fornece uma classe acessível para cuidar dos valores faltantes: Imputer. Veja como utilizá-la. Primeiro você cria uma instância do Imputer, especificando que deseja substituir os valores faltantes de cada atributo pela média desse atributo: from sklearn. preprocessing import Imputer imputer = Imputer(strategy="median") Uma vez que a média só pode ser calculada em atributos numéricos, precisamos criar uma cópia dos dados sem o atributo de texto ocean_proximity : housing_num = housing. drop("ocean_proximity", axis=1) imputer. fit(housing_num)Agora, você pode ajustar a instância imputer aos dados de treinamento utilizando o método fit() :housing_num = housing. drop("ocean_proximity", axis=1) imputer. fit(housing_num) O imputer simplesmente calculou a média de cada atributo e armazenou o resultado em sua variável da instância statistics_. Somente o atributo total_bedrooms tinha valores faltantes, mas não podemos ter certeza de que não haverá valores faltantes nos novos dados após o sistema entrar em operação por isso é mais seguro aplicar o imputer a todos os atributos numéricos: >>> imputer. statistics_ array([-118. 51, 34. 26, 29., 2119. 5, 433., 1164., 408., 3. 5409]) >>> housing_num. median(). values array([-118. 51, 34. 26, 29., 2119. 5, 433., 1164., 408., 3. 5409]) Agora, você pode utilizar esse imputer “treinado” substituindo os valores perdidos pelas médias aprendidas a fim de transformar o conjunto de treinamento: X = imputer. transform(housing_num) O resultado será um array Numpy simples que contém as características transformadas. Se quiser colocá-lo de volta em um Data Frame Pandas, é simples: housing_tr = pd. Data Frame(X, columns=housing_num. columns) CG_MIOLO_Hands_On_Machine_Learning. indb 63 07/05/2019 17:08:08 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
64 | Capítulo 2: Projeto de Aprendizado de Máquina de Ponta a Ponta Scikit-Learn Design A API do Scikit-Learn é muito bem projetada. Os principais princípios de design (http:// goo. gl/w L10s I) são:15 Consistência. To dos os objetos compartilham uma interface simples e consistente: —Estimadores. Qualquer objeto que possa estimar alguns parâmetros com base em um conjunto de dados é chamado de estimador (por exemplo, um imputer é um estimador). A estimativa em si é realizada pelo método fit(), e é necessário apenas um conjunto de dados como parâmetro (ou dois para algoritmos de aprendizado supervisionado; o segundo conjunto de dados contém os rótulos). Qualquer outro parâmetro necessário para orientar o processo de estimativa é considerado um hiperparâmetro (como imputer's strategy ), e deve ser configurado como uma variável da instância (geralmente por meio de um parâmetro do construtor). —Transformadores. Alguns estimadores (como um imputer ) também podem transformar um conjunto de dados; esses são chamados transformadores. Mais uma vez, a API é bem simples: a transformação é realizada pelo método transform() para transformar o conjunto de dados como um parâmetro. Ele retorna o conjunto de dados transformado. Esta transformação geralmente depende dos parâmetros aprendidos, como é o caso de um imputer. Todos os transformadores também possuem um método de conveniência chamado fit_transform() que é o equivalente a chamar a fit() e então transform() (mas algumas vezes fit_transform() é otimizado e roda muito mais rápido). —Previsores. Finalmente, a partir de um conjunto de dados, alguns estimadores são capazes de fazer previsões; eles são chamados previsores. Por exemplo, o modelo Linear Regression do capítulo anterior foi um previsor: previu a satisfação de vida, dado o PIB per capita de um país. Um previsor tem um método predict() que pega um conjunto de dados de novas instâncias e retorna um conjunto de dados de previsões correspondentes. Ele também tem um método score(), que mede a qualidade das previsões, dado um conjunto de teste (e os rótulos correspondentes no caso de algoritmos de aprendizado supervisionado). 16 Inspeção. Todos os hiperparâmetros do estimador são diretamente acessíveis por meio de variáveis das instâncias públicas (por exemplo, imputer. strategy ), e todos os parâmetros aprendidos do estimador também são acessíveis por variáveis das ins-tâncias públicas com um sufixo de sublinhado (por exemplo, imputer. statistics_ ). 15 Para mais detalhes em princípios de design, consulte “API design for machine learning software: experiences from the scikit-learn project”, L. Buitinck, G. Louppe, M. Blondel, F. Pedregosa, A. Müller, et al. (2013). 16 Alg uns previsores também fornecem métodos para medir a confiança de suas previsões. CG_MIOLO_Hands_On_Machine_Learning. indb 64 07/05/2019 17:08:08 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
Descubra e Visualize os Dados para Obter Informações | 65 Não proliferação de classes. Os c onjuntos de dados são representados como arrays Num Py ou matrizes esparsas Sci Py em vez de classes caseiras. Os hiperparâmetros são apenas strings ou números Python. Composição. Os blocos de construção existentes são reutilizados tanto quanto possível. Por exemplo, é fácil criar um estimador Pipeline seguido por um estimador final a partir de uma sequência arbitrária de transformadores, como veremos mais à frente. Padrões sensíveis. O Sc ikit-Learn fornece valores padrão razoáveis para a maioria dos parâmetros, facilitando a criação rápida de um sistema padronizado de trabalho. Manipulando Texto e Atributos Categóricos Anteriormente, excluímos o atributo categórico ocean_proximity por ser um atributo de texto, portanto não podemos calcular sua média: >>> housing_cat = housing["ocean_proximity"] >>> housing_cat. head(10)17606 <1H OCEAN 18632 <1H OCEAN 14650 NEAR OCEAN 3230 INLAND 3555 <1H OCEAN 19480 INLAND8879 <1H OCEAN13685 INLAND 4937 <1H OCEAN 4861 <1H OCEAN Name: ocean_proximity, dtype: object>>> housing_cat = housing["ocean_proximity"] >>> housing_cat. head(10)17606 <1H OCEAN 18632 <1H OCEAN 14650 NEAR OCEAN 3230 INLAND 3555 <1H OCEAN 19480 INLAND8879 <1H OCEAN13685 INLAND 4937 <1H OCEAN 4861 <1H OCEAN Name: ocean_proximity, dtype: object De qualquer modo, a maioria dos algoritmos de Aprendizado de Máquina prefere traba-lhar com números, então vamos converter essas categorias de texto para números. Para tanto, podemos utilizar o método factorize() do Pandas, que mapeia cada categoria para um número inteiro diferente: >>> housing_cat_encoded, housing_categories = housing_cat. factorize() >>> housing_cat_encoded[:10]array([0, 0, 1, 2, 0, 2, 0, 2, 0, 0]) Este é melhor: housing_cat_encoded agora é puramente numérico. O método factorize() também retorna a lista de categorias (“<1H OCEAN” foi mapeado para 0, “NEAR OCEAN” foi mapeado para 1, etc. ): >>> housing_categories Index(['<1H OCEAN', 'NEAR OCEAN', 'INLAND', 'NEAR BAY', 'ISLAND'], dtype='object') CG_MIOLO_Hands_On_Machine_Learning. indb 65 07/05/2019 17:08:08 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
66 | Capítulo 2: Projeto de Aprendizado de Máquina de Ponta a Ponta Um problema nesta representação é que os algoritmos de Aprendizado de Máquina assumirão que dois valores próximos são mais parecidos do que dois valores distantes. Obviamente, este não é o caso (por exemplo, as categorias 0 e 4 são mais semelhantes do que as categorias 0 e 2). Para corrigir este problema, uma solução comum seria a criação de um atributo binário por categoria: um atributo igual a 1 quando a categoria for “<1H OCEAN” (e 0 caso contrário), outro atributo igual a 1 quando a categoria for “NEAR OCEAN” (e 0 caso contrário), e assim por diante. Isso é chamado de one-hot encoding, porque apenas um atributo será igual a 1 ( hot), enquanto os outros serão 0 ( cold). O Scikit-Learn fornece um codificador One Hot Encoder para converter valores categóri-cos inteiros em vetores one-hot. Vamos programar as categorias como vetores one-hot : >>> from sklearn. preprocessing import One Hot Encoder >>> encoder = One Hot Encoder() >>> housing_cat_1hot = encoder. fit_transform(housing_cat_encoded. reshape(-1,1)) >>> housing_cat_1hot <16512x5 sparse matrix of type '<class 'numpy. float64'>' with 16512 stored elements in Compressed Sparse Row format> Note que fit_transform() espera um array 2D, mas housing_cat_encoded é um array 1D, então precisamos remodelá-lo. 17 Além disso, observe que a saída é uma matriz esparsa Sci Py, não um array Num Py. Isso é muito útil quando você possui atributos categóricos com milhares de categorias. Após um one-hot encoding, obtemos uma matriz com milhares de colunas e cheia de zeros, exceto por um único 1 por linha. Seria muito desperdício utilizar toneladas de memória para armazenar principalmente zeros, então, em vez disso, uma matriz esparsa armazena apenas a localização dos elementos diferentes de zero. Você pode utilizá-la principalmente como um array 2D normal,18 mas, se realmente quiser convertê-la em um array (denso) Num Py, basta chamar o método toarray() : >>> housing_cat_1hot. toarray() array([[ 1., 0., 0., 0., 0. ], [ 1., 0., 0., 0., 0. ], [ 0., 1., 0., 0., 0. ], ..., [ 0., 0., 1., 0., 0. ], [ 1., 0., 0., 0., 0. ], [ 0., 0., 0., 1., 0. ]]) Você pode aplicar ambas as transformações de uma única vez (de categorias de texto a categorias de inteiros, depois de categorias de inteiros para vetores one-hot ) utilizando a classe Categorical Encoder. Ela não faz parte do Scikit-Learn 0. 19. 0 e mais antigos, mas 17 A função Num Py reshape() pe rmite que uma dimensão seja-1, o que significa “não especificado”: o val or é inferido do comprimento do array e das dimensões restantes. 18 Vej a a documentação do Sci Py para mais detalhes. CG_MIOLO_Hands_On_Machine_Learning. indb 66 07/05/2019 17:08:09 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
Descubra e Visualize os Dados para Obter Informações | 67será adicionada em breve, então talvez já esteja disponível no momento em que você lê este livro. Se não estiver, pode obtê-la no notebook Jupyter para este capítulo (o código foi copiado do Pull Request #9151). Segue abaixo como usá-la: >>> from sklearn. preprocessing import Categorical Encoder # ou pegue do notebook >>> cat_encoder = Categorical Encoder() >>> housing_cat_reshaped = housing_cat. values. reshape(-1, 1)>>> housing_cat_1hot = cat_encoder. fit_transform(housing_cat_reshaped) >>> housing_cat_1hot <16512x5 sparse matrix of type '<class 'numpy. float64'>' with 16512 stored elements in Compressed Sparse Row format> Por padrão, o Categorical Encoder mostra uma matriz esparsa, mas você pode confi-gurar a codificação para “ onehot-dense ” se preferir uma matriz densa: >>> cat_encoder = Categorical Encoder(encoding="onehot-dense") >>> housing_cat_1hot = cat_encoder. fit_transform(housing_cat_reshaped) >>> housing_cat_1hot array([[ 1., 0., 0., 0., 0. ], [ 1., 0., 0., 0., 0. ], [ 0., 0., 0., 0., 1. ], ..., [ 0., 1., 0., 0., 0. ], [ 1., 0., 0., 0., 0. ], [ 0., 0., 0., 1., 0. ]]) Você pode obter a lista de categorias utilizando a variável de instância categories_. É uma lista que contém um array de 1D de categorias para cada atributo categórico (neste caso, uma lista contendo um único array, uma vez que existe apenas um atributo categórico): >>> cat_encoder. categories_ [array(['<1H OCEAN', 'INLAND', 'ISLAND', 'NEAR BAY', 'NEAR OCEAN'], dtype=object)] Se um atributo categórico tiver um grande número de categorias possíveis (por exemplo, código do país, profissão, espécies, etc. ), então uma codificação one-hot resultará em um grande número de características de entrada. Isso pode diminuir o treinamento e de-gradar o desempenho. Se isso acontecer, será necessário produzir representações mais densas chamadas embeddings, mas isso requer uma boa compreensão das redes neurais (veja o Capítulo 14 para mais detalhes). Customize Transformadores Embora o Scikit-Learn forneça muitos transformadores úteis, você precisará escre-ver seus próprios para tarefas como operações de limpeza personalizadas ou combi-nar atributos específicos. É preciso que o seu transformador funcione perfeitamente CG_MIOLO_Hands_On_Machine_Learning. indb 67 07/05/2019 17:08:09 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
68 | Capítulo 2: Projeto de Aprendizado de Máquina de Ponta a Pontacom as funcionalidades do Scikit-Learn (como os pipelines ) e, como o Scikit-Learn depende da tipagem duck typing (não herança), você só precisa criar uma classe e im-plementar os três métodos: fit() (retornando self ), transform() e fit_transform(). Você pode obter o último de graça ao simplesmente acrescentar Transformer Mixin em uma classe base. Além disso, se você adicionar Base Estimator como uma classe base (e evitar *args e **kargs em seu construtor) você receberá dois métodos extras (get_params() e set_params() ) que serão úteis para o ajuste automático dos hiperparâ-metros. Por exemplo, esta é uma pequena classe transformer que adiciona os atributos combinados discutidos anteriormente: from sklearn. base import Base Estimator, Transformer Mixin rooms_ix, bedrooms_ix, population_ix, household_ix = 3, 4, 5, 6 class Combined Attributes Adder(Base Estimator, Transformer Mixin): def __init__(self, add_bedrooms_per_room = True): # sem *args ou **kargs self. add_bedrooms_per_room = add_bedrooms_per_room def fit(self, X, y=None): return self # nothing else to do def transform(self, X, y=None): rooms_per_household = X[:, rooms_ix] / X[:, household_ix] population_per_household = X[:, population_ix] / X[:, household_ix] if self. add_bedrooms_per_room: bedrooms_per_room = X[:, bedrooms_ix] / X[:, rooms_ix] return np. c_[X, rooms_per_household, population_per_household, bedrooms_per_room] else: return np. c_[X, rooms_per_household, population_per_household] attr_adder = Combined Attributes Adder(add_bedrooms_per_room=False) housing_extra_attribs = attr_adder. transform(housing. values) Neste exemplo, o transformador tem um hiperparâmetro, add_bedrooms_per_room, definido por padrão como True (geralmente é útil fornecer padrões sensíveis). Este hi-perparâmetro permitirá que você descubra facilmente se a adição deste atributo ajuda ou não os algoritmos de Aprendizado de Máquina. De forma mais geral, você pode adicionar um hiperparâmetro para controlar qualquer etapa da preparação de dados sobre a qual você não tem 100% de certeza. Quanto mais você automatizar essas etapas de preparação de dados, mais combinações poderá experimentar automaticamente, tornando muito mais provável encontrar uma ótima combinação (e economizar muito tempo). Escalonamento das Características Uma das transformações mais importantes que você precisa aplicar aos seus dados é o escalonamento das características. Com poucas exceções, os algoritmos de Aprendizado de Máquina não funcionam bem quando atributos numéricos de entrada têm escalas muito diferentes. Este é o caso dos dados do setor imobiliário: o número total de cômodos CG_MIOLO_Hands_On_Machine_Learning. indb 68 07/05/2019 17:08:09 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
Descubra e Visualize os Dados para Obter Informações | 69varia de 6 a 39. 320, enquanto os rendimentos médios variam apenas de 0 a 15. Observe que geralmente não é necessário escalar os valores-alvo. Existem duas maneiras comuns de todos os atributos obterem a mesma escala: escala min-max e padronização. O escalonamento min-max (muitas pessoas chamam de normalização ) é bastante sim-ples: os valores são deslocados e redimensionados para que acabem variando de 0 a 1. Fazemos isso subtraindo o valor mínimo e dividindo pelo máximo menos o mínimo. O Scikit-Learn fornece um transformador chamado Min Max Scaler para isso. Ele possui um hiperparâmetro feature_range que permite alterar o intervalo se você não quiser 0-1 por algum motivo. A padronização é bem diferente: em primeiro lugar ela subtrai o valor médio (assim os valores padronizados sempre têm média zero) e, em seguida, divide pela variância, de modo que a distribuição resultante tenha variância unitária. Ao contrário do escalona-mento min-max, a padronização não vincula valores a um intervalo específico, o que pode ser um problema para alguns algoritmos (por exemplo, as redes neurais geralmente esperam um valor de entrada variando de 0 a 1). No entanto, a padronização é muito menos afetada por outliers. Por exemplo, suponha que um bairro tenha uma renda média igual a 100 (por engano). O escalonamento min-max, em seguida, comprimiria todos os outros valores de 0-15 para 0-0,15, enquanto a padronização não seria muito afetada. O Scikit-Learn fornece um transformador para padronização chamado Standard Scaler. Tal como acontece com todas as transformações, é importante encai-xar os escalonadores apenas nos dados de treinamento e não no con-junto completo de dados (incluindo o conjunto de testes). Só então você pode utilizá-los para transformar o conjunto de treinamento e o conjunto de teste (e novos dados). Pipelines de Transformação Como você pode ver, existem muitas etapas de transformação de dados que precisam ser exe-cutadas na ordem correta. Felizmente, o Scikit-Learn fornece a classe Pipeline para ajudar com tais sequências de transformações. Eis um pequeno pipeline para os atributos numéricos: from sklearn. pipeline import Pipeline from sklearn. preprocessing import Standard Scaler num_pipeline = Pipeline([ ('imputer', Imputer(strategy="median")), ('attribs_adder', Combined Attributes Adder()), ('std_scaler', Standard Scaler()), ]) housing_num_tr = num_pipeline. fit_transform(housing_num) CG_MIOLO_Hands_On_Machine_Learning. indb 69 07/05/2019 17:08:10 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
70 | Capítulo 2: Projeto de Aprendizado de Máquina de Ponta a Ponta O construtor Pipeline se vale de uma lista de pares de nome/estimador que definem uma sequência de etapas. Todos, exceto o último estimador, devem ser transformadores (ou seja, eles devem ter um método fit_transform() ). Os nomes podem ser o que você quiser (desde que não contenham sublinhados duplos “__”). Quando você chama o método fit() do pipeline, ele chama fit_transform() sequen-cialmente em todos os transformadores, passando a saída de cada chamada como pa-râmetro para a próxima chamada, até chegar ao estimador final, o qual chama apenas o método fit(). O pipeline expõe os mesmos métodos que o estimador final. Neste exemplo, o último estimador é um Standard Scaler, que é um transformador, então o pipeline possui um método transform() que aplica todas as transformações aos dados em sequência (tam-bém possui um método fit_transform que poderíamos ter usado em vez de chamar a fit() e depois transform() ). Agora, seria bom se pudéssemos fornecer diretamente em nosso pipeline um Data Frame Pandas que contivesse colunas não numéricas em vez de termos que primeiro extrair manualmente as colunas numéricas em um array Num Py. Não há nada no Scikit-Learn que lide com os Data Frames Pandas,19 mas podemos escrever um transformador per-sonalizado para esta tarefa: from sklearn. base import Base Estimator, Transformer Mixin class Data Frame Selector(Base Estimator, Transformer Mixin): def __init__(self, attribute_names): self. attribute_names = attribute_names def fit(self, X, y=None): return self def transform(self, X): return X[self. attribute_names]. values Nosso Data Frame Selector transformará os dados selecionando os atributos desejados, descartando o resto e convertendo o Data Frame resultante em um array Num Py. Com isso, você pode facilmente escrever um pipeline que terá um Data Frame Pandas e lidar apenas com os valores numéricos: o pipeline iniciaria apenas com um Data Frame Selector para escolher os atributos numéricos, seguido dos outros passos de pré-processamen-to que discutimos anteriormente. E você também pode escrever outro pipeline com facilidade para os atributos categóricos simplesmente ao selecioná-los utilizando um Data Frame Selector e depois aplicando um Categorical Encoder. 19 Confira também Pull Request #3886, que deve introduzir uma classe Column Transformer, qu e facilitará transformações específicas de atributos. Você também pode testar pip3 install sklearn-pandas para obter uma classe Data Frame Mapper com um objetivo semelhante. CG_MIOLO_Hands_On_Machine_Learning. indb 70 07/05/2019 17:08:10 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
Selecione e Treine um Modelo | 71num_attribs = list(housing_num) cat_attribs = ["ocean_proximity"] num_pipeline = Pipeline([ ('selector', Data Frame Selector(num_attribs)), ('imputer', Imputer(strategy="median")), ('attribs_adder', Combined Attributes Adder()), ('std_scaler', Standard Scaler()), ]) Mas como é possível juntar esses dois pipelines em um único? A resposta é utilizar a classe Feature Union do Scikit-Learn. Você lhe dá uma lista de transformadores (que po-dem ser pipelines transformadores inteiros); quando o método transform() é chamado, ele executa cada método transform() em paralelo, aguarda sua saída e, em seguida, os concatena e retorna o resultado (e, claro, chamar o método fit() chama cada método fit() do transformador). Um pipeline completo que manipula ambos atributos numé-ricos e categóricos pode ser mais ou menos assim: from sklearn. pipeline import Feature Union full_pipeline = Feature Union(transformer_list=[ ("num_pipeline", num_pipeline), ("cat_pipeline", cat_pipeline), ]) E você pode executar todo o pipeline simplesmente: >>> housing_prepared = full_pipeline. fit_transform(housing)>>> housing_prepared array([[-1. 15604281, 0. 77194962, 0. 74333089,..., 0. , 0. , 0. ], [-1. 17602483, 0. 6596948,-1. 1653172,..., 0. , 0. , 0. ], [... ] >>> housing_prepared. shape(16512, 16) Selecione e Treine um Modelo Finalmente! Você enquadrou o problema, obteve os dados e os explorou, selecionou um conjunto de treinamento e um conjunto de testes e escreveu canais de transformação para limpar e preparar automaticamente seus dados para os algoritmos de Aprendizado de Máquina. Agora você está pronto para selecionar e treinar um modelo de Aprendizado de Máquina. CG_MIOLO_Hands_On_Machine_Learning. indb 71 07/05/2019 17:08:10 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
72 | Capítulo 2: Projeto de Aprendizado de Máquina de Ponta a Ponta Treinando e Avaliando o Conjunto de Treinamento A boa notícia é que, graças a todas essas etapas anteriores, as coisas agora serão muito mais simples do que você pensa. Treinaremos primeiro um modelo de Regressão Linear, como fizemos no capítulo anterior: from sklearn. linear_model import Linear Regression lin_reg = Linear Regression() lin_reg. fit(housing_prepared, housing_labels) Feito! Agora, você possui um modelo de Regressão Linear funcional. Vamos tentar isso em algumas instâncias do conjunto de treinamento: >>> some_data = housing. iloc[:5] >>> some_labels = housing_labels. iloc[:5] >>> some_data_prepared = full_pipeline. transform(some_data)>>> print("Predictions:", lin_reg. predict(some_data_prepared)) Predictions: [ 210644. 6045 317768. 8069 210956. 4333 59218. 9888 189747. 5584] >>> print("Labels:", list(some_labels)) Labels: [286600. 0, 340600. 0, 196900. 0, 46300. 0, 254500. 0] Funciona, embora as previsões não sejam exatamente precisas (por exemplo, a primeira previsão tem cerca de 40% de erro!). Vamos medir a RMSE desse modelo de regressão em todo o conjunto de treinamento com o uso da função mean_squared_error do Scikit-Learn: >>> from sklearn. metrics import mean_squared_error >>> housing_predictions = lin_reg. predict(housing_prepared) >>> lin_mse = mean_squared_error(housing_labels, housing_predictions) >>> lin_rmse = np. sqrt(lin_mse) >>> lin_rmse 68628. 198198489219 Ok, isso é melhor do que nada, mas certamente não é uma grande pontuação: a maioria dos median_housing_values dos bairros varia entre US$ 120 mil e US$ 265 mil, então um erro de margem típico de US$ 68. 628 não é muito aceitável. Este é um exemplo de um modelo de subajuste dos dados de treinamento. Quando isso acontece, pode significar que as características não fornecem informações suficientes para fazer boas previsões ou que o modelo não é suficientemente poderoso. Como vimos no capítulo anterior, as principais formas de corrigir o subajuste são: selecionar um modelo mais poderoso, alimentar o al-goritmo de treinamento com melhores características ou reduzir as restrições no modelo. Este modelo não é regularizado, o que exclui a última opção. Você poderia tentar adicionar mais características (por exemplo, o registro da população), mas primeiro vamos tentar um modelo mais complexo para ver como ele se sai. CG_MIOLO_Hands_On_Machine_Learning. indb 72 07/05/2019 17:08:11 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
Selecione e Treine um Modelo | 73Treinaremos um Decision Tree Regressor. Este é um modelo poderoso, capaz de encontrar relações não lineares complexas nos dados (as Árvores de Decisão serão apresentadas com mais detalhes no Capítulo 6). O código deve ser familiar agora: from sklearn. tree import Decision Tree Regressor tree_reg = Decision Tree Regressor() tree_reg. fit(housing_prepared, housing_labels) Agora que o modelo está treinado, vamos avaliá-lo no conjunto de treinamento: >>> housing_predictions = tree_reg. predict(housing_prepared) >>> tree_mse = mean_squared_error(housing_labels, housing_predictions) >>> tree_rmse = np. sqrt(tree_mse) >>> tree_rmse 0. 0 Espere, o quê?! Nenhum erro? Será que esse modelo é realmente absolutamente perfeito? Claro, é muito mais provável que o modelo tenha se sobreajustado mal aos dados. Como você pode ter certeza? Como vimos anteriormente, você não pode tocar no conjunto de testes até que esteja pronto para lançar um modelo confiável, então você precisa utilizar parte do conjunto de treinamento para treinar, e parte para validar o modelo. Avaliando Melhor com a Utilização da Validação Cruzada Uma maneira de avaliar o modelo da Árvore de Decisão seria utilizar a função train_test_split para dividir o conjunto de treinamento em um conjunto menor de treinamento e um conjunto de validação, em seguida treinar seus modelos com o con-junto menor e avaliá-los com o conjunto de validação. É um pouco trabalhoso, mas nada muito difícil e funciona muito bem. Uma ótima alternativa é utilizar o recurso da validação cruzada do Scikit-Learn. O código a seguir executa a validação cruzada K-fold : ele divide aleatoriamente o conjunto de treinamento em 10 subconjuntos distintos chamados de partes ( folds), então treina e avalia o modelo da Árvore de Decisão 10 vezes escolhendo uma parte ( fold) diferente a cada uma delas para avaliação e treinando nas outras 9 partes. O resultado é um array contendo as 10 pontuações de avaliação: from sklearn. model_selection import cross_val_score scores = cross_val_score(tree_reg, housing_prepared, housing_labels, scoring="neg_mean_squared_error", cv=10) tree_rmse_scores = np. sqrt(-scores) CG_MIOLO_Hands_On_Machine_Learning. indb 73 07/05/2019 17:08:11 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
74 | Capítulo 2: Projeto de Aprendizado de Máquina de Ponta a Ponta Os recursos da validação cruzada do Scikit-Learn esperam uma função de utilidade (mais alta é melhor) ao invés de uma função de custo (mais baixa é melhor), de modo que a função de pontuação é exatamente o oposto do MSE (ou seja, um valor negativo), e é por isso que o código anterior calcula-scores antes de calcular a raiz quadrada. Vamos olhar os resultados: >>> def display_scores(scores):... print("Scores:", scores)... print("Mean:", scores. mean())... print("Standard deviation:", scores. std())... >>> display_scores(tree_rmse_scores) Scores: [ 70232. 0136482 66828. 46839892 72444. 08721003 70761. 50186201 71125. 52697653 75581. 29319857 70169. 59286164 70055. 37863456 75370. 49116773 71222. 39081244]Mean: 71379. 0744771 Standard deviation: 2458. 31882043 Agora a Árvore de Decisão não tem uma aparência tão boa quanto antes. Na verdade, parece ser pior do que o modelo de Regressão Linear! Observe que a validação cruzada permite que você obtenha não apenas uma estimativa do desempenho do seu modelo, mas também uma medida da precisão dessa estimativa (ou seja, seu desvio padrão). A Árvore de Decisão possui uma pontuação de aproximadamente 71. 379, geralmente ± 2. 458. Você não teria essa informação se utilizasse apenas um conjunto de validação. Mas a validação cruzada treina o modelo várias vezes, então nem sempre é possível. Calcularemos as mesmas pontuações para o modelo de Regressão Linear apenas para ter certeza: >>> lin_scores = cross_val_score(lin_reg, housing_prepared, housing_labels,... scoring="neg_mean_squared_error", cv=10)... >>> lin_rmse_scores = np. sqrt(-lin_scores) >>> display_scores(lin_rmse_scores) Scores: [ 66782. 73843989 66960. 118071 70347. 95244419 74739. 57052552 68031. 13388938 71193. 84183426 64969. 63056405 68281. 61137997 71552. 91566558 67665. 10082067] Mean: 69052. 4613635 Standard deviation: 2731. 6740018 É isso mesmo: o modelo da Árvore de Decisão está se sobreajustando tanto que acaba sendo pior do que o modelo de Regressão Linear. Vamos tentar um último modelo agora: Random Forest Regressor. Como veremos no Capí-tulo 7, Florestas Aleatórias funcionam com o treinamento de muitas Árvores de Decisão em subconjuntos aleatórios das características, e em seguida calculam a média de suas CG_MIOLO_Hands_On_Machine_Learning. indb 74 07/05/2019 17:08:11 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
Selecione e Treine um Modelo | 75previsões. Construir um modelo em cima de muitos outros modelos é chamado Ensemble Learning, e muitas vezes é uma ótima maneira de aumentar ainda mais os algoritmos de Aprendizado de Máquina. Ignoraremos a maior parte do código, pois é essencialmente o mesmo para os outros modelos: >>> from sklearn. ensemble import Random Forest Regressor >>> forest_reg = Random Forest Regressor() >>> forest_reg. fit(housing_prepared, housing_labels) >>> [... ] >>> forest_rmse21941. 911027380233 >>> display_scores(forest_rmse_scores) Scores: [ 51650. 94405471 48920. 80645498 52979. 16096752 54412. 74042021 50861. 29381163 56488. 55699727 51866. 90120786 49752. 24599537 55399. 50713191 53309. 74548294] Mean: 52564. 1902524 Standard deviation: 2301. 87380392 Isso é muito melhor: Florestas Aleatórias parecem muito promissoras. No entanto, note que a pontuação no conjunto de treinamento ainda é muito menor do que nos conjuntos de validação, o que significa que o modelo ainda está se sobreajustando ao conjunto de treinamento. Possíveis soluções para sobreajustes são: simplificar o modelo, restringi-lo (ou seja, regularizá-lo), ou obter muito mais dados de treinamento. No entanto, antes de mergulhar mais profundamente em Florestas Aleatórias, você deve experimentar muitos outros modelos de várias categorias de algoritmos de Aprendizado de Máquina (várias Máquinas de Vetores de Suporte com diferentes kernels, possivelmente uma rede neural, etc. ), sem gastar muito tempo ajustando os hiperparâmetros. O objetivo é selecionar alguns modelos promissores (de dois a cinco). Você deve salvar todos os modelos que experimenta para que possa voltar facilmente para qualquer um deles. Certifique-se de salvar os hiperparâme-tros e os parâmetros treinados, bem como as pontuações de validação cruza-da e talvez as previsões também. Isso permitirá que você compare facilmente as pontuações entre tipos de modelo e compare os tipos de erros que eles cometem. Você pode facilmente salvar modelos do Scikit-Learn utilizando o módulo pickle do Python ou usando o sklearn. externals. joblib, que é mais eficiente na serialização de grandes arrays Num Py: from sklearn. externals import joblib joblib. dump(my_model, "my_model. pkl") # and later... my_model_loaded = joblib. load("my_model. pkl") CG_MIOLO_Hands_On_Machine_Learning. indb 75 07/05/2019 17:08:12 | Mãos à obra Aprendizado de máquina Aurelien Geron.pdf |
End of preview. Expand
in Dataset Viewer.
README.md exists but content is empty.
Use the Edit dataset card button to edit it.
- Downloads last month
- 3