O PROBLEMA DO SUCESSO E O ALGORITMO BURRO
4.5 RESUMINDO
resultado = modelo.predict(teste_dados) acertos = resultado == teste_marcacoes total_de_acertos = sum(acertos) total_de_elementos = len(teste_dados)
taxa_de_acerto = 100.0 * total_de_acertos / total_de_elementos print("Taxa de acerto do algoritmo: %f" % taxa_de_acerto) print(total_de_elementos)
Vamos testar novamente o nosso arquivo
classifica_buscas.py :
> python3 classifica_buscas.py Taxa de acerto base: 83.200000
Taxa de acerto do algoritmo: 82.000000 100
Como podemos ver, o nosso algoritmo está funcionando perfeitamente. Além disso, fizemos uma implementação mais genérica. Ele consegue contar a quantidade de dados e nos retorna o maior, independentemente de qual informação esteja contida dentro do arquivo de dados.
Neste capítulo, iniciamos a questão do sucesso do algoritmo, isto é, concluir se foi bom ou ruim dado o seu resultado. Vimos que, para sabermos se o nosso resultado foi um sucesso ou um fracasso de verdade, precisamos comparar o nosso algoritmo. Uma das possíveis formas é compararmos com um algoritmo base, ou seja, aquele que chuta o mesmo valor para cada elemento independente de suas características.
Se realizarmos o teste e o nosso algoritmo for pior do que o
algoritmo base, podemos concluir que o nosso não é tão bom quanto imaginamos. Podemos utilizar esse método como o primeiro critério de avaliação para identificar se o algoritmo está bom ou não.
Um segundo critério é verificar se o número obtido é relevante para o seu negócio. Por exemplo, se o seu teste é para detectar terremotos na Terra e o algoritmo acerta em 51% das vezes, e acaba obtendo um resultado melhor do que um algoritmo que chuta apenas sim ou não, perceba que 51% das vezes para gerar um alerta de terremotos parece não fazer muito sentido, pois metade das vezes o alerta será inútil. Será que esse tipo de resultado é bom para esse negócio?
Repare que, além de apenas avaliar o resultado com o algoritmo base, precisamos verificar se o número faz sentido ou não para o negócio também.
Uma outra situação seria descobrir quais serão os alunos que terão dificuldade nas provas no final do ano. A princípio, podemos concluir que nosso algoritmo é bom, porém, pode ser que ele também preveja muitos alunos que não terão dificuldades, logo, provavelmente gastaremos mais tempo dos professores com alunos que não têm dificuldade de verdade.
Perceba que, além de considerar se o resultado do algoritmo foi maior que o algoritmo base, é importante entender se ele faz sentido ou não. Então veja que você também precisa avaliar o resultado e saber dizer se 51%, 82% ou qualquer outro valor faz ou não sentido para o seu objetivo.
Além disso, em todos os outros testes, utilizamos apenas zeros
4.5 RESUMINDO 167
e uns, mas, dessa vez, vimos que podemos também trabalhar com palavras, isto é, sim s e nao s. Porém, tivemos de realizar uma refatoração no nosso código para que ele fosse o mais genérico possível e, assim, aceitasse quaisquer tipos de valores. Para isso, usamos APIs mais genéricas do Python, como no caso do
Counter .
Por fim, vimos que, quando queremos comparar dois algoritmos, é de extrema importância usarmos os mesmos dados.
Ou seja, se foram usados os dados X para treinar e testar o nosso algoritmo, teremos de utilizar esses mesmos dados X para o nosso algoritmo base.
Lembre-se também de que o algoritmo base não exige nenhum tipo de treino, pois ele simplesmente chuta o mesmo valor para todos os elementos. Será que no nosso algoritmo usamos os mesmos dados tanto para o algoritmo base quanto para o algoritmo que implementamos? Vejamos os dados de cada um:
Algoritmo base:
# restante do código
acerto_base = max(Counter(Y).values())
taxa_de_acerto_base = 100.0 * acerto_base / len(Y)
Nosso algoritmo:
# restante do código porcentagem_treino = 0.9
tamanho_de_treino = porcentagem_treino * len(Y) tamanho_de_teste = len(Y) - tamanho_de_treino treino_dados = X[:tamanho_de_treino]
treino_marcacoes = Y[:tamanho_de_treino]
teste_dados = X[-tamanho_de_teste:]
168 4.5 RESUMINDO
teste_marcacoes = Y[-tamanho_de_teste:]
from sklearn.naive_bayes import MultinomialNB modelo = MultinomialNB()
modelo.fit(treino_dados, treino_marcacoes) resultado = modelo.predict(teste_dados) acertos = resultado == teste_marcacoes total_de_acertos = sum(acertos) total_de_elementos = len(teste_dados)
A princípio, parece que são os mesmos dados, porém, no algoritmo base estamos utilizando o Y , ou seja, 100% dos dados, enquanto que no algoritmo que implementamos estamos usando uma parte do Y , nesse caso, 90%. Será que esse teste está sendo justo?
Com certeza, não! Lembre-se de que, quando é necessário comparar dois algoritmos, precisamos sempre usar os mesmos dados. Se usarmos 90% para o nosso algoritmo, precisamos utilizar os mesmos 90% para o algoritmo base. Mas e se forem 90%
aleatórios? Os mesmos 90% aleatórios precisarão ser usados no algoritmo base.
Considerando o que acabamos de ver, vamos fazer com que o nosso algoritmo base utilize os mesmos dados que o nosso algoritmo. Primeiro, copiaremos este trecho de código:
acerto_base = max(Counter(Y).values())
taxa_de_acerto_base = 100.0 * acerto_base / len(Y) print("Taxa de acerto base: %f" % taxa_de_acerto_base)
Então, colaremos no final do arquivo:
# restante do código
print("Taxa de acerto do algoritmo: %f" % taxa_de_acerto)
4.5 RESUMINDO 169
print(total_de_elementos)
acerto_base = max(Counter(Y).values())
taxa_de_acerto_base = 100.0 * acerto_base / len(Y) print("Taxa de acerto base: %f" % taxa_de_acerto_base)
Por fim, alteraremos os valores de Y e usaremos a variável
teste_marcacoes que se refere aos 90% do Y usados no nosso algoritmo. O código final fica da seguinte forma:
import pandas as pd
from collections import Counter df = pd.read_csv('buscas.csv')
X_df = df[['home', 'busca', 'logado']]
Y_df = df['comprou']
Xdummies_df = pd.get_dummies(X_df) Ydummies_df = Y_df
X = Xdummies_df.values Y = Ydummies_df.values porcentagem_treino = 0.9
tamanho_de_treino = porcentagem_treino * len(Y) tamanho_de_teste = len(Y) - tamanho_de_treino treino_dados = X[:tamanho_de_treino]
treino_marcacoes = Y[:tamanho_de_treino]
teste_dados = X[-tamanho_de_teste:]
teste_marcacoes = Y[-tamanho_de_teste:]
from sklearn.naive_bayes import MultinomialNB modelo = MultinomialNB()
modelo.fit(treino_dados, treino_marcacoes) resultado = modelo.predict(teste_dados) acertos = resultado == teste_marcacoes total_de_acertos = sum(acertos)
170 4.5 RESUMINDO
total_de_elementos = len(teste_dados)
taxa_de_acerto = 100.0 * total_de_acertos / total_de_elementos print("Taxa de acerto do algoritmo: %f" % taxa_de_acerto) print(total_de_elementos)
acerto_base = max(Counter(teste_marcacoes).values())
taxa_de_acerto_base = 100.0 * acerto_base / len(teste_marcacoes) print("Taxa de acerto base: %f" % taxa_de_acerto_base)
Ao rodarmos o código com esses ajustes, teremos:
> python3 classifica_buscas.py Taxa de acerto do algoritmo: 82.000000 100
Taxa de acerto base: 82.000000
Repare que, usando exatamente os mesmos dados para ambos os algoritmos, mesmo não tendo um resultado superior, o nosso algoritmo foi tão bom quanto o algoritmo base. Ou seja, é de extrema importância a utilização de exatamente os mesmos dados para a comparação entre dois algoritmos.
4.5 RESUMINDO 171
CAPÍTULO 5
Até agora, utilizamos apenas o algoritmo MultinomialNB
(Naive Bayes). Como será que esse algoritmo funciona por de trás dos panos? Em outras palavras, dado um conjunto de dados que separamos entre treino e teste, como será que ele faz para treinar a partir desses dados? Ou então, como o nosso cérebro faz para dizer se é um porco ou um cachorro, ou se o e-mail é spam ou não spam?
Mas por que precisamos saber como ele funciona? É justamente para obtermos uma base melhor de como um algoritmo de classificação funciona. Existem diversas formas de classificação que envolvem teorias matemáticas, porém, nesse instante, veremos o MultinomialNB . Podemos iniciar com um exemplo do dia a dia do brasileiro: a eleição. Pegamos um determinado público e perguntamos quem ganharia, entre o Guilherme e o Paulo, e os resultados foram: