CURSO MACHINE LEARNING

COM PYTHON

Sobre o Curso:
Aprenda o funcionamento dos principais algoritmos de Machine Learning bem
como a utilização de ferramentas para criar aplicações práticas.
 CURSO MACHINE LEARNING COM PYTHON

APRESENTAÇÃO
O MATERIAL
Este material foi construído pensando em seu processo de aprendizagem. Nele você
encontrará informações importantes que poderão ser usadas como referência para o seu tra-
balho com Machine Learning durante e após o curso.

O CURSO
Este curso ensina a utilização de diversos módulos por meio da construção de proje-
tos e algoritmos que visam as necessidades comuns tanto no ambiente corporativo quanto
em um ambiente acadêmico.
Serão abordados algoritmos de classificação, regressão, cauterização e diversos ou-
tros.

APRENDIZAGEM
O curso possui trechos teóricos, entretanto, o conteúdo geral é voltado para a prá-
tica, e ao longo do mesmo é interessante que a replicação dos códigos seja executada.

PRÉ-REQUISITOS
Possuir conhecimento básico na linguagem Python e na utilização de módulos. Tam-
bém é necessário um conhecimento básico de Estatística e operações com matrizes (n este
livro existe uma revisão de matemática e estatística que deve ser conferida ).

Página 2
 CURSO MACHINE LEARNING COM PYTHON

CONTROLE DE VERSÃO
As informações contidas neste material se referem ao curso de Machine Learning
com Python. Abaixo é apresentado o controle de versão deste material e respectivos autores
e revisores.

Data Versão Autor(es) Revisor(es)

27/01/2019 1.0 Vinício Schmidt

Página 3
CURSO MACHINE LEARNING COM PYTHON

SUMÁRIO
O que é Machine Learning? .......................................................................................................... 8
História ................................................................................................................................... 8

Aplicações ............................................................................................................................... 9
Critérios de classificação .............................................................................................................. 9
Tipo de supervisão................................................................................................................. 10
Aprendizagem on-line e em lotes ........................................................................................... 14

Aprendizagem baseada em instância versus aprendizagem baseada em modelo ...................... 16

Maiores desafios do Machine Learning ....................................................................................... 19
Quantidade insuficiente de dados de treinamento.................................................................. 19

Dados de treinamento não representativo ............................................................................. 20

Dados de baixa qualidade ...................................................................................................... 21
Dados irrelevantes ................................................................................................................. 22
Sobre ajuste (Overfitting) ...................................................................................................... 22

Sub ajuste (Underfitting) ....................................................................................................... 23

Teste e Validação ....................................................................................................................... 23
Validação cruzada .................................................................................................................. 24
Revisão Matemática e Estatística ............................................................................................... 25

Média ................................................................................................................................... 25
mediana ................................................................................................................................ 25
Moda .................................................................................................................................... 26

Variância ............................................................................................................................... 26
Pontos................................................................................................................................... 27
Distância entre dois pontos ................................................................................................... 28
Matrizes ................................................................................................................................ 28

Introdução ao módulo Matplotlib ............................................................................................... 31

Gráficos com pyplot ............................................................................................................... 31
Introdução ao módulo Numpy .................................................................................................... 40
Instalação .............................................................................................................................. 40
Criação de arrays ................................................................................................................... 40
Propriedades de um array ...................................................................................................... 43
Acesso de itens ...................................................................................................................... 44

Substituição de valores .......................................................................................................... 45

Fatiamento de arrays ............................................................................................................. 45
União de Arrays ..................................................................................................................... 46

Separação de Arrays .............................................................................................................. 48

Remodelamento de Arrays ..................................................................................................... 50

Página 4
CURSO MACHINE LEARNING COM PYTHON

Operações Aritméticas ........................................................................................................... 51

Funções estatísticas ............................................................................................................... 53

Datetimes e Timedeltas ......................................................................................................... 53
Introdução ao módulo pandas .................................................................................................... 56
Instalação .............................................................................................................................. 56

Estruturas de dados ............................................................................................................... 57

Séries .................................................................................................................................... 59
Métodos Estatísticos ............................................................................................................. 69
Conversão de tipos ................................................................................................................ 70

Classificação .......................................................................................................................... 73
Aplicando uma função ........................................................................................................... 74
DataFrames ........................................................................................................................... 75

Importação de arquivos ......................................................................................................... 76

União de Data Frames ............................................................................................................ 88
Obtenção de dados .................................................................................................................... 92
Módulo Quandl ..................................................................................................................... 92

Introdução à análise exploratória e ao módulo Seaborn ............................................................ 100

Instalação ............................................................................................................................ 100
Obtenção de dados .............................................................................................................. 100

Visualizando relações estatísticas ........................................................................................ 101

Plotagem com dados categóricos ......................................................................................... 108
Visualizando a Distribuição de um Conjunto de Dados .......................................................... 116
Visualizando relacionamentos lineares ................................................................................. 120

Classificação ............................................................................................................................ 124

Naive Bayes ............................................................................................................................. 124
Implementação manual ....................................................................................................... 125

Implementação em Python .................................................................................................. 127

Pipelines .................................................................................................................................. 129
Regressão Linear ...................................................................................................................... 132
A Equação Normal ............................................................................................................... 133

Complexidade computacional .............................................................................................. 135

Gradiente Descendente ....................................................................................................... 135
Gradiente Descendente Estocástico ..................................................................................... 139

Gradiente Descendente em Mini-Lotes ................................................................................. 141

Regressão polinomial ........................................................................................................... 142
Curvas de Aprendizagem ...................................................................................................... 144
Erros de generalização ......................................................................................................... 147

Modelos lineares regularizados ............................................................................................ 147

Página 5
CURSO MACHINE LEARNING COM PYTHON

Regressão de Ridge .............................................................................................................. 147

Regressão Lasso .................................................................................................................. 148

Rede elástica ....................................................................................................................... 149
Parada antecipada ............................................................................................................... 150
Regressão logística .............................................................................................................. 151

Máquinas de Vetor de Suporte ................................................................................................. 155

Classificação SVM linear ...................................................................................................... 155
Classificação de Margem Suave ............................................................................................ 156
Classificação SVM não linear ................................................................................................ 158

Kernel Polinomial ................................................................................................................ 159

Kernel Gaussiano RBF .......................................................................................................... 160
Regressão SVM .................................................................................................................... 162

Árvores de Decisão .................................................................................................................. 163

Treinando e visualizando uma árvore de decisão .................................................................. 163
Fazendo previsões ............................................................................................................... 165
Estimando Probabilidades de Classe ..................................................................................... 167

O algoritmo de treinamento CART ........................................................................................ 167

Hiper parâmetros de regularização ...................................................................................... 168
Regressão ............................................................................................................................ 169

Instabilidade ....................................................................................................................... 172

Algoritmos Ensemble ............................................................................................................... 174
Classificadores de votação ................................................................................................... 174
Bagging and Pasting no Scikit-Learn ..................................................................................... 178

Avaliação Out-of-Bag ........................................................................................................... 179

Boosting .............................................................................................................................. 180
AdaBoost............................................................................................................................. 180

Gradient Boosting ................................................................................................................ 182

Stacking .............................................................................................................................. 186
Florestas Aleatórias ................................................................................................................. 190
Árvores Extras ..................................................................................................................... 191

Importância de um atributo ................................................................................................. 191

Processamento de Linguagem Natural ...................................................................................... 193
Como funciona? .................................................................................................................. 194

Processamento .................................................................................................................... 195

Obtenção de conjuntos de dados ......................................................................................... 211
Aprendizado não supervisionado .............................................................................................. 212
K-means .............................................................................................................................. 212

Deep Learning ......................................................................................................................... 218

Página 6
CURSO MACHINE LEARNING COM PYTHON

Algumas aplicações.............................................................................................................. 219

Introdução às redes neurais artificiais .................................................................................. 219

Dos neurônios biológicos aos artificiais ................................................................................ 219
Neurônios biológicos ........................................................................................................... 220
Computações Lógicas com Neurônios ................................................................................... 221

O Perceptron ....................................................................................................................... 222

Perceptron multicamada e retropropagação......................................................................... 226
Tensorflow, Keras e PyTorch ................................................................................................ 229
Detenção de Diabetes usando Deep Learning com Keras ....................................................... 231

Lista de verificação do projeto de aprendizado de máquina .................................................. 236

Página 7
 CURSO MACHINE LEARNING COM PYTHON

CAPÍTULO 1
O que é Machine Learning?
Machine learning é um subconjunto de estudo da inteligência Artificial e se resume a
um conjunto de programação e estatística. Uma das melhores classificações de machine lear-
ning é trazida por François Chollet na qual ele define machine learning como "um novo para-
digma de programação". Isso se deve a forma com que os algoritmos de machine learning
funcionam.
Um programa de computador comum pode ser resumido em um conjunto de dados e
regras que produzem um resultado. Já em um programa de machine learning, se entrega as
entradas e os resultados esperados e as regras são geradas pelo program a.

HISTÓRIA
A história da Inteligência Artificial (IA) começou na antiguidade, com mitos, histórias
e rumores de seres artificiais dotados de inteligência ou consciência por mestres artesãos. Já
as sementes da IA moderna foram plantadas por filósofos clássicos que tentaram descrever o
processo do pensamento humano como a manipulação mecânica de símbolos.
Este trabalho culminou na invenção do computador digital programável na década de
1940, uma máquina baseada na essência abstrata do raciocínio matemático. Esse dispositivo
e as idéias por trás dele inspiraram um punhado de cientistas a começar a discutir seria-
mente a possibilidade de construir um cérebro eletrônico.
O campo da pesquisa em IA foi fundado em uma oficina realizada no campus do Dart-
mouth College durante o verão de 1956.
Os participantes se tornaram os líderes da pesquisa em IA por décadas. Muitos deles
previram que uma máquina tão inteligente quanto um ser humano existiria em não mais de
uma geração e receberam milhões de dólares para tornar essa visão realidade.
Entretanto, ficou óbvio que eles subestimaram grosseiramente a dificuldade do pro-
jeto. Em 1973, em resposta às críticas de James Lighthill e à pressão constante do congresso,
os governos dos EUA e da Grã-Bretanha pararam de financiar pesquisas não direcionadas so-
bre inteligência artificial, e os anos difíceis que se seguiram seriam mais tarde conhecidos
como "inverno da IA".
Sete anos depois, uma iniciativa visionária do governo japonês inspirou governos e a
indústria a fornecer à IA bilhões de dólares, mas no final dos anos 80 o s investidores ficaram
desiludidos com a ausência da energia necessária para o computador (hardware) e retiraram
o financiamento novamente.
O investimento e o interesse em IA cresceram nas primeiras décadas do século XXI,
quando o aprendizado de máquina foi aplicado com sucesso a muitos problemas na acade-
mia e na indústria devido a novos métodos, à aplicação de um poderoso hardware de com-
putador e à coleta de imensos conjuntos de dados.

Página 8
 CURSO MACHINE LEARNING COM PYTHON

APLICAÇÕES
Inteligência artificial está em todo lugar. Ao sair de casa por exemplo e checar o trân-
sito pelo Google Maps uma predição de trânsito é utilizada baseando-se em uma inteligência
artificial. De forma similar, aplicativos de transporte como o Uber, Cabify e 99 usam um algo-
ritmo de machine learning para a predição de preço.
Ao entrar em um site de vendas, produtos são recomendados com base nas procuras
usando um algoritmo de recomendação. Nas redes sociais com algoritmos de reconheci-
mento facial e sugestões de amizade são comuns. Em sistemas de email, o reconhecimento
de spam e de arquivos com vírus são feitos usando técnicas de Machine Learning. Chatbots
também são outra aplicação prática do uso de machine learning. Bancos também usam ma-
chine learning na detecção de fraudes bancárias.
Desta forma, pode-se elencar 4 grandes problemas que o machine learning se torna
muito recomendado:
● Problemas para os quais as soluções existentes exigem muita sintonia manual ou lon-
gas listas de regras: um algoritmo de Machine Learning geralmente pode simplificar
o código e ter um desempenho melhor.
● Problemas complexos para os quais não existe uma boa solução usando uma aborda-
gem tradicional: técnicas de Machine Learning podem encontrar uma solução.
● Ambientes instáveis: um sistema de Machine Learning pode se adaptar a novos da-
dos.
● Obter informações sobre problemas complexos e grandes quantidades de dados.

Critérios de classificação
Pode-se classificar um algoritmo de Machine Learning com base em três principais
características:
1. Se eles são ou não treinados com supervisão humana se dividindo em:
a. supervisionado
b. não supervisionado
c. semi supervisionado
d. aprendizado por reforço
2. Se eles podem ou não aprender de forma incremental em tempo real, dividindo -se
em:
a. Aprendizado on-line
b. Aprendizado em lotes
3. Existe ainda a diferenciação por forma de funcionamento:
a. Aprendizado baseado em instância (funcionam simplesmente comparando
novos pontos de dados com pontos de dados conhecidos)
b. Aprendizado baseado em modelo (detectando padrões nos dados de treina-
mento e construindo um modelo preditivo, assim como os cientistas)

Esses critérios não são exclusivos,

ou seja, é possível combiná-los da maneira que quiser.

Página 9
 CURSO MACHINE LEARNING COM PYTHON

Por exemplo, o filtro de spam pode ser um sistema de aprendizado on -line, baseado
em modelo e supervisionado.

TIPO DE SUPERVISÃO
APRENDIZADO SUPERVISIONADO
No aprendizado supervisionado, os dados de treinamento que são alimentados para
o algoritmo incluem as soluções desejadas, chamadas de saídas ou rótulos (labels):

Figura 1 Conjunto de dados rotulado para aprendizado supervisionado

Uma tarefa típica de aprendizado supervisionado é a classificação. O filtro de spam é

um bom exemplo disso pois ele é treinado com muitos e -mails de exemplo, juntamente com
sua classe (spam ou não), e precisa aprender a class ificar novos e-mails.
Outra tarefa típica é prever um valor numérico de destino, como o preço de um
carro, dado um conjunto de recursos (quilometragem, idade, marca, etc.) chamados predito-
res. Esse tipo de tarefa é chamado de regressão.
Para treinar o sistema, é necessário dar muitos exemplos de carros, incluindo os pre-
ditores e os rótulos (ou seja, os preços).

APRENDIZAGEM NÃO SUPERVISIONADA

No aprendizado não supervisionado, como você pode imaginar, os dados de treina-
mento não são rotulados. O sistema tenta aprender sem um professor.

Figura 2 Conjunto de dados sem rótulos para aprendizado não supervisionado

Página 10
 CURSO MACHINE LEARNING COM PYTHON

Abaixo estão representados alguns dos mais importantes algoritmos de aprendizado

não supervisionado divididos em algumas de suas funções:
● Clusterização
○ k-Means
○ Análise de Cluster Hierárquica (Hierarchical Cluster Analysis ou HCA)
○ Maximização de Expectativas
● Visualização e redução de dimensionalidade
○ Análise do componente principal (Principal Component Analysis ou PCA)
○ Kernel PCA
○ Incorporação localmente linear (Locally-Linear Embedding ou LLE)
○ incorporação estocástica de vizinhos distribuídos em t do inglês t -distributed
Stochastic Neighbor Embedding (t-SNE)
● Aprendizagem de regras de associação
○ Apriori
○ Eclat

Supondo por exemplo, um blog, é possível executar um algoritmo de clustering para

tentar detectar grupos de visitantes semelhantes. Em nenhum momento é dito ao algoritmo
a que grupo um visitante pertence: ele encontra essas conexões sem ajuda.

Figura 3 Processo de Clusterização

Os algoritmos de visualização também são bons exemplos de algoritmos de aprendi-

zado não supervisionado. Seu funcionamento inicia com a alimentação de muitos dados
complexos e não rotulados, e eles produzem uma representação 2D ou 3D dos dados que po-
dem ser facilmente plotados.
Esses algoritmos tentam preservar o máximo de estrutura possível para que seja pos-
sível entender como os dados são organizados e, talvez, identificar padrões inesperados.
Observe, por exemplo, como os animais são bem separados dos veículos, co mo os
cavalos estão próximos dos cervos, mas longe dos pássaros, e assim por diante.

Página 11
 CURSO MACHINE LEARNING COM PYTHON

Figura 4 Exemplo de uma visualização t-SNE destacando clusters semânticos

Outra tarefa importante não supervisionada é a detecção de anomalias - por exem-

plo, a detecção de transações incomuns com cartão de crédito para evitar fraudes, a detec-
ção de defeitos de fabricação ou a remoção automática de valores discrepantes de um con-
junto de dados antes de alimentá-lo com outro algoritmo de aprendizado.
O sistema é treinado com instâncias normais e, quando vê uma nova instância, pode
dizer se parece com uma normal ou se é provável que seja uma anomalia.

Figura 5 Detecção de Anomalias

Outra tarefa comum, não supervisionada, é a aprendizagem de regras de associação,

na qual o objetivo é cavar grandes quantidades de dados e descobrir relações interessantes
entre atributos.

Página 12
 CURSO MACHINE LEARNING COM PYTHON

Por exemplo, suponha um supermercado. A execução de uma regra de associação em

seus registros de vendas pode revelar que as pessoas que compram molho barbecue e bata-
tas fritas também tendem a comprar bife. Portanto, convém colocar esses itens um perto do
outro.

APRENDIZAGEM SEMI SUPERVISIONADA

Alguns algoritmos podem lidar com dados de treinamento parcialmente rotulados,
geralmente muitos dados não rotulados e um pouco de dados rotulados. Isso é chamado de
aprendizado semi supervisionado.
Um bom exemplo é o Google Fotos pois depois de carregar todas as fotos de sua fa-
mília, ele reconhece automaticamente que a mesma pessoa A aparece nas fotos 1, 5 e 11,
enquanto outra pessoa B aparece nas fotos 2, 5 e 7. Essa é a parte não supervisionada do al-
goritmo. Agora, tudo o que o sistema precisa é que você diga quem são essas pessoas para
se tornar capaz de nomear todos em todas as fotos, o que é útil para pesquisar fotos.

Figura 6 Aprendizado semi supervisionado

APRENDIZAGEM POR REFORÇO

O aprendizado por reforço é bem peculiar pois tem seu funcionament o baseado em
recompensas e penalidades.
O sistema de aprendizado, chamado agente (neste contexto), pode observar o ambi-
ente, selecionar e executar ações e receber recompensas ou penalidades em troca.
Em seguida, deve aprender por si qual é a melhor estratégia, chamada de política,
para obter a maior recompensa ao longo do tempo. Uma política define qual ação o agente
deve escolher quando estiver em uma determinada situação.
Por exemplo, muitos robôs implementam algoritmos de aprendizado por reforço
para aprender a andar.
O programa AlphaGo do DeepMind também é um bom exemplo de aprendizado por
reforço. Ele venceu o campeão mundial Lee Sedol no jogo Go. Ele aprendeu sua política de
vitória analisando milhões de jogos e depois jogando muitos jogos contra si mesmo.

Página 13
 CURSO MACHINE LEARNING COM PYTHON

Figura 7 Aprendizado por reforço

APRENDIZAGEM ON-LINE E EM LOTES

Outro critério usado para classificar os sistemas de Machine Learning é se o sistema
pode ou não aprender de forma incremental a partir de um fluxo de dados recebidos.

APRENDIZADO EM LOTES
No aprendizado em lote, o sistema é incapaz de aprender de forma incremental pois
ele deve ser treinado usando todos os dados disponíveis. Geralmente, isso leva mui to tempo
e recursos de computação por isso, normalmente, é feito com o sistema desligado, ou seja, o
sistema é treinado e, em seguida, é lançado em produção e executado sem aprender mais
apenas aplicando o que aprendeu.
Desta forma, para que um sistema de aprendizado em lote saiba sobre novos dados
(como um novo tipo de spam), é necessário treinar uma nova versão do sistema do zero no
conjunto de dados completo (não apenas os novos dados, mas também os dados antigos).
Ainda é necessário parar o sistema antigo e substituí-lo o pelo novo.
Além disso, o treinamento no conjunto completo de dados requer muitos recursos
de computação (CPU, espaço em memória, espaço em disco, E/S de disco, E/S de rede etc.).
Se existirem muitos dados e o sistema for treinado do zero todos os dias, isso acaba
custando muito dinheiro. Se a quantidade de dados for enorme, pode ser impossível usar um
algoritmo de aprendizado em lote.
Por fim, se o sistema precisa aprender de forma autônoma e possui recursos limita-
dos (por exemplo, um aplicativo para smartphone ou um rover em Marte), transportar gran-
des quantidades de dados de treinamento e consumir muitos recursos para treinar por horas
todos os dias é um empecilho.

Página 14
 CURSO MACHINE LEARNING COM PYTHON

APRENDIZADO ONLINE
No aprendizado on-line, o sistema é treinado de forma incremental, alimentando ins-
tâncias de dados sequencialmente, individualmente ou por pequenos grupos chamados mini -
lotes.
Cada etapa do aprendizado é rápida e barata, para que o sistema possa aprender so-
bre novos dados rapidamente, à medida que eles chegam.

Figura 8 Aprendizado Online

O aprendizado on-line é ótimo para sistemas que recebem dados de um fluxo contí-
nuo (por exemplo, preços das ações) e precisam se adaptar às mudanças de forma rápida ou
autônoma.
Também é uma boa opção se os recursos de computação forem limitados, pois, após
um sistema de aprendizado on-line aprender sobre novas instâncias de dados, ele não pre-
cisa mais delas, podendo descartá-las (a menos que queira reverter para uma versão ante-
rior). Isso pode economizar uma quantidade enorme de espaço.
Os algoritmos de aprendizado on-line também podem ser usados para treinar siste-
mas em grandes conjuntos de dados que não cabem na memória principal de uma máquina
(isso é chamado de aprendizado fora do núcleo). O algoritmo carrega parte dos dados, exe-
cuta uma etapa de treinamento nesses dados e repete o processo até que seja executado em
todos os dados.

Figura 9
Aprendizado online
usado em um conjunto
de dados muito grande

Página 15
 CURSO MACHINE LEARNING COM PYTHON

Um parâmetro importante dos sistemas de aprendizado on -line é a rapidez com que

eles devem se adaptar à alteração dos dados, este parâmetro é chamado de taxa de aprendi-
zado. Ao definir uma alta taxa de aprendizado, o sistema se adapta rapidamente a no vos da-
dos, mas também tenderá a esquecer rapidamente os dados antigos.
Por outro lado, ao definir uma baixa taxa de aprendizado, o sistema terá mais inér-
cia, isto é, ele aprenderá mais lentamente, mas também será menos sensível ao ruído nos
novos dados ou a sequências de pontos de dados não representativos.
Um grande desafio do aprendizado on-line é que, se dados incorretos forem forneci-
dos ao sistema, o desempenho do sistema diminuirá gradualmente. Se estamos falando de
um sistema ativo, os clientes perceberão.
Por exemplo, dados ruins podem vir de um sensor com defeito em um robô ou de al-
guém enviando um spam para um mecanismo de pesquisa para tentar obter uma classifica-
ção alta nos resultados de pesquisa.
Para reduzir esse risco, é necessário monitorar o sistema de perto e prontamente de-
sativar o aprendizado (e possivelmente reverter para um estado anterior) ao detectar uma
queda no desempenho. Também é possível monitorar os dados de entrada e reagir a dados
anormais (por exemplo, usando um algoritmo de detecção de anomalias).

APRENDIZAGEM BASEADA EM INSTÂNCIA VERSUS

APRENDIZAGEM BASEADA EM MODELO
Mais uma maneira de categorizar os sistemas de Machine Learning é como eles ge-
neralizam. A maioria das tarefas de Machine Learning é sobre fazer previsões. I sso significa
que, dados vários exemplos de treinamento, o sistema precisa ser capaz de generalizar para
exemplos que nunca viu antes.
Ter uma boa medida de desempenho nos dados de treinamento é bom, mas insufici-
ente, o verdadeiro objetivo é ter um bom desempenho em novas instâncias.
Existem duas abordagens principais para a generalização: aprendizado baseado em
instância e aprendizado baseado em modelo.

APRENDIZADO BASEADO EM INSTÂNCIA

Possivelmente, a forma mais trivial de aprender é simplesmente aprend er de cor. Ao
criar um filtro de spam usando instância, o algoritmo simplesmente irá sinalizar todos os e -
mails idênticos aos e-mails que já foram sinalizados pelos usuários.
Em vez de apenas sinalizar e-mails idênticos aos e-mails de spam conhecidos, o filtro
de spam pode ser programado para sinalizar e-mails muito semelhantes aos e-mails de spam
conhecidos.
Isso requer uma medida de semelhança entre dois e-mails. Uma medida de similari-
dade (muito básica) entre dois e-mails pode ser contar o número de palavras que eles têm

Página 16
 CURSO MACHINE LEARNING COM PYTHON

em comum. O sistema sinalizaria um email como spam se tiver muitas palavras em comum
com um email de spam conhecido.
Isso é chamado de aprendizado baseado em instância: o sistema aprende os exem-
plos de cor e depois generaliza para novos casos usando uma medida de similaridade .

Figura 10 Aprendizado baseado em instância

APRENDIZADO BASEADO EM MODELO

Outra maneira de generalizar a partir de um conjunto de exemplos é construir um
modelo desses exemplos e usá-lo para fazer previsões. Isso é chamado de aprendizado base-
ado em modelo.

Figura 11 Aprendizado baseado em modelo

Por exemplo, suponha que se queira saber se o dinheiro deixa as pessoas felizes,
para isso os valores do PIB per capita e do índice de satisfação podem ser usados.
Com base nos dados de PIB per capita e do índice de satisfação, a seguinte tabela é
obtida:

Página 17
 CURSO MACHINE LEARNING COM PYTHON

Tabela 1 Comparação do PIB per capta com o índice de satisfação

País PIB Índice de satisfação

Hungria 12,24 4.9

Coréia 27,195 5.8

França 37,675 6.5

Austrália 50,962 7.3

Estados Unidos 55,805 7.2

A Tabela 1 está representada na Figura 12.

Figura 12 índice de satisfação pelo PIB per capita

É possível notar uma correlação entre estas duas variáveis, podendo ser represen-
tado por um modelo linear de uma reta. Uma reta pode ser representada em função de duas
variáveis como visto na Equação 1.
𝑦 = 𝜃 ∗ 𝑥 + 𝜃1
Equação 1 Equação da reta

Desta forma, o trabalho de

um algoritmo baseado em modelo
é encontrar quais parâmetros (θ e
θ1) fazem com que a reta se ajuste
melhor aos dados como visto na Fi-
gura 13.

Figura 13 Algumas possibilidades de ajuste

Página 18
 CURSO MACHINE LEARNING COM PYTHON

Maiores desafios do Machine Learning

A principal tarefa de um projeto de Machine Learning é selecionar um algoritmo de
aprendizado e treiná-lo em alguns dados. Com isso, duas coisas podem dar errado: ter um
“algoritmo ruim" ou ter "dados ruins".

QUANTIDADE INSUFICIENTE DE DADOS DE TREINA-

MENTO
Para uma criança aprender o que é uma maçã, basta apontar para uma maçã e dizer
“maçã” (possivelmente repetindo esse procedimento algumas vezes). Agora a criança é ca-
paz de reconhecer maçãs em todos os tipos de cores e formas.
O aprendizado de máquina ainda não chegou a este ponto pois são necessários mui-
tos dados para que a maioria dos algoritmos de Machine Learning funcione corretamente,
mesmo para problemas muito simples, normalmente precisa-se de milhares de exemplos, e
para problemas complexos, como reconhecimento de imagem ou fala, pode -se precisar de
milhões de exemplos.
A Figura 14 é resultado do trabalho realizado pelos pesquisadores da Microsoft Mi-
chele Banko e Eric Brill e demonstra a precisão em relação a quantidade de dados usando di-
versos algoritmos diferentes.

Figura 14 A importância dos dados em diferentes algoritmos

Página 19
 CURSO MACHINE LEARNING COM PYTHON

A ideia de que os dados importam mais do que algoritmos para problemas complexos
foi popularizada por Peter Norvig em um artigo intitulado “A eficácia irracional dos dados”
publicado em 2009.
Deve-se notar, no entanto, que conjuntos de dados de pequeno e médio porte ainda
são muito comuns e nem sempre é fácil ou barato obter dados de treinamento extras, por-
tanto, a eficácia dos algoritmos ainda não pode ser abandonada.

DADOS DE TREINAMENTO NÃO REPRESENTATIVO

Usar dados que não representem o modelo obviamente irá alterar seu comporta-
mento, portanto, para generalizar bem, é crucial que seus dados de treinamento sejam re-
presentativos dos novos casos para os quais se deseja generalizar.
Por exemplo, o conjunto de países usado anteriormente para treinar o modelo linear
não era perfeitamente representativo pois alguns países estavam desaparecidos.
A Figura 15 mostra como são os dados quando os países ausentes são adicionados.

Figura 15 Uma amostra de treinamento mais representativa

Ao treinar um modelo linear nesses dados, obtém-se a linha sólida, enquanto o mo-
delo antigo é representado pela linha pontilhada. Como é possível observar, a adição de al-
guns países ausentes não apenas altera significativamente o modelo, mas também deixa
claro que um modelo linear tão simples provavelmente nunca funcionará bem.
Parece que os países muito ricos não são mais felizes do que os países moderada-
mente ricos (na verdade eles parecem mais infelizes) e, inversamente, alguns países pobres
parecem mais felizes do que muitos países ricos.
Usando um conjunto de treinamento não representativo, um modelo dificilmente
fará previsões precisas, especialmente para países muito pobres e muito ricos.
É crucial usar um conjunto de treinamento representativo dos casos para os quais se
deseja generalizar. Isso geralmente é mais difícil d o que parece: se a amostra for muito pe-
quena, muito ruído de amostragem existirá (ou seja, dados não representativos como resul-
tado do acaso), mas mesmo amostras muito grandes podem não ser representativas se o
método de amostragem for defeituoso. Isso é chamado de viés de amostragem.

Página 20
 CURSO MACHINE LEARNING COM PYTHON

Talvez o exemplo mais famoso de viés de amostragem tenha acontecido durante a

eleição presidencial dos EUA em 1936, que colocou Landon contra Roosevelt: o Literary Di-
gest, uma importante revista semanal americana, realizou uma pesquisa muito grande, envi-
ando correspondência para cerca de 10 milhões de pessoas. Ele obteve 2,4 milhões de res-
postas e previu com grande confiança que Landon receberia 57% dos votos.
Em vez disso, Roosevelt venceu com 62% dos votos. A falha estava no método de
amostragem do Literary Digest:
Primeiro, para obter os endereços para envio das pesquisas, o Literary Digest usava
listas telefônicas, listas de assinantes de revistas, listas de membros de clubes e similares.
Todas essas listas tendem a favorecer pessoas mais ricas, com maior probabilidade de votar
nos republicanos (daí Landon).
Segundo, menos de 25% das pessoas que receberam a pesquisa responderam. Nova-
mente, isso introduz um viés de amostragem, descartando pessoas que não se importam
muito com política, pessoas que não gostam do resumo literário e outros grupos -chave. Esse
é um tipo especial de viés de amostragem chamado viés de não resposta.
Um outro exemplo interessante pode ser usado com músicas. Suponha que se queira
criar um sistema para reconhecer vídeos de música funk. Uma maneira de criar seu conjunto
de treinamento é pesquisar “funk” no YouTube e usar os vídeos resultantes.
Mas isso pressupõe que o mecanismo de pesquisa do YouTube retorne um conjunto
de vídeos representativos de todos os vídeos de música funk do YouTube.
Na realidade, é provável que os resultados da pesquisa sejam direcionados a artistas
populares (e se você mora no Brasil, terá muitos vídeos de "funk carioca", que não se pare-
cem com os funks americanos do James Brown).

DADOS DE BAIXA QUALIDADE

Obviamente, se os dados de treinamento estiverem cheios de erros, discrepâncias e
ruídos (por exemplo, devido a medições de baixa qualidade), será mais difícil para o sistema
detectar os padrões subjacentes, portanto, é menos prov ável que seu sistema tenha um bom
desempenho.
Muitas vezes, vale a pena o esforço de gastar tempo limpando os dados de treina-
mento. A verdade é que a maioria dos cientistas de dados passa uma parte significativa de
seu tempo fazendo exatamente isso.
Existem formas de se tratar com dados nestas condições como por exemplo:
● Se algumas instâncias são claramente discrepantes, pode ser útil simplesmente des-
cartá-las ou tentar corrigir os erros manualmente.
● Se em alguns registros dados estiverem faltando (por exemplo, 5% de seus clientes
não especificaram sua idade), você pode decidir se deseja ignorar esse atributo de
idade completamente, preencher os valores ausentes (por exemplo, com o idade mé-
dia) ou treinar um modelo com o recurso e um modelo sem ele.

Página 21
 CURSO MACHINE LEARNING COM PYTHON

DADOS IRRELEVANTES
Seu sistema só será capaz de aprender se os dados de treinamento contiverem recur-
sos relevantes. Uma parte crítica do sucesso de um projeto de Machine Learning é apresen-
tar um bom conjunto de dados para treinar. Esse processo, chamado de engenharia de re-
cursos (feature engineering), envolve:
● Seleção de características: selecionar as características mais úteis para treinar entre
as existentes.
● Extração de características: combinar características existentes para produzir novas
mais úteis (como por exemplo, unir a quilometragem e a idade de um carro em um
novo atributo chamado depreciação).
● Criando novas características reunindo novos dados.

SOBRE AJUSTE (OVERFITTING)

Digamos que um turista esteja visitando um país estrangeiro e o motorista do táxi o
engane. Ele pode ficar tentado a dizer que todos os taxistas daquele país são ladrões.
No Machine Learning, isso é chamado de ajuste excessivo: significa que o modelo
tem um bom desempenho nos dados de treinamento, mas não generaliza bem.
A generalização excessiva é algo que humanos fazem com muita frequência e, infeliz-
mente, as máquinas podem cair na mesma armadilha se certos cuidados não forem tomados.
A Figura 16 representa uma aproximação polinomial (vista em detalhes a frente) da
satisfação pelo PIB per capita. Ele acerta muito bem os dados atuais, entretanto, adicionar
um novo valor
pode gerar um re-
sultado completa-
mente inesperado.
O sobre ajuste
acontece quando o
modelo é muito
complexo em rela-
ção à quantidade
de ruído dos dados de treina- Figura 16 Modelo Sobre Ajustado
mento.
As soluções possíveis são:
● Simplificar o modelo selecionando um com menos parâmetros (por exemplo, um mo-
delo linear em vez de um modelo polinomial de alto grau), reduzindo o número de
atributos nos dados de treinamento ou restringindo o modelo
● Coletar mais dados de treinamento

Reduzir o ruído nos dados de treinamento (por exemplo, corrigir erros de dados e re-
mover discrepâncias) Restringir um modelo para simplificá-lo e reduzir o risco de sobre
ajuste é chamado regularização.

Página 22
 CURSO MACHINE LEARNING COM PYTHON

Por exemplo, o modelo linear definido anteriormente tem dois parâmetros, θ0 e θ1.
Isso dá ao algoritmo de aprendizado dois graus de liberdade para adaptar o modelo aos da-
dos de treinamento: ele pode ajustar a altura (θ0) e a inclinação (θ1) da linha. Ao força θ1 =
0, o algoritmo terá apenas um grau de liberdade e terá muito mais dificuldade em ajustar os
dados corretamente: tudo o que se pode fazer é mover a linha para cima ou para baixo para
se aproximar o máximo possível das instâncias de treinamento, então acabaria em torno da
média. Um modelo muito simples, de fato!
Ao permitir que o algoritmo modifique θ1, mas obrigando o algoritmo a mantê-lo pe-
queno, o algoritmo de aprendizado terá efetivamente algo entre um e dois graus de liber-
dade. Ele produzirá um modelo mais simples do que com dois graus de liberdade, mas mais
complexo do que com apenas um. Encontrar o equilíbrio certo entre ajus tar os dados perfei-
tamente e manter o modelo simples o suficiente para garantir que ele se generalize bem
exige diversos testes.

SUB AJUSTE (UNDERFITTING)

O sub ajuste ocorre quando o modelo é muito simples para aprender a estrutura dos
dados. Por exemplo, um modelo linear de satisfação com a vida é propenso a desajustar pois
a realidade é mais complexa do que o modelo, portanto, suas previsões são imprecisas,
mesmo nos exemplos de treinamento.
As principais opções para corrigir esse problema são:
● Selecionando um modelo mais poderoso, com mais parâmetros
● Alimentando recursos melhores ao algoritmo de aprendizado ( engenharia de recur-
sos)
● Reduzindo as restrições no modelo

Teste e Validação
A única maneira de saber até que ponto um modelo será generaliz ado para novos ca-
sos é realmente testá-lo em novos casos. Uma maneira de fazer isso é colocar o modelo em
produção e monitorar o desempenho dele. Isso funciona bem, mas se o modelo é terrivel-
mente ruim, os usuários reclamam e com certeza não é a melhor ideia.
Uma opção melhor é dividir seus dados em dois conjuntos: o conjunto de treina-
mento e o conjunto de teste.
Como esses nomes sugerem, o modelo é treinado usando o conjunto de treinamento
e testado usando o conjunto de teste. A taxa de erro em novos caso s é chamada de erro de
generalização (generalization error) e, ao avaliar o modelo no conjunto de testes, obtém-se
uma estimativa desse erro. Esse valor informa o desempenho do modelo em instâncias
nunca vistas antes.
Se o erro de treinamento for baixo (ou seja, seu modelo cometer poucos erros no
conjunto de treinamento), mas o erro de generalização for alto, isso significa que o modelo
está ajustando demais os dados de treinamento.
Portanto, avaliar um modelo é bastante simples: basta usar um conjunto de testes.

Página 23
 CURSO MACHINE LEARNING COM PYTHON

VALIDAÇÃO CRUZADA
Agora, suponha que se esteja hesitando entre dois modelos (um modelo linear e um
modelo polinomial): como decidir? Uma opção é treinar os dois e comparar o quanto eles ge-
neralizam usando o conjunto de testes.
Suponha que o modelo linear se generalize melhor, mas se deseja aplicar alguma re-
gularização de parâmetro para evitar o ajuste excessivo (restringir os valore de θ por exem-
plo). Como escolher o valor do hiper parâmetro de regularização? Uma opção é treinar 100
modelos diferentes usando 100 valores diferentes para esse hiper parâmetro.
Suponha então, que se encontre o melhor valor de hiper parâmetro que produz um
modelo com o menor erro de generalização, digamos apenas 5% de erro. Entretanto, ao lan-
çar esse modelo em produção, ele apresenta 15% de erros
O problema é que o erro de generalização foi medido várias vezes no conjunto de
teste e adaptou o modelo e os hiper parâmetros para produzir o melhor modelo para esse
conjunto. Isso significa que é improvável que o modelo tenha bom desempenho em novos
dados pois o modelo não generaliza.
Uma solução comum para esse problema é ter um segundo conjunto de validação
chamado conjunto de validação. Você treina vários modelos com vários parâmetros usando
o conjunto de treinamento, seleciona o modelo e os parâmetros que apresentam melhor de-
sempenho no conjunto de validação e, quando está satisfeito com seu modelo, executa um
único teste final no conjunto de testes para obter uma estimativa de o erro de generalização.
Para evitar o "desperdício" em dados de treinamento e validação, uma técnica co-
mum é usar a validação cruzada: o conjunto de treinamento é dividido em subconjuntos
complementares e cada modelo é treinado em uma combinação diferente desses subconjun-
tos e validado nas partes restantes.
Depois que o tipo de modelo e os hi-
per parâmetros são selecionados, um modelo
final é treinado usando esses hiper parâme-
tros no conjunto de treinamento completo, e
o erro generalizado é medido no conjunto de
teste. A Figura 17 demonstra a validação
Figura 17 Validação cruzada usando a técnica k-
cruzada utilizando a técnica de k-fold: fold

Página 24
 CURSO MACHINE LEARNING COM PYTHON

CAPÍTULO 2
Revisão Matemática e Estatística
Um fator muito importante a ser salientado é que Inteligência Artificial é matemá-
tica. Algumas pessoas pregam Inteligência Artifical de forma errônea chamando até mesmo
de mágica. Para que o aprendizado sobre Machine Learning seja efetivo, neste tópico ser ão
abordados e revisados alguns temas fundamentais de matemática e estatística.

MÉDIA
A média pode ser definida como um número que representa o ponto de equilíbrio
dos dados, ou seja, um número que representa o valor de um conjunto de dados

Equação 2 Média

Por exemplo, considerando uma lista de notas, o algoritmo abaixo pode ser usado
para encontrar a média:
notas = [10,5,5] #Notas
soma = sum(notas) #Soma das notas
n = len(notas) #Quantidade de Notas
media = soma/n #Média
print(media)

Ou seja, a soma de todos os valores divididos pelo número de números. Alternativa-

mente, o método mean do módulo statistics pode ser usado:
from statistics import mean
notas = [10,5,5] #Notas
media = mean(notas) #Média

MEDIANA
Já a mediana, é o valor que separa a metade maior e a metade menor de uma amos-
tra. Se o número de amostras for ímpar, o número do meio é o valor do meio:

Equação 3 Mediana para impares

Por exemplo, com uma lista de idades pode-se encontrar a mediana da seguinte
forma:
idades = [2,2,3,7,8,9,9] #idades
index_medio = int(len(idades)/2) #Index médio

Página 25
 CURSO MACHINE LEARNING COM PYTHON

mediana = idades[index_medio] #Mediana

Alternativamente com o módulo statistics:

from statistics import median
idades = [2,2,3,7,8,9,9] #Idades
mediana = median(idades) #Mediana

Se o número de elementos for par, não há um único valor do meio, portanto, a medi-
ana é definida como a média dos dois valores do meio:
e

Equação 4 Números usados para obter a mediana

Por exemplo, considerando uma lista de idades com um número de elementos par:
from statistics import median
idades = [2,2,3,7,8,9,9,9] #Idades
mediana = median(idades) #Mediana

MODA
A moda se refere a quantidade de aparecimento, ou seja, a frequência de um certo
dado. Por exemplo, considerando uma lista de carros pode-se encontrar moda, ou seja, o
carro que mais apareceu usando a classe Counter:
from collections import Counter

carros = ["Chevrolet Onix",

"Ford KA",
"Chevrolet Onix",
"Volkswagen Gol",
"Fiat Uno",
"Chevrolet Onix"]

moda = Counter(carros).most_common(1)

VARIÂNCIA
A variância se refere a intensidade de variação dos dados. Por exemplo, conside-
rando duas personas fictícias Júlio e Anna com as notas:

Notas Júlio Anna

Nota 1 3 7

Nota 2 8 7

Nota 3 10 7

A média de ambos é a mesma:

Página 26
 CURSO MACHINE LEARNING COM PYTHON

from statistics import mean

anna = [7,7,7]
julio = [3,8,10]
print(mean(anna)) #Média 7
print(mean(julio))#Média 7

Para diferir os dois conjuntos a variância se mostra muito útil, a variância é calculada
com base na Equação 5 Variância:

Equação 5 Variância

O módulo statistics inclui o método variance visto abaixo:

from statistics import variance
anna = [7,7,7]
julio = [3,8,10]
print(variance(anna)) #Variância 0
print(variance(julio))#Variância 13

PONTOS
Um ponto representa um local entre duas variáveis. Por exemplo, para representar o
consumo de combustível de 17 litros no km a Figura 18 pode ser usada. No mesmo gráfico o
pode-se representar um outro ponto de consumo como visto na Figura 18.

Figura 18 Consumo vs Km do trajeto

Página 27
 CURSO MACHINE LEARNING COM PYTHON

DISTÂNCIA ENTRE DOIS PONTOS

Para determinar a distância entre dois pontos basta usar a Equação 6.

Equação 6 Distância entre dois pontos

No exemplo anterior, imagine que se

deseja obter a distância entre os pon-
tos. Como visto na Figura 19.

Figura 19 Distância entre dois pontos

MATRIZES
Toda matriz tem o formato mxn onde m é o número de linhas e n o número de colu-
nas.
Existem diversas maneiras
de representar matrizes como:
● Colchetes: [ ]
● Parênteses: ( )
● Barras Simples: | |
● Barras Duplas: || ||

Figura 20 Exemplos de Matrizes

ELEMENTOS DE UMA MATRIZ

Seja a matriz genérica mxn, isto é,
m representa as linhas e n o número de
colunas, cada elemento pode ser repre-
sentado conforme a Figura 21.
Dessa forma, os elementos da ma-
triz são indicados por aij, onde o i repre-
senta o índice da linha e j representa o ín-
dice da coluna para o elemento em questão. Figura 21 Elementos de uma matriz

Página 28
 CURSO MACHINE LEARNING COM PYTHON

Assim, para se localizar um elemento na coluna, basta procura o número da linha e da co-
luna, esses números são os índices i e j.
Exemplos:
● a11 representa o elemento da linha 1 e coluna 1.
● a32 representa o elemento da linha 3 e coluna 2.
● a22 representa o elemento da linha 2 e coluna 2.
● amn representa o elemento da linha m e coluna n.

Considerando a Figura 22:

● a11 representa o elemento 1.
● a12 representa o elemento 4.
● a13 representa o elemento 0.
● a21 representa o elemento -2.
● a22 representa o elemento 4.
● a23 representa o elemento 3.
Figura 22 Matriz 2x3

MATRIZ TRANSPOSTA
Uma matriz transposta é uma matriz resultante da troca de linhas pelas colunas de
outra matriz. Para uma matriz A, a
transposta de A tem notação At.
Por exemplo, seja a matriz
A = [aij]mxn, a matriz transposta de
A é At = [aij]nxm. O processo fica
mais claro na Figura 23.

Figura 23 Processo de transposição de uma matriz

ADIÇÃO DE MATRIZES
Para fazer a adição de duas matrizes,
deve-se somar todos os elementos corresponden-
tes de uma matriz com a outra, ou seja, somar li-
nha com linha e coluna com coluna. As matrizes
devem ter a mesma ordem.
Por exemplo, sejam A e B duas matrizes de
mesma mxn. Basta somar A e B, e escrever A + B,
obtendo uma matriz C de mesma ordem mxn, de
forma que C seja obtida somando os elementos
correspondentes de A e B. Este processo é visto na
Figura 24.

Figura 24 Processo de adição de matrizes

Página 29
 CURSO MACHINE LEARNING COM PYTHON

SUBTRAÇÃO DE MATRIZES
Para fazer a subtração de duas matrizes, deve-se
subtrair todos os elementos correspondentes de uma ma-
triz com a outra, ou seja, subtrair linha com linha e coluna
com coluna. As matrizes devem ter a mesma ordem. Este
processo é demonstrado na

MULTIPLICAÇÃO DE UM NÚMERO Figura 25 Processo de

REAL POR UMA MATRIZ subtração de matrizes

Seja Amxn uma matriz, e a um

número real. O produto de a por A re-
sulta em uma matriz Bmxn, de forma
que multiplicamos o número real a por
cada elemento de A. A Figura 26 de-
monstra este processo.
Figura 26 Multiplicação de uma matriz por um escalar

MULTIPLICAÇÃO ENTRE MATRIZES

Considerem as matrizes Amxn e
Bnxp. A multiplicação das matrizes A e B,
nesta ordem, resulta em Cmxp, de forma
que C seja obtida pela soma dos produtos
dos elementos da linha i de A e da coluna j
de B. A multiplicação de matriz somente é
possível se o número de colunas em uma
matriz for igual ao número de linhas da ou-
tra matriz. A matriz resultante C tem o
mesmo número de linha da primeira matriz
e o mesmo número de colunas da segunda
Figura 27 Multiplicação entre matrizes
matriz. Este processo é mais claro na Figura
27.

Página 30
 CURSO MACHINE LEARNING COM PYTHON

CAPÍTULO 3
Introdução ao módulo Matplotlib
Números representam, de forma bem consistente o mundo, entretanto, para trans-
mitir o seu conteúdo de forma mais efetiva e fácil recorre-se a gráficos.
Python possui diversas bibliotecas para apresentação gráfica, uma das mais conheci-
das é a biblioteca Matplotlib.
O Matplotlib é uma biblioteca de plotagem 2D do Python que produz gráficos de
qualidade em vários formatos para ambientes interativos entre plataformas. O Matplotlib
pode ser usado em scripts Python, no IPython, no notebook Jupyter, em servidores de aplica-
tivos da web e em interfaces gráficas.
Com este módulo é possível gerar gráficos de histogramas, espectros de potência,
gráficos de barras, gráficos de erros, gráficos de dispersão e uma infinidade de outros. com
apenas algumas linhas de código.
O Matplotlib possui ainda vários kits de ferramentas complementares, incluindo plo-
tagem 3D com mplot3d e gráficos animados com animation.
A documentação oficial está disponível em https://matplotlib.org.

GRÁFICOS COM PYPLOT

Uma das ferramentas mais usadas desta biblioteca é o pyplot. Com ela é possível ge-
rar gráficos 2D.
Para iniciar é necessário importar esta ferramenta. Por convenção, geralmente se
apelida pyplot de plt como visto abaixo:
import matplotlib.pyplot as plt #Importação

Imagine que se tenham duas listas, uma contém os dias, e a outra contém o número
de vendas de canetas azuis:
dias = [1,2,3,4,5]
vendas_caneta = [2,3,4,10,15]

Para plotar estes dados bastas usar a função plot como visto abaixo:
plt.plot(dias,vendas_caneta) #Plotando os dados

Por fim, para exibir este gráfico, basta o método show como visto abaixo:
plt.show()#Exibição do gráfico criado

Página 31
 CURSO MACHINE LEARNING COM PYTHON

Desta forma, a Figura 28 foi gerada.

Figura 28 Gráfico gerado com pyplot

TÍTULOS E LEGENDAS
Para adicionar uma descrição dos eixos, basta usar os métodos xlabel e ylabel como
visto abaixo:
plt.xlabel("Dia") #Descrição do eixo x
plt.ylabel("Canetas Vendidas") #Descrição do eixo y

Um título para o gráfico pode ser adicionado usando o método title:

plt.title("Vendas de Canetas Azuis") #Título

O resultado pode ser

visto na Figura 29.
Suponha agora
que no mesmo gráfico de-
seja-se adicionar as ven-
das de suco de maracujá.
Para isso, basta
adicionar ao código os no-
vos dados antes de mos-
trar o gráfico. O seguinte
código deve ser inserido:
Figura 29 Aplicação de título e descrição nos eixos

vendas_suco = [7,6,4,6,2]
plt.plot(dias,vendas_suco) #Plotando as vendas de maracujá

É possível mudar as cores passando o parâmetro color no método plot como visto
abaixo:
plt.plot(dias,vendas_caneta,color="black")

Existem diversas formas de se compor estas cores, por exemplo:

1. RGB or RGBA: (0.1, 0.2, 0.5) ou (0.1, 0.2, 0.5, 0.3).
2. Hexadecimal: #F4C937 ou #000000
3. Com uma letra contida no set de opções {'b', 'g', 'r', 'c', 'm', 'y', 'k', 'w'};

Página 32
 CURSO MACHINE LEARNING COM PYTHON

4. Passando o nome completo (em inglês).

Para a documentação completa sobre as cores consultar

https://matplotlib.org/3.1.1/tutorials/colors/colors.html .
O código final ficou desta forma:
import matplotlib.pyplot as plt #Importação

dias = [1,2,3,4,5]
vendas_caneta = [2,3,4,10,15]
vendas_suco = [7,6,4,6,2]

plt.plot(dias,vendas_caneta,color=(0.1, 0.2, 0.5, 0.3)) #Plotando

as vendas de canetas
plt.plot(dias,vendas_suco,color="#F4C937") #Plotando as vendas de
maracujá

plt.xlabel("Dia") #Descrição do eixo x

plt.ylabel("Canetas Vendidas") #Descrição do eixo y
plt.title("Vendas de Canetas Azuis") #Título

plt.show()#Exibição do gráfico criado

O resultado pode ser observado na Figura 30.

Figura 30 Vendas de canetas azuis e de suco de maracujá.

Página 33
 CURSO MACHINE LEARNING COM PYTHON

GRÁFICO DE BARRAS
Os mesmos dados podem ser representados usando um gráfico de barras usando o
método bar. O código abaixo demonstra o uso e dever ser inserido no local de .plot():
plt.bar(dias,vendas_caneta,color=(0.1, 0.2, 0.5, 0.3)) #Plotando as
vendas de canetas
plt.bar(dias,vendas_suco,color="#F4C937") #Plotando as vendas de
maracujá

O resultado pode ser

observado na Figura 31.

Figura 31 Gráfico de barras

GRÁFICO DE HISTOGRAMA
Um histograma, diferente um gráfico de barras, mostra a frequência com que um
dado aparece em uma sequência.
Por exemplo, se existir uma lista contendo as idades de diversos participantes de um
concurso como visto abaixo:
idade_participantes =
[22,55,62,45,21,22,34,42,42,4,9,102,110,120,121,122,130,111,115,112
,80,75,65,54,44,43,42,48]

Para ver a repetição destes dados o método hist pode ser usado como visto abaixo:
plt.hist(idade_participantes)

O resultado ainda é um pouco confuso

como visto na Figura 32.
Para melhorar a compreensão deste grá-
fico alguns outros parâmetros devem ser explora-
dos.

Figura 32 Histograma de idades

Página 34
 CURSO MACHINE LEARNING COM PYTHON

RWIDTH
Ao usar o parâmetro rwidth a largura das
colunas é alterada. O código abaixo altera para
80% da largura:
plt.hist(idade_idade_participantes,
rwidth=0.8)

E o resultado (Observado na Figura 33) já

se torna mais compreensível

Figura 33 Alteração da largura das colunas

com rwidth

BINS
Ainda é possível criar faixas de divisão com o
parâmetro bins. Por exemplo, no código abaixo:
faixas = [0,10,20,30,40,50,
60,70,80,90,100,110,120,130]
plt.hist(idade_idade_participan-
tes, rwidth=0.8, bins=faixas)

A Figura 34 demonstra a saída. É possível no-

tar que na faixa de idade=10 não existe coluna pois
não existem dados nesta faixa.

Figura 34 Distribuição em faixas

HISTTYPE
O parâmetro histtype pode ser usado para gerar histogramas de diferentes formas
com as seguintes opções:
1. 'bar' Tradicional gráfico de barras (padrão).
2. 'barstacked' Tradicional gráfico de barras
empilhadas, quando existe mais de uma va-
riável ela é empilhada.
3. 'step' Gráfico de linha.
4. 'stepfilled' Gráfico de linhas preenchido

Com o parâmetro setado em step, como no

código abaixo que gera a Figura 35.
plt.hist(idade_participantes,
faixas, histtype="step") Figura 35 histtype="step"

Página 35
 CURSO MACHINE LEARNING COM PYTHON

Para criar um gráfico de barras horizontal, basta usar

o parâmetro orientation por exemplo no código abaixo que
gera a Figura 36:
plt.hist(idade_idade_participantes,

rwidth=0.8, orientation="horizontal")

Figura 36 Gráfico de barras horizontais

GRÁFICO DE DISPERSÃO
Gráficos de dispersão são muito usados em análises
estatísticas. Para gerá-los o método scatter é usado.
Imagine que se tenha a média de acidentes para
cada dia do mês como visto abaixo:
#Dias do mês
dias = [dia for dia in range(1, 31)]
#Acidentes
media_acidentes = [0,1,2,2.2,2,3,3.1,3.2,
3,4,5,6,6.5,6.8,7,7,7,7.3,7.8,9,9.
Figura 37 Gráfico de dispersão
1,9.2,10,10,11,12,11.1,10,5,2]

Para plotar estes dados em um gráfico de dispersão, basta usar o método scatter
como visto abaixo:
plt.scatter(dias, media_acidentes)

O resultado pode ser visto na Figura 37.

MARCADORES
É possível alterar os marcado-
res usando o parâmetro marker. Como
por exemplo:
plt.scatter(dias,
media_acidentes,
marker="*")

O resultado obtido é visto na

Figura 38. A lista completa de opções
está disponível em
https://matplotlib.org/3.1.1/api/mar-
kers_api.html.
Figura 38 Marcadores personalizados

Página 36
 CURSO MACHINE LEARNING COM PYTHON

TAMANHO DOS MARCADORES

O tamanho dos marcadores pode ser
modificado através do parâmetro s (size):
plt.scatter(dias, media_acidentes,
marker="*", s=150)

O resultado é demonstrado na Figura

39.

Figura 39 s=150

GRÁFICOS DE LINHAS EMPILHADAS

Imagine que um ser humano tenha 24 horas disponíveis em um dia. Diversas ativida-
des são feitas neste tempo. Supondo que as horas de alguém foram monitoradas por 5 dias e
se encontram dispersas da seguinte forma:
dia = [1,2,3,4,5]
dormindo = [7,8,6,11,7]
comendo = [2,3,4,3,2]
trabalhando = [7,8,7,2,2]
jogando = [8,5,7,8,13]

É possível criar uma visualização de linhas

empilhadas usando o método stackplot da seguinte
forma:
plt.stackplot(dia,
dormindo,
comendo,
trabalhando,
jogando)
Figura 40 Gráfico de linhas empilhadas

O resultado é observado na Figura 40.

LEGENDAS
Para adicionar legendas se usa o parâmetro labels ou label e se declara a existência
de legendas. Por exemplo no código abaixo que gera a Figura 42:
plt.stackplot(dia,
dormindo,
comendo,
trabalhando,
jogando,
labels=("dormindo","comendo","trabalhando","jo-
gando"))
plt.legend()

Página 37
 CURSO MACHINE LEARNING COM PYTHON

Figura 42 Legendas em um gráfico de Figura 41 Legendas em um gráfico de

linhas empilhadas linhas

Ou, para o gráfico de linhas anterior (o código abaixo gera a Figura 41):
plt.plot(dias,vendas_caneta,label="Vendas de Canetas")
#Plotando as vendas de canetas

plt.plot(dias,vendas_suco,label="Vendas de Suco") #Plotando

as vendas de maracujá

plt.legend()

GRÁFICO DE PIZZA
Um gráfico de pizza também pode ser produzido com a Matplotlib. No exemplo ante-
rior, pode-se separar os dados pela média da quantidade de horas gastas em cada atividade:
#Média de horas
dormindo = 7.8
comendo = 2.8
trabalhando = 5.2
jogando = 8.2

O gráfico de pizza necessita de

duas listas, uma contendo os valores e
outra os textos de legenda:
dados = [7.8,2.8,5.2,8.2]
legendas = ["Dormindo","Co-
mendo","Trabalhando","Jo-
gando"]

Por fim, basta usar o método pie:

plt.pie(dados, labels=legen-
das)

O resultado pode ser visto na Fi-

gura 43. Figura 43 Gráfico de pizza

Página 38
 CURSO MACHINE LEARNING COM PYTHON

SHADOW
Para dar profundidade ao gráfico de
pizza existe o parâmetro shadow:
plt.pie(dados, labels=legendas,
shadow=True)

O resultado pode ser visto na Figura

44.

Figura 44 Gráfico de pizza com profundidade

EXPLODE
Para separar o pedaços, o parâme-
tro explode se mostra úti. Este parâmetro
recebe um tupla contendo o espaçamento
que se deseja de cada variável:
plt.pie(dados, labels=legendas,
shadow=True,exlode=(0,0,0.1,0))

O resultado pode ser visto na Fi-

gura 45.

Figura 45 Gráfico de pizza com parâmetro explode

AUTOPCT
Para adicionar percentis, basta usar o
método autopct com a formatação desejada
como visto no código abaixo que gera a Figura
46:
plt.pie(dados,
labels=legendas,
shadow=True,
explode=(0,0,0.1,0),
autopct="%1.1f%%")

Figura 46 Gráfico com percentis

Página 39
 CURSO MACHINE LEARNING COM PYTHON

Introdução ao módulo Numpy

O NumPy, é um projeto open-source criado por Travis Oliphant que se consolida em
um módulo Python. Seu nome significa Numerical Python.
A ideia fundamental do NumPy é o suporte a matrizes multidimensionais. Portanto, o
NumPy pode ser considerado a base para a computação numérica no Python sendo criado
para permitir que o Python seja usado na resolução de problemas matemáticos e científicos.
O módulo NumPy fornece-nos centenas de funções matemáticas úteis além de cons-
tantes como a base dos logaritmos naturais (e) e pi (π).
O NumPy é, na verdade, um pacote fundamental para a computação científica com
Python. Ele contém entre outras coisas:
● um poderoso objeto de matriz N-dimensional
● funções (broadcasting) sofisticadas
● ferramentas para integrar código C/C++ e Fortran
● recursos úteis de álgebra linear, transformação de Fourier e números aleatórios

Além de seus óbvios usos científicos, o NumPy também pode ser usado como um efi-
ciente recipiente multidimensional de dados genéricos.
Tipos de dados arbitrários podem ser definidos. Isso permite que o NumPy se integre
de maneira fácil e rápida a uma ampla variedade de bancos de dados.
O NumPy é licenciado sob a licença BSD, permitindo a reutilização com poucas restri-
ções.

INSTALAÇÃO
Para instalar o módulo numpy, basta usar o utilitário pip:
pip install numpy

No Ambi-
ente Anaconda o
numpy já vem au-
tomaticamente
instalado como
vista Figura 47.

Figura 47 Pacote numpy no Anaconda

CRIAÇÃO DE ARRAYS
Convencionalmente, a numpy é apelidada de
np como visto no Código 1.

Código 1 Importação clássica do módulo numpy

Página 40
 CURSO MACHINE LEARNING COM PYTHON

As matrizes numpy são de natureza ho-

mogênea, ou seja, elas compreendem apenas
um tipo de dado (número inteiro, flutuante,
duplo, etc.) ao contrário de listas.

Código 2 Criação de um array numpy Para criar um array simples contendo

alguns números Código 2 pode ser usado.
Para especificar o tipo de dados que estará contido basta usar o parâmetro dtype
como visto no Código 3.

Código 3 Especificação de um array de números de ponto flutuante

Matrizes podem conter várias dimensões como no Código 4.

Código 4 Criação de uma matriz de 2 linhas e 3 colunas

O módulo numpy compreende uma série de funções facilitadoras. A função .zeros()

por exemplo, que cria uma matriz preenchida de zeros como visto no Código 5.

Código 5 np.zeros() cria uma sequência de zeros

A função .ones(), de forma análoga a função .zeros() cria uma matriz de uns como
visto no Código 6

Código 6 np.ones() cria uma matriz de números 1

Página 41
 CURSO MACHINE LEARNING COM PYTHON

De forma seme-
lhante, é possível usar a
função .full() para preen-
cher com um valor predefi-
nido, como por exemplo
1.23 no Código 7. Código 7 Matriz preenchida com o valor 1.23

Para criar sequências existem as funções .arrange(), que cria uma sequência a partir
de um início, um fim e um passo (de forma semelhante a função range() do Python) podendo
ser vista no Código 9 e a função .linspace() que partindo de um início, um fim e um número
de elementos gera um array como no Código 8.

Código 9 Sequência de número de 0 Código 8 Geração dos números

até 20 com passo de 2 de 0 até 1 com 5 elementos

Números aleatórios podem ser gerados com facilidade usando as funções random da
numpy que podem ser visualizados na Figura 48:

Figura 48 Funções da numpy para geração de números aleatórios

Por exemplo, no Có-

digo 10 uma matriz de nú-
meros aleatória é gerada
usando a função rand().

Código 10 Cria uma matriz 3x3 contendo números aleatórios de 0 à 1

Página 42
 CURSO MACHINE LEARNING COM PYTHON

Ou, como no usando números inteiros e limites :

Código 11 Matriz de números aleatórios 3x3 com números de 0 até 50

Para alguns usos, como em Machine Learning, é interessante fixar o valor da se-
mente randômica como no Código 12. Esta semente é
responsável sobre como o numpy irá gerar os números
Código 12 Fixa a semente randômica
e, desta forma, os números gerados aleatoriamente
sempre serão os mesmos.

PROPRIEDADES DE UM ARRAY
A função dir()
pode ser usada para
exibir as propriedades
de um array numpy.
Código 13 Geração de algumas matrizes aleatórias

Usando o Código 13 como base, é possível algumas das pro-

priedades no Código 14.

Código 14 Propriedades de uma matriz numpy

SHAPE
O atributo shape retorna uma tupla de dimensões da matriz como visto na Figura 49
Então a seguinte instrução irá retornar o número de linhas e colunas respectivamente:

Figura 49 Dimensões de algumas matrizes

SIZE
O atributo size, como visto na Figura 50, retorna o número de elementos na matriz.

Página 43
 CURSO MACHINE LEARNING COM PYTHON

Figura 50 Quantidade de itens de algumas matrizes

NDIM
O atributo ndim retornará o número de dimensões da matriz como visto na .

Figura 51 número de dimensões de uma matriz

ACESSO DE ITENS
A forma de acesso de valor é idêntica à uma lista Python. Por exemplo em uma ma-
triz de uma dimensão a Figura 52 demonstra o acesso dos itens.

Figura 52 Diferentes formas de acesso em uma matriz de uma dimensão

Matrizes com mais dimensões podem ser acessadas como na Figura 53.

Figura 53 Formas de acesso em uma matriz de duas (à esquerda) e três (à direita) dimensões

Página 44
 CURSO MACHINE LEARNING COM PYTHON

SUBSTITUIÇÃO DE VALORES
Substituir valores é muito simples, basta atribuir o novo ao index desejado. Como,
por exemplo no Código 16. Valores de um tipo diferente da matriz são automaticamente
convertidos como visto no Código 15.
Caso não seja possível fazer a conversão, um erro será gerado

Código 15 Alteração automática de tipo

após atribuição.
Código 16 Alteração de um valor na
matriz

Código 17 Erro de atribuição em uma matriz de números inteiros

FATIAMENTO DE ARRAYS
Como nas listas Python um array numpy também pode ser fatiado, para os exemplos
considerar o Código 18.

Código 18 Array de 0 até 10

Página 45
 CURSO MACHINE LEARNING COM PYTHON

A sintaxe de fatiamento é a mesma de uma lista como visto na Figura 54.

Figura 54 Algumas formas de fatiamento

A forma reversa
também é permitida
como visto no Código 19.

Código 19 Forma de acesso reversa em um array numpy

UNIÃO DE ARRAYS
Muitas vezes é necessário combinar diferentes matrizes. Para não digitar cada um de
seus elementos manualmente, é possível usar a concatenação de matriz para lidar com essas
tarefas facilmente.
Para concatenar duas
ou mais matrizes de uma só
vez basta passar o que é de-
sejado concatenar para o
método concatenate() como
visto no Código 20. Código 20 concatenate em dois arrays

É possível criar também ma-

trizes multidimensionais como no
Código 21.

Código 21 União de duas matrizes multidimensionais

Página 46
 CURSO MACHINE LEARNING COM PYTHON

Usando o parâmetro de eixo

(axis), pode-se definir a matriz de linhas
ou de colunas como visto no Código 22.
Para concatenar matrizes com
um número de dimensões diferente as
funções vstack() e hstack() são mais re-
comendadas. Código 22 Eixo definido como horizontal

Considerando, matrizes geradas

no Código 23 as funções vstack() e hstack() serão demonstradas.
:

Código 23 Matrizes geradas para demonstrar a concatenação

O resultado do empilhamento horizontal pode ser observado no Código 25 e o verti-

cal no Código 24.

Código 25 Empilhamento Horizontal

Código 24 Empilhamento vertical

É importante notar que, no empilhamento vertical os dois elementos precisam ter o

mesmo número de colunas como visto na . Já no empilhamento horizontal é necessário ter o
mesmo número de linhas como visto na

Página 47
 CURSO MACHINE LEARNING COM PYTHON

Código 27 mesmo número de linhas Código 26 mesmo número de linhas

SEPARAÇÃO DE ARRAYS
É possível ainda
dividir as matrizes com
base em posições pre-
definidas. Como de-
monstra o Código 28.

Código 28 separação de um array

As saídas do Código 28 estão representadas na Figura 55.

Figura 55 Saídas do código 28

Página 48
 CURSO MACHINE LEARNING COM PYTHON

É possível também passar o número de arrays que se deseja dividir como na Figura
56.

Figura 56 Divisão pelo núemro de arrays desejados

É necessário
que a divisão do nú-
mero de elementos
pelo número de divi-
sões seja inteiro
como no exemplo
16/2=8. Caso esta
condição não seja
atendida, um erro
será gerado, por
exemplo 16/3=5,33
como visto na Figura
57.
Figura 57 Erro na divisão de uma matriz

Da mesma forma as matrizes multidimensionais po-

dem ser divididas como mostra a Figura 58.

Figura 58 Divisão de uma matriz multidimensional

Página 49
 CURSO MACHINE LEARNING COM PYTHON

REMODELAMENTO DE ARRAYS
Para remodelar uma matriz, a função reshape() é usada. Esta função dá uma nova
forma à matriz sem alterar seus dados.
O uso básico possui dois parâmetros obrigatórios, a matriz que será redimensionada
e a nova forma da matriz. Para que seja possível remodelar uma matriz o número de elemen-
tos tem que ser igual ao número do remodelamento.
Supondo, por exemplo um array de 16 elementos visto na Figura 59.

Figura 59 Array de 16 elementos iniciados em 0

É possível remodelar para todos as possibilidades que contenham 16 elementos

como, por exemplo, 1x16 (Figura 60), 16x1(Figura 61), 2x8, 8x2(Figura 62) e 4x4(Figura 63).

Figura 60 Remodelamento 1 linha por 16 colunas

Figura 62 Remodelamento 8 linhas por 2 colunas

Figura 61 Remodelamento 16
linhas por 1 coluna Figura 63 Remodelamento 4 linhas por 4 colunas

Página 50
 CURSO MACHINE LEARNING COM PYTHON

OPERAÇÕES ARITMÉTICAS
O numpy possibilita
as operações de adição,
subtração, multiplicação e
divisão entre números e
entre arrays.
Por exemplo, para
multiplicar um array inteiro
por 2 basta fazer uma mul-
Figura 64 Multiplicação de uma matriz por um escalar
tiplicação simples como
visto na Figura 64.

Figura 65 Divisão com retorno de infinição e infinito

As outras operações
funcionam de forma idêntica,
sendo que a divisão por zero
não retorna um erro, mas sim
um resultado infinito como
visto na Figura 65.
Dois arrays também po-
dem ser operados de forma se-
melhante. Considerando, por
exemplo, dois arrays, a e b vis-
tos na Figura 66.
As operações com estas Figura 66 geração de dois arrays multidimensionais
matrizes podem ser vistas nas
Figura 687, 68, 69, e 70.

Página 51
 CURSO MACHINE LEARNING COM PYTHON

Figura 68 Operação de subtração Figura 67 Operação de adição

Figura 70 Operação de divisão Figura 69 Operação de multiplicação

A operação de inverso multipli-

cativo está disponível. A operação de
inversão pode ser vista na Figura 71.
A função usada é chamada de
reciprocal(), nela, elementos com valo-
res absolutos maiores que 1.99 são
convertidos em 0 devido à maneira
como o Python lida com a divisão in- Figura 71 Inverso multiplicativo
teira. para o número inteiro 0, um aviso
de estouro é emitido. Seu uso está representado na Figura 72.

Figura 72 Uso da função reciprocal

Página 52
 CURSO MACHINE LEARNING COM PYTHON

FUNÇÕES ESTATÍSTICAS
Funções para obter o maior valor, menor va-
lor, média e outras medidas estatísticas estão dispo-
níveis como vistas na Figura 73.
A lista completa está disponível em
https://docs.scipy.org/doc/numpy-1.13.0/refe-
rence/routines.statistics.html.

DATETIMES E TIMEDELTAS
Formatos de data e hora (datetime) e inter-
valos de tempo (timedelta) são nativamente suporta-
dos pela numpy. O tipo de dados é chamado "date-
time64", assim chamado porque "datetime" já é utili-
zado pela biblioteca datetime incluída no Python.
Figura 73 Uso de funções estatísticas
CRIAÇÃO
Para criar um array contendo elementos “da-
tetime” basta especificar pelo parâmetro dtype como visto na Figura 74.

Figura 74 Criação de uma data

Da mesma forma, para criar intervalos de datas, a função arange() pode ser usada
como demonstrado na Figura 75.

Figura 75 Criação de um array de datas

Também é possível criar intervalos com a diferença de minutos como visto na Figura
76.

Página 53
 CURSO MACHINE LEARNING COM PYTHON

Figura 76 Geração de horários

Para criar um intervalo de tempo deve-se usar o método timedelta64 e especificar o

que se deseja, por exemplo, Anos, Meses, Dias, Horas, minutos e segundos como visto na Fi-
gura 77.

Figura 77 Geração de intervalos de tempo

O objeto datetime representa um único momento no tempo. Se duas datas têm uni-
dades diferentes, elas ainda podem representar o mesmo momento. Portanto, ao comparar
uma data gerada a partir de um ano com uma unidade menor como dias e meses a única
comparação feita será sob o ano.
Como visto na Figura 78.
Figura 78 Comparação de duas datas

ARITMÉTICA
O NumPy permite a subtração de dois valores de data e hora, uma operação que pro-
duz um número com uma unidade de tempo.
Ao operar (adição ou subtração por exemplo) uma data em outra data o retorno é
um intervalo de tempo como visto Figura 79.

Figura 79 Subtração de datas

Página 54
 CURSO MACHINE LEARNING COM PYTHON

Ao operar um intervalo em uma data, o retorno será uma data como observado na
Figura 82.

Figura 80 Operação com dois intervalos

Ao operar um intervalo de tempo em um intervalo de tempo um número escalar sim-

ples é retornado:

Figura 81 Operações de adição de intervalos em datas

Existem duas unidades Time-

delta ('Y', anos e 'M', meses) que são
tratadas especialmente, porque quanto
tempo elas representam muda depen-
dendo de quando são usadas. Enquanto
uma unidade de dia com intervalo de
tempo equivalente a 24 horas, não há
como converter uma unidade de mês em
dias, porque meses diferentes têm núme- Figura 82 Geração e conversão de um ano para meses
ros diferentes de dias.
Um erro ao usar outro tipo de data pode ser observado na Figura 84.

Página 55
 CURSO MACHINE LEARNING COM PYTHON

Figura 83 Erro ao converter anos para dias

Mais detalhes podem ser obtidos na documentação oficial disponível em

https://docs.scipy.org/doc/numpy/reference/arrays.datetime.html .

Introdução ao módulo pandas

Uma das tendências que vem surgindo é adoção do Python para vários aspectos da
"ciência de dados" como coleta de dados, limpeza de dados, análise, aprendizado de má-
quina e visualização.
Neste meio, o módulo pandas tem ganhado grande importância. O pandas é uma bi-
blioteca de código aberto, que fornece estruturas de dados de alto desempenho, diversas
ferramentas de análise de dados de fácil aprendizado para a linguagem de programação
Python.
O pandas é um banco de dados nosql na memória, que possui construções semelhan-
tes a sql, suporte estatístico e analítico básico, além de capacidade de representação gráfica.
Por ser construído sobre o Cython, possui menos sobrecarga de memória e é execu-
tado mais rapidamente. Muitas pessoas estão usando pandas para substituir o Excel, execu-
tar ETL, processar dados tabulares, carregar arquivos CSV, XLS, JSON, HTML e muito mais.

INSTALAÇÃO
Se o desenvolvimento da biblioteca se dar em um ambiente Python comum, basta
usar o gerenciador de pacotes pip da seguinte maneira:
pip install pandas

Página 56
 CURSO MACHINE LEARNING COM PYTHON

Como alternativa mais fácil, é possível usar o ambiente integrado Anaconda que já
possui o pacote instalado por padrão.

Figura 84 Pandas no ambiente Anaconda

Diferente da maioria dos pacotes, o pandas possui pacotes complementares, que po-
dem ser instalados conforme a necessidade. Alguns exemplos são:
1. xlwr, xlwd eopenpyxl para o gerenciamento de documentos xls e xlsx.
2. requests e BeautifulSoup4 para trabalhar com documentos html.

No ambiente Anaconda, estes pacotes geralmente já vêm instalados.

ESTRUTURAS DE DADOS
A chave para entender a biblioteca pandas é entender as formas de dados que exis-
tem. A Tabela 2 mostra a forma e o equivalente Excel para cada tipo de objeto pandas.

Tabela 2 Tipos de objetos pandas

OBJETO PANDAS DIMENSÕES NO EXCEL

Series 1D Coluna

DataFrame 2D Planilha simples

Panel 3D Múltiplas planilhas

As estruturas de dados mais usadas são a Série e o DataFrame, estes, lidam com da-
dos de matriz e dados tabulares, respectivamente.

Página 57
 CURSO MACHINE LEARNING COM PYTHON

Fazendo uma analogia com o mundo das planilhas, o DataFrame é semelhante a uma
folha de uma planilha com linhas e colunas como representado na Figura 86.

Figura 85 Representação de um DataFrame no Excel

Um Series é semelhante a uma única coluna ou linha de dados como visto na Figura
87.

Figura 86 Representação de 2 Séries no Excel

Um painel é um grupo de fo-

lhas ou uma planilha como re-
presentado na Figura 88.

Figura 87 Representação de um panel no pandas

Página 58
 CURSO MACHINE LEARNING COM PYTHON

Da mesma forma, no pandas, um painel pode ter muitos DataFrames, cada um por
sua vez tem várias séries como ressaltado na Figura 89.

Figura 88 Relação entre as principais estruturas de dados em pandas.

SÉRIES
A série representa dados de apenas uma dimensão, semelhante a uma lista
Python. O objeto Series também possui mais alguns comple-
mentos como um índice e um nome. Artista Músicas

Uma ideia comum através dos pandas é a noção de um eixo. 0 145

Como uma série é unidimensional, ela possui um único eixo , como o
1 142
índice de contagens de canções compostas por artistas presente na
Tabela 3. 2 38

Tabela 3 Músicas com um index 3 13

É possível representar estes dados em Python usando uma estrutura de dados como
na Figura 90.
É um dicionário que possui uma lista dos dados, armazenados sob as chaves.

Figura 89 Representação de uma Série pandas com elementos tradicionais

Manipular dados nesta estrutura começa a ficar um pouco complexo, para represen-
tar o mesmo tipo de dados usando a pandas o Código 29 pode ser usado.

Página 59
 CURSO MACHINE LEARNING COM PYTHON

Código 29 Série pandas

Note que o apelido usado para a biblioteca pandas foi pd e para a série foi s. Estes
são os padrões adotados pela comunidade e por vias gerais mais recomendados.
Quando a série é impressa, o pandas se esforça ao máximo para formatar no tama-
nho atual do terminal.
Para imprimir, em um terminal, basta usar a função print, se estiver no ambiente
Anaconda, basta declarar a série.

Código 30 Impressão dos dados no ambiente Anaconda

A coluna mais à esquerda é o índice. O nome genérico para um índice é um eixo

(axis), e os valores do índice - 0, 1, 2, 3 - são chamados de rótulos(labels).
A coluna mais à direita na saída contém os valores da série. O tipo de uma série é re-
presentado por dtype, no caso int64, que significa número inteiro de 64 bits). Uma série
pode representar qualquer tipo de Objeto Python.
Para obter a melhor velocidade (como operações vetorizadas), os valores devem ser
do mesmo tipo, embora isso não seja necessário.Manipulação de Séries
A estrutura de dados da série pandas fornece operações de criação, edição, leitura e
exclusão dos dados.

Página 60
 CURSO MACHINE LEARNING COM PYTHON

CRIAÇÃO
Como anteriormente já observado, para criar uma série basta passar os valores, o
seu nome e os índices desejados. Por exemplo, para criar uma série contendo o total de mú-
sicas atribuídas a George Harrison durante os anos finais dos Beatles e o lançamento de seu
álbum de 1970, All Things o Código 31 pode ser usado.

Código 31 Músicas de George Harrison durante os anos finais dos Beatles

Observe, na Figura 91, que

1970 é incluído uma vez no trabalho
de George como membro dos Beatles
e para seu álbum solo.
Este exemplo demonstra algu-
mas características interessantes do
pandas como os índices de formatos
Figura 90 Saída do Código 31
alternativos como strings e duplica-
dos. A princípio isso pode gerar confu-
são, mas em alguns casos isso torna a análise muito mais fácil.
Para verificar se uma série possui index du-
plicados pode se usar o atributo .is_unique

Figura 91 Atributo de unicidade do pandas

Séries também po-

dem ser geradas a partir de
dicionários. Por exemplo, o
código da Figura 93 é usado
para gerar uma série con-
tendo o valor de ações de
bancos brasileiros partindo
de um dicionário.
Desta maneira, o va-
lor dos indexes pode ser
omitido (as chaves do dicio-
nário se tornaram os índi-
ces).

Figura 92 Geração de uma série a partir de um dicionário

Página 61
 CURSO MACHINE LEARNING COM PYTHON

LEITURA
Para ler ou selecionar
os dados de uma série, pode-
se simplesmente usar um ín-
dice. Para isso imagine o
exemplo dos álbuns de Ge-
orge. Para selecionar os álbuns
de 1968 basta usar o exemplo
Figura 93 Albuns do George de 1968
da Figura 94.

Entretanto ao buscar por 1970,

como na Figura 95, usar um index re-
petido, o valor retornado será uma
nova série contendo os dois registros
de 1970.
Figura 94 Index repetido gera mais de um resultado

É possível iterar estes dados como

uma lista usando o for como visto na

Figura 95 Iteração dos dados repetidos

Para testar se um valor está presente em

uma série, basta usar a diretiva in em conjunto
com o atributo values da série como visto na Fi-
gura 97
Figura 96 Teste se o valor 22 está presente em
uma série

ATUALIZAÇÃO DE VALORES
Para atualizar um valor para um determinado índice,
a operação de atribuição de índice padrão funciona como
visto na Figura 98.

Figura 97 Atribuição de index.

Página 62
 CURSO MACHINE LEARNING COM PYTHON

Se o index não estiver contido, o mesmo é adicionado a série. Por exemplo, para adi-
cionar o ano de 1973 que não está contido inicialmente o Figura 99.

Figura 98 Adição de um novo registro

Se o índice for repetido como o ano de 1970, ambos são alterados como visto na Fi-
gura 101.
Para alterar um valor baseando-se na posição é necessário usar o atributo iloc como
visto na Figura 100.

Figura 100 Alteração de valor baseado na posição Figura 99 Alteração de múltiplos registros

DELEÇÃO DE VALORES
Deletar valores não é co-
mum no ambiente pandas, é muito
mais comum criar um novo con-
junto, entretanto, se realmente se
desejar excluir um dado, pode-se
usar a diretiva del como visto na Fi-
gura 102.
Figura 101 Exclusão dos álbuns de 1973
Não é possível deletar um
elemento com índices repetidos, a tentativa implica em erro, como visto na Figura 103.

Página 63
 CURSO MACHINE LEARNING COM PYTHON

Figura 102 Exclusão de um índice repetido

BOAS PRÁTICAS DE INDEXAÇÃO

As regras de indexação são um pouco complexas. Eles se comportam como um dicio-
nário, mas no caso em que um rótulo de índice é uma string (em vez de inteiro com base na
indexação), o comportamento recai na indexação de lista do Python.
Sim, isso é confuso. Alguns exemplos podem ajudar a es-
clarecer. A série de músicas do George, vista na Figura 104, possui
índices não numéricos. Figura 103 Músicas do George

Esta série também pode ser indexada por

posição (usando números inteiros). O primeiro
item está na chave 0 e o último item está em -1
Figura 104 Acesso por index
como visto na Figura 105.
Porém, na filosofia do Python “Explícito é melhor que Implícito” e para resolver este
problema (bem como problemas de desempenho) a documentação sugere o uso dos méto-
dos iloc e loc. Isso pode ser visto no trecho traduzido da documentação:
“Enquanto expressões Python/Numpy padrão para seleção e configuração são intuiti-
vos e úteis para trabalhos interativos, para produção de código, recomendamos os métodos
otimizados de acesso a dados do pandas .iat, .loc, .iloc e .ix.”

.ILOC AND .LOC

Os métodos iloc e loc permitem fazer indexação baseada em posição (index) e por
nome. Por exemplo, tomando por base o exemplo anterior de músicas, para obter o primeiro
e o último elemento (por posição) basta usar o método iloc como visto

Figura 105 Primeiro e último item da série

Página 64
 CURSO MACHINE LEARNING COM PYTHON

Ao passar uma string ou um elemento que não existe para o método iloc, o mesmo
irá retornar um erro como visto na

Figura 106 Erro de index inexistente e de index não inteiro (string)

Com o método loc a indexa-

ção é feita por nome (label). Por
exemplo, para selecionar o primeiro
ano (1968) e o último ano (1971) da
Figura 109 usando o método loc
basta usar um código semelhante ao
da Figura 108. Figura 108 Músicas do George

A grande diferença nos métodos loc e iloc está no

fato que um busca pela posição do elemento (iloc) e outro
pelo nome (loc).

Figura 107 Busca usando o loc

FATIAMENTO
É possível extrair um trecho de
uma série de forma muito semelhante
à uma lista Python.
Por exemplo, para selecionar
os valores do primeiro ao segundo ele-
mento pode-se usar o método iloc ou
loc como na Figura 110.

Figura 109 Fatiamento de uma série

Página 65
 CURSO MACHINE LEARNING COM PYTHON

Uma outra forma muito interessante de fatiamento permitida é usando uma lista de
valores desejados. Por exemplo, para buscar os valores de 1968 e 1970 usando o método loc
ou iloc como visto na Figura 111.

Figura 110 Acesso com uma lista de valores

.AT AND .IAT

Os métodos .at e .iat são análogos a .loc e .iloc com a sútil diferença de retornarem
um numpy.ndarray ao retirar um valor duplicado, enquanto .loc e .iloc retornam uma série.
Por exemplo, nas músicas de George, o resultado seria demonstrado como na Figura 112.

Figura 111 Comparação entre o métodos at e loc.

.IX
O método .ix é semelhante à indexação [ ]. Ele permite tanto indexação baseada em
nomes (labels) como em índices. Seu uso é desaconselhável em vias gerais, pois, tende a le-
var a resultados confusos violando a noção de “explícito é melhor do que implícito".
Entretanto, a documentação da biblioteca mantém um adendo:
“.ix é excepcionalmente útil ao lidar com posições posicionais e
índices hierárquicos baseados em etiquetas.”
Em tarefas usando tabelas dinâmicas ou empilhamento (conforme descrito posterior-
mente), o .ix pode ser útil.

FILTROS
O sistema de filtros do pandas se baseia em um array booleano. De forma básica, se
cria uma máscara com os valores que serão filtrados.
Ao verificar quais elementos da série de músicas do George é maior que 7, por exem-
plo, uma nova série contendo um array de quais são (True) e quais não são (False) é obtida
conforme a Figura 113 demonstra.

Página 66
 CURSO MACHINE LEARNING COM PYTHON

Figura 112 Comparação dos anos com mais de 7 músicas

Como pode ser notado, os elementos que tem mais de 7 elementos recebem o valor
de True e os demais False. Para usar isso, o primeiro passo é colocar esta máscara em uma
variável e então combinar na indexação de uma série. Quando as séries são combinadas com
uma máscara (filtro) na indexação os valores são filtrados como mostra a Figura 114.

Figura 113 Filtro sendo aplicado na série

Pode-se criar um segundo filtro com os anos que se tenha menos que 15 , como mos-
tra a Figura 115.

Figura 114 Filtro de mais de 15 músicas sendo aplicado

Diversos operadores podem

ser unidos para criar novos filtros,
por exemplo, maiores que 7 e me-
nores que 15 representado na Fi-
gura 116.
Os operadores disponíveis
estão representados na Tabela 4 e
na Tabela 5. Figura 115 Filtros combinados pela lógica &

Página 67
 CURSO MACHINE LEARNING COM PYTHON

Tabela 4 Operadores de comparação

Operador Nome Tabela 5 Operadores lógicos

== Igual a
Operador Nome
!= Diferente de
And &
< Menor que
Or |
> Maior que
Not ~
<= Menor ou igual a

>= Maior ou igual a

OPERAÇÕES EM SÉRIES
É possível aplicar diversas operações a uma série completa de forma muito simples.
Considerando as duas séries contendo as músicas individualmente atribuídas aos membros
dos Beatles nos anos de 1966 e 1969, como observado na Figura 117, é possível somar 2 à
todos os elementos de 1969 como demonstra a

Figura 116 Músicas individualmente atribuídas aos membros dos Beatles

:
Da mesma maneira, os operadores de
subtração, divisão, módulo e divisão inteira estão
disponíveis.

Figura 117 somar de um escalar aos álbuns de 1969

Um ponto de atenção é que ao somar da-

dos nulos como Ringo em 1966 (como observado
na Figura 119) a resposta continua sendo nula.
Isso se deve a forma com que a pandas
opera. Isso leva a uma questão bem problemática
pois interfere em todas as demais operações.

Figura 118 Erro ao somar um escalar

nos dados nulos

Página 68
 CURSO MACHINE LEARNING COM PYTHON

PREENCHIMENTO DE DADOS NULOS

Felizmente, para evitar problemas com dados nulos, o módulo pandas possui um mé-
todo que trata os dados nulos chamado fillna(). Para substituir os valores desconhecidos por
0 (número escalar somável) como observado na Figura 120.

Figura 119 Preenchimento de dados nulos usando o método fillna

Perceba que no exemplo anterior, para aplicar as mudanças foi necessário jogar o re-
sultado da operação para dentro da série novamente. Isso se deve a natureza da pandas de
que as operações devem ser explícitas,
desta forma, sempre que uma operação
ser executada ela irá apenas retornar a
série e não aplicar as mudanças nela.
Em alguns códigos, é comum que
ao invés de re-atribuir o valor para a sé-
rie, se use o parâmetro inplace=True
como na Figura 121. Figura 120 Aplicação parâmetro inplace

Uma outra forma é a eliminação

dos dados nulos (geralmente não é útil para a
análise de dados) com o método dropna. A Figura
122 mostra este processo.

Figura 121 Eliminação dos dados nulos

MÉTODOS ESTATÍSTICOS
Séries pandas possuem
métodos estatísticos como
soma, média, mínimo e má-
ximo implementados. Por
exemplo, supondo a série con-
tendo as 5 marcas mais valio-
sas do mundo segundo a em-
presa Kantar (vista na Figura
123)

Figura 122 As 5 empresas

mais valiosas do mundo

Página 69
 CURSO MACHINE LEARNING COM PYTHON

Para somar o valor total que estas empresas acumu-

lam, basta usar o método sum() ()

Figura 123 Soma

De forma análoga a média, mínimo e máximo na

Figura 124 Média, Minimo e Máximo

A Tabela 6 representa alguns outros métodos interessantes.
Tabela 6 Funções estatísticas

Função Descrição

count() Números não nulos observados

sum() Soma dos valores

mean() Média dos valores

median() Mediana dos valores

mode() Moda dos valores

std() Desvio Padrão dos dados

min() Menor valor

max() Maior valor

abs() Valor absoluto

prod() Multiplicação dos valores

cumsum() Soma Aumulada

Para a lista completa de métodos consultar: https://pandas.pydata.org/pandas-

docs/stable/reference/api/pandas.Series.html

CONVERSÃO DE TIPOS
Para converter o tipo de uma série o método astype() pode ser usado. Por exemplo,
imagine que exista uma série de dados contendo as maiores ondas já registradas no mundo ,
como mostra a Figura 126.

Página 70
 CURSO MACHINE LEARNING COM PYTHON

Figura 125 Maiores ondas registradas no mundo

Observando a saída dtype, é pos-

sível ver que o formato é um objeto
Python (no caso uma string). Para conver-
ter, basta usar o método astype() usando
o parâmetro float como visto abaixo:
É possível converter para outros
formatos como int e str além de outros
Figura 126 Tipo convertido para float
formatos (providos pelo módulo numpy)
como indicado na Tabela 7.
Tabela 7 Comparação entre tipos no pandas

No pandas No Python Na NumPy Uso indicado

string_, unicode_, Texto ou mixagem de valores numérico

object str or mixed mixed types e não-numéricos

int_, int8, int16,

int32, int64, uint8,
uint16, uint32,
int64 int uint64 Números inteiros

float_, float16,
float64 float float32, float64 Números decimais

bool bool bool_ Valores booleanos

datetime64 NA datetime64[ns] Datas e Horas

timedelta[ns] NA NA Diferença entre datas

Página 71
 CURSO MACHINE LEARNING COM PYTHON

Um outro exemplo muito importante é o da conversão de datas. Supondo, por exem-

plo, uma série
que contenha o
lançamento de
diversos consoles
de videogame
com as datas em
strings como
visto na Figura
128. Figura 127 Lançamento de alguns videogames

Para converter esta série no formato

datetime64 pode-se usa o método astype
como observado na Figura 129.

Figura 128 Conversão de strings em datas

Um outro exemplo muito pertinente é o da conversão com dados formatados em

moedas como R$, U$ e BTC$ (pois estes dados não podem ser somados diretamente).

Figura 129 Série contendo dados em real, dollar e bitcoin

Ao tentar
converter os dados da Fi-
gura 130 para ponto flutu-
ante o seguinte erro da Fi-
gura 131 é exibido.
Isso ocorre pois
existem caracteres não
Figura 130 Erro na conversão direta para ponto flutuante
numéricos presentes. Uma
das formas mais fáceis de
resolver este problema é usar a função str() em conjunto com a função replace().

Página 72
 CURSO MACHINE LEARNING COM PYTHON

A função str() fará com que o valor das células seja tratado como uma string comum,
possibilitando, por
exemplo, fatiar os ca-
racteres ou substituí-
los como observado
na Figura 132.
A função re-
place(), de forma
idêntica a função re- Figura 131 Remoção de caracteres especiais com uma função de regex
place do Python pode
remover caracteres
usando a sintaxe regex
como visto na Figura
132. Desta forma, para
resolver o exemplo an-
terior, é necessário re-
mover os caracteres es-
peciais e então fazer a
conversão como obser- Figura 132 Remoção de caracteres especiais e conversão para ponto
vado na Figura 134. flutuante

Os demais mé-
todos de uma string como lower(), upper(). findall(), len() e split() também estão disponí-
veis.

CLASSIFICAÇÃO
Organizar dados é uma tarefa
muito importante. Existem diversos mo-
dos de se fazer isso usando a biblioteca
pandas.
O método sort_values() por exem-
plo, organiza os dados de forma seme-
lhante ao método sort() do Python. Por
exemplo, imaginando a série de filmes do
Quentin Tarantino como na Figura 135.
Para classificar em ordem alfabé-
tica pode-se usar o método sort_values()
como pode ser visualizado na Figura 137.
Figura 133 Alguns filmes de Quentin Tarantino

Página 73
 CURSO MACHINE LEARNING COM PYTHON

É possível também usar o parâmetro ascending=False para classificar em ordem re-

versa como visto na

Figura 135 Método sort_values

Figura 134 Método sort_values com o parâmetro
ascending

Caso seja desejado, pode-se classificar por index com o método sort_index(), lem-
brando que o parâmetro ascending pode ser usado também como visto na Figura 138.

Figura 136 Método sort_index

APLICANDO UMA FUNÇÃO

Aplicar uma função à uma série inteira é muito fácil e intuitiva pois utiliza a função
map() de forma idên-
tica a dados iteráveis
comuns do Python.
Por exemplo,
imagine que se deseja
adicionar o trecho “R$
” na frente de uma sé-
rie inteira.
Tomando por
base a seguinte série Figura 137 Dados de dinheiro não formatados
da Figura 139.
O primeiro passo, é criar uma função que recebe um valor e devolve o valor com a
adição da cifra de real como visto no Código 32.

Código 32 Função de adiciona cifra de real

Página 74
 CURSO MACHINE LEARNING COM PYTHON

Agora é só utilizar ela como parâme-

tro na função map para formatar os dados como
visto na Figura 140.

Figura 138 Uso da função map

DATAFRAMES
DataFrames podem ser comparados à uma
folha de uma planilha sendo considerado um dado
tabular. Sendo um dado de duas dimensões, possui
linhas e colunas como visto na Figura 141.
Para criar um DataFrame o método Data-
Frame() pode ser usado de uma forma muito se-
Figura 139 Representação de um DataFrame no
melhante às Series. Excel

Por exemplo,
para representar o
mesmo conjunto da
Figura 141 no pandas
basta usar o método
DataFrame como
visto na Figura 142.

Figura 140 Representação

pandas de um Dataframe

A representação gráfica
da Figura 143 mostra o nome de
cada um dos elementos que com-
pões um DataFrame.

Figura 141 Legenda de um DataFrame

Página 75
 CURSO MACHINE LEARNING COM PYTHON

Para acessar uma coluna, basta passar seu

nome entre colchetes como visto na
Ao usar a função type é possível notar que o
retorno é uma série. Isso leva a uma constatação, um
DataFrame é na verdade um conjunto de séries. Por-
Figura 142 Acesso de uma Série de um
tanto, os métodos de acesso das linhas são idênticos a
DataFrame
uma série.
Por exemplo, para acessar
uma linha o atributo .loc e .iloc
podem ser usados como demons-
trado na Figura 145.
Figura 143 Acesso das linhas de uma Série presente em um
DataFrame

Ainda é possível combinar as duas propriedades de fatiamento (linhas e colunas) uti-

lizando apenas as funções loc e iloc como demonstra a Figura 146.

Figura 144 Fatiamento de linhas e colunas

Na Figura 147, por exemplo, as duas primeiras linhas da coluna "nome" são obtidas
usando .iloc e .loc.

Figura 145 Obtenção de linhas e colunas com os métodos loc e iloc

Um fato importante de ser notado é que o atributo iloc funciona com o nome do in-
dex da linha (portanto inclui tudo que existe entre o primeiro valor 0 e o último valor 1) e o
atributo iloc funciona com a posição (incluindo desta forma, todo intervalo que está entre a
posição 0 e a posição 1).

IMPORTAÇÃO DE ARQUIVOS
Para potencializar o uso, pandas permite a leitura e a gravação de diversos formatos
de arquivos como csv, excel, json e html além de proporcionar interface com o banco de da-
dos.

Página 76
 CURSO MACHINE LEARNING COM PYTHON

CSV
Suponha que exista um arquivo chamado “salario_da_liga.csv” (gerado conforme [1])
contendo o nome e o salário de diversos funcionários como demonstrado na Tabela 8.
Tabela 8 Formato do conjunto de dados csv

Nome Salário

Lanterna Verde 10000

Flash 15000

Um arquivo csv pode ser aberto e convertido para um DataFrame usando o método
read_csv() na seguinte forma:
df = pd.read_csv("salario_da_liga.csv")

Para indicar que a primeira coluna é a coluna de index, basta usar o parâmetro in-
dex_col=0 como visto abaixo:
df = pd.read_csv("salario_da_liga.csv", index_col=0)

Para salvar um arquivo no formato csv, basta usar o método to_csv() como visto
abaixo:
df.to_csv("novo_nome.csv")

XLS OU XLSX
Programas como o Microsoft Excel usam o formato xls para manipular planilhas, para
trazê-las para o formato DataFrame do pandas, de forma muito semelhante ao csv, se usa o
método read_excel():
df = pd.read_excel("salario_da_liga.xlsx")

ou para o xls:
df = pd.read_excel("salario_da_liga.xls")

Para salvar um DataFrame como xls ou xlsx basta usar o método to_excel()::
df.to_excel("novo_nome.xls")

JSON
Diversos programas e API’s usam o formato JSON. Para importar arquivos JSON
existe o método read_json() como visto abaixo:
df = pd.read_json("salario_da_liga.json")

Para integrar com uma API, como a SIDRA do IBGE, basta passar o link como parâme-
tro:

Página 77
 CURSO MACHINE LEARNING COM PYTHON

df = pd.read_json(

"https://servicodados.ibge.gov.br/api/v3/agregados",

encoding='UTF-8')

Para salvar no formato JSON, o método to_json() é perfeito:

df.to_json("novo_nome.json")

HTML
Para abrir um arquivo html, o método read_html() é usado:
df = pd.read_html("salario_da_liga.html")

É possível ler arquivos de páginas web também:

df = pd.read_html("https://pt.wikipedia.org/wiki/Lista_de_mem-
bros_da_Liga_da_Justi%C3%A7a")

O arquivo, entretanto, não é do tipo DataFrame e sim uma lista de DataFrames. Para
processar, é necessário transformar em um DataFrame com o método DataFrame:
df = pd.DataFrame(df[0]) #Pega o primeiro item da lista e trans-
forma em um DataFrame

Para salvar o arquivo no formato HTML, de forma semelhante aos anteriores, basta
usar o método to_html() como visto abaixo:
df.to_html("novo_nome.html")

Para os demais formatos consultar: https://pandas.pydata.org/pandas-docs/sta-

ble/user_guide/io.html

ADIÇÃO DE LINHAS
Tomando por base
um arquivo excel chamado
“pokemons.xlxs” (conforme
gerado em [2]), o primeiro
passo é importa-lo usando o
método read_excel conforme
demonstrado na Figura 148.

Figura 146 Importação do DataFrame de pokemóns

Página 78
 CURSO MACHINE LEARNING COM PYTHON

Para se adicionar uma nova linha, inicialmente deve-se criar uma nova série con-
forme demonstrado na Figura 149.

Figura 147 criação de uma Série pandas

Com a série criada, basta usar o método append com o parâmetro ignore_in-
dex=True como visto no Código 33 para adicionar a linha ao final do DataFrame.

Código 33 Adição de uma linha

ADIÇÃO DE COLUNAS
A adição de colunas é feita de forma semelhante a atribuição de dados em um dicio-
nário Python comum.
Tomando por
exemplo uma plani-
lha chamada “produ-
cao_2026.xlsx” (que
pode ser gerada em
[3]).
Para, por
exemplo, adicionar
uma nova coluna
contendo um im-
posto de 10% em
cima do ganho bruto
(produção) bastaria Figura 148 Criação de uma nova coluna a partir de outra

multiplicar a coluna
"produção" por 0.1 (10%) e atribuir a uma coluna chamada "imposto" como pode ser visto
na Figura 150.

Página 79
 CURSO MACHINE LEARNING COM PYTHON

EXCLUSÃO DE LINHAS E COLUNAS

Para excluir uma linha ou uma coluna, o método drop pode ser usado. Considerando,
por exemplo, uma planilha chamada “tarantino.xlsx” contendo os filmes do Quentin Taran-
tino (gerado em [4]), pode-se excluir algumas linhas com o uso do método drop passando o
index das linhas que se deseja excluir como visto na Figura 152.

Figura 149 Planilha sem alterações

Figura 150 Linhas 1,7 e 8 removidas

Um bom truque para eliminar diversos fatiamentos ou partes do DataFrame é usar o

atributo index com o DataFrame de filtro. Por exemplo, eliminar do index 2 ao 5, conforme
demonstra a Figura 153.

Figura 151 Exclusão das linhas 2 a 5

Página 80
 CURSO MACHINE LEARNING COM PYTHON

Para excluir uma coluna o mesmo método pode ser usado com a sutil di ferença de
passar um parâmetro nomeado como columns como visto na Figura 154 com a exclusão das
colunas "Nota do usuário" e "Profissão":

Figura 152 Exclusão de colunas

Como alternativa, também é possível usar a diretiva del (Figura 155).

Figura 153 Uso da diretiva del

AGRUPAMENTO, PIVOTEAMENTO, E REMODELAMENTO

Um dos recursos mais avançados do pandas é a capacidade de executar operações
em grupos de dados.

Página 81
 CURSO MACHINE LEARNING COM PYTHON

É um pouco abstrato, mas, para usuários do excel que estão familiarizados com tabe-
las dinâmicas, e o pandas fornece esta mesma funcionalidade. Por exemplo, considerando
um conjunto de dados de notas de uma turma de alunos como visto na Figura 156.

Figura 154 Notas de Alunos

AGRUPAMENTO
De forma muito semelhante a um comando SQL de GROUPBY, o método groupby()
faz com que dados sejam tra-
tados em grupos.
A Figura 157 , por
exemplo, agrupa por professo-
res. Figura 155 Criação do grupo de professores

Desta maneira um objeto é

criado. Para buscar um elemento
que está contido em um grupo, por
exemplo, os dados agrupados do
professor "Dimitri" basta usar o
método get_group() como visto na
Figura 158.
Figura 156 Extração do grupo Dimitri

Alguns métodos adicionais como max(), min(), mean() e describe() podem ser aplica-
dos a estes grupos conforme demonstra a

Página 82
 CURSO MACHINE LEARNING COM PYTHON

Figura 157 Aplicação dos métodos min e max em um grupo

Existe ainda a opção de aplicar uma função de

forma semelhante a função map com o método ap-
ply(). Por exemplo, somar 3 anos na idade de todos os
grupos, basta criar a função e usar o método apply
conforme visto na

Figura 158 Uso do método apply

Para percorrer todos os grupos, um laço de repetição pode ser usado conforme de-
monstrado na

Figura 159 Loop for em todos os grupos

Para facilitar o entendimento, o diagrama da Figura 162 mostra como todo o pro-
cesso o correu.

Página 83
 CURSO MACHINE LEARNING COM PYTHON

Figura 160 Diagrama do processo de agrupamento

Para trazer apenas as linhas desejadas é possível fazer uma espécie de fatiamento
usando como parâmetro uma lista como demonstra a Figura 163.

Figura 161 Filtragem de linhas

Página 84
 CURSO MACHINE LEARNING COM PYTHON

É possível ainda agrupar por mais de uma co-

luna passando uma lista como parâmetro para o mé-
todo groupby(), como, por exemplo, a Figura 164
que agrupa por professor e idade.

Figura 162 Agrupamento com mais de uma coluna

PIVOTEAMENTO
Com o uso de uma ta-
bela dinâmica, é possível gene-
ralizar determinados comporta-
mentos de grupo.
Para obter, por exem-
plo, as pontuações médias dos
alunos por professor como
visto na Figura 165.

Figura 163 Pontuação média de alunos por professor

De forma semelhante, usando o excel, o mesmo resultado é obtido conforme de-

monstra a Figura 166.

Figura 164 Processo de pivoteamento no Excel

Página 85
CURSO MACHINE LEARNING COM PYTHON

A Figura 167 pode esclarecer um pouco sobre o significado de cada parâmetro.

Figura 165 Processo de pivoteamento no pandas

Para incluir totais, o parâmetro margins=True é usado como visto na Figura 168.

Figura 166 Inclusão de totais (All)

Página 86
 CURSO MACHINE LEARNING COM PYTHON

FUSÃO DE DADOS
Em conceitos de análise de dados existem duas noções básicas muito importantes
chamados de fato e dimensão.
Uma dimensão é um grupo de valores que descrevem as condições do fato. Em um
cenário de vendas, por exemplo, o número de vendas de um item e o custo do item podem
ser interpretados como um fato.
As dimensões podem ser a loja onde o item foi vendido, a data e o cliente.
Os dados das notas dos alunos,
por exemplo, estão em um formato am-
plo (às vezes chamado de formulário
empilhado ou de registro). Em contraste
com um formato "longo" (às vezes cha-
mado de forma organizada), em que
cada linha contém um único fato (com
talvez outras variáveis descrevendo as
Figura 167 Notas dos alunos separadas em duas colunas
dimensões).
Para fazer com que os dados
sejam organizados e contenham
apenas um único fato por linha o
método melt() será usado passando
o DataFrame desejado, as colunas
que devem ser mantidas e as colu-
nas que devem ser convertidas
como demonstrado na Figura 170.

Figura 168 Duas colunas convertidas para apenas uma

É possível renomear a coluna

variable usando o parâmetro
var_name como visto na Figura 171.

Figura 169 Renomeação da coluna

Página 87
 CURSO MACHINE LEARNING COM PYTHON

Muitas vezes, as ferramentas, tais como o módulo scikit-learn ou matplotlib, por

exemplo, exigem que os dados sejam armazenados em um formato longo e só tenham um
fato por linha. Esse formato é desnormalizado e repete muitas das dimensões, entretanto,
facilita a análise.

EMPILHAMENTO E DESEMPILHAMENTO
Outro mecanismo para ajustar os
dados é "empilhar" e "desempilhar". Isso é
particularmente útil quando se possui índi-
ces de vários níveis, obtidos das tabelas di-
nâmicas, se passar uma lista para o parâme-
tro index.
O desempilhar pega-se um conjunto
de dados que possui um índice de vários ní-
veis e extrai o nível mais interno do índice e
o torna o nível mais interno das colunas.
O processo de empilhamento faz o
inverso. A Figura 172 deixa este processo
mais claro:
Figura 170 Fluxo do processo de empilhamento e
desempilhamento

UNIÃO DE DATA FRAMES

De mesma forma que bancos de dados comuns, é possível fazer uniões entre Data-
Frames de forma semelhante à duas tabelas. Como base, os dois DataFrames da Figura 173
serão usados.

Figura 171 DataFrames de exemplo

Página 88
 CURSO MACHINE LEARNING COM PYTHON

ADICIONANDO LINHAS
Para combinar dois DataFrames em um único,
usando as linhas de ambos a função concat é usada. Ela
necessita de uma lista contendo os DataFrames que de-
vem ser unidos e o parâmetro sort para saber se os da-
dos devem ou não ser reorganizados. O resultado pode
ser observado na Figura 174.
Observe que método concat preserva os valores
do índice, portanto, o DataFrame resultante possui valo-
res duplicados. Para criar novos indexes, o parâmetro
ignore_index=True é usado como observado na Figura
175. Figura 172 Concatenação de DataFra-
mes pelas linhas

Figura 173 ignore_index

ADICIONANDO COLUNAS
A função concat também tem a capacidade de alinhar DataFrames com base nos va-
lores do índice, em vez de usar as colunas.
Ao passar, por exemplo, o parâmetro axis=1, a Figura 176 é obtida.

Figura 174 Adição de uma coluna

Página 89
 CURSO MACHINE LEARNING COM PYTHON

MERGE
Para unir tabelas, um banco de dados possui diversos tipos de junções. Os mais co-
muns estão representados na Figura 177.

Figura 175 Formas de união de dados em um banco de dados

De forma semelhante, DataFrames possuem um método para suportar essas opera-

ções que se chama merge.
Ao utilizar o método merge sem nenhum parâ-
metro, a operação inner é aplicada como visto na Figura
178.
Note que a coluna de index é usada para fazer a
união.
Para usar um método diferente, basta passar o
parâmetro how como visto na Figura 179 para fazer um Figura 176 Inner Join

left.

Figura 177 Left Join

Página 90
 CURSO MACHINE LEARNING COM PYTHON

A Tabela 9 demonstra o uso das demais formas de parâmetrização.

Tabela 9 Formas de merge

how Resultado

left Left Join

right Right Join

outer Outer Join

inner Inner Join

Como pode ser notado, os métodos de exclusão não são listados, pois, não existem
de forma tão simples. Para criar um efeito semelhante, basta usar o parâmetro indica-
tor=True e então filtrar pelo que se deseja como pode ser visto na Figura 180.

Figura 178 Formas alternativas para executar os métodos Excluding

Página 91
 CURSO MACHINE LEARNING COM PYTHON

CAPÍTULO 4
Obtenção de dados
Quando se está aprendendo sobre o Machine Learning, é melhor experimentar com
dados do mundo real, não apenas com conjuntos de dados artificiais. Felizmente, existem
milhares de conjuntos de dados abertos para escolher, variando em todos os tipos de domí-
nios. Aqui estão alguns lugares que você pode procurar para obter dados:

● Repositórios de dados abertos populares

○ UC Irvine Machine Learning Repository (http://archive.ics.uci.edu/ml/)
○ Kaggle datasets (https://www.kaggle.com/datasets)
○ Amazon’s AWS datasets (http://aws.amazon.com/fr/datasets/)
● Meta-portais (eles listam repositórios de dados abertos):
○ http://dataportals.org/
○ http://opendatamonitor.eu/
○ http://quandl.com/
● Outras páginas que listam muitos repositórios populares de dados abertos:
○ Wikipedia’s list of Machine Learning datasets (https://en.wikipe-
dia.org/wiki/List_of_datasets_for_machine-learning_research)
○ Quastão no Quora.com contendo outras fontes
(https://www.quora.com/Where-can-I-find-large-datasets-open-to-the-pu-
blic)
○ Subreddit sobre o tema Datasets (https://www.reddit.com/r/datasets/)

MÓDULO QUANDL
A empresa quandl oferece uma imensidão de datasets estruturados com diversos te-
mas, sendo alguns pagos e outros gratuitos.
Obviamente a maior parte é relacionada aos Estados Unidos, mas tem bastante coisa
útil do Brasil. Boa parte dos dados do sistema de séries temporais do Banco Central estão lá
e são atualizados diariamente.
O Quandl ainda disponibiliza um API online para download dos dados em formatos
estruturados como: XML, JSON, CSV, HTML, que também apresenta diversas funções para or-
denação, transformação e filtragem dos dados.
Através da API é possível especificar o intervalo de datas para aquisição dos dados, a
frequência dos dados: diária, semanal, mensal, anual, ..., e realizar cálculos no dataset como
a diferença entre os dados, a normalização para a indexação, entre outros.
Além disso, ainda foram desenvolvidas bibliotecas, pela própria equipe do Quandl e
por outros desenvolvedores pelo mundo, para customizar o download dos dados.

Página 92
 CURSO MACHINE LEARNING COM PYTHON

QUANDL COM PYTHON

Existe um módulo Python para trabalhar diretamente com os datasets do Quandl. O
projeto pode ser encontrado no github em quandl/Python o no PyPI.
Para instalar, basta usar o pip:
pip install quandl

No Anaconda, é necessário instala-lo. Primeiramente indo na guia Environments:

Figura 179 Guia Environments

Deve-se então clicar no ícone de play e em Open Terminal:

Figura 180 Abrir o terminal que contém o ambiente Anaconda

Por fim,
basta apenas ins-
talar o pacote
usando o pip.

Figura 181 Instalação no Ambiente Anaconda

Página 93
 CURSO MACHINE LEARNING COM PYTHON

O Quandl precisa do numpy e do pandas para funcionar de forma que ele não dispo-
nibiliza os dados em estruturas de dados padrões do Python como dict e list e caso se queira
os dados nestas estruturas sugiro utilizar diretamente a
API online, escolher o formato JSON e utilizar o módulo
json. O Código 34 importa o módulo quandl.
Código 34 Importação do módulo
Para obter os dados basta chamar a função get do quandl
módulo passando o ticket do dataset que se deseja baixar.
Para encontrar o ticket desejado, é necessário entrar no site www.quandl.com e bus-
car pelo assunto desejado.
No exemplo abaixo a palavra-chave usada foi Brasil:

Figura 182 Busca por todos os conjuntos relacionados ao Brasil

Ainda é possível refinar a pesquisa usando os filtros, neste caso iremos buscar ape-
nas pelos gratuitos (Free).

Figura 183 Filtro dos conjuntos gratuitos sendo aplicado

Página 94
 CURSO MACHINE LEARNING COM PYTHON

O primeiro resultado apresentado se dispõe a apresentar os dados estatísticos do

banco central, como demonstra a Figura 187.

Figura 185 Banco de dados sobre o Banco Central do Brasil

Abaixo, é possível notar alguns tickets para obtenção de dados.

Figura 184 Alguns exemplos de tickets

Ao clicar no link
dos dados do banco
central, uma lista de
Séries Temporais (da-
dos ordenados por
data) será exibida. Para
pesquisar um tema es-
pecífico, basta usar a
barra de pesquisa e
usar o código que está
no canto inferior di-
reito como visto na
Figura 186 Séries Temporais do Banco Central do Brasil

Página 95
 CURSO MACHINE LEARNING COM PYTHON

Um dado interessante para estudo é a quantidade de capital estrangeiro investido

diretamente. As buscas são feitas em inglês. Portanto, deve -se digitar “Foreign direct inves-
tment” como visto na

Figura 187 Busca por capital estrangeiro

Para ver mais detalhes, basta clicar em EXPAND. Ao fazer isso, um quadro geral dos
dados é aberto como mostra a Figura 191.

Figura 188 Quadro geral dos dados de capital estrangeiro

É possível notar:
1. A última atualização dos dados
2. A frequência de atualização
3. Um gráfico dos dados
4. O código de acesso aos dados
5. As formas de exportação dos da-
dos
Ao clicar em Python (no menu 5),
a janela da Figura 192 mostrando o
código que deve ser usado será exi- Figura 189 Código para obtenção dos dados
bida.

Página 96
 CURSO MACHINE LEARNING COM PYTHON

Ao adicionar este código em um arquivo python, o resultado será um DataFrame

pandas como visto na

Figura 190 Obtenção dos dados de capital estrangeiro

Caso não queira

ou não goste de traba-
lhar com pandas é pos-
sível obter os dados em
um numpy array com o
uso do parâmetro re-
turns como visto na Fi-
gura 194. Figura 191 Retorno na forma de um numpy array

BAIXANDO MÚLTIPLOS ATIVOS

Uma coisa legal é poder baixar
diversos ativos em um único request.
Par isso, basta passar uma lista con-
tendo os códigos desejados.
Figura 192 Múltiplos tickets em uma única requisição.

BAIXANDO INTERVALOS DE DATAS ESPECÍFICOS

É possível limitar as datas, ou buscar as datas desejadas usando o intervalo de início
(trim_start) e o intervalo de fim (trim_end).

Página 97
 CURSO MACHINE LEARNING COM PYTHON

Figura 193 Busca com intervalos de datas

PARÂMETROS ADICIONAIS
Outras opções in-
teressantes como baixar
os últimos n registros e
ordenar os dados são pos-
síveis com os parâmetros
rows=n e sort_or-
der='desc'.

Figura 194 Parâmetros

adicionais

TOKENS DE ACESSO
Alguns dados são restritos à 50
consultas por dia. Isso é um número muito
pequeno pensando que são dados globais.
Para fazer consultas ilimitadas, ou
poder pagar por conjuntos premium, é ne-
cessário fazer uma conta clicando em SIGN
UP e preenchendo os dados.

Figura 195 Tela de cadastro no quandl

Página 98
 CURSO MACHINE LEARNING COM PYTHON

Ao terminar o cadastro, um código (API KEY) será obtido.

Figura 196 Tela de sucesso no cadastro com a chave de acesso

Com o código em mãos, basta passa-lo como parâmetro e os dados já estarão alinha-
dos a sua conta como visto na Figura 200.

Figura 197 Utilização do código de acesso

Página 99
 CURSO MACHINE LEARNING COM PYTHON

CAPÍTULO 5
Introdução à análise exploratória e ao módulo
Seaborn
Seaborn é uma biblioteca de visualização de dados Pyth on baseada no matplotlib.
Ele fornece uma interface de alto nível para desenhar gráficos estatísticos atraentes e infor-
mativos.
As principais vantagens dela são:
● Temas padrão que são esteticamente agradáveis.
● Paletas de cores personalizadas.
● Gráficos estatísticos atraentes.
● Exibição de distribuições com facilidade e flexibilidade.
● Visualização de informações de matrizes e DataFrames de forma direta.

No entanto, Seaborn é um complemento, e não um substituto, para o Matplotlib,

pois, existem alguns ajustes que ainda exigem o Matplotlib.

INSTALAÇÃO
Para instalar o módulo seaborn basta usar o gerenciador pip:
pip install seaborn

No ambiente integrado Anaconda, este pacote já é instalado automaticamente.

Figura 198 Módulo seaborn na Anaconda

O primeiro passo para usar este módulo é

importar ele para o arquivo que se deseja usar. É
muito comum (e recomendado) o uso do apelido
sns ao importar como visto na Figura 202. Figura 199 Importação recomendada

OBTENÇÃO DE DADOS
O seaborn possui alguns conjuntos de dados para demonstrações e pode ser carre-
gado usando a função load_dataset().

Página 100
 CURSO MACHINE LEARNING COM PYTHON

Como pode ser

observado, o conjunto
importado é um simples
DataFrame do pandas,
que por sinal, é muito
mais comum em fins
práticos.

Figura 200 conjunto de dados de gorjetas (tips)

VISUALIZANDO RELAÇÕES ESTATÍSTICAS

A análise estatística é um processo para entender como as variáveis de um conjunto
de dados se relacionam entre si e como esses relacionamentos dependem de outras variá-
veis. A visualização pode ser um componente central desse processo porque, quando os da-
dos são visualizados adequadamente, o sistema visual humano pode ver tendências e pa-
drões que indicam um relacionamento.

RELACIONANDO VARIÁVEIS COM GRÁFICOS DE DISPERSÃO

O gráfico de dispersão é um dos pilares da visualização estatística. Ele descreve a dis-
tribuição conjunta de duas variáveis usando uma nuvem de pontos, onde cada ponto repre-
senta uma observação no con-
junto de dados. Essa represen-
tação permite que o olho de-
duza uma quantidade substan-
cial de informações sobre se
existe algum relacionamento
significativo entre eles
Existem várias maneiras
de desenhar um gráfico de dis-
persão no seaborn. O mais bá-
sico é usando a função replot()
com o parâmetro kind=”scat-
ter”.
Enquanto os pontos são
plotados em duas dimensões,
outra dimensão pode ser adicio-
nada ao gráfico usando o parâ-
metro hue=”” para colorir os
pontos de acordo com uma ter-
ceira variável. Figura 201 Exemplo de gráfico de dispersão comparando
o tamanho da gorjeta com o tamanho da conta

Página 101
 CURSO MACHINE LEARNING COM PYTHON

No seaborn, isso é chamado de "semântica de matiz", porque a cor do ponto ganha

significado, como enfatiza a Figura 205.

Figura 202 Classes separadas por cor

Para enfati-
zar a diferença entre
as classes e melhorar
a acessibilidade (em
impressões preto e
branco por exemplo),
é possível usar um
estilo de marcador
diferente para cada
classe usando o parâ-
metro style=”” como
na

Figura 203 Fumantes

recebem um símbolo diferente

Também é possível representar quatro variáveis alterando a tonalidade e o estilo de

cada ponto independentemente como visto na Figura 208. Mas isso deve ser feito com cui-
dado, porque o olho é muito menos sensível à forma do que à cor .

Página 102
 CURSO MACHINE LEARNING COM PYTHON

Figura 205 Estilo e tonalidade diferente para cada ponto (confuso de observar)

Nos exemplos acima, os dados do parâmetro hue eram categóricos, portanto, a pa-
leta de cores padrão foi aplicada. Se os dados do parâmetro hue for numérica, a coloração
padrão alterna para uma paleta sequencial como visto na Figura 207.

Figura 204 Paleta de cores

sequencial

O parâmetro size altera o tamanho de cada

ponto, conforme pode ser observado naFigura 209.
Esse intervalo pode ser personalizado com o
parâmetro sizes que recebe uma tupla contendo o
tamanho inicial
e o tamanho de Figura 206 Utilização do parâmetro size
fim. e do parâmetro sizes

Página 103
 CURSO MACHINE LEARNING COM PYTHON

ENFATIZANDO A CONTINUIDADE COM GRÁFICOS DE LINHAS

Os gráficos de dispersão são altamente eficazes, mas não existe um tipo de visualiza-
ção universalmente ideal. Em vez disso, a representação visua l deve ser adaptada às especifi-
cidades do conjunto de dados e à pergunta que se busca responder com o gráfico.
Com alguns conjuntos de dados,
pode-se entender as alterações em uma
variável em função do tempo ou em
uma variável igualmente contínua.
Nessa situação, uma boa opção é dese-
nhar um gráfico de linhas.
No seaborn, basta usar a função
replot() com o parâmetro kind=”line”
como observado na Figura 210.
O gráfico de linha supõe que os
dados do eixo x devem estar em se-
quência, o comportamento padrão é
classificar os dados antes da plotagem.
No entanto, isso pode ser desa-
tivado e o gráfico ser plotado respei-
tando os índices do conjunto de dados
usando sort, como visto na
Figura 207 Exemplo de gráfico de linha

Figura 208 Geração de um conjunto aleatório e plotagem sem ordenação (inferior esquerdo) e
com ordenação (inferior direito)

Página 104
 CURSO MACHINE LEARNING COM PYTHON

AGREGAÇÃO E REPRESENTAÇÃO DA INCERTEZA

Conjuntos de dados mais complexos terão várias medidas para o mesmo valor da va-
riável x. Por exemplo, em um exame de ressonância magnética vários sensores examinam a
mesma região e cada um deles pode ter um resultado diferente.
O comportamento padrão no seaborn é agregar as várias medidas em cada valor,
plotando a média e o intervalo de confiança de 95% em torno da média .

Figura 209 A linha central representa a média e as sombras todos os demais valores medidos .

Os intervalos de confi-
ança são calculados usando a
inicialização, que pode levar
muito tempo para conjuntos de
dados maiores. Portanto, é pos-
sível desativá-los usando o pa-
râmetro ci=False como obser-
vado na

Figura 210 Curva média dos dados

Página 105
 CURSO MACHINE LEARNING COM PYTHON

O parâmetro ci também pode demonstrar o desvio padrão (standard deviation = sd)

dos dados como demonstrado na Figura 214.

Figura 211 Desvio padrão aplicado nas sombras (ci="sd")

PLOTANDO COM DADOS DE DATA

Gráficos de li-
nhas são frequente-
mente usados para vi-
sualizar dados associa-
dos a datas e horas.
Como a matplotlib
sabe interpretar dados
do tipo datetime e in-
corporar os rótulos
nos eixos o mesmo
ocorre na seaborn.

Figura 212 Interpretação automática de datas

Página 106
 CURSO MACHINE LEARNING COM PYTHON

MOSTRANDO VÁRIOS RELACIONAMENTOS COM FACETAS

Para mostrar a influência de uma variável adicional, em vez de atribuí-la ao mesmo
gráfico (ficando confuso de entender a plotagem), é possível usar uma "faceta".
Ou seja, criar vários eixos e subconjuntos de plotagem dos dados em cada um deles
como visto na

Figura 213 Gráficos separados pela coluna "time"

Também é pos-
sível mostrar a influên-
cia de duas variáveis
dessa maneira: uma fa-
cetada nas colunas e
outra facetada nas li-
nhas.
Ao começar a
adicionar mais variá-
veis à grade, pode-se
diminuir o tamanho da
figura usando o parâ-
metro height.

Figura 214
Exemplo de controle
de tamanho com o
parâmetro height

Página 107
 CURSO MACHINE LEARNING COM PYTHON

Essas visualizações, que geralmente são chamadas de "treliça" ou "pequenos múlti-

plos", são muito eficazes porque apresentam os dados em um formato que facilita aos olhos
a detecção de padrões gerais e desvios desses padrões.
Embora deva-se usar a flexibilidade oferecida pela função relplot(), sempre lembre-
se de que várias plotagens simples são mais eficazes que uma plotagem complexa.

PLOTAGEM COM DADOS CATEGÓRICOS

Até o momento o foco foi em variáveis numéricas, entretanto, em muitos casos vari-
áveis categóricas são muito importantes. Se uma das principais variáveis for “categórica” (di-
vidida em grupos discretos), pode ser útil usar uma abordagem mais especializada para visu-
alização.
Semelhante à função relplot() a função catplot() é usada na plotagem de dados cate-
góricos. Ela possui diversos tipos que podem ser classificados em três grupos principais:
1. Gráficos de dispersão categóricos:
a. stripplot() (com kind="strip"; o padrão)
b. swarmplot() (com kind="swarm")
2. Gráficos de distribuição categórica:
a. boxplot() (com kind="box")
b. violinplot() (com kind="violin")
c. boxenplot() (com kind="boxen")
3. Gráficos de estimativa categórica:
a. pointplot() (com kind="point")
b. barplot() (com kind="bar")
c. countplot() (com kind="count")

Página 108
 CURSO MACHINE LEARNING COM PYTHON

GRÁFICOS DE DISPERSÃO CATEGÓRICOS

A representação padrão
dos dados em catplot() usa um
gráfico de dispersão. A forma pa-
drão de tratar dados que ocupam
o mesmo ponto ou estão muito
próximos é ajustar as posições dos
pontos no eixo categórico com
uma pequena quantidade de “tre-
mulação” aleatória.

Figura 215 Representação

do total de contas por dia da semana

O parâmetro jitter controla a magnitude desta tremulação, podendo até mesmo ser
desligada.

Figura 216 Representação do uso do parâmetro jitter

Uma outra abordagem ajusta

os pontos ao longo do eixo categórico
usando um algoritmo que os impede
de se sobrepor. Pode dar uma melhor
representação da distribuição das ob-
servações, embora funcione bem ape-
nas para conjuntos de dados relativa-
mente pequenos. O parâmetro usado
é kind="swarm".

Figura 217 O parâmetro

swarn impede sobreposição

Página 109
 CURSO MACHINE LEARNING COM PYTHON

Semelhante aos gráficos relacionais, é possível adicionar outra dimensão a um grá-

fico categórico usando o parâmetro hue.

Figura 218 Categorias separadas pelo sexo.

Para criar uma ordenação diferente, bem como quais colunas serão exibidas o parâ-
metro order pode ser usado.

Figura 219 Ordenando com o parâmetro order

Em diversas situações é útil colocar a variável

categórica no eixo vertical (principalmente quando os
nomes das categorias são relativamente longos ou
existem muitas categorias).
Para fazer isso, basta trocar a atribuição de
variáveis para eixos, no caso da Figura 223, o eixo x
pelo y.

Figura 220 Gráfico horizontal

Página 110
 CURSO MACHINE LEARNING COM PYTHON

DISTRIBUIÇÕES DE OBSERVAÇÕES DENTRO DE CATEGORIAS

À medida que o tamanho do conjunto de dados aumenta, os gráficos de dispersão
categórica se tornam limitados nas informações que eles podem fornecer sobre a distribui-
ção de valores dentro de cada categoria. Quando isso acontece, existem várias abordagens
para resumir as informações de distribuição de maneira a facilitar comparações fáceis entre
os níveis de categoria.

BOXPLOTS
O boxplot é uma fer-
ramenta gráfica para repre-
sentar a variação de dados
observados de uma variável
numérica por meio de quartis.

Figura 221 Uso básico de um

boxplot

É possível adicionar uma hue

Figura 222 Classes separadas por fumantes

Página 111
 CURSO MACHINE LEARNING COM PYTHON

BOXENPLOTS
O gráfico boxen desenha um gráfico
que é semelhante a um gráfico de caixa,
mas otimizado para mostrar mais informa-
ções sobre o formato da distribuição. É mais
adequado para conjuntos de dados maiores.

Figura 223 Exemplo de uso de um

gráfico boxen

VIOLINPLOTS
O gráfico violin combina um boxplot com
o procedimento de estimativa de densidade.

Figura 224 Uso básico de um violin

Também é possível "dividir" os violinos

quando o parâmetro hue possui apenas dois
níveis usando o parâmetro split, o que pode
permitir um uso mais eficiente do espaço:

Figura 225 Uso do parâmetro hue

Página 112
 CURSO MACHINE LEARNING COM PYTHON

Existem várias opções

para o gráfico desenhado no
interior dos violinos, incluindo
maneiras de mostrar cada ob-
servação individual em vez dos
valores resumidos do gráfico
de caixa usando o parâmetro
inner como demonstrado na Fi-
gura 229

Figura 226 Gráficos desenhados no

interior dos violinos mostrando os registros

O parâmetro inner ainda possui as opções:box, quartile e point:

Figura 227 Da esquerda para a direita, box, quartile e point.

ESTIMATIVA ESTATÍSTICA DENTRO DE CATEGORIAS

Em vez de mostrar a distribuição em cada categoria, convém mostrar uma estimativa
da tendência central dos valores. Seaborn tem duas maneiras principais de mostrar essa in-
formação.

GRÁFICOS DE BARRAS
Para plotar um gráfico categórico de barras
basta usar bar.
É possível notar que quando existem vários da-
dos no mesmo eixo uma barra de erro é d esenhada.
Com o parâmetro count o gráfico de barras
conta o número de ocorrências em cada categoria,
como visto na Figura 231.

Página 113
 CURSO MACHINE LEARNING COM PYTHON

Figura 228 Contagem de registros em cada um dos deques do Titanic

Ambos (bar e count) podem ser chama-

dos com todas as opções discutidas acima, jun-
tamente com outras que são demonstradas na
documentação detalhada de cada função como
demonstrado na Figura 232.

Figura 229 Demonstração de parâme-

tros em um gráfico de barras

GRÁFICOS DE PONTOS
Um estilo alternativo para visualizar as mesmas
informações de um gráfico de barras é oferecido parâ-
metro point. Este parâmetro traz uma estimativa de
erro e conecta pontos da mesma categoria.
Isso facilita a visualização pois os olhos são
muito bons em perceber diferenças de inclinação.

Figura 230 Comparativo entre sexos nos sobreviventes do Titanic

Página 114
 CURSO MACHINE LEARNING COM PYTHON

Para destacar ainda mais os dados, é interessante alterar os parâmetros pallet, lines-
tyles e markers para melhor entendimento das categorias como visto na Figura 234.

Figura 231 Demonstração

de parâmetros de estilo

MOSTRANDO VÁRIOS RELACIONAMENTOS COM FACETAS

Da mesma forma que o método rel-
plot(), no catplot(), é fácil adicionar variáveis
facetativas para visualizar relacionamentos.

Figura 232 Demonstração de facetas

com catplot

Página 115
 CURSO MACHINE LEARNING COM PYTHON

VISUALIZANDO A DISTRIBUIÇÃO DE UM CONJUNTO DE

DADOS
Ao lidar com um conjunto de dados, geralmente a primeira coisa que se deseja fazer
é ter uma noção de como as variáveis são distribuídas. O seaborn possui diversas funções
para análises univariadas e bivariadas.

PLOTANDO DISTRIBUIÇÕES UNIVARIADAS

A maneira mais conveni-
ente de analisar rapidamente uma
distribuição univariada é usando a
função distplot().
Por padrão, será dese-
nhado um histograma e uma curva
que se adequa aos dados

Figura 233 Uso da função distplot

em um conjunto de dados randômicos

HISTOGRAMAS
Um histograma representa a distri-
buição dos dados, desenhando barras para
mostrar o número de observações que
caem em cada intervalo.
Para ilustrar isso, basta remover a
curva de densidade com o parâmetro kde.

Figura 234 Exemplo de histograma

Ao desenhar histogramas, a princi-

pal opção que você tem é o número de po-
sições a serem usadas e onde colocá-las
chamadas de bins.

Figura 235 Exemplo do

uso do parâmetro bins

Página 116
 CURSO MACHINE LEARNING COM PYTHON

ESTIMATIVA DA DENSIDADE DO NÚCLEO

A estimativa da densidade
do kernel pode ser menos familiar,
mas pode ser uma ferramenta útil
para plotar o formato de uma dis-
tribuição. Para mostrar apenas esta
curva, basta setar o parâmetro
hist().

Figura 236 Curva de densidade dos dados

De forma alternativa, a fun-

ção kdeplot() traça a mesma curva, entre-
tando, oferece outros parâmetros adicio-
nais:

Figura 237 Curva de densidade preenchida

TRAÇANDO DISTRIBUIÇÕES BIVARIADAS

Também pode ser útil visuali-
zar uma distribuição bivariada de
duas variáveis. A maneira mais fácil
de fazer isso no mar é apenas usar a
função jointplot(), que cria uma fi-
gura de vários painéis e mostra a re-
lação bivariada (ou conjunta) entre
duas variáveis, juntamente com a
distribuição univariada (ou marginal)
de cada uma em eixos separados.
O DataFrame da Figura 238 Figura 238 Conjunto de dados aleatórios que será usado
será usado para demonstrar os usos
mais frequentes.

Página 117
 CURSO MACHINE LEARNING COM PYTHON

GRÁFICOS DE DISPERSÃO
A maneira mais familiar de visualizar
uma distribuição bivariada é um gráfico de dis-
persão, onde cada observação é mostrada com
pontos nos valores x e y.

Figura 239 Exemplo de gráfico bivariado

GRÁFICOS DE HEXBINA
O análogo bivariado de um
histograma é conhecido como plota-
gem “hexbin”, este gráfico mostra
as contagens de observações que
caem dentro de caixas hexagonais.
Esse gráfico funciona me-
lhor com conjuntos de dados relati-
vamente grandes.
Ele está acessível com o pa-
râmetro kind setado em hex.

Figura 240 Gráfico de Hexbina

ESTIMATIVA DA DENSIDADE DO NÚCLEO

Também é possível usar o procedimento de estimativa de densidade de kernel des-
crito acima para visualizar uma distribuição bivariada. O parâmetro kde é passado para o
kind.

Página 118
 CURSO MACHINE LEARNING COM PYTHON

Figura 241 Exemplo de uso da

função joinplot

VISUALIZANDO RELACIONAMENTOS EM PARES EM UM CONJUNTO DE DADOS

Para plotar várias distribuições bi-
variadas aos pares em um conjunto de da-
dos, pode-se usar a função pairplot().
Figura 242 Conjunto de dados iris, muito
usado em ML

Esta função cria uma matriz de eixos e

mostra o relacionamento para cada par de colunas
em um DataFrame. Por padrão, também desenha a
distribuição univariada de cada variável nos eixos
diagonais como visto na

Figura 243 Matrix de eixos criada

com a função pairplot

Página 119
 CURSO MACHINE LEARNING COM PYTHON

VISUALIZANDO RELACIONAMENTOS LINEARES

Muitos conjuntos de dados contêm várias variáveis quantitativas, e o objetivo de
uma análise é frequentemente relacionar essas variáveis entre si. O seaborn traz diversos
gráficos de regressão linear que se destinam-se principalmente a adicionar um guia visual
que ajuda a enfatizar padrões em um conjunto de dados durante análises exploratórias de
dados. Ou seja, o seaborn não é um pacote para análise estatística e sim um guia visual.

FUNÇÕES PARA DESENHAR MODELOS DE REGRESSÃO LINEAR

Duas funções são usadas para visu-
alizar uma relação linear determinada por
regressão. Estas funções (regplot() e
lmplot()) estão intimamente relacionados,
e compartilham muito de sua funcionali-
dade principal. Para este documento, só
será abordada a função lmplot(). Na invo-
cação mais simples, ambas as funções de-
senham um gráfico de dispersão de duas
variáveis x e y, em seguida, ajustam o mo-
delo de regressão e plotam a linha de re-
gressão.
Figura 244 Regressão linear de alguns pontos

É possível ajustar uma regressão linear

quando uma das variáveis usa valores discretos,
no entanto, o gráfico de dispersão simples pro-
duzido por esse tipo de conjunto de dados ge-
ralmente não é o ideal.

Figura 245 Gráfico de duas variáveis discretas

Uma opção é recolher as observações em

cada compartimento discreto para plotar uma esti-
mativa da tendência central, juntamente com um in-
tervalo de confiança usando o parâmetro x_estima-
tor.

Figura 246 Utilização do parâmetro estimator

Página 120
 CURSO MACHINE LEARNING COM PYTHON

MONTAGEM DE DIFERENTES TIPOS DE MODELOS

O modelo de regressão linear usado
acima é muito simples de ajustar, no entanto,
não é apropriado para alguns tipos de conjuntos
de dados.
O conjunto de dados do quarteto de
Anscombe mostra alguns exemplos em que a
regressão linear simples fornece uma estimativa
idêntica de um relacionamento em que a inspe-
ção visual simples mostra claramente as dife-
renças.
Por exemplo, no primeiro subconjunto, Figura 247 Primeiro subconjunto de
a regressão linear é um bom modelo. Ascombe, a regressão se adapta de forma
adequada aos pontos

A relação linear no segundo

conjunto de dados é a mesma, mas o
gráfico mostra claramente que este
não é um bom modelo.

Figura 248 Um modelo linear simples não consegue

se ajustar aos dados

Na presença deste tipo de relações

de ordem superior, lmplot() e regplot()
podem ajustar um modelo de regressão
polinomial para explorar os tipos simples
de tendências não-lineares no conjunto de
dados. O parâmetro utilizado é order, ele
demonstra o grau da função que será
usado.

Figura 249 Aproximação com

uma função de 2º grau (order=2)

Página 121
 CURSO MACHINE LEARNING COM PYTHON

Um outro problema
diferente é colocado por pon-
tos fora da curva que se des-
viam por algum motivo, como
por exemplo um sensor defei-
tuoso.

Figura 250 Ponto fora da curva

desajusta a reta

Na presença de valores discrepan-

tes, pode ser útil ajustar uma regressão
robusta (robust=True), que usa uma fun-
ção de perda diferente para diminuir o
peso de resíduos relativamente grandes.

Figura 251 O modo robusto faz com que pontos muito fora
da curva sejam suavizados

CONDICIONAMENTO EM OUTRAS VARIÁVEIS

Frequentemente uma pergunta interessante pode vir “como a relação entre duas va-
riáveis muda em função de uma terceira variável?”
A melhor maneira de
separar um relacionamento é
plotar ambos os níveis nos mes-
mos eixos e usar a cor para dis-
tingui-los usando o parâmetro
hue.

Figura 252 Parâmetro hue

sendo usado no atributo fumantes

Página 122
 CURSO MACHINE LEARNING COM PYTHON

Além da cor, é possível usar

diferentes marcadores com o parâme-
tro marker.

Figura 253 Diferentes marcadores sendo usados

Para adicionar outra variável, basta fazer uso de outras "facetas" com os parâmetros
col e row demonstrado na e na

Figura 255 Parâme-

tro col separando a
classe tempo

Figura 254 Parâmetro "rol" e

"col" sendo usados

Página 123
 CURSO MACHINE LEARNING COM PYTHON

CAPÍTULO 6
Classificação
A classificação é uma sub-categoria de aprendizagem supervisionada. Classificação é
o processo de tomar algum tipo de entrada e atribuir um rótulo a ela. Sistemas de classifica-
ção são usados geralmente quando as previsões são de natureza distinta, ou sej a, um sim-
ples “sim ou não”.
Como exemplo, é possível citar o mapeamento de uma imagem de uma pessoa e
classificação como masculino ou feminino.

Naive Bayes
Um dos mais conhecidos classificadores de Machine Learning é o algoritmo “Naive
Bayes”. Ele é um classificador probabilístico baseado no “Teorema de Bayes”, o qual foi cri-
ado por Thomas Bayes (1701 - 1761) para tentar provar a existência de Deus.
Atualmente, o algoritmo se tornou popular em Aprendizado de Máquina (Machine
Learning) para categorizar textos baseado na frequência das palavras usadas, para por exem-
plo, ser usado para identificar se determinado e-mail é um SPAM ou sobre qual assunto se
refere determinado texto.
Por ser muito simples e rápido, possui um desempenho relativamente maior do que
outros classificadores. Além disso, o Naive Bayes só precisa de um pequeno número de da-
dos de teste para concluir classificações com uma boa precisão.
A principal característica do algoritmo, e também o motivo de receber “naive” (do
inglês ingênuo) no nome, é que ele desconsidera completamente a correlação entre as variá-
veis (features). Logo, se a correlação entre os fatores for extremamente importante, o Naive
Bayes pode falhar na predição da nova informação.
Por exemplo, se determinada fruta é considerada uma “Maçã” se ela for “Vermelha”,
“Redonda” e possui “aproximadamente 10cm de diâmetro”, o algoritmo não vai levar em
consideração a correlação entre esses fatores, tratando cada um de forma independente.
Frequentemente é aplicado em processamento de linguagem natural e diagnósticos
médicos, o método pode ser usado quando os atributos que descrevem as instâncias forem
condicionalmente independentes. Ou seja, o teorema de Bayes trata sobre probabilidade
condicional. Isto é, qual a probabilidade de o evento A ocorrer, dado o evento B.
O Algoritmo de Navie Bayes é recomendado nos seguintes casos:
● Se o problema for classificar texto ou algo do gênero.
● Previsões em tempo real já que possui uma velocidade relativamente alta e precisa
de poucos dados para realizar a classificação
● Classificação de textos/Filtragem de spam/Análise de sentimento: Muito utilizado
para filtragem de SPAM, Análise de Sentimento nas redes sociais (identificar se o
usuário está feliz ou triste ao publicar determinado texto).

Página 124
 CURSO MACHINE LEARNING COM PYTHON

IMPLEMENTAÇÃO MANUAL
Um problema simples que exemplifica bem o teorema é o cálculo de probabilidades
em cima de diagnóstico de doenças.
Imagine que se esteja trabalhando no diagnóstico de uma nova doença. Após realizar
testes, coletas e análises com 100 pessoas distintas, constatou-se que 20 pessoas possuíam a
doença (20%) e 80 pessoas estavam saudáveis (80%).
De todas as pessoas que possuíam a doença, 90% receberam positivo no teste (diag-
nóstico correto) e 30% das pessoas que não possuíam a doença também receberam o teste
positivo (diagnóstico errado).
Listando esses dados:
● 100 pessoas realizaram o teste (amostra total).
● 20% das pessoas que realizaram o teste possuíam a doença (pessoas com classifica-
ção de doente).
● 90% das pessoas que possuíam a doença, receberam positivo no teste (corretamente
diagnosticadas).
● 30% das pessoas que não possuíam a doença, receberam positivo no teste (falso po-
sitivo) (diagnóstico errado).

Para ficar mais claro, a tabela abaixo representa o conjunto de dados de 10 pessoas:

Tabela 10 Diagnóstico de 10 pacientes do conjunto de 100 pessoas

ESTADO DO PACIENTE RESULTADO DO TESTE STATUS DO TESTE

DOENTE DOENTE CORRETO

DOENTE DOENTE CORRETO

DOENTE SAUDÁVEL ERRADO

SAUDÁVEL SAUDÁVEL CORRETO

SAUDÁVEL SAUDÁVEL CORRETO

SAUDÁVEL SAUDÁVEL CORRETO

SAUDÁVEL SAUDÁVEL CORRETO

SAUDÁVEL DOENTE ERRADO

SAUDÁVEL SAUDÁVEL CORRETO

SAUDÁVEL SAUDÁVEL CORRETO

Página 125
 CURSO MACHINE LEARNING COM PYTHON

A partir destes dados, surge o problema: se uma nova pessoa realizar o teste e rece-
ber um resultado positivo, qual a probabilidade dela realmente possuir a doença?
O algoritmo de Naive Bayes consiste em encontrar uma probabilidade a posteriori
(possuir a doença, dado que recebeu um resultado positivo), multiplicando a probabilidade a
priori (possuir a doença) pela probabilidade de “receber um resultado positivo, dado que
tem a doença”.
Deve-se também computar a probabilidade a posteriori da negação (Não possuir a
doença, dado que recebeu um resultado Positivo).
Ou seja:
● P(doença|positivo) = 20% * 90%
● P(doença|positivo) = 0,2 * 0,9
● P(doença|positivo) = 0,18
● P(não doença|positivo) = 80% * 30%
● P(não doença|positivo) = 0,8 * 0,3
● P(não doença|positivo) = 0,24

Após isso é necessário normalizar os dados, para que a soma das duas probabilida-
des resulte 1 (100%).
Para isso, basta dividir o resultado pela soma das duas probabilidades.
1. P(doença|positivo) = 0,18/(0,18+0,24) = 0,4285
2. P(não doença|positivo) = 0,24/(0,18+0,24) = 0,5714
3. 0,4285 + 0,5714 = 0,9999.. ou aproximadamente 1.

A fórmula se apresenta desta maneira:

Equação 7 Equação do Teorema de Navie Bayes

Pode-se concluir que se o resultado do teste da nova pessoa for positivo, ela possui
aproximadamente 43% (0,4285) de chance de estar doente.

Página 126
 CURSO MACHINE LEARNING COM PYTHON

IMPLEMENTAÇÃO EM PYTHON
O Sklearn implementa o Naive Bayes de diversas formas como visto na Figura 260.

Figura 256 Trecho retirado da documentação oficial do sklearn

As mais usadas são:

1. GaussianNB;
2. MultinomialNB;
3. BernoulliNB;

Cada implementação é utilizada para objetivos diferentes.

GAUSSIANNB
Se assumir que os dados seguem uma distribuição normal (como visto n a Figura 261)
esta classe é utilizada.
Por exemplo, suponha que
um cientista está tentando classifi-
car se um estudante universitário
pode enterrar uma bola de bas-
quete com base apenas na sua al-
tura.
A distribuição de alturas em
humanos é contínua e respeita uma
distribuição normal (a distribuição
normal também é chamada de dis-
tribuição Gaussiana, daí o nome).
Figura 257 Curva de distribuição normal
Portanto, o algoritmo ana-
lisa a altura de todos os alunos pesquisados e determina onde deve estar o ponto de corte
para maximizar o desempenho do modelo (geralmente precisão) para classificar enterrado-
res e não enterradores.

MULTINOMIALNB
É usado quando os dados são discretos (por exemplo, classificações de filmes que va-
riam de 1 a 5, pois cada classificação terá uma certa frequência para representar).

Página 127
 CURSO MACHINE LEARNING COM PYTHON

No aprendizado de texto, por exemplo, a contagem de cada palavra para prever a

classe ou o rótulo também pode ser usada.

BERNOULLINB
Como o MultinomialNB, esse classificador é adequado para dados discretos. A dife-
rença é que, enquanto o MultinomialNB trabalha com contagens de ocorrências, o Bernoul-
liNB foi projetado para recursos binários / booleano, ou seja, se parte do princípio de que to-
dos os recursos são binários, de modo que eles recebem apenas dois valores.
Por exemplo, o 0 (valor falso) pode representar "a palavra não ocorre no docu-
mento" e 1 (valor verdadeiro) pode representar "a palavra ocorre no documento".

EXEMPLO DE UTILIZAÇÃO
Supondo que os dados da ocorrência ou não de jogos de golf baseados no clima este-
jam em um arquivo Excel chamado “golf.xlsx”. As implementa um classificador via Bernoul-
liNB nos dados para a previsão de futuros jogos.

Figura 258 Passo 1: carregamento dos dados

Figura 259 Passo 2: Transformação dos

dados

Página 128
 CURSO MACHINE LEARNING COM PYTHON

Figura 262 Passo 3: Binarização dos dados

com a função criada no passo 2

Figura 261 Passo 4: Separar as entradas das saídas

Figura 260 Criação e treino do modelo

PREDIÇÃO DE NOVOS VALORES

Agora para obter uma nova predição basta passar os dados para o modelo .

Figura 263 Predizendo o resultado para novas entradas. A classe 0 significa False (não houve
jogo) e a classe 1 significa True (houve jogo)

Pipelines
Existem, na maioria dos casos, muitas etapas na transformação de dados que preci-
sam ser executadas na ordem correta. Felizmente, o Scikit -Learn fornece a classe Pipeline
para ajudar nessas sequências de transformações.

Página 129
 CURSO MACHINE LEARNING COM PYTHON

Todos os transformadores numéricos (como o StandardScaler) possuem um método

chamado fit_transform(), e todos os estimadores (como o SVC ou GaussianNB) possuem um
método chamado fit().
Desta maneira, para executar todas as transformações e treinar o modelo, o constru-
tor Pipeline obtém uma lista de pares nome/estimador, definindo u ma 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 definidos da forma que for mais conveniente.
Ao chamar o método fit() do pipeline, ele aplica sequencialmente todos os transfor-
madores, passando a saída de cada chamada como parâmetro para a próxima chamada, até
atingir o estimador final.
Para ficar mais claro, o dataset wine do sklearn será usado. O primeiro passo é im-
portá-lo, separar as entradas das saídas e criar o conjunto de treino e testes conforme visto
na Figura 268.

Figura 264 Passo 1: importação e separação dos dados

Um conjunto de etapas pode ser criado. O mesmo contém o transformador Stan-

dardScaler e o classificador SVC como visto na

Figura 265 Passo 2: Criação da lista de tuplas contendo os passos que serão aplicados

Um objeto de Pipeline é criado contendo as etapas que serão aplicadas .

Figura 266 Passo 3: Criação do objeto Pipeline

Por fim, basta chamar o método fit() passando os parâmetros de entrada e saída.

Figura 267 Passo 4: Treino do pipeline

Página 130
 CURSO MACHINE LEARNING COM PYTHON

Desta forma, todas as etapas de transformação foram aplicadas e o resultado final

foi treinado sendo possível fazer previsões.
Uma outra aplicação interessante é mesclar as funcionalidades com a busca em
grade da classe GridSearchCV. O código abaixo cria uma busca em grade que utiliza todas as
etapas do Pipeline.

Figura 268 Exemplo de utilização da busca em grade com a classe GridSearchCV

Desta forma, basta treinar usando o método fit().

Figura 269 O treino em grade vai buscar os melhores parâmetros

E acompanhar os melhores parâmetros:

Figura 270 Melhores parâmetros encontrados na busca em grade

Para mais detalhe, consultar a documentação oficial em https://scikit-learn.org/sta-

ble/modules/generated/sklearn.pipeline.Pipeline.html

Página 131
 CURSO MACHINE LEARNING COM PYTHON

CAPÍTULO 7
Regressão Linear
Ao coletar certos dados é possível ver padrões nos mesmos, podendo correlacionar
duas variáveis e tirar conclusões como por exemplo:
1. Aumento na venda de bebidas em um dia quente
2. Queda de vendas em carros após uma matéria polêmica

Figura 272 Venda de litros de água pela tempe- Figura 271 Queda na venda de carros após
ratura matéria polêmica

Em ambos os exemplos é
possível traçar uma reta de apro-
ximação para representar os da-
dos.
Este processo de estima-
ção é chamado de Regressão Li-
near e gera um Modelo Linear
dos dados.
Um modelo linear faz
uma previsão simplesmente com-
putando uma soma ponderada
dos dados de entrada, além de
uma constante chamada termo
de viés (também chamado de Figura 273 Retas de regressão linear
termo de interceptação).
Este modelo po de ser escrito usando uma forma vetorizada, como mostrado na
Equação 8.

Equação 8 Modelo de regressão linear na forma vetorizada

θ T é um vetor que contém os pesos de cada atributo e é o termo que será posteri-
ormente ajustado.

Página 132
 CURSO MACHINE LEARNING COM PYTHON

O termo x contém o valor dos atributos.

Esse é o modelo de regressão linear. Agora, como ele é treinado? Bem, é necessário
lembrar que treinar um modelo significa definir seus parâmetros para que o modelo se
ajuste melhor ao conjunto de treinamento.
Para esse fim, é necessário medir o quão bem (ou mal) o modelo se ajusta aos dados
de treinamento. A medida de desempenho mais comum de um modelo de regressão é o erro
quadrático médio da raiz (RMSE).
Portanto, para treinar um modelo de regressão linear, é necessário encontrar o valor
de θ que minimiza o RMSE. Na prática, é mais simples minimizar o erro quadrado médio
(MSE) do que o RMSE e leva ao mesmo resultado.
O MSE de uma hipótese de regressão linear hθ em um conjunto de treinamento X é
calculado usando a Equação 9.

Equação 9 Função de custo MSE para um modelo de Regressão Linear

A EQUAÇÃO NORMAL
Para encontrar o melhor valor de θ existe uma equação matemática chamada Equa-
ção Normal descrita pela Equação 10.

Equação 10 Equação Normal

𝜃̂ É o valor de θque minimiza a função de custo e y é o vetor que contém as saídas.

Para demonstrar o seu funcionamento, o
primeiro passo é gerar dados como visto na Figura
278.

Figura 274 Geração de dados com ruído

Página 133
 CURSO MACHINE LEARNING COM PYTHON

O próximo passo é calcular θ

usando a equação normal. A função inv()
do módulo de Álgebra Linear do NumPy
(np.linalg) é usada para calcular o inverso
de uma matriz e o método dot() para a
multiplicação de matrizes.

Figura 275 Adição de uma coluna que permita

a multiplicação

Figura 276 Processo para encontrar o melhor valor de teta com a Equação Normal

A função real que foi usada para gerar os dados é

y=4+3x+ruído gaussiano. Após aplicar a equação normal, os
resultados da Figura 281 foram
Figura 277 Vetor que
obtidos. contém os melhores valores de
theta

O resultado esperado é θ0 =4 e θ1 =3 em
vez de θ0 =3.8905 e θ1 =3.2172. O ruído gaussiano
aplicado tornou impossível recuperar os parâme-
tros exatos da função original.

Figura 278 representação dos pontos 0 e 2

Contudo, agora é possível fazer previ-

sões usando θ. Considerando por exemplo, os
pontos 0 e 2 (da Figura 282) é possível encon-
trar os valores preditos como demonstrado
na Figura 283. Figura 279 Novos valores preditos

O Código 35 monta um gráfico com

uma reta dos valores preditos.

Código 35 Criação de um gráfico

que demonstra os valores preditos

Figura 280 A linha vermelha demonstra

os valores preditos

Página 134
 CURSO MACHINE LEARNING COM PYTHON

Alternativamente, a biblioteca Scikit-Learn implementa este processo (evitando usar

um código extenso e
pouco eficiente) utili-
zando a classe Linear-
Regression.
Código 36 Criação e treino de um modelo linear com Scikit Learn

É possível acessar os coeficientes θ, como demonstrado na Figura 285.

Figura 281 Coeficientes preditos pela classe LinearRegression

Para predizer novos valores, basta usar o mé-

todo predict().

Figura 282 Uso do método predict

COMPLEXIDADE COMPUTACIONAL
A Equação Normal calcula o inverso de X T · X. A complexidade computacional da in-
versão dessa matriz é tipicamente de n 2.4. Em outras palavras, ao dobrar o número de dados,
o tempo de computação é multiplicado por 2 2,4=5,3, ou seja, 5 vezes mais tempo.
Essa equação é linear em relação ao número de instâncias no conjunto de treina-
mento, portanto, ele lida com grandes conjuntos de treinamento com eficiência, desde que
possam caber na memória.
Depois de treinar o modelo de regressão linear (usando a equação normal ou qual-
quer outro algoritmo), as previsões são muito rápidas: a complexidade computacional é li-
near em relação ao número de instâncias nas quais você deseja fazer previsões e ao número
de recursos. Em outras palavras, fazer previsões com o dobro de instâncias (ou o dobro de
recursos) levará apenas o dobro do tempo.
Existe, entretanto, maneiras diferentes de treinar um modelo de regressão linear fa-
zendo com que se torne mais adequado para casos em que há um grande número de dados
ou muitas instâncias de treinamento.

GRADIENTE DESCENDENTE
O Gradiente Descendente (GD) é um algoritmo de otimização muito genérico capaz
de encontrar soluções ideais para uma ampla gama de problemas. A ideia geral do Gradiente
Descendente é ajustar os parâmetros iterativamente, a fim de minimizar uma função de
custo.

Página 135
 CURSO MACHINE LEARNING COM PYTHON

Uma analogia comum para explicar o Gradiente Descendente é o do homem na mon-

tanha. Suponha que um homem esteja perdido nas montanhas em um denso nevoeiro. Ele só
pode sentir a inclinação do chão abaixo de seus pés.
Uma boa estratégia para chegar rapidamente ao fundo do vale é descer ladeira
abaixo na direção da encosta mais íngreme. É exatamente isso que a descida do gradiente
faz: mede o gradiente local da função de erro em relação ao vetor de parâmetro θ e segue
na direção do Gradiente Descendente. Quando o gradiente é zero, o mínimo (valor ideal) foi
atingido.
Inicialmente, co-
meça-se preenchendo θ
com valores aleatórios
(isso é chamado de inicia-
lização aleatória) e se faz
uma aprimoração gra-
dual, dando um passo de
cada vez, tentando dimi-
nuir a função de erro (por
exemplo, o MSE), até que
o algoritmo consiga con-
vergir ao mínimo.

Figura 283 Representação gráfica do processo de GD

Um parâmetro importante no Gradi-

ente Descendente é o tamanho das etapas,
determinado pelo hiper parâmetro da taxa
de aprendizado. Se a taxa de aprendizado
for muito pequena, o algoritmo precisará
passar por muitas iterações para convergir,
o que levará muito tempo.

Figura 284 Taxa de aprendizado lenta

Por outro lado, se a taxa

de aprendizado for muito alta, é
possível pular o valor ideal e
acabar do outro lado, possivel-
mente com um erro mais alto do
que antes.
Isso pode fazer com que
o algoritmo crie valores de erro
cada vez maiores, deixando de
encontrar uma boa solução. Figura 285 Taxa de aprendizado muito alta

Página 136
 CURSO MACHINE LEARNING COM PYTHON

Por fim, nem todos os conjuntos de dados parecem vales agradáveis. Pode haver bu-
racos, cordilheiras, planaltos e todo tipo de terreno irregular, dificultando muito a conver-
gência ao mínimo.

Figura 286 Mínimos locais, mínimo Global e Planície

A Figura 290 mostra os dois principais desafios do Gradiente Descendente:

1. Se a inicialização aleatória iniciar o algoritmo à esquerda, o mesmo irá convergir para
um mínimo local, que não é tão bom quanto o mínimo global.
2. Se começar à direita, levará muito tempo para atravessar a planície, ou seja, se parar
muito cedo, o mínimo global nunca será alcançado

A função de custo (MSE) tem o formato de uma tigela, mas pode ser uma tigela alon-
gada se os dados possuírem escalas muito diferentes.
A Figura 291
mostra a descida do
gradiente em um con-
junto de treinamento
em que os dados 1 e 2
têm a mesma escala
(à esquerda) e em um
conjunto de treina-
mento em que o re- Figura 287 GD com e sem escalamento dos dados
curso 1 tem valores
muito menores que o recurso 2 (à direita).
Como é possível observar, à esquerda, o algoritmo Gradiente Descendente vai direto
ao mínimo, alcançando-o rapidamente, enquanto à direita primeiro ele segue uma direção
quase ortogonal à direção do mínimo global e termina com uma longa marcha descendo um
vale quase plano. Eventualmente, atingirá o mínimo, mas levará muito tempo.

Página 137
 CURSO MACHINE LEARNING COM PYTHON

Ao usar o Gradiente Descendente, deve-se garantir que todos os recursos tenham

uma escala semelhante (por exemplo, usando a classe StandardScaler do Scikit-Learn), ou o
tempo para convergir será muito grande.
Gradiente Descendente em lotes .
Para implementar a descida do gradiente, é necessário calcular o gradiente da fun-
ção de custo em relação a cada parâmetro do modelo θj. Em outras palavras, é necessário
calcular quanto a função de custo mudará ao alterar θj um pouco. Isso é chamado de deri-
vada parcial. É como perguntar "qual é a inclinação da montanha sob meus pés, se eu estiver
voltado para o leste?" E depois fazer a mesma pergunta voltada para o norte (e assi m por di-
ante para todas as outras dimensões).
Em vez de calcular esses gradientes individualmente, é possível usar a Equação 11
para computá-los de uma só vez.

Equação 11 Vetor gradiente da função de custo

É possível ver que esta equação envolve cálculos sobre o conjunto completo de trei-
namento X, a cada etapa da descida do gradiente. Por este motivo o algoritmo é chamado de
Gradiente Descendente em Lote (GDL): ele usa todo o lote de dados de treinamento a cada
passo.
Como resultado, é muito lento em conjuntos de treinamento muito grandes, no en-
tanto, a descida do gradiente se adapta bem ao número de recursos pois treinar um modelo
de regressão linear quando houver
centenas de milhares de recursos é
muito mais rápido usando a descida
de gradiente do que usando a equa-
ção normal.

Equação 12 Implementação
manual de um algoritmo de GDL

Página 138
 CURSO MACHINE LEARNING COM PYTHON

O algoritmo de Gradiente Descendente funcionou perfeitamente. Mas e se a taxa de

aprendizado fosse diferente? A Figura 292 mostra as 10 primeiras etapas do Gradiente Des-
cendente usando três taxas de aprendizado diferentes (a linha tracejada representa o ponto
de partida).

Figura 288 10 primeiras iterações com diferentes taxas de aprendizado (n)

À esquerda, a taxa de aprendizado é muito baixa, ou seja, o algoritmo chegará à solu-

ção, mas levará muito tempo. No meio, a taxa de aprendizado parece boa pois em apenas
algumas iterações, ela já convergiu para a solução. À direita, a taxa de aprendizado é muito
alta, ou seja, o algoritmo passa por todo o lugar e fica cada vez mais longe da solução.
Portanto, se o número de iterações for muito baixo, a solução ideal pode não ser
atingida quando o algoritmo parar. Se for muito alto, muito tempo será consumido para atin-
gir a solução ideal.
Uma solução simples é definir um número muito grande de iterações, mas interrom-
per o algoritmo quando o vetor gradiente atingir uma tolerância, fazendo o Gradiente Des-
cendente (quase) atingir o mínimo.

GRADIENTE DESCENDENTE ESTOCÁSTICO

O principal problema do GDL é o fato de ele usar todo o conjunto de treinamento
para calcular os gradientes a cada etapa, o que torna muito lento quando o conjunto de trei-
namento é grande.
No extremo oposto, o Gradiente Descendente Estocástico (GDE) seleciona apenas
uma instância aleatória no conjunto de treinamento a cada etapa e calcula os gradientes
com base apenas nessa instância única.
Obviamente, isso torna o algoritmo muito mais rápido, pois possui poucos dados
para manipular a cada iteração. Também possibilita o treinamento em grandes conjuntos de
treinamento, uma vez que apenas uma instância precisa estar na memória a cada iteração).

Página 139
 CURSO MACHINE LEARNING COM PYTHON

Por outro lado, devido à sua natureza es-

Figura 289 Função de custo de um GDE
tocástica (ou seja, aleatória), esse algoritmo é
muito menos regular do que a descida do gradi-
ente em lote, ou seja, em vez de diminuir suave-
mente até atingir o mínimo, a função de custo
salta para cima e para baixo, diminuindo apenas
em média. Portanto, quando o algoritmo para, os
valores finais dos parâmetros são bons, mas não
são ideais.
O Código 37 imple-
menta a descida estocástica
de gradiente usando uma
programação simples.
Por convenção, os
dados são iterados por épo-
cas.

Código 37 Implementação GDE simples

Enquanto o código de GDL repetiu

1.000 vezes por todo o conjunto de treina-
mento, esse código passa pelo conjunto de
treinamento apenas 50 vezes e alcança uma
boa solução.

Figura 290 Primeiros 10 passos do GDE

Para executar a regressão linear usando o GDE com o Scikit -Learn, é possível usar a
classe SGDRegressor.
O código a seguir executa 50 épocas (max_iter=50), começando com uma taxa de
aprendizado de 0,1 (eta0=0.1), com tolerância minima (tol=-np.infty), usando o cronograma
de aprendizado padrão e não usa nenhuma regularização (penality=None):

Figura 291 Implementação GDE

com Scikit Learn

Página 140
 CURSO MACHINE LEARNING COM PYTHON

Mais uma vez, você en-

contra uma solução muito pró-
xima da retornada pela Equação
Normal. Figura 292 Coeficientes encontrados via GDE

GRADIENTE DESCENDENTE EM MINI-LOTES

De forma semelhante ao GDE, a cada etapa, em vez de calcular os gradientes com
base no conjunto de treinamento completo (como no GDL) ou com base em apenas uma ins-
tância (como no GDE), O GDML calcula os gradientes em pequenos conjuntos aleatórios de
instâncias chamados mini-lotes ou minibatches.
A principal vantagem do GDML sobre o Estocástico é que se pode obter um aumento
de desempenho com a otimização de hardware das operações da matriz, especialmente ao
usar GPUs.
O progresso do algoritmo é menos irregular do que com o GDE, especialmente com
mini-lotes grandes. Como resultado, o GDML acabará caminhando um pouco mais perto do
mínimo do que o GDE. Por outro lado, pode ser mais difícil escapar dos mínimos locais
A Figura 297 mostra os caminhos percorridos pelos três algoritmos de GD durante o
treinamento.
O GD em Lotes en-
contra no mínimo, enquanto
o GD Estocástico e o GD em
Mini-Lotes ficam bem próxi-
mos.
É necessário ressal-
tar, entretanto, que o GDL
leva muito tempo para exe-
cutar cada etapa, e o GDE e
o GDML também alcançam o
mínimo com um bom crono-
Figura 293 Caminha percorrido por diversos algoritmos de GD
grama de aprendizado.
A Tabela 11 demonstra em mais detalhes as diferenças entre os algoritmos de GD.
Tabela 11 Comparativo entre algoritmos de GD

Algoritmo Comportamento com Comportamento com Suporte na Skle-

muitos Atributos muito Dados arn

Equação Nor- Rápido Lento LinearRegression

mal

Em Lotes Lento Rápido Não

Estocástico Rápido Rápido SGDRegressor

Mini-Lotes Rápido Rápido Não

Página 141
 CURSO MACHINE LEARNING COM PYTHON

REGRESSÃO POLINOMIAL
E se os dados forem realmente mais complexos do que uma simples linha reta? Sur-
preendentemente, é possível usar um modelo linear para ajustar dados não lineares usando
uma técnica chamada de Regressão Polinomial (RP).
Vamos ver um
exemplo. Primeiro, é ne-
cessário gerar alguns da-
dos não lineares, com base
em uma equação quadrá-
tica simples (mais algum
Código 38 Equação quadrática com ruído
ruído conforme o Código
38.
Claramente, uma li-
nha reta nunca ajustará
esses dados correta-
mente. Para este fim, é
necessário usar a classe
PolynomialFeatures do
Scikit-Learn para trans-
formar os dados de
treinamento, adicio-
nando o quadrado (po-
linômio de segundo
grau) de cada recurso
no conjunto de treina-
Figura 295 Dados gerados no Código 38 mento como novos re-
cursos conforma de-
monstrado na Figura 298.

Figura 294 Implementação polinomial com Scikit Learn

X_poly agora contém os dados origi-

nais de X mais o quadrado destes dados.
Agora é possível ajustar um modelo de re-
gressão linear a esses dados de treinamento
estendidos como visto na Figura 302. Figura 296 Dado original e o seu quadrado

Página 142
 CURSO MACHINE LEARNING COM PYTHON

O resultado das pre-

dições pode ser visto na Fi-
gura 301.

Figura 298 Implementação de Regressão Linear em dados polinomiais

Figura 297 Regressão polinomial

O modelo estimado foi:

O modelo original é:

Um resultado muito bom.

Observe que, quando há vários recursos, a Regressão Polinomial é capaz de encon-
trar relacionamentos entre os recursos. Isso é possível pelo fato de que a classe Polynomial-
Features também adiciona todas as combinações de recursos até o nível especificado.
Por exemplo, se houvesse dois atributos a e b, com grau 3 (degree=3) não apenas
adicionaria os recursos a², a³ e b³, mas também as combinações ab, a²b e ab².
PolynomialFeatures (degree = d) transforma uma
matriz que contém n atributos em uma matriz que contém
um número descrito pela Equação 13. Equação 13 Números de atributos
em PolinomialFeatures

Página 143
 CURSO MACHINE LEARNING COM PYTHON

Onde “!” é o fatorial, logo, é necessário cautela com a explosão combinatória do nú-
mero de características.

CURVAS DE APRENDIZAGEM
Ao executar uma regressão polinomial de alto grau, provavelmente os dados de trei-
namento irão se ajustar muito melhor do que com a regressão linear simples.
Por exemplo, a Figura
303 aplica um modelo polino-
mial de 300 graus aos dados
de treinamento anteriores e
compara o resultado com um
modelo linear puro e um mo-
delo quadrático (polinômio de
segundo grau).
Observe como o mo-
delo polinomial de 300 graus
se move para se aproximar o
máximo possível das instân-
cias de treinamento. Figura 299 Utilização de vários graus polinomiais

Obviamente, esse modelo de regressão polinomial de alto grau está super adaptado
aos dados de treinamento, enquanto o modelo linear está sub adaptado. O modelo que me-
lhor aproxima-se da função original nesse caso é o modelo quadrático.
Faz sentido, uma vez que os dados foram gerados usando um modelo quadrático,
mas, em geral, a função que gerou os dados é desconhecida, então como decid ir quão com-
plexo deve ser o modelo? Como dizer que o seu modelo está ajustando demais ou insuficien-
temente os dados?
A validação cruzada pode ser usada para obter uma estimativa do desempenho da
generalização de um modelo. Se um modelo tiver um bom desemp enho nos dados de treina-
mento, mas generalizar mal de acordo com as métricas de validação cruzada, seu modelo es-
tará se ajustando demais. Se o desempenho for ruim em ambos, será insuficiente. Esta é
uma maneira de saber quando um modelo é muito simples ou muito complexo.
Outra maneira é observar as curvas de aprendizado. Curvas de aprendizado são gráfi-
cos do desempenho do modelo no conjunto de treinamento e o conjunto de validação em
função do tamanho do conjunto de treinamento. Para gerar os gráficos, bas ta treinar o mo-
delo várias vezes em subconjuntos de tamanhos diferentes do conjunto de treinamento.

Página 144
 CURSO MACHINE LEARNING COM PYTHON

O Código 39 define uma função que plota as curvas de aprendizado de um modelo,

com base em alguns dados de treinamento.

Código 39 Código para plotar as curvas de aprendizado

Abaixo estão representadas as curvas de aprendizado do modelo de regressão linear

simples.

Figura 300 Curvas de aprendizado

Ao analisar o desempenho nos dados de treinamento quando há apenas uma ou

duas instâncias no conjunto de treinamento, o modelo pode ajustá -las perfeitamente, e é
por isso que a curva de erro nos dados de treinamento começa em zero.
Entretanto, à medida que novas instâncias são adicionadas ao conjunto de treina-
mento, torna-se impossível para o modelo ajustar os dados de treinamento perfeitamente,
tanto pela natureza de ruído dos dados quanto pelo fato de não serem lineares.
Portanto, o erro nos dados de treinamento aumenta até atingir um valor , nesse mo-
mento, adicionar novas instâncias ao conjunto de treinamento não torna o erro médio muito
melhor ou pior.

Página 145
 CURSO MACHINE LEARNING COM PYTHON

Quando o modelo é treinado em poucas instâncias d e treinamento, ele é incapaz de

generalizar adequadamente, razão pela qual o erro de validação é inicialmente alto. Então, à
medida que o modelo mostra mais exemplos de treinamento, ele aprende e, portanto, o erro
de validação diminui lentamente. No entanto, mais uma vez, uma linha reta não pode execu-
tar um bom trabalho de modelagem dos dados, portanto, o erro termina em um certo nível,
muito próximo da outra curva.
Essas curvas de aprendizado são típicas de um modelo sub treinado (underfitting)
pois ambas as curvas atingiram um nível próximo e razoavelmente alto.
Se o modelo não estiver adaptando os dados do treinamento, adicionar mais exem-
plos de treinamento não ajudará. É necessário usar um modelo mais complexo ou criar me-
lhores recursos para melhorar o modelo.
O Código 40 plota as curvas
de aprendizado de um modelo poli-
nomial de 10º grau com os mesmos
dados. O resultado pode ser visuali-
zado na
Código 40 Modelo Polinomial de 10º grau

Figura 301 Curvas de aprendizado de um modelo de 10º grau

Essas curvas de aprendizado se parecem um pouco com as anteriores , mas há duas dife-
renças muito importantes:
1. O erro nos dados de treinamento é muito menor do que no modelo de regressão li-
near.
2. Existe um espaço entre as curvas. Isso significa que o modelo tem um desempenho
significativamente melhor nos dados de treinamento do que nos dados de validação,
que é a marca registrada de um modelo de sobre ajuste. No entanto, se um conjunto
de treinamento muito maior for usado, as duas curvas continuariam se aproximando.

Página 146
 CURSO MACHINE LEARNING COM PYTHON

Uma maneira de melhorar um modelo de sobre ajuste é alimentá-lo com mais dados
de treinamento até que o erro de validação atinja o erro de treinamento.

ERROS DE GENERALIZAÇÃO
Um resultado teórico importante da estatística e do aprendizado de máquina é o
fato de que o erro de generalização de um modelo pode ser expresso como a soma de três
erros muito diferentes:
1. Bias (desvio): Essa parte do erro de generalização se deve a suposições erradas,
como supor que os dados são lineares quando na verdade são quadráticos.
2. Variância: Esta parcela de erro se deve à sensibilidade excessiva do modelo a peque-
nas variações nos dados de treinamento. É provável que um modelo com muitos
graus de liberdade (como um modelo polinomial de alto grau) possua alta variação e,
portanto, super ajuste os dados de treinamento.
3. Erro irredutível: Esta parcela vem do ruído dos próprios dados. A única maneira de
reduzir essa parte do erro é limpar os dados (por exemplo, corrigir as fontes de da-
dos, como sensores quebrados, ou detectar e remover discrepâncias).

Aumentar a complexidade de um modelo normalmente aumenta sua variação e re-

duz seu desvio. Por outro lado, reduzir a complexidade de um modelo aumenta seu desvio e
reduz sua variação.

MODELOS LINEARES REGULARIZADOS

Uma boa maneira de reduzir o excesso de ajuste é regularizar o modelo (restringi-lo).
Ou seja, quanto menos graus de liberdade ele tiver, mais difícil será para superestimar os da-
dos. Por exemplo, uma maneira simples de regularizar um modelo polinomial é reduzir o nú-
mero de graus polinomiais.

REGRESSÃO DE RIDGE
Regressão de Ridge (também chamada regularização de Tikhonov) é uma versão re-
gularizada da regressão linear, ou seja, um termo de regularização é adicionado à função de
custo, fazendo o algoritmo de aprendizado a não apenas ajustar os dados, mas também man-
ter o peso do modelo o menor possível.
O termo de regularização deve ser adicionado apenas à função de custo durante o
treinamento. Depois que o modelo é treinado, e se deseja avaliar o desempenho do modelo
usando a medida de desempenho não regulamentada.
O hiper parâmetro "α" controla quanto
se deseja regularizar o modelo. Se α = 0, a re-
gressão de Ridge é apenas uma regressão linear.
Se α for muito grande, todos os pesos acabarão
muito próximos de zero e o resultado será uma Equação 14 Função de custo
da regressão de Ridge
linha plana que passa pela média dos dados.
A Equação 14 apresenta a função de custo de Regressão
de Ridge.

Página 147
 CURSO MACHINE LEARNING COM PYTHON

Ao usar uma regressão de Ridge é importante dimensionar os dados (por exemplo,

usando a classe StandardScaler do Scikit-Learn) pois este método é sensível à escala dos da-
dos de entrada.
A Figura 306 mostra vá-
rios modelos treinados em alguns
dados lineares usando diferentes
valores de α.
À esquerda, modelos de
Ridge Lineares são usados. À di-
reita, está representado uma Re-
gressão Polinomial com regulari-
zação de Ridge. Observe como o
Figura 302 Regressão de Ridge
aumento de α leva a previsões
mais planas (ou seja, menos extremas, mais razoáveis).
A biblioteca Scikit-Learn
permite executar a regressão de
Ridge usando a classe Ridge.

Figura 303 Regressão de Ridge com alfa=1

Alternativamente pode-se usar o hiper

parâmetro penality em um GDE.

Figura 304 Uso do parâmetro penality

REGRESSÃO LASSO
A regressão LASSO vem do inglês "Least
Absolute Shrinkage and Selection Operator Re-
gression". Ela se trata de outra versão regulari-
zada da regressão linear que assim como a re-
Equação 15 Função de custo da Regres-
gressão de Ridge adiciona um termo de regula- são de LASSO
rização à função de custo.
A Figura 309 mostra o mesmo que Figura 306, mas substitui os modelos Ridge pelos
modelos Lasso e usa valores α menores.

Página 148
 CURSO MACHINE LEARNING COM PYTHON

Uma caracte-
rística importante
da regressão LASSO
é que ela tende a
eliminar completa-
mente os pesos dos
recursos menos im-
portantes (ou seja,
defini-los como
zero).

Figura 305 Regressão LASSO

Por exemplo, a linha tracejada no gráfico à direita na Figura 309 (com α = 10-7) pa-
rece quadrática, quase linear pois todos os pesos para os recursos polinomiais de alto grau
são iguais a zero. Em outras palavras, a regressão LASSO executa automaticamente a seleção
de dados e gera um modelo com poucos pesos diferentes de zero.
Abaixo está representado um pe-
queno exemplo do Scikit-Learn usando a
classe Lasso.

Figura 306 Utilização do Scikit Learn com a classe LASSO

REDE ELÁSTICA
A rede elástica é um meio termo entre a regressão de Ridge e a regressão LASSO. O
termo de regularização é uma mistura dos termos de regularização de Ridge e Lasso, e pode -
se controlar a taxa de mistura r. Quando r = 0, a Rede Elástica é equivalen te à Regressão de
Ridge, e quando r = 1, é equivalente à Regressão de Lasso.Então, quando se deve usar Re-
gressão Linear, Ridge, LASSO ou rede elástica? É quase sempre preferível ter pelo menos um
pouco de regularização; portanto, geralmente deve-se evitar uma regressão linear simples.
Ridge é um bom padrão, entretanto, ao suspeitar que apenas alguns recursos são
realmente úteis (existam dados pouco representativos), o Lasso ou a Rede Elástica deve ser
preferidas, pois tendem a reduzir o peso dos recursos inúteis para zero. Em geral, a Rede
Elástica é preferida ao Lasso, pois o Lasso pode se comportar de maneira irregular quando o
número de atributos for maior que o número de dados de treinamento ou quando vários
atributos estiverem
fortemente correlaci-
onados.

Figura 307 Exemplo usando o ElasticNet do Scikit-Learn (l1_ratio corresponde à taxa de mistura r)

Página 149
 CURSO MACHINE LEARNING COM PYTHON

PARADA ANTECIPADA
Uma maneira muito diferente de regularizar algoritmos de aprendizado iterativo, é
parar o treinamento assim que o erro de validação atingir o mínimo. Isso é chamado de pa-
rada antecipada.
A Figura 312 mostra um modelo complexo (neste caso, um modelo de regres são poli-
nomial de alto grau) sendo treinado usando GDL.
À medida que as
épocas passam, o algo-
ritmo aprende e seu erro
de previsão (RMSE) no con-
junto de treinamento dimi-
nui naturalmente, e o
mesmo ocorre com o erro
de previsão no conjunto de
validação.
No entanto, após
algum tempo, o erro de va-
lidação para de diminuir e,
na verdade, começa a vol-
Figura 308 Exemplo de para antecipada
tar para cima. Isso indica que o
modelo começou a superestimar os dados de treinamento. Com a parad a antecipada, para
de se treinar assim que o erro de validação atinge o mínimo.
Com o GDE e o
GDML, as curvas não
são tão suaves e pode
ser difícil saber se o
mínimo foi atingido ou
não. Uma solução é pa-
rar somente depois
que o erro de validação
estiver acima do mí-
nimo por algum tempo
Código 41 Implementação básica de parada antecipada (Observe
que, com warm_start=True o método fit() continua o treinamento onde pa- e, em seguida, reverter
rou, em vez de reiniciar do zero) os parâmetros do mo-
delo para o ponto em que o erro de validação esteja no mínimo. É possível analisar a melhor
época e o melhor modelo gerados no Código 41 na Figura 313.

Figura 309 Melhor época e melhor modelo obtido

Página 150
 CURSO MACHINE LEARNING COM PYTHON

REGRESSÃO LOGÍSTICA
Alguns algoritmos de regressão também podem ser usados para classificação (e vice -
versa). A regressão logística (também chamada de regressão logit) é comumente usada para
estimar a probabilidade de uma instância pertencer a uma classe específica (por exemp lo,
qual é a probabilidade de um cliente comprar um produto).
Em um caso Binomial (duas classes), se a probabilidade estimada for maior que 50%,
o modelo prediz que a instância pertence a essa classe tornando -se um classificador binário.

COMO FUNCIONA
A regressão logística é uma função sigmoide
(isto é, em forma de S) que gera um número entre 0 e
1. Ela é definida na Equação 16 e representada na Fi-
gura 314. Equação 16 Função Logística

Figura 310 Função Logística

LIMITES DE DECISÃO
Para demonstrar o funciona-
mento é útil usar o conjunto de da-
dos chamado íris. Este é um con-
junto de dados famoso que contém
o comprimento e largura das sépa-
las e pétalas de 150 flores de íris de
três espécies diferentes: Iris-Setosa,
Iris-Versicolor e Iris-Virginica.
Para criar um classificador
binário que separa o tipo Iris-Virgi- Figura 312 Diferentes espécies de Íris
nica dos demais com base apenas
no recurso de largura da pétala o primeiro passo é carregar os dados .

Figura 311 Passo 1: Carregar os dados

Página 151
 CURSO MACHINE LEARNING COM PYTHON

Separar a largura da pétala,

transformar as classes numéricas
em números é próximo passo.

Figura 313 Separação de atributos e classes

Por fim, é necessário trei-
nar um modelo de regressão logís-
tica, conforme demonstrado no Código 42.

Código 42 Treino do modelo de Regressão

As probabilidades estimadas do modelo para flores com larguras de pétalas variando

de 0 a 3 cm podem ser vistas Figura 318.

Figura 314 Classificação conforme a largura das pétalas

A largura da pétala das flores Iris-Virginica (representadas por triângulos) varia de

1,4 cm a 2,5 cm, enquanto as outras flores da íris (representadas por quadrados) geralmente
têm uma largura menor, variando de 0,1 cm a 1,8 cm. É possível observar que há um pouco
de sobreposição.
Acima de 2 cm, o classificador está altamente confiante de que a flor é uma Ir is-Virgi-
nica, enquanto abaixo de 1 cm está altamente confiante de que não é uma Iris -Virginica. En-
tre esses extremos (próximo do limite), o classificador não tem certeza.
Existe um limite de decisão em torno de 1,6 cm, onde ambas as probabilidades são
iguais a 50%, ou seja, se a largura da pétala for maior que 1,6 cm, o classificador irá prever
que a flor é uma Iris-Virginica e se for menor irá prever que não é.
É possível prever a classe mais prová-
vel que uma instância possui usando o método
predit() mesmo que a largura esteja próxima
do limite e o algoritmo não tenha muita cer-
teza. Figura 315 Método predict

Página 152
 CURSO MACHINE LEARNING COM PYTHON

É possível adicionar vários atributos no Modelo de Regressão Linear. A Figura 320

mostra o mesmo conjunto de dados exibindo dois atributos: largura e comprimento da pé-
tala.

Figura 316 Comparação com dois atributos

A linha tracejada representa o limite, ou sejam os pontos em que o modelo estima

uma probabilidade de 50%.
Cada linha paralela representa os pontos em que o modelo gera uma probabilidade
específica partindo de 15% (canto inferior esquerdo) até 90% (canto superior direito).
Todas as flores além da linha superior direita têm mais de 90% de chance de serem
Iris-Virginica, de acordo com o modelo.

REGRESSÃO SOFTMAX
O modelo de regressão logística pode ser generalizado para suportar diretamente vá-
rias classes. Este processo se chama Regressão Softmax, ou Regressão Logística Multinomial.
Assim como o classificador por regressão logística, o classificador Softmax prediz a
classe com a maior probabilidade estimada (que é simplesmente a classe com a maior pontu-
ação),
O classificador Softmax prevê apenas uma classe de cada vez (ou seja, é multiclasse,
não multi-saída), portanto, deve ser usado apenas com classes mutuamente exclusivas,
como diferentes tipos de plantas. Não se pode usá-lo para reconhecer várias pessoas em
uma imagem, por exemplo.
Para usar a regressão softmax, inicialmente é necessário separar um conjunto de
treinamento que possua os dois atributos:

Figura 317 Separação dos dados de entrada

Página 153
 CURSO MACHINE LEARNING COM PYTHON

É necessário, para aplicar uma regressão Softmax, setar o parâmetro mult_class para
“multinomial” e selecionar qual será o método de otimização com o parâmetro solver.

Figura 318 Opções disponíveis para o parâmetro solver

Para entender o melhor otimizador (solver), e saber qual é o melhor a ser usado, a
documentação traz alguns tópicos de ajuda:
● Para conjuntos de dados pequenos, 'liblinear' é uma boa opção, enquanto 'sag' e 'sa-
ga' são mais rápidos para os grandes.
● Para problemas multiclasses, apenas 'newton-cg', 'sag', 'saga' e 'lbfgs' lidam com o
parâmetro multinomial. 'liblinear' é limitado a esquemas de um contra o resto.
● 'newton-cg', 'lbfgs', 'sag' e 'saga' lidam com L2 ou sem penalidade
● 'liblinear' e 'saga' também são penalizados com L1
● 'saga' também suporta pena 'elasticnet'
● 'liblinear' não suporta configuração penalty='none'

O solver escolhido inicialmente será o 'liblinear'.

Figura 319 Treino do modelo

Agora, basta usar o modelo criado para predizer novos valores. Por exemplo, uma íris
com pétalas de 5 cm de comprimento e 2 cm de largura é classificada como Iris -Virginica
(classe 2) com 94,2% de certeza como visto na

Figura 320 Probabilidade de cada classe

A Figura abaixo mostra os limites de decisão resultantes, representados pelas cores

de fundo. A figura mostra as probabilidades para a classe Iris-Versicolor, representada pelas
linhas curvas (por exemplo, a linha rotulada com 0,450 representa o limite de probabilidade
de 45%). O modelo pode prever uma classe com probabilidade estimada abaixo de 50%.
Por exemplo, no ponto de limite,
todas as classes têm uma probabilidade
estimada igual de 33%.

Figura 321 Limites de decisão de cada classe

Página 154
 CURSO MACHINE LEARNING COM PYTHON

Máquinas de Vetor de Suporte

Uma Máquina de Vetor de Suporte ou SVM (do inglês Support Vector Machine) é um
modelo de aprendizado de máquina muito poderoso e versátil, capaz de executar classifica-
ção linear e não linear, regressão e detecção de pontos fora da curva.
É um dos modelos mais populares do Machine Learning, e qualquer pessoa interes-
sada no Machine Learning deve tê-lo em sua caixa de ferramentas.
Os SVMs são particularmente adequados para a classificação de conjuntos de dados
complexos, mas com poucos dados.
O que uma SVM faz é encontrar uma linha de separação, mais comumente chamada
de hiperplano entre dados de duas classes. Essa linha busca maximizar a distância entre os
pontos mais próximos em relação a cada uma das classes.

CLASSIFICAÇÃO SVM LINEAR

A Figura 326 representa
duas classes do conjunto de da-
dos íris. É possível traçar uma
linha para separar estas duas
classes de diversas formas.
NaFigura 327 estão representa-
das algumas aproximações cria-
das.

Figura 322 Classes do conjunto Íris

Figura 323 Modelos de classificação linear

A Figura 328 representa uma aproximação

gerada por um algoritmo de SVM. A linha repre-
senta o limite de decisão de um classificador SVM,
essa linha não apenas separa as duas classes, mas
também fica o mais longe possível das instâncias
de treinamento mais próximas.

Figura 324 Linha de separação das classes

Página 155
 CURSO MACHINE LEARNING COM PYTHON

É possível traçar mar-

gens (linhas tracejadas) onde as
primeiras instâncias estão.
Um algoritmo de SVM
tem a função de encontrar a
posição em que a largura das
margens seja a maior possível.
Este processo é chamado de
classificação de margem
grande.
Adicionar mais instân-
cias de treinamento fora das
Figura 325 Vetores de suporte sob as instâncias mais próximas
margens não afetará o limite da
decisão: é totalmente determinado (ou “suportado”) pelas instâncias localizadas na beira das
margens. Essas instâncias são chamadas de vetores de suporte.
Ao trabalhar com SVMs é necessário ter atenção pois este algoritmo é muito sensí-
vel às escalas dos dados, como pode ser visto na Figura 330.

Figura 326 Diferença no escalonamento das entradas

Na plotagem esquerda, a escala vertical é muito maior que a escala horizontal , por-
tanto, a margem mais larga possível fica próxima da horizontal. Após o dimensionamento do
recurso (usando o StandardScaler do Scikit-Learn), o limite de decisão fica muito melhor
(como observado na imagem direita).

CLASSIFICAÇÃO DE MARGEM SUAVE

Ao assumir a condição de que todas as instâncias estejam fora das margens existem
dois problemas principais que irão surgir.
Primeiro, ele só funciona se os dados são linearmente separáveis, ou seja, se é possí-
vel traçar uma linha para separar os dados. Segundo, existe muita sensibilidade aos valores
extremos podendo levar a separações equivocadas das classes.

Página 156
 CURSO MACHINE LEARNING COM PYTHON

A Figura 331 mostra o conjunto de dados da íris com apenas um ponto fora da curva.
À esquerda, é impossível encontrar uma margem que se adeque. À direita, o limite de deci-
são termina muito diferente do esperado.

Figura 327 Imagem com ponto propositalmente deslocado

Desta forma, se apenas um dos dados vindos de um sensor estiver com uma falha ou
deslocado a classificação se torna ruim ou impraticável.
Para evitar esses problemas, é preferível usar um modelo mais flexível. O objetivo é
encontrar um bom equilíbrio entre manter as margens o mais largas quanto possível e limi-
tar as violações de margem (ou seja, instâncias que terminam no meio das margens ou
mesmo do lado errado). Este processo é chamado de Classificação de Margem Suave.
Nas classes SVM do Scikit-Learn, é possível controlar esse equilíbrio usando o hiper
parâmetro C. Com um valor de C menor, as margens são maiores e, desta forma, as violações
de margem se tornam maiores.
A Figura 332 mostra os limites de decisão e as margens de dois classificadores SVM
em um conjunto de dados não linearmente separável.

Figura 328 Diferentes parâmetros de C

Este modelo foi gerado usando o .

Este código carrega o conjunto de dados
íris, dimensiona os recursos (usando o
classe StandardScaler) e treina um modelo
SVM linear (usando a classe LinearSVC com
C = 1) para detectar flores Iris-Virginica.

Código 43 Treino de um classificador SVM

Página 157
 CURSO MACHINE LEARNING COM PYTHON

É possível fazer predições com este modelo

utilizando o método predict.

Código 44 Predição de um valor com o SVM

Diferentemente dos classificadores de regressão logística, os classificadores SVM não

emitem probabilidades para cada classe.
Como alternativa, pode-se usar a classe SVC, usando a classe SVC (kernel = "linear", C
= 1), entretanto é muito mais lento, especialmente com conjuntos de treinamento grandes,
portanto, não é recomendado.

CLASSIFICAÇÃO SVM NÃO LINEAR

Embora os classificadores lineares SVM sejam eficientes e funcionem surpreendente-
mente bem em muitos casos, muitos conjuntos de dados nem sequer estão perto de serem
linearmente separáveis.
Uma abordagem para lidar com conjuntos de dados não lineares é adicionar mais
atributos, como recursos polinomiais. Em alguns casos, isso pode resultar em um conjunto
de dados linearmente separável.

Figura 329 Conjunto não linearmente separável

A Figura 333 representa um conjunto de dados simples com apenas um atributo x1.
Esse conjunto de dados não é linearmente separável, entretanto, ao adicionar um segundo
atributo x2 = (x1)², o conjunto de dados 2D resultante será perfeitamente separável linear-
mente como visto na Figura 334.

Figura 330 Demonstração de um novo atributo linearmente separável

Página 158
 CURSO MACHINE LEARNING COM PYTHON

Para implementar essa ideia usando o Scikit-Learn, basta criar um Pipeline contendo
um transformador da classe PolynomialFeatures seguido por um dimensionador da classe
StandardScaler e um LinearSVC.

KERNEL POLINOMIAL
A adição de recursos polinomiais é simples de implementar e pode funcionar muito
bem com todos os tipos de algoritmos de Machine Learning, mas em um grau polinomial
baixo, não é possível lidar com conjuntos de dados muito complexos e, com um alto grau po-
linomial, cria um grande número de recursos, tornando o modelo muito lento.
Felizmente, ao usar SVMs, é
possível aplicar uma técnica mate-
mática quase milagrosa chamada
truque do kernel. Esta técnica per-
mite obter o mesmo resultado,
como se tivesse adicionado muitos
recursos polinomiais, mesmo com
polinômios de graus muito altos,
sem precisar adicioná-los. Portanto,
não há explosão combinatória do
número de recursos, pois não se
adiciona nenhum recurso. Esse tru-
que é implementado pela classe Figura 331 Conjunto de dados de luas

SVC.
O Código 45 aplica
uma normalização dos
dados (StandardSca-
ler) e então aplica um
kernel polinomial de
grau 3.
Código 45 Normalização com kernel de 3º grau

Figura 332 SVM com kernel de 3º grau

Página 159
 CURSO MACHINE LEARNING COM PYTHON

O hiper parâmetro coef0 controla quanto o modelo é influenciado por polinômios de

alto grau versus polinômios de baixo grau.

Figura 333 Comparação com aproximações de grau 3, 10 e 20 respectivamente

Obviamente, se o modelo estiver sobre ajustado, convém reduzir o grau polinomial.

Por outro lado, se estiver mal ajustado, é necessário alterar os parâmetros.
Uma abordagem comum para encontrar os valores corretos de hiper parâmetros é
usar a pesquisa em grade. Geralmente, é mais rápido primeiro fazer uma pesquisa de grade
mais grotesca partindo, em seguida, para uma pesquisa de grade mais precisa, em torno dos
melhores valores encontrados.
Ter uma boa noção do que cada hiper parâmetro realmente faz também pode ser útil
para pesquisar e otimizar o local certo.

KERNEL GAUSSIANO RBF

Assim como o método
de recursos polinomiais, o mé-
todo de recursos de similari-
dade pode ser útil com qual-
quer algoritmo de Machine Le-
arning, mas pode ser caro em Código 46 Implementação da técnica kernel RBF
termos computacionais para
computar todos os recursos adicionais, especialmente em
grandes conjuntos de treinamento. No entanto, mais uma
vez, o truque do kernel faz sua mágica no SVM pois torna
possível obter um resultado semelhante como se estivesse
adicionado muitos recursos de similaridade, sem realmente
precisar adicioná-los.
O Código 46 implementa esta técnica usando o parâ-
metro kernel=”rbf” na classe SVC. A saída pode ser
observada na Figura 338.
Figura 334 Implementação do kernel RBF

Página 160
 CURSO MACHINE LEARNING COM PYTHON

O aumento da gama torna a curva em forma de sino mais estreita, e, como resul-
tado, a faixa de influência de cada instância é menor pois o limite da decisão acaba sendo
mais irregular, contornando instâncias individuais. Um pequeno valor gama torna a curva em
forma de sino mais ampla, para que as instâncias tenham uma gama maior de influência e o
limite de decisão acabe mais suave. Portanto, γ atua como um hiper parâmetro de regulari-
zação pois se o seu modelo estiver sobre ajustado, deve-se reduzi-lo e, se estiver abaixo do
mesmo, deve-se aumentá-lo.

Figura 335 Resultado de testes com diferentes parâmetros

Existem outros kernels, mas raramente são usados. Por exemplo os string kernels
que são usados ao classificar documentos de texto ou sequências de DNA (por exemplo,
usando o "string subsequence kernel " ou kernels baseados na distância de Levenshtein).
Com tantos kernels para escolher, como decidir qual usar? Como regra geral, deve
sempre tentar primeiro o kernel linear pois é muito mais rápido especialmente se o conjunto
de treinamento for muito grande ou se houver muitos recursos. Se o conjunto de treina-
mento não for muito grande, o kernel RBF também funciona bem na maioria dos casos.
Se poder de computação não for um problema, também pode-se experimentar al-
guns outros kernels usando as técnicas de validação cruzada e pesquisa em grade.

Página 161
 CURSO MACHINE LEARNING COM PYTHON

REGRESSÃO SVM
O algoritmo SVM é bastante versátil e também suporta regressão linear e não linear.
O truque é reverter o objetivo: em vez de t entar ajustar a maior margem possível entre duas
classes enquanto limita violações de margem, a regressão tenta ajustar o maior número pos-
sível de instâncias na margem enquanto limita violações de margem.
A largura da margem é controlada pelo hiper parâmetro ϵ. A figura abaixo mostra
dois modelos lineares de regressão SVM treinados em alguns dados lineares aleatórios, um
com uma grande margem (ϵ = 1,5) e outro com uma pequena margem (ϵ = 0,5).

Figura 336 Regressão com SVM's

Adicionar mais instâncias de treinamento dentro da margem não afeta as previsões

do modelo, assim, diz-se que o modelo é insensível a ϵ.
A classe LinearSVR do Scikit-Learn é
usada para executar uma regressão SVM linear.
Para lidar com tarefas de regressão não
linear, um modelo SVM kernelizado pode ser
Código 47 Implementação de regressão linear
usado. com SVM's

A Figura 341 mostra

a regressão SVM em um
conjunto de treinamento
quadrático aleatório,
usando um kernel de 2º
grau. Há pouca regulariza-
ção no gráfico esquerdo (ou
seja, um valor C grande) e
Figura 337 Regressão SVM usando um kernel polinomial de 2º grau
muito mais regularização
no gráfico direito (ou seja, um valor C pequeno).
O Código 48 produz o modelo representado à esquerda da figura anterior usando a
classe SVR do Scikit Learn.

Página 162
 CURSO MACHINE LEARNING COM PYTHON

Código 48 SVR com kernel de 2º grau

Árvores de Decisão
As Árvores de Decisão são algoritmos versáteis de Aprendizado de Máquina que po-
dem executar tarefas de classificação e regressão. Um ponto importante é que a classifica-
ção com múltiplas saídas também é possível.
As Árvores de Decisão são algoritmos muito poderosos, capazes de ajustar conjuntos
de dados muito complexos. As árvores de decisão também são os componentes fundamen-
tais das florestas aleatórias, que por sinal, estão entre os mais poderosos algoritmos de
aprendizado de máquina disponíveis atualmente.

TREINANDO E VISUALIZANDO UMA ÁRVORE DE DECI-

SÃO
O primeiro passo para en-
tender as Árvores de Decisão é
entender como ela faz previsões.
O Código 49 treina um modelo
classificador usando a classe De-
cisionTreeClassifier no conjunto
de dados íris. Código 49 Treino de uma Árvore de decisão

Para visualizar a Árvore de

Decisão treinada, o método ex-
port_graphviz() pode ser usado para
gerar um arquivo de definição de
gráfico (.dot) chamado iris_tree.dot
conforme o Código 50.
Em seguida, (se o sistema
operacional for uma distribuição
Código 50 Exportação do modelo criado linux) pode-se converter esse ar-
quivo .dot em vários formatos,
como PDF ou PNG, usando o comando dot do pacote graphviz.
Essa linha de comando converte o arquivo .dot em um arquivo de imagem .png:

Página 163
 CURSO MACHINE LEARNING COM PYTHON

De forma alternativa, se o sistema operacional for Windows, o processo é um pouco

mais complexo.
Primeiro, é necessário baixar o programa Graphviz no link https://www.gra-
phviz.org/download/.

Figura 338 Link de download

Após instalado, é possível usar o edi-

tor para visualizar os arquivos .dot gerados

Figura 339 Vizualização no Graphviz

Entretanto, é
muito mais interes-
sante usar estas funci-
onalidades no Jupyter
ou em um outro algo-
ritmo Python. A função
desenvolvida no Có-
digo 51 retorna uma
visualização a partir de
um modelo e mais al-
guns parâmetros (é
necessário que o Gra- Código 51 Função de vizualização no Jupyter
phviz esteja instalado).

Página 164
 CURSO MACHINE LEARNING COM PYTHON

Mais detalhes sobre a visualização no Windows, consultar [5] e [6].

FAZENDO PREVISÕES
Suponha que uma flor de íris é encontrada e se queira classificá -la. Para isso, a ár-
vore de decisão gerada anteriormente pode ser usada.

Figura 340 Árvore de decisão gerada

Começando do topo, ou como é conhecido, nó raiz (profundidade 0), a pergunta que

tem que se responder é se o comprimento da pétala da flor é menor que 2,45 cm. Se for,
basta descer para o nó filho esquerdo da raiz (profundidade 1, esquerda). Nesse caso, é um
nó folha (ou seja, não possui nós filhos), portanto, a flor é classificada como Íris-Setosa
(class = setosa).
Entretanto, se o comprimento da pétala é superior a 2,45 cm é necessário descer
para o nó filho direito da raiz (profundidade 1, direita), e fazer outra pergunta: a largura da
pétala é menor que 1,75 cm? Se for, ela é classificada como Iris-Versicolor (profundidade 2,
esquerda). Caso contrário, ela é classificada como uma Iris-Virginica (profundidade 2, à di-
reita). É realmente simples assim.
Uma das muitas qualidades das Árvores de Decisão é que elas exigem pouquíssima
preparação de dados pois não exigem escala ou centralização de recursos.
O atributo samples de um nó conta quantas instâncias de treinamento se enquadram
a todas as condições do nó.
Por exemplo, o nó raíz possui 150, pois é o número total de amostras. Após a pri-
meira condição ter sida aplicada (comprimento de pétala maior que 2,45cm) restam 100

Página 165
 CURSO MACHINE LEARNING COM PYTHON

amostras (profundidade 1, direita). Após aplicar mais uma condição (largura de pétala meno r
que 1,75 cm ) restaram 54 (profundidade 2, esquerda).
O atributo value de um nó informa quantas instâncias de cada classe pertencem a
esse nó. Por exemplo, o nó inferior direito se aplica a 0 Iris -Setosa, 1 Iris-Versicolor e 45 Iris-
Virginica.
Por fim, o atributo gini de um nó mede sua impureza. Um nó é "puro" (gini = 0) se
todas as instâncias às quais ele se aplica pertencerem à mesma classe. Por exemplo, no nó
esquerdo de profundidade 1 se aplica apenas às instâncias de treinamento de Iris-Setosa, é
puro e sua pontuação de gini é 0.
A Equação 6-1 mostra como o algoritmo de treinamento calcula a pontuação de gini.

Equação 17 Impureza gini

Por exemplo, o nó esquerdo de profundidade 2 tem uma pontuação gini igual:

O Scikit-Learn usa o algoritmo CART, que produz apenas árvores binárias , ou seja,
nós não-folha sempre têm dois filhos (perguntas têm apenas as respostas sim e não).
No entanto, outros algoritmos, como o ID3, podem produzir Árvores de Decisão com
nós que têm mais de dois filhos.
A Figura 345 mostra os
limites de decisão desta Árvore
de Decisão.
A linha vertical grossa
representa o limite de decisão
do nó raiz (profundidade 0),
comprimento da pétala = 2,45
cm.
Ao lado direito, existe Figura 341 Limites de decisão da árvore
ainda o limite de decisão da lar-
gura da pétala= 1.75 cm definido pela linha tracejada.
Como o parâmetro max_depth foi definido como 2, a Árvore de Decisão para ali. No
entanto, ao definir max_depth como 3, os dois nós de profundidade 2 adicionaram um outro
limite de decisão representado pelas linhas pontilhadas.

Página 166
 CURSO MACHINE LEARNING COM PYTHON

ESTIMANDO PROBABILIDADES DE CLASSE

Uma Árvore de Decisão também pode estimar a probabilidade de uma instância per-
tencer a uma classe. Ela faz isso percorrendo a árvore para encontrar o nó folha para essa
instância e, em seguida, retorna a proporção de instâncias de treinamento da classe nesse
nó. Por exemplo, suponha que uma flor cujas pétalas têm 5 cm de comprimento e 1,5 cm de
largura.
O nó folha correspondente é o nó esquerdo de profundidade 2.

Figura 342 Nó esquerdo de profundidade 2

Portanto, a Árvore de Decisão deve produzir as seguintes probabilidades:

● 0% para Iris-Setosa (0/54),
● 90,7% para Iris-Versicolor (49/54)
● 9,3% para Iris-Virginica (5/54)

E, é claro, os métodos .pre-

dict() e predict_proba() estão dis-
poníveis.

Figura 343 Métodos disponíveis

O ALGORITMO DE TREINAMENTO CART

O Scikit-Learn usa o algoritmo CART (Classification And Regression Tree) para trei nar
árvores de decisão (também chamadas de árvores "em crescimento").
A ideia é bem simples: o algoritmo primeiro divide o conjunto de treinamento em
dois subconjuntos, usando uma característica k (por exemplo, "comprimento da pétala”) e
um limiar tk (“≤ 2,45 cm").

Página 167
 CURSO MACHINE LEARNING COM PYTHON

Como ele escolhe k e tk? Ele procura o par (k, tk) que produz os subconjuntos mais
puros (ponderados pelo tamanho). A função de custo que o algoritmo tenta minimizar é
dada pela Equação 18.

Equação 18 Função de custo CART

Onde, G (left/right) é a medida de impuridade do subset e m(left/right) é o número

de instâncias no subset e m é o número de amostras total.
Depois de dividir com êxito o conjunto de treinamento em dois, ele divide os subcon-
juntos usando a mesma lógica, depois os subconjuntos e assim por diante, recursivamente.
Ele para de repetir quando atinge a profundidade máxima (definida pelo hiper parâ-
metro max_depth) ou se não conseguir encontrar uma divisão que reduza a impureza.
Alguns outros hiper parâmetros controlam condições de parada adicionais
(min_samples_split, min_samples_leaf, min_weight_fraction_leaf e max_leaf_nodes).
Infelizmente, encontrar a árvore ideal requer muito tempo tornando o problema in-
tratável, mesmo para conjuntos de treinamento pequenos. É por isso que se deve contentar
com uma solução "razoavelmente boa".

HIPER PARÂMETROS DE REGULARIZAÇÃO

As árvores de decisão fazem poucas suposições sobre os dados de treinamento (em
oposição aos modelos lineares, que obviamente assumem que os dados são lineares, por
exemplo). Se deixada sem restrições, a estrutura da árvore se adapta aos dados de treina-
mento criando problemas de generalização.
Para evitar o super ajuste dos dados de treinamento, é necessário restringir a li ber-
dade da Árvore de Decisão durante o treinamento. Os hiperparâmetros de regularização de-
pendem do algoritmo usado, mas geralmente se pode pelo menos restringir a profundidade
máxima da Árvore de Decisão.
No Scikit-Learn, a profundidades é controlada pelo hiperparâmetro max_depth (o
valor padrão é Nenhum, o que significa ilimitado). Reduzir max_depth irá regularizará o mo-
delo e, assim, reduzirá o risco de sobreajuste.
A classe DecisionTreeClassifier possui alguns outros parâmetros que restringem de
forma semelhante a forma da Árvore de Decisão:
● min_samples_split, o número mínimo de amostras que um nó deve ter antes de po-
der ser dividido
● min_samples_leaf, número mínimo de amostras que um nó folha deve ter
● min_weight_fraction_leaf, o mesmo que min_samples_leaf, mas expresso como
uma fração do número total de instâncias ponderadas
● max_leaf_nodes número máximo de nós folhas

Página 168
 CURSO MACHINE LEARNING COM PYTHON

● max_features número máximo de recursos que são avaliados para divisão em cada
nó.

Aumentar hiper parâmetro min_ * ou reduzir um hiperparâmetro max_ * irá regula-

rizar o modelo.
A Figura 348 mostra duas Árvores de Decisão treinadas com diferentes parâmetros
no conjunto de dados em formato de luas.

Figura 344 Restrição com o parâmetro min_samples_leaf

À esquerda, a Árvore de Decisão é treinada com os hiper parâmetros padrão (ou

seja, sem restrições) e à direita a Árvore de Decisão é treinada com min_samples_leaf=4.
É bem óbvio que o modelo à esquerda está sobre ajustado e o modelo à direita pro-
vavelmente irá trabalhar melhor com novos dados.

REGRESSÃO
As árvores de decisão também
são capazes de executar tarefas de re-
gressão.
Para demonstrar isso, supo-
nha um conjunto de dados quadrático
com muito ruído gerado conforme o
Código 52. Código 52 Dados quadráticos com alto ruído

Figura 345 Dados

aleatórios com ruído

Página 169
 CURSO MACHINE LEARNING COM PYTHON

A classe DecisionTreeRegressor do Scikit-Learn será usada para aplicar a regressão.

Figura 346 Regressão com Árvores de Decisão

A árvore resultante é representada na Figura 351.

Figura 347 Árvore de decisão para regressão

Essa árvore se parece muito com uma árvore de classificação a principal diferença é
que, em vez de prever uma classe em cada nó, ela prevê um valor.
Por exemplo, suponha uma previsão para uma nova instância com o valor de x1 =
0,6. Começando na raiz eventualmente se alcança o nó da folha que prediz valor = 0,1106
(profundidade 3, esquerda).
Essa previsão é simplesmente o valor-alvo médio das 110 instâncias de treinamento
associadas a este nó folha. Essa previsão resulta em um erro médio quadrático (MSE) i gual a
0,0151 nessas 110 instâncias.
As previsões deste modelo estão re-
presentadas na Figura 352.
A linha tracejada representa a pri-
meira profundidade e a linha sólida repre-
senta a segunda profundidade.

Figura 348 Limites de regressão

Página 170
 CURSO MACHINE LEARNING COM PYTHON

Observe como
o valor previsto para
cada região é sempre
o valor-alvo médio das
instâncias nesta re-
gião. O algoritmo di-
vide cada região de
uma maneira que
torna a maioria das
instâncias de treina-
mento o mais próximo
possível do valor pre-
visto.

Figura 349 Comparati-

vos entre modelos de
com o parâmetro
max_depth diferente

Assim como nas tarefas de classificação, as Árvores de Decisão tendem a se ajustar

demais ao lidar com tarefas de regressão. A Figura 354 representa um modelo padrão e um
modelo regularizado com o parâmetro min_samples_leaf=10.

Figura 350 Comparativo de sobre ajuste

Claramente, o modelo da esquerda está sobre ajustado e não irá generalizar bem
com novos dados.

Página 171
 CURSO MACHINE LEARNING COM PYTHON

INSTABILIDADE
Apesar dos enormes benefícios, algoritmos de Árvores de Decisão possuem algumas
limitações. Primeiro, as Árvores de Decisão são muito suscetíveis à limites de decisão ortogo-
nais (todas as divisões são perpendiculares a um eixo), o que as torna sensíveis à rotação do
conjunto de treinamento.
Por exemplo, a Figura 355 mostra um conjunto de dados simples e separável linear-
mente.

Figura 351 Conjunto de dados linearmente separável

Uma Árvore de Decisão

pode dividi-lo facilmente como
observado na linha grossa da Fi-
gura 356.

Figura 352 Conjunto de

dados separados

Entretanto, depois que o con-

junto de dados é girado em 45 °, o li-
mite da decisão parece desnecessari-
amente complicado.

Figura 353 Dados inclinados

Página 172
 CURSO MACHINE LEARNING COM PYTHON

Embora ambas as Árvores de Decisão se encaixem perfeitamente no conjunto de

treinamento, é muito provável que o modelo sobre ajustado não seja muito eficiente com
novos dados.
Uma maneira de limitar esse problema é usar o PCA, o que geralmente resulta em
uma melhor orientação dos dados de treinamento.
Um outro problema das Árvores de Decisão é que elas são muito sensíveis a peque-
nas variações nos dados de treinamento. Por exemplo, se a flor da classe Iris -Versicolor que
possui as maiores pétalas for removida (contornado pelo círculo vermelho), o modelo repre-
sentado será muito diferente do primeiro como visto na Figura 358.

Figura 354 Alteração de todo o modelo devido a mudança de um único ponto

Como é possível observar o comportamento dos modelos é muito diferente. Na ver-

dade, como o algoritmo de treinamento usado pelo Scikit -Learn é estocástico, é possível ob-
ter modelos muito diferentes mesmo nos mesmos dados de treinamento (a menos que você
defina o hiperparâmetro random_state).

Página 173
 CURSO MACHINE LEARNING COM PYTHON

CAPÍTULO 8
Algoritmos Ensemble
Suponha que se faça uma pergunta complexa a milhares de pessoas aleatórias e de-
pois agregue suas respostas. Em muitos casos, essa resposta agregada é melhor que a res-
posta de um especialista. Isso é chamado de sabedoria da multidão.
Da mesma forma, ao agregar as previsões de um grupo de preditores (como classifi-
cadores ou regressores), geralmente melhores previsões serão obtidas em relação ao melhor
preditor individual. Um grupo de preditor es é chamado de conjunto, portanto, essa técnica é
chamada de Ensemble Learning (Do inglês Aprendizado em Conjunto).
Por exemplo, ao treinar um grupo de classificadores da Árvore de Decisão usando
dados diferentes para fazer previsões, obtém-se as previsões de todas as árvores individuais
e, em seguida, a classe que obtém mais votos é classificada. Esse método, alias, é chamado
de florestas aleatórias e, apesar de sua simplicidade, é um dos algoritmos de aprendizado de
máquina mais poderosos disponíveis atualmente.
Além disso, é comum usar métodos Ensemble perto do final de um projeto, depois
de criar alguns bons preditores, para combiná-los em um preditor ainda melhor. De fato, as
soluções vencedoras nas competições de Machine Learning geralmente envolvem v ários mé-
todos de Ensemble (mais famosos na competição do Prêmio Netflix).
Os métodos de ensemble são meta-algoritmos que combinam várias técnicas de
aprendizado de máquina em um modelo preditivo para diminuir a variação ( bagging), o viés
(boosting) ou melhorar as previsões (stacking).

CLASSIFICADORES DE VOTAÇÃO
Suponha que tenha se treinado alguns classificadores, cada um atingindo cerca de
80% de precisão. Por exemplo, se existir um classificador de Regressão Logística, um classifi-
cador SVM, um classificador de Florestas aleatórias, um classificador KNN e talvez mais al-
guns como visto na Figura 359.

Figura 355 Treino de diversos classificadores

Página 174
 CURSO MACHINE LEARNING COM PYTHON

Uma maneira muito

simples de criar um classifi-
cador ainda melhor é agregar
as previsões de cada classifi-
cador e prever a classe que
obtém mais votos. Esse clas-
sificador de votos por maio-
ria é chamado de classifica-
dor de votação definitiva e
pode ser visto na Figura 360.
Surpreendente- Figura 356 Classificador de votação
mente, esse classificador de
votação geralmente alcança uma precisão mais alta que o melhor classificador do conjunto.
De fato, mesmo que cada classificador seja apenas um pouco melhor que a suposição aleató-
ria, o conjunto ainda pode atingir alta precisão.
Para entender como isso é possível a seguinte analogia pode ajudar. Suponha que
uma moeda ligeiramente tendenciosa que tem 51% de chance de aparecer cara e 49% de
chance de aparecer coroa. Ao jogar 1.000 vezes, um total de mais ou menos 510 caras e 490
coroas será contabilizado.
Ao fazer as contas, a probabilidade de obter a maioria de caras após 1.000 lançamen-
tos é próxima de 75%. E desta forma quanto mais se joga a moeda, maior a probabilidade
(por exemplo, com 10.000 lançamentos, a probabilidade ultrapassa 97%).
Isso se deve à lei dos grandes números, em outras p alavras, à medida que a moeda é
jogada, a proporção de
caras fica cada vez
mais próxima da pro-
babilidade (51%).
A Figura 361
mostra 10 séries de
lançamentos tendenci-
osos de moedas. É
possível notar que, à
medida que o número Figura 357 Lançamentos tendenciosos de uma moeda
de lançamentos aumenta, a proporção de caras se aproxima de 51%. Eventualmente, todas
as 10 séries acabam tão perto de 51% que estão consistentemente acima de 50%.
Da mesma forma, ao construir um conjunto contendo 1.000 classificadores que são
individualmente corretos apenas 51% das vezes (um pouco melhor do que a suposição alea-
tória) ao prever a classe votada por maioria, pode-se atingir até 75% de precisão.
No entanto, isso só é verdade se todos os classificadores forem perfeitamente inde-
pendentes, cometendo erros não correlacionados, o que claramente não é o caso, pois eles
são treinados nos mesmos dados. É provável que cometam os mesmos tipos de erros, por-
tanto haverá muitos votos majoritários para a classe errada, reduzindo a precisão do con-
junto.
Página 175
 CURSO MACHINE LEARNING COM PYTHON

Os métodos de agrupamento funcionam melhor quando os preditores são tão inde-

pendentes um do outro quanto possível. Uma maneir a de obter classificadores diversos é
treiná-los usando algoritmos muito diferentes. Isso aumenta a chance de eles cometerem ti-
pos muito diferentes de erros, melhorando a precisão do conjunto
O Código 53 cria um classificador de votação usando a classe VotingClassifier do Sci-
kit-Learn.

Código 53 Criação de um modelo de votação com 3 estimadores diferentes

O treino é feito de forma idêntica aos

outros algoritmos com o método fit do SciKit
Learn como demonstrado no Código 54 que
Código 54 Treino do modelo de votação
faz o treino do classificador com o conjunto
de luas.
A precisão de cada um dos modelos pode ser observada na

Figura 358 P resição medida nos diferentes algoritmos

O classificador de votação, como pode ser observado, supera ligeiramente todos os

classificadores individuais.
Se todos os classificadores poderem estimar probabilidades de classe (ou seja, eles
têm um método predict_proba()), é possível dizer ao Scikit-Learn para prever a classe com a
maior probabilidade, com média de todos os classificadores individuais. Isso é chamado de
votação.
Como não é o caso da classe SVC pois, por padrão, é necessário definir seu hiperpa-
râmetro de probabilidade como True (isso fará com que a classe SVC use a validação cru zada

Página 176
 CURSO MACHINE LEARNING COM PYTHON

para estimar as probabilidades da classe, desacelerando o treinamento e adicionando um

método prediz_proba().
Ao modificar o código anterior para usar a votação eletrônica, o classificador de vo-
tação atinge uma precisão de 91% como visto na Figura 363.

Figura 359 Votação eletrônica (voting="soft")

Bagging e Pasting
Uma maneira de obter um conjunto diversificado de classificadores é usar algoritmos
de treinamento diferentes. Outra abordagem é usar o mesmo algoritmo de treinamento para
todos os preditores, mas treiná-los em diferentes subconjuntos aleatórios frutos do conjunto
de treinamento.
Este processo se dá da seguinte maneira::
● O conjunto de dados é copiado diversas vezes gerando novos conjuntos idênticos ao
original.
● Se for desejado, um método de substituição pode ser aplicado. Este método duplica
um determinado número de registros para aumentar artificialmente o tamanho do
conjunto.
● Os dados de cada uma das cópias é embaralhada de forma aleatória.

Quando a amostragem é realizada com substituição, o método é chamado de Bag-

ging (Bootstrap Aggregating). Quando a amostr agem é realizada sem substituição, é cha-
mada de Pasting.
Em outras palavras, estes mé-
todos permitem que as instâncias de
treinamento sejam amostradas várias
vezes em vários preditores, mas ape-
nas o Bagging permite que as instân-
cias de treinamento sejam amostra-
das várias vezes para o mesmo predi-
tor.
Figura 360 Processo de Bagging

Página 177
 CURSO MACHINE LEARNING COM PYTHON

O processo de amostragem e treinamento Bagging está representado na Figura 364.

Depois que todos os preditores são treinados, o conjunto pode fazer uma previsão
para uma nova instância simplesmente agregando as previsões de todos os preditores.
A função de agregação faz com que previsão mais frequente seja usada no classifica-
dor e a média em uma tarefa de regressão.
Este método permite que todos os preditores sejam treinados em paralelo, por meio
de diferentes núcleos de CPU ou mesmo servidores diferentes. Da mesma forma , previsões
podem ser feitas em paralelo. Essa é uma das razões pelas quais Bagging e Pasting são méto-
dos tão populares.

BAGGING AND PASTING NO SCIKIT-LEARN

O Scikit-Learn oferece uma forma simples para trabalhar com Bagging e Pasting utili-
zando a classe BaggingClassifier (ou BaggingRegressor para regressão).
Usando ainda o
conjunto de luas, o Có-
digo 55 utiliza a técnica
de Bagging com 500
classificadores baseados
em Árvores de Decisão
e com 100 registros (de
um total de 375) sepa-
rados aleatoriamente
usando o parâmetro
max_samples=100.
Este é um exem- Código 55 Implementação de Bagging
plo de Bagging, para usar
Pasting, basta definir o parâmetro bootstrap=False).
O parâmetro n_jobs
informa ao Scikit-Learn o
número de núcleos da CPU a
serem usados para treina-
mento e previsões (–1 diz ao
Scikit-Learn para usar todos
os núcleos disponíveis).
Figura 361 Demonstração do processo de Bagging A Figura 365 com-
para o limite de decisão de uma única Árvore de Decisão com o limite de decisão de um con-
junto de Bagging do código anterior.
As previsões do Bagging provavelmente irão se generalizar muito melhor do que as
previsões da uma única Árvore de Decisão.

Página 178
 CURSO MACHINE LEARNING COM PYTHON

AVALIAÇÃO OUT-OF-BAG
No Bagging, algumas instâncias podem ser amostradas várias vezes para um determi-
nado preditor, enquanto outras podem não ser amostradas.
Isso significa que apenas cerca de 63% das instâncias de treinamento são amostra-
das, em média, para cada preditor. Os 37% restantes das instâncias de treinam ento que não
são amostradas são chamados de instâncias prontas para uso.
Como um preditor não usa estas instâncias durante o treinamento, as mesmas po-
dem ser usadas nos testes, sem a necessidade, neste caso, de um conjunto de validação se-
parado ou de validação cruzada.
Para avaliar o próprio conjunto basta calcular a média das avaliações de cada predi-
tor como demonstrado na Figura 366.

Figura 362 Medida de precisão calculada

De acordo com essa avaliação, é pro-

vável que este BaggingClassifier atinja aproxi-
madamente 90,13% de precisão no conjunto
de teste. Conforme comprovado na Figura
367 que demonstra 91,2% de precisão no Figura 363 Precisão no conjunto de testes
conjunto de testes, uma aproximação muito
grande.
A função de decisão, contendo a proba-
bilidade para cada instância de treinamento tam-
bém está disponível através da variável oob_de-
cision_function_.
Como observado na Figura 368, a se-
gunda instância de treinamento tem 31,74% de
probabilidade de pertencer à classe positiva (e
68,25% de pertencer à classe negativa).

Figura 364 Probabilidade em cada instância

Página 179
 CURSO MACHINE LEARNING COM PYTHON

BOOSTING
Impulsionar (originalmente chamado de aumento de hipóteses) refere-se a qualquer
método Ensemble que pode combinar vários modelos fracos em um forte. A ideia geral da
maioria dos métodos de reforço é treinar preditores sequencialmente, cada um tentando
corrigir seu predecessor. Existem muitos métodos de reforço disponíveis, mas os mais popu-
lares são o AdaBoost (abreviação de Adaptive Boosting) e o Gradient Boo sting.

ADABOOST
Uma maneira de um novo preditor corrigir seu antecessor é prestar um pouco mais
de atenção às instâncias de treinamento que o antecessor não ajustou. Isso resulta em novos
preditores focando cada vez mais nos casos difíceis. Essa é a técnica usada pelo AdaBoost.
Por exemplo, para criar um classificador AdaBoost, um classificador (como uma Ár-
vore de Decisão) é treinado e usado para fazer previsões no conjunto de treinamento. O
peso relativo de instâncias de treinamento classificadas incorreta mente é aumentado. Um
segundo classificador é treinado usando os pesos atualizados e, novamente se faz previsões
no conjunto de treinamento, os pesos são atualizados e assim por diante.
A Figura 369 retrata este processo.

Figura 365 Treino sequencial Adaboost com ajuste de pesos

A Figura 370 mos-

tra os limites de decisão
de cinco preditores con-
secutivos no conjunto de
dados de luas (neste
exemplo, cada preditor é
um classificador SVM alta-
mente regularizado com um
Figura 366 Linhas de decisão para preditores consecutivos
kernel RBF).

Página 180
 CURSO MACHINE LEARNING COM PYTHON

O primeiro classificador erra muitas instâncias, portanto, seus pesos são aumenta-
dos. O segundo classificador, portanto, faz um trabalho melhor nessas instâncias e assim por
diante. O gráfico à direita representa a mesma sequência de preditores, excet o que a taxa de
aprendizado é reduzida pela metade (ou seja, os pesos de instância mal classificados são au-
mentados mais lentamente em cada iteração).
Depois que todos os preditores são treinados, o conjunto faz previsões muito pareci-
das com o Bagging ou Pasting, exceto que os preditores têm pesos diferentes, dependendo
de sua precisão geral no conjunto de treinamento ponderado.
Há uma desvantagem importante nessa técnica de aprendizado sequencial: ela não
pode ser paralelizada (ou apenas parcialmente), uma vez que cada preditor só pode ser trei-
nado após o preditor anterior ter sido treinado e avaliado. Como resultado, ele não é escalá-
vel como no bagging ou pasting.
Para fazer previsões, o AdaBoost simplesmente calcula as previsões de todos os pre-
ditores e as compara usando as características de acerto do preditor. A classe prevista é a
que recebe a maioria dos votos ponderados.
O Scikit-Learn, na verdade, usa uma versão multiclasse do AdaBoost chamada
SAMME (que, traduzida do inglês, significa Modelagem Aditiva Stagewise usando uma função
de perda Exponencial Multiclasse). Quando há apenas duas classes, o SAMME é equivalente
ao AdaBoost.
Se os preditores puderem estimar as probabilidades de classe (ou seja, se tiverem
um método predict_proba()), o Scikit-Learn poderá usar uma variante do SAMME chamada
SAMME.R (o R significa "Real"), que depende das probabilidades de classe em vez de previ-
sões e geralmente tem um desempenho melhor.
O Código 56 treina um classificador AdaBoost com base em 200 Decision Stumps
usando a classe AdaBoostClassifier do Scikit-Learn (como você pode esperar, também há
uma classe AdaBoostRegressor).

Código 56 Implementação de um código AdaBoost

Um Decision Stumps é uma Árvore de Decisão com max_depth = 1, em outras pala-

vras, uma árvore composta por um único nó de decisão mais dois nós de folha. Este é o esti-
mador base padrão para a classe AdaBoostClassifier .

Página 181
 CURSO MACHINE LEARNING COM PYTHON

Se o seu conjunto AdaBoost está adaptando demais o conjunto de treinamento, é

possível reduzir o número de estimadores ou regularizar mais fortemente o estimador de
base.

GRADIENT BOOSTING
Outro algoritmo de Boosting muito popular é o Gradient Boosting. Assim como o
AdaBoost, o Gradient Boosting funciona adicionando sequencialmente preditores a um con-
junto, cada um corrigindo seu antecessor.
No entanto, em vez de ajustar os
pesos a cada iteração, como o AdaBoost,
esse método tenta ajustar o novo preditor
aos erros residuais cometidos pelo predi-
tor anterior.
Para exemplificar, imagine um
conjunto de dados com alto ruído como
visto na Figura 371.
O primeiro passo é ajustar um De-
cisionTreeRegressor ao conjunto de trei- Figura 367 Dados quadráticos com alto ruído
namento como no Código 57.

Código 57 Primeiro modelo

Agora basta treinar um segundo DecisionTreeRegressor nos erros residuais cometi-

dos pelo primeiro preditor conforme o Código 58.

Código 58 Segundo modelo criado com base nos erros do primeiro

Em seguida, um terceiro modelo é treinado com base nos erros residuais cometidos
pelo segundo preditor.

Código 59 Terceiro modelo criado com base nos erros do segundo

Página 182
 CURSO MACHINE LEARNING COM PYTHON

Agora um conjunto contendo três árvores está disponível. Ele pode fazer previsões
em uma nova instância simplesmente adicionando as previsões de todas as árvores como de-
monstrado no Código 60.

Código 60 Predição com os modelos anteriores.

A Figura 372 representa as previsões dessas três árvores. Na coluna da esquerda es-
tão representadas cada árvore individualmente e as previsões do conjunto na coluna da di-
reita.

Figura 368 Previsões para os modelos treinados

Na primeira linha, o conjunto tem apenas uma árvore, portanto, suas previsões são
exatamente as mesmas que as da primeira árvore.
Na segunda linha, uma nova árvore é treinada sobre os erros residuais da primeira
árvore.
À direita, é possível ver que as previsões do conjunto são iguais à soma das previsões
das duas primeiras árvores. Da mesma forma, na terceira linha, outra árvore é treinada so-
bre os erros residuais da segunda árvore.

Página 183
 CURSO MACHINE LEARNING COM PYTHON

Desta forma, é possível ver que as previsões do conjunto melhoram gradua lmente à
medida que as árvores são adicionadas ao conjunto.
Uma maneira mais simples de treinar conjuntos de é usar a classe GradientBoostin-
gRegressor do Scikit-Learn.
Assim como a classe RandomForestRegressor, ela possui hiper parâmetros para con-
trolar o crescimento de Árvores de Decisão (por exemplo, max_depth, min_samples_leaf e
assim por diante), além de hiperparâmetros para controlar o treinamento do conjunto, como
o número de árvores (n_estimators).
O Código 61 cria o mesmo
conjunto que o anterior.

Código 61 GradientBoosting parametrizado

O hiper parâmetro learning_rate escala a contribuição de cada árvore. Ao definir um

valor baixo, como 0.1 mais árvores serão necessárias no conjunto para ajustar -se ao con-
junto de treinamento, mas as previsões geralmente se generalizam melhor.
Esta é uma técnica de regularização chamada contração. A Figura 373 mostra dois
conjuntos treinados com uma baixa taxa de aprendizado. Como é possível observar o da es-
querda não possui árvores suficientes para caber no conjunto de treinamento, enquanto o
da direita tem muitas árvores e supera o conjunto de treinamento.

Figura 369 Comparação de taxas de aprendizado

Para encontrar o número ideal de árvores, é possível usar a parada antecipada. Uma
maneira simples de implementar isso é usar o método staged_predict() pois ele retorna um
iterador sobre as previsões feitas pelo conjunto em cada estágio do treinamento (com uma
árvore, duas árvores, etc.).
O Código 62 treina um conjunto com 120 árvores, mede o erro de validação em cada
estágio do treinamento para encontrar o número ideal de árvores e, finalmente, treina outro
conjunto usando o número ideal de árvores.

Página 184
 CURSO MACHINE LEARNING COM PYTHON

Código 62 Exemplo de implementação

Os erros de validação são representados à esquerda da Figura 374 abaixo e as previ-

sões do melhor modelo são representadas à direita.

Figura 370 A esquerda erros de validação e a direita o resultado do melhor modelo

Também é possível implementar a parada antecipada, parando o treinamento mais

cedo (em vez de treinar um grande número de árvores primeiro e depois olhar para trás para
encontrar o número ideal).
Para fazer isso, deve-se configurar warm_start=True, o que faz com que o ScikitLe-
arn mantenha as árvores existentes quando o método fit() é chamado, permitindo treina-
mento incremental.
O Código 63 interrompe o treinamento quando o erro de validação não melhora por
cinco iterações consecutivas.

Página 185
 CURSO MACHINE LEARNING COM PYTHON

Código 63 Implementação de parada por critério

A classe GradientBoostingRegressor também suporta um hiperparâmetro de suba-

mostra (subsample), que especifica a fração de instâncias de treinamento a serem usadas
para treinar cada árvore.
Por exemplo, se subsample=0.25, cada árvore é treinada em 25% das instâncias de
treinamento, selecionadas aleatoriamente. Como é provável supor, isso troca um viés mais
alto por uma variação menor. Também acelera o treinamento consideravelmente. Essa téc-
nica é chamada de reforço estocástico de gradiente.
É possível usar o Gradient Boosting com outras funções de custo. Isso é controlado
pelo hiperparâmetro de perda (loss). Para mais detalhes basta consultar a documentação do
Scikit-Learn.

STACKING
O último método do Ensemble que é discutido aqui é chamado Stacking (que, tradu-
zido do inglês, é uma abreviação de generalização empilhada).
É baseado em uma ideia simples: em vez de usar funções triviais (como votação)
para agregar as previsões de todos os preditores de um ensemble por que não trein ar um
modelo para executar essa agregação?

Página 186
 CURSO MACHINE LEARNING COM PYTHON

A mostra esse conjunto executando

uma tarefa de regressão em uma nova instân-
cia. Cada um dos três preditores inferiores
prevê um valor diferente (3.1, 2.7 e 2.9) e, em
seguida, o preditor final (chamado de liquidifi-
cador ou meta-aprendiz) toma essas previsões
como entradas e faz a previsão final (3.0).

Figura 371 Uso de um preditor para agre-

gação dos dados

Para treinar o liquidificador, uma

abordagem comum é usar um conjunto de
espera. Primeiro, o conjunto de treina-
mento é dividido em dois subconjuntos. O
primeiro subconjunto é usado para treinar
os preditores na primeira camada.

Figura 372 Treino da primeira camada

Em seguida, os preditores da
primeira camada são usados para fazer
previsões no segundo conjunto.
Isso garante que as previsões
sejam "limpas", pois os preditores
nunca viram essas instâncias durante o
treinamento. Agora, para cada instân-
cia no conjunto de espera, existem três
valores previstos.
Na verdade, é possível treinar
vários liquidificadores diferentes dessa
maneira (por exemplo, um usando re-
gressão linear, outro usando regressão
de florestas aleatórias e assim por di-
ante) pois, desta forma, uma camada
inteira de liquidificadores é obtida. Figura 373 Treino do liquidificador

O truque é dividir o conjunto

de treinamento em três subconjunto. O primeiro é usado para treinar a primeira camada, o
segundo é usado para criar o conjunto de treinamento usado para treinar a segunda camada
(usando previsões feitas pelos preditores da primeira camada ) e o terceiro é usado para

Página 187
 CURSO MACHINE LEARNING COM PYTHON

criar o conjunto de treinamento

para treinar a terceira camada
(usando previsões feitas pelos
preditores da segunda camada).
Feito isso, é possível fa-
zer uma previsão para uma nova
instância, percorrendo cada ca-
mada sequencialmente, como
mostra a Figura 378.

Figura 374 Predições em um algoritmo Stacking multicamada

Infelizmente, o Scikit-Learn na versão 0.21 (versão atual do Anaconda) não oferece

suporte ao empilhamento diretamente, mas não é muito difícil implementar.
Como alternativa, é possível usar o pacote mlxtend, para usá-lo é necessário instalar
com o gerenciador pip:
pip insatall mlxtend

Supondo o conjunto de dados

íris importado no

Código 64 Importação do conjunto íris

É necessário apenas usar a classe StackingClassifier como visto no Código 66.

Página 188
 CURSO MACHINE LEARNING COM PYTHON

Código 66 Implementação de um classificador Stacking

O Código 65 faz uma validação cruzada com 3 dobras.

Código 65 Validação cruzada de 3 dobras (os alertas foram ignorados devido ao uso do módulo mlxtend)

Os resultados se
mostram bem proveitosos
conforme observado na

Figura 375 Resultado da validação cruzada

Para mais informações consultar [7].

Página 189
 CURSO MACHINE LEARNING COM PYTHON

Florestas Aleatórias
Florestas aleatórias ou florestas de decisão aleatória são um método de aprendizado
em conjunto para classificação, regressão e outras tarefas. Elas operam construindo uma in-
finidade de árvores de decisão no momento do treinamento e obtendo por meio de votação
a classe (classificação) ou a média das árvores individuais de um valor (regressão).
A Figura 380 mostra um exemplo com 3 árvores (n_estimators=3) e u m número má-
ximo de nós folhas em 2 (max_leaf_nodes=2).

Figura 376 Árvores de decisão de uma floresta aleatória

Uma Floresta Aleatória, geralmente é treinada pelo método de Bagging (ou Pasting),
geralmente com o parâmetro max_samples configurado para o tamanho do conjunto de trei-
namento.
Em vez de criar um BaggingClassifier passando um DecisionTreeClassifier como parâ-
metro, é possível usar a classe RandomForestClassifier, que é mais conveniente e otimizada
para as Árvores de Decisão (da mesma forma, existe uma classe RandomForestRegressor
para tarefas de regressão).
O Código 67 treina um classificador de Floresta Aleatória com 500 árvores (cada uma
limitada ao máximo de 16 nós), usando todos os núcleos de CPU disponíveis (n_jobs=-1).

Código 67 Treino de uma Floresta Aleatória

Com algumas exceções, um RandomForestClassifier possui todos os hiper parâmetros

de um DecisionTreeClassifier, além de todos os hiper parâmetros de um BaggingClassifier
para controlar o próprio conjunto
O algoritmo introduz ainda aleatoriedade extra ao cultivar árvores , ou seja, em vez
de procurar o melhor recurso ao dividir um nó, ele procura o melhor recurso entre um sub-
conjunto aleatório de recursos.
Isso resulta em uma maior diversidade de árvores, g eralmente produzindo um mo-
delo melhor. O BaggingClassifier do Código 68 é aproximadamente equivalente ao Random-
ForestClassifier anterior.

Página 190
 CURSO MACHINE LEARNING COM PYTHON

Código 68 Equivalente Bagging do Código 67

ÁRVORES EXTRAS
Quando uma árvore é treinada em uma Floresta Aleatória, em cada nó apenas um
subconjunto aleatório dos recursos é considerado para divisão (conforme discutido anterior-
mente).
É possível tornar as árvores ainda mais aleatórias usando também limites aleatórios
para cada recurso, em vez de procurar os melhores limites possíveis (como fazem as Árvores
de Decisão regulares).
Uma floresta dessas árvores é simplesmente chamada de conjunto de Árvores Extre-
mamente Aleatórias (ou Extra-Árvores para abreviar). Isso torna o algoritmo muito mais rá-
pido e com menos variação ao treinar as florestas aleatórias regulares, já que encontrar o
melhor limite possível para cada recurso em cada nó é uma das tarefas mais demoradas para
o treinamento de uma árvore.
Para criar um classificador Extra-Trees basta usar a classe ExtraTreesClassifier ao in-
vés de RandomForestClassifier.
É difícil dizer com antecedência se um RandomForestClassifier terá um desempe nho
melhor ou pior que um ExtraTreesClassifier. Geralmente, a única maneira de saber é tentar
os dois e compará-los usando a validação cruzada (e ajustando os hiper parâmetros usando a
pesquisa em grade).

IMPORTÂNCIA DE UM ATRIBUTO
Ao olhar para uma única Árvore de Decisão, é provável que recursos importantes
apareçam mais próximos da raiz da árvore, enquanto recursos sem importância geralmente
aparecerão mais próximos das folhas (ou não).
Portanto, é possível obter uma estimativa da importância de um atributo calculando
a profundidade média em que ele aparece em
todas as árvores da floresta. O Scikit-Learn cal-
cula isso automaticamente para todos os re-
cursos após o treinamento.O resultado está
contido na variável feature_importances_. Por
exemplo, a Figura 381 treina um RandomFores-
tClassifier no conjunto de dados da íris e
mostra a importância de cada atributo. Figura 377 Atributos mais importantes do conjunto

Página 191
 CURSO MACHINE LEARNING COM PYTHON

Parece que as características mais importantes são o comprimento (44%) e largura

(42%) da pétala. O comprimento e a largura da sépala não se mostram tão importantes (11%
e 2%, respectivamente).
Da mesma forma, ao
treinar um classificador Ran-
dom Forest no conjunto de
dados MNIST e plotar a im-
portância de cada pixel, ob-
terá a Figura 382.

Figura 378 Importancia de cada pixel

no conjunto de dados MNIST

As florestas aleatórias são muito úteis para entender rapidamente quais recursos re-
almente importam, principalmente se for preciso executar a seleção de atributos.

Página 192
 CURSO MACHINE LEARNING COM PYTHON

CAPÍTULO 9
Processamento de Linguagem Natural
Processamento de linguagem natural, conhecida pela sigla PLN (ou NLP do inglês na-
tural language processing), é um campo da inteligência artificial que ajuda as máquinas a en-
tenderem e interpretarem a língua humana e vice-versa.
Compreender um texto é muito mais complexo do que se imagina. É necessário que
os computadores possam identificar um contexto, fazer as análises sintática, morfológica,
semântica e léxica para, só então, ser capaz de produzir resumos, realizar traduções para
outras línguas, absorver informações, extrair aprendizados e interpretar sentidos e senti-
mentos.
O maior desafio para a PNL é julgar com precisão a intenção das palavras, tendo em
mente a ambiguidade da linguagem.
Os estudos de NPL se dividem em 7 grandes grupos:
● Morfologia: Estudo da fonologia, ou seja, da organização do som sistematicamente.
● Morfema: Estudo da construção de palavras a partir de unidades significativas primi-
tivas.
● Sintaxe: Estudo das regras que regem a construção de frases n as línguas naturais
● Semântica: Organizando palavras para formar uma frase; determinar o papel estrutu-
ral das palavras em frases e frases, ou seja, estuda o significado usado por seres hu-
manos para se expressar através da linguagem.
● Pragmática: Estuda os significados das palavras e como combiná-las para criar frases
e frases significativas.
● Discurso: Estudo o uso e compreensão de sentenças em várias situações para, desta
forma, determinar como isso afeta a interpretação da frase.
● Conhecimento Mundial: Compreensão de como uma sentença pode afetar a próxima.

Página 193
 CURSO MACHINE LEARNING COM PYTHON

COMO FUNCIONA?
Assim como todos os projetos de inteligência artificial, diversas etapas são necessá-
rias para se obter algum resultado prático. Para NPL, existem 7 níveis de processamento: fo-
nologia, morfologia, léxico e sintático, semântico e contextual de um discurso e por fim o
pragmático. Eles estão representados na Figura 383.

Figura 379 Processo de Análise NPL

A fonologia identifica e interpreta os sons que formam as palavras quando a máquina

precisa entender a linguagem falada.
A morfologia cuida do que se refere à composição das palavras e sua natureza, divi-
dindo-as em morfemas (menores unidades de significação que constituem as palavras: desi-
nência, raiz, radical, afixo, tema e vogal temática). Enquanto o processamento sintático ana-
lisa a formação da sentença e a especificação das estruturas perm itidas na linguagem.
O léxico analisa a entrada de linhas de caracteres (como o código -fonte de um pro-
grama) e produz uma sequência de símbolos léxicos (lexical tokens). Capta o significado indi-
vidual das palavras.
A análise semântica se ocupa com o significado da frase. Extrai um significado da es-
trutura sintática. E o discurso verifica o total do significado do texto.
Por fim, o processamento pragmático interpreta os conceitos extraídos do texto,
averiguando se o significado da análise semântica está correto e determinando significados
que não estejam claros.

TIPOS DE ABORDAGEM
Os níveis de processamento são abordados de 4 formas: simbólica, estatística, cone-
xionista e híbrida.
A abordagem simbólica se baseia nas regras linguísticas sem ambiguidades e bem es-
truturadas.

Página 194
 CURSO MACHINE LEARNING COM PYTHON

A estatística utiliza modelos matemáticos para deduzir o uso correto dos níveis, sem
aplicar regras linguísticas.
A conexionista também desenvolve modelos genéricos para a linguagem, mas faz
isso utilizando aprendizado estatístico e teorias de representação do conhecimento, po-
dendo transformar, inferir e manipular os textos.
Finalmente, a abordagem híbrida mistura as abordagens anteriores. Flexibiliza e
trata problemas de PLN amplamente e com mais eficácia.

PROCESSAMENTO
A primeira etapa é o pré-processamento. Esta etapa é responsável por concentrar os
dados e moldar a língua, de modo que a máquina possa compreendê -la. Esta etapa é indis-
pensável e é feita com o uso de pré-processamentos textuais.

TOKENIZAÇÃO
Tokenizar significa dividir seu texto em unidades significativas mínimas. É uma etapa
obrigatória antes de qualquer tipo de processamento. Um tokenizer básico (como no NLTK)
divide o texto em frases e suas frases em tokens tipográficos.
Um tokenizador mais elaborado identificará locuções e palavras homogêneas. Os re-
cursos do tokenizador dependerão do que se deseja fazer em seguida.
A maior parte dos trabalhos com a linguagem se baseia primeiro na separação ou na
tokenização de palavras (dividindo o texto em unidades significativas mínimas). As palavras
geralmente são separadas umas das outras por espaços em branco, mas nem sempre esses
espaços são suficientes.
"Nova York" e "rock 'n' roll" são às vezes tratados como palavras grandes, apesar de
conterem espaços, enquanto outras vezes precisamos separar, como no iglês, "I’m" nas duas
palavras "I am".
Para processar tweets ou textos, é necessário tokenizar emoticons como ":)" ou
hashtags como #nlproc. Alguns idiomas, como o chinês, não têm espaços entre as palavras;
portanto, a tokenização de palavras se torna mais difícil.
Existem duas maneiras de tokenização no NLTK, uma é a tokenização de sentenças
(sent_tokenizer) e a outra é a tokenização de palavras (word_tokenizer).
A Figura 384 de-
monstra o funcionamento
de cada uma destas fun-
ções
É importante no-
tar que, na separação por
sentenças, apesar do Figura 380 Processo de tokenização
ponto final na palavra Sr.
a sentença continuou, isso é útil pois evita que a sentença perca sentido.

Página 195
 CURSO MACHINE LEARNING COM PYTHON

REMOÇÃO DE PALAVRAS VAZIAS

Uma palavra vazia, ou como é conhecida stopword, é uma palavra que é removida
antes ou após o processamento de um texto em linguagem natur al. Não existe uma lista uni-
versal de palavras vazias usadas por todas as ferramentas de processamento de linguagem
natural e nem todas ferramentas fazem uso de uma lista dessas palavras.
A remoção de stopwords geralmente consiste em retirar palavras muit o repetidas,
como “a”, “o”, “que” e “de”, porque, no geral, não são relevantes na construção do modelo.
Essas remoções só devem ocorrer quando as stopwords realmente não forem importantes.
Algumas ferramentas, inclusive, evitam remover as chamadas "palavras vazias" para
dar suporte à busca de sentenças.
Remover numerais e os símbolos que os acompanham (por exemplo: “R$”, “US$”,
“km”, “kg”) também é neces-
sário.
A Figura 385 retrata
este processo. É importante
notar que a pontuação tam-
bém foi removida utilizando
ponctuation da biblioteca
string.
Figura 381 Remoção de stopwords e pontuações

STEMIZAÇÃO
O processo de stemização, ou steaming, reduz uma palavra ao seu tronco(stem),
base ou raiz, geralmente uma forma da palavra escrita.
O tronco não precisa ser idêntico à raiz morfológica da palavra; ele geralmente é su-
ficiente que palavras relacionadas sejam mapeadas para o mesmo tronco, mesmo se es te
tronco não for ele próprio uma raiz válida. O estudo de algoritmos para stemização tem sido
realizado em ciência da computação desde a década de 60. Vários motores de buscas tratam
palavras com o mesmo tronco como sinônimos como um tipo de expansão de c onsulta, em
um processo de combinação.
Exemplo:
1. "O jovem está a cavalo"
2. "O jovem estava a cavalo"

A Figura 386 retrata este processo usando duas classes diferente que suportam a lin-
gua Portuguesa.

Página 196
 CURSO MACHINE LEARNING COM PYTHON

Figura 382 Stemização com duas classe suportadas pela lingua Portuguesa

Neste exemplo, a classe RSLPStemmer considerou as 3 palavras de forma idêntica

com o significado associado a python.

PART-OF-SPEECH TAGGING
Part-of-speech tagging (POST), ou
marcação de parte do discurso é o pro-
cesso de marcar uma palavra em um texto
como correspondendo a uma parte especí-
fica de fala, com base em sua definição e
em seu contexto, classificando por exem-
plo, em substantivos, verbos, adjetivos, ad-
vérbios.
Crianças, por exemplo, são acostu-
madas a identificar parte das partes de um
discurso. Por exemplo, ler uma frase e ser Figura 383 Processo de POST
capaz de identificar quais palavras atuam como substantivos, pronomes, verbos, advérbios e
assim por diante. Todos estes são referidos como a partes de um discurso e são classificados
por tags. A Figura 387 faz uso da função pos_tag e demonstra a utilização em uma frase na
língua inglesa.

Página 197
 CURSO MACHINE LEARNING COM PYTHON

Na saída, é possível ver que a palavra recebeu uma tag, ou seja, uma classificação
para o seu tipo. O significado de cada sigla pode ser obtido como na Figura 388.

Figura 384 Significado de cada tag

Para fins de conveniência, a lista abaixo se encontra traduzida para o português:

● CC: conjunção, coordenação
● CD: numeral, cardeal
● DT: determinante
● EX: existencial lá
● FW: palavra estrangeira
● IN: preposição ou conjunção, subordinação
● JJ: adjetivo ou numeral, ordinal
● JJR: adjetivo, comparativo
● JJS: adjetivo, superlativo
● LS: marcador de item da lista
● MD: auxiliar modal
● NN: substantivo, comum, singular ou massa
● PNN: substantivo, próprio, singular
● NNPS: substantivo, apropriado, plural
● NNS: substantivo, comum, plural
● PDT: pré-determinante
● POS: marcador genitivo
● PRP: pronome pessoal
● PRP $: pronome, possessivo
● RB: advérbio
● RBR: advérbio, comparativo
● RBS: advérbio, superlativo
● RP: partícula
● SYM: símbolo
● TO: "to" como preposição ou marcador infinitivo
● UH: interjeição
● VB: verbo, forma base
● VBD: verbo, pretérito

Página 198
 CURSO MACHINE LEARNING COM PYTHON

● VBG: verbo, particípio presente ou gerúndio

● VBN: verbo, particípio passado

Infelizmente a biblioteca NTKL não tem suporte para POST. Entretanto, existe um re-
positório chamado Nltk-Tagger-Portuguese que executa este trabalho.
Para instalar, o primeiro passo é copiar o código disponível em
https://github.com/fmaruki/Nltk-Tagger-Portuguese e executa-lo.

Figura 385 Código presente no repositório

Com esta execução, um arquivo pickle será gerado. Desta forma, é possível fazer a
classificação de frases em português. A Figura 390 demonstra o carregamento do arquivo
(que deve estar no mesmo diretório) e o processo de POST.

Figura 386 Processo de POST utilizando o arquivo gerado

Página 199
 CURSO MACHINE LEARNING COM PYTHON

CHUNKING E CHINKING
Chunks, ou pedaços de linguagem,
são grupos de palavras encontrados com
frequência dentro de uma língua. Esses gru-
pos de palavras possuem sempre uma es-
trutura fixa ou mesmo semifixa.
Chunks são palavras afins (duas ou
mais), usadas em conjunto de forma muito
frequente no idioma. A união dos termos
individuais forma um termo maior com sig-
nificado autônomo.
Alguns destes termos não são apro-
priados para a linguagem formal escrita,
sendo mais verificados na língua falada.
Contudo, não por isso deixam de ter ex-
trema relevância no aprendizado e no per- Figura 387 Processo de Chunk
curso para a fluência do idioma.
Este processo geralmente utiliza expres-
sões regulares como demonstrado na Figura
391.
Chinking são palavras que não podem
fazer parte do chuck. e podem ser removidas na
mesma instrução do regex como observado na
Figura 392.

Figura 388 Processo de Chiking

RECONHECIMENTO DE ENTIDADES MENCIONADAS

O reconhecimento de entidades mencionadas é um ramo do processamento de lin-
guagem natural que procura extrair e classificar as entidades mencionadas em um texto es-
crito em linguagem natural.
A Figura 393 retrata alguns exemplos para a língua portuguesa.

Página 200
 CURSO MACHINE LEARNING COM PYTHON

Figura 389 Reconhecimento de entidades relacionadas

Infelizmente, este processo ainda não está disponível em nenhum módulo de fácil
acesso e que funcione razoavelmente bem para a língua portuguesa. Além disso, encontra
erros que impossibilitam a aplicação real até mesmo em inglês.
A Figura 394 demonstra
o uso simples em uma frase do
inglês.

Figura 390 Reconhecimento de entidades nomeadas

Mesmo
usando uma frase mais
comum poucas pala-
vras são classificadas.

Figura 391 Algoritmo tem dificuldade no reconhecimento

Página 201
 CURSO MACHINE LEARNING COM PYTHON

LEMMATIZING
Lemmatizing, ou Lematização, é o processo de agrupar as formas flexionadas de uma
palavra para que possam ser analisadas como um único item, identificado pelo lema da pala-
vra ou forma de dicionário.
A Figura 396, demonstra, por exemplo a utilização da classe WordNetLemmatizer, é
possível perceber que mudando a palavra o lemma continua sendo o mesmo.

Figura 392 Processo de lematização

Mais uma vez, a língua portuguesa não é suportada na NLTK. Entretanto, existe uma
outra biblioteca que executa este trabalho. Ela se chama spacy. Para instalar basta usar o
pip:
pip install spacy

E fazer o download do pacote de texto da linguagem que se deseja usar, como por
exemplo o pacote português:
python -m spacy download pt_core_news_sm

Desta maneira é possível encontrar os lemmas como visto na

Figura 393 Lematização da palavra "estaremos"

É necessário ter atenção, pois esta biblioteca ainda tem um funcionamento muito ru-
dimentar, como na Figura 399.

Página 202
 CURSO MACHINE LEARNING COM PYTHON

Figura 395 Lematização incorreta da palavra estás

“Estás” não foi

corretamente lematizado
e “Estar” nem mesmo foi
classificado. Além do
mais, letras maiúsculas e
minúsculas interferem no
funcionamento, portanto,
todas as frases devem es-
tar minúsculas como
mostrado na Figura 398. Figura 394 Letras maiúsculas e minúsculas

SUMARIZAÇÃO AUTOMÁTICA DE TEXTO

Para deixar os processos de NPL mais claros, o seguinte projeto tem como objetivo
criar um algoritmo de resumo automático de notícias.
O primeiro passo é obter a notícia, para isso o módulo urllib e o módulo Beautiful-
Soup executam uma garimpagem (web scraping) do site de notícias ig como observado no
Código 69.

Código 69 Obtenção do conteúdo da página

Página 203
 CURSO MACHINE LEARNING COM PYTHON

A div com o id de "notícia" contém o conteúdo da notícia conforme observado na

Figura 396 Id que contém a notícia

O próximo passo é obter todas as pala-

vras e todas as sentenças do texto: (tokeniza-
ção).
Figura 397 Tokenização

Realizar a
remoção de pala-
vras vazias.
Código 70 Remoção de pontuação e stopwords

Na Figura 402, o algoritmo cria uma distribuição de frequência com a função FreqDist
da biblioteca nltk.probability com o intuito de descobrir quais são as mais importantes .

Figura 398 Criação da distribuição de frequência

Agora é necessário separar quais são as sentenças mais importantes do texto. Um

“score” é criado para cada sentença baseado no número de vezes que uma palavra impor-
tante se repete dentro dela.
Um dicionário especial chamado defaultdict da biblioteca collections é usado pois ele
não lança uma exceção quando se pesquisa por uma chave inexistente (KeyError). Ao contrá-
rio, ele adiciona essa chave no dicionário como visto abaixo no Código 71.

Página 204
 CURSO MACHINE LEARNING COM PYTHON

Código 71 Criação do dicionário de scores

Note que o código acima popula o dicionário com o índice da sentença (key) e a
soma da frequência de cada palavra presente na sentença (value).
Pronto! De posse dessas informações, é possível selecionar no dicionário as “n” sen-
tenças mais importantes para formar o resumo.
Para facilitar a funcionalidade nlargest da biblioteca heapq será utilizada como de-
monstra o Código 72.

Código 72 Seleção das sentenças mais importantes

Desta maneira, já é possível visualizar o texto resumido

Figura 399 Visualização do texto resumido

Ainda é possível ajustar o número de sentenças que serão mostradas e obter melho-
res resultados.

Página 205
 CURSO MACHINE LEARNING COM PYTHON

CLASSIFICAÇÃO DE TEXTOS
Uma importante tarefa de NPL é a classificação de textos. Isso pode ser usado para,
por exemplo, marcar emails como spam, descobrir se uma pessoa está sendo bem vista em
uma rede social, marcar comentários desrespeitosos ou indesejados e assim por diante.
Para deixar esta tarefa mais clara, o seguinte projeto demonstra a implementação de
um analisador de sentimentos baseado nas tags #triste e #feliz no twitter. O conjunto de da-
dos usado é gerado usando o seguinte algoritmo, é importante lembrar que ele não foi vali-
dado mecânicamente.

GERAÇÃO DO CONJUNTO
1. Criação da função de autenticação. Os dados das chaves podem ser obtidos em
https://developer.twitter.com:

2. Obtenção dos dados:

3. Função para salvar os arquivos:

Página 206
 CURSO MACHINE LEARNING COM PYTHON

4. Por fim, salvar os arquivos em um csv:

TRATAMENTO NPL
Com o conjunto de da-
dos gerado, é hora de traba-
lhar com ele. Para isso, o pri-
meiro passo é importá-lo.

Figura 400 Abertura do arquivo com a pandas

É necessário embaralhar as mensa-

gens.
As próximas etapas estão ligadas
diretamente ao processo de processa-
Código 73 Embaralhamento dos dados
mento. O primeiro passo é fazer os im-
ports necessários como demonstrado no
Código 74.

Código 74 Dependências

Página 207
 CURSO MACHINE LEARNING COM PYTHON

O próximo passo é criar as funções de cada etapa:

1. Tokenização:

2. Remoção de stopwords:

3. Steamização:

4. Chunk e Chink:

5. Lematização:

Página 208
 CURSO MACHINE LEARNING COM PYTHON

Com todas estas funções, torna-se possível criar uma função que irá executar todas
estas tarefas e retornar o texto final.

Código 75 União dos processos (o processo de lematização não será usado)

Como é possível observar, o processo de lematização não foi aplicado devido à apli-
cação de Steaming aplicado anteriormente.
É necessário aplicar a função na coluna “tweets” como na

Figura 401 Aplicação dos processos

Como com dados brutos, uma sequência de símbolos não pode ser alimentada dire-
tamente nos próprios algoritmos, pois a maioria deles espera vetores de recursos numéricos
com tamanho fixo, em vez de documentos de texto bruto com comprimento variável.
Para resolver este impasse é necessário converter o tipo da classe (de texto para nú-
meros). Para fazer isso com o objetivo (feliz, triste) basta usar o Código 76.

Código 76 Conversão dos rótulos para dados numéricos

Neste passo, é impor-

tante separar um conjunto de
testes para validação posterior.
Código 77 Separação do conjunto de treino e testes

Página 209
 CURSO MACHINE LEARNING COM PYTHON

Para transformar os tweets em dados numéricos é necessário aplicar uma técnica

chamada Vetorização. A vetorização faz com que cada palavra contida nos dados se torne
uma coluna e cada linha contenha um tweet mostrando o número de ocorrências desta pala-
vra.
Este processo é facilmente aplicado utilizando a classe CountVectorizer do scikit le-
arn como visto no Código 78.

Código 78 Processo de Vetorização

Um trecho da matriz gerada pode ser visualizado na

Figura 402 Algumas colunas fltradas da matriz de frequências

O processo de processamento está completo. Neste ponto é possível usar um classi-

ficador para testar novos registros. O algoritmo abaixo implementa uma classificação Navie
Bayes Multinomial.

Código 79 Treino do modelo

Página 210
 CURSO MACHINE LEARNING COM PYTHON

É possível, desta forma, analisar a precisão.

Figura 403 Teste de precisão com o conjunto de testes

Incrivelmente, apenas com os parâmetros padrão o modelo já alcançou 97,5% de

acerto. Outros algoritmos classificadores e até um siste ma de votação podem ser aplicados
conforme for necessário.
Para mais detalhes sobre esta implementação, o seguinte link possui outra imple-
mentação para a classificação de spam em mensagens de texto https://www.ritchi-
eng.com/machine-learning-multinomial-naive-bayes-vectorization/.

OBTENÇÃO DE CONJUNTOS DE DADOS

Conjunto de dados em português são muito difíceis de ser encontrados. Os seguinte
repositório contém alguns locais para obtenção de dados para PLN em português https://li-
onbridge.ai/datasets/best-portuguese-language-datasets-for-machine-learning/

Página 211
 CURSO MACHINE LEARNING COM PYTHON

CAPÍTULO 10
Aprendizado não supervisionado
Os modelos preditivos geralmente exigem o treinamento dos dados "rotulados", ou
seja, os dados têm alguma variável de destino já preenchida. Obviamente, o objetivo é usar
o modelo em dados invisíveis onde não se conhece o valor da variável de destino, mas sem
dados de treinamento rotulados adequadamente, não há como validar um modelo. Por esse
motivo, a produção de dados geralmente é a parte mais difícil de um projeto de ciência de
dados. Digamos, por exemplo, que se queira ensinar um computador a ler caligrafia. Não
basta coletar centenas de páginas de palavras escritas e digitalizá -las. Também é necessário
rotular esses dados para ter uma "leitura correta" para cada palavra. Com algo tão compli-
cado quanto a caligrafia, pode-se precisar de centenas de milhares de exemplos de treina-
mento e rotulagem manual, pois muitas entradas serão trabalhosas.
Talvez se encontrar um conjunto de dados sem uma variável de destino rotulada, há
uma maneira de obter algumas informações sobre ele sem passar pelo trabalho de rotulá-lo.
Talvez simplesmente não se tenha tempo ou recursos para rotular os dados ou talvez não
exista uma variável de destino clara para prever, ainda existe uma maneira de usar os da-
dos? Este é o mundo do "aprendizado não supervisionado".
Um dos objetivos mais comuns do aprendizado não supervisionado é agrupar os da-
dos, encontrar agrupamentos razoáveis em que os pontos de cada grupo pareçam mais se-
melhantes entre si do que os dos outros grupos. Dois dos métodos mais comuns de agrupa-
mento são o agrupamento K-means e o agrupamento aglomerativo.

K-MEANS
Ao ver a Figura 408 é possível observar a divisão de
dados em três principais grupos. Visualmente, é fácil ver os
clusters, mas como fazer com que o computador descubra
os clusters por conta própria? A primeira estratégia que
pode ser usada é o k-means. Na estratégia k-means, pri-
meiro é especificado quantos clusters se procura, neste
caso 3, e o computador começa colocando muitos novos
pontos aleatoriamente, chamados de centroides, como ob-
servado na Figura 409.
Esses novos
Figura 404 Alguns dados hipotéticos
pontos serão o centro
dos clusters. Por que
colocá-los aleatoriamente? Bem, não há realmente uma
maneira de o computador informar antecipadamente
onde seria um local sensato para colocar os centros de
cluster, então a estratégia é colocá-los aleatoriamente e
movê-los passo a
Figura 405 Inserção inicial de centroides

Página 212
 CURSO MACHINE LEARNING COM PYTHON

passo para melhorar o cluster.

Para decidir como mover os centroi-
des, primeiro atribui-se cada um dos seus pon-
tos ao centroide mais próximo como obser-
vado na Figura 410.
Pode-se observar que os centroides
vermelhos e verdes estão próximos um do ou-
tro e em direção à borda dos dados, isso não
parece fazer muito sentido além de que o clus-
ter vermelho tem apenas dois pontos.
Então, é necessário mover esses cen-
troides para um lugar mais central. Cada cen-
Figura 406 Separação de grupos por centroide troide é movido para o centro do cluster, que
é o local médio dentro do cluster. Depois de
movidos, os centroides, atribui-se novamente os
pontos ao centroide mais próximo. Na Figura
411 é possível ver como são as novas atribuições
em uma etapa do processo.
É necessário repetir esse processo, mo-
vendo os centroides passo a passo e reatribu-
indo os pontos aos agrupamentos associados,
até que um conjunto estável de centros que dei-
xaram de se mover seja encontrado.

Figura 407 Segunda etapa do processo

Nesse caso, esse equilíbrio é

observado na Figura 412.

Figura 408 Processo final de cauterização K-means

Página 213
 CURSO MACHINE LEARNING COM PYTHON

O movimento dos próprios centroides pode ser

observado na Figura 413.
Nesse caso, o algoritmo de cluster acaba des-
cobrindo essencialmente os grupos que foram criados.
No entanto, lembre-se de que, sendo este um pro-
blema de aprendizado não supervisionado, o algoritmo
não pode validar esses grupos de nenhuma maneira.
Os agrupamentos foram feitos sem nenhuma
referência à qual classe os pontos pertenciam, apenas
sua posição e, de qualquer forma, o computador não
Figura 409 Movimento dos centroides seria capaz de dizer o que esses agrupamentos repre-
sentavam.
Se quisesse uma interpretação dos clusters, uma pessoa precisaria olhar para os gru-
pos e pensar sobre eles, e não há garantia de que alguém pudesse ver imediatamente quais
recursos tipificaram os clusters que foram cria-
dos - especialmente se houver mais de duas
variáveis de recurso dificultando a visualização
dos dados.
Outro desafio é que os agrupamentos
que são criados dependem de onde os centroi-
des iniciais pousam e também de quantos exis-
tem, e, novamente, pode não ter como validar
se o agrupamento encontrado é o melhor pos-
sível ou se possui um número apropriado de
clusters.
Considere, por exemplo, a Figura 414
que também possui três clusters, mas os cen-
troides começam em lugares diferentes. Os
Figura 410 Mesmo conjunto de dados
clusters vermelho e verde acabam migrando com pontos iniciais diferentes
para a bolha no canto superior direito, divi-
dindo-a entre si, deixando o centroide azul sozinho com dois terços dos dados. O algoritmo
k-means não tem como saber se esse conjunto de clus-
ters faz mais ou menos sentido do que o primeiro que
encontramos.
Da mesma forma, é necessário especificar em
quantos clusters deve-se agrupar os dados, é possível
escolher qualquer número. A Figura 415 contém outro
agrupamento com 5 clusters em vez de 3.
Em alguns casos, pode-se ter um motivo especí-
fico para escolher um número específico de grupos - tal-
vez se esteja dividindo os casos de suporte ao cliente
Figura 411 Clusterização com 5 grupos entre um certo número de funcionários de suporte, para
que se queira apenas tantos agrupamentos quanto os
Página 214
 CURSO MACHINE LEARNING COM PYTHON

membros da equipe - mas geralmente um dos desafios dos não supervisionados é decidir o
número de clusters.
A biblioteca Scikit Learn implementa um algoritmo de K-means. Para demonstrar o
funcionamento, o conjunto dado Wholesale que contém os dados de gastos anuais em USD
de clientes de um atacadista em 5 categorias de produtos será usado.

Figura 412 Importação do conjunto de dados Wholesale

A base também continha informação de canal e região, mas é excluída pois não serão
úteis para nosso estudo.
Como pode-se observar, o conjunto possuí 440 observações (o que é bem pouco mas
serve para o exemplo), os dados tem um desvio padrão consideravelmente alto ( pode-se
usar o método describe para observar isso). Isso quer dizer que os dados tem uma variedade
muito grande.
Seria útil, por exemplo, fazer alguma campanha de marketing com base nesses da-
dos. Entretanto, com eles nesta forma crua, ela não será tão efetiva pois é um grupo com
perfis de gasto muito diferentes. Seria melhor se grupos menores com clien tes com gastos
mais parecidos fossem mapeados para tornar a campanha ser mais efetiva, certo.
Para agrupar
estes clientes a classe
KMeans será usada
como observado no
Código 80.

Código 80 Implementação de um algoritmo KMeans

Página 215
 CURSO MACHINE LEARNING COM PYTHON

O resultado pode ser plotado usando o Código 81.

Código 81 Plotagem dos dados

O resultado final pode ser observado na Figura 417.

Figura 413 Clientes separados em clusters

As seguintes contatações podem ser tomadas:

• cluster 0, parece ser os clientes que gastam pouco, distribuído ali entre todos os pro-
dutos
• cluster 1, também não gastam tanto, porém os gastos são focados em groceries
• cluster 2, já são os clientes que tem um dispêndio maior e são bem focados em ali-
mentos frescos
• cluster 3, também são os clientes focados em alimentos frescos, porém com um
gasto total menor
• cluster 4, são os clientes que gastam mais, porém focados em groceries

Página 216
 CURSO MACHINE LEARNING COM PYTHON

Então basicamente, o que o algoritmo fez de maneira automática e sem eu ter que
dar nenhuma instrução explícita, foi identificar clientes com comportamentos similares, apa-
rentemente baseado em dispêndio total e foco em produtos frescos ou groceries. Desta ma-
neira, se ao fazer uma ação especial com os clientes que gastam mais em alimentos frescos,
sabe-se exatamente quem eles são. Ou, ao tentar aumentar os gastos no ticket médio, tam-
bém sabe quem são os que gastam pouco e no que eles gastam para direcionar o esforço.

Página 217
 CURSO MACHINE LEARNING COM PYTHON

CAPÍTULO 11
Deep Learning
Um subgrupo específico de técnicas de
Machine Learning é conhecido como Deep Lear-
ning (DL). Geralmente utilizam redes neurais
profundas e dependem de muitos dados para o
treinamento.
Existem muitos fatores que as diferen-
ciam das técnicas clássicas de machine learning,
e alguns desses fatores favorecem a utilização
dessas técnicas em áreas como visão computa-
cional e processamento de linguagem natural.
Existem alguns pontos importantes que diferem
as técnicas clássicas de ML dos métodos de DL,
os principais são: Figura 414 Enquadra-
mento de cada subgrupo em IA
• A necessidade e o efeito de muitos dados
• Poder computacional
• Flexibilidade na modelagem dos problemas.
Embora os dados sejam o “combustível” das técnicas de ML, existem dois problemas que
afligem as técnicas clássicas com relação aos dados, a “maldição da dimensionalidade” e a
estagnação da performance ao adicionar mais dados após um certo limite.
Uma analogia é a melhor forma de explicar a “maldição da dimensionalidade”, até por-
que o ser humano sofre do mesmo mau.
Pense, por exemplo, que se está querendo comprar um carro, e o objetivo é escolher
um carro com melhor custo benefício. Inicialmente pode-se escolher o carro pelo ano e
preço, uma tarefa considerada bem simples para escolher o melhor carro.
Agora, em outra situação, imagine escolher o carro baseado no ano, preço, marca,
modelo, cor, acessórios, estofado, tamanho do tanque… etc. São tantas características, ou
seja, tantas informações sobre o problema que uma pessoa acabaria se prendendo aos deta-
lhes e perdendo o foco principal.
É isso que acontece com a maioria das técnicas clássicas ao adicionar dimensionali-
dade ao problema. Existe, inclusive, uma área de pesquisa focada apenas na redução de di-
mensionalidade (PCA) para minimizar esse pro-
blema.
Outra questão, é que as técnicas clássicas
chegam a um ponto de saturação com relação a
quantidade de dados, ou seja, chegam no limite má-
ximo que conseguem extrair de informação dos
dados. Figura 415 Performance vs Quantidade de dados

Página 218
 CURSO MACHINE LEARNING COM PYTHON

O mesmo não acontece facilmente com DL, que são preparadas para tr abalhar com
uma maior quantidade de dados. Esses dois problemas dos algoritmos clássicos de ML refor-
çam um dos principais benefícios do uso de DL, que é: Quanto mais dados, melhor.

ALGUMAS APLICAÇÕES
As aplicações são tão diversas que chega a ser difícil separar as “mais importantes”.
Embora DL seja um técnica de propósito geral, as áreas que mais se beneficiaram são:
• Visão computacional. Como reconhecimento de objetos, segmentação semântica,
descrição de cenário, etc. A aplicação mais direta disso tudo em conjunto são os car-
ros autônomos.
• Reconhecimento da fala e NLP. É notável a melhoria nos assistentes pessoais como
Cortana, Siri e Google Now nos últimos anos. E isso graças ao uso do DL.
• Healthcare. Um capítulo à parte nos avanços alcançados com DL foi na área da sa-
úde, especificamente no diagnóstico por imagens.
Como DL é um grupo de métodos de propósito geral, qualquer problema clássico de
Machine Learning pode ser resolvido com DL como por exemplo:
• Sistemas de Recomendação, filmes, livros e músicas baseadas em comportamento. A
Netflix, Amazon e o Spotify utilizam bastante em suas plataformas.
• Detecção de fraudes, muito comum nas Fintech como Nubank.
• Análise de sentimento em vídeo, texto ou imagem. Muito utilizado para monitora-
mento de marca em redes sociais.

INTRODUÇÃO ÀS REDES NEURAIS ARTIFICIAIS

Para entender como esta técnica funciona o jeito mais fácil é fazer um paralelo com
a biologia, pois, historicamente os estudos foram concebidos desta maneira. Os pássaros,
por exemplo, nos inspiraram a voar, as plantas de bardana inspiraram o velcro, e a natureza
inspirou muitas outras invenções, desta forma, parece lógico olhar para a arquitetura do cé-
rebro em busca de inspiração sobre como construir uma máquina inteligente. Essa é a idéia
principal que inspirou as redes neurais artificiais (RNAs).
No entanto, embora os aviões tenham sido inspirados por pássaros, eles não preci-
sam bater as asas. Da mesma forma, as RNAs gradualmente se tornaram bastante diferentes
de seus primos biológicos. Alguns pesquisadores chegam a argumentar que devemos aban-
donar completamente a analogia biológica, para não restringir a criatividade à sistemas bio-
logicamente plausíveis.

DOS NEURÔNIOS BIOLÓGICOS AOS ARTIFICIAIS

Surpreendentemente, as RNAs existem há bastante tempo: foram i ntroduzidas pela
primeira vez em 1943 pelo neurofisiologista Warren McCulloch e pelo matemático Walter
Pitts. Em seu artigo de referência, “A Logical Calculus of Ideas Immanent in Nervous Acti-
vity”, McCulloch e Pitts apresentaram um modelo computacional simplificado de como os
neurônios biológicos podem trabalhar juntos em cérebros de animais para realizar cálculos

Página 219
 CURSO MACHINE LEARNING COM PYTHON

complexos usando lógica proposicional. Essa foi a primeira arquitetura de rede neural artifi-
cial. Desde então, muitas outras arquiteturas foram inventadas, como veremos.
Os sucessos iniciais das RNAs até a década de 1960 levaram à crença generalizada de
que em breve estaríamos conversando com máquinas verdadeiramente inteligentes. Quando
ficou claro que essa promessa não seria cumprida (pelo menos por um bom tempo), os in-
vestimentos voaram para outros lugares e as RNAs entraram em uma longa era sombria (In-
verno das IA).
No início dos anos 80, houve um renascimento do interesse pelas RNAs, à medida
que novas arquiteturas de rede foram inventadas e melhores técnicas de treinamento foram
desenvolvidas. Mas na década de 1990, poderosas técnicas alternativas de aprendizado de
máquina alternativas, como o SVM, foram favorecidas pela maioria dos pesquisadores, pois
pareciam oferecer melhores resultados e fundamentos teóricos mais fortes.
Finalmente, agora estamos testemunhando mais uma onda de interesse nas RNAs.
Diferente das anteriores, existem algumas boas razões para acreditar que essa não irá desa-
parecer tão cedo e terá um impacto muito mais profundo em nossas vidas:
• Atualmente, existe uma enorme quantidade de dados disponíveis para treinar redes
neurais, e as RNAs frequentemente superam outras técnicas de ML em problemas
muito grandes e complexos.
• O tremendo aumento no poder da computação desde os anos 90 agora possibilita o
treinamento de grandes redes neurais em um período de tempo razoável. Isso se
deve em parte à lei de Moore, mas também graças à indústria de jogos, que produziu
milhões de placas de GPU poderosas.
• Os algoritmos de treinamento foram aprimorados. Para ser justo, eles são apenas li-
geiramente diferentes dos usados nos anos 90, mas esses ajustes relativamente pe-
quenos têm um enorme impacto positivo.
• Algumas limitações teóricas das RNAs se mostraram benignas na prática. Por exem-
plo, muitas pessoas pensaram que os algoritmos de treinamento da RNA estavam
condenados porque provavelmente ficariam presos aos ótimos locais, mas acontece
que isso é bastante raro na prática (ou quando é o caso, eles geralmente estão muito
próximos do ótimo global).
• As RNA parecem ter entrado em um círculo virtuoso de financiamento e progresso.
Os produtos surpreendentes baseados em RNAs fazem regularmente as manchetes,
o que atrai cada vez mais atenção e financiamento para eles, resultando em cada vez
mais progresso e produtos ainda mais surpreendentes.

NEURÔNIOS BIOLÓGICOS
Antes de discutirmos os neurônios artificiais, vamos dar uma olhada rápida em um
neurônio biológico. É uma célula de aparência incomum, encontrada principalmente no cór-
tex cerebral, composta de um corpo celular que contém o núcleo e a maioria dos componen-
tes complexos da célula, além de muitas extensões ramificadas chamadas dendritos, além de
uma extensão muito longa chamada de axônio.
O comprimento do axônio pode ser apenas algumas vezes maior que o corpo da cé-
lula ou até dezenas de milhares de vezes mais . Perto de sua extremidade, o axônio se divide

Página 220
 CURSO MACHINE LEARNING COM PYTHON

em muitos ramos chamados telodendria, e na ponta desses ramos existem estruturas minús-
culas chamadas terminais sinápticos (ou simplesmente sinapses), que são conectadas aos
dendritos (ou diretamente ao corpo celular) de outros neurônios.
Neurônios biológicos recebem
impulsos elétricos curtos chamados
sinais de outros neurônios por meio
dessas sinapses. Quando um neurônio
recebe um número suficiente de si-
nais de outros neurônios dentro de
alguns milissegundos, ele dispara seus
próprios sinais.
Assim, os neurônios biológi-
cos individuais parecem se comportar
de uma maneira bastante simples, Figura 416 Neurônio biológico
mas estão organizados em uma vasta
rede de bilhões de neurônios, cada neurônio normalmente conectado a milhares de outros
neurônios. Cálculos altamente complexos podem ser realizados por uma vasta rede de neu-
rônios bastante simples, assim como um formigueiro complexo pode emergir dos esforços
combinados de formigas simples.
A arquitetura das redes neurais biológicas (BNN) ainda é objeto de pesquisa ativa,
mas algumas partes do cérebro foram mapeadas, e parece que os neurônios são frequente-
mente organizados em camadas consecutivas.

Figura 417 Rede biológica de neurônios multicamada (córtex humano)

COMPUTAÇÕES LÓGICAS COM NEURÔNIOS

Warren McCulloch e Walter Pitts propuseram um modelo muito simples do neurônio
biológico, que mais tarde ficou conhecido como neurônio artificial: ele possui uma ou m ais
entradas binárias (on/off) e uma saída binária.
O neurônio artificial simplesmente ativa sua saída quando mais de um determinado
número de entradas está ativo. McCulloch e Pitts mostraram que, mesmo com um modelo
tão simplificado, é possível construir uma rede de neurônios artificiais que calcula qualquer
proposição lógica que se deseja.

Página 221
 CURSO MACHINE LEARNING COM PYTHON

Por exemplo, para construir algumas RNAs que executam vários cálculos lógicos, um
neurônio é ativado quando pelo menos duas de suas entradas estiverem ativas.

Figura 418 Operações lógicas com RNA's

• A primeira rede à esquerda é simplesmente a função de identidade: se o neurônio A

estiver ativado, o neurônio C também será ativado (uma vez que recebe dois sinais
de entrada do neurônio A), mas se o neurônio A estiver desativado, o neurônio C es-
tará desativado como bem.
• A segunda rede executa um AND lógico: o neurônio C é ativado apenas quando os
neurônios A e B são ativados (um único sinal de entrada não é suficiente para ativar
o neurônio C).
• A terceira rede executa um OR lógico: o neurônio C é ativado se o neurônio A ou o
neurônio B estiver ativado (ou ambos).
• Finalmente, se supusermos que uma conexão de entrada possa inibir a atividade do
neurônio (que é o caso dos neurônios biológicos), a quarta rede calcula uma proposi-
ção lógica um pouco mais complexa: o neurônio C é ativado apenas se o neurônio A
estiver ativo e se o neurônio B está fora. Se o neurônio A estiver ativo o tempo todo,
você receberá um NOT lógico: o neurônio C estará ativo quando o neurônio B estiver
desativado e vice-versa.
Você pode imaginar facilmente como essas redes podem ser combinadas para calcular
expressões lógicas complexas.

O PERCEPTRON
O Perceptron é uma das arquiteturas mais simples da RNA, inventada em 1957 por
Frank Rosenblatt. Ele é baseado em um neurônio artificial ligeiramente diferente (veja a Fi-
gura 423), chamado de unidade de limiar linear (LTU).
Nele, as entradas e saídas agora são números (em vez de valores binários de ligado /
desligado) e cada conexão de entrada está associada a um peso.
A LTU calcula uma soma ponderada de
suas entradas, depois aplica uma função de ativa-
ção a essa soma e gera o resultado.
Uma única LTU pode ser usada para classi-
ficação binária linear simples. Ele calcula uma
combinação linear das entradas e, se o resultado
Figura 419 Neurônio Perceptron

Página 222
 CURSO MACHINE LEARNING COM PYTHON

exceder um limite, gera a classe positiva ou gera a classe neg ativa (como um classificador de
regressão logística ou um SVM linear).
Um Perceptron é simplesmente composto de uma única camada de LTU, com cada
neurônio conectado a todas as entradas. Essas conexões são frequentemente representadas
usando neurônios de passagem especiais chamados neurônios de entrada pois eles apenas
emitem qualquer entrada que são alimentados. Além disso, geralmente é adicionado um re-
curso de polarização extra (x0 = 1).
Esse recurso de polarização é normalmente representado usando um ti po especial de
neurônio chamado neurônio de polarização, que gera apenas 1 o tempo todo.
Um Perceptron com duas entradas e três saídas é representado na Figura 424. Esse
Perceptron pode classificar instâncias simultaneamente em três classes binárias diferentes, o
que o torna um classificador de saída múltipla

Figura 420 Perceptron de múltiplas saídas

Se as instâncias de treinamento forem linearmente separáveis, Rosenblatt demons-

trou que esse algoritmo converge para uma solução. Isso é conhecido como teorema da con-
vergência de Perceptron.
Para tornar isso mais claro, imagine as entradas e saídas da função AND como obser-
vado na Tabela 12.
Tabela 12 Entradas e Saídas porta AND

X1 X2 Saída

0 0 0

0 1 0

1 0 0

1 1 1

Afunção de ativação que será usada é muito seme-

lhante a função Heaviside, com a leve diferença de atuar no
limiar de 1. Ela é descrita na Equação 19
Equação 19 Função Heaviside deslocada

Página 223
 CURSO MACHINE LEARNING COM PYTHON

A Figura 425 demonstra a representação gráfica da rede neste exemplo.

Figura 421 Rede neural com duas entradas (X1 e X2), pesos (p1 e p2) uma função de soma e a
função de ativação

Definindo, inicialmente os pesos em 0, a

primeira entrada pode ser analisada na Figura
426. O resultado final foi obtido conforme espe-
rado.
As entradas 2 e 3 pode ser observada na
Figura 427 também atingindo o objetivo.

Figura 422 Primeira entrada

Figura 423 Entradas 2 e 3

Entretanto, ao chegar na entrada 4, como demons-

trado na Figura 428, a saída predita está incorreta. Desta
forma, este modelo atinge 75% de precisão e precisa de al-
guma forma de ajuste nos pesos para atingir 100% de preci-
são.

Figura 424 Entrada 4

Página 224
 CURSO MACHINE LEARNING COM PYTHON

Então, como um Perceptron é treinado? Bem, treinar uma rede destas consiste em
encontrar os valores certos para cada um dos pesos. O algoritmo de treinamento Perceptron
proposto por Frank Rosenblatt foi amplamente inspirado pela regra de Hebb.
Esta regra pode ser resumida em “não reforçar as conexões que levam à saída er-
rada”. Mais especificamente, o Perceptron é alimentado com uma instância de treinamento
e, para cada instância, faz suas previsões.
Para cada neurônio de saída que produziu uma previsão incorreta, ele reforça os pe-
sos de conexão das entradas que teriam contribuído para a previsão correta. A regra é mos-
trada na Equação 20.
peso(x + 1) = peso(x) + taxa_aprendizagem ∗ entrada ∗ erro
Equação 20 Regra de treino de um Perceptron

Tomando o exemplo da entrada 4 (figura x) e definindo uma taxa de aprendizado de

0.1 é possível calcular o peso:
p1 = 0 + (0.1*1*1) = 0.1
Repetindo o mesmo processo anterior, com os pesos iguais a 0.5 (conversão do peso
após algumas tentativas) o resultado da Figura 429 é obtido. É possível observar que quando
o resultado está em 0.5 a função de Heaviside fez com que o resultado final se mantivesse
em 0. Desta maneira, as saídas atingiram a precisão de 100%.

Figura 425 Saídas utilizando pesos de 0.5

Para um exemplo um pouco mais prático pode-se, por exemplo, usar uma única LTU
para classificar as flores da íris com base no comprimento e largura da pétala (adicionando
também um recurso de polarização extra x0 = 1).
O Scikit-Learn fornece uma
classe Perceptron que im-
plementa uma única rede
LTU). O Código 82 de-
monstra seu uso.
Você pode ter re-
conhecido que o algoritmo
de aprendizado Percep-
tron se parece muito com Código 82 Perceptron com scikit
a descida estocástica do
gradiente. De fato, a classe Perceptron do Scikit-Learn é equivalente a usar um SGDClassifier
com os seguintes hiperparâmetros: loss = "perceptron", learning_rate = "constant", eta0 = 1
(taxa de aprendizado) e penalidade = Nenhuma (sem regularização).

Página 225
 CURSO MACHINE LEARNING COM PYTHON

Observe que, ao contrário dos classificadores de regressão logística, os Perceptrons

não produzem uma probabilidade de classe, em vez disso, eles apenas fazem previsões com
base em um limite rígido. Essa é uma das boas razões para preferir a regressão logística do
que os Perceptrons.
Na monografia de 1969 intitulada Perceptrons, Marvin Minsky e Seymour Papert
destacaram uma série de deficiências sérias dos Perceptrons, em particular o fato de s erem
incapazes de resolver alguns problemas triviais (por exemplo, o problema de classificação
XOR.
É claro que isso também se aplica a qualquer outro modelo de classificação linear
(como os classificadores de Regressão Logística), mas os pesquisadores esp eravam muito
mais da Perceptrons, e sua decepção foi grande. Como resultado, muitos pesquisadores
abandonaram completamente o conexionismo (ou seja, o estudo redes neurais) em favor de
problemas de nível superior, como lógica, resolução de problemas e pesq uisa.
No entanto, verifica-se que algumas das limitações do Perceptrons podem ser elimi-
nadas empilhando vários Perceptrons. A RNA resultante é chamada de Perceptron de várias
camadas (MLP).
Em particular, um MLP pode resolver o
problema XOR, como você pode verificar calcu-
lando a saída do MLP representado à direita da
Figura 10-6, para cada combinação de entradas:
com entradas (0, 0) ou (1, 1 ) a rede emite 0 e,
com as entradas (0, 1) ou (1, 0), emite 1.

Figura 426 Classificação XOR com multicamadas

PERCEPTRON MULTICAMADA E RETROPROPAGAÇÃO

Um MLP é composto de uma camada de entrada (passagem), uma ou mais camadas
de LTUs, chamadas camadas ocultas, e uma camada final de LTUs, chamada camada de saída
(veja a Figura 10-7).
Cada camada,
exceto a camada de
saída, inclui um neurô-
nio de polarização e
está totalmente conec-
tada à próxima ca-
mada. Quando uma
RNA tem duas ou mais
camadas ocultas, é cha- Figura 427 Diferença entre uma rede Neural comum e uma rede neural pro-
mada de rede neural funda (Deep)

profunda (RNP ou DNN do inglês Deep Neural Network) como observado na Figura 431.

Página 226
 CURSO MACHINE LEARNING COM PYTHON

Por muitos anos, os pesquisadores lutaram para encontrar uma maneira de treinar
MLPs, sem sucesso. Mas em 1986, David E. Rumelhart publicou um artigo inovador introdu-
zindo o algoritmo de treinamento de retropropagação.
Em resumo, para cada instância de treinamento, o algoritmo de retropropagação pri-
meiro faz uma previsão (passagem direta), mede o erro e depois passa por cada camada no
sentido inverso para medir a contribuição do erro de cada conexão (passagem reversa) e, fi-
nalmente, ligeiramente os pesos da conexão para reduzir o erro (etapa de descida do gradi-
ente).
O algoritmo de retropropagação pode ser usado com outras funções de ativação, em
vez da função logística ou a função step.
Duas outras funções de ativação populares são:
• A função tangente hiperbólica que, assim como a função logística, tem a forma de S,
contínua e diferenciável, mas seu valor de saída varia de –1 a 1 (em vez de 0 a 1 no
caso da função logística), que tende a tornar a saída de cada camada mais ou menos
normalizada (ou seja, centralizada em torno de 0) no início do treinamento. Isso ge-
ralmente ajuda a acelerar a convergência
• A função ReLU que funciona muito bem e tem a vantagem de ser rápida de calcular.
Mais importante, o fato de ela não ter um valor máximo de saída também ajuda a re-
duzir alguns problemas durante a descida do gradiente.
Um MLP é frequentemente usado para classifi-
cação, com cada saída correspondendo a uma
classe binária diferente. Quando as classes são ex-
clusivas (por exemplo, classes 0 a 9 para classifica-
ção de imagem com dígitos), a camada de saída é
tipicamente modificada substituindo as funções de
ativação individuais por uma função comparti-
lhada softmax (consulte a Figura 432).
A saída de cada neurônio corresponde à pro-
babilidade estimada da classe correspondente. Figura 428 Rede de múltiplas camadas e múl-
tiplas saídas
Observe que o sinal flui apenas em uma direção
(das entradas às saídas); portanto, essa arquite-
tura é um exemplo de rede neural feedforward (FNN).
Os neurônios biológicos parecem implementar uma função de ativação mais ou me-
nos sigmóide (em forma de S), portanto, os pesquisadores mantêm suas funções sigmóides
por muito tempo. Mas acontece que a função de ativação ReLU geralmente funciona melhor
em RNAs. Este é um dos casos em que a analogia biológica era enganosa.

Página 227
 CURSO MACHINE LEARNING COM PYTHON

Existem inúmeras arquiteturas diferentes com propósitos diferentes, seu funciona-

mento também depende da estrutura, mas de forma geral, todas são baseadas nas redes
neurais. Na Figura 433 estão demonstrados alguns exemplos.

Figura 429 Exemplos comuns de arquiteturas de rede Deep Learning

Essa liberdade de arquitetura possibilita que Deep Learning resolva inúmeros proble-
mas, e seja na verdade como uma caixa de peças lego, só esperando ser montada e desmon-
tada para construir coisas novas.

Figura 430 Linha do tempo das descobertas

Página 228
 CURSO MACHINE LEARNING COM PYTHON

TENSORFLOW, KERAS E PYTORCH

Para aplicações mais avançadas de DL a biblioteca scikit learn não dá suporte, no en-
tanto, pode-se criar canais profundos de algoritmos de aprendizado. Por exemplo, pode-se
executar a seleção de recursos, clustering, transformação de cada amostra em um vetor de
distâncias dos clusters e executar a classificação nessa representação alternativa. Esse tipo
de composição "profunda" dos algoritmos de aprend izagem difere das redes neurais, pois as
camadas são treinadas sequencialmente (e não simultaneamente), mas em alguns casos po-
dem competir com o treinamento de ponta a ponta.
Como este processo é complicado e não é comunmente utilizado, é muito mais inte-
ressante a utilização de ferramentas que possíbilitem a construção de algoritmos
P sendo necessário o uso de outras ferramentas.
Para estas aplicações três ferramentas principais são utilizadas:
• Pythorch: O PyTorch é uma biblioteca de aprendizado de máquina de código aberto
para Python, baseada no Torch. É usado para aplicativos como processamento de lin-
guagem natural e foi desenvolvido pelo grupo de pesquisa de IA do Facebook.
• Tensorflow: O TensorFlow é uma biblioteca de software de código aberto para pro-
gramação de fluxo de dados em uma variedade de tarefas. É uma biblioteca matemá-
tica simbólica usada para aplicativos de aprendizado de máquina como redes neu-
rais.
• Keras: Keras é uma biblioteca de rede neural de código aberto escrita em Python. É
capaz de rodar sobre o TensorFlow. Ele foi projetado para permitir experimentação
rápida com redes neurais profundas.

Figura 431 Logo das ferramentas

Para decidir qual delas utilizar, pode-se avaliar ambas nos seguintes tópicos:
• Nível da API
• Rapidez
• Arquitetura
• Depuração
• Conjunto de dados
• Popularidade

Página 229
 CURSO MACHINE LEARNING COM PYTHON

NÍVEL DA API
O Keras é uma API de alto nível capaz de executar sobre TensorFlow, CNTK e Theano.
Ele ganhou destaque por sua facilidade de uso e simplicidade sintática, facilitando o desen-
volvimento rápido.
O TensorFlow é uma estrutura que fornece APIs de alto e baixo nível.
Pytorch, por outro lado, é uma API de baixo nível focada no trabalho direto com ex-
pressões de matriz. Ele ganhou imenso interesse no ano passado, tornando -se uma solução
preferida para pesquisa acadêmica e aplicações de aprendizado profundo que exigem a oti-
mização de expressões personalizadas.
RAPIDEZ
O desempenho é comparativamente mais lento em Keras, enquanto o Tensorflow e o
PyTorch fornecem um ritmo semelhante, rápido e adequado para alto desempenho.
ARQUITETURA
Keras tem uma arquitetura simples pois é mais legível e conciso. O tensorflow, por
outro lado, não é muito fácil de usar, apesar de fornecer o Keras como uma estrutura que
facilita o trabalho.
O PyTorch possui uma arquitetura complexa e a legibilidade é menor quando compa-
rada ao Keras.
DEPURAÇÃO
No keras, geralmente há uma necessidade muito menos frequente de depurar redes
simples. Mas no caso do Tensorflow, é bastante difícil executar a depuração. Por outro lado,
o Pytorch possui melhores recursos de depuração em comparação com os outros dois.
CONJUNTO DE DADOS
Keras é geralmente usado para conjuntos de dados pequenos, pois é comparativa-
mente mais lento. Por outro lado, o TensorFlow e o PyTorch são usad os para modelos de alto
desempenho e grandes conjuntos de dados que requerem execução rápida.
POPULARIDADE
Com a crescente demanda no campo da ciência de dados, houve um enorme cresci-
mento da tecnologia de aprendizado profundo no setor. Com isso, todas as três estruturas
ganharam bastante popularidade. Keras está no topo da lista, seguido por TensorFlow e
PyTorch. Ele ganhou imensa popularidade devido à sua simplicidade quando co mparado aos
outros dois.

Figura 432 Comparação usando o Google Trends

Página 230
 CURSO MACHINE LEARNING COM PYTHON

A Tabela X descreve o melhor uso para cada uma das bibliotecas.

Tabela 13 Comparativo entre Keras, TensorFlow e PyTorch

Keras TensorFlow PyTorch

Prototipagem Rápida Conjunto de dados grande Flexibilidade

Conjunto de dados pequeno Alta performance Duração curta do treina-

mento

Suporte múltiplo de back- Funcionalidade Recursos de depuração

end

DETENÇÃO DE DIABETES USANDO DEEP LEARNING COM KE-

RAS
Para reforçar os conhecimentos de Deep Learning e demonstrar o funcionamento da
biblioteca Keras o seguinte projeto demonstra a predição de diabetes usando técnicas de DL.
O primeiro passo é importar os dados dísponiveis em
https://www.kaggle.com/uciml/pima-indians-diabetes-database. Este conjunto de dados é
originalmente do Instituto Nacional de Diabetes e Doenças Digestivas e Renais.
O objetivo do conjunto de dados é prever se um paciente tem ou não diabetes, com
base em determinadas medidas de diagnóstico incluídas no conjunto de dados. Várias restri-
ções foram colocadas na seleção dessas instâncias em um banco de dados maior. Em particu-
lar, todos os pacientes aqui são mulheres com pelo menos 21 anos de idade da herança indí-
gena Pima.
Utilizando o pandas o Código 83
importa os dados.
A próxima etapa é separar o con-
junto de testes, neste caso 10% como de-
monstra o Código 84.

Código 83 Importação dos dados

Código 84 Separação do conjunto de treino e de testes

Agora é necessário criar o modelo da rede Keras. Os modelos no Keras são definidos
como uma sequência de camadas.
Inicialmente um modelo sequencial é criado e então camadas são adicionadas, uma
de cada vez, até que se esteja satisfeito com a arquitetura de rede.

Página 231
 CURSO MACHINE LEARNING COM PYTHON

A primeira coisa a se acertar é garantir que a camada de entrada tenha o número

certo de recursos de entrada. Isso pode ser especificado ao criar a primeira camada com o
argumento input_dim e configurá-lo como 8 para as 8 variáveis de entrada.

COMO SABEMOS O NÚMERO DE CAMADAS E SEUS TIPOS?

Esta é uma pergunta muito difícil. Existem heurísticas que podem ser usadas, muitas
vezes, a melhor estrutura de rede é encontrada através de um p rocesso de tentativa e tenta-
tiva de erro. Geralmente, é necessário uma rede grande o suficiente para capturar a estru-
tura do problema.
Neste exemplo, uma estrutura de rede totalmente conectada com três camadas será
usada.
Camadas totalmente conectadas são definidas usando a classe Dense. Pode-se espe-
cificar o número de neurônios ou nós na camada como o primeiro argumento e especificar a
função de ativação usando o argumento de ativação.
A função de ativação de unidade linear retificada denominada ReLU será usada nas
duas primeiras camadas e a função Sigmoid na camada de saída.
Antes, as funções de ativação Sigmoid e Tanh eram preferidas para todas as cama-
das. Atualmente, é obtido um melhor desempenho usando a função de ativação ReLU.
Uma função sigmóide é usada na camada de saída para garantir que a saída da rede
esteja entre 0 e 1 e fácil de mapear para uma probabilidade da classe 1 ou ajustar para uma
classificação rígida de qualquer classe com um limite padrão de 0,5.
Resumindo em tópicos:
• O modelo espera linhas de dados com 8 variáveis (o argumento input_dim = 8)
• A primeira camada oculta possui 12 nós e usa a função de ativação ReLU.
• A segunda camada oculta possui 8 nós e usa a função de ativação ReLU.
• A camada de saída possui um nó e usa a função de ativação sigmóide.
O Código 85 representa todo este processo.

Código 85 Criação do modelo e das camadas

Página 232
 CURSO MACHINE LEARNING COM PYTHON

Agora que o modelo está definido, é necessário compilá-lo. A compilação do modelo

usa as bibliotecas numéricas como Theano ou TensorFlow. O back -end escolhe automatica-
mente a melhor maneira de representar a rede para treinamento e previsão de execução no
seu hardware, como CPU ou GPU ou mesmo distribuído.
Ao compilar, é necessário especificar algumas propriedades adicionais necessárias ao
treinar a rede. Lembre-se de treinar uma rede significa encontrar o melhor conjunto de pe-
sos para mapear entradas para saídas em um conjunto de dados.
É necessário, neste ponto, especificar a função de perda a ser usada para avaliar um
conjunto de pesos, o otimizador é usado para pesquisar pesos diferentes para a rede e quais-
quer métricas opcionais que gostaríamos de coletar e relatar durante o treinamento.
Para este exemplo, a entropia cruzada será usada como argumento de perda. Essa
perda é para problemas de classificação binária e é definida no Keras como "binary_crossen-
tropy".
Definiremos o otimizador como o eficiente algoritmo de descida de gradiente esto-
cástico "adam". Esta é uma versão popular da descida de gradiente, porque se ajusta auto-
maticamente e fornece bons resultados em uma ampla gama de problemas.
Por fim, por se tratar de um problema de classificação, a precisão da classificação
será reportada definida pelo argumento de métricas”metrics”.

Código 86 Compilação do modelo

Definimos nosso modelo e o compilamos para uma computação eficiente. Agora é

hora de executar o modelo em alguns dados.
Podemos treinar ou ajustar nosso modelo em nossos dados carregados chamando a
função fit() no modelo. O treinamento ocorre em épocas e cada época é di vidida em lotes.
• Época: Uma passagem por todas as linhas no conjunto de dados de treinamento.
• Lote: uma ou mais amostras consideradas pelo modelo em uma época antes da atua-
lização dos pesos.
Uma época é composta por um ou mais lotes, com base no tamanho de lote escolhido e
o modelo é adequado para muitas épocas.
O processo de treinamento será executado para um número fixo de iterações através do
conjunto de dados chamado épocas (que será especificado usando o argumento de epochs).
Também deve-se definir o número de linhas do conjunto de dados que são consideradas an-
tes que os pesos do modelo sejam atualizados em cada época. Este número é denominado
como tamanho do lote e configurados usando o argumento batch_size.
Para esse problema, um pequeno número de épocas (150) e um tamanho de lote relati-
vamente pequeno de 10 serão usados. Essas configurações podem ser escolhidas experimen-
talmente por tentativa e erro.

Página 233
 CURSO MACHINE LEARNING COM PYTHON

O Código 87 implementa esta

etapa.

Código 87 Treino do modelo

Para avaliar o modelo no conjunto de dados de treinamento a função evaluate() é

usada.
Isso gerará uma previsão para cada par de entrada e saída e coletará pontuações, in-
cluindo a perda média e quaisquer métricas configuradas, como precisão.
A função evaluate() retornará uma lista com dois valores. O primeiro será a perda do
modelo no conjunto de dados e o segundo será a precisão do modelo no conjunto de dados.
Na Figura 437
apenas a precisão é usada
e o valor da perda é igno-
rado.

Figura 433 Precisão do modelo criado

Pode-se adaptar o exemplo acima

e usá-lo para gerar previsões no conjunto
de dados de treinamento com o método
predict_classes() como demonstrado na
Figura 438.

Figura 434 Predição de novas entradas

Página 234
 CURSO MACHINE LEARNING COM PYTHON

CONCLUSÃO
Parabéns!!!! Não foi fácil chegar até aqui.
Este não é o ponto de chegada, na verdade, é o início de uma grande jornada para
exploração. Neste ponto você já percebeu o quanto o mundo de Machine Learning é pode-
roso e como pode auxiliar para a tomada de decisões e obtenção de insights.
Não pare de se aperfeiçoar, mantendo contato com este mundo e agregando novos
conhecimentos muito em breve você poderá contribuir com a comunidade e desenvolver al-
goritmos muito mais poderosos que os definidos neste material.
Aguardamos você em mais um curso, até lá, bons estudos.

Página 235
 CURSO MACHINE LEARNING COM PYTHON

APÊNDICE
LISTA DE VERIFICAÇÃO DO PROJETO DE APRENDIZADO
DE MÁQUINA

Esta lista de verificação pode guiá-lo pelos seus projetos de Machine Learning. Exis-
tem oito etapas principais:
1. Enquadre o problema e veja a imagem geral.
a. Defina o objetivo em termos de negócios.
b. Como sua solução será usada?
c. Quais são as soluções / soluções alternativas atuais (se houver)?
d. Como você deve enquadrar esse problema (supervisionado / não supervisio-
nado, online / offline, etc.)?
e. Como o desempenho deve ser medido?
f. A medida de desempenho está alinhada com o objetivo do negócio?
g. Qual seria o desempenho mínimo necessário para alcançar o objetivo do ne-
gócio?
h. Quais são os problemas comparáveis? Você pode reutilizar experiências ou
ferramentas?
i. Existe experiência humana disponível?
j. Como você resolveria o problema manualmente?
k. Liste as suposições que você (ou outras pessoas) fizeram até agora.
l. Verifique as suposições, se possível.
2. Obtenha os dados.
a. Liste os dados necessários e quanto você precisa.
b. Encontre e documente onde você pode obter esses dados.
c. Verifique quanto espaço será necessário.
d. Verifique as obrigações legais e obtenha autorização, se necessário.
e. Obtenha autorizações de acesso.
f. Crie um espaço de trabalho (com espaço de armazenamento suficiente).
g. Obtenha os dados.
h. Converta os dados em um formato que você possa manipular facilmente
(sem alterar os dados em si).
i. Verifique se as informações confidenciais são excluídas ou protegidas (por
exemplo, anonimizadas).
j. Verifique o tamanho e o tipo de dados (séries temporais, amostra, geográfi-
cas etc.).
k. Faça uma amostra de um conjunto de testes, coloque-o de lado e nunca olhe
para ele (sem espionagem de dados!)
3. Explore os dados para obter insights.
a. Crie uma cópia dos dados para exploração (amostrando-os em um tamanho
gerenciável, se necessário).
b. Crie um bloco de anotações Jupyter para manter um registro de sua explora-
ção de dados.

Página 236
 CURSO MACHINE LEARNING COM PYTHON

c. Estude cada atributo e suas características:

i. Nome
ii. Tipo (categórico, int / float, limitado / ilimitado, texto, estruturado
etc.)
iii. % de valores ausentes
iv. Ruído e tipo de ruído (estocástico, outliers, erros de arredonda-
mento, etc.)
v. Possivelmente útil para a tarefa?
vi. Tipo de distribuição (gaussiana, uniforme, logarítmica, etc.)
d. Para tarefas de aprendizado supervisionado, identifique o(s) atributo(s) de
destino.
e. Visualize os dados.
f. Estude as correlações entre atributos.
g. Estude como você resolveria o problema manualmente.
h. Identifique as transformações promissoras que você deseja aplicar.
i. Identifique dados extras, ou de outras fontes, que seriam úteis.
j. Documente o que você aprendeu.
4. Prepare os dados para melhor expor os padrões de dados subjacentes aos algorit-
mos de Machine Learning.
a. Trabalhe em cópias dos dados (mantenha intacto o conjunto de dados origi-
nal).
b. Limpeza de dados:
i. Corrija ou remova valores discrepantes (opcional).
ii. Preencha os valores ausentes (por exemplo, com zero, média, medi-
ana ...) ou exclua suas linhas (ou colunas).
c. Seleção de Características
i. Exclua os atributos que não fornecem informações úteis para a ta-
refa.
d. Engenharia de recursos
i. Discretizar recursos contínuos
ii. Decomponha características (por exemplo, categóricos, data / hora
etc.).
iii. Agregue características em novas características.
e. Escala de recursos: padronize ou normalize recursos
5. Explore muitos modelos diferentes e faça uma lista curta dos melhores.
a. Treine muitos modelos rápidos e pouco eficientes de diferentes categorias
(por exemplo, lineares, Navie Bayes, SVM, florestas aleatórias, rede neural
etc.) usando parâmetros padrão.
b. Avalie e compare seu desempenho.
i. Para cada modelo, use a validação cruzada de dobras N e calcule a
média e o desvio padrão da medida de desempenho nas dobras N.
c. Analise as variáveis mais significativas para cada algoritmo.
d. Analise os tipos de erros que os modelos cometem.
i. Quais dados um humano usaria para evitar esses erros?
e. Faça uma rápida seleção de engenharia e seleção de recursos.
f. Faça uma ou duas mais iterações rápidas das cinco etapas anteriores.

Página 237
 CURSO MACHINE LEARNING COM PYTHON

g. Faça uma lista curta dos três a cinco modelos mais promissores, preferindo
modelos que cometem tipos diferentes de erros.
6. Ajuste seus modelos e combine-os em uma ótima solução.
a. Use os parâmetros para melhorar seu modelo
b. Quando estiver confiante sobre seu modelo final, meça seu desempenho no
conjunto de testes para estimar o erro de generalização.
7. Apresente sua solução.
a. Documente o que você fez.
b. Crie uma boa apresentação.
i. Certifique-se de destacar primeiro o quadro geral
c. Explique por que sua solução atinge o objetivo de negócios.
d. Não se esqueça de apresentar pontos interessantes que você notou ao longo
do caminho.
i. Descreva o que funcionou e o que não funcionou.
ii. Liste suas suposições e limitações do seu sistema
e. Certifique-se de que suas principais conclusões sejam comunicadas através
de belas visualizações ou declarações fáceis de lembrar (por exemplo, "a
renda mediana é o principal fator preditor dos preços da habitação").
8. Inicie, monitore e mantenha seu sistema.
a. Prepare sua solução para produção (conecte as entradas de dados de produ-
ção, escreva testes unitários etc.).
b. Escreva o código de monitoramento para verificar o desempenho ao vivo do
seu sistema em intervalos regulares e acionar alertas quando ele cair.
c. Cuidado com a degradação lenta também: os modelos tendem a "apodrecer"
à medida que os dados evoluem.
i. Medir o desempenho pode exigir um pipeline humano (por exemplo,
através de um serviço de crowdsourcing).
ii. Monitore também a qualidade de suas entradas (por exemplo, um
sensor com defeito enviando valores aleatórios ou a saída de outra
equipe ficando obsoleta). Isso é particularmente importante para os
sistemas de aprendizado on-line.
d. Treine seus modelos regularmente com novos dados (automatize o máximo
possível).

Página 238
 CURSO MACHINE LEARNING COM PYTHON

REFERÊNCIAS

[1] Geração de Dataset de salários fictícios:

import pandas as pd

import numpy as np

link = "https://pt.wikipedia.org/wiki/Lista_de_mem-
bros_da_Liga_da_Justi%C3%A7a"

#Acessa a página e obtém as tabelas

df = pd.read_html(link)

#Filtra os dados e transforma a série em um DataFrame

df = pd.DataFrame(df[0]["Personagem(heróis)"])

df = df.rename(columns={ #Renomeando a coluna Personagem(heróis)

"Personagem(heróis)":"Funcionário"})

#Eliminando tudo que tenha mais que 37 caracteres

df = df[df["Funcionário"].str.len()<=37]

#Gera os salários

df["Salários"] = np.random.randint(10000, 50000, df.shape[0])

#Salvando em diferentes formatos

df.to_csv("salario_da_liga.csv") #Salva em CSV

df.to_excel("salario_da_liga.xls") #Salva em xls

df.to_excel("salario_da_liga.xlsx") #Salva em xlsx

df.to_json("salario_da_liga.json") #Salva em json

df.to_html("salario_da_liga.html") #Salva em HTML

[2] Gerador do dataset de pokémons:

import requests

import pandas as pd

url = 'https://bulbapedia.bulbagar-
den.net/wiki/List_of_Pok%C3%A9mon_by_base_stats_(Genera-
tion_VII)'

#Cria um cabeçalho para simular um acesso com navegador

header = {

Página 239
 CURSO MACHINE LEARNING COM PYTHON

"User-Agent": "Mozilla/5.0 (X11; Linux x86_64) AppleWeb-

Kit/537.36 (KHTML, like Gecko) Chrome/50.0.2661.75 Sa-
fari/537.36",

"X-Requested-With": "XMLHttpRequest"

#Faz a requisição e obtém a página

pagina = requests.get(url, headers=header)

#Obtém as tabelas presentes no site

df_pokemons = pd.read_html(pagina.text)

#Pega apenas a primeira

df_pokemons = df_pokemons[1]

#Obtém as colunas relevantes (remove "#"" e "Unnamed: 1")

df_pokemons = df_pokemons.loc[:, "Pokémon":"Average"]

#Salva o arquivo

df.to_csv("pokemons.csv") #Salva em CSV

df.to_excel("pokemons.xls") #Salva em xls

df.to_excel("pokemons.xlsx") #Salva em xlsx

df.to_json("pokemons.json") #Salva em json

df.to_html("pokemons.html") #Salva em HTML

[3] Gerador de dados de produção

import pandas as pd

import numpy as np

df= pd.DataFrame()

ano = 2026

df["data"] = [np.datetime64(str(ano)+'-01-01')+(i%365) for i in

range(1000)]

df["producao"] = np.random.randint(10000, 50000, 1000)

df["custos"] = np.random.randint(7000, 15000, 1000)

df["resultado"] = df["producao"] - df["custos"]

df.sort_values(by=['data'], inplace=True)

df.to_excel("produção_"+str(ano)+".xlsx")

Página 240
 CURSO MACHINE LEARNING COM PYTHON

[4] Nome de filmes do Quentin Tarantino

import pandas as pd

link = "http://www.adorocinema.com/personalidades/personalidade-
15570/filmografia/"

df = pd.read_html(link)[0]

df.to_excel("tarantino.xlsx")

[5] https://stackoverflow.com/questions/40632486/dot-exe-not-found-in-path-
pydot-on-python-windows-7
[6] https://towardsdatascience.com/how-to-visualize-a-decision-tree-in-5-steps-
19781b28ffe2
[7] http://rasbt.github.io/mlxtend/user_guide/classifier/StackingClassifier/

Página 241