Projeto-2-NB-Pedro_Luiz_Rafael_Libertini.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Projeto 2 - Classificador Automático de Sentimento\n",
    "\n",
    "Você foi contratado por uma empresa parar analisar como os clientes estão reagindo a um determinado produto no Twitter. A empresa deseja que você crie um programa que irá analisar as mensagens disponíveis e classificará como \"relevante\" ou \"irrelevante\". Com isso ela deseja que mensagens negativas, que denigrem o nome do produto, ou que mereçam destaque, disparem um foco de atenção da área de marketing.<br /><br />\n",
    "Como aluno de Ciência dos Dados, você lembrou do Teorema de Bayes, mais especificamente do Classificador Naive-Bayes, que é largamente utilizado em filtros anti-spam de e-mails. O classificador permite calcular qual a probabilidade de uma mensagem ser relevante dadas as palavras em seu conteúdo.<br /><br />\n",
    "Para realizar o MVP (*minimum viable product*) do projeto, você precisa implementar uma versão do classificador que \"aprende\" o que é relevante com uma base de treinamento e compara a performance dos resultados com uma base de testes.<br /><br />\n",
    "Após validado, o seu protótipo poderá também capturar e classificar automaticamente as mensagens da plataforma.\n",
    "\n",
    "## Informações do Projeto\n",
    "\n",
    "Prazo: 19/Set até às 23:59.<br />\n",
    "Grupo: 2 ou 3 pessoas - grupos com 3 pessoas terá uma rubrica diferenciada.<br /><br />\n",
    "Entregáveis via GitHub: \n",
    "* Arquivo notebook com o código do classificador, seguindo as orientações abaixo.\n",
    "* Arquivo Excel com as bases de treinamento e teste totalmente classificado.\n",
    "\n",
    "**NÃO gravar a key do professor no arquivo**\n",
    "\n",
    "\n",
    "### Entrega Intermediária: Check 1 - APS 2\n",
    "\n",
    "Até o dia 10/Set às 23:59, xlsx deve estar no Github com as seguintes evidências: \n",
    "\n",
    "  * Produto escolhido.\n",
    "  * Arquivo Excel contendo a base de treinamento e a base de testes já classificadas.\n",
    "\n",
    "Sugestão de leitura:<br />\n",
    "https://monkeylearn.com/blog/practical-explanation-naive-bayes-classifier/"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "___\n",
    "\n",
    "## Parte I - Adquirindo a Base de Dados\n",
    "\n",
    "Acessar o notebook **Projeto-2-Planilha** para realizar a coleta dos dados. O grupo deve classificar os dados coletados manualmente."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "___\n",
    "## Parte II - Montando o Classificador Naive-Bayes\n",
    "\n",
    "Com a base de treinamento montada, comece a desenvolver o classificador. Não se esqueça de implementar o Laplace Smoothing (https://en.wikipedia.org/wiki/Laplace_smoothing).\n",
    "\n",
    "Opcionalmente: \n",
    "* Limpar as mensagens removendo os caracteres: enter, :, \", ', (, ), etc. Não remover emojis.<br />\n",
    "* Corrigir separação de espaços entre palavras e/ou emojis.\n",
    "* Propor outras limpezas/transformações que não afetem a qualidade da informação.\n",
    "\n",
    "Escreva o seu código abaixo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [],
   "source": [
    "#imports \n",
    "import pandas as pd\n",
    "#é necessario realizar o comando pip install emoji\n",
    "import emoji\n",
    "import emoji_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Leitura dos arquivos em Excel\n",
    "\n",
    "nubank_treinamento = pd.read_excel('tweets_treinamento_p2.xlsx')\n",
    "nu_treino_sim = nubank_treinamento[nubank_treinamento['Avaliacao'] == 'sim']\n",
    "nu_treino_nao = nubank_treinamento[nubank_treinamento['Avaliacao'] == 'nao']\n",
    "nubank_teste = pd.read_excel('tweets_teste_p2.xlsx')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Função que recebe uma tabela com vários tweets e limpa alguns caracteres especiais e emojis do tweet e retorna a \n",
    "#mesma tabela.\n",
    "def limpar_caracteres(tabela, titulo):\n",
    "    a = tabela[titulo]\n",
    "    a = a.str.lower()\n",
    "\n",
    "    itens = ['.', ':', ';', '\"', \"'\", '?', '(', ')', '[',']',',', '\\n', '\\t']\n",
    "    i2 = ['?', '!']\n",
    "    emojis = emoji_list.all_emoji\n",
    "    for emoji in emojis:\n",
    "        try:\n",
    "            a = a.str.replace(emoji,\" {} \".format(emoji) )\n",
    "        except:\n",
    "            pass\n",
    "    for e in itens:\n",
    "        a = a.str.replace(e,'')\n",
    "    for e in i2:\n",
    "        a = a.str.replace(e,' {} '.format(e))\n",
    "\n",
    "    a = a.str.replace('é','e')\n",
    "    a = a.str.replace('ê','e')\n",
    "    a = a.str.replace('á','a')\n",
    "    a = a.str.replace('ã','a')\n",
    "    a = a.str.replace('ô','o')\n",
    "    a = a.str.replace('ó','o')\n",
    "    a = a.str.replace('ú','u')\n",
    "    a = a.str.replace('ç','c')\n",
    "    a = a.str.replace('í','i')\n",
    "    a = a.str.replace('@',' @')\n",
    "        \n",
    "    tabela[titulo] = a\n",
    "\n",
    "    return tabela\n",
    "\n",
    "#Essa função recebe a tabela que ja foi tratada com a função limpar_caracteres() e remove os últimos caracteres especiais\n",
    "#como hiperlinks, #, rt e menções (@). Nós optamos que se a citação for diretamente ao nubank (@nubank) a palavra\n",
    "#permanecerá na frase. A função retorna uma tabela com os tweets com o split, ou seja, cada tweet pertance a uma lista \n",
    "#e cada elemento dessa lista é uma palavra do tweet.\n",
    "def split_tweet(tabela, titulo):\n",
    "    a = tabela[titulo].str.split(' ')\n",
    "\n",
    "    nova = pd.DataFrame()\n",
    "    nova['palavras'] = []\n",
    "\n",
    "    for lista in a:\n",
    "        for e in ['#','' , ' ', 'rt']:\n",
    "            while lista.count(e) != 0:\n",
    "                lista.remove(e)\n",
    "\n",
    "        for palavra in lista:\n",
    "            if '@' in palavra and palavra != '@nubank':\n",
    "                lista.remove(palavra) \n",
    "            if palavra[:4] == 'http':\n",
    "                lista.remove(palavra)\n",
    "        nova = nova.append({'palavras': lista}, ignore_index=True)\n",
    "                \n",
    "    return nova\n",
    "\n",
    "#Essa função recebe a tabela tratada pela split_tweet() e retorna uma tabela com todas as palavras, sendo cada elemento\n",
    "#uma palavra.\n",
    "def tabela_palavras(tabela):\n",
    "    a = tabela['palavras']\n",
    "    prob = pd.DataFrame()\n",
    "    prob['palavras'] = []\n",
    "    for lista in a:\n",
    "        for e in lista:\n",
    "            prob = prob.append({'palavras': e}, ignore_index=True)\n",
    "    \n",
    "    return prob['palavras']\n",
    "\n",
    "#Essa função recebe 2 tabelas de palavras e retorna uma tabela com todas as palavras. Ela será utilizada para o LaPlace.\n",
    "def tabela_tudo(tabela1, tabela2):\n",
    "    a = tabela1['palavras']\n",
    "    b = tabela2['palavras']\n",
    "    tudo = pd.DataFrame()\n",
    "    tudo['palavras'] = []\n",
    "    for lista in a:\n",
    "        for e in lista:\n",
    "            tudo = tudo.append({'palavras': e}, ignore_index=True)\n",
    "    for lista in b:\n",
    "        for e in lista:\n",
    "            tudo = tudo.append({'palavras': e}, ignore_index=True)\n",
    "    \n",
    "    return tudo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/Pedro/anaconda3/lib/python3.6/site-packages/ipykernel_launcher.py:29: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: http://pandas.pydata.org/pandas-docs/stable/indexing.html#indexing-view-versus-copy\n"
     ]
    }
   ],
   "source": [
    "palavras_sim = tabela_palavras(split_tweet(limpar_caracteres(nu_treino_sim, 'Treinamento'), 'Treinamento'))\n",
    "#Series com a quantidade de vezes que cada palavra aparece\n",
    "num_sim = palavras_sim.value_counts()\n",
    "#Tamanho do Series\n",
    "len_sim = len(num_sim)\n",
    "\n",
    "palavras_nao = tabela_palavras(split_tweet(limpar_caracteres(nu_treino_nao, 'Treinamento'), 'Treinamento'))\n",
    "num_nao = palavras_nao.value_counts()\n",
    "len_nao = len(num_nao)\n",
    "\n",
    "teste = split_tweet(limpar_caracteres(nubank_teste, 'Teste'), 'Teste')\n",
    "teste = teste.join(nubank_teste['Avaliacao'])\n",
    "\n",
    "tudo = tabela_tudo(split_tweet(limpar_caracteres(nu_treino_sim, 'Treinamento'), 'Treinamento'),split_tweet(limpar_caracteres(nu_treino_nao, 'Treinamento'), 'Treinamento'))\n",
    "#Total de palavras diferentes que aparecem na base de treinamento para o LaPlace.\n",
    "total_palavras = len(tudo['palavras'].value_counts())\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "___\n",
    "## Verificando a performance\n",
    "\n",
    "Agora você deve testar o seu Classificador com a base de Testes.<br /><br /> \n",
    "\n",
    "Você deve extrair as seguintes medidas:\n",
    "* Porcentagem de positivos falsos (marcados como relevante mas não são relevantes)\n",
    "* Porcentagem de positivos verdadeiros (marcado como relevante e são relevantes)\n",
    "* Porcentagem de negativos verdadeiros (marcado como não relevante e não são relevantes)\n",
    "* Porcentagem de negativos falsos (marcado como não relevante e são relevantes)\n",
    "\n",
    "Obrigatório para grupos de 3 alunos:\n",
    "* Criar categorias intermediárias de relevância baseado na diferença de probabilidades. Exemplo: muito relevante, relevante, neutro, irrelevante e muito irrelevante."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/Pedro/anaconda3/lib/python3.6/site-packages/ipykernel_launcher.py:26: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\n",
      "\n",
      "See the caveats in the documentation: http://pandas.pydata.org/pandas-docs/stable/indexing.html#indexing-view-versus-copy\n",
      "/Users/Pedro/anaconda3/lib/python3.6/site-packages/pandas/core/indexing.py:194: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\n",
      "\n",
      "See the caveats in the documentation: http://pandas.pydata.org/pandas-docs/stable/indexing.html#indexing-view-versus-copy\n",
      "  self._setitem_with_indexer(indexer, value)\n",
      "/Users/Pedro/anaconda3/lib/python3.6/site-packages/ipykernel_launcher.py:30: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\n",
      "\n",
      "See the caveats in the documentation: http://pandas.pydata.org/pandas-docs/stable/indexing.html#indexing-view-versus-copy\n"
     ]
    }
   ],
   "source": [
    "#Aplicando o Naive Bayes\n",
    "\n",
    "i = 0\n",
    "teste[\"Avaliacao_nb\"] = pd.Series()\n",
    "teste[\"Resultado\"] = pd.Series()\n",
    "\n",
    "for linha in teste[\"palavras\"]:\n",
    "    p_sim = 1\n",
    "    p_nao = 1\n",
    "    p_naive = ''\n",
    "    for palavra in linha:\n",
    "        try:\n",
    "            #probabilidade com laplace\n",
    "            p_sim *= (num_sim[palavra] + 1)/(len_sim + total_palavras)\n",
    "            p_nao *= (num_nao[palavra] + 1)/(len_nao + total_palavras)\n",
    "        except:\n",
    "            p_sim *= 1/(len_sim + total_palavras)\n",
    "            p_nao *= 1/(len_nao + total_palavras)\n",
    "    if p_sim > p_nao:\n",
    "        p_naive = 'sim'\n",
    "        teste[\"Avaliacao_nb\"][i] = \"sim\"\n",
    "        if teste['Avaliacao'][i] == p_naive:\n",
    "            teste[\"Resultado\"][i] = \"Positivo Verdadeiro\"\n",
    "        elif teste['Avaliacao'][i] != p_naive:\n",
    "            teste[\"Resultado\"][i] = \"Positivo Falso\"\n",
    "\n",
    "    elif p_sim < p_nao:\n",
    "        p_naive = 'nao'\n",
    "        teste[\"Avaliacao_nb\"][i] = p_naive\n",
    "        if teste['Avaliacao'][i] == p_naive:\n",
    "            teste[\"Resultado\"][i] = \"Negativo Verdadeiro\"\n",
    "        elif teste['Avaliacao'][i] != p_naive:\n",
    "            teste[\"Resultado\"][i] = \"Negativo Falso\"\n",
    "    i+=1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>palavras</th>\n",
       "      <th>Avaliacao</th>\n",
       "      <th>Avaliacao_nb</th>\n",
       "      <th>Resultado</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>[queria, saber, pq, digio, e, nubank, investem...</td>\n",
       "      <td>sim</td>\n",
       "      <td>nao</td>\n",
       "      <td>Negativo Falso</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>[4, 7, ainda, nao, temos, previsao, mas, os, n...</td>\n",
       "      <td>nao</td>\n",
       "      <td>nao</td>\n",
       "      <td>Negativo Verdadeiro</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>[opa, fica, tranquilo, !, chama, a, gente, la,...</td>\n",
       "      <td>nao</td>\n",
       "      <td>nao</td>\n",
       "      <td>Negativo Verdadeiro</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>[chegou, meu, @nubank, agora, sounu, 💜]</td>\n",
       "      <td>nao</td>\n",
       "      <td>nao</td>\n",
       "      <td>Negativo Verdadeiro</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>[1, imagina, !, 💜, que, bom, que, gostou, 😉, 9...</td>\n",
       "      <td>nao</td>\n",
       "      <td>nao</td>\n",
       "      <td>Negativo Verdadeiro</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                            palavras Avaliacao Avaliacao_nb  \\\n",
       "0  [queria, saber, pq, digio, e, nubank, investem...       sim          nao   \n",
       "1  [4, 7, ainda, nao, temos, previsao, mas, os, n...       nao          nao   \n",
       "2  [opa, fica, tranquilo, !, chama, a, gente, la,...       nao          nao   \n",
       "3            [chegou, meu, @nubank, agora, sounu, 💜]       nao          nao   \n",
       "4  [1, imagina, !, 💜, que, bom, que, gostou, 😉, 9...       nao          nao   \n",
       "\n",
       "             Resultado  \n",
       "0       Negativo Falso  \n",
       "1  Negativo Verdadeiro  \n",
       "2  Negativo Verdadeiro  \n",
       "3  Negativo Verdadeiro  \n",
       "4  Negativo Verdadeiro  "
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#tabela final para comparação\n",
    "teste.head(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Negativo Verdadeiro    68.5\n",
      "Negativo Falso         18.0\n",
      "Positivo Falso          8.5\n",
      "Positivo Verdadeiro     5.0\n",
      "Name: Resultado, dtype: float64\n"
     ]
    }
   ],
   "source": [
    "#Series com as porcentagens dos resultados\n",
    "print(teste[\"Resultado\"].value_counts(normalize=True)*100)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "___\n",
    "## Concluindo\n",
    "\n",
    "Escreva aqui a sua conclusão.<br /> \n",
    "Faça um comparativo qualitativo sobre as medidas obtidas.<br />\n",
    "Explique como são tratadas as mensagens com dupla negação e sarcasmo.<br />\n",
    "Proponha um plano de expansão. Por que eles devem continuar financiando o seu projeto?<br />\n",
    "\n",
    "Opcionalmente: \n",
    "* Discorrer por que não posso alimentar minha base de Treinamento automaticamente usando o próprio classificador, aplicado a novos tweets.\n",
    "* Propor diferentes cenários de uso para o classificador Naive-Bayes. Cenários sem intersecção com este projeto.\n",
    "* Sugerir e explicar melhorias reais no classificador com indicações concretas de como implementar (não é preciso codificar, mas indicar como fazer e material de pesquisa sobre o assunto).\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A partir dos resultados obtidos do classificador Naive Bayes, observou-se uma grande porcentagem de Negativos Falsos(18%), tweets marcados como não relevantes e são relevantes, e uma baixa porcentagem de Positivos Verdadeiros(5%), tweets marcados como relevantes e são relevantes, comparando com a base de testes. Isso occoreu devido ao fato de que a base de treinamento utilizada não possui tweets suficientes para uma análise consistente e há, também, problemas e inversões de sintaxe que o programa não consegue detectar, como por exemplo as duplas negações. Já os Positivos Falsos obtiveram uma boa performance (8.5%),indicando que o classificador possui uma maior precisão ao analizar os tweets irrelevantes. Uma possīvel causa para esse comportamento é de que os tweets relevantes tem maior diversidade de conteúdo que os irrelevantes, visto que os não revelantes se encaixam em basicamente em 3 categorias: conteúdo impróprio, perguntas e citações irrelevantes ao nubank, pois na época em que os tweets foram coletados o nubank estava lançando uma playlist de músicas no spotify. Essa diferença faz com que a base de dados das palavras irrelevantes do classificador seja mais consistente, ou seja, com menos variação de palavras.\n",
    "\n",
    "A respeito dos tweets com dupla negação, pode-se dizer que: as mensagens de dupla negação e sarcasmo são interpretadas, na maioria das vezes, como tweets irrelevantes, visto que, para a nossa base de treinamento, os tweets com conotação negativa em sua maior parte são irrelevantes. Portanto, a dupla negação em um tweet classificado como relevante aumenta a P(Tweet|Irelevante), de acordo com o método do Naive Bayes, o que o classifica como irrelevante. Isso explica uma parte da grande quantidade de Negativos Falsos obtidos.\n",
    "\n",
    "O projeto \"Classificador Automático de Sentimento\" deve continuar sendo financiado devido a sua boa porcentagem de acertos de Negativos Verdadeiros (89%), com apenas uma pequena base de dados. Isso irá ajudar no filtro para responder os tweets, eliminando a necessidade de um funcionário que analisa os tweets. Dessa forma, a empresa apenas precisará de um funcionário para responder os tweets que já foram pré selecionados pelo classificador. Alguns planos de expansão para o projeto serão: o aumento da base de dados, identificar duplas negações, adicionar palavras semelhantes a certos grupos de relevância, remover artigos e preposições e obter mais níveis de classificação, como: Muito Relevante, Pouco Relevante, Neutro, Pouco Irrelevante, Muito Irrelevante. Essas melhorias irão proporcionar uma maior precisão e uma maior porcentagem de Positivos Verdadeiros.\n",
    "\n",
    "O classificador não pode ser realimentado pelos tweets classificados, pois mesmo com uma grande precisão ele ainda irá apresentar Positivos e Negativos Falsos, que são resultados de uma classificação errada do tweet. Dessa forma, a base de dados será realimentada com um erro e, portanto, esse erro será propagado, o que diminuirá a precisão do classificador, apresentando um resultado ao contrário do esperado.\n",
    "\n",
    "Durante o percorrer deste projeto, o classificador de sentimento com Naive Bayes provou-se extremamente útil. Podemos imaginar diferentes cenarios onde ele pode ser aplicado, a fim de facilitar, agiliazar e otimizar processos, como por exemplo: Em um app de streaming de música, podemos prever qual seria a avaliação de uma música a ser lançada, com base nas análises feitas por usuarios e críticos dos metadados da música."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}