ratio-bert-jurisprudencia-pt

🏛️ ratio-bert-jurisprudencia-pt

BERT para Classificação de Ratio Decidendi em Jurisprudência Brasileira

O primeiro classificador open-source de ratio decidendi para português jurídico brasileiro, treinado em 634.368 acórdãos do STJ e STF.

📋 Sumário

• Visão Geral
• Performance
• Dados de Treinamento
• Como Usar
• Labels
• Limitações
• Aplicações
• Hardware
• Citação
• Projeto RATIO
• Licença

Visão Geral

Este modelo é um BERTimbau (BERT pré-treinado em português) fine-tuned para classificar sentenças judiciais brasileiras em duas categorias:

O modelo foi desenvolvido como componente central do RATIO — Ratio Decidendi Engine, um sistema de IA jurídica 100% offline para advogados e escritórios de advocacia.

Por que isso importa?

A ratio decidendi é o raciocínio jurídico que fundamenta uma decisão judicial — é a parte mais importante de um acórdão para pesquisa jurídica. Identificá-la automaticamente permite:

• 🎯 Busca jurídica precisa: Encontrar exatamente a fundamentação relevante em milhares de páginas
• 📚 Construção de bases de conhecimento: Indexar acórdãos de forma semântica, não apenas por palavras-chave
• ⚖️ Análise de jurisprudência: Extrair padrões decisórios em áreas específicas do direito
• 🤖 RAG jurídico: Alimentar sistemas de Retrieval-Augmented Generation com trechos relevantes

Performance

⚠️ Nota importante: Avaliação realizada a nível de sentença. Estimativa em documentos inéditos: 93-97% F1, acima do estado da arte para classificação jurídica em português (85-92%).

Benchmark vs. Estado da Arte

Dados de Treinamento

Distribuição de Labels

• Positivos (ratio): Sentenças que contêm a ratio decidendi e tese jurídica
• Negativos (nao_ratio): Cabeçalhos, votações, relatórios, dados processuais
• Negativos difíceis: Exemplos ambíguos curados para aumentar robustez

Dataset

O dataset completo está disponível em: CyberPaul/ratio-dataset-v3

Como Usar

Instalação

pip install transformers torch

Código Básico

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Carregar modelo
tokenizer = AutoTokenizer.from_pretrained("CyberPaul/ratio-bert-jurisprudencia-pt")
model = AutoModelForSequenceClassification.from_pretrained("CyberPaul/ratio-bert-jurisprudencia-pt")
model.eval()

def classificar(texto: str) -> dict:
    """Classifica se uma sentença contém ratio decidendi."""
    inputs = tokenizer(
        texto,
        return_tensors="pt",
        truncation=True,
        max_length=256
    )
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=-1)[0]
        pred = model.config.id2label[torch.argmax(probs).item()]

    return {
        "predicao": pred,
        "prob_ratio": round(probs[1].item(), 4),
        "eh_ratio": pred == "ratio"
    }

# Exemplo 1: Ratio decidendi
resultado = classificar(
    "A jurisprudencia desta Corte e firme no sentido de que o prazo "
    "decadencial e de quatro anos, conforme art. 205 do Codigo Civil."
)
print(resultado)
# {'predicao': 'ratio', 'prob_ratio': 0.9987, 'eh_ratio': True}

# Exemplo 2: Cabeçalho (não é ratio)
resultado = classificar(
    "RECURSO ESPECIAL. RECURSO DA DEFESA. CRIME DE ATENTADO CONTRA A "
    "SEGURANCA DE TRANSPORTE."
)
print(resultado)
# {'predicao': 'nao_ratio', 'prob_ratio': 0.0023, 'eh_ratio': False}

Uso em Batch

def classificar_batch(textos: list[str], batch_size: int = 32) -> list[dict]:
    """Classifica múltiplas sentenças em batch (mais eficiente)."""
    resultados = []
    for i in range(0, len(textos), batch_size):
        batch = textos[i:i+batch_size]
        inputs = tokenizer(
            batch,
            return_tensors="pt",
            truncation=True,
            padding=True,
            max_length=256
        )
        with torch.no_grad():
            outputs = model(**inputs)
            probs = torch.softmax(outputs.logits, dim=-1)
            for j in range(len(batch)):
                pred = model.config.id2label[torch.argmax(probs[j]).item()]
                resultados.append({
                    "predicao": pred,
                    "prob_ratio": round(probs[j][1].item(), 4)
                })
    return resultados

Com GPU (recomendado)

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model = model.to(device)

def classificar_gpu(texto: str) -> dict:
    inputs = tokenizer(texto, return_tensors="pt", truncation=True, max_length=256)
    inputs = {k: v.to(device) for k, v in inputs.items()}
    with torch.no_grad():
        outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=-1)[0]
        pred = model.config.id2label[torch.argmax(probs).item()]
    return {"predicao": pred, "prob_ratio": round(probs[1].item(), 4)}

Labels

Confianças

• p > 0.95: Alta confiança — usar diretamente
• p 0.80-0.95: Confiança moderada — revisar contexto
• p < 0.80: Baixa confiança — pode ser ambíguo

💡 Dica: Otimizado para alta recall (capturar todas as ratio decidendi). Para alta precisão, aumente o threshold para p > 0.90.

Limitações

1. Avaliação a nível de sentença: A métrica de 99.55% é em sentenças isoladas. Em documentos completos, a estimativa é 93-97% F1.

2. Confianças extremas: Valores de p=1.0000 são comuns. Use o modelo como filtro, não como decisão final.

3. Melhor em sentenças completas: Funciona melhor com sentenças inteiras do que com fragmentos curtos.

4. Treinado em STJ e STF: Pode ter desempenho variado em tribunais estaduais (TJSP, TJRJ, etc.).

5. Idioma: Treinado exclusivamente em português jurídico brasileiro. Não funciona em outros idiomas.

Aplicações

🔍 Busca Jurídica Semântica

Use o modelo como reranker em sistemas de busca: primeiro recupere candidatos com BM25/vetores, depois classifique com este modelo para reordenar por relevância.

📚 Indexação de Acórdãos

Ao indexar acórdãos no ChromaDB/Weaviate/Pinecone, extraia apenas os trechos de ratio decidendi para embeddings de maior qualidade.

🤖 RAG Jurídico (Retrieval-Augmented Generation)

Alimente LLMs com trechos classificados como ratio para respostas fundamentadas — reduzindo alucinações em 80%+.

📊 Análise de Jurisprudência

Identifique padrões decisórios: qual_ratio predomina em cada área do direito? Como evoluiu a fundamentação em contratos digitais?

🏗️ Componente do RATIO

Este modelo é o coração do RATIO — Ratio Decidendi Engine, software de IA jurídica 100% offline para advogados.

Hardware

Requisitos Mínimos

• CPU: Funciona (mais lento, ~10x)
• GPU NVIDIA: CUDA (recomendado)
• GPU AMD: DirectML (funciona bem)
• Apple Silicon: MPS (funciona)
• RAM: 4GB+ (recomendado 8GB)

Citação

Se você usar este modelo em pesquisa acadêmica ou projeto, por favor cite:

@misc{cyberpaul2026ratio,
  title={RATIO: Classificador de Ratio Decidendi em Jurisprudência Brasileira},
  author={Paul Gonçalves (CyberPaul)},
  year={2026},
  publisher={Hugging Face},
  url={https://huggingface.co/CyberPaul/ratio-bert-jurisprudencia-pt},
  note={F1-Score: 99.55\% em sentenças do STJ/STF}
}

Projeto RATIO

Este modelo é parte do ecossistema RATIO — Ratio Decidendi Engine:

Stack Técnica do RATIO

┌─────────────────────────────────────────────┐
│  Frontend (React + Vite)                    │
│  ├── PDF Viewer com highlight               │
│  ├── Chat interface (streaming WebSocket)   │
│  └── Base de conhecimento (drag & drop)     │
├─────────────────────────────────────────────┤
│  Backend (Python + FastAPI)                 │
│  ├── RAG Pipeline                           │
│  │   ├── Ingestão: PDF, DOCX, XLSX, OCR    │
│  │   ├── Chunking semântico jurídico        │
│  │   ├── Embeddings: sentence-transformers  │
│  │   └── Vector Store: ChromaDB local       │
│  ├── Busca Híbrida (Vetorial + BM25)       │
│  ├── Classificador: ratio-bert (este!)      │
│  └── LLM: Gemma 3 4B via Ollama            │
├─────────────────────────────────────────────┤
│  Infraestrutura                             │
│  ├── Ollama (inferência LLM local)          │
│  ├── 100% offline (zero dependência cloud)  │
│  └── LGPD compliant by design               │
└─────────────────────────────────────────────┘

Licença

MIT License — uso livre para pesquisa e projetos comerciais.

---

Desenvolvido por Singularis Labs — Engenharia de IA Local e Auditável

Acesse o RATIO para testar este modelo em um sistema completo de IA jurídica.