<jupyter_start><jupyter_text>UNIVERSIDADE PRESBITERIANA MACKENZIEESPECIALIZAÇÃO EM CIÊNCIA DE DADOS (BIG DATA PROCESSING AND ANALYTICS)RECUPERAÇÃO DA INFORMAÇÃO NA WEB E EM REDES SOCIAIS*<NAME>***Processamento de Linguagem Natural: extração de palavras-chave - Articulistas UOL** **1. Introdução**Este trabalho tem o objetivo de mostrar o processamento de linguagem natural com a extração de palavras-chave de uma lista de artigos de diversos blogueiros do site de notícias UOL.   **2. Importação dos dados**Primeiramente, foram importadas todas as bibliotecas necessárias do Python e o arquivo no formato 'json' contendo os dados a serem analisados.<jupyter_code>!pip install unidecode
import pandas as pd
import matplotlib.pyplot as plt
import json
import re
import unicodedata
from unidecode import unidecode
import string
import collections
from wordcloud import WordCloud, STOPWORDS
import nltk
from nltk.corpus import stopwords
from nltk.tokenize import word_tokenize
from nltk.collocations import *
from nltk import FreqDist
from nltk.util import ngrams    
data = pd.read_json('https://raw.githubusercontent.com/mahmayer/articulistas/main/UolBlogs.json')

content = data[['content']].copy()
content.head(10)<jupyter_output><empty_output><jupyter_text>**3. Primeira Análise** **3.1. Histograma**Análise da distribuição de palavras por artigo.<jupyter_code>#Faz a contagem de palavras por cada linha do artigo
content['words'] = content['content'].str.split().str.len()

content.plot.hist(bins=30, alpha=0.8)<jupyter_output><empty_output><jupyter_text>**3.2. Primeira Nuvem de Palavras**Em seguida, foi gerada a primeira nuvem de palavras antes do pré-tratamento.<jupyter_code>text = ' '.join(content['content'])

wordcloud1 = WordCloud(collocations=False, normalize_plurals=False, stopwords=None, width=800, height=800, background_color='white', min_font_size = 10, max_words=50).generate(text)
                    
plt.figure(figsize = (8, 8), facecolor = None) 
plt.imshow(wordcloud1)
plt.axis("off")
plt.show()<jupyter_output><empty_output><jupyter_text>**4. Pré-tratamento**Nessa etapa, foram feitos os pré-tratamentos necessários. Primeiramente, foi importado a função de singularização.<jupyter_code>"""
Thanks for https://simasware.wordpress.com/2014/02/28/pluralizacao-em-pt-br-rails/
"""

INVARIAVEL = [  'lápis',
                'atlas',
                'pires',
                'ônibus',
                'vírus',
                'bônus',
                'ônus',
                'cais',
                'xis',
                'óculos',
                'ourives',
                'parabéns',
                'atras',
                'frances',
                'ingles',

            ]
def transliterate(string: str) -> str:
    # Copy from inflection Library https://github.com/jpvanhal/inflection
    """
    Replace non-ASCII characters with an ASCII approximation. If no
    approximation exists, the non-ASCII character is ignored. The string must
    be ``unicode``.
    Examples::
        >>> transliterate('älämölö')
        'alamolo'
        >>> transliterate('Ærøskøbing')
        'rskbing'
    """
    normalized = unicodedata.normalize('NFKD', string)

    return normalized.encode('ascii', 'ignore').decode('ascii')

def singularizar(PalavraOriginal):
    """ Remove acentos e deixa tudo minuscula"""
    palavra = PalavraOriginal.lower()

    for wd in INVARIAVEL:
        if transliterate(wd).lower() == palavra:
            return palavra

    """      Lista de regras, composto em tuplas de valor a ser buscado e regra de substituição    """
    rules = []

    """    Palavras terminadas em ns    """
    rules.append((r"^([a-zA-z]*)ns$", r"\1m"))

    """ Palavras terminas em r ou z luzes - luz, flores - flor, arrozes - arroz"""
    rules.append((r"^([a-zA-z]*)res$", r"\1r"))
    rules.append((r"^([a-zA-z]*)zes$", r"\1z"))
    rules.append((r"^([a-zA-z]*)ses$", r"\1s"))

    """    Palavras terminadas em ão    """
    rules.append((r"^([a-zA-z]*)oes$", r"\1ao"))
    rules.append((r"^([a-zA-z]*)aos$", r"\1ao"))
    rules.append((r"^([a-zA-z]*)aes$", r"\1ao"))

    """ Palavras regulares, casos simples: carros, arvores, aboboras"""
    rules.append((r"^([a-zA-z]*)(a|e|o|u)is$", r"\1\2l"))

    """ Palavras terminas em il  cantis - cantil """
    rules.append((r"^([a-zA-z]*)is$", r"\1il"))

    """ Palavras terminas em les  mal - males, mel - meles """
    rules.append((r"^([a-zA-z]*)les$", r"\1l"))


    """ Palavras regulares, casos simples: carros, arvores, aboboras"""
    rules.append((r"^([a-zA-z]*)(a|e|i|o|u)s$", r"\1\2"))
    
    for rule in rules:
        if re.match(rule[0], palavra) is not None:
            return re.sub(rule[0], rule[1], palavra, 1, re.IGNORECASE)
    return palavra<jupyter_output><empty_output><jupyter_text>Em seguida, transformou-se todas as letras em minúscula, removeu-se os acentos, a pontuação, os números, as palavras de parada e os plurais.<jupyter_code>nltk.download('stopwords')
stop = stopwords.words('portuguese')

content['content_treated'] = content['content'].str.lower().apply(lambda x: unidecode(x))
content['content_treated'] = content['content_treated'].str.replace('[{}]'.format(string.punctuation), '')
content['content_treated'] = content['content_treated'].str.replace('[{}]'.format(string.digits), '')
content['content_treated'] = content['content_treated'].str.lower().apply(lambda x: ' '.join([word for word in x.split() if word not in (stop)]))
content['content_treated'] = content['content_treated'].apply(lambda x: ' '.join([singularizar(word) for word in x.split()]))<jupyter_output>[nltk_data] Downloading package stopwords to /root/nltk_data...
[nltk_data]   Package stopwords is already up-to-date!<jupyter_text>**5. Resultados** **5.1. Tabela**A tabela a seguir apresenta as 10 palavras mais frequentes nos artigos com sua respectiva quantidade.<jupyter_code>#cria uma lista com todos os tokens
nltk.download('punkt')

big_line = ' '.join(sent for sent in content['content_treated'])
tokens = word_tokenize(big_line)
df = nltk.FreqDist(tokens)
df = sorted(df.items(), key=lambda x: x[1], reverse=True)
freq = pd.DataFrame.from_dict(df)
n = 0
display(freq.iloc[n:n+10])<jupyter_output>[nltk_data] Downloading package punkt to /root/nltk_data...
[nltk_data]   Package punkt is already up-to-date!<jupyter_text>**5.2. Nuvem de palavras**Após o pré-tratamento tem-se uma nova nuvem de palavras, com 50 termos mais significativos.<jupyter_code>treated_text = ' '.join(content['content_treated'])

wordcloud2 = WordCloud(collocations=False, normalize_plurals=False, stopwords=None, width=800, height=800, background_color='white', min_font_size = 10, max_words=50).generate(treated_text)
                       
plt.figure(figsize = (8, 8), facecolor = None) 
plt.imshow(wordcloud2)
plt.axis("off")
plt.show()<jupyter_output><empty_output><jupyter_text>**6. Bigramas**Nesta etapa do trabalho foi feito o tratamento por bigramas, ou seja, tokenização por um par de palavras subsequentes, para ver como ficava a frequência de termos com esse tratamento.<jupyter_code>bigram = nltk.FreqDist(nltk.bigrams(word_tokenize(treated_text)))
sorted_bigram = sorted(bigram.items(), key=lambda x: x[1], reverse=True)
tokens_bigram = dict((' '.join(text), count) for text, count in sorted_bigram)<jupyter_output><empty_output><jupyter_text>Após tratamento tem-se uma tabela com os 10 bigramas mais frequentes e uma nova nuvem de palavra formada com 50 principais bigramas.<jupyter_code>treated_text = ' '.join(content['content_treated'])

tokens = word_tokenize(treated_text)
bigram_tokens = nltk.bigrams(tokens)
bigram_fd = nltk.FreqDist(bigram_tokens)
sorted_bigram = sorted(bigram_fd.items(), key=lambda x: x[1], reverse=True)
pd_bigram = pd.DataFrame.from_dict(sorted_bigram)

pd_bigram.head(10)
wordcloud3 = WordCloud(collocations=False, normalize_plurals=False, stopwords=None, width=800, height=800, background_color='white', min_font_size = 10, max_words=50).generate_from_frequencies(tokens_bigram)
                    
plt.figure(figsize = (8, 8), facecolor = None) 
plt.imshow(wordcloud3)
plt.axis("off")
plt.show()<jupyter_output><empty_output>
{'fraction_non_alphanumeric': 0.14106967615309127, 'fraction_numerical': 0.012634936211972522, 'mean_word_length': 4.370882740447958, 'pattern_counts': {'":': 0, '<': 36, '<?xml version=': 0, '>': 43, 'https://': 3, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 4, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '9', 'dir': 'jupyter-structured-clean-dedup', 'id': '655323', 'license': 'MIT', 'n_tokens_mistral': 3032, 'n_tokens_neox': 2875, 'n_words': 648, 'path': 'Linguagem_natural_Articulistas.ipynb', 'repo_name': 'mahmayer/mackenzie', 'size': '8173'}