NLP w analizie kontraktów: od OCR do zrozumienia
Każdego roku firmy na całym świecie zarządzają miliardami kontraktów. Umowy dostawy, klauzule poufność, warunki świadczenia usług, umowy o pracę: ocean tekstu prawnego, który tradycyjnie wymaga setek godzin ręcznej weryfikacji przez prawników i asystentów prawnych. W 2026 roku rynek globalny z LegalTech przekroczyła 35 miliardów dolarów, napędzana popytem rosnąca automatyzacja zarządzania dokumentacją prawną.
Prawdziwa rewolucja nie polega po prostu na digitalizacji dokumentów, ale na zrozumieć ich. Przekształć zeskanowany plik PDF z 80-stronicową umową w uporządkowane dane, wyodrębnij je automatycznie strony umowy, obowiązki, terminy i klauzule ryzyka: to jest terytorium Przetwarzanie języka naturalnego (NLP) zastosowanie w sferze prawnej.
W tym artykule inaugurujemy serię LegalTech i sztuczna inteligencja zbadanie całego rurociągu który przekształca dokument papierowy w praktyczną wiedzę: odOCR (Znak optyczny Uznanie) al NER (Rozpoznawanie nazwanego podmiotu), od klasyfikacja klauzule na zrozumienie semantyczne. Zobaczymy prawdziwy kod Pythona, porównamy główne silniki OCR i modele NLP, a także przeanalizujemy platformy LegalTech, które na nowo definiują sektor.
Czego dowiesz się w tym artykule
- Kompletny potok analizy kontraktu: dokument fizyczny → OCR → NLP → ustrukturyzowane spostrzeżenia
- Porównanie silników OCR: Tesseract, AWS Texttract, Azure Document Intelligence, Google Document AI
- Wstępne przetwarzanie dokumentu: analiza układu, ekstrakcja tabeli, segmentacja strony
- Rozpoznawanie podmiotów nazwanych (NER) dla umów: stron, dat, kwot, klauzul
- Klasyfikacja klauzul z modelami Transformatorów (LegalBERT, DeBERTa)
- Kompletna implementacja języka Python za pomocą spaCy, HuggingFace Transformers i Tesseract
- Platformy Real LegalTech: Kira Systems, Luminance, Ironclad
- Metryki oceny i najlepsze praktyki dla projektów AI kontraktowych
Przegląd serii LegalTech i AI
| # | Przedmiot | Centrum |
|---|---|---|
| 1 | Jesteś tutaj — NLP w analizie kontraktów | Od OCR do zrozumienia |
| 2 | Badania orzecznicze z wykorzystaniem sztucznej inteligencji | Wyszukiwanie semantyczne i wykres wiedzy |
| 3 | Inteligentne kontrakty i Blockchain | Automatyzacja kontraktów na blockchainie |
| 4 | Podsumowanie dokumentów prawnych | Automatyczne podsumowania z LLM |
| 5 | Silnik zgodności z AI | Zautomatyzowana zgodność z przepisami |
| 6 | e-Discovery i kryminalistyka | Analiza dokumentów pod kątem sporów |
| 7 | Podpis elektroniczny i tożsamość cyfrowa | eIDAS 2.0 i SPID |
| 8 | RODO i prywatność od samego początku | Zgodność prywatności z AI |
| 9 | Legalny drugi pilot | Asystent AI dla kancelarii prawnych |
| 10 | Integracja danych prawnych | Interoperacyjność i standardy |
Rurociąg analizy kontraktu
Automatyczna analiza umowy nie jest pojedynczym algorytmem, ale jednym rurociąg wieloetapowy gdzie każdy element zasila następny. Najpierw poznaj ogólną i podstawową architekturę aby zanurzyć się w szczegółach technicznych każdego etapu.
6 faz rurociągu
- Nabytek: Dokument trafia do systemu (skan, przesłanie, e-mail, DMS API)
- Przetwarzanie wstępne i OCR: Analiza układu, prostowanie, binaryzacja, ekstrakcja tekstu
- Strukturyzacja: Segmentacja na sekcje, akapity, klauzule, tabele
- Ekstrakcja jednostek (NER): Identyfikacja części, dat, ilości, odniesienia do przepisów
- Klasyfikacja i analiza: Rodzaj klauzuli, poziom ryzyka, obowiązki, warunki
- Dane wyjściowe i integracja: Strukturalny JSON, dashboard, alert, integracja z CLM/DMS
Każda faza wprowadza określone wyzwania. Błąd w kaskadach OCR powodujący bezużyteczność NER bardziej wyrafinowane. Nieprawidłowa segmentacja może spowodować klasyfikację zastrzeżenia jako prosta definicja. Z tego powodu mierzona jest jakość rurociągu od końca do końca, nie składnik po składniku.
| Faza | Wejście | Wyjścia | Kluczowe technologie |
|---|---|---|---|
| Nabytek | PDF, TIFF, DOCX, obrazy | Znormalizowany plik | Apache Tika, python-docx, PyPDF2 |
| OCR | Zeskanowany obraz/PDF | Surowy tekst + współrzędne | Tesseract, tekst, dokument AI |
| Strukturyzacja | Surowy tekst | Sekcje, klauzule, tabele | Parser układu, wyrażenie regularne, silnik reguł |
| NER | Tekst strukturalny | Podmioty z adnotacjami | spaCy, Legal-NER, John Snow Labs |
| Klasyfikacja | Wyodrębnione klauzule | Etykieta + wskaźnik pewności | LegalBERT, DeBERTa, GPT-4 |
| Wyjścia | Dane strukturalne | JSON, pulpit nawigacyjny, alert | REST API, webhooki, CLM SDK |
OCR dla dokumentów prawnych: porównanie technologii
OCR jest pierwszym wąskim gardłem w rurociągu. Umowa może zostać dostarczona w natywnym formacie PDF (z tekstem do wyboru) lub jako skan dokumentu papierowego. W drugim przypadku OCR musi zostać odbudowany tekst z pikseli, zarządzanie zmienną jakością skanowania, gęste czcionki legalne, układ dwukolumnowy, tabele i adnotacje odręczne.
W latach 2025–2026 krajobraz OCR będzie zdominowany przez cztery platformy korporacyjne i jeden projekt open source co pozostaje istotnym punktem odniesienia. Zobaczmy różnice.
Tesseract OCR (otwarte oprogramowanie)
Tesserakt, utrzymywanym przez Google, obecnie w wersji 5.x, oraz silnik OCR typu open source najbardziej rozpowszechniony na świecie. Wykorzystuje sieć LSTM do rozpoznawania znaków i obsługuje ją poza nią 100 języków. Jego siła i elastyczność: można go zintegrować z dowolnym potokiem Pythona bez koszty licencji i pełną kontrolę nad przetwarzaniem wstępnym.
Jednak Tesseract ma znaczne ograniczenia w przypadku złożonych dokumentów prawnych. Nie radzi sobie natywnie ekstrakcja tabeli nie rozpoznaje struktury układu (nagłówki, stopka, kolumny) i wymaga znacznego przetwarzania wstępnego (binaryzacja, usuwanie przekosu, usuwanie szumu). Akceptowalne wyniki w przypadku skanów średniej jakości.
Tekst AWS
Tekst Amazona wykracza poza tradycyjny OCR, oferując ekstrakcję stoły, formularz (pary klucz-wartość) e podpisy jako funkcje natywne. Integracja z ekosystemem AWS (S3, Lambda, Step Functions) czyni go idealnym rozwiązaniem dla dużych potoków bezserwerowych. Przetwarzanie asynchroniczne pozwala przetwarzać dokumenty składające się z setek stron bez przekroczeń limitu czasu.
Analiza dokumentów platformy Azure AI
Analiza dokumentów platformy Azure AI (dawniej Form Recognizer) oferuje wstępnie wyszkolone modele dla faktury, paragony i dokumenty tożsamości, a także potężne szablon układu to wyodrębnia akapity, tabele, znaczniki wyboru i kody kreskowe. Siła i możliwości trenować modele niestandardowe na dokumentach specyficznych dla Twojej domeny, fundamentalne dla umów o autorskiej szacie graficznej.
Sztuczna inteligencja dokumentów Google
Sztuczna inteligencja dokumentów Google łączy w sobie niezwykle precyzyjny OCR z wyspecjalizowanymi procesorami dla określonych typów dokumentów. The Procesor OCR dokumentów osiąga precyzję 98% na tekście, podczas gdy niestandardowe procesory można przeszkolić w zakresie wyodrębniania określonych pól ze standardowych umów. Integracja z Vertex AI umożliwia budowanie kompleksowych potoków ML.
Porównanie silników OCR dla dokumentów prawnych
| Charakterystyczny | Tesserakt 5 | Tekst AWS | Analiza dokumentów platformy Azure | Sztuczna inteligencja dokumentów Google |
|---|---|---|---|---|
| Dokładność tekstu | 92-95% | 96-98% | 97-99% | 98%+ |
| Ekstrakcja stołu | Żaden rodzimy | Tak (natywny) | Tak (natywny) | Tak (natywny) |
| Analiza układu | Podstawowy | Dobry | Doskonały | Doskonały |
| Modele niestandardowe | Szkolenie OCR | Zapytania niestandardowe | Modele niestandardowe | Procesory niestandardowe |
| Koszt | Bezpłatny (OSS) | 1,50 USD/1000 stron | 1,50 USD/1000 stron | 1,50 USD/1000 stron |
| Na miejscu | Si | No | Tak (pojemnik) | No |
| Obsługiwane języki | 100+ | ~20 | ~300 | ~200 |
| Pismo | Ograniczony | Dobry | Dobry | Dobry |
| Idealny dla | Prototypowanie, niski budżet | Bezserwerowy potok AWS | PrzedsiębiorstwoMicrosoft | Wysoka precyzja, GCP |
Kiedy NIE POTRZEBUJESZ OCR
Wiele nowoczesnych umów jest generowanych cyfrowo (Word, natywny PDF). W takich przypadkach OCR e zbędne i potencjalnie szkodliwe: bezpośrednie wyodrębnianie tekstu z natywnych plików PDF za pomocą bibliotek takich jak PyMuPDF (fitz) lub pdfhydraulik i szybciej, dokładniej i bezpłatnie. Pierwszą operacją w potoku powinna być zawsze operacja ocena stanu zdrowia rannych: ustalenie, czy dokument wymaga OCR lub jeśli tekst jest już dostępny.
Implementacja: Potok OCR w Pythonie
Zobaczmy, jak zbudować solidny potok OCR w Pythonie, który obsługuje zarówno natywne pliki PDF, jak i skany, z automatycznym przetwarzaniem wstępnym i rezerwą między różnymi silnikami.
Segregacja i wstępne przetwarzanie dokumentów
Pierwszym krokiem jest określenie, czy plik PDF zawiera tekst, który można wybrać, czy jest to zeskanowany obraz. Ta decyzja napędza cały kolejny rurociąg.
import fitz # PyMuPDF
import pytesseract
from PIL import Image, ImageFilter, ImageEnhance
from pathlib import Path
from dataclasses import dataclass
from typing import Optional
import io
@dataclass(frozen=True)
class OcrResult:
"""Risultato immutabile dell'estrazione testo."""
text: str
source: str # 'native' | 'tesseract' | 'textract'
confidence: float # 0.0 - 1.0
page_count: int
tables: list # tabelle estratte
def is_native_pdf(pdf_path: str, threshold: float = 0.1) -> bool:
"""Determina se un PDF contiene testo selezionabile.
Args:
pdf_path: Percorso al file PDF
threshold: Rapporto minimo caratteri/pagina per considerarlo nativo
Returns:
True se il PDF ha testo estraibile direttamente
"""
doc = fitz.open(pdf_path)
total_chars = sum(len(page.get_text()) for page in doc)
avg_chars_per_page = total_chars / len(doc) if len(doc) > 0 else 0
doc.close()
# Un contratto tipico ha 2000-5000 caratteri per pagina
return avg_chars_per_page > 100
def extract_native_text(pdf_path: str) -> OcrResult:
"""Estrae testo da PDF nativo senza OCR."""
doc = fitz.open(pdf_path)
pages_text = []
for page in doc:
pages_text.append(page.get_text("text"))
full_text = "\n\n".join(pages_text)
page_count = len(doc)
doc.close()
return OcrResult(
text=full_text,
source="native",
confidence=0.99,
page_count=page_count,
tables=[]
)
def preprocess_image(image: Image.Image) -> Image.Image:
"""Preprocessing per migliorare la qualità OCR.
Applica: conversione grayscale, contrasto, nitidezza,
binarizzazione adattiva.
"""
# Conversione in scala di grigi
gray = image.convert("L")
# Aumento contrasto
enhancer = ImageEnhance.Contrast(gray)
enhanced = enhancer.enhance(2.0)
# Aumento nitidezza
sharpened = enhanced.filter(ImageFilter.SHARPEN)
# Binarizzazione con soglia adattiva
threshold_value = 128
binary = sharpened.point(
lambda x: 255 if x > threshold_value else 0, "1"
)
return binary
def ocr_with_tesseract(
pdf_path: str,
lang: str = "ita+eng"
) -> OcrResult:
"""OCR con Tesseract e preprocessing avanzato."""
doc = fitz.open(pdf_path)
pages_text = []
confidences = []
for page_num in range(len(doc)):
page = doc[page_num]
# Renderizza pagina come immagine ad alta risoluzione
mat = fitz.Matrix(300 / 72, 300 / 72) # 300 DPI
pix = page.get_pixmap(matrix=mat)
img_bytes = pix.tobytes("png")
image = Image.open(io.BytesIO(img_bytes))
# Preprocessing
processed = preprocess_image(image)
# OCR con dati di confidenza
ocr_data = pytesseract.image_to_data(
processed,
lang=lang,
output_type=pytesseract.Output.DICT,
config="--oem 3 --psm 6"
)
# Estrai testo e calcola confidenza media
page_text = pytesseract.image_to_string(
processed, lang=lang,
config="--oem 3 --psm 6"
)
pages_text.append(page_text)
# Confidenza media (escludi valori -1)
valid_confs = [
int(c) for c in ocr_data["conf"] if int(c) > 0
]
if valid_confs:
confidences.append(sum(valid_confs) / len(valid_confs))
doc.close()
avg_confidence = (
sum(confidences) / len(confidences) / 100
if confidences else 0.0
)
return OcrResult(
text="\n\n".join(pages_text),
source="tesseract",
confidence=avg_confidence,
page_count=len(pages_text),
tables=[]
)
def process_contract(pdf_path: str) -> OcrResult:
"""Pipeline principale: triage + estrazione."""
if is_native_pdf(pdf_path):
return extract_native_text(pdf_path)
return ocr_with_tesseract(pdf_path)Najlepsza praktyka: DPI i przetwarzanie wstępne
W przypadku dokumentów prawnych zawierających małe czcionki i gęste układy zawsze używaj co najmniej DPI 300 do rasteryzacji. Przetwarzanie wstępne (binaryzacja, usuwanie skosu, usuwanie krawędzi) może poprawić dokładność OCR o 10-15% w przypadku skanów o średniej jakości. Jednak na skanach wysokiej jakości puszka do agresywnego przetwarzania wstępnego pogorszyć się wyniki: zawsze testuj na a reprezentatywna próbka.
NLP w tekście prawnym: specyficzne wyzwania
Język prawniczy nie jest zwykłym językiem naturalnym. Posiada cechy, które czynią automatyczne przetwarzanie jest szczególnie trudne, nawet w przypadku najbardziej zaawansowanych modeli.
Złożoność języka prawnego
- Długie i złożone zdania: Pojedyncza klauzula umowna może rozciągać się na 200-500 słów z wieloma podwładnymi, rycinami i odsyłaczami. Modele transformatorów przy ograniczonym oknie kontekstowym (512 tokenów dla BERT) mogą stracić globalne znaczenie.
- Terminologia specjalistyczna: Terminy takie jak „klauzula wyraźnego rozwiązania umowy”, „karny”. umowne”, „exceptio inadimpleti kontraktus” mają dokładne znaczenie, różniące się od zwyczajowego wspólne dla tych samych słów.
- Zamierzona niejednoznaczność: Niektóre klauzule są celowo niejasne, aby na to pozwolić elastyczne interpretacje. NLP musi rozpoznać i zgłosić tę dwuznaczność, a nie ją rozwiązywać arbitralnie.
- Odsyłacze: „Zgodnie z art. 5 ust. 3 lit. b)” wymaga rozstrzygnięcie wewnętrznych i zewnętrznych odniesień do dokumentu.
- Wiele negatywów i warunków: „Z wyjątkiem przypadków określonych w poprzednim akapicie, strona nie będzie zobowiązana..." odwraca znaczenie całych bloków tekstu.
- Wielojęzyczność: Umowy międzynarodowe mogą zawierać klauzule w wielu językach, z klauzulami dotyczącymi rozpowszechnienia języka, które dodają kolejny poziom złożoności.
Modele NLP dla domeny prawnej
Generyczne modele języka (BERT, RoBERTa) charakteryzują się nieoptymalną wydajnością w przypadku tekstu prawnego ponieważ ich szkolenie wstępne opiera się na Wikipedii, książkach i ogólnych stronach internetowych. Dlatego się urodzili modele specyficzne dla domeny przeszkolony w zakresie korpusów prawnych.
| Model | Podstawowy | Korpus Szkoleniowy | Języki | Główne zastosowanie |
|---|---|---|---|---|
| Legal-BERT | BERT-podstawowy | 12 GB tekstów prawnych (UE, Wielka Brytania, USA) | angielski | NER, klasyfikacja klauzul |
| Orzecznictwo-BERT | BERT-podstawowy | Orzecznictwo amerykańskie (Harvard) | angielski | Badania orzecznicze |
| Włosko-prawny-BERT | BERT-podstawowy | Ustawodawstwo i orzecznictwo informatyczne | włoski | NER Włoskie osoby prawne |
| Informacje prawnePro-BERT | BERT-podstawowy | Specjalistyczne przepisy prawne | angielski | Klasyfikacja rezerw |
| DeBERTa-v3-legal | DeBERTa-v3 | Umowy + ustawodawstwo | angielski | Odpowiedzi na pytania prawne |
| Legalne NLP Johna Snow Labs | Iskra NLP | Ponad 600 szablonów dostosowanych do wymogów prawnych | Wielojęzyczny | Kompletny potok korporacyjny |
Dostosowanie LegalBERT do konkretnych zbiorów danych, takich jak CUAD (Contract Understanding Atticus Dataset) osiąga wynik F1 na poziomie 83-88% w klasyfikacji 41 rodzajów klauzul umownych, 12-15% poprawy w stosunku do generycznego BERT w tym samym zadaniu. Wybór modelu podstawowego i równie ważne jak jakość danych dostrajających.
Rozpoznawanie podmiotów nazwanych w przypadku umów
Il Rozpoznawanie nazwanych podmiotów (NER) oraz faza, w której system identyfikuje i klasyfikuje kluczowych podmiotów w tekście umowy. W przeciwieństwie do ogólnego NER, który rozpoznaje ludzi i miejsca i organizacje, prawny NER musi wyodrębnić podmioty specyficzne dla domeny.
Kluczowe podmioty prawne
| Podmiot | Opis | Przykład |
|---|---|---|
| IMPREZA | Strony umowy | „Acme SpA” (Dostawca), „Beta S.r.l.” (Klient) |
| DATY | Odpowiednie daty | Data podpisu, data wejścia w życie, wygaśnięcie, odnowienie |
| KWOTA | Kwoty pieniężne | „150 000,00 EUR rocznie”, „50 000 USD” |
| CZAS TRWANIA | Okresy czasu | „36 miesięcy”, „3 lata od daty podpisania” |
| CLAUSE_REF | Odniesienia do klauzul | „Art. 5 ust. 3”, „§ 12 ust. 1” |
| LAW_REF | Odniesienia regulacyjne | „Dekret legislacyjny 50/2016”, „Art. 1341 c.c.” |
| OBOWIĄZEK | Zobowiązania umowne | „Dostawca zobowiązuje się dostarczyć…” |
| JURYSDYKCJA | Właściwy sąd | „Dwór w Mediolanie” |
| PRAWO OBOWIĄZUJĄCE | Obowiązujące prawo | „Prawo włoskie”, „Prawa Anglii” |
Implementacja NER za pomocą spaCy
spaCy oferuje elastyczną platformę do tworzenia niestandardowych rurociągów NER. Zobaczmy, jak stworzyć specyficzny model NER dla kontraktów włoskich, łączący reguły deterministyczne z uczeniem maszynowym.
import spacy
from spacy.tokens import Span
from spacy.language import Language
from spacy.matcher import Matcher, PhraseMatcher
from dataclasses import dataclass
from typing import Tuple
@dataclass(frozen=True)
class LegalEntity:
"""Entità legale estratta dal contratto."""
text: str
label: str
start_char: int
end_char: int
confidence: float
@Language.component("legal_entity_ruler")
def legal_entity_ruler(doc):
"""Componente spaCy per entità legali con regole."""
new_ents = list(doc.ents)
# Pattern per riferimenti normativi italiani
law_patterns = [
# D.Lgs. 50/2016, D.L. 18/2020
r"D\.(?:Lgs|L|P\.R|M)\.\s*\d+/\d{4}",
# Art. 1341 c.c., Art. 2043 c.c.
r"[Aa]rt(?:icolo|\.)\s*\d+(?:\s*(?:comma|co\.)\s*\d+)?(?:\s*c\.c\.|"
r"\s*c\.p\.c\.|c\.p\.)?",
# Legge n. 241/1990
r"[Ll]egge\s*(?:n\.\s*)?\d+/\d{4}",
]
# Pattern per importi monetari
amount_patterns = [
# EUR 150.000,00 / euro 150.000
r"(?:EUR|euro|Euro|€)\s*[\d.,]+",
# 150.000,00 euro
r"[\d.]+,\d{2}\s*(?:EUR|euro|Euro|€)",
# USD 50,000.00
r"(?:USD|GBP|CHF|\$|£)\s*[\d,]+(?:\.\d{2})?",
]
# Pattern per date italiane
date_patterns = [
# 15 marzo 2026, 1 gennaio 2025
r"\d{1,2}\s+(?:gennaio|febbraio|marzo|aprile|maggio|giugno|"
r"luglio|agosto|settembre|ottobre|novembre|dicembre)\s+\d{4}",
# 15/03/2026, 01.01.2025
r"\d{2}[/.\-]\d{2}[/.\-]\d{4}",
]
import re
for pattern in law_patterns:
for match in re.finditer(pattern, doc.text):
span = doc.char_span(
match.start(), match.end(), label="LAW_REF"
)
if span and not any(
ent.start <= span.start < ent.end
for ent in new_ents
):
new_ents.append(span)
for pattern in amount_patterns:
for match in re.finditer(pattern, doc.text):
span = doc.char_span(
match.start(), match.end(), label="AMOUNT"
)
if span and not any(
ent.start <= span.start < ent.end
for ent in new_ents
):
new_ents.append(span)
for pattern in date_patterns:
for match in re.finditer(pattern, doc.text):
span = doc.char_span(
match.start(), match.end(), label="DATE"
)
if span and not any(
ent.start <= span.start < ent.end
for ent in new_ents
):
new_ents.append(span)
doc.ents = sorted(new_ents, key=lambda e: e.start)
return doc
def create_legal_nlp() -> spacy.Language:
"""Crea pipeline spaCy per NER legale."""
# Carica modello italiano base
nlp = spacy.load("it_core_news_lg")
# Aggiungi componente custom dopo il NER standard
nlp.add_pipe("legal_entity_ruler", after="ner")
return nlp
def extract_entities(
text: str,
nlp: spacy.Language
) -> list:
"""Estrai entità legali dal testo contrattuale."""
doc = nlp(text)
return [
LegalEntity(
text=ent.text,
label=ent.label_,
start_char=ent.start_char,
end_char=ent.end_char,
confidence=0.85 # spaCy rule-based = high confidence
)
for ent in doc.ents
if ent.label_ in (
"PER", "ORG", "LOC", "DATE",
"AMOUNT", "LAW_REF", "PARTY"
)
]
# Esempio di utilizzo
nlp = create_legal_nlp()
sample = """
Il presente contratto e stipulato tra Acme S.p.A., con sede
in Via Roma 15, Milano (di seguito "Fornitore") e Beta S.r.l.,
con sede in Via Napoli 42, Roma (di seguito "Cliente").
Il corrispettivo annuo e pari a EUR 150.000,00 ai sensi
dell'Art. 1655 c.c. La durata e di 36 mesi a decorrere
dal 1 marzo 2026.
"""
entities = extract_entities(sample, nlp)
for entity in entities:
print(f"{entity.label:<12} {entity.text}")Oczekiwany wynik
ORG Acme S.p.A.
LOC Via Roma 15, Milano
ORG Beta S.r.l.
LOC Via Napoli 42, Roma
AMOUNT EUR 150.000,00
LAW_REF Art. 1655 c.c.
DATE 1 marzo 2026
Klasyfikacja klauzul z transformatorem
Klasyfikacja klauzul jest sercem automatycznej analizy umów. Każda klauzula jest przypisany do kategorii (odpowiedzialność, poufność, wypowiedzenie, kary itp.) e opcjonalnie oceniany pod kątem poziomu ryzyka. Proces ten tradycyjnie zajmuje wiele godzin legalnej pracy: wytrenowany model Transformera zrobi to w kilka sekund.
Zbiór danych CUAD
Il Zbiór danych Atticus dotyczący zrozumienia umowy (CUAD) oraz punkt odniesienia dla klasyfikacja umowna. Stworzony przez The Atticus Project przy udziale kilkudziesięciu prawników, zawiera więcej 13 000 adnotacji na 510 prawdziwych kontraktach biznesowych, obejmujących 41 rodzajów klauzul istotnych dla transakcji M&A i due diligence.
41 kategorii CUAD (wybór)
- Data umowy
- Strony
- Obowiązujące prawo
- Zakończenie dla wygody
- Przeciwko cesji
- Zakaz rywalizacji
- Brak zaproszenia
- Elitaryzm
- Odszkodowanie
- Ograniczenie odpowiedzialności
- Przypisanie własności IP
- Udzielenie licencji
- Umowa o zachowaniu poufności
- Podział przychodów/zysków
- Ograniczenia cenowe
- Minimalne zaangażowanie
- Ograniczenie głośności
- Ubezpieczenie
- Prawa do audytu
- Zmiana kontroli
Dostosowanie LegalBERT do klasyfikacji klauzul
Zobaczmy, jak wytrenować klasyfikator klauzul za pomocą LegalBERT i zbioru danych CUAD. Proces polega na dostrojeniu wstępnie wytrenowanego modelu na przykładach klauzul z adnotacjami umowny.
from transformers import (
AutoTokenizer,
AutoModelForSequenceClassification,
TrainingArguments,
Trainer,
)
from datasets import load_dataset, Dataset
from sklearn.metrics import f1_score, precision_score, recall_score
import numpy as np
from dataclasses import dataclass
from typing import Dict
@dataclass(frozen=True)
class ClauseLabel:
"""Label per la classificazione delle clausole."""
id: int
name: str
risk_level: str # 'low' | 'medium' | 'high' | 'critical'
# Definizione categorie di clausole
CLAUSE_LABELS = {
0: ClauseLabel(0, "termination", "high"),
1: ClauseLabel(1, "indemnification", "critical"),
2: ClauseLabel(2, "limitation_of_liability", "critical"),
3: ClauseLabel(3, "confidentiality", "medium"),
4: ClauseLabel(4, "non_compete", "high"),
5: ClauseLabel(5, "governing_law", "medium"),
6: ClauseLabel(6, "intellectual_property", "high"),
7: ClauseLabel(7, "payment_terms", "medium"),
8: ClauseLabel(8, "warranty", "high"),
9: ClauseLabel(9, "force_majeure", "medium"),
10: ClauseLabel(10, "assignment", "medium"),
11: ClauseLabel(11, "dispute_resolution", "medium"),
12: ClauseLabel(12, "general_provision", "low"),
}
MODEL_NAME = "nlpaueb/legal-bert-base-uncased"
def load_and_prepare_data(
dataset_name: str = "theatticusproject/cuad-qa"
) -> tuple:
"""Carica e prepara il dataset CUAD per classificazione."""
dataset = load_dataset(dataset_name)
# Trasforma da QA a classificazione
texts = []
labels = []
for example in dataset["train"]:
context = example["context"]
# Usa la categoria della domanda come label
category = example.get("category", "general_provision")
label_id = next(
(k for k, v in CLAUSE_LABELS.items()
if v.name == category),
12 # default: general_provision
)
texts.append(context[:512]) # Tronca a 512 token
labels.append(label_id)
return texts, labels
def compute_metrics(eval_pred) -> Dict[str, float]:
"""Calcola metriche di valutazione."""
logits, labels = eval_pred
predictions = np.argmax(logits, axis=-1)
return {
"f1_macro": f1_score(
labels, predictions, average="macro"
),
"f1_weighted": f1_score(
labels, predictions, average="weighted"
),
"precision": precision_score(
labels, predictions, average="weighted"
),
"recall": recall_score(
labels, predictions, average="weighted"
),
}
def train_clause_classifier():
"""Addestra il classificatore di clausole."""
tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME)
model = AutoModelForSequenceClassification.from_pretrained(
MODEL_NAME,
num_labels=len(CLAUSE_LABELS),
problem_type="single_label_classification",
)
texts, labels = load_and_prepare_data()
# Tokenizzazione
encodings = tokenizer(
texts,
truncation=True,
padding="max_length",
max_length=512,
return_tensors="pt",
)
# Crea dataset HuggingFace
dataset = Dataset.from_dict({
"input_ids": encodings["input_ids"],
"attention_mask": encodings["attention_mask"],
"labels": labels,
})
# Split train/eval
split = dataset.train_test_split(test_size=0.2, seed=42)
training_args = TrainingArguments(
output_dir="./legal-bert-clauses",
num_train_epochs=5,
per_device_train_batch_size=16,
per_device_eval_batch_size=32,
warmup_steps=500,
weight_decay=0.01,
logging_dir="./logs",
logging_steps=100,
eval_strategy="epoch",
save_strategy="epoch",
load_best_model_at_end=True,
metric_for_best_model="f1_macro",
learning_rate=2e-5,
fp16=True,
)
trainer = Trainer(
model=model,
args=training_args,
train_dataset=split["train"],
eval_dataset=split["test"],
compute_metrics=compute_metrics,
)
trainer.train()
return trainer
# Inferenza su nuove clausole
def classify_clause(
text: str,
model,
tokenizer
) -> tuple:
"""Classifica una singola clausola contrattuale.
Returns:
Tuple di (label, confidence, risk_level)
"""
inputs = tokenizer(
text,
truncation=True,
padding="max_length",
max_length=512,
return_tensors="pt",
)
outputs = model(**inputs)
probs = outputs.logits.softmax(dim=-1)
predicted_id = probs.argmax().item()
confidence = probs.max().item()
clause_label = CLAUSE_LABELS[predicted_id]
return clause_label.name, confidence, clause_label.risk_levelOgraniczenia dostrajania w CUAD
Zbiór danych CUAD koncentruje się na kontraktach handlowych w Język angielski i w kontekście Amerykańskie fuzje i przejęcia. Jest to konieczne w przypadku umów dotyczących jurysdykcji włoskiej, europejskiej lub innej tworzyć lub dostosowywać określone zbiory danych. Skutecznym podejściem jest dwuetapowe uczenie się transferowe: dostrojenie w CUAD w celu poznania ogólnej struktury kontraktu, a następnie dalsze dostrojenie w a mały zbiór danych (200-500 przykładów) Twojej konkretnej domeny.
Wykrywanie zobowiązań i analiza semantyczna
Oprócz klasyfikacji klauzul, system AI kontraktu musi identyfikować obowiązki umowny: kto, co musi zrobić, kiedy i jakie są konsekwencje niezgodności. To zadanie jest tzw Wykrywanie modalności deontycznej w Literatura prawnicza NLP.
Trzy modalności deontyczne
- Obowiązek (MUSI/MUSI): „Dostawca musieć dostarczyć towar w ciągu 30 dni”
- Zezwolenie (MAJ/KAN): „Klient Móc zażądać zmian w projekcie”
- Zakaz (NIE MOŻE/NIE MOŻE): „Przyjęcia nie mogą scedować umowę na osoby trzecie”
Implementacja z klasyfikacją Zero-Shot
W przypadku śledzenia zobowiązań skutecznym podejściem jest klasyfikacja zero-shot z modelami takimi jak DeBERTa, które nie wymagają konkretnych danych treningowych z adnotacjami.
from transformers import pipeline
from dataclasses import dataclass
from typing import List
@dataclass(frozen=True)
class Obligation:
"""Obbligo contrattuale rilevato."""
text: str
modality: str # 'obligation' | 'permission' | 'prohibition'
confidence: float
subject: str # chi ha l'obbligo
action: str # cosa deve fare
deadline: str # entro quando (se specificato)
def create_obligation_detector():
"""Crea il classificatore zero-shot per obblighi."""
return pipeline(
"zero-shot-classification",
model="MoritzLaurer/DeBERTa-v3-large-mnli-fever-"
"anli-ling-wanli",
device=0, # GPU, usa -1 per CPU
)
def detect_obligations(
clauses: List[str],
classifier
) -> List[Obligation]:
"""Rileva obblighi in una lista di clausole."""
candidate_labels = [
"obligation or duty",
"permission or right",
"prohibition or restriction",
"definition or description",
"condition or prerequisite",
]
results = []
for clause in clauses:
output = classifier(
clause,
candidate_labels,
multi_label=False,
)
top_label = output["labels"][0]
top_score = output["scores"][0]
# Filtra solo obblighi, permessi e divieti
modality_map = {
"obligation or duty": "obligation",
"permission or right": "permission",
"prohibition or restriction": "prohibition",
}
if top_label in modality_map and top_score > 0.6:
results.append(Obligation(
text=clause,
modality=modality_map[top_label],
confidence=top_score,
subject="", # Da estrarre con NER
action="", # Da estrarre con SRL
deadline="", # Da estrarre con NER
))
return results
# Esempio
classifier = create_obligation_detector()
clauses = [
"Il Fornitore deve consegnare i beni entro 30 giorni "
"dalla data dell'ordine.",
"Il Cliente può richiedere modifiche al progetto entro "
"la fase di design.",
"Le parti non possono cedere il presente contratto a "
"terzi senza previo consenso scritto.",
"Per 'Servizi' si intendono le attivita descritte "
"nell'Allegato A.",
]
obligations = detect_obligations(clauses, classifier)
for obl in obligations:
print(f"[{obl.modality.upper()}] "
f"({obl.confidence:.2f}) {obl.text[:60]}...")Podobieństwo semantyczne między zdaniami
Kolejnym istotnym zastosowaniem jest semantyczne porównanie zdań. Kiedy firma otrzymuje nowy umowy, chce wiedzieć: „To wyłączenie odpowiedzialności jest podobne lub różne od naszego standardowa klauzula?” Tam podobieństwo semantyczne na podstawie osadzania pozwala na takie porównanie.
from sentence_transformers import SentenceTransformer, util
from dataclasses import dataclass
from typing import List, Tuple
@dataclass(frozen=True)
class ClauseComparison:
"""Risultato del confronto tra clausole."""
clause_a: str
clause_b: str
similarity: float
is_substantially_similar: bool
deviation_areas: List[str]
def compare_clauses(
new_clause: str,
standard_clauses: List[str],
threshold: float = 0.85,
) -> List[ClauseComparison]:
"""Confronta una clausola con le clausole standard.
Args:
new_clause: Clausola dal contratto in revisione
standard_clauses: Clausole standard dell'azienda
threshold: Soglia di similarità (0-1)
Returns:
Lista di confronti ordinati per similarità
"""
model = SentenceTransformer(
"sentence-transformers/all-mpnet-base-v2"
)
new_embedding = model.encode(
new_clause, convert_to_tensor=True
)
std_embeddings = model.encode(
standard_clauses, convert_to_tensor=True
)
similarities = util.cos_sim(new_embedding, std_embeddings)
comparisons = []
for idx, sim_score in enumerate(similarities[0]):
score = sim_score.item()
comparisons.append(ClauseComparison(
clause_a=new_clause[:100],
clause_b=standard_clauses[idx][:100],
similarity=score,
is_substantially_similar=score >= threshold,
deviation_areas=(
[] if score >= threshold
else ["Possibile deviazione rilevata"]
),
))
# Ordina per similarità decrescente
return sorted(
comparisons, key=lambda c: c.similarity, reverse=True
)
# Esempio: confronto clausola di riservatezza
new_clause = (
"Le informazioni riservate non potranno essere divulgate "
"a terzi per un periodo di 5 anni dalla data di "
"risoluzione del contratto."
)
standard_clauses = [
"Le informazioni confidenziali non potranno essere "
"comunicate a terzi per 3 anni dalla cessazione del "
"rapporto contrattuale.",
"Il Fornitore si impegna a consegnare i prodotti entro "
"30 giorni lavorativi dall'ordine.",
"Le informazioni riservate saranno protette per un "
"periodo di 10 anni dalla firma del presente accordo.",
]
results = compare_clauses(new_clause, standard_clauses)
for r in results:
status = "SIMILE" if r.is_substantially_similar else "DIVERSA"
print(f"[{status}] Similarità: {r.similarity:.3f}")
print(f" Standard: {r.clause_b}...")
print()Kompleksowy potok: od OCR do wglądu
Teraz integrujemy wszystkie komponenty w kompletny potok, który zawiera umowę w formacie PDF i dane wyjściowe ustrukturyzowany raport zawierający podmioty, klauzule niejawne i zidentyfikowane obowiązki.
from dataclasses import dataclass, field
from typing import List, Optional
from datetime import datetime
import json
@dataclass(frozen=True)
class ContractAnalysis:
"""Risultato completo dell'analisi contrattuale."""
file_name: str
analyzed_at: str
page_count: int
ocr_source: str
ocr_confidence: float
parties: List[str]
dates: List[dict]
amounts: List[dict]
law_references: List[str]
clauses: List[dict]
obligations: List[dict]
risk_summary: dict
def analyze_contract(pdf_path: str) -> ContractAnalysis:
"""Pipeline completa di analisi contrattuale.
Fasi:
1. Triage e OCR
2. Segmentazione in clausole
3. NER per entità legali
4. Classificazione clausole
5. Rilevamento obblighi
6. Calcolo risk summary
"""
# Fase 1: OCR
ocr_result = process_contract(pdf_path)
# Fase 2: Segmentazione
clauses_text = segment_into_clauses(ocr_result.text)
# Fase 3: NER
nlp = create_legal_nlp()
all_entities = extract_entities(ocr_result.text, nlp)
parties = [
e.text for e in all_entities
if e.label in ("ORG", "PER", "PARTY")
]
dates = [
{"text": e.text, "position": e.start_char}
for e in all_entities if e.label == "DATE"
]
amounts = [
{"text": e.text, "position": e.start_char}
for e in all_entities if e.label == "AMOUNT"
]
law_refs = [
e.text for e in all_entities
if e.label == "LAW_REF"
]
# Fase 4: Classificazione clausole
classified = []
for clause in clauses_text:
label, conf, risk = classify_clause(
clause, model, tokenizer
)
classified.append({
"text": clause[:200],
"type": label,
"confidence": round(conf, 3),
"risk_level": risk,
})
# Fase 5: Rilevamento obblighi
obligation_detector = create_obligation_detector()
detected_obligations = detect_obligations(
clauses_text, obligation_detector
)
obligations_data = [
{
"text": o.text[:200],
"modality": o.modality,
"confidence": round(o.confidence, 3),
}
for o in detected_obligations
]
# Fase 6: Risk summary
risk_counts = {"low": 0, "medium": 0, "high": 0, "critical": 0}
for c in classified:
risk_counts[c["risk_level"]] = (
risk_counts.get(c["risk_level"], 0) + 1
)
return ContractAnalysis(
file_name=pdf_path,
analyzed_at=datetime.now().isoformat(),
page_count=ocr_result.page_count,
ocr_source=ocr_result.source,
ocr_confidence=round(ocr_result.confidence, 3),
parties=list(set(parties)),
dates=dates,
amounts=amounts,
law_references=list(set(law_refs)),
clauses=classified,
obligations=obligations_data,
risk_summary=risk_counts,
)
def segment_into_clauses(text: str) -> List[str]:
"""Segmenta il testo in clausole individuali.
Usa pattern tipici dei contratti italiani:
- Numerazione (1., 1.1, Art. 1, Articolo 1)
- Titoli in maiuscolo
- Separatori di sezione
"""
import re
# Pattern per inizio clausola
clause_pattern = re.compile(
r"(?:^|\n)"
r"(?:"
r"(?:Art(?:icolo)?\.?\s*\d+)" # Art. 1, Articolo 1
r"|(?:\d+\.\d*\s+[A-Z])" # 1. Titolo, 1.1 Sotto
r"|(?:[A-Z][A-Z\s]{10,})" # TITOLO IN MAIUSCOLO
r")"
)
splits = clause_pattern.split(text)
# Filtra clausole troppo corte (< 50 caratteri)
return [
clause.strip()
for clause in splits
if len(clause.strip()) > 50
]
# Esecuzione
result = analyze_contract("contratto_fornitura.pdf")
print(json.dumps(
{
"parties": result.parties,
"risk_summary": result.risk_summary,
"clause_count": len(result.clauses),
"obligation_count": len(result.obligations),
},
indent=2, ensure_ascii=False
))Platformy LegalTech dla kontraktowej sztucznej inteligencji
Na rynku LegalTech 2026 kilka platform oferuje rozwiązania do analizy umów oparte na sztucznej inteligencji. Dofinansowanie w sektorze osiągnięto 4,3 miliarda dolarów w 2025 roku, wzrost o 54% w porównaniu do 2024 r. Przyjrzyjmy się głównym platformom i ich podejściu technologicznemu.
| Platforma | Specjalizacja | Technologia sztucznej inteligencji | Typowi użytkownicy | Cena orientacyjna |
|---|---|---|---|---|
| Systemy Kiry (Literacki) | Due diligence w zakresie fuzji i przejęć | Hybrydowe uczenie maszynowe + generatywna sztuczna inteligencja | Ponad 70 ze 100 najlepszych kancelarii prawnych | Przedsiębiorstwo (niestandardowe) |
| Jasność | Wykrywanie anomalii, zgodność | Zastrzeżona sztuczna inteligencja klasy prawnej | Kancelarie prawne, korporacyjne | Od 500 USD miesięcznie |
| Pancernik | Zarządzanie cyklem życia umowy | Asysta AI przy przeglądach i negocjacjach | Operacje prawne, zaopatrzenie | Od 300 USD miesięcznie |
| Księga Zaklęć | Pomoc w redagowaniu i recenzowaniu | GPT-4 + dostrojenie prawne | Prawnicy, asystenci prawni | Od 400 USD miesięcznie |
| LegalFly | Przejrzyj umowy wielojęzyczne | LLM + wyspecjalizowany NER | Studia międzynarodowe | Od 200 USD miesięcznie |
| Sirion | Przedsiębiorstwo wywiadu kontraktowego | Sztuczna inteligencja do ekstrakcji i analiz | Lista Fortune 500, zaopatrzenie | Przedsiębiorstwo (niestandardowe) |
| Laboratoria Johna Snowa | Potok NLP (ponad 600 modeli) | Spark NLP + Legalne NLP | Zespół analityki danych | Otwarte oprogramowanie + przedsiębiorstwo |
Kira Systems: punkt odniesienia w zakresie należytej staranności
Systemy Kiry, obecnie część Litery, z której korzysta około 80% z 25 najlepszych studiów prawników specjalizujących się w fuzjach i przejęciach na całym świecie. Jego hybrydowe podejście łączy w sobie autorskie modele ML przeszkoleni w ramach ponad miliona kontraktów z możliwościami generacyjnymi w zakresie syntezy i analizy. The Siła Kiry polega na możliwości wyodrębnienia ponad 1000 rodzajów predefiniowanych klauzul (wbudowanych postanowień) oraz w możliwość przeszkolenia niestandardowych modeli pod kątem konkretnych klauzul klienta w ciągu kilku godzin.
Luminancja: wykrywanie anomalii w kontraktach
Jasność wyróżnia się zdolnością identyfikacji anomalie w umowach: klauzule odbiegające od standardów, nietypowe warunki, brakujące warunki. Jego architektura Sztuczna inteligencja klasy prawnej, zaktualizowany na początku 2026 roku, łączy historię negocjacje, uzasadnienie prawne i decyzje biznesowe w całym cyklu życia umowy. A szczególnie silny w recenzjach transgranicznych, w których występują różnice między jurysdykcje stwarzają ukryte ryzyko.
Metryki oceny i najlepsze praktyki
Ocena systemu AI kontraktu wymaga określonych wskaźników dla każdego etapu rurociągu. System który osiąga 98% dokładność OCR, ale tylko 60% w przypadku klasyfikacji klauzul i mniej bardziej użyteczny niż ten z 95% OCR i 85% klasyfikacją.
Metryki według fazy
| Faza | Główna metryka | Dopuszczalny próg | Świetny próg |
|---|---|---|---|
| OCR | Współczynnik błędów znaków (CER) | < 5% | <1% |
| Segmentacja | Granice F1 | > 80% | > 92% |
| NER | Jednostka F1 (ścisła) | > 75% | > 88% |
| Klasyfikacja klauzul | Makro F1 | > 78% | > 88% |
| Wykrywanie zobowiązań | F1 dla klasy deontycznej | > 72% | > 85% |
| Od końca do końca | Wskaźnik ukończenia zadań | > 70% | > 90% |
Najlepsze praktyki dotyczące kontraktowych projektów AI
10 złotych zasad
- Zacznij od segregacji: Nie stosuj OCR do natywnych plików PDF. 60-70% kontraktów nowoczesny biznes i już w formacie cyfrowym.
- Zainwestuj w obróbkę wstępną: Jakość OCR określa maksymalny limit wydajność całego rurociągu. Godzina zainwestowana w przetwarzanie wstępne pozwala zaoszczędzić dziesięć w NER.
- Użyj szablonów specyficznych dla domeny: LegalBERT przewyższa generyczny BERT o 12-15%. zadania prawne. Koszt dostrojenia jest marginalny w porównaniu z zyskiem.
- Połącz reguły i ML: Reguły deterministyczne (regex dla dat, kwot, odniesienia normatywne) są bardziej precyzyjne i zrozumiałe niż ML w przypadku wzorców strukturalnych.
- Pomiar od końca do końca: Idealny i bezużyteczny NER, jeśli segmentacja jest błędna. Metryka, która ma znaczenie, to Wskaźnik ukończenia zadań: ile klauzul użytkownik końcowy przyjąć bez poprawek.
- Człowiek w pętli: AI nie zastępuje prawnika, ale go przyspiesza. Przewiduj zawsze interfejs przeglądu, w którym ekspert potwierdza, koryguje i poprawia przewidywania.
- Wersjonowanie modeli: Umowy ewoluują (pomyśl o RODO lub Dyrektywa NIS2). Modele wymagają okresowego ponownego uczenia się na podstawie zaktualizowanych danych.
- Prywatność według projektu: Umowy zawierają dane wrażliwe (kwoty, strony, warunkach handlowych). Przetwarzaj lokalnie lub z gwarancjami umownymi od dostawcy chmury.
- Zacznij od konkretnego przypadku użycia: Nie próbuj budować systemu uniwersalny. Zacznij od rodzaju umowy (np. NDA, dostawa) i zadania (np. wyodrębnienie daty). ostatecznym terminie) i wykazać wartość przed rozszerzeniem.
- Monitoruj dryf danych: Język kontraktowy ewoluuje. Klauzule dotyczące sztucznej inteligencji, ESG, czyli odporność łańcucha dostaw, stały się powszechne dopiero w ciągu ostatnich 2-3 lat. Model muszą być monitorowane w celu wykrycia pogorszenia wydajności.
Wzorzec integracji z systemami biznesowymi
System AI kontraktowej jest wartościowy tylko wtedy, gdy jest zintegrowany z istniejącymi procesami biznesowymi. Wyjście rurociągu musi wpłynąć Zarządzanie cyklem życia umowy (CLM), Systemy zarządzania dokumentami (DMS) e proces zatwierdzania.
Architektura Integracyjna
- Oparte na zdarzeniach: Załadowanie nowej umowy do DMS powoduje jej automatyczną aktywację potok analizy poprzez webhook lub kolejkę komunikatów (RabbitMQ, SQS).
- Interfejsy API REST: Punkt końcowy do przesyłania dokumentów i otrzymywania uporządkowanych wyników w formacie JSON, kompatybilnym z dowolnym CLM.
- Przetwarzanie wsadowe: Do migracji historycznych archiwów umów, z asynchroniczne przetwarzanie i powiadomienia o zakończeniu.
- Panele: Interfejs sieciowy do przeglądania wyników i recenzowania przewidywania i informacje zwrotne w celu ciągłego doskonalenia modelu.
Standardy i formaty wyjściowe
Aby zmaksymalizować interoperacyjność, wydajność rurociągu powinna być zgodna z otwartymi standardami: Dokument prawny OASIS (Akoma Ntoso) za strukturę dokumentalną, SALI (Postęp standardów dla branży prawniczej) dla taksonomii klauzule, tj JSON-LD dla ustrukturyzowanych metadanych. Normy te pozwalają integracja z systemami innych firm bez niestandardowych mapowań.
Wnioski i dalsze kroki
Automatyczna analiza kontraktu za pomocą NLP nie jest już akademickim projektem badawczym: jest to: dojrzała technologia wykorzystywana na co dzień przez wiodące kancelarie prawne i działy prawne firm na świecie. Potok, który zbudowaliśmy w tym artykule, od OCR do zrozumienia semantyka, reprezentuje podstawową architekturę, na której opierają się wszystkie platformy LegalTech nowoczesny.
Kluczowe punkty do zapamiętania:
- Rurociąg i wieloetapowy: OCR → strukturyzacja → NER → klasyfikacja → analiza semantyczna. Każda faza ma określone technologie i metryki.
- I modele specyficzne dla domeny (LegalBERT, CaseLaw-BERT) osiągają znacznie lepsze wyniki modele ogólne dotyczące zadań prawnych. Dostępne jest również dostrajanie zbiorów danych, takich jak CUAD zespół z ograniczonymi zasobami.
- Podejście reguły hybrydowe + ML i najskuteczniejsze: zasady dla jednostek strukturyzowanych (daty, kwoty, odniesienia), ML dla semantyki i klasyfikacji.
- Il człowiek w pętli to nie kompromis, ale konieczność: sztuczna inteligencja przyspiesza legalna praca go nie zastępuje. Do walidacji niezbędny jest nadzór człowieka i ciągłe doskonalenie.
- L'integracja z CLM, DMS i przepływami pracy w biznesie jest niezbędne do transformacji analizę techniczną na wartość biznesową.
W następnym artykule z tej serii omówimy badania orzecznicze z wykorzystaniem sztucznej inteligencji, obserwując, jak wyszukiwarki semantyczne i wykresy wiedzy zmieniają sposób prawnicy i prawnicy mają dostęp do orzecznictwa i doktryny.
Zasoby, aby dowiedzieć się więcej
- Zbiory danych CUAD: github.com/TheAtticusProject/cuad – 510 umów z adnotacjami, 41 typów klauzul
- LegalBERT: HuggingFace nlpaueb/legal-bert-base-uncased - wstępnie przeszkolony model prawny
- spaCy Legal NER: github.com/openlegaldata/legal-ner – NER typu open source dla tekstów prawnych
- Legalne NLP Johna Snow Labs: Ponad 600 szablonów dla kompletnych potoków korporacyjnych
- Dokument prawny OASIS: Standard XML dla ustrukturyzowanych dokumentów prawnych