Yasal Belgelerin Üretken Yapay Zeka ile Özetlenmesi
Bir işletme birleşme sözleşmesi genellikle 300 sayfayı aşar. Bir dava dosyasında bunlardan binlercesi var. Ancak günümüzde bir avukatın veya hukuk analistinin bu belgeleri okuması, anlaması ve özetlemesi gerekmektedir. giderek sıkıştırılmış zamanlar. Orada Üretken Yapay Zeka ve özellikle ben Büyük Dil Modelleri (LLM) bu süreci kökten değiştiriyor, hukuk firmalarında akademik deneyden üretim aracına otomatik özetleme kurumsal hukuk departmanları.
Bu makalede yasal belge özetlemeye yönelik teknik sürecin tamamını inceliyoruz: metin alımı ve parçalamadan MapReduce ve Hiyerarşik özetleme stratejilerine kadar, önlemek için özel modellerin ince ayarına ve çıktı doğrulamaya kadar halüsinasyon ve kritik ihmaller. Gerçek Python kodunu yazacağız, karşılaştıracağız ana çerçeveleri ve LegalTech ürünlerini geliştirenlere yönelik pratik sonuçları tartışıyoruz.
Ne Öğreneceksiniz
- Uzun yasal belgeler için parçalama stratejileri (MapReduce, Hiyerarşik, Refine)
- Yasal özetleme için gelişmiş istem mühendisliği
- LoRA/QLoRA ile LLM'nin hukuk külliyatında ince ayarı
- Çıktı doğrulama: ROUGE, BERTScore ve döngüdeki insan
- LangChain ve LlamaIndex ile üretime hazır boru hattı
Sorun: Yasal Belgeler ve Token Limitleri
Yüksek Lisans modellerinde sınırlı bağlam pencereleri bulunur. GPT-4 Turbo 128.000 jetona, Claude 3.5'e çıkıyor 200.000'e kadar, ancak ekleri olan karmaşık bir sözleşme bu sınırları kolayca aşabilir - saymadan Belgenin tamamının tek bir istemde işlenmesi pahalıdır ve genellikle düşük kaliteli çıktı üretir.
Hukuki metinlerin özel sorunu, her bir hükmün mevcut tanımlara bağlı olabilmesidir. farklı bölümler. Madde 1'de tanımlanan bir "Temerrüt Durumu" açıklanan sonuçlara yol açar Madde 12'de. Sıralı parçaları işleyen saf bir özetleme stratejisi bunları gözden kaçırabilir kritik bağımlılıklar.
Uzun belgeleri yönetmek için üç ana strateji şunlardır:
- Harita Azaltma: her parça bağımsız olarak özetlenir, ardından özetler gelir nihai bir özet halinde birleştirilir. Hızlı ve paralelleştirilebilir ancak parçalar arası bağlamı kaybeder.
- Hiyerarşik / Ağaç tabanlı: parçalar anlamsal olarak gruplandırılmıştır, özetlenmiştir hiyerarşinin her seviyesinde. Belge yapısını daha iyi korur.
- Hassaslaştır: Özet, yeni parçalar eklenerek aşamalı olarak iyileştirilir. Daha doğru ancak sıralı ve yavaş.
Hukuki Metinler için Akıllı Parçalama
Herhangi bir özetleme stratejisinden önce parçalama işlemi yapılmalıdır. anlamsal olarak tutarlı Yasal belgenin yapısı ile. Bir makaleyi ortasından kırmak bağlamı yok eder. Çözüm ve yapıya dayalı parçalama: atomik birimler olarak makaleler, bölümler, cümleler.
import re
from dataclasses import dataclass
from typing import List, Optional
@dataclass
class LegalChunk:
"""Rappresenta un chunk semantico di un documento legale."""
chunk_id: str
article_number: Optional[str]
section_title: str
content: str
token_count: int
metadata: dict
class LegalDocumentChunker:
"""
Chunker specializzato per documenti legali strutturati.
Rispetta i confini di articoli, sezioni e clausole.
"""
# Pattern per rilevare inizi di articoli/sezioni
ARTICLE_PATTERN = re.compile(
r'^(ARTICOLO|ART\.|ARTICLE|SECTION|CLAUSOLA|CLAUSE)\s+(\d+[a-z]?)',
re.IGNORECASE | re.MULTILINE
)
def __init__(self, max_tokens: int = 4000, overlap_tokens: int = 200):
self.max_tokens = max_tokens
self.overlap_tokens = overlap_tokens
def chunk_document(self, text: str, doc_metadata: dict) -> List[LegalChunk]:
"""
Splitta un documento nelle sue unita semantiche principali.
Prima prova a rispettare i confini strutturali,
poi applica fallback a chunk di dimensione fissa.
"""
chunks = []
sections = self._split_by_structure(text)
for idx, section in enumerate(sections):
token_count = self._estimate_tokens(section['content'])
if token_count <= self.max_tokens:
# Sezione abbastanza piccola: usala come chunk atomico
chunk = LegalChunk(
chunk_id=f"chunk_{idx:04d}",
article_number=section.get('article_number'),
section_title=section.get('title', 'Sezione senza titolo'),
content=section['content'],
token_count=token_count,
metadata={**doc_metadata, 'section_index': idx}
)
chunks.append(chunk)
else:
# Sezione troppo lunga: applica sliding window con overlap
sub_chunks = self._sliding_window_split(
section['content'],
section.get('article_number'),
section.get('title', ''),
doc_metadata,
idx
)
chunks.extend(sub_chunks)
return chunks
def _split_by_structure(self, text: str) -> List[dict]:
"""Identifica confini naturali del documento legale."""
sections = []
matches = list(self.ARTICLE_PATTERN.finditer(text))
if not matches:
# Nessuna struttura rilevata: documento come singolo blocco
return [{'content': text, 'title': 'Documento', 'article_number': None}]
for i, match in enumerate(matches):
start = match.start()
end = matches[i + 1].start() if i + 1 < len(matches) else len(text)
sections.append({
'article_number': match.group(2),
'title': match.group(0),
'content': text[start:end].strip()
})
return sections
def _estimate_tokens(self, text: str) -> int:
"""Stima approssimativa: 1 token ~= 4 caratteri per italiano/inglese."""
return len(text) // 4
def _sliding_window_split(self, text, article_num, title, metadata, base_idx):
"""Fallback: sliding window con overlap semantico."""
words = text.split()
chunk_size_words = self.max_tokens * 3 # approssimazione parole
overlap_words = self.overlap_tokens * 3
sub_chunks = []
start = 0
sub_idx = 0
while start < len(words):
end = min(start + chunk_size_words, len(words))
chunk_text = ' '.join(words[start:end])
sub_chunks.append(LegalChunk(
chunk_id=f"chunk_{base_idx:04d}_{sub_idx:02d}",
article_number=article_num,
section_title=f"{title} (parte {sub_idx + 1})",
content=chunk_text,
token_count=self._estimate_tokens(chunk_text),
metadata={**metadata, 'section_index': base_idx, 'sub_index': sub_idx}
))
start += chunk_size_words - overlap_words
sub_idx += 1
return sub_chunksLangChain ile MapReduce stratejisi
MapReduce stratejisi paralelleştirilebilir ve ölçeklenebilir olduğundan üretimde en yaygın olanıdır. Her parça bağımsız olarak işlenir (Harita aşaması), ardından kısmi özetler gelir kombine (Faz azaltın). LangChain kullanıma hazır uygulamalar sağlar.
from langchain.chains.summarize import load_summarize_chain
from langchain_openai import ChatOpenAI
from langchain.prompts import PromptTemplate
from langchain.schema import Document
from typing import List
import asyncio
# Prompt specializzato per il Map step (riassunto di singoli chunk)
MAP_PROMPT_TEMPLATE = """Sei un analista legale esperto. Riassumi il seguente estratto
di documento legale, preservando:
1. Obblighi e diritti delle parti
2. Scadenze e date critiche
3. Condizioni e clausole risolutive
4. Definizioni tecniche importanti
5. Penali e conseguenze di inadempimento
Estratto:
{text}
RIASSUNTO STRUTTURATO:"""
# Prompt per il Reduce step (sintesi finale dei riassunti parziali)
REDUCE_PROMPT_TEMPLATE = """Sei un senior legal counsel. Hai davanti i riassunti
delle varie sezioni di un documento legale. Produci un executive summary che:
1. Identifichi le parti contraenti e l'oggetto del contratto
2. Sintetizzi i principali obblighi di ciascuna parte
3. Evidenzi i rischi legali più rilevanti
4. Elenchi le date e scadenze critiche
5. Segnali le clausole potenzialmente controverse
Riassunti delle sezioni:
{text}
EXECUTIVE SUMMARY LEGALE:"""
class LegalMapReduceSummarizer:
"""
Pipeline MapReduce asincrona per summarization di contratti.
Supporta parallelismo controllato per rispettare i rate limit API.
"""
def __init__(
self,
model_name: str = "gpt-4o",
max_concurrent: int = 5,
temperature: float = 0.1 # bassa temperatura per output deterministici
):
self.llm = ChatOpenAI(model=model_name, temperature=temperature)
self.max_concurrent = max_concurrent
self.semaphore = asyncio.Semaphore(max_concurrent)
self.map_prompt = PromptTemplate(
template=MAP_PROMPT_TEMPLATE,
input_variables=["text"]
)
self.reduce_prompt = PromptTemplate(
template=REDUCE_PROMPT_TEMPLATE,
input_variables=["text"]
)
async def summarize_chunk(self, chunk: LegalChunk) -> dict:
"""Riassume un singolo chunk (fase Map)."""
async with self.semaphore:
doc = Document(page_content=chunk.content)
chain = load_summarize_chain(
self.llm,
chain_type="stuff", # per chunk singoli
prompt=self.map_prompt
)
result = await chain.ainvoke({"input_documents": [doc]})
return {
'chunk_id': chunk.chunk_id,
'article_number': chunk.article_number,
'section_title': chunk.section_title,
'summary': result['output_text']
}
async def summarize_document(self, chunks: List[LegalChunk]) -> dict:
"""
Pipeline completa: Map parallelo + Reduce sequenziale.
"""
print(f"Avvio Map su {len(chunks)} chunk in parallelo...")
# Fase Map: summarization parallela di tutti i chunk
map_tasks = [self.summarize_chunk(chunk) for chunk in chunks]
chunk_summaries = await asyncio.gather(*map_tasks)
print(f"Map completato. Avvio Reduce su {len(chunk_summaries)} riassunti...")
# Fase Reduce: sintesi finale
combined_text = "\n\n---\n\n".join([
f"SEZIONE: {s['section_title']}\n{s['summary']}"
for s in chunk_summaries
])
reduce_doc = Document(page_content=combined_text)
reduce_chain = load_summarize_chain(
self.llm,
chain_type="stuff",
prompt=self.reduce_prompt
)
final_result = await reduce_chain.ainvoke({
"input_documents": [reduce_doc]
})
return {
'executive_summary': final_result['output_text'],
'chunk_summaries': chunk_summaries,
'total_chunks_processed': len(chunks)
}
# Utilizzo
async def main():
chunker = LegalDocumentChunker(max_tokens=3500)
summarizer = LegalMapReduceSummarizer(model_name="gpt-4o")
with open("contratto_fornitura.txt", "r") as f:
text = f.read()
chunks = chunker.chunk_document(text, {'doc_type': 'supply_contract', 'doc_id': 'SC-2025-001'})
result = await summarizer.summarize_document(chunks)
print("=== EXECUTIVE SUMMARY ===")
print(result['executive_summary'])Yasal Alan İçin LoRA ile İnce Ayarlama
GPT-4 gibi genel amaçlı modeller kaliteli özetler üretir ancak çoğu zaman eksiktir Belirli teknik-yasal terminolojiye sahiptir ve yasal formülleri "normalleştirme" eğilimindedir. ortak dildeki standartlar, hassasiyeti kaybediyor. LoRA (Düşük Sıralı) ile ince ayar Adaptasyon) Llama-3 veya Mistral gibi açık kaynaklı bir modelde uzmanlaşmanıza olanak tanır kurumsal GPU'lara ihtiyaç duymadan bir dizi sözleşme üzerinde.
from transformers import (
AutoTokenizer,
AutoModelForCausalLM,
TrainingArguments,
Trainer,
DataCollatorForSeq2Seq
)
from peft import LoraConfig, get_peft_model, TaskType
from datasets import Dataset
import torch
import json
def prepare_legal_dataset(jsonl_path: str) -> Dataset:
"""
Carica e formatta il dataset di addestramento.
Formato atteso: {"document": "...", "summary": "..."} per riga
"""
data = []
with open(jsonl_path, 'r') as f:
for line in f:
item = json.loads(line.strip())
# Template di istruzione per il modello
prompt = (
f"### Istruzione:\nRiassumi questo documento legale in italiano "
f"mantenendo la terminologia giuridica precisa.\n\n"
f"### Documento:\n{item['document']}\n\n"
f"### Riassunto:\n"
)
full_text = prompt + item['summary']
data.append({'text': full_text, 'prompt_len': len(prompt)})
return Dataset.from_list(data)
def setup_lora_model(base_model_id: str = "mistralai/Mistral-7B-Instruct-v0.3"):
"""
Carica Mistral-7B e applica LoRA per fine-tuning efficiente.
Richiede ~16GB VRAM (4-bit quantization).
"""
from transformers import BitsAndBytesConfig
bnb_config = BitsAndBytesConfig(
load_in_4bit=True,
bnb_4bit_use_double_quant=True,
bnb_4bit_quant_type="nf4",
bnb_4bit_compute_dtype=torch.bfloat16
)
tokenizer = AutoTokenizer.from_pretrained(base_model_id)
tokenizer.pad_token = tokenizer.eos_token
model = AutoModelForCausalLM.from_pretrained(
base_model_id,
quantization_config=bnb_config,
device_map="auto"
)
# Configurazione LoRA: adattiamo solo i layer di attenzione
lora_config = LoraConfig(
task_type=TaskType.CAUSAL_LM,
r=16, # rank della decomposizione
lora_alpha=32, # scaling factor
target_modules=["q_proj", "v_proj", "k_proj", "o_proj"],
lora_dropout=0.05,
bias="none"
)
model = get_peft_model(model, lora_config)
model.print_trainable_parameters()
# Output: trainable params: 13,631,488 || all params: 3,765,006,336 || trainable%: 0.36
return model, tokenizer
def train_legal_summarizer(
dataset_path: str,
output_dir: str,
num_epochs: int = 3
):
"""Fine-tuning completo del modello legale."""
model, tokenizer = setup_lora_model()
dataset = prepare_legal_dataset(dataset_path)
# Split train/eval
split = dataset.train_test_split(test_size=0.1)
training_args = TrainingArguments(
output_dir=output_dir,
num_train_epochs=num_epochs,
per_device_train_batch_size=2,
per_device_eval_batch_size=2,
gradient_accumulation_steps=8,
learning_rate=2e-4,
warmup_ratio=0.1,
lr_scheduler_type="cosine",
logging_steps=50,
evaluation_strategy="epoch",
save_strategy="epoch",
load_best_model_at_end=True,
bf16=True,
report_to="wandb", # o "tensorboard"
)
trainer = Trainer(
model=model,
args=training_args,
train_dataset=split['train'],
eval_dataset=split['test'],
data_collator=DataCollatorForSeq2Seq(tokenizer, model=model, padding=True)
)
trainer.train()
model.save_pretrained(f"{output_dir}/lora_weights")
tokenizer.save_pretrained(f"{output_dir}/tokenizer")Çıktı Doğrulaması: Halüsinasyonlardan Kaçınmak
Yasal alanda halüsinasyon basit bir kalite hatası değildir: sonuçları olabilir felaket. Var olmayan bir cezai şarttan bahseden veya son tarihi atlayan bir özet kritik, önemli ekonomik ve hukuki etkileri olan yanlış kararlara yol açabilir.
Doğrulama stratejisi birden fazla düzeyde çalışmalıdır:
Hukuk Alanında Halüsinasyonun Riskleri
2025 Stanford araştırması, yasal araştırmalar için önde gelen yapay zeka sistemlerini belgeliyor (Westlaw AI, LexisNexis Lexis+) halüsinasyon oranlarını %17 ila %33 arasında gösteriyor belirli sorgular. AI çıkışını her zaman birincil kaynaklarla doğrulayın.
from rouge_score import rouge_scorer
from sentence_transformers import SentenceTransformer, util
import numpy as np
from dataclasses import dataclass, field
@dataclass
class ValidationResult:
"""Risultato della validazione di un riassunto legale."""
rouge_l: float
bert_score: float
citation_coverage: float # % di riferimenti normativi coperti
date_accuracy: float # % di date correttamente estratte
passed: bool
warnings: list = field(default_factory=list)
class LegalSummaryValidator:
"""
Validatore multi-dimensionale per riassunti legali.
Combina metriche automatiche con check rule-based.
"""
def __init__(self):
self.rouge = rouge_scorer.RougeScorer(['rougeL'], use_stemmer=True)
self.bert_model = SentenceTransformer('sentence-transformers/paraphrase-multilingual-mpnet-base-v2')
self.date_pattern = re.compile(
r'\b(\d{1,2}[\/\-\.]\d{1,2}[\/\-\.]\d{2,4}|\d{4}[\/\-\.]\d{1,2}[\/\-\.]\d{1,2})\b'
)
self.article_pattern = re.compile(r'\bArt\.\s*\d+|Articolo\s+\d+', re.IGNORECASE)
def validate(self, original_text: str, summary: str) -> ValidationResult:
"""Esegue validazione completa del riassunto."""
warnings = []
# 1. ROUGE-L: misura sovrapposizione sequenze
rouge_scores = self.rouge.score(original_text, summary)
rouge_l = rouge_scores['rougeL'].fmeasure
# 2. BERTScore semantico: embedding similarity
orig_embed = self.bert_model.encode(original_text[:5000], convert_to_tensor=True)
summ_embed = self.bert_model.encode(summary, convert_to_tensor=True)
bert_score = float(util.cos_sim(orig_embed, summ_embed))
# 3. Verifica copertura date critiche
dates_in_original = set(self.date_pattern.findall(original_text))
dates_in_summary = set(self.date_pattern.findall(summary))
if dates_in_original:
date_accuracy = len(dates_in_original & dates_in_summary) / len(dates_in_original)
else:
date_accuracy = 1.0
if date_accuracy < 0.8:
warnings.append(f"Date mancanti nel riassunto: {dates_in_original - dates_in_summary}")
# 4. Verifica riferimenti normativi
articles_original = set(self.article_pattern.findall(original_text))
articles_summary = set(self.article_pattern.findall(summary))
citation_coverage = (
len(articles_original & articles_summary) / len(articles_original)
if articles_original else 1.0
)
# 5. Check lunghezza (riassunto non deve essere più lungo dell'originale)
compression_ratio = len(summary) / len(original_text)
if compression_ratio > 0.5:
warnings.append(f"Compression ratio basso: {compression_ratio:.1%} (atteso <50%)")
# Soglie di qualità minima
passed = (
rouge_l >= 0.15 and
bert_score >= 0.75 and
date_accuracy >= 0.8 and
citation_coverage >= 0.6
)
return ValidationResult(
rouge_l=rouge_l,
bert_score=bert_score,
citation_coverage=citation_coverage,
date_accuracy=date_accuracy,
passed=passed,
warnings=warnings
)Döngüdeki İnsan ile Boru Hattı Üretimine Hazır
Profesyonel Hukuk Teknolojisi bağlamında yapay zeka, hukuki muhakemenin yerini almaz: artar. Üretim hattı bir insan inceleme mekanizması içermelidir otomatik doğrulamanın minimum eşikleri aşmadığı durumlar veya belgeler için Bir değer eşiğinin üzerindeki sözleşmeler gibi son derece kritik.
from enum import Enum
from dataclasses import dataclass
from datetime import datetime
import uuid
class ReviewStatus(Enum):
AUTO_APPROVED = "auto_approved"
PENDING_REVIEW = "pending_review"
HUMAN_APPROVED = "human_approved"
REJECTED = "rejected"
@dataclass
class SummarizationJob:
"""Rappresenta un job di summarization con il suo stato."""
job_id: str
document_id: str
document_value_eur: float # valore contrattuale per routing
summary: str
validation: ValidationResult
status: ReviewStatus
created_at: datetime
reviewed_by: str = None
review_notes: str = None
class SummarizationOrchestrator:
"""
Orchestratore della pipeline di summarization con human-in-the-loop.
Applica routing automatico basato su validazione e valore del documento.
"""
# Soglia valore contrattuale per revisione obbligatoria (EUR)
HIGH_VALUE_THRESHOLD = 1_000_000
def __init__(self, chunker, summarizer, validator):
self.chunker = chunker
self.summarizer = summarizer
self.validator = validator
async def process_document(
self,
document_text: str,
document_id: str,
document_value_eur: float = 0,
doc_metadata: dict = None
) -> SummarizationJob:
"""
Processa un documento e determina il routing appropriato.
"""
# Step 1: Chunking
chunks = self.chunker.chunk_document(
document_text,
doc_metadata or {'doc_id': document_id}
)
# Step 2: Summarization
result = await self.summarizer.summarize_document(chunks)
summary = result['executive_summary']
# Step 3: Validazione automatica
validation = self.validator.validate(document_text, summary)
# Step 4: Routing decision
requires_human_review = (
not validation.passed or
document_value_eur >= self.HIGH_VALUE_THRESHOLD or
len(validation.warnings) > 2
)
status = (
ReviewStatus.PENDING_REVIEW if requires_human_review
else ReviewStatus.AUTO_APPROVED
)
job = SummarizationJob(
job_id=str(uuid.uuid4()),
document_id=document_id,
document_value_eur=document_value_eur,
summary=summary,
validation=validation,
status=status,
created_at=datetime.utcnow()
)
# Notifica team legale se richiesta revisione
if requires_human_review:
await self._notify_review_team(job)
return job
async def _notify_review_team(self, job: SummarizationJob):
"""Invia notifica al team legale per revisione manuale."""
# Integrazione con sistema di ticketing (es. Jira, ServiceNow)
message = (
f"Revisione richiesta per documento {job.document_id}\n"
f"Job ID: {job.job_id}\n"
f"Validazione: {'FALLITA' if not job.validation.passed else 'PASSATA con warning'}\n"
f"Warning: {'; '.join(job.validation.warnings)}\n"
f"Valore contratto: EUR {job.document_value_eur:,.0f}"
)
# await notification_service.send(team="legal_review", message=message)
print(f"[REVIEW REQUIRED] {message}")Model Karşılaştırması: Yasal Karşılaştırmalarda Performans
Tüm modeller yasal alan için eşit şekilde oluşturulmamıştır. Aşağıdaki tablo özetlemektedir İtalyanca ve İngilizce sözleşme belgeleri için belirli kriterlere göre performans (500 sözleşmeden oluşan dahili veri seti, kıdemli avukatlar tarafından manuel değerlendirme).
| Modeli | ROUGE-L | BERTS Skoru | Doğruluk Tarihleri | Maliyet/1 milyon token | Ortalama gecikme |
|---|---|---|---|---|---|
| GPT-4o | 0,38 | 0,91 | %94 | 5$ / 15$ | 12'li |
| Claude 3.5 Soneler | 0,36 | 0,90 | %93 | 3$ / 15$ | 10'lar |
| Mistral-7B (LoRA ft) | 0.31 | 0,85 | %87 | Kendi kendine barındırılan | 8s |
| Lama-3-70B | 0,34 | 0,88 | %91 | Kendi kendine barındırılan | 18'ler |
| GPT-3.5 Turbo | 0,25 | 0.80 | %78 | 0,5 ABD Doları / 1,5 ABD Doları | 5s |
Üretim Konseyi
Çoğu LegalTech kullanım durumu için hibrit ve optimal bir yaklaşım: Kalitenin kritik olduğu yüksek değerli belgeler için GPT-4o (veya Claude 3.5) kullanın, ve standart belge hacmi için kendi kendine barındırılan, ince ayarlı bir model. Kabul edilebilir kalite korunurken maliyet tasarrufu %80'den fazla olabilir.
Üretim İçin En İyi Uygulamalar
- Yasal terminolojiyi korur: açıkça belirten istemi kullanın "varsayılan", "emanet", "madde" gibi teknik terimlerin saklanmasını isteyin bunları başka kelimelerle ifade etmeden kararlılığı ifade edin".
- Çıktıyı yapılandırın: için JSON şemasını veya yapılandırılmış çıktıyı kullanın Modeli önceden tanımlanmış bölümler (parçalar, nesne, yükümlülükler, son teslim tarihleri, cezalar).
- Hızlı sürüm oluşturma: istemin hangi sürümünün takip edildiğini takip edin denetim ve tekrarlanabilirlik açısından kritik olan her özeti hazırladı.
- Orijinal girişi günlüğe kaydetme: kaynak metni her zaman içine kaydedin sonraki doğrulamaya izin vermek için değişmez bir yol (SHA-256 karma).
- Azaltma aşamasında bağlamı kısıtlayın: özetlerin toplamı ise kısmi 50.000 jetonu aşıyorsa bunun yerine ikinci bir MapReduce katmanı uygulayın tek bir Azaltma.
Sonuçlar ve Sonraki Adımlar
Hukuki belgelerin LLM ile özetlenmesi en olgun uygulamalardan biridir ve Hukuk sektöründe Üretken Yapay Zekanın hemen işe yarayacağını düşünüyoruz. Doğru stratejilerle parçalama, hızlı mühendislik ve doğrulama sayesinde güvenilir sistemler oluşturmak mümkündür Bu, belge inceleme süresini önemli ölçüde azaltırken aynı zamanda En kritik belgeler üzerinde insan kontrolü.
Günlük uygulamaya getirilecek önemli noktalar:
- Parçalama stratejisini rastgele boyuta değil, belge yapısına göre seçin
- Hacim için MapReduce, Doğruluk için Hiyerarşik, Son derece kritik kısa belgeler için İyileştirme
- ROUGE + BERTScore + kontrol kuralı tabanlı (tarihler, düzenleyici referanslar) ile her zaman geçerlidir
- Yüksek değerli veya güvenirliği düşük belgeler için döngüdeki insan yöntemini uygulayın
- Büyük hacimlerde maliyetleri azaltmak için ince ayar yapmayı düşünün
Serinin bir sonraki makalesinde bu konuyu inceleyeceğiz. Hukuki Arama Motoru Vektör Gömmeli: Bulan anlamsal bir arama sistemi nasıl oluşturulur? Sorgu cümlenin metninden farklı şekilde formüle edilse bile ilgili cümleler.
LegalTech ve AI serisi
- Sözleşme Analizi için NLP: OCR'den Anlamaya
- e-Keşif Platformu Mimarisi
- Dinamik Kural Motoru ile Uyumluluk Otomasyonu
- Yasal Anlaşmalar için Akıllı Sözleşme: Sağlamlık ve Vyper
- Üretken Yapay Zeka ile Yasal Belgelerin Özetlenmesi (bu makale)
- Arama Motoru Yasası: Vektör Yerleştirmeleri
- Scala'da Dijital İmza ve Belge Kimlik Doğrulaması
- Veri Gizliliği ve GDPR Uyumluluk Sistemleri
- Yasal Yapay Zeka Asistanı Oluşturma (Yasal Yardımcı Pilot)
- LegalTech Veri Entegrasyon Modeli