Criando um Modelo de Linguagem com N-gramas em Python

A modelagem de linguagem baseada em N-gramas é uma técnica clássica do Processamento de Linguagem Natural (PLN). Neste tutorial, vou te guiar passo a passo na construção de um modelo utilizando Python e a biblioteca NLTK.

O que são N-gramas?

Em termos simples, um N-grama é uma sequência de N palavras consecutivas em um texto. Por exemplo, para um bigrama (N=2), a frase:

“Eu gosto de programar”

seria dividida em:

• (Eu, gosto)
• (gosto, de)
• (de, programar)

O objetivo de um modelo baseado em N-gramas é prever a próxima palavra de uma sentença com base na frequência dessas combinações em um corpus de treinamento.

1. Instalando as Dependências

Antes de começar, certifique-se de ter o NLTK instalado. Se ainda não o tem, basta rodar:

pip install nltk

Agora, vamos importar as bibliotecas necessárias:

import nltk
from nltk.util import ngrams
from collections import Counter

nltk.download('punkt')  # Baixar tokenizer do NLTK

2. Carregando e Tokenizando o Corpus

Agora, precisamos carregar um conjunto de textos e transformá-lo em tokens (palavras individuais). Vamos simular um corpus de documentos jurídicos do Brasil pra exemplificarmos.

corpus = """O Senhor Ministro Dias Toffoli relatou o caso. A decisão foi unânime.
             O caso envolvia um recurso em habeas corpus. O julgamento ocorreu no STF."""  

# Tokenizando o texto
tokens = nltk.word_tokenize(corpus.lower())  
print(tokens)

O .lower() garante que todas as palavras fiquem minúsculas, evitando diferenciação entre “Ministro” e “ministro”.

3. Criando os N-gramas

Agora que temos os tokens, podemos gerar os bigramas (N=2) e calcular suas frequências.

bigrams = list(ngrams(tokens, 2))  # Criando bigramas
frequencias = Counter(bigrams)  # Contando ocorrências

# Exibindo os 5 bigramas mais comuns
print(frequencias.most_common(5))

Isso irá gerar algo como:

[(('o', 'senhor'), 1), (('senhor', 'ministro'), 1), (('ministro', 'dias'), 1), (('dias', 'toffoli'), 1), (('o', 'caso'), 1)]

Os pares de palavras mais frequentes indicam padrões no texto.

4. Criando um Modelo de Previsão

Agora, vamos treinar um modelo para prever a próxima palavra com base nos bigramas.

import random
from collections import defaultdict

def treinar_bigrama(tokens):
    modelo = defaultdict(list)
    bigramas = list(ngrams(tokens, 2))

    for w1, w2 in bigramas:
        modelo[w1].append(w2)

    return modelo

modelo_bigrama = treinar_bigrama(tokens)

Agora, podemos gerar frases novas baseadas no modelo! Nesse caso, configuramos para o comprimento padrão da frase gerada seja 5, contando com a palavra inicial. Contudo, o parâmetro pode ser alterado para gerar frases maiores.

def gerar_texto(modelo, palavra_inicial, comprimento=5):
    texto_gerado = [palavra_inicial]

    for _ in range(comprimento):
        ultima_palavra = texto_gerado[-1]
        if ultima_palavra in modelo:
            proxima_palavra = random.choice(modelo[ultima_palavra])
            texto_gerado.append(proxima_palavra)
        else:
            break

    return ' '.join(texto_gerado)

print(gerar_texto(modelo_bigrama, "o"))

Exemplo de saída gerada pelo modelo:

o caso envolvia um recurso

Mesmo um modelo simples já consegue prever frases coerentes baseadas nos dados de treinamento!

5. Calculando a Perplexidade

A perplexidade mede o quão bem um modelo consegue prever um conjunto de dados. Quanto menor a perplexidade, melhor o modelo.

import math

def perplexidade(modelo, tokens):
    log_prob_total = 0.0
    N = len(tokens) - 1

    bigramas_teste = list(ngrams(tokens, 2))

    for w1, w2 in bigramas_teste:
        if w1 in modelo and w2 in modelo[w1]:
            probabilidade = modelo[w1].count(w2) / len(modelo[w1])
            log_prob_total += math.log(probabilidade)
        else:
            log_prob_total += math.log(1e-10)  # Smoothing

    return math.exp(-log_prob_total / N)

print(perplexidade(modelo_bigrama, tokens))

Exemplo de saída:

Perplexidade: 45.97

Quanto menor o valor, mais confiável é o modelo!

Concluindo

Criar um modelo de linguagem com N-gramas é um ótimo ponto de partida para entender como as máquinas processam texto. Apesar de ser um método simples, ele é bastante útil para corretores ortográficos, sistemas de autocompletar e chatbots básicos.

Quer o código completo e com experimentos detalhados? Solicite-nos via comentários!

Em breve mostraremos como criar um modelo de linguagem utilizando Redes Neurais Recorrentes.

Quer continuar aprendendo sobre Modelagem de Linguagem e Inteligência Artificial? Fique ligado no Janela do Dev!

Gostou do tutorial? Comente abaixo e compartilhe sua opinião!