Data-Science-For-Beginners/translations/pt-BR/1-Introduction/01-defining-data-science/notebook.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Desafio: Analisando Texto sobre Ciência de Dados\n",
    "\n",
    "Neste exemplo, vamos fazer um exercício simples que cobre todas as etapas de um processo tradicional de ciência de dados. Você não precisa escrever nenhum código, pode apenas clicar nas células abaixo para executá-las e observar o resultado. Como desafio, você é incentivado a testar este código com dados diferentes.\n",
    "\n",
    "## Objetivo\n",
    "\n",
    "Nesta lição, temos discutido diferentes conceitos relacionados à Ciência de Dados. Vamos tentar descobrir mais conceitos relacionados fazendo uma **mineração de texto**. Começaremos com um texto sobre Ciência de Dados, extrairemos palavras-chave dele e, em seguida, tentaremos visualizar o resultado.\n",
    "\n",
    "Como texto, vou usar a página sobre Ciência de Dados da Wikipedia:\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "url = 'https://en.wikipedia.org/wiki/Data_science'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Passo 1: Obtendo os Dados\n",
    "\n",
    "O primeiro passo em todo processo de ciência de dados é obter os dados. Usaremos a biblioteca `requests` para fazer isso:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import requests\n",
    "\n",
    "# Define a custom header.\n",
    "headers = {\n",
    "    'User-Agent': 'DataScienceChallenge/1.0 (myemail@gmail.com)'\n",
    "}\n",
    "\n",
    "# Pass the headers into the get request\n",
    "response = requests.get(url, headers=headers)\n",
    "\n",
    "if response.status_code == 200:\n",
    "    text = response.content.decode('utf-8')\n",
    "    print(text[:1000])\n",
    "else:\n",
    "    print(f\"Error: {response.status_code}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Passo 2: Transformando os Dados\n",
    "\n",
    "O próximo passo é converter os dados para a forma adequada para processamento. No nosso caso, baixamos o código-fonte HTML da página, e precisamos convertê-lo em texto simples.\n",
    "\n",
    "Existem muitas maneiras de fazer isso. Usaremos o [BeautifulSoup](https://www.crummy.com/software/BeautifulSoup/), uma biblioteca Python popular para analisar HTML. O BeautifulSoup nos permite direcionar elementos HTML específicos, assim podemos focar no conteúdo principal do artigo da Wikipedia e reduzir alguns menus de navegação, barras laterais, rodapés e outros conteúdos irrelevantes (embora algum texto padrão possa ainda permanecer).\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Primeiro, precisamos instalar a biblioteca BeautifulSoup para análise de HTML:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys\n",
    "!{sys.executable} -m pip install beautifulsoup4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from bs4 import BeautifulSoup\n",
    "\n",
    "# Parse the HTML content\n",
    "soup = BeautifulSoup(text, 'html.parser')\n",
    "\n",
    "# Extract only the main article content from Wikipedia\n",
    "# Wikipedia uses 'mw-parser-output' class for the main article content\n",
    "content = soup.find('div', class_='mw-parser-output')\n",
    "\n",
    "def clean_wikipedia_content(content_node):\n",
    "    \"\"\"Remove common non-article elements from a Wikipedia content node.\"\"\"\n",
    "    # Strip jump links, navboxes, reference lists/superscripts, edit sections, TOC, sidebars, etc.\n",
    "    selectors = [\n",
    "        '.mw-jump-link',\n",
    "        '.navbox',\n",
    "        '.reflist',\n",
    "        'sup.reference',\n",
    "        '.mw-editsection',\n",
    "        '.hatnote',\n",
    "        '.metadata',\n",
    "        '.infobox',\n",
    "        '#toc',\n",
    "        '.toc',\n",
    "        '.sidebar',\n",
    "    ]\n",
    "    for selector in selectors:\n",
    "        for el in content_node.select(selector):\n",
    "            el.decompose()\n",
    "\n",
    "if content:\n",
    "    # Clean the content node to better approximate article text only.\n",
    "    clean_wikipedia_content(content)\n",
    "    text = content.get_text(separator=' ', strip=True)\n",
    "    print(text[:1000])\n",
    "else:\n",
    "    print(\"Could not find main content. Using full page text.\")\n",
    "    text = soup.get_text(separator=' ', strip=True)\n",
    "    print(text[:1000])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Passo 3: Obtendo Insights\n",
    "\n",
    "O passo mais importante é transformar nossos dados em alguma forma da qual possamos extrair insights. No nosso caso, queremos extrair palavras-chave do texto e ver quais palavras-chave são mais significativas.\n",
    "\n",
    "Usaremos uma biblioteca Python chamada [RAKE](https://github.com/aneesha/RAKE) para extração de palavras-chave. Primeiro, vamos instalar esta biblioteca caso ela não esteja presente: \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys\n",
    "!{sys.executable} -m pip install nlp_rake"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A funcionalidade principal está disponível a partir do objeto `Rake`, que podemos personalizar usando alguns parâmetros. No nosso caso, definiremos o comprimento mínimo de uma palavra-chave para 5 caracteres, a frequência mínima de uma palavra-chave no documento para 3 e o número máximo de palavras em uma palavra-chave - para 2. Sinta-se à vontade para experimentar outros valores e observar o resultado.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import nlp_rake\n",
    "extractor = nlp_rake.Rake(max_words=2,min_freq=3,min_chars=5)\n",
    "res = extractor.apply(text)\n",
    "res"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "Obtivemos uma lista de termos junto com o grau associado de importância. Como você pode ver, as disciplinas mais relevantes, como aprendizado de máquina e big data, estão presentes na lista nas posições superiores.\n",
    "\n",
    "## Passo 4: Visualizando o Resultado\n",
    "\n",
    "As pessoas conseguem interpretar os dados melhor em forma visual. Portanto, muitas vezes faz sentido visualizar os dados para extrair alguns insights. Podemos usar a biblioteca `matplotlib` em Python para traçar uma distribuição simples das palavras-chave com sua relevância:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "def plot(pair_list):\n",
    "    k,v = zip(*pair_list)\n",
    "    plt.bar(range(len(k)),v)\n",
    "    plt.xticks(range(len(k)),k,rotation='vertical')\n",
    "    plt.show()\n",
    "\n",
    "plot(res)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Há, no entanto, uma maneira ainda melhor de visualizar as frequências de palavras - usando **Nuvem de Palavras**. Precisaremos instalar outra biblioteca para plotar a nuvem de palavras a partir da nossa lista de palavras-chave.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!{sys.executable} -m pip install wordcloud"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "O objeto `WordCloud` é responsável por receber tanto o texto original quanto uma lista pré-calculada de palavras com suas frequências, e retorna uma imagem, que pode então ser exibida usando o `matplotlib`:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from wordcloud import WordCloud\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "wc = WordCloud(background_color='white',width=800,height=600)\n",
    "plt.figure(figsize=(15,7))\n",
    "plt.imshow(wc.generate_from_frequencies({ k:v for k,v in res }))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Também podemos passar o texto original para `WordCloud` - vamos ver se conseguimos obter um resultado semelhante:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.figure(figsize=(15,7))\n",
    "plt.imshow(wc.generate(text))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "wc.generate(text).to_file('images/ds_wordcloud.png')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Você pode ver que a nuvem de palavras agora parece mais impressionante, mas também contém muito ruído (por exemplo, palavras não relacionadas como `Retrieved on`). Além disso, obtemos menos palavras-chave que consistem em duas palavras, como *data scientist* ou *computer science*. Isso ocorre porque o algoritmo RAKE faz um trabalho muito melhor na seleção de boas palavras-chave a partir do texto. Este exemplo ilustra a importância do pré-processamento e limpeza dos dados, pois uma imagem clara no final nos permitirá tomar decisões melhores.\n",
    "\n",
    "Neste exercício, passamos por um processo simples de extrair algum significado do texto da Wikipedia, na forma de palavras-chave e nuvem de palavras. Este exemplo é bastante simples, mas demonstra bem todas as etapas típicas que um cientista de dados fará ao trabalhar com dados, começando desde a aquisição dos dados até a visualização.\n",
    "\n",
    "No nosso curso, discutiremos todas essas etapas em detalhes.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n\n<!-- CO-OP TRANSLATOR DISCLAIMER START -->\n**Aviso Legal**:\nEste documento foi traduzido usando o serviço de tradução por IA [Co-op Translator](https://github.com/Azure/co-op-translator). Embora nos esforcemos pela precisão, por favor, esteja ciente de que traduções automatizadas podem conter erros ou imprecisões. O documento original em seu idioma nativo deve ser considerado a fonte autorizada. Para informações críticas, recomenda-se tradução profissional humana. Não nos responsabilizamos por quaisquer mal-entendidos ou interpretações incorretas decorrentes do uso desta tradução.\n<!-- CO-OP TRANSLATOR DISCLAIMER END -->\n"
   ]
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "c28e7b6bf4e5b397b8288a85bf0a94ea8d3585ce2b01919feb195678ec71581b"
  },
  "kernelspec": {
   "display_name": "Python 3.8.11 64-bit ('base': conda)",
   "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.11"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}