Naive Bayes para classificação de textos

Se há algo capaz de minar a paciência no cotidiano profissional, é o trabalho repetitivo e monótono. Refiro-me àquela tarefa tediosa de analisar planilhas extensas, repletas de textos, e categorizar cada linha individualmente. Já enfrentei essa situação diversas vezes; a lembrança mais marcante é de um projeto onde recebíamos centenas de comentários diários de clientes em uma única planilha. Eram feedbacks variados sobre um produto, desde elogios entusiasmados a reclamações pontuais ou sugestões para novas funcionalidades. Em teoria, a tarefa era direta: ler cada comentário e atribuí-lo a uma categoria como "Relato de Bug", "Solicitação de Funcionalidade", "Sugestão Geral" ou "Elogio".

Inicialmente, éramos dois revezando, e conseguíamos acompanhar o ritmo. Contudo, o volume só aumentava. Chegou um ponto em que eu dedicava aproximadamente duas horas por dia a essa atividade, e o pior: a classificação carecia de consistência. O que para mim era um "Relato de Bug", meu colega, por vezes, classificava como "Sugestão Geral" se o usuário não mencionasse explicitamente a palavra "bug", mesmo com uma descrição clara do problema. Isso gerou uma grande dificuldade na elaboração de relatórios, pois os dados estavam comprometidos. Observando a pilha de texto crescer incessantemente na planilha, percebi: "Isso não é escalável. Preciso encontrar uma maneira de automatizar, nem que seja para me dar um ponto de partida."

Foi nesse contexto que me veio à mente um conceito que havia explorado superficialmente anos antes: a classificação de texto. Dentre todas as abordagens, o Naive Bayes sempre pareceu a opção mais pragmática para começar, especialmente para quem não deseja se aprofundar em redes neurais complexas logo de cara. Não exigia um supercomputador, funcionava perfeitamente no meu ambiente local e, crucialmente, entregava resultados concretos para um desafio muito real que eu estava vivenciando com aquela planilha.

Por que Naive Bayes? A simplicidade que salva o dia

Ao iniciar a busca por uma solução para a classificação dos comentários na planilha, a primeira inclinação foi considerar algo ultrassofisticado, como os vastos modelos de linguagem gerados por inteligência artificial. No entanto, respirei fundo. Meu propósito não era criar um robô filósofo, mas sim categorizar textos de maneira eficiente e com uma precisão aceitável. Necessitava de algo relativamente simples de implementar, que processasse rapidamente e não demandasse uma quantidade exorbitante de dados rotulados. E, mais importante, algo que pudesse integrar ao meu ecossistema de planilhas e Python sem a necessidade de reescrever tudo do zero.

O Naive Bayes, apesar de seu nome que evoca certa erudição, encaixa-se perfeitamente nessa descrição. Trata-se de um algoritmo de classificação probabilística fundamentado no Teorema de Bayes, mas com uma "ingenuidade" peculiar: ele assume que a ocorrência de uma palavra em um texto é independente da ocorrência de qualquer outra palavra, desde que a categoria do texto seja conhecida. Parece uma simplificação drástica, não é? E de fato é! Contudo, essa simplificação é o que o torna tão ágil e eficaz, especialmente para a classificação textual.

Em meu cenário, onde precisava categorizar comentários em poucas classes bem definidas, essa "ingenuidade" era uma vantagem. Eu não precisava que o modelo discernisse o sarcasmo ou a ironia do cliente (ainda bem, pois isso tornaria o problema consideravelmente mais difícil). Bastava que ele identificasse padrões de palavras que sinalizassem um "bug" ou uma "funcionalidade". Por exemplo, se um comentário contivesse "erro", "não funciona", "trava", a probabilidade de ser um "Relato de Bug" aumentava. Caso tivesse "gostaria de", "sugiro", "seria bom se", as chances de ser uma "Solicitação de Funcionalidade" se elevavam.

Sua grande vantagem reside na contagem. Essencialmente, o algoritmo aprende a probabilidade de cada palavra surgir em cada categoria. Se a palavra "erro" aparece com muito mais frequência em "Relato de Bug" do que em "Elogio", o modelo absorve essa informação. Posteriormente, ao deparar-se com um novo texto, ele calcula qual categoria possui a maior probabilidade de ter gerado aquele conjunto específico de palavras. Simples assim. Essa clareza foi o que me motivou a experimentá-lo.

Desmistificando o Algoritmo: Como Naive Bayes Vê o Texto

Para que um algoritmo como o Naive Bayes (ou qualquer outro que processe texto) possa funcionar, as palavras devem ser convertidas em representações numéricas. Essa é a ponte essencial entre a linguagem humana e a lógica matemática da máquina. Esse processo envolve algumas etapas que, para quem lida com dados, são quase um rito.

Pré-processamento: Limpar a bagunça

Primeiramente, é fundamental higienizar o texto. Se você já trabalhou com dados provenientes de formulários de feedback, e-mails ou redes sociais, sabe que eles chegam brutos. Pontuação, caracteres especiais, links, números – tudo isso pode contaminar o texto e confundir o modelo. Minha abordagem usual inclui:

• Minúsculas: Converto todo o texto para minúsculas. Para o modelo, "Erro" e "erro" são a mesma entidade; caso contrário, seriam tratadas como palavras distintas, diluindo sua frequência real.
• Remover pontuação e números: Pontos, vírgulas, exclamações, interrogações, e algarismos. A menos que números sejam genuinamente pertinentes para sua classificação (como em números de série), eles apenas geram ruído. Expressões regulares são ferramentas valiosas aqui.
• Remover stopwords: Palavras como "de", "a", "o", "e", "para" são ubíquas em qualquer idioma e em todas as categorias. Elas adicionam ruído e não contribuem para que o modelo diferencie as classes. Bibliotecas como NLTK em Python já oferecem listas de stopwords prontas para o português.
• Lematização ou Stemming (Opcional, mas útil): Reduzir as palavras às suas formas primitivas. "Rodando", "rodar", "rodei" se transformariam em "rodar". Isso auxilia no agrupamento de variações da mesma palavra, embora possa ser um pouco mais complexo de implementar e nem sempre é imprescindível para um bom início. No meu caso inicial, a remoção de stopwords e pontuação já representou um avanço significativo.

Vetorização: Transformando palavras em números

Após a etapa de limpeza, o próximo passo consiste em transformar esse texto purificado em algo que o algoritmo possa processar: um vetor numérico.

• Bag-of-Words (BoW): A contagem simplificada.

  A maneira mais elementar e eficaz de converter texto em números é utilizando o modelo Bag-of-Words (Saco de Palavras). Imagine cada texto como um "saco" de palavras, onde a ordem não tem relevância; apenas a frequência de cada palavra importa. O processo é direto: você constrói um vocabulário com todas as palavras únicas que apareceram no seu conjunto de textos. Em seguida, para cada texto, você contabiliza quantas vezes cada palavra desse vocabulário ocorre. O resultado é um vetor numérico. Por exemplo:

  Vocabulário: ["o", "aplicativo", "é", "lento", "e", "trava", "muito"]

  Texto 1: "O aplicativo é lento"

  Vetor 1: [1, 1, 1, 1, 0, 0, 0] (representando a contagem de "o", "aplicativo", "é", "lento", etc.)

  Texto 2: "O aplicativo trava muito"

  Vetor 2: [1, 1, 0, 0, 0, 1, 1] (representando a contagem de "o", "aplicativo", "trava", "muito")

  Esta é uma abordagem extremamente direta e, para o Naive Bayes, funciona admiravelmente, dado que ele se baseia em contagens e probabilidades.

• TF-IDF: Atribuindo peso às palavras.

  TF-IDF (Term Frequency-Inverse Document Frequency) representa uma evolução mais refinada do modelo Bag-of-Words. Ele não se limita a contabilizar a frequência de uma palavra em um documento (Term Frequency - TF), mas também avalia quão incomum ou comum essa palavra é em todo o corpus de documentos (Inverse Document Frequency - IDF). O propósito é conceder maior importância a palavras que surgem frequentemente em um documento específico, mas são raras no conjunto total de documentos. Essa técnica auxilia na identificação de termos que são verdadeiramente distintivos para um determinado texto.

  Na prática, o TF-IDF tende a reduzir o peso de palavras muito comuns (como "aplicativo" no meu exemplo, que surgiria em quase todos os feedbacks) e a elevar o peso de palavras mais específicas (como "trava" ou "bug", que indicam um problema). Geralmente, eu testo tanto o BoW quanto o TF-IDF para determinar qual se adapta melhor ao meu tipo de texto e ao problema em questão. Para a classificação de textos curtos e com categorias bem distintas, o BoW costuma ser bastante competitivo e mais rápido de calcular.

A Matemática por Trás (Bem por Cima): O Teorema de Bayes na prática

Sem aprofundar em pormenores matemáticos complexos, a premissa central do Teorema de Bayes, neste contexto, é calcular a probabilidade de um texto pertencer a uma categoria específica, considerando o conjunto de palavras que ele contém. A fórmula é:

P(Categoria | Texto) = P(Texto | Categoria) * P(Categoria) / P(Texto)

• P(Categoria | Texto): É o que buscamos determinar – a probabilidade de o texto se enquadrar em uma categoria particular.
• P(Texto | Categoria): A probabilidade de aquele texto específico ocorrer, dada a categoria. É aqui que entra a "ingenuidade" do Naive Bayes: ele simplifica isso para o produto das probabilidades de cada palavra do texto aparecer naquela categoria. Ou seja, se o texto contém as palavras "A" e "B", ele calcula P(A|Categoria) * P(B|Categoria).
• P(Categoria): A probabilidade de uma categoria surgir, independentemente do texto. Se 80% dos seus feedbacks são "Elogios", a probabilidade P(Elogio) é elevada.
• P(Texto): A probabilidade de um texto específico surgir. Geralmente, este é um fator de normalização que não precisamos calcular diretamente, pois nosso objetivo é apenas comparar as probabilidades entre as diferentes categorias.

Em suma, o modelo registra a frequência de cada palavra em cada categoria dentro do seu conjunto de treinamento. Baseando-se nessas contagens, ele consegue estimar as probabilidades e, para um novo texto, "infere" a categoria que melhor se alinha aos padrões de palavras aprendidos. Essa simplicidade, para mim, foi decisiva.

Construindo o Classificador: Da Planilha ao Python e de Volta

Chegou a hora de aplicar o conhecimento, transformando a teoria em uma solução funcional para minhas planilhas do Google.

Passo 1: Coletando e Rotulando os Dados. A parte chata, mas vital.

Não há atalhos mágicos. Para treinar um Naive Bayes a classificar, são necessários exemplos. Muitos, e cuidadosamente rotulados. No meu caso, isso implicou em selecionar uma amostra dos comentários da planilha e categorizá-los manualmente. Essa foi a etapa mais demorada e, confesso, exaustiva. No entanto, sem ela, o modelo não existiria.

Criei uma nova coluna na minha planilha, nomeada "Categoria Manual", e iniciei o preenchimento. Para otimizar o processo, desenvolvi um pequeno script em Apps Script que, ao selecionar uma célula de texto, abria um menu lateral com botões correspondentes às categorias ("Relato de Bug", "Solicitação de Funcionalidade", etc.). Clicar no botão preenchia a célula na coluna "Categoria Manual". Não era uma automação que rotulava sozinha, mas um atalho que me poupou inúmeros cliques e erros de digitação. Esse conjunto de dados rotulado tornou-se o alicerce do meu treinamento.

Passo 2: O Código Python na Prática

Com os dados devidamente rotulados, a próxima fase é o ambiente Python. Utilizo `pandas` para a manipulação dos dados, `scikit-learn` para o algoritmo classificador e `gspread` para a interação com o Google Sheets. Meu fluxo de trabalho inicial era o seguinte:

1. Obter os dados da Planilha:

   Geralmente, recorro ao `gspread` para essa finalidade. Autentico a API do Google Sheets e leio a planilha diretamente. É um método muito mais prático do que a exportação constante para CSV. Se a planilha for muito extensa ou tiver restrições de API, exporto-a para CSV ou JSON e a leio com `pandas` localmente. Para o treinamento inicial, uma amostra de algumas centenas ou milhares de linhas já era suficiente.

   // Exemplo conceitual de como pegar os dados
   import gspread
   import pandas as pd
   gs = gspread.service_account(filename='caminho/para/sua/credencial.json')
   spreadsheet = gs.open("Nome da Minha Planilha de Feedbacks")
   worksheet = spreadsheet.worksheet("Dados para Treino")
   data = worksheet.get_all_records()
   df = pd.DataFrame(data)
   texts = df['Comentário'].astype(str)
   labels = df['Categoria Manual']

2. Pré-processar os textos:

   Desenvolvo uma função para limpar os textos (converter para minúsculas, remover pontuação, eliminar stopwords). Aplico essa função à coluna que contém o texto.

3. Vetorizar os textos:

   Emprego `CountVectorizer` ou `TfidfVectorizer` do `scikit-learn`.

   // Exemplo conceitual de vetorização e treino
   from sklearn.feature_extraction.text import CountVectorizer
   from sklearn.naive_bayes import MultinomialNB
   from sklearn.model_selection import train_test_split
   vectorizer = CountVectorizer() // Ou TfidfVectorizer()
   X = vectorizer.fit_transform(texts)
   y = labels
   X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
   model = MultinomialNB()
   model.fit(X_train, y_train)
   predictions = model.predict(X_test)

4. Treinar e avaliar o modelo:

   Divido os dados em conjuntos de treinamento e teste, treino o `MultinomialNB` e analiso as métricas de desempenho (acurácia, f1-score). Se o resultado for satisfatório para o problema, salvo o modelo e o vetorizador utilizando `joblib` ou `pickle`.

Passo 3: Integrando com Google Sheets via Apps Script e APIs

O objetivo final era que a classificação ocorresse de forma autônoma para os novos comentários que chegavam à planilha. Isso exigia uma conexão entre a planilha (Apps Script) e o modelo Python. A solução que implementei foi a criação de uma API simplificada.

1. API Python (Cloud Function ou similar):

   Encapsulei meu modelo Python (já treinado e persistido) em uma função que pudesse ser invocada via requisição HTTP POST. Utilizo bastante o Google Cloud Functions para isso: carrego meu script Python lá, onde ele carrega o modelo salvo e o vetorizador na inicialização. Quando uma requisição POST chega contendo um texto, ele pré-processa, vetoriza com o vetorizador que foi salvo junto com o modelo, realiza a predição e retorna a categoria em formato JSON.

   // Exemplo conceitual da função Python para a API
   import pickle
   import joblib
   import functions_framework
   @functions_framework.http
   def classify_text(request):
       request_json = request.get_json(silent=True)
       text_to_classify = request_json['text']
       // Carregar modelo e vetorizador (uma vez na inicialização da função)
       // Pré-processar o texto
       // Vetorizar o texto
       // Fazer a predição
       return {'category': 'Categoria Predita'}

2. Apps Script para disparar a automação:

   Na planilha, criei um script em Apps Script que monitorava uma coluna específica (por exemplo, "Comentário Novo"). Sempre que um novo comentário era adicionado e a coluna "Categoria Predita" estivesse vazia, o script disparava uma requisição HTTP para minha Cloud Function. A resposta JSON da API era então utilizada para preencher a coluna "Categoria Predita" na mesma linha da planilha.

   // Exemplo conceitual de Apps Script para chamar a API
   function classifyNewComments() {
     var sheet = SpreadsheetApp.getActiveSpreadsheet().getSheetByName("Comentários"); // Nome da sua aba
     var range = sheet.getDataRange();
     var values = range.getValues();
     var header = values[0];
     var textColIndex = header.indexOf("Comentário"); // Coluna do texto
     var categoryColIndex = header.indexOf("Categoria Predita"); // Coluna para preencher
     var apiEndpoint = "URL_DA_SUA_CLOUD_FUNCTION";
     for (var i = 1; i < values.length; i++) { // Começa da linha 1 (ignora cabeçalho)
       var text = values[i][textColIndex];
       var currentCategory = values[i][categoryColIndex];
       if (text && !currentCategory) { // Se tem texto e a categoria está vazia
         var payload = JSON.stringify({text: text});
         var options = {
           'method' : 'post',
           'contentType': 'application/json',
           'payload' : payload
         };
         try {
           var response = UrlFetchApp.fetch(apiEndpoint, options);
           var jsonResponse = JSON.parse(response.getContentText());
           sheet.getRange(i + 1, categoryColIndex + 1).setValue(jsonResponse.category);
         } catch (e) {
           Logger.log("Erro ao classificar: " + e.toString());
         }
       }
     }
   }

   Implementei um `onEdit` ou um `time-driven trigger` (com execução, por exemplo, a cada 15 minutos) para que esse script fosse executado automaticamente, classificando os novos comentários. O resultado? Centenas de comentários categorizados em poucos segundos, com uma precisão satisfatória para nossas necessidades. A inconsistência diminuiu drasticamente, e eu recuperei aquelas duas horas diárias que antes eram perdidas.

Embora esta abordagem não represente o "estado da arte" em IA, ela resolveu um problema concreto, economizou tempo e conferiu consistência à análise de dados que eu e minha equipe tanto precisávamos. É a prova de que a solução mais complexa nem sempre é a ideal.

4 Dicas Práticas Testadas

• 1. Comece com conjuntos de treinamento modestos: Não é preciso esperar ter um milhão de amostras rotuladas para dar o pontapé inicial. Eu comecei com cerca de 500 linhas de comentários que classifiquei manualmente na planilha. Com essa base, já foi possível construir um modelo rudimentar. Posteriormente, fui adicionando mais dados e retreinando o modelo, em um processo iterativo. O fundamental é possuir dados suficientes para cada categoria, mesmo que em número reduzido.
• 2. A limpeza de texto representa a maior parte do esforço (e dos desafios): Dediquei um tempo considerável a expressões regulares e à experimentação de diversas remoções de caracteres especiais, URLs, e-mails, entre outros. Uma função de limpeza mal elaborada é o caminho mais curto para um modelo ineficaz. Verifique o que resta dos seus textos após a limpeza; por vezes, um "texto limpo" ainda contém bastante lixo que seu `CountVectorizer` tentará processar.
• 3. Compare Bag-of-Words (BoW) com TF-IDF: Embora o TF-IDF seja frequentemente aclamado como "superior", isso nem sempre se aplica a todos os cenários. Para textos muito curtos ou com vocabulários específicos para cada categoria, o BoW pode ser mais eficaz e mais rápido. No meu caso, os comentários eram relativamente concisos, e a diferença de desempenho não justificou a complexidade adicional do TF-IDF em termos de processamento. Teste ambos e observe qual entrega as melhores métricas para o seu problema.
• 4. Valide seus resultados e não confie cegamente no modelo: Após o modelo estar em operação, sempre seleciono uma amostra dos textos classificados automaticamente para revisão manual. Por vezes, o modelo comete erros que as métricas gerais não revelam. Essa prática me auxilia a identificar as falhas e a adicionar mais dados de treinamento para aquelas situações problemáticas. Criei uma flag "Revisado" na planilha para esses casos.
• 5. Monitore e retreine periodicamente: A linguagem é dinâmica. Novos termos surgem, ou a maneira como as pessoas descrevem "bugs" ou "funcionalidades" pode evoluir. Meu modelo Naive Bayes, após alguns meses, começou a apresentar uma leve queda de desempenho em certas categorias. Foi preciso coletar dados mais recentes, rotulá-los e retreiná-lo. A automação não é uma solução "configure e esqueça" eterna; exige manutenção contínua.

SEÇÃO "Erros que já cometi ou vi cometerem"

Cometer erros é uma parte inerente do aprendizado. Com o Naive Bayes, especialmente no início, enfrentei algumas falhas que me causaram grande dor de cabeça. E presenciei outros colegas cometerem erros semelhantes.

• 1. Limpeza de dados deficiente, ou excessiva: Lembro-me de um projeto onde o modelo parecia operar aleatoriamente. Após extensa depuração, percebi que eu não estava removendo URLs e códigos internos que os usuários copiavam e colavam. O modelo estava tentando classificar textos com base em sequências de números e letras de links quebrados ou códigos de erro! Ele estava interpretando um certo padrão de URL como extremamente relevante para uma categoria. Em outra ocasião, fui tão agressivo na limpeza que acabei removendo palavras cruciais para a classificação, como "acesso" ou "login", que eram essenciais para uma categoria de "Problemas de Acesso". O equilíbrio na limpeza é fundamental.
• 2. Treinar com poucas amostras para categorias minoritárias: Eu tinha uma categoria "Outros" que servia como um repositório para tudo que não se encaixava. Ela contava com apenas cerca de 50 exemplos. Em contraste, a categoria "Elogio" possuía uns 5000. O modelo, de forma inteligente, sempre tendia a classificar tudo como "Elogio" ou nas categorias com maior volume de dados. Ele agia de forma "preguiçosa", estatisticamente preferindo a maioria. Tive de realizar um tedioso trabalho manual para coletar mais exemplos para a categoria "Outros" ou empregar técnicas de oversampling (duplicar exemplos da minoria) ou undersampling (reduzir exemplos da maioria) para equilibrar o dataset.
• 3. Presumir que o modelo "compreende" o texto como um humano: Minha maior frustração inicial foi com a ironia. Um feedback como "O sistema é UMA MARAVILHA, só trava a cada 5 minutos e exclui meus dados." O modelo identificava "maravilha", "sistema" e classificava como "Elogio". Eu ficava indignado! No entanto, o Naive Bayes não decifra sarcasmo; ele apenas conta palavras. Tive de aceitar que, para problemas dessa natureza, seria necessário algo muito mais avançado, ou uma etapa de revisão humana. É crucial conhecer as limitações do algoritmo que se está utilizando.
• 4. Falha em versionar o modelo e o vetorizador: Houve uma vez em que retreinei o modelo com dados novos e, inadvertidamente, perdi a versão antiga. Sem querer, o novo modelo era inferior, mas eu não tinha como reverter para o anterior. Pior ainda, retreinei o `CountVectorizer` com os dados atualizados, e ele alterou a ordem das palavras no vocabulário! Quando tentei carregar o modelo antigo com o novo vetorizador, tudo falhou, pois as colunas de "palavras" já não correspondiam. Desde então, salvo o modelo E o vetorizador em conjunto, e os versiono como qualquer outro código.

FAQ

P1: Qual é a principal limitação do Naive Bayes para a classificação de texto?

A limitação mais significativa reside na suposição de independência entre as palavras (a "ingenuidade" do algoritmo). Ele assume que a presença de uma palavra em um texto não influencia a presença de outra, considerando-se a categoria. Na realidade, as palavras possuem dependências contextuais. Por exemplo, na frase "não gostei", a palavra "não" nega o sentido de "gostei", mas o Naive Bayes pode ter dificuldade em captar essa relação complexa, tratando "não" e "gostei" como eventos isolados. Isso implica que ele enfrenta desafios com nuances, ironia, sarcasmo ou frases onde a ordem das palavras altera drasticamente o significado.

P2: Quando devo considerar o uso de outro algoritmo (além do Naive Bayes) para classificação de texto?

Recomenda-se considerar outras alternativas quando a complexidade semântica do texto for elevada, ou quando o contexto e a sequência das palavras forem determinantes para a classificação. Por exemplo, se a tarefa for classificar sentimentos muito sutis, identificar ironia, ou lidar com textos extensos e que abordam múltiplos temas. Nessas situações, algoritmos como SVMs (Support Vector Machines), Random Forests ou, em abordagens mais modernas, modelos baseados em redes neurais como LSTMs, GRUs ou Transformers (a exemplo do BERT e suas variantes) podem oferecer um desempenho superior, pois são capazes de aprender representações mais ricas e contextuais do texto, embora com um custo consideravelmente maior em termos de complexidade, volume de dados e poder computacional.

Em suma, o Naive Bayes não é a solução definitiva em IA e, certamente, não resolverá todos os problemas de texto existentes. No entanto, para muitos dos desafios de classificação textual que encontro no dia a dia, especialmente quando o volume de dados é grande e as categorias são nítidas e bem definidas, ele entrega o que promete: é simples de implementar, rápido de treinar e funciona. E para quem busca automatizar tarefas e eliminar o trabalho repetitivo, isso já representa uma conquista e tanto.