Projeto1_Layout_Classificador (1).ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Projeto 1 - Ciência dos Dados"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Objetivo do Projeto\n",
    "\n",
    "Você foi contratado por uma empresa para analisar como os clientes estão reagindo a um determinado produto no Twitter. A empresa deseja que você: crie um programa que selecione algumas mensagens disponíveis no Twitter, as quais mencionam esse particular produto; e classifique esses tweets como \"relevante\" ou \"irrelevante\", pelo menos.Com isso, essa empresa deseja que mensagens relevantes, que denigrem o nome do produto, ou que mereçam destaque, por exemplo, disparem um foco de atenção da área de marketing. 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, por exemplo. Esse classificador permite calcular qual a probabilidade de uma mensagem ser relevante dada as palavras em seu conteúdo.\n",
    "\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.\n",
    "\n",
    "Após validado, o seu protótipo poderia, porque não, também capturar e classificar automaticamente as mensagens da plataforma.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Contribuidores\n",
    "\n",
    "Nome: Larissa Jordana de Paula Soares\n",
    "\n",
    "Nome: Luis Antônio Bordignon de Oliveira"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Atenção: Serão permitidos grupos de três pessoas, mas com uma rubrica mais exigente. Grupos deste tamanho precisarão fazer um questionário de avaliação de trabalho em equipe"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "___\n",
    "Carregando algumas bibliotecas:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import os\n",
    "import emoji\n",
    "import unidecode\n",
    "import unicodedata\n",
    "import re"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Diretório utilizado:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Esperamos trabalhar no diretório\n",
      "C:\\Users\\LariLari\\Projeto1_Cdados\n"
     ]
    }
   ],
   "source": [
    "print('Esperamos trabalhar no diretório')\n",
    "print(os.getcwd())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Carregando a base de dados com os tweets classificados como (R) relevantes e (I) não relevantes do excel de treinamento e teste:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "filename = 'sony.xlsx'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "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>Treinamento</th>\n",
       "      <th>Classificação</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>se o martinho da vila pedir 01 dólar por cada ...</td>\n",
       "      <td>I</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>@jeanino_ @s9_ricardo @fuck_off_matt então a s...</td>\n",
       "      <td>I</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>2022 vai me falir dmsssss pqp caralho https://...</td>\n",
       "      <td>I</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>@luarzinmsm ata, a sony é uma vagabunda mesmo</td>\n",
       "      <td>I</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>@rafael_fenixx @raphaelvieirac4 @drakesincero1...</td>\n",
       "      <td>I</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>@formigonny acho que vai ser só sony viu...</td>\n",
       "      <td>I</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                         Treinamento Classificação\n",
       "0  se o martinho da vila pedir 01 dólar por cada ...             I\n",
       "1  @jeanino_ @s9_ricardo @fuck_off_matt então a s...             I\n",
       "2  2022 vai me falir dmsssss pqp caralho https://...             I\n",
       "3      @luarzinmsm ata, a sony é uma vagabunda mesmo             I\n",
       "4  @rafael_fenixx @raphaelvieirac4 @drakesincero1...             I\n",
       "5        @formigonny acho que vai ser só sony viu...             I"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train = pd.read_excel(filename)\n",
    "train.head(6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "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>Teste</th>\n",
       "      <th>Clasificação</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>único jogo novo anunciado pela sony que eu que...</td>\n",
       "      <td>R</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>@highlevelbeu sony no seu nivel mais belo né k...</td>\n",
       "      <td>I</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>a sony vai lançar uma sequência de jogos mt fo...</td>\n",
       "      <td>I</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>@th0rdthy gloria a sony</td>\n",
       "      <td>I</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>@paladinodoxbox sony liberou a versão do ps5, ...</td>\n",
       "      <td>I</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                               Teste Clasificação\n",
       "0  único jogo novo anunciado pela sony que eu que...            R\n",
       "1  @highlevelbeu sony no seu nivel mais belo né k...            I\n",
       "2  a sony vai lançar uma sequência de jogos mt fo...            I\n",
       "3                            @th0rdthy gloria a sony            I\n",
       "4  @paladinodoxbox sony liberou a versão do ps5, ...            I"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test = pd.read_excel(filename, sheet_name = 'Teste')\n",
    "test.head(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "___\n",
    "## Classificador automático de sentimento\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " ##### Critérios de classificação dos tweets:\n",
    "  Foram consideradas relevantes críticas à empresa sony (com contexto detectável), como a insatisfação do público por causa do pequeno tempo de duração de um filme produzido pela empresa. Também, em menor quantidade, elogios certeiros foram levados em consideração, apontando aonde a empresa acertou e deve continuar assim.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "___\n",
    "## Montando um Classificador Naive-Bayes\n",
    "\n",
    "##### Contextualização:\n",
    "\n",
    "  O algoritmo “Naive Bayes” é um classificador probabilístico muito utilizado em machine learning. Baseado no “Teorema de Bayes”, o modelo foi criado por um matemático inglês, e também ministro presibiteriano, chamado Thomas Bayes (1701 – 1761) para tentar provar a existência de Deus. Hoje é também utilizado na área de Aprendizado de Máquina (Machine Learning) para categorizar textos com base na frequência das palavras usadas. Entre as possibilidades de aplicações está a classificação de um e-mail como SPAM ou Não-SPAM e a identificação de um assunto com base em seu conteúdo. Ele recebe o nome de “naive” (ingênuo) porque desconsidera a correlação entre as variáveis (features). Ou seja, se determinada fruta é rotulada como “Limão”, caso ela também seja descrita como “Verde” e “Redonda”, o algoritmo não vai levar em consideração a correlação entre esses fatores. Isso porque trata cada um de forma independente.\n",
    "  \n",
    "  \n",
    "  \n",
    "  Fontes: https://www.datageeks.com.br/naive-bayes/\n",
    "  \n",
    "  \n",
    "  O modelo Naive Bayes é fácil de construir e particularmente útil para grandes volumes de dados. Além de simples, Naive Bayes é conhecido por ganhar de métodos de classificação altamente sofisticados. Teorema de Bayes fornece uma forma de calcular a probabilidade posterior P (C | X) a partir de P (C), P (x) e P (X | c). Note a equação abaixo:\n",
    "  \n",
    "  $P(c|x) = \\frac{P(x|c) \\cdot P(c)}{P(x)}$ $\\quad$\n",
    "  \n",
    "  \n",
    "  $\\quad\\quad P(c|X) = P(x1|c) \\cdot P(x2|c) \\cdot P(x3|c) \\cdot P(x4|C) \\cdot P(x5|c) \\cdot ... \\cdot P(xN|c) \\cdot P(c)$\n",
    "  \n",
    "  \n",
    " * P (c | x) é a probabilidade posterior da classe (c, alvo) dada preditor (x, atributos).\n",
    " * P (c) é a probabilidade original da classe.\n",
    " * P (x | c) é a probabilidade que representa a probabilidade de preditor dada a classe.\n",
    " * P (x) é a probabilidade original do preditor.\n",
    " \n",
    " \n",
    " \n",
    "  Fontes: https://www.vooo.pro/insights/6-passos-faceis-para-aprender-o-algoritmo-naive-bayes-com-o-codigo-em-python/\n",
    "  \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Agora para o nosso projeto:\n",
    "Considerando apenas as mensagens da planilha Treinamento, ensine  seu classificador."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "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>Treinamento</th>\n",
       "      <th>Classificação</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>se o martinho da vila pedir 01 dólar por cada ...</td>\n",
       "      <td>I</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>@jeanino_ @s9_ricardo @fuck_off_matt então a s...</td>\n",
       "      <td>I</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>2022 vai me falir dmsssss pqp caralho https://...</td>\n",
       "      <td>I</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>@luarzinmsm ata, a sony é uma vagabunda mesmo</td>\n",
       "      <td>I</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>@rafael_fenixx @raphaelvieirac4 @drakesincero1...</td>\n",
       "      <td>I</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                         Treinamento Classificação\n",
       "0  se o martinho da vila pedir 01 dólar por cada ...             I\n",
       "1  @jeanino_ @s9_ricardo @fuck_off_matt então a s...             I\n",
       "2  2022 vai me falir dmsssss pqp caralho https://...             I\n",
       "3      @luarzinmsm ata, a sony é uma vagabunda mesmo             I\n",
       "4  @rafael_fenixx @raphaelvieirac4 @drakesincero1...             I"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Arquivo \"sony\"\n",
    "train.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Implementação a devida Limpeza no Twitters:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "#célula de limpeza\n",
    "import functools\n",
    "import operator\n",
    "def cleanup(text):#Função de limpeza muito simples que troca alguns sinais básicos por espaços\n",
    "    #import string\n",
    "    punctuation = '[!-.:?;\"”“*)(/|[\\]]' # Note que os sinais [] são delimitadores de um conjunto.\n",
    "    pattern = re.compile(punctuation)\n",
    "    text_subbed = re.sub(pattern, '', text)\n",
    "    text_subbed = emoji.get_emoji_regexp().split(text_subbed)\n",
    "    separa = [texto.split() for texto in text_subbed]\n",
    "    text_subbed = functools.reduce(operator.concat, separa)\n",
    "    return \" \".join(text_subbed)\n",
    "\n",
    "#Função que coloca todos texto em minúsculo \n",
    "def lower(text):\n",
    "    return text.lower()\n",
    "\n",
    "#Função que remove os @ e o \"http\"\n",
    "def remove_imagem_arroba(text): \n",
    "    lista = \"\"\n",
    "    for i in text.split():\n",
    "        if i[:4]!= 'http' and i[0]!='@':\n",
    "            lista+= i + \" \"\n",
    "    return lista.strip()\n",
    "\n",
    "# Função que remove acentuação\n",
    "def remove_acentos(text):\n",
    "    text = unicodedata.normalize('NFD', text)\n",
    "    return re.sub(r'[\\u0300-\\u036f]', '', text).casefold()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Função com a implementação de todas a limpezas\n",
    "def limpeza (text):\n",
    "    text = remove_acentos(text)\n",
    "    text= lower(text)\n",
    "    text = remove_imagem_arroba(text)\n",
    "    text = cleanup(text)\n",
    "    return text"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "scrolled": false
   },
   "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>Treinamento</th>\n",
       "      <th>Classificação</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>se o martinho da vila pedir 01 dolar por cada ...</td>\n",
       "      <td>I</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>entao a sony n revela os numeros de tlou pq fr...</td>\n",
       "      <td>I</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>2022 vai me falir dmsssss pqp caralho</td>\n",
       "      <td>I</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>ata a sony e uma vagabunda mesmo</td>\n",
       "      <td>I</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>ao decorrer das decadas sony god of war 1° fra...</td>\n",
       "      <td>I</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>295</th>\n",
       "      <td>q na verdade ja tem ne pq em 2017 passava na s...</td>\n",
       "      <td>I</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>296</th>\n",
       "      <td>relevancia me diga qual foi o ultimo jogo inov...</td>\n",
       "      <td>R</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>297</th>\n",
       "      <td>thor gordo isso mesmo sony sempre fiel a mitol...</td>\n",
       "      <td>I</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>298</th>\n",
       "      <td>estranho e saber que a r conseguiu ser a unica...</td>\n",
       "      <td>I</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>299</th>\n",
       "      <td>a sony hoje esta totalmente agarrada as parcer...</td>\n",
       "      <td>I</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>300 rows × 2 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "                                           Treinamento Classificação\n",
       "0    se o martinho da vila pedir 01 dolar por cada ...             I\n",
       "1    entao a sony n revela os numeros de tlou pq fr...             I\n",
       "2                2022 vai me falir dmsssss pqp caralho             I\n",
       "3                     ata a sony e uma vagabunda mesmo             I\n",
       "4    ao decorrer das decadas sony god of war 1° fra...             I\n",
       "..                                                 ...           ...\n",
       "295  q na verdade ja tem ne pq em 2017 passava na s...             I\n",
       "296  relevancia me diga qual foi o ultimo jogo inov...             R\n",
       "297  thor gordo isso mesmo sony sempre fiel a mitol...             I\n",
       "298  estranho e saber que a r conseguiu ser a unica...             I\n",
       "299  a sony hoje esta totalmente agarrada as parcer...             I\n",
       "\n",
       "[300 rows x 2 columns]"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "num= 0\n",
    "for i in train.loc[:,'Treinamento']:\n",
    "    train.loc[num, 'Treinamento']= limpeza(i)\n",
    "    num+= 1\n",
    "train"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Primeira parte do desenvolvimento:\n",
    " Para essa segunda interação, vamos introduzir alguns calculos importantes. Sendo eles:\n",
    " * Calculo do total de palavras separadas dos tweets relevantes e irrelevantes.\n",
    " * Calculo do total de palavras separadas de dos os tweets.\n",
    " "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "300"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Separando as mensagens Relevantes e Irrelevantes da nossa base de treinamento\n",
    "Train_Relevante= train.loc[train['Classificação']=='R', 'Treinamento']\n",
    "Train_Irrelevante= train.loc[train['Classificação']=='I', 'Treinamento']\n",
    "Train_Total= train.loc[:,'Treinamento']\n",
    "train.shape[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Implementando a limpeza\n",
    "l_relevante=[]\n",
    "l_irrelevante=[]\n",
    "l_total=[]\n",
    "\n",
    "for i in Train_Relevante:\n",
    "    l_relevante.append(i)\n",
    "l_relevante= \" \".join(l_relevante).split()\n",
    "\n",
    "for i in Train_Irrelevante:\n",
    "     l_irrelevante.append(i)\n",
    "l_irrelevante= \" \".join(l_irrelevante).split()\n",
    "for i in Train_Total:\n",
    "     l_total.append(i)\n",
    "l_total= \" \".join(l_total).split()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "tab_relevante  = pd.Series(l_relevante)\n",
    "tab_irrelevante  = pd.Series(l_irrelevante)\n",
    "tab_total  = pd.Series(l_total)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###  Fazendo cálculo de frequências:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Frequencias absolutas\n",
    "tab_rel_absoluta  = tab_relevante.value_counts()\n",
    "tab_irr_absoluta  = tab_irrelevante.value_counts()\n",
    "tab_total_absoluta = tab_total.value_counts()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Frequências relativas\n",
    "tab_rel_relativa = tab_relevante.value_counts(True)\n",
    "tab_irr_relativa = tab_irrelevante.value_counts(True)\n",
    "tab_total_relativa = tab_total.value_counts(True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "palavras_separadas_total=[]\n",
    "for i in l_total:\n",
    "    if i not in palavras_separadas_total:\n",
    "        palavras_separadas_total.append(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "___\n",
    "### Montando um Classificador Naive-Bayes\n",
    "\n",
    "Considerando apenas as mensagens da planilha Treinamento, ensine  seu classificador."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Segundo desenvolvimento:\n",
    "\n",
    "##### Calcular a $P(R)$ e $P(I)$:\n",
    "   Sendo ele: \n",
    "   * $\\quad\\quad P(R) =$ $\\frac{R}{T}$ (R= total de palavras dos tweets relevantes e T= total de palavras de todos os tweets)\n",
    "   * $\\quad\\quad P(R) =$ $\\frac{I}{T}$ (I= total de palavras dos tweets irrelevantes e T= total de palavras de todos os tweets)\n",
    "   \n",
    "   \n",
    "##### em seguida:\n",
    "  Calcular $P(T|R)$ e $P(T|I)$\n",
    "  \n",
    "  Sendo:\n",
    "  * $\\quad\\quad\\quad P(palavra|R) = \\frac{Tr}{R}$\n",
    "  $\\quad\\quad\\quad Tr=$ total de vezes que a palavra apareceu nos tweets relevantes\n",
    "  \n",
    "  \n",
    "  $\\quad\\quad P(T|R) = P(palavra1|R) \\cdot P(palavra2|R) \\cdot P(palavra3|R) \\cdot P(palavra4|R) \\cdot P(palavra5|R) \\cdot ... \\cdot P(palavraN|R)$\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Calculo de P(R) e P(I)\n",
    "probR = sum(tab_rel_absoluta) / sum(tab_total_absoluta)\n",
    "\n",
    "probI = sum(tab_irr_absoluta) / sum(tab_total_absoluta)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Fazendo a limpeza\n",
    "l_test= []\n",
    "for i in test.Teste:\n",
    "    l_test.append(limpeza(i).split())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "# criando um DataFrame para o computador preencher\n",
    "\n",
    "df = {'TweetN':  [],\n",
    "        'N_Classificação': [],\n",
    "        }\n",
    "NovoDF = pd.DataFrame(df, columns = ['TweetN','N_Classificação'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Terceiro Desenvolvimento:\n",
    "\n",
    "#####  Calcular as probabilidades com a suavização de laplace tanto para os relevantes, quanto para os irrelevantes, como mostrado abaixo:\n",
    "\n",
    "\n",
    " Para relevantes:\n",
    " * $\\quad P(R|T) = \\frac{P(T \\cap R)}{P(T)}$ $\\Rightarrow$ $P(R|T) = \\frac{P(T|R) \\cdot P(R)}{P(T)}$ $\\quad$\n",
    " \n",
    " \n",
    " Para irrelevantes:\n",
    " * $\\quad P(I|T) = \\frac{P(T \\cap I)}{P(T)}$ $\\Rightarrow$ $P(I|T) = \\frac{P(T|I) \\cdot P(I)}{P(T)}$ $\\quad$\n",
    " \n",
    " \n",
    " ###### Assim, descobrindo e comparando as probabilidades pela definição dos tweet (R) para relevante e (I) para irrelevante:\n",
    " \n",
    " \n",
    " * $P(R|T)$ \n",
    "\n",
    " * $P(I|T)$\n",
    " \n",
    " * $\\quad  P(R|T) > P(I|T)$ ou $P(R|T) < P(I|T)$ $\\quad$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "# #Calculando a probabilidade de uma frase ser R ou I por Naive Bayes e a suavização de laplace\n",
    "\n",
    "# contador que acessa a linha desejada da tabela\n",
    "contador = 0\n",
    "for frase in l_test:\n",
    "    \n",
    "    probTDadoR = 1\n",
    "    for palavra in frase:\n",
    "        # Laplace smoothing\n",
    "        if palavra in tab_rel_absoluta:\n",
    "            probTDadoR*=(tab_rel_absoluta[palavra] + 1) / (len(tab_relevante) + len(palavras_separadas_total))\n",
    "        else:\n",
    "            probTDadoR*=(0 + 1) / (len(tab_relevante ) + len(palavras_separadas_total))\n",
    "                    \n",
    "    probTDadoI = 1\n",
    "    for palavra in frase:\n",
    "        # Laplace smoothing\n",
    "        if palavra in tab_irr_absoluta:\n",
    "            probTDadoI*=(tab_irr_absoluta[palavra] + 1) / (len(tab_irrelevante) + len(palavras_separadas_total))\n",
    "        else:\n",
    "            probTDadoI*=(0 + 1) / (len(tab_irrelevante) + len(palavras_separadas_total))\n",
    "      \n",
    "    probRdadoT = probTDadoR*probR  \n",
    "    probIdadoT = probTDadoI*probI\n",
    " \n",
    "  # Comparação das probabilidades e montando a tabela nova\n",
    "    if probRdadoT>probIdadoT:\n",
    "        \n",
    "        NovoDF.loc[contador,\"TweetN\"]= \" \".join(frase)\n",
    "        NovoDF.loc[NovoDF.TweetN==\" \".join(frase),\"N_Classificação\"] = \"R\"\n",
    "    \n",
    "    elif probRdadoT<probIdadoT:\n",
    "        \n",
    "        NovoDF.loc[contador,\"TweetN\"]= \" \".join(frase)\n",
    "        NovoDF.loc[NovoDF.TweetN==\" \".join(frase),\"N_Classificação\"] = \"I\"\n",
    "    \n",
    "    contador+=1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###  Verificando a performance do classificador e resultados:\n",
    "\n",
    "Agora você deve testar o seu classificador com a base de Testes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Criação de nova coluna \n",
    "NovoDF[\"Performance\"] = \" \"\n",
    "\n",
    "# verificação e preenchendo da tabela nova\n",
    "for i in range(len(NovoDF)):\n",
    "    if NovoDF.iloc[i, 1] == test.iloc[i,1]:\n",
    "        if NovoDF.iloc[i, 1] == \"R\": NovoDF.iloc[i, 2]=\"Vdd_Positivo\"\n",
    "            \n",
    "        else: NovoDF.iloc[i, 2]=\"Vdd_Negativo\"  \n",
    "    \n",
    "    elif NovoDF.iloc[i, 1] != test.iloc[i,1]:       \n",
    "        if NovoDF.iloc[i, 1] == \"R\": NovoDF.iloc[i, 2]=\"Falso_Positivo\"\n",
    "            \n",
    "        else: NovoDF.iloc[i, 2]=\"Falso_Negativo\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "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>TweetN</th>\n",
       "      <th>N_Classificação</th>\n",
       "      <th>Performance</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>unico jogo novo anunciado pela sony que eu que...</td>\n",
       "      <td>I</td>\n",
       "      <td>Falso_Negativo</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>sony no seu nivel mais belo ne kkkkkkkkkk</td>\n",
       "      <td>R</td>\n",
       "      <td>Falso_Positivo</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>a sony vai lancar uma sequencia de jogos mt fo...</td>\n",
       "      <td>R</td>\n",
       "      <td>Falso_Positivo</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>gloria a sony</td>\n",
       "      <td>I</td>\n",
       "      <td>Vdd_Negativo</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>sony liberou a versao do ps5 fonte google</td>\n",
       "      <td>I</td>\n",
       "      <td>Vdd_Negativo</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>195</th>\n",
       "      <td>pois e kkkk ao menos a sony podia ter especifi...</td>\n",
       "      <td>I</td>\n",
       "      <td>Falso_Negativo</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>196</th>\n",
       "      <td>funimation encomendando dublagens a todo vapor...</td>\n",
       "      <td>R</td>\n",
       "      <td>Falso_Positivo</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>197</th>\n",
       "      <td>quer saber tudo o que aconteceu na showcase da...</td>\n",
       "      <td>I</td>\n",
       "      <td>Vdd_Negativo</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>198</th>\n",
       "      <td>o playstation 5 bateu o recorde do playstation...</td>\n",
       "      <td>I</td>\n",
       "      <td>Vdd_Negativo</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>199</th>\n",
       "      <td>se nao for pra ofender a sony caixista nem liga</td>\n",
       "      <td>I</td>\n",
       "      <td>Vdd_Negativo</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>200 rows × 3 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "                                                TweetN N_Classificação  \\\n",
       "0    unico jogo novo anunciado pela sony que eu que...               I   \n",
       "1            sony no seu nivel mais belo ne kkkkkkkkkk               R   \n",
       "2    a sony vai lancar uma sequencia de jogos mt fo...               R   \n",
       "3                                        gloria a sony               I   \n",
       "4            sony liberou a versao do ps5 fonte google               I   \n",
       "..                                                 ...             ...   \n",
       "195  pois e kkkk ao menos a sony podia ter especifi...               I   \n",
       "196  funimation encomendando dublagens a todo vapor...               R   \n",
       "197  quer saber tudo o que aconteceu na showcase da...               I   \n",
       "198  o playstation 5 bateu o recorde do playstation...               I   \n",
       "199    se nao for pra ofender a sony caixista nem liga               I   \n",
       "\n",
       "        Performance  \n",
       "0    Falso_Negativo  \n",
       "1    Falso_Positivo  \n",
       "2    Falso_Positivo  \n",
       "3      Vdd_Negativo  \n",
       "4      Vdd_Negativo  \n",
       "..              ...  \n",
       "195  Falso_Negativo  \n",
       "196  Falso_Positivo  \n",
       "197    Vdd_Negativo  \n",
       "198    Vdd_Negativo  \n",
       "199    Vdd_Negativo  \n",
       "\n",
       "[200 rows x 3 columns]"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "NovoDF"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "14.0% Verdadeiro Positivo\n",
      "47.5% Verdadeiro Negativo\n",
      "17.5% Falso Negativo\n",
      "21.0% Falso Positivo\n"
     ]
    }
   ],
   "source": [
    "# Calculo das porcentagens\n",
    "p = NovoDF.Performance.value_counts(normalize=True).round(4)*100\n",
    "vp = p[\"Vdd_Positivo\"].round(4)\n",
    "fp = p[\"Falso_Positivo\"]\n",
    "vn = p[\"Vdd_Negativo\"]\n",
    "fn = p[\"Falso_Negativo\"]\n",
    "print(\"{0}% Verdadeiro Positivo\".format(vp))\n",
    "print(\"{0}% Verdadeiro Negativo\".format(vn))\n",
    "print(\"{0}% Falso Negativo\".format(fn))\n",
    "print(\"{0}% Falso Positivo\".format(fp))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "I    130\n",
       "R     70\n",
       "Name: N_Classificação, dtype: int64"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "NovoDF['N_Classificação'].value_counts()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "___\n",
    "### Concluindo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "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>Performance</th>\n",
       "      <th>Falso_Negativo</th>\n",
       "      <th>Falso_Positivo</th>\n",
       "      <th>Vdd_Negativo</th>\n",
       "      <th>Vdd_Positivo</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>N_Classificação</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>I</th>\n",
       "      <td>17.5</td>\n",
       "      <td>0.0</td>\n",
       "      <td>47.5</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>R</th>\n",
       "      <td>0.0</td>\n",
       "      <td>21.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>14.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "Performance      Falso_Negativo  Falso_Positivo  Vdd_Negativo  Vdd_Positivo\n",
       "N_Classificação                                                            \n",
       "I                          17.5             0.0          47.5           0.0\n",
       "R                           0.0            21.0           0.0          14.0"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Distrubuição de acertos\n",
    "d_Acertos= pd.crosstab(NovoDF[\"N_Classificação\"],NovoDF['Performance'], normalize=True).round(4)*100\n",
    "d_Acertos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A porcentagem de acerto é de 61.5%\n",
      "A porcentagem de erro é de 38.5%\n"
     ]
    }
   ],
   "source": [
    "# Acertos e erros\n",
    "acerto = p[\"Vdd_Positivo\"] + p[\"Vdd_Negativo\"]\n",
    "acertos = acerto.round(5)\n",
    "erro = p[\"Falso_Positivo\"] + p[\"Falso_Negativo\"]\n",
    "erros = erro.round(5)\n",
    "print(\"A porcentagem de acerto é de {0}%\".format(acerto))\n",
    "print(\"A porcentagem de erro é de {0}%\".format(erro))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Análise:\n",
    "\n",
    "   Para o desenvolvimento do projeto, foi utilizado uma base de dados de 500 tweets, sendo eles 300 para base de treinamento e 200 para a base de teste. A base de teste tinha 130 tweets irrelevantes e 70 relevantes. O classificador obteve uma performance aceitável, visto que teve uma precisão de 61.5% de acerto, considerando pequeno o tamanho da base de dados utilizada e que não foi realizada a classificação avançada.\n",
    "  \n",
    "### Mensagens com dupla negação e sarcasmo:\n",
    "\n",
    "   A dupla negação e o sarcasmo não são identificados, já que o classificador trata eles indiferentemente, não conseguindo interpretar o contexto das frases, assim fazendo com que o programa não consiga diferenciar a negação e o sarcasmo. O classificador interpreta a palavra como um elemento independente e não inserido em um contexto de frase ou texto. O único momento do projeto que foi percebido a influência do sarcasmo e dupla negação foi na classificação dos tweets no excel, feito manualmente pela dupla, onde foi realizado o próprio julgamento dos autores do projeto sobre o que deve ser relevante ou não.\n",
    "    \n",
    "### Conclusão:\n",
    "\n",
    "   \n",
    "    \n",
    "#### Por qual motivo devem continuar a investir no nosso projeto:\n",
    "\n",
    "   Tendo em vista o tamanho da base de dados, é possível expandi-la, tendo uma base de dados maior com mais tweets, onde será possível extrair mais informações relevantes, assim igualando a quantidades de tweets relevantes e irrelevantes, para que o classificador tenha um parâmetro melhor para definir um tweet como relevante ou irrelevante. O projeto tem como intuito ajudar a empresa \"Sony\" em varias áreas, como: marketing, desenvolvimento de filmes e desenvolvimento de jogos. Isso porque os tweets coletados têm mensagens negativas em relação aos jogos que poderiam ser mais elaborados, filmes que poderiam ter mais tempo de duração, entre outras informações extraídas. Por conta dessa disponibilidade de informações, o projeto pode acrescentar melhorias à empresa em vários aspectos, tendo assim respostas mais positivas em seus produtos, gerando mais vendas e maior lucro.\n",
    "\n",
    "    \n",
    "#### Diferente cenário para Naïve Bayes fora do contexto do projeto:\n",
    "\n",
    "   * Detecção de fraudes: identificar se uma transação financeira é “legal” ou “suspeita”.\n",
    "   * Programas de filtragem de spam: detectar se e-mail é “normal” ou “spam”.\n",
    "   * Aprovação de crédito: classificar um cliente como de “alto”, “médio” ou “baixo” risco para a concessão de crédito."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "___\n",
    "### Qualidade do Classificador a partir de novas separações dos tweets entre Treinamento e Teste\n",
    "\n",
    "Caso for fazer esse item do Projeto"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "___\n",
    "## Aperfeiçoamento:\n",
    "\n",
    "Trabalhos que conseguirem pelo menos conceito B vão evoluir em conceito dependendo da quantidade de itens avançados:\n",
    "\n",
    "* IMPLEMENTOU outras limpezas e transformações que não afetem a qualidade da informação contida nos tweets. Ex: stemming, lemmatization, stopwords\n",
    "* CORRIGIU separação de espaços entre palavras e emojis ou entre emojis e emojis\n",
    "* CRIOU categorias intermediárias de relevância baseadas na probabilidade: ex.: muito relevante, relevante, neutro, irrelevante, muito irrelevante. Pelo menos quatro categorias, com adição de mais tweets na base, conforme enunciado. (OBRIGATÓRIO PARA TRIOS, sem contar como item avançado)\n",
    "* EXPLICOU porquê não pode usar o próprio classificador para gerar mais amostras de treinamento\n",
    "* PROPÔS diferentes cenários para Naïve Bayes fora do contexto do projeto\n",
    "* SUGERIU e EXPLICOU melhorias reais com indicações concretas de como implementar (indicar como fazer e indicar material de pesquisa)\n",
    "* FEZ o item 6. Qualidade do Classificador a partir de novas separações dos tweets entre Treinamento e Teste descrito no enunciado do projeto (OBRIGATÓRIO para conceitos A ou A+)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "___\n",
    "## Referências"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Naive Bayes and Text Classification](https://arxiv.org/pdf/1410.5329.pdf)  **Mais completo**\n",
    "\n",
    "[A practical explanation of a Naive Bayes Classifier](https://monkeylearn.com/blog/practical-explanation-naive-bayes-classifier/) **Mais simples**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "https://www.youtube.com/watch?v=F_gYj6fcSl4 **Ensina como remover os acentos**\n",
    "\n",
    "\n",
    "https://gist.github.com/luizomf/54b58615cd674db44153470c369a8284 **git do Youtube**\n",
    "\n",
    "***Contextualização do Naive Bayes:*** https://www.datageeks.com.br/naive-bayes/ & https://www.vooo.pro/insights/6-passos-faceis-para-aprender-o-algoritmo-naive-bayes-com-o-codigo-em-python/"
   ]
  },
  {
   "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.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}