text: #!-*- coding: utf8 -*-
  
  import pandas as pd
  from collections import Counter
  import numpy as np
  from sklearn.model_selection import cross_val_score
  
  
  classificacoes = pd.read_csv('emails.csv')
  
  textosPuros = classificacoes['email']
  
  textosQuebrados = textosPuros.str.lower().str.split(' ')
  
  dicionario = set()
  
  for texto in textosQuebrados:
      dicionario.update(texto)
  
  totalDePalavras = len(dicionario)
  
  tuplas = zip(dicionario, range(totalDePalavras))
  
  tradutor = {palavra:indice for palavra, indice in tuplas}
  
  def vetorizar_texto(texto, tradutor):
      vetor = [0] * len(tradutor)
  
      for palavra in texto:
          if palavra in tradutor:
              posicao = tradutor[palavra]
              vetor[posicao] += 1
      
      return vetor
  
  vetoresDeTexto = [vetorizar_texto(texto, tradutor) for texto in textosQuebrados]
  
  
  X = np.array(vetoresDeTexto)
  Y = np.array(classificacoes['classificacao'])
  
  
  porcentagem_de_treino = 0.8
  
  tamanho_de_treino = int(porcentagem_de_treino * len(Y))
  tamanho_de_validacao = len(Y) - tamanho_de_treino
  
  print(tamanho_de_treino)
  
  treino_dados = X[0:tamanho_de_treino]
  treino_marcacoes = Y[0:tamanho_de_treino]
  
  validacao_dados = X[tamanho_de_treino:]
  validacao_marcacoes = Y[tamanho_de_treino:]
  
  def fit_and_predict(nome, modelo, treino_dados, treino_marcacoes):
      k = 10
      scores = cross_val_score(modelo, treino_dados, treino_marcacoes, cv = k)
      taxa_de_acerto = np.mean(scores)
      print("Taxa de acerto do {0}: {1}".format(nome, taxa_de_acerto))
      return taxa_de_acerto
  
  def teste_real(modelo, validacao_dados, validacao_marcacoes):
      resultado = modelo.predict(validacao_dados)
  
      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)
  
  resultados = {}
  
  from sklearn.multiclass import OneVsRestClassifier
  from sklearn.svm import LinearSVC
  modeloOneVsRest = OneVsRestClassifier(LinearSVC(random_state = 0))
  resultadoOneVsRest = fit_and_predict("OneVsRest", modeloOneVsRest, treino_dados, treino_marcacoes)
  resultados[resultadoOneVsRest] = modeloOneVsRest
  
  from sklearn.multiclass import OneVsOneClassifier
  modeloOneVsOne = OneVsOneClassifier(LinearSVC(random_state = 0))
  resultadoOneVsOne = fit_and_predict("OneVsOne", modeloOneVsOne, treino_dados, treino_marcacoes)
  resultados[resultadoOneVsOne] = modeloOneVsOne 
  
  from sklearn.naive_bayes import MultinomialNB
  modeloMultinomial = MultinomialNB()
  resultadoMultinomial = fit_and_predict("MultinomialNB", modeloMultinomial, treino_dados, treino_marcacoes)
  resultados[resultadoMultinomial] = modeloMultinomial
  
  from sklearn.ensemble import AdaBoostClassifier
  modeloAdaBoost = AdaBoostClassifier(random_state=0)
  resultadoAdaBoost = fit_and_predict("AdaBoostClassifier", modeloAdaBoost, treino_dados, treino_marcacoes)
  resultados[resultadoAdaBoost] = modeloAdaBoost
  
  
  print(resultados)
  
  maximo = max(resultados)
  vencedor = resultados[maximo]
  
  print("Vencerdor: ")
  print(vencedor)
  
  vencedor.fit(treino_dados, treino_marcacoes)
  
  teste_real(vencedor, validacao_dados, validacao_marcacoes)
  
  acerto_base = max(Counter(validacao_marcacoes).values())
  taxa_de_acerto_base = 100.0 * acerto_base / len(validacao_marcacoes)
  print("Taxa de acerto base: %f" % taxa_de_acerto_base)
  
  total_de_elementos = len(validacao_dados)
  print("Total de teste: %d" % total_de_elementos)