Gist com código comentado do curso da parte I de ML

classifica_buscas_comentado.py

# -*- coding: utf-8 -*-
# adicionei a linha de itf-8 porque o terminal pediu, mas você pode desconsiderá-la
import pandas as pd
from collections import Counter

df = pd.read_csv('busca.csv')
X_df = df[['home', 'busca', 'logado']]
Y_df = df['comprou']

Xdummies_df = pd.get_dummies(X_df).astype(int)
Ydummies_df = Y_df

X = Xdummies_df.values
Y = Ydummies_df.values

porcentagem_treino = 0.8
porcentagem_de_teste = 0.1

# na linha baixo precisamos manter a conversao para int no tamanho de treino
tamanho_de_treino = int(porcentagem_treino * len(Y))
tamanho_de_teste = porcentagem_de_teste * len(Y)
tamanho_de_validacao =  len(Y) - tamanho_de_treino - tamanho_de_teste

treino_dados = X[0:tamanho_de_treino]
treino_marcacoes = Y[0:tamanho_de_treino]

# creio que o fim_de_treino ficou aqui durante o curso, e que ele é o fim_de_teste
# fim_de_treino = int(tamanho_de_treino+ tamanho_de_teste)
# no fim_de_teste também mantenha a conversão para inteiro
# no fim_de_teste, a agregação é de fim de treino e tamanho de treino
fim_de_teste = int(tamanho_de_treino+ tamanho_de_teste)
# abaixo no teste_dados, pegamos o tamanho com o fim de teste ao invés do de treino
# teste_dados = X[tamanho_de_treino:fim_de_treino]
teste_dados = X[tamanho_de_treino:fim_de_teste]
# a mesma coisa do teste_dados para teste_marcacoes: estamos lidando com fim_de_teste ao invés de fim_de_treino
# teste_marcacoes = Y[tamanho_de_treino:fim_de_treino]
teste_marcacoes = Y[tamanho_de_treino:fim_de_teste]


validacao_dados = X[fim_de_teste:]
validacao_marcacoes = Y[fim_de_teste:]

def fit_and_predict(nome, modelo, treino_dados, treino_marcacoes, teste_dados, teste_marcacoes):
	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)

	taxa_de_acerto = 100.0 * total_de_acertos / total_de_elementos

	msg = "Taxa de acerto do {0}: {1}".format(nome, taxa_de_acerto)
	print(msg)

	return taxa_de_acerto

from sklearn.naive_bayes import MultinomialNB
modeloMultinomial = MultinomialNB()
resultadoMultinomialNB = fit_and_predict("MultinomialNB", modeloMultinomial, treino_dados, treino_marcacoes, teste_dados, teste_marcacoes)

from sklearn.ensemble import AdaBoostClassifier
modeloAdaBoost = AdaBoostClassifier()
resultadoAdaBoost = fit_and_predict("AdaBoostClassifier", modeloAdaBoost, treino_dados, treino_marcacoes, teste_dados, teste_marcacoes)

if (resultadoMultinomialNB > resultadoAdaBoost):
	# vencedor = resultadoMultinomialNB
	# aqui precisamos chamar o modelo para usar o classificador: então ao invés de resultado é modelo
	vencedor = modeloMultinomialNB
else:	
	# vencedor = resultadoAdaBoost
	# mesma coisa do que com o MultinomialNB, trocar resultado por modelo que declaramos antes
	vencedor = modeloAdaBoost

resultado = vencedor.predict(validacao_dados)

# acertos = resultado - validacao_marcacoes
# nesta linha estamos comparando o resultado com a validacao ao invés de subtrair
acertos = (resultado == validacao_marcacoes)

total_de_acertos = sum(acertos)
total_de_elementos = len(validacao_marcacoes)

taxa_de_acerto = 100.0 * total_de_acertos / total_de_elementos

msg = "Taxa de acerto do vencedor entre os dois algoritmos no mundo real {0}".format(taxa_de_acerto)
print(msg)

# acerto_base = max(Counter(teste_marcacoes).itervalues())
# aqui estamos contando a partir do teste ao invés da validação
acerto_base = max(Counter(validacao_marcacoes).itervalues())
# taxa_de_acerto_base = 100.0 * acerto_base / len(teste_marcacoes)
# abaixo, ao invés do teste, vamos dividir pelo tamanho da validação_marcações
taxa_de_acerto_base = 100.0 * acerto_base / len(validacao_marcacoes)
print("Taxa de acerto base: %f" % taxa_de_acerto_base)

# print("Total de testes: %d" %len(teste_dados))
# abaixo no total, também usamos a validaço ao invés do teste para comparar
print("Total de testes: %d" %len(validacao_dados))