Clarify Apostila Machine Learning Python
Clarify Apostila Machine Learning Python
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.
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
Média ................................................................................................................................... 25
mediana ................................................................................................................................ 25
Moda .................................................................................................................................... 26
Variância ............................................................................................................................... 26
Pontos................................................................................................................................... 27
Distância entre dois pontos ................................................................................................... 28
Matrizes ................................................................................................................................ 28
Página 4
CURSO MACHINE LEARNING COM PYTHON
Classificação .......................................................................................................................... 73
Aplicando uma função ........................................................................................................... 74
DataFrames ........................................................................................................................... 75
Página 5
CURSO MACHINE LEARNING COM PYTHON
Página 6
CURSO MACHINE LEARNING COM PYTHON
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)
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):
Página 10
CURSO MACHINE LEARNING COM PYTHON
Página 11
CURSO MACHINE LEARNING COM PYTHON
Página 12
CURSO MACHINE LEARNING COM PYTHON
Página 13
CURSO MACHINE LEARNING COM PYTHON
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.
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
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 .
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
É 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
Página 18
CURSO MACHINE LEARNING COM PYTHON
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.
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
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.
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.
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)
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:
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
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
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
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:
Nota 1 3 7
Nota 2 8 7
Nota 3 10 7
Página 26
CURSO MACHINE LEARNING COM PYTHON
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
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.
Página 27
CURSO MACHINE LEARNING COM PYTHON
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: || ||
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.
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.
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.
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
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.
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
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
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")
Página 32
CURSO MACHINE LEARNING COM PYTHON
dias = [1,2,3,4,5]
vendas_caneta = [2,3,4,10,15]
vendas_suco = [7,6,4,6,2]
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á
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)
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)
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)
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
Página 35
CURSO MACHINE LEARNING COM PYTHON
rwidth=0.8, orientation="horizontal")
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)
MARCADORES
É possível alterar os marcado-
res usando o parâmetro marker. Como
por exemplo:
plt.scatter(dias,
media_acidentes,
marker="*")
Página 36
CURSO MACHINE LEARNING COM PYTHON
Figura 39 s=150
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
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.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
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)
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))
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%%")
Página 39
CURSO MACHINE LEARNING COM PYTHON
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.
CRIAÇÃO DE ARRAYS
Convencionalmente, a numpy é apelidada de
np como visto no Código 1.
Página 40
CURSO MACHINE LEARNING COM PYTHON
A função .ones(), de forma análoga a função .zeros() cria uma matriz de uns como
visto no Código 6
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.
Números aleatórios podem ser gerados com facilidade usando as funções random da
numpy que podem ser visualizados na Figura 48:
Página 42
CURSO MACHINE LEARNING COM PYTHON
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
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:
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
NDIM
O atributo ndim retornará o número de dimensões da matriz como visto na .
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.
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
FATIAMENTO DE ARRAYS
Como nas listas Python um array numpy também pode ser fatiado, para os exemplos
considerar o Código 18.
Página 45
CURSO MACHINE LEARNING COM PYTHON
A forma reversa
também é permitida
como visto no Código 19.
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
Página 46
CURSO MACHINE LEARNING COM PYTHON
Página 47
CURSO MACHINE LEARNING COM PYTHON
SEPARAÇÃO DE ARRAYS
É possível ainda
dividir as matrizes com
base em posições pre-
definidas. Como de-
monstra o 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.
É 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
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 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.
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
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.
Da mesma forma, para criar intervalos de datas, a função arange() pode ser usada
como demonstrado na Figura 75.
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
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.
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.
Página 55
CURSO MACHINE LEARNING COM PYTHON
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.
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.
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.
Series 1D Coluna
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.
Um Series é semelhante a uma única coluna ou linha de dados como visto na Figura
87.
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.
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
É 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.
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
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.
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.
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.
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.
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.
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
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
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.
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.
.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
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.
Pode-se criar um segundo filtro com os anos que se tenha menos que 15 , como mos-
tra a Figura 115.
Página 67
CURSO MACHINE LEARNING COM PYTHON
== Igual a
Operador Nome
!= Diferente de
And &
< Menor que
Or |
> Maior que
Not ~
<= Menor 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
:
Da mesma maneira, os operadores de
subtração, divisão, módulo e divisão inteira estão
disponíveis.
Página 68
CURSO MACHINE LEARNING COM PYTHON
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
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)
Página 69
CURSO MACHINE LEARNING COM PYTHON
Função Descrição
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
float_, float16,
float64 float float32, float64 Números decimais
Página 71
CURSO MACHINE LEARNING COM PYTHON
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
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.
Página 74
CURSO MACHINE LEARNING COM PYTHON
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.
A representação gráfica
da Figura 143 mostra o nome de
cada um dos elementos que com-
pões um DataFrame.
Página 75
CURSO MACHINE LEARNING COM PYTHON
Na Figura 147, por exemplo, as duas primeiras linhas da coluna "nome" são obtidas
usando .iloc e .loc.
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
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')
HTML
Para abrir um arquivo html, o método read_html() é usado:
df = pd.read_html("salario_da_liga.html")
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")
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.
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.
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.
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
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":
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.
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
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
Para percorrer todos os grupos, um laço de repetição pode ser usado conforme de-
monstrado na
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
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.
Página 84
CURSO MACHINE LEARNING COM PYTHON
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.
Página 85
CURSO MACHINE LEARNING COM PYTHON
Para incluir totais, o parâmetro margins=True é usado como visto na Figura 168.
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.
Página 87
CURSO MACHINE LEARNING COM PYTHON
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
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
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.
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.
left.
Página 90
CURSO MACHINE LEARNING COM PYTHON
how Resultado
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.
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:
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
Por fim,
basta apenas ins-
talar o pacote
usando o pip.
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:
Ainda é possível refinar a pesquisa usando os filtros, neste caso iremos buscar ape-
nas pelos gratuitos (Free).
Página 94
CURSO MACHINE LEARNING COM PYTHON
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
Para ver mais detalhes, basta clicar em EXPAND. Ao fazer isso, um quadro geral dos
dados é aberto como mostra a Figura 191.
É 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
Página 97
CURSO MACHINE LEARNING COM PYTHON
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'.
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.
Página 98
CURSO MACHINE LEARNING COM PYTHON
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.
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.
INSTALAÇÃO
Para instalar o módulo seaborn basta usar o gerenciador pip:
pip install seaborn
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
Página 101
CURSO MACHINE LEARNING COM PYTHON
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
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.
Página 103
CURSO MACHINE LEARNING COM PYTHON
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
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
Página 105
CURSO MACHINE LEARNING COM PYTHON
Página 106
CURSO MACHINE LEARNING COM PYTHON
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
Página 108
CURSO MACHINE LEARNING COM PYTHON
O parâmetro jitter controla a magnitude desta tremulação, podendo até mesmo ser
desligada.
Página 109
CURSO MACHINE LEARNING COM PYTHON
Para criar uma ordenação diferente, bem como quais colunas serão exibidas o parâ-
metro order pode ser usado.
Página 110
CURSO MACHINE LEARNING COM PYTHON
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.
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.
VIOLINPLOTS
O gráfico violin combina um boxplot com
o procedimento de estimativa de densidade.
Página 112
CURSO MACHINE LEARNING COM PYTHON
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
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.
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.
Página 115
CURSO MACHINE LEARNING COM PYTHON
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.
Página 116
CURSO MACHINE LEARNING COM PYTHON
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.
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.
Página 118
CURSO MACHINE LEARNING COM PYTHON
Página 119
CURSO MACHINE LEARNING COM PYTHON
Página 120
CURSO MACHINE LEARNING COM PYTHON
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 251 O modo robusto faz com que pontos muito fora
da curva sejam suavizados
Página 122
CURSO MACHINE LEARNING COM PYTHON
Para adicionar outra variável, basta fazer uso de outras "facetas" com os parâmetros
col e row demonstrado na e na
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:
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.
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.
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
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.
Página 128
CURSO MACHINE LEARNING COM PYTHON
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
Figura 265 Passo 2: Criação da lista de tuplas contendo os passos que serão aplicados
Por fim, basta chamar o método fit() passando os parâmetros de entrada e saída.
Página 130
CURSO MACHINE LEARNING COM PYTHON
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.
θ 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
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.
Página 133
CURSO MACHINE LEARNING COM PYTHON
Figura 276 Processo para encontrar o melhor valor de teta com a Equação Normal
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.
Página 134
CURSO MACHINE LEARNING COM PYTHON
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
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.
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
É 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
Página 139
CURSO MACHINE LEARNING COM PYTHON
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):
Página 140
CURSO MACHINE LEARNING COM PYTHON
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.
Página 142
CURSO MACHINE LEARNING COM PYTHON
O modelo original é:
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
Página 145
CURSO MACHINE LEARNING COM PYTHON
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).
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
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).
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.
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.
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
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 .
Página 151
CURSO MACHINE LEARNING COM PYTHON
Página 152
CURSO MACHINE LEARNING COM PYTHON
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:
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.
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'
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
Página 154
CURSO MACHINE LEARNING COM PYTHON
Página 155
CURSO MACHINE LEARNING COM PYTHON
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).
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.
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.
Página 157
CURSO MACHINE LEARNING COM PYTHON
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.
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
Página 159
CURSO MACHINE LEARNING COM PYTHON
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.
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).
Página 162
CURSO MACHINE LEARNING COM PYTHON
Á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.
Página 163
CURSO MACHINE LEARNING COM PYTHON
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
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.
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.
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
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.
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ó.
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
Página 169
CURSO MACHINE LEARNING COM PYTHON
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.
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.
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.
Página 172
CURSO MACHINE LEARNING COM PYTHON
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.
Página 174
CURSO MACHINE LEARNING COM PYTHON
Página 176
CURSO MACHINE LEARNING COM PYTHON
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.
Página 177
CURSO MACHINE LEARNING COM PYTHON
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.
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.
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).
Página 181
CURSO MACHINE LEARNING COM PYTHON
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.
Em seguida, um terceiro modelo é treinado com base nos erros residuais cometidos
pelo segundo preditor.
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.
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.
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.
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
Página 185
CURSO MACHINE LEARNING COM PYTHON
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
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
Página 187
CURSO MACHINE LEARNING COM PYTHON
Página 188
CURSO MACHINE LEARNING COM PYTHON
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
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).
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).
Página 190
CURSO MACHINE LEARNING COM PYTHON
Á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
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.
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
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
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.
Página 198
CURSO MACHINE LEARNING COM PYTHON
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.
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.
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.
Página 200
CURSO MACHINE LEARNING COM PYTHON
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.
Mesmo
usando uma frase mais
comum poucas pala-
vras são classificadas.
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.
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
É 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
Página 203
CURSO MACHINE LEARNING COM PYTHON
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 .
Página 204
CURSO MACHINE LEARNING COM PYTHON
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.
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:
Página 206
CURSO MACHINE LEARNING COM PYTHON
TRATAMENTO NPL
Com o conjunto de da-
dos gerado, é hora de traba-
lhar com ele. Para isso, o pri-
meiro passo é importá-lo.
Código 74 Dependências
Página 207
CURSO MACHINE LEARNING COM PYTHON
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.
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
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.
Página 209
CURSO MACHINE LEARNING COM PYTHON
Página 210
CURSO MACHINE LEARNING COM PYTHON
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
Página 213
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.
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.
Página 215
CURSO MACHINE LEARNING COM PYTHON
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.
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.
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.
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
X1 X2 Saída
0 0 0
0 1 0
1 0 0
1 1 1
Página 223
CURSO MACHINE LEARNING COM PYTHON
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
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
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
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
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.
Página 228
CURSO MACHINE LEARNING COM PYTHON
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.
Página 230
CURSO MACHINE LEARNING COM PYTHON
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
Página 232
CURSO MACHINE LEARNING COM PYTHON
Página 233
CURSO MACHINE LEARNING COM PYTHON
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
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
import numpy as np
link = "https://pt.wikipedia.org/wiki/Lista_de_mem-
bros_da_Liga_da_Justi%C3%A7a"
df = pd.read_html(link)
df = pd.DataFrame(df[0]["Personagem(heróis)"])
"Personagem(heróis)":"Funcionário"})
df = df[df["Funcionário"].str.len()<=37]
#Gera os salários
import pandas as pd
url = 'https://bulbapedia.bulbagar-
den.net/wiki/List_of_Pok%C3%A9mon_by_base_stats_(Genera-
tion_VII)'
header = {
Página 239
CURSO MACHINE LEARNING COM PYTHON
"X-Requested-With": "XMLHttpRequest"
df_pokemons = pd.read_html(pagina.text)
df_pokemons = df_pokemons[1]
#Salva o arquivo
import numpy as np
df= pd.DataFrame()
ano = 2026
df.sort_values(by=['data'], inplace=True)
df.to_excel("produção_"+str(ano)+".xlsx")
Página 240
CURSO MACHINE LEARNING COM PYTHON
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