Introdução ao Sistema de Análise de Sentimentos

Este artigo apresenta um sistema completo para análise de sentimentos em redes sociais, utilizando Python como principal linguagem de programação. O sistema foi desenvolvido com uma arquitetura moderna que inclui MySQL como banco de dados, Flask como framework back end, Pandas para processamento de dados, ECharts para visualização e bibliotecas especializadas em processamento de linguagem natural.

Componentes Técnicos

• Backend: Flask framework para criação da API web
• Banco de Dados: MySQL 8 para armazenamento dos dados coletados
• Análise de Dados: Pandas para manipulação e análise estatística
• Visualização: ECharts para criação de gráficos interativos
• Processamento de Texto: Jieba para segmentação de texto, SnowNLP para análise de sentimentos
• Coleta de Dados: Requests para爬取 (web scraping) de dados do Weibo
• Nuvem de Palavras: WordCloud para visualização de termos mais frequentes

Funcionalidades Implementadas

• Sistema de autanticação de usuários (login e registro)
• Coleta automática de posts e comentários do Weibo
• Análise de frequência de termos e palavras-chave
• Análise de sentimento dos comentários
• Visualização de dados interativos com ECharts, incluindo:
  • Análise de artigos do Weibo
  • Análise de localização (IP) dos posts
  • Análise de comentários
  • Mapa de sentimentos da plataforma
• Geração de nuvens de palavras para:
  • Conteúdo dos posts
  • Comentários dos usuários
  • Usuários que mais comentam

Exemplos de Código

Processamento de Texto e Análise de Frequência

import re
import jieba
import pandas as pd
from dao import post_dao

def carregar_lista_palavras_parada():
    """
    Carrega lista de palavras de parada (stop words)
    """
    return [linha.strip() for linha in open('stopwords.txt', encoding='UTF-8').readlines()]

def processar_texto_posts():
    """
    Processa e segmenta texto dos posts
    """
    with open('posts_processados.txt', 'a+', encoding='utf-8') as arquivo:
        segmentos = segmentar_texto(post_dao.obter_todos_posts())
        arquivo.write(" ".join(segmentos))

def calcular_frequencia_palavras():
    """
    Calcula frequência das palavras, filtrando números, palavras únicas e stopwords
    """
    segmentos = segmentar_texto()
    palavras_parada = carregar_lista_palavras_parada()
    
    # Filtra números, palavras únicas e stopwords
    lista_filtrada = []
    for segmento in segmentos:
        numeros = re.search('\d+', segmento)
        if not numeros and segmento not in palavras_parada and len(segmento) > 1:
            lista_filtrada.append(segmento)
    
    # Calcula frequência
    frequencia = {}
    for palavra in set(lista_filtrada):
        frequencia[palavra] = lista_filtrada.count(palavra)
    
    # Ordena por frequência
    lista_ordenada = sorted(frequencia.items(), key=lambda x: x[1], reverse=True)
    return lista_ordenada

def segmentar_texto():
    """
    Realiza segmentação de texto dos posts
    """
    # Concatena todos os posts
    texto_completo = " ".join([post[1].strip() for post in post_dao.obter_todos_posts()])
    segmentos = jieba.cut(texto_completo)  # Modo preciso de segmentação
    return segmentos

def exportar_frequencia_para_csv(lista_frequencia):
    """
    Exporta resultados da análise de frequência para CSV
    """
    df = pd.DataFrame(lista_frequencia, columns=['Termo', 'Frequência'])
    df.to_csv('frequencia_termos.csv', index=False)

if __name__ == '__main__':
    # exportar_texto_processado()
    exportar_frequencia_para_csv(calcular_frequencia_palavras())

Geração de Nuvem de Palavras

import sys
import pandas as pd
from PIL import Image
import numpy as np
from matplotlib import pyplot as plt
from wordcloud import WordCloud

sys.path.append('processamento_texto')

def gerar_nuvem_palavras(texto, imagem_mascara, nome_saida):
    """
    Geração de nuvem de palavras personalizada
    :param texto: Texto processado com termos separados por espaço
    :param imagem_mascara: Arquivo de imagem para máscara
    :param nome_saida: Nome do arquivo de saída
    """
    # Abre imagem de máscara
    img = Image.open('./static/' + imagem_mascara)
    img_array = np.array(img)  # Converte imagem para array numpy
    
    # Configuração da nuvem de palavras
    wc = WordCloud(
        width=800, height=600,
        background_color='white',
        colormap='viridis',
        font_path='STHUPO.TTF',
        mask=img_array,
    )
    wc.generate_from_text(texto)
    
    # Exibe e salva a nuvem de palavras
    plt.imshow(wc)
    plt.axis('off')  # Oculta eixos
    
    # Salva imagem
    plt.savefig('./static/' + nome_saida, dpi=500, bbox_inches='tight')

Arquitetura do Sistema

O sistema segue uma arquitetura cliente-servidor, onde:

• O frontend utiliza ECharts para visualização interativa dos dados
• O back end Flask expõe APIs para processamento e análise
• O banco MySQL armazena os dados brutos e processados
• Módulos especializados em NLP realizam o processamento de linguagem natural

A arquitetura permite a expansão para outras plataformas de redes sociais além do Weibo, mantendo a mesma estrutura de análise e visualização.