Aula06_Exercicio_Texto_Camoes_Machado_MLcomBayes.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "___\n",
    "# Exercício: <p> <center>  Camões&Lusíadas - Tomando decisão com Teorema de Bayes\n",
    "___\n",
    "\n",
    "## Aula 06"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "___\n",
    "<div id=\"indice\"></div>\n",
    "\n",
    "\n",
    "## Índice\n",
    "\n",
    "- [Análise \"Os Lusíadas\" vs \"Dom Casmurro\"](#analise-lusiadas-vs-dom-casmurro)\n",
    "    - [Limpeza das bases](#limpeza-das-bases)\n",
    "    - [Tabelas de frequências: Dom Casmurro](#tabelas-de-frequencias-dom-casmurro)\n",
    "        - [Frequências absolutas](#frequencias-absolutas-casmurro)\n",
    "        - [Frequências relativas](#frequencias-relativas-casmurro)\n",
    "    - [Tabelas de frequências: Os Lusíadas](#tabelas-de-frequencias-os-lusiadas)\n",
    "- [Probabilidades](#probabilidades)\n",
    "- [Probabilidades na língua portuguesa](#probabilidades-na-lingua-portuguesa)\n",
    "- [Classificação: Lusíadas ou Dom Casmurro?](#classificacao-lusiadas-ou-dom-casmurro)\n",
    "    - [A ingenuidade - Naïve Bayes](#a-ingenuidade-naive-bayes)\n",
    "\n",
    "- [O que você deve fazer](#o-que-voce-deve-fazer)\n",
    "    - [Exercício 1](#ex1) **- APS3 disponível no Blackboard**\n",
    "    - [Exercício 2](#ex2) **- APS3 disponível no Blackboard**\n",
    "    - [Exercício 3](#ex3) **- APS3 disponível no Blackboard**\n",
    "    - [Exercício 4](#ex4) **- APS3 disponível no Blackboard**\n",
    "- [O que você deve pesquisar para fazer o Projeto 1](#o-que-pesquisar)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "___\n",
    "### Este notebook é uma prévia para o Projeto 1.\n",
    "\n",
    "### A técnica apresentada neste notebook foi usada para resolver [um problema histórico de autoria de documentos](https://priceonomics.com/how-statistics-solved-a-175-year-old-mystery-about/).\n",
    "\n",
    "### Leia [esta referência do Prof. Sebastian Raschka](https://arxiv.org/pdf/1410.5329.pdf) após concluir esta atividade. Também existe [em formato de blog](https://sebastianraschka.com/Articles/2014_naive_bayes_1.html)\n",
    "___\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 393,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "from IPython.display import display\n",
    "pd.options.display.max_rows = 13"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Abaixo definimos uma função de limpeza simples, que usaremos nos trechos de texto analizados"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 394,
   "metadata": {},
   "outputs": [],
   "source": [
    "# https://docs.python.org/3/library/re.html#\n",
    "import re \n",
    "\n",
    "\n",
    "def cleanup(text):\n",
    "    \"\"\"\n",
    "        Função de limpeza muito simples que troca alguns sinais básicos por espaços\n",
    "    \"\"\"\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",
    "    return text_subbed\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Avaliando funcionamento da função `cleanup()`:**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 395,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'A não ´ \" ser que haja ! várias : pontuações ; excluir tudo ? não de novo A que haja haja haja'"
      ]
     },
     "execution_count": 395,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "texto = f'A não ´ \" ser que haja ! várias : pontuações ; excluir tudo ? não de novo A que haja haja haja'\n",
    "texto"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 396,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "23"
      ]
     },
     "execution_count": 396,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(texto.split())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 397,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "23"
      ]
     },
     "execution_count": 397,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(pd.Series(texto.split()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 398,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'A não   ser que haja  várias  pontuações  excluir tudo  não de novo A que haja haja haja'"
      ]
     },
     "execution_count": 398,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Limpa texto mas não guarda limpeza\n",
    "cleanup(texto)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 399,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'A não   ser que haja  várias  pontuações  excluir tudo  não de novo A que haja haja haja'"
      ]
     },
     "execution_count": 399,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "texto = cleanup(texto)\n",
    "texto"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 400,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'A não   ser que haja  várias  pontuações  excluir tudo  não de novo A que haja haja haja'"
      ]
     },
     "execution_count": 400,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Se quiser guardar texto limpo no mesmoo objeto, então:\n",
    "texto = cleanup(texto)\n",
    "texto"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div id=\"analise-lusiadas-vs-dom-casmurro\"></div>\n",
    "\n",
    "## Análise \"Os Lusíadas\" vs \"Dom Casmurro\"\n",
    "\n",
    "Vamos analisar as obras Dom Casmurro, de [Machado de Assis](http://machado.mec.gov.br/) e Os Lusíadas, de [Luis Vaz de Camões](https://pt.wikipedia.org/wiki/Lu%C3%ADs_de_Cam%C3%B5es). Ambas as obras são de domínio público e foram obtidas no site do [Projeto Gutenberg](https://www.gutenberg.org/wiki/PT_Principal).\n",
    "\n",
    "Nosso objetivo é: dada uma frase extraída de alguma das duas obras, identificar a qual obra a frase pertence.\n",
    "Ou seja, queremos classificar uma frase como pertencendo a \"Os Lusíadas\" ou a \"Dom Casmurro\". \n",
    "\n",
    "Para isso temos somente a informação de quais **palavras constituem a frase**. Como podemos utilizar as palavras para descobrir a qual obra a frase pertence? Você deve ter algum conhecido que sempre usa alguma palavra um pouco estranha ou diferente que somente ele/ela usa. A intuição no nosso caso é semelhante: cada autor deve ter algumas palavras específicas que usa com mais frequência do que o outro autor. Se isso for verdade, poderíamos tentar descobrir qual é a obra dependendo de quais palavras aparecem na frase.\n",
    "\n",
    "Vamos pensar em termos de probabilidade. A informação que temos disponível sobre a frase são as palavras. Assim, temos os seguintes eventos:\n",
    "\n",
    "- $Casmurro$: a frase foi extraída da obra \"Dom Casmurro\";\n",
    "- $Lusíadas$: a frase foi extraída da obra \"Os Lusíadas\";\n",
    "- $frase$: uma determinada frase foi encontrada.\n",
    "\n",
    "Utilizamos $w_i$ como um nome genérico para qualquer palavra utilizada em algum dos textos.\n",
    "\n",
    "A partir das palavras contidas na frase, queremos calcular a probabilidade da frase ter sido extraída de \"Dom Casmurro\" ou de \"Os Lusíadas\". Traduzindo em termos de probabilidades:\n",
    "\n",
    "- $P(Casmurro|frase)$: probabilidade da obra original ser \"Dom Casmurro\" dado a frase;\n",
    "- $P(Lusíadas|frase)$: probabilidade da obra original ser \"Os Lusíadas\" dado a frase.\n",
    "\n",
    "Se $P(Casmurro|frase) > P(Lusíadas|frase)$ classificaremos a frase como extraída de \"Dom Casmurro\", senão, classificaremos como \"Os Lusíadas\". Mas como podemos calcular essas probabilidades?\n",
    "\n",
    "Vimos na atividade da aula (dataset do Titanic), que é possível utilizar o **Teorema de Bayes** para obter uma probabilidade condicional $P(Casmurro|frase)$ da seguinta forma:\n",
    "\n",
    "$$P(Casmurro|frase) = \\frac{P(frase|Casmurro) P(Casmurro)}{P(frase)}$$\n",
    "\n",
    "<br>\n",
    "\n",
    "<br>\n",
    "\n",
    "O processo é análogo para $P(Lusíadas|frase)$:\n",
    "\n",
    "$$P(Lusíadas|frase) = \\frac{P(frase|Lusíadas) P(Lusíadas)}{P(frase)}$$\n",
    "\n",
    "Ou seja, precisamos de: \n",
    "- $P(frase|Casmurro)$: probabilidade de encontrar a frase na obra \"Dom Casmurro\";\n",
    "- $P(frase|Lusíadas)$: probabilidade de encontrar a frase na obra \"Os Lusíadas\";\n",
    "- $P(Casmurro)$: probabilidade da obra original ser \"Dom Casmurro\";\n",
    "- $P(Lusíadas)$: probabilidade da obra original ser \"Os Lusíadas\";\n",
    "- $P(frase)$: probabilidade de uma frase ocorrer na língua portuguesa.\n",
    "\n",
    "Veremos que temos como conseguir estimativas de todas essas probabilidades. Assim poderemos obter as probabilidades desejadas. \n",
    "\n",
    "**Observação**: classificadores como o que vamos construir, que utilizam a regra de Bayes para calcular as probabilidades, são chamados Classificadores Bayesianos. Na verdade, vamos utilizar uma simplificação, conhecida como **Naïve Bayes**.\n",
    "\n",
    "Vamos começar carregando o texto de cada obra."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 401,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Esperamos trabalhar no diretório: \n",
      "c:\\Users\\ribei\\OneDrive\\Área de Trabalho\\cdados\\cdados\n",
      "\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "print(f'Esperamos trabalhar no diretório: \\n{os.getcwd()}\\n')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 402,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['.git',\n",
       " 'Aula00_Atividade_ExploratoriaManipularDF_Introdução.ipynb',\n",
       " 'Aula01_Atividade_Manipular_Filtrar_DF.ipynb',\n",
       " 'Aula01_Exercicio__Manipular_Filtrar_DF.ipynb',\n",
       " 'Aula02_Exercicio_TeoriaDaProbabilidade.ipynb',\n",
       " 'Aula03_Atividade_ExplorandoVariaveisQualitativas.ipynb',\n",
       " 'Aula03_Exercicio_ExplorandoVariaveisQualitativas.ipynb',\n",
       " 'Aula04_Atividade_Titanic_ClassificadorBayes.ipynb',\n",
       " 'Aula05_Atividade_ExplorandoVariaveisQuantitativas.ipynb',\n",
       " 'Aula06_Exercicio_Texto_Camoes_Machado_MLcomBayes.ipynb',\n",
       " 'barrachoco.jpg',\n",
       " 'domcasmurro_texto.txt',\n",
       " 'empresaTV.jpg',\n",
       " 'EmpresaTV_Cod.xlsx',\n",
       " 'figura_media.png',\n",
       " 'figura_mediana.png',\n",
       " 'figura_mediana_nimpar.png',\n",
       " 'figura_mediana_npar.png',\n",
       " 'figura_quantil.png',\n",
       " 'figura_quartil.png',\n",
       " 'figura_variabilidade.png',\n",
       " 'flavors_of_cacao.xlsx',\n",
       " 'Gapminder.xlsx',\n",
       " 'lusiadas_texto.txt',\n",
       " 'README.md',\n",
       " 'titanic.jpeg',\n",
       " 'titanic.xlsx',\n",
       " 'WorldBank.xlsx']"
      ]
     },
     "execution_count": 402,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "os.listdir()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 403,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Parece que o arquivo lusiadas_texto.txt está na pasta diretório correto, yay!\n"
     ]
    }
   ],
   "source": [
    "filename = 'lusiadas_texto.txt'\n",
    "\n",
    "if filename in os.listdir():\n",
    "    print(f'Parece que o arquivo {filename} está na pasta diretório correto, yay!')\n",
    "    \n",
    "else:\n",
    "    print(f'Não encontrei o arquivo {filename}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 404,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Parece que o arquivo domcasmurro_texto.txt está na pasta diretório correto, yay!\n"
     ]
    }
   ],
   "source": [
    "filename = 'domcasmurro_texto.txt'\n",
    "\n",
    "if filename in os.listdir():\n",
    "    print(f'Parece que o arquivo {filename} está na pasta diretório correto, yay!')\n",
    "    \n",
    "else:\n",
    "    print(f'Não encontrei o arquivo {filename}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 405,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Luís Vaz de Camões\n",
      "Os Lusíadas\n",
      "\n",
      "Canto Primeiro\n",
      "\n",
      "1\n",
      "As armas e os barões assinalados,\n",
      "Que da ocidental praia Lusitana,\n",
      "Por mares nunca de antes navegados,\n",
      "Passaram ainda além da Taprobana,\n",
      "Em perigos e \n"
     ]
    }
   ],
   "source": [
    "# Carrega o arquivo de texto\n",
    "# Como ele possui caracteres com acentos, precisamos carregar utilizando o encoding=\"utf8\".\n",
    "with open(\"lusiadas_texto.txt\", \"r\", encoding=\"utf-8-sig\") as arquivo_texto:\n",
    "    lusiadas_raw = arquivo_texto.read()\n",
    "\n",
    "# Imprime os 200 primeiros caracteres do texto para verificar se está tudo ok.\n",
    "print(lusiadas_raw[0:200])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 406,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "DOM CASMURRO\n",
      "\n",
      "POR\n",
      "\n",
      "MACHADO DE ASSIS\n",
      "\n",
      "DA ACADEMIA BRAZILEIRA\n",
      "\n",
      "H. GARNIER, LIVREIRO-EDITOR\n",
      "\n",
      "RUA MOREIRA CEZAR, 71\n",
      "\n",
      "RIO DE JANEIRO\n",
      "\n",
      "6, RUE DES SAINTS-PÈRES, 6\n",
      "\n",
      "PARIZ\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "I\n",
      "\n",
      "Do titulo.\n",
      "\n",
      "Uma noite destas, \n"
     ]
    }
   ],
   "source": [
    "with open(\"domcasmurro_texto.txt\", \"r\", encoding=\"utf-8-sig\") as arquivo_texto:\n",
    "    casmurro_raw = arquivo_texto.read()\n",
    "\n",
    "# Imprime os 200 primeiros caracteres do texto para verificar se está tudo ok.\n",
    "print(casmurro_raw[0:200])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div id=\"limpeza-das-bases\"></div>\n",
    "\n",
    "### Limpezas das bases\n",
    "\n",
    "Em nossa análise será necessário calcular a frequência das palavras no texto. Entretanto, o Python diferencia caracteres maiúsculos (e.g. `'A'` ou `'B'`) de minúsculos (e.g. `'a'` e `'b'`). Por isso, vamos converter todo o texto para letras minúsculas com `.lower()`.\n",
    "\n",
    "Além disso, apesar de serem importantes para a língua, vamos simplificar nossa análise removendo sinais de pontuação. Para isso vamos aplicar uma limpeza rudimentar com a função `cleanup()` definida anteriormente."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 407,
   "metadata": {},
   "outputs": [],
   "source": [
    "lusiadas = cleanup(lusiadas_raw.lower())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 408,
   "metadata": {},
   "outputs": [],
   "source": [
    "casmurro = cleanup(casmurro_raw.lower())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vamos inspecionar  os arquivos após limpeza visualizando os 200 primeiros caracteres"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 409,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "luís vaz de camões\n",
      "os lusíadas\n",
      "\n",
      "canto primeiro\n",
      "\n",
      "1\n",
      "as armas e os barões assinalados\n",
      "que da ocidental praia lusitana\n",
      "por mares nunca de antes navegados\n",
      "passaram ainda além da taprobana\n",
      "em perigos e guer\n"
     ]
    }
   ],
   "source": [
    "print(lusiadas[0:200])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 410,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dom casmurro\n",
      "\n",
      "por\n",
      "\n",
      "machado de assis\n",
      "\n",
      "da academia brazileira\n",
      "\n",
      "h garnier livreiroeditor\n",
      "\n",
      "rua moreira cezar 71\n",
      "\n",
      "rio de janeiro\n",
      "\n",
      "6 rue des saintspères 6\n",
      "\n",
      "pariz\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "i\n",
      "\n",
      "do titulo\n",
      "\n",
      "uma noite destas vindo da \n"
     ]
    }
   ],
   "source": [
    "print(casmurro[0:200])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div id=\"tabelas-de-frequencias-dom-casmurro\"></div>\n",
    "\n",
    "### Tabelas de frequências: Dom Casmurro"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Primeiro, vamos quebrar o texto em palavras utilizando o comando `.split()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 411,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['dom',\n",
       " 'casmurro',\n",
       " 'por',\n",
       " 'machado',\n",
       " 'de',\n",
       " 'assis',\n",
       " 'da',\n",
       " 'academia',\n",
       " 'brazileira',\n",
       " 'h']"
      ]
     },
     "execution_count": 411,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Verificando o uso do split para as primeiras 10 palavras\n",
    "casmurro.split()[0:10]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nosso objetivo é contar as palavras de cada texto, ou seja, construir a tabela de frequência absoluta para as palavras de cada obra. \n",
    "\n",
    "Assim, vamos converter as obras (strings contendo o texto completo) em objetos do tipo `pd.Series`, nos quais cada elemento é uma palavra. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 412,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0           dom\n",
       "1      casmurro\n",
       "2           por\n",
       "3       machado\n",
       "4            de\n",
       "5         assis\n",
       "6            da\n",
       "7      academia\n",
       "8    brazileira\n",
       "9             h\n",
       "dtype: object"
      ]
     },
     "execution_count": 412,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Quebrando o texto em palavras\n",
    "todas_palavras_casmurro = casmurro.split()\n",
    "\n",
    "# Guardando as palavras como um pd.Series\n",
    "serie_casmurro = pd.Series(todas_palavras_casmurro)\n",
    "serie_casmurro.head(10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div id=\"frequencias-absolutas-casmurro\"></div>\n",
    "\n",
    "#### Frequências absolutas"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Palavras em um texto são variáveis **qualitativas nominais**, portanto usaremos `value_counts()` para obter a tabela de frequências relativas e absolutas:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 413,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "cru             1\n",
       "aches           1\n",
       "dantes          1\n",
       "esperteza       1\n",
       "critica         1\n",
       "               ..\n",
       "austera         1\n",
       "metto           1\n",
       "exclusivismo    1\n",
       "castissima      1\n",
       "lxxih           1\n",
       "Length: 15, dtype: int64"
      ]
     },
     "execution_count": 413,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Como serie_casmurro é uma pd.Series, podemos usar value_counts() nessa variável\n",
    "tabela_casmurro = serie_casmurro.value_counts()\n",
    "tabela_casmurro.tail(15)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div id=\"frequencias-relativas-casmurro\"></div>\n",
    "\n",
    "#### Frequências relativas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 414,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "que    0.040500\n",
       "a      0.038141\n",
       "e      0.033256\n",
       "de     0.030044\n",
       "o      0.025996\n",
       "não    0.023134\n",
       "um     0.011902\n",
       "é      0.010806\n",
       "os     0.010106\n",
       "da     0.009573\n",
       "do     0.009482\n",
       "mas    0.009239\n",
       "se     0.008630\n",
       "dtype: float64"
      ]
     },
     "execution_count": 414,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tabela_casmurro_relativa = serie_casmurro.value_counts(True)\n",
    "tabela_casmurro_relativa.head(13)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "É de se estranhar a linha abaixo?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 415,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9999999999999998"
      ]
     },
     "execution_count": 415,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tabela_casmurro_relativa.sum()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "Agora faremos exatamente os mesmos passos de converter em `Series` e obter as tabelas de frequência para a obra \"Os Lusíadas\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div id=\"tabelas-de-frequencias-os-lusiadas\"></div>\n",
    "\n",
    "### Tabelas de frequências: \"Os Lusíadas\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 416,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['luís',\n",
       " 'vaz',\n",
       " 'de',\n",
       " 'camões',\n",
       " 'os',\n",
       " 'lusíadas',\n",
       " 'canto',\n",
       " 'primeiro',\n",
       " '1',\n",
       " 'as']"
      ]
     },
     "execution_count": 416,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Verificando o uso do split para as primeiras 10 palavras\n",
    "lusiadas.split()[0:10]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 417,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0        luís\n",
       "1         vaz\n",
       "2          de\n",
       "3      camões\n",
       "4          os\n",
       "5    lusíadas\n",
       "6       canto\n",
       "7    primeiro\n",
       "8           1\n",
       "9          as\n",
       "dtype: object"
      ]
     },
     "execution_count": 417,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Quebrando o texto em palavras\n",
    "todas_palavras_lusiadas = lusiadas.split()\n",
    "\n",
    "# Guardando as palavras como um pd.Series\n",
    "serie_lusiadas = pd.Series(todas_palavras_lusiadas)\n",
    "serie_lusiadas.head(10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div id=\"frequencias-absolutas-lusiadas\"></div>\n",
    "\n",
    "#### Frequências absolutas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 418,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Não funciona porque é lista e não pd.Series. Comando value_counts() funciona com pd.Sereis\n",
    "#todas_palavras_lusiadas.value_counts() "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 419,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Aqui a lista foi redefinida como pd.Series(). Então comando value_counts() funciona.\n",
    "#serie_lusiadas.value_counts() "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 420,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "denegrida      1\n",
       "gotas          1\n",
       "caíam          1\n",
       "antolha        1\n",
       "romperam       1\n",
       "pecou          1\n",
       "desque         1\n",
       "conversação    1\n",
       "adversárias    1\n",
       "montanhas      1\n",
       "atalhavam      1\n",
       "tracto         1\n",
       "trudante       1\n",
       "dtype: int64"
      ]
     },
     "execution_count": 420,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tabela_lusiadas = serie_lusiadas.value_counts()\n",
    "tabela_lusiadas.tail(13)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 421,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "56367"
      ]
     },
     "execution_count": 421,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tabela_lusiadas.sum()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div id=\"frequencias-relativas-lusiadas\"></div>\n",
    "\n",
    "#### Frequências relativas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 422,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "que            0.048628\n",
       "e              0.038994\n",
       "o              0.033335\n",
       "a              0.031827\n",
       "de             0.025228\n",
       "                 ...   \n",
       "adversárias    0.000018\n",
       "montanhas      0.000018\n",
       "atalhavam      0.000018\n",
       "tracto         0.000018\n",
       "trudante       0.000018\n",
       "Length: 9277, dtype: float64"
      ]
     },
     "execution_count": 422,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tabela_lusiadas_relativa = serie_lusiadas.value_counts(True)\n",
    "tabela_lusiadas_relativa"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 423,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9999999999999999"
      ]
     },
     "execution_count": 423,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tabela_lusiadas_relativa.sum()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div id=\"probabilidades\"></div>\n",
    "\n",
    "## Probabilidades\n",
    "\n",
    "Relembrando, queremos descobrir, dentre outras coisas, a probabilidade de uma frase ocorrer em uma das obras. Para isso, vamos assumir uma simplificação **bastante ingênua** de que a probabilidade de uma palavra da frase ocorrer em uma obra é independente da probabilidade de qualquer outra palavra. Assim, assumindo independência, **a probabilidade da frase é igual ao produto das probabilidades de cada palavra individualmente**.\n",
    "\n",
    "Vamos assumir para fins destas análises que **a frequência relativa observada nestes textos é igual à probabilidade**. Ou seja, que se quisermos encontrar $P(portugal|Lusíadas)$ basta checar a frequência da palavra `'portugal'`: `tabela_lusiadas_relativa[\"portugal\"]` (note que o acesso é semelhante ao acesso a um dicionário).\n",
    "\n",
    "Ou seja, a $P(portugal|Lusíadas)$  pode ser obtida buscando a frequência relativa da palavra `portugal` dentro da tabela do texto Os Lusíadas:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 424,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.0001951496442954211"
      ]
     },
     "execution_count": 424,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tabela_lusiadas_relativa[\"portugal\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Da mesma fora, se quisermos $P(capitú|casmurro)$ basta checar: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 425,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.005220461774957003"
      ]
     },
     "execution_count": 425,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tabela_casmurro_relativa[\"capitú\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notamos que na versão do *Gutenberg* a palavra *Capitú* aparece grafada com acento."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div id=\"probabilidades-na-lingua-portuguesa\"></div>\n",
    "\n",
    "## Probabilidades na língua portuguesa\n",
    "\n",
    "Vamos fazer mais uma simplificação. Vamos assumir que o todo da língua portuguesa fosse formado pela fusão das obras *Dom Casmurro* e *Os Lusíadas*.\n",
    "\n",
    "Nesse caso, vamos juntar os dois textos já limpos pela função `cleanup` que foram guardados em  `lusiadas` e `casmurro`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 426,
   "metadata": {},
   "outputs": [],
   "source": [
    "portugues = lusiadas + casmurro"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vamos repetir os passos anteriores quebrando o texto guardando em `portugues` em palavras e depois guardá-lo em uma `pd.Series()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 427,
   "metadata": {},
   "outputs": [],
   "source": [
    "todas_palavras_portugues = portugues.split()\n",
    "serie_portugues = pd.Series(todas_palavras_portugues)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos refazer a análise de probabilidades considerando este novo *corpus* de texto que contem as duas obras:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 428,
   "metadata": {},
   "outputs": [],
   "source": [
    "tabela_portugues = serie_portugues.value_counts()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 429,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "que           0.044253\n",
       "e             0.035906\n",
       "a             0.035226\n",
       "o             0.029385\n",
       "de            0.027820\n",
       "                ...   \n",
       "abrochado     0.000008\n",
       "camafeu       0.000008\n",
       "bandós        0.000008\n",
       "sibilantes    0.000008\n",
       "lxxih         0.000008\n",
       "Length: 16577, dtype: float64"
      ]
     },
     "execution_count": 429,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tabela_portugues_relativa = serie_portugues.value_counts(True)\n",
    "tabela_portugues_relativa"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Desta forma, se quisermos saber a probabilidade da palavra *pintura* em toda a \"língua portuguesa\", a notação seria simplesmente $P(pintura)$ porque estamos a assumir que trabalhamos com a totalidade da língua, ou seja **o conjunto universo**.\n",
    "\n",
    "Assim, a probabilidade $P(pintura)$ é:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 430,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.00010649627263045793"
      ]
     },
     "execution_count": 430,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tabela_portugues_relativa[\"pintura\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div id=\"classificacao-lusiadas-ou-dom-casmurro\"></div>\n",
    "\n",
    "## Classificação de uma frase: Lusíadas ou Dom Casmurro?\n",
    "\n",
    "Agora vamos ao problema que queremos resolver.\n",
    "\n",
    "Você precisa dizer se a **frase**: \n",
    "\n",
    "$\\quad$ **\"Contou que João como santo se verá vestido, de maneira  que virão a barba do marido\"**\n",
    "\n",
    "é mais provável de ter vindo de *Os Lusíadas* ou de *Dom Casmurro*.\n",
    "\n",
    "Ou seja, precisa decidir: \n",
    "\n",
    "$\\quad \\Rightarrow$ Se $P(Casmurro|frase) > P(Lusíadas|frase)$, então frase será classificada como de *Dom Casmurro*\n",
    "\n",
    "$\\quad \\Rightarrow$ Se $P(Casmurro|frase) < P(Lusíadas|frase)$, então frase será classificada como de *Os Lusíadas*\n",
    "\n",
    "\n",
    "<br>\n",
    "\n",
    "A partir deste ponto, vamos denotar $Casmurro$ como $C$ e $Lusíadas$ como $L$ para brevidade.\n",
    "\n",
    "O **Teorema de Bayes** vai ser particularmente útil neste caso. Lembre-se que:\n",
    "\n",
    "$\\quad P(C|frase) = \\frac{P(frase|C)P(C)}{P(frase)}$\n",
    "\n",
    "e que:\n",
    "\n",
    "$\\quad P(L|frase) = \\frac{P(frase|L)P(L)}{P(frase)}$\n",
    "\n",
    "\n",
    "<br>\n",
    "Teremos que calcular **TODAS** as probabilidades que se encontram no lado direito das equações acima e com elas calcular $P(C|frase)$ e $P(L|frase)$.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Frase a classificar:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 431,
   "metadata": {},
   "outputs": [],
   "source": [
    "frase = \"Contou que João como santo se verá vestido, de maneira  que virão a barba do marido\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Todo o preparo que as obras passaram, devem se repetir na frase.\n",
    "\n",
    "Vamos converter primeiro em minúsculas e fazer a limpeza:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 432,
   "metadata": {},
   "outputs": [],
   "source": [
    "frase = cleanup(frase.lower())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Agora a frase está assim:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 433,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'contou que joão como santo se verá vestido de maneira  que virão a barba do marido'"
      ]
     },
     "execution_count": 433,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "frase"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Em forma de lista, para facilitar o processamento:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 434,
   "metadata": {},
   "outputs": [],
   "source": [
    "frase = frase.split()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div id=\"a-ingenuidade-naive-bayes\"></div>\n",
    "\n",
    "### A ingenuidade - Naïve Bayes\n",
    "\n",
    "Agora vamos à parte ingênua do Naïve Bayes, que consiste em assumir que as palavras são independentes entre si e que sua ordem na frase não importa. \n",
    "\n",
    "\n",
    "Ou seja:\n",
    "\n",
    "$\\quad P(frase|C) = \n",
    "P(contou|C)\\cdot P(que|C)\\cdot P(joão|C)\\cdot P(como|C)\\cdot P(santo|C)\\cdot P(se|C)\\cdot P(verá|C)\\cdot P(vestido|C)\\cdot P(de|C)\\cdot...$\n",
    "$\\qquad\\qquad\\qquad\\quad ...\\cdot P(maneira|C)\\cdot P(que|C)\\cdot P(virão|C)\\cdot P(a|C)\\cdot P(barba|C)\\cdot P(do|C)\\cdot P(marido|C)$\n",
    "\n",
    "<br>\n",
    "\n",
    "Vamos denotar **Dom Casmurro** simplesmente como $C$, para encurtar a fórmula a seguir aplicando o uso do Teorema de Bayes.\n",
    "\n",
    "Assim, a fórmula completa fica:\n",
    "\n",
    "$P(C|frase) = \\frac{P(contou|C).P(que|C).P(joão|C).P(como|C).P(santo|C).P(se|C).P(verá|C).P(vestido|C).P(de|C).P(maneira|C).P(que|C).P(virão|C).P(a|C).P(barba|C).P(do|C).P(marido|C).P(C)}{P(frase)}$\n",
    "\n",
    "<br>\n",
    "\n",
    "Da mesma forma, denotando **Os Lusíadas** como $L$, a fórmula completa fica:\n",
    "\n",
    "$P(L|frase) = \\frac{P(contou|L).P(que|L).P(joão|L).P(como|L).P(santo|L).P(se|L).P(verá|L).P(vestido|L).P(de|L).P(maneira|L).P(que|L).P(virão|L).P(a|L).P(barba|L).P(do|L).P(marido|L).P(L)}{P(frase)}$\n",
    "\n",
    "<br>\n",
    "\n",
    "Note que o denominador das duas probabilidade condicionais acima é o mesmo, para fazer a classificação da frase podemos cancelar o cálculo do denominador $P(frase)$. \n",
    "\n",
    "Assim, a **Classificação da frase** se dará conforme abaixo:\n",
    "\n",
    "$\\quad \\Rightarrow$ Se $P(C|frase) > P(L|frase)$, então frase será classificada como de *Dom Casmurro*\n",
    "\n",
    "$\\quad \\Rightarrow$ Se $P(C|frase) < P(L|frase)$, então frase será classificada como de *Os Lusíadas*\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div id=\"o-que-voce-deve-fazer\"></div>\n",
    "\n",
    "# [TAREFA] Faça os cálculos e classifique a seguinte frase:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**OBJETIVO PRINCIPAL:** O objetivo principal dessa aula é classificar a frase a seguir:\n",
    "\n",
    "* *contou que joão como santo se verá vestido de maneira  que virão a barba do marido*\n",
    "\n",
    "como sendo uma frase  pertencente ao texto do Dom Casmurro ou do Lusíadas.\n",
    "\n",
    "Para tanto, calcule as probabilidades exigidas nos Exercícios 1 a 3 para que, no Exercício 4, seja possível realizar essa classificação com o uso do Teorema de Bayes.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 435,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Frase que deverá ser classificada após realizar os exercícios a seguir é: \n",
      "\n",
      "=>   ['contou', 'que', 'joão', 'como', 'santo', 'se', 'verá', 'vestido', 'de', 'maneira', 'que', 'virão', 'a', 'barba', 'do', 'marido']\n"
     ]
    }
   ],
   "source": [
    "print(f'Frase que deverá ser classificada após realizar os exercícios a seguir é: \\n\\n'\n",
    "      f'=>   {frase}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div id=\"ex1\"></div>\n",
    "\n",
    "### EXERCÍCIO 1\n",
    "\n",
    "Como podemos calcular os valores dos priors $P(C)$ e $P(L)$ ? Ou, colocando a pergunta em termos Bayesianos: o que é um *prior* razoável para se usar?\n",
    "\n",
    "<br> \n",
    "**Dica**:\n",
    "\n",
    "Você pode usar proporção de número de palavras do conjunto *Lusíadas* e *Dom Casmurro* em relação ao total. Ou ainda proporção destas palavras ponderadas pela frequência absoluta.\n",
    "\n",
    "<br>\n",
    "\n",
    "Armazene o valor de $P(C)$ e $P(L)$ nas variáveis `probC` e `probL`, respectivamente."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 436,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.538240353895306"
      ]
     },
     "execution_count": 436,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# ESCREVA SEU CÓDIGO AQUI\n",
    "probC = tabela_casmurro.sum()/tabela_portugues.sum()\n",
    "probC"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 437,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.46175964610469405"
      ]
     },
     "execution_count": 437,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "probL = tabela_lusiadas.sum()/tabela_portugues.sum()\n",
    "probL"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div id=\"ex2\"></div>\n",
    "\n",
    "### EXERCÍCIO 2\n",
    "\n",
    "Calcule os termos: \n",
    "\n",
    "$\\quad P(frase|L) = \n",
    "P(contou|L)\\cdot P(que|L)\\cdot P(joão|L)\\cdot P(como|L)\\cdot P(santo|L)\\cdot P(se|L)\\cdot P(verá|L)\\cdot P(vestido|L)\\cdot P(de|L)\\cdot...$\n",
    "$\\qquad\\qquad\\qquad\\quad ...\\cdot P(maneira|L)\\cdot P(que|L)\\cdot P(virão|L)\\cdot P(a|L)\\cdot P(barba|L)\\cdot P(do|L)\\cdot P(marido|L)$\n",
    "\n",
    "e \n",
    "\n",
    "$\\quad P(frase|C) = \n",
    "P(contou|C)\\cdot P(que|C)\\cdot P(joão|C)\\cdot P(como|C)\\cdot P(santo|C)\\cdot P(se|C)\\cdot P(verá|C)\\cdot P(vestido|C)\\cdot P(de|C)\\cdot...$\n",
    "$\\qquad\\qquad\\qquad\\quad ...\\cdot P(maneira|C)\\cdot P(que|C)\\cdot P(virão|C)\\cdot P(a|C)\\cdot P(barba|C)\\cdot P(do|C)\\cdot P(marido|C)$\n",
    "\n",
    "<br>\n",
    "\n",
    "Armazene o valor de $P(frase|L)$ e $P(frase|C)$ nas variáveis `probFraseDadoC` e `probFraseDadoL`.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 438,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8.633953743025594e-50"
      ]
     },
     "execution_count": 438,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# ESCREVA SEU CÓDIGO AQUI\n",
    "probFraseDadoC = 1\n",
    "for palavra in frase:\n",
    "    probFraseDadoC *= tabela_casmurro_relativa[palavra]\n",
    "\n",
    "probFraseDadoC"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 439,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.2832826970284067e-48"
      ]
     },
     "execution_count": 439,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "probFraseDadoL = 1\n",
    "for palavra in frase:\n",
    "    probFraseDadoL *= tabela_lusiadas_relativa[palavra]\n",
    "\n",
    "probFraseDadoL"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div id=\"ex3\"></div>\n",
    "\n",
    "### EXERCÍCIO 3\n",
    "\n",
    "Calcule $P(L|frase)$ e $P(C|frase)$ como indicado acima. \n",
    "\n",
    "Lembre-se que não precisamos descobrir o valor de $P(frase)$, pois ele é denominador comum de ambos os lados da comparação. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 440,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5.925681640321144e-49"
      ]
     },
     "execution_count": 440,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# ESCREVA SEU CÓDIGO AQUI\n",
    "probLDadoFrase = probFraseDadoL*probL\n",
    "probLDadoFrase"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 441,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4.6471423181617975e-50"
      ]
     },
     "execution_count": 441,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "probCDadoFrase = probFraseDadoC*probC\n",
    "probCDadoFrase"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div id=\"ex4\"></div>\n",
    "\n",
    "### EXERCÍCIO 4\n",
    "\n",
    "Escreva seu parecer: você acha que o texto indicado pertence a Os Lusíadas ou a Dom Casmurro?\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 442,
   "metadata": {},
   "outputs": [],
   "source": [
    "# O texto indicado pertence a Os Lusíadas"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div id=\"o-que-pesquisar\"></div>\n",
    "\n",
    "# O que você deve pesquisar para fazer o Projeto 1:\n",
    "\n",
    "No [texto recomendado](https://arxiv.org/pdf/1410.5329.pdf) estude o que fazer quando duas situações acontecerem:\n",
    "- Quando aparecem palavras inéditas para classificar\n",
    "- Quando a multiplicação das probabilidades é um valor tão pequeno que ocorre *underflow*"
   ]
  }
 ],
 "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.10.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}