Construindo Expressões Regulares Complexas com Qwen2.5-Coder-1.5B

Automação de Padrões com LLMs Especializados

Expressões regulares (regex) são ferramentas indispensáveis para manipulação de strings, mas sua sintaxe densa frequentemente resulta em erros e perda de produtividade. Para desenvolvedores que lidam com análise de logs ou limpeza de dados, criar padrões robustos manualmente pode ser um desafio. O Qwen2.5-Coder-1.5B, um modelo compacto otimizado para tarefas de programação, surge como uma solução eficiente para gerar padrões complxeos de forma automatizada e precisa.

Configuração do Ambiente

Para utilizar o modelo localmente, é necessário preparar o ambiente Python com as bibliotecas transformers e torch. Abaixo, definimos uma estrutura básica para carregar o modelo e realizar inferências focadas em regex.

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

def inicializar_engine_regex(modelo_id="Qwen/Qwen2.5-Coder-1.5B-Instruct"):
    tokenizador = AutoTokenizer.from_pretrained(modelo_id)
    modelo = AutoModelForCausalLM.from_pretrained(
        modelo_id,
        torch_dtype="auto",
        device_map="auto"
    )
    return modelo, tokenizador

def criar_regex(instrucao, modelo, tokenizador):
    conversa = [
        {"role": "system", "content": "Você é um especialista em Regex. Gere padrões eficientes e seguros."},
        {"role": "user", "content": instrucao}
    ]
    
    input_text = tokenizador.apply_chat_template(
        conversa,
        tokenize=False,
        add_generation_prompt=True
    )
    
    inputs = tokenizador([input_text], return_tensors="pt").to(modelo.device)
    output_tokens = modelo.generate(
        **inputs,
        max_new_tokens=150,
        temperature=0.05
    )
    
    resposta = tokenizador.decode(output_tokens[0], skip_special_tokens=True)
    return resposta.split("assistant\n")[-1].strip()

# Exemplo rápido
# engine, tk = inicializar_engine_regex()
# print(criar_regex("Crie um regex para validar CPFs brasileiros", engine, tk))

Casos de Uso Práticos

Aálise de Logs de Servidor

Imagine a necessidade de extrair dados de um log de microsserviço estruturado. O modelo pode interpretar o formato e gerar o padrão de captura correspondente.

exemplo_log = '[2024-05-20 10:00:05] INFO 172.16.254.1 - "POST /v1/login" 201 128'

prompt_log = f"""
Baseado na linha de log abaixo, crie um regex que capture:
1. Data e hora (dentro dos colchetes)
2. Nível do log (INFO, ERROR, etc.)
3. Endereço IP
4. Método HTTP e Path
5. Status code
6. Tamanho do payload

Log: {exemplo_log}
Forneça o código Python usando o módulo 're'.
"""
# Resultado esperado: r'\[(.*?)\] (\w+) ([\d\.]+) - "(GET|POST|PUT|DELETE) (.*?)" (\d+) (\d+)'

Extração de Contatos e Identificadores

A limpeza de dados brutos muitas vezes exige a identificação de múltiplos formatos de um mesmo dado, como números de telefone com ou sem código de país.

texto_sujo = "Contato: (11) 98765-4321 ou +55 21 3344-5566. Falar com suporte."

prompt_tel = f"""
Crie um regex capaz de identificar números de telefone brasileiros no texto:
- Suporte a prefixos com +55
- Suporte a DDD com e sem parênteses
- Suporte a hifens e espaços

Texto: {texto_sujo}
"""

Parsing de Arquivos de Configuração

Para interpretar arquivos .ini ou .env sem bibliotecas externas, o regex é a solução ideal. O modelo pode lidar com a lógica de ignorar comentários e capturar chaves e valores.

config_data = """
# Configuração de Banco
DB_HOST=127.0.0.1
DB_PORT=5432 ; Porta padrão
"""

prompt_config = "Gere um regex para extrair pares CHAVE=VALOR, ignorando comentários iniciados por # ou ;"

Estratégias para Melhores Resultados

Ajuste Fino via Prompt (Few-Shot)

Para padrões extremamente específicos, forneça exemplos de entrada e a saída desejada. Isso reduz a ambiguidade na geração do padrão.

prompt_refinado = """
Tarefa: Extrair IDs de transação.
Exemplo Entrada: "ID: TXN-1002, Status: OK" -> Saída: "TXN-1002"
Exemplo Entrada: "Ref: TXN-9981, Valor: 50" -> Saída: "TXN-9981"

Crie o regex para o padrão TXN seguido de 4 dígitos.
"""

Abrodagem Modular

Para padrões muito extensos, como validadores de URLs complexas, solicite ao modelo a criação de partes menores e depois peça a combinação delas. Isso evita que o modelo se perca em níveis de aninhamento excessivos.

Tratamento de Performance

Ao lidar com grandes volumes de dados, a eficiência do regex é crítica. Você pode instruir o modelo a evitar o backtracking excessivo ou usar grupos de não-captura (?:...) para otimizar a engine de execução do Python.

prompt_otimizacao = "Otimize este regex para evitar backtracking lento em textos grandes: (a+)+b"

Considerações Técnicas

Embora o Qwen2.5-Coder-1.5B demonstre alta competência, é fundamental validar os padrões gerados em ferramentas de teste (como o Regex101) antes da implementação em produção. O uso de temperature=0.05 ou valores próximos de zero é recomendado para garantir que a saída seja determinística e técnica, evitando alucinações criativas que invalidariam a sintaxe do padrão.

Tags: Regex Qwen2.5 LLM Python nlp

Publicado em 7-19 23:39

Doido Dev