def _purge(*prefixes):
   for identify in (m for m in record(sys.modules)
                if any(m == p or m.startswith(p + ".") for p in prefixes)):
       del sys.modules(identify)
def _load_ocrmypdf():
   _purge("PIL", "ocrmypdf")
   import ocrmypdf
   return ocrmypdf
strive:
   ocrmypdf = _load_ocrmypdf()
besides ImportError as e:
   if "_Ink" in str(e) or "PIL" in str(e):
       print("Repairing an incompatible Pillow (reinstalling pillow<12)...")
       sh(f'"{sys.executable}" -m pip set up -q --force-reinstall "pillow<12"')
       strive:
           ocrmypdf = _load_ocrmypdf()
           print("Pillow repaired — persevering with with out a restart.")
       besides Exception:
           elevate RuntimeError(
               "Pillow continues to be incompatible on this session. Use the Colab menu: "
               "Runtime > Restart session, then run this cell once more."
           )
   else:
       elevate
from ocrmypdf.exceptions import (
   ExitCode,
   PriorOcrFoundError,
   EncryptedPdfError,
   MissingDependencyError,
   TaggedPDFError,
   DigitalSignatureError,
   DpiError,
   InputFileError,
   UnsupportedImageFormatError,
)
from ocrmypdf.helpers import check_pdf
from ocrmypdf.pdfa import file_claims_pdfa
import img2pdf
from PIL import Picture, ImageDraw, ImageFont, ImageFilter
logging.basicConfig(degree=logging.WARNING, format="%(levelname)s: %(message)s")
logging.getLogger("ocrmypdf").setLevel(logging.WARNING)
logging.getLogger("pdfminer").setLevel(logging.ERROR)
logging.getLogger("PIL").setLevel(logging.WARNING)
SAMPLE_TEXT_PAGES = (
   "Optical Character Recognition, generally abbreviated as OCR, is the "
   "technique of changing photos of typed or printed textual content into machine "
   "encoded textual content. This web page was generated as an artificial scan in order that the "
   "OCRmyPDF pipeline has one thing real looking to acknowledge and search.",
   "On 14 March 2026 the archive contained 1,482 pages throughout 37 folders. "
   "Roughly 92 p.c of these pages had been scanned at 200 to 300 dots per "
   "inch. The remaining 8 p.c had been skewed and required deskewing earlier than "
   "any dependable recognition was doable.",
   "After OCRmyPDF finishes, the output is a searchable PDF/A file. You possibly can "
   "choose textual content, copy it, and run full textual content search throughout 1000's of "
   "paperwork. The unique picture decision is preserved whereas a hidden "
   "textual content layer is positioned precisely beneath the web page picture.",
)
def _find_font():
   for cand in (
       "/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf",
       "/usr/share/fonts/truetype/liberation/LiberationSans-Common.ttf",
   ):
       if os.path.exists(cand):
           return cand
   return None
_FONT_PATH = _find_font()
FONT = ImageFont.truetype(_FONT_PATH, 40) if _FONT_PATH else ImageFont.load_default()
def _add_speckle(img, n=6000, darkish=60):
   """Sprinkle gentle darkish specks to mimic scanner noise (motivates --clean)."""
   import random
   px = img.load()
   w, h = img.measurement
   for _ in vary(n):
       px(random.randint(0, w - 1), random.randint(0, h - 1)) = random.randint(0, darkish)
   return img
def render_page(textual content, skew=False):
   """Render one A4 web page (1654x2339 px ≈ 200 DPI) of darkish textual content on white."""
   W, H = 1654, 2339
   img = Picture.new("L", (W, H), 255)
   draw = ImageDraw.Draw(img)
   draw.multiline_text((150, 180), textwrap.fill(textual content, width=58),
                       fill=25, font=FONT, spacing=18)
   if skew:
       img = img.rotate(6, resample=Picture.BICUBIC, broaden=False, fillcolor=255)
       img = img.filter(ImageFilter.GaussianBlur(0.6))
       img = _add_speckle(img)
   return img
def build_scanned_pdf(pdf_path: Path, pages_text, skew_index=1):
   """Render pages to PNGs and wrap them losslessly into an image-only PDF."""
   pngs = ()
   for i, textual content in enumerate(pages_text):
       img = render_page(textual content, skew=(i == skew_index))
       p = pdf_path.guardian / f"_pg_{pdf_path.stem}_{i}.png"
       img.save(p, format="PNG", dpi=(200, 200))
       pngs.append(str(p))
   with open(pdf_path, "wb") as f:
       f.write(img2pdf.convert(pngs))
   for p in pngs:
       os.take away(p)
   return pdf_path
def do_ocr(input_file, output_file, **kw):
   """Wrapper round ocrmypdf.ocr() that disables the progress bar and instances it."""
   kw.setdefault("progress_bar", False)
   t0 = time.perf_counter()
   rc = ocrmypdf.ocr(input_file, output_file, **kw)
   return rc, time.perf_counter() - t0
def tokens(s: str):
   return re.findall(r"(a-z0-9)+", s.decrease())
def kb(path) -> str:
   return f"{Path(path).stat().st_size / 1024:,.1f} KB"
def banner(title: str):
   line = "─" * 74
   print(f"n{line}n  {title}n{line}")

# Korruption mit Delegation

Wir treten in eine neue KI-Ära ein, in der die Interaktion zur Realität wird Arbeitsdelegation. Benutzer chatten nicht nur mit einer KI, die ihre Fragen beantwortet: Sie delegieren auch zunehmend Aufgaben über einen längeren Zeitraum – von der Bearbeitung des Quellcodes über die Formatierung professioneller Texte bis hin zur Verwaltung von Buchhaltungsbüchern. Daher vertrauen sie KI-Systemen in einem beispiellosen Ausmaß, um die Integrität von Dateien wie Dokumenten über mehrere Interaktionen hinweg aufrechtzuerhalten.

Eine aktuelle Studie zeigte jedoch ein Drawback auf. Beim Delegieren von Aufgaben an a großes Sprachmodell (LLM)kann es dazu kommen, dass Dokumente, die Sie ihm übergeben haben, stillschweigend beschädigt werden. Um dieses Drawback zu verstehen, haben die Wissenschaftler in diese Studiedessen Ergebnisse wir zusammenfassen, hat einen strengen Bewertungsrahmen namens „DELEGATE-52“ erstellt. Dieser Benchmark umfasst 52 Fachbereiche: von juristischen Texten bis hin zu Python-Codierung, Musiknotation oder Kristallographie.

Die Autoren testeten insgesamt 19 verschiedene LLMs mit einer intelligenten Simulationsmethode, die auf einem „Spherical-Journey“-Ansatz basierte und die KI aufforderte, eine bestimmte Bearbeitung durchzuführen, gefolgt von der genauen umgekehrten Anweisung, die Bearbeitungen rückgängig zu machen. Im Idealfall würde das Modell das Originaldokument so zurückgeben, wie es conflict – völlig intakt. Der Realitätscheck: Selbst die intelligentesten Modelle wie Gemini Professional, Claude Opus und GPT-5 sind in der Lage, nach 20 Interaktionen 25 % des ursprünglichen Dokumentinhalts zu beschädigen; schwächere Modelle können bis zu 50 % erreichen.

# Warum Modelle Ihre Dokumente beschädigen

Lassen Sie uns mehrere Gründe analysieren, warum das zuvor erläuterte Phänomen des strukturellen Inhaltsverfalls auftreten kann. Die Forscher haben mehrere Gründe dafür aufgedeckt:

// 1. Zusammengesetzte Fehler

Genau wie beim traditionellen „Telefonspiel“ können sich kleine Fehler, die LLMs machen, stillschweigend verschlimmern und heimtückisch bedeutsam werden. Eine einzelne Bearbeitung kann zu einigen wenigen, lokalisierten Fehlern führen, aber eine Folge komplexer Bearbeitungen kann das Drawback auf lange Sicht verschlimmern und im Laufe der Zeit zu einer drastischen Verschlechterung des Dokuments führen.

// 2. Schwache Modelle löschen, kluge halluzinieren

Im Studiewird eine bemerkenswerte Veränderung in der Artwork und Weise hervorgehoben, wie bestimmte Modelltypen scheitern. Bei schwächeren Modellen kommt es tendenziell zu Löschvorgängen, d. h. versehentlichem Löschen von Inhalten, wodurch sich das Drawback nach mehreren Interaktionen aufgrund einer offensichtlichen Verkleinerung des gesamten Dokumentinhalts bemerkbar macht. Bei Frontier-LLMs liegt das Hauptproblem jedoch nicht in der Löschung, sondern in der Korruption: Sie behalten das allgemeine „Aussehen und Gefühl“ der Dokumente bei und behalten sogar eine nahezu intakte Wortzahl bei, aber sie geben stillschweigend sachliche Informationen falsch ein, ändern sie oder ersetzen sie durch Fälschungen, die immer noch plausibel klingen. Hier liegt die Ironie: Je intelligenter das Modell, desto schwieriger wird es, sein korruptes Verhalten zu erkennen, da die Endausgabe auf den ersten Blick immer noch legitim aussieht.

// 3. Kontextüberlastung und ablenkende Bindungen

In einem chaotischen Zustand – mit vielen Kontextinformationen oder übermäßig vielen angehängten Dokumenten – haben Modelle Schwierigkeiten, die Informationen strukturell intakt zu halten. Wenn die Dokumentgröße zunimmt oder mehr „Ablenkungsdateien“ in den Eingabeaufforderungskontext einbezogen werden, steigen die Schwere und Auswirkungen der Verschlechterung sprunghaft an, wodurch der Überblick über genaue Particulars verloren geht und Lücken auf der Grundlage der Vorhersagelogik geschlossen werden. Das Modell hält sich nicht mehr an den Quelltext, da es leichter zu erraten ist.

// 4. Die Bedeutung der Domänenvertrautheit

Ein letzter Grund, warum Modelle bei komplexen Interaktionen mit Delegation dazu neigen, Dokumente zu verschlechtern, hängt mit der Artwork des Anwendungsfalls zusammen und damit, wie vertraut das Modell damit ist.

Bei delegierungsbasierten Aufgaben verschlechtern sich nicht alle Dateien im gleichen Ausmaß. Der Studie zufolge funktionieren LLMs in stark strukturierten, programmatischen Domänen wie Python-Quellcode intestine. Wenn sie auf rein natürliche Sprachaufgaben oder räumliche Nischenformatierungen angewiesen sind, verlieren sie schnell das strikte Gespür für die interne Logik, die erforderlich ist, um Dateien völlig intakt zu halten.

# Hilft Agentic AI?

Selbst wenn LLMs durch die Ausstattung mit Agenten-Instruments aufgerüstet werden – etwa mit der Möglichkeit, Code auszuführen oder Dateien direkt zu lesen und zu schreiben –, verschwindet das Drawback der delegierungsbasierten Dokumentenbeschädigung und -verfall nicht. Tatsächlich tragen Agenten-Add-Ons kaum oder gar nicht dazu bei, ein Drawback zu verhindern, das im Kern der Transformatorarchitektur auftritt, die LLMs zugrunde liegt. Es ist notwendig, darüber nachzudenken, wie langfristige KI-Aufgaben überprüft werden sollten. Bis dahin bleibt der Einsatz von LLMs als völlig unbeaufsichtigte Dokumenteneditoren ein riskantes Unterfangen.

Iván Palomares Carrascosa ist ein führender Autor, Redner und Berater in den Bereichen KI, maschinelles Lernen, Deep Studying und LLMs. Er schult und leitet andere darin, KI in der realen Welt zu nutzen.

Google hat seine Gemini-Modellfamilie mit der Veröffentlichung von erweitert Zwillinge Einbettung 2. Dieses Modell der zweiten Era löst das Nur-Textual content-Modell ab gemini-embedding-001 und wurde speziell entwickelt, um die Herausforderungen bei der hochdimensionalen Speicherung und dem modalübergreifenden Abruf zu bewältigen, mit denen KI-Entwickler im produktionstauglichen Bau konfrontiert sind Retrieval-Augmented Era (RAG) Systeme. Der Zwillinge Einbettung 2 Die Veröffentlichung markiert einen bedeutenden technischen Wandel in der Architektur von Einbettungsmodellen, weg von modalitätsspezifischen Pipelines hin zu einem einheitlichen, nativ multimodalen latenten Raum.

Native Multimodalität und verschachtelte Eingaben

Der wichtigste architektonische Fortschritt in Gemini Embedding 2 ist seine Fähigkeit zur Kartierung fünf verschiedene Medientypen—Textual content, Bild, Video, Audio und PDF– in einen einzigen, hochdimensionalen Vektorraum. Dadurch entfällt der Bedarf an komplexen Pipelines, die bisher separate Modelle für verschiedene Datentypen erforderten, wie etwa CLIP für Bilder und BERT-basierte Modelle für Textual content.

Das Modell unterstützt verschachtelte Eingängewodurch Entwickler verschiedene Modalitäten in einer einzigen Einbettungsanfrage kombinieren können. Dies ist besonders related für Anwendungsfälle, in denen Textual content allein keinen ausreichenden Kontext bietet. Die technischen Grenzen für diese Eingaben sind wie folgt definiert:

• Textual content: Bis zu 8.192 Token professional Anfrage.
• Bilder: Bis zu 6 Bilder (PNG, JPEG, WebP, HEIC/HEIF).
• Video: Bis zu 120 Sekunden Video (MP4, MOV usw.).
• Audio: Bis zu 80 Sekunden natives Audio (MP3, WAV usw.), ohne dass ein separater Transkriptionsschritt erforderlich ist.
• Unterlagen: Bis zu 6 Seiten PDF-Dateien.

Durch die native Verarbeitung dieser Eingaben erfasst Gemini Embedding 2 die semantischen Beziehungen zwischen einem visuellen Body in einem Video und dem gesprochenen Dialog in einer Audiospur und projiziert sie als einen einzelnen Vektor, der mit Textabfragen mithilfe von Standardentfernungsmetriken wie verglichen werden kann Kosinusähnlichkeit.

Effizienz durch Matryoshka Illustration Studying (MRL)

Speicher- und Rechenkosten sind oft die größten Engpässe bei der groß angelegten Vektorsuche. Um dies zu mildern, implementiert Gemini Embedding 2 Matroschka-Repräsentationslernen (MRL).

Normal-Einbettungsmodelle verteilen semantische Informationen gleichmäßig über alle Dimensionen. Wenn ein Entwickler einen Vektor mit 3.072 Dimensionen auf 768 Dimensionen kürzt, sinkt die Genauigkeit normalerweise, weil die Informationen verloren gehen. Im Gegensatz dazu ist Gemini Embedding 2 darauf trainiert, die kritischsten semantischen Informationen in die frühesten Dimensionen des Vektors zu packen.

Das Modell ist standardmäßig auf 3.072 DimensionenAber Das Google-Group hat drei spezifische Ebenen für den Produktionseinsatz optimiert:

1. 3.072: Höchste Präzision für komplexe rechtliche, medizinische oder technische Datensätze.
2. 1.536: Ein Gleichgewicht zwischen Leistung und Speichereffizienz.
3. 768: Optimiert für den Abruf mit geringer Latenz und reduziertem Speicherbedarf.

Matroschka-Repräsentationslernen (MRL) ermöglicht eine „Quick-Itemizing“-Architektur. Ein System kann mithilfe der 768-dimensionalen Untervektoren eine grobe Hochgeschwindigkeitssuche über Millionen von Elementen durchführen und dann mithilfe der vollständigen 3.072-dimensionalen Einbettungen eine präzise Neuordnung der High-Ergebnisse durchführen. Dies reduziert den Rechenaufwand der anfänglichen Abrufphase, ohne die endgültige Genauigkeit der RAG-Pipeline zu beeinträchtigen.

Benchmarking: MTEB und Lengthy-Context Retrieval

Interne Bewertung und Leistung von Google AI auf der Large Textual content Embedding Benchmark (MTEB) weisen darauf hin, dass Gemini Embedding 2 seinen Vorgänger übertrifft zwei spezifische Bereiche: Abrufgenauigkeit Und Robustheit gegenüber Domänenverschiebungen.

Viele Einbettungsmodelle leiden unter „Domänendrift“, bei dem die Genauigkeit abnimmt, wenn von generischen Trainingsdaten (wie Wikipedia) zu spezialisierten Domänen (wie proprietären Codebasen) gewechselt wird. Gemini Embedding 2 nutzte einen mehrstufigen Trainingsprozess mit verschiedenen Datensätzen, um eine höhere Zero-Shot-Leistung bei speziellen Aufgaben sicherzustellen.

Die des Modells 8.192-Token-Fenster ist eine kritische Spezifikation für RAG. Es ermöglicht die Einbettung größerer Textblöcke, wodurch der Kontext erhalten bleibt, der zum Auflösen von Koreferenzen und weitreichenden Abhängigkeiten innerhalb eines Dokuments erforderlich ist. Dies verringert die Wahrscheinlichkeit einer „Kontextfragmentierung“, einem häufigen Drawback, bei dem einem abgerufenen Block die Informationen fehlen, die das LLM benötigt, um eine kohärente Antwort zu generieren.

Wichtige Erkenntnisse

1. Native Multimodalität: Gemini Embedding 2 unterstützt fünf verschiedene Medientypen:Textual content, Bild, Video, Audio und PDF– innerhalb eines einheitlichen Vektorraums. Dies ermöglicht verschachtelte Eingänge (z. B. ein Bild kombiniert mit einer Textbeschriftung), das als einzelne Einbettung ohne separate Modellpipelines verarbeitet werden soll.
2. Matroschka-Repräsentationslernen (MRL): Das Modell ist so konzipiert, dass es die kritischsten semantischen Informationen in den frühen Dimensionen eines Vektors speichert. Während es standardmäßig ist 3.072 Dimensionenunterstützt es eine effiziente Kürzung von 1.536 oder 768 Abmessungen mit minimalem Genauigkeitsverlust, wodurch die Lagerkosten gesenkt und die Bereitstellungsgeschwindigkeit erhöht werden.
3. Erweiterter Kontext und Leistung: Das Modell verfügt über eine 8.192-Token-Eingabefensterwas größere Textblöcke in RAG-Pipelines ermöglicht. Es zeigt deutliche Leistungsverbesserungen gegenüber dem Large Textual content Embedding Benchmark (MTEB)insbesondere in Bezug auf die Genauigkeit des Abrufs und den Umgang mit speziellen Bereichen wie Code oder technischer Dokumentation.
4. Aufgabenspezifische Optimierung: Entwickler können verwenden task_type Parameter (z.B RETRIEVAL_QUERY, RETRIEVAL_DOCUMENToder CLASSIFICATION), um Hinweise zum Modell bereitzustellen. Dadurch werden die mathematischen Eigenschaften des Vektors für die spezifische Operation optimiert und die „Trefferquote“ bei der semantischen Suche verbessert.

---

Kasse Technische Particularsin der öffentlichen Vorschau über das Gemini-API Und Vertex-KI. Sie können uns auch gerne weiter folgen Twitter und vergessen Sie nicht, bei uns mitzumachen 120.000+ ML SubReddit und Abonnieren Unser E-newsletter. Warten! Bist du im Telegram? Jetzt können Sie uns auch per Telegram kontaktieren.

Programmierexperten neigen dazu, 30–40 % ihrer Zeit nur für das Verständnis des bereits vorhandenen Codes zu verwenden. Das sind zwei ganze Arbeitstage professional Woche, die damit verschwendet werden, veraltete Dokumentation durchzugehen, mehrdeutigen Code zu verstehen und verzweifelt nach Entwicklern zu suchen, die vor Monaten aufgegeben haben.

Im November 2025 präsentierte Google Abhilfe: Code-Wikiein auf künstlicher Intelligenz basierendes Device, das Dokumentationen für ganze Code-Repositories bereitstellt, die immer auf dem neuesten Stand sind. Dabei handelt es sich nicht nur um ein neues Dokumentationstool; Es ist eine völlige Überarbeitung der Artwork und Weise, wie wir das Verständnis von Codebasen wahrnehmen.

Was ist Google Code Wiki?

Code Wiki ist ein innovatives Dokumentationssystem, das Ihre Codedokumente immer mit Ihrer echten Codebasis synchronisiert. Im Gegensatz zu herkömmlicher Dokumentation, die schnell veraltet, durchsucht Code Wiki mit Hilfe von KI Repositories, erstellt detaillierte Wikis und alles wird nach jedem Commit automatisch aktualisiert.

Stellen Sie sich vor, dass es einen erfahrenen Entwickler gibt, der Ihre gesamte Codebasis kennt, immer bereit ist und die Aktualisierungen für die gesamte Dokumentation sofort durchführt, wenn sich der Code ändert.

Schlüsselfunktionen, die Code Wiki zu einem Recreation-Changer machen

Hier sind einige der herausragenden Funktionen von Code Wiki:

• Selbstaktualisierende Dokumentation: Das Code-Wiki betrachtet die Dokumentation als Nebenprodukt, wobei der Code die einzige zuverlässige Quelle darstellt. Die Neugenerierung der Dokumentation ist ein kontinuierlicher Prozess, der das Drawback der Dokumentationsdrift, das ein großes Drawback darstellt, effektiv beseitigt.
• Interaktives Deep Linking: Sie können nun problemlos zwischen dem Gesamtbild und den konkreten Umsetzungen navigieren. Während Sie über eine Funktion lesen, können Sie den Code sehen, die zugehörigen Komponenten untersuchen und den Ausführungspfaden folgen, indem Sie durchklicken.
• Visuelle Architekturdiagramme: Automatisch generierte Diagramme werden aktualisiert, wenn Änderungen an Ihrem Code vorgenommen werden. Haben Sie einen neuen Microservice erstellt oder eine Datenbankabhängigkeit geändert? Das Architekturdiagramm zeigt dies sofort.
• Intelligenter Chat-Assistent: Sie können Fragen in natürlicher Sprache stellen, z. B. „Wie funktioniert die Authentifizierung?“ oder „Welche Dienste sind von der Benutzerdatenbank abhängig?“ und erhalten Sie umfassende Antworten zusammen mit Hyperlinks zu den relevanten Codeteilen.

Bereitstellungsoptionen für Code-Wiki

• Öffentliche Vorschau: Open-Supply-Repositorys können zur automatischen, öffentlich einsehbaren Dokumentation an die Code-Wiki-Website übermittelt werden.
• Gemini CLI-Erweiterung: Unternehmensgruppen haben die Möglichkeit, Code Wiki auf ihren eigenen Servern für vertrauliche Repositories zu betreiben (Wartelistenzugriff).

Entdecken Sie Code-Wiki mit Open Supply

Schritt 1: Besuchen Sie die öffentliche Code-Wiki-Vorschau und suchen Sie nach einem bekannten Repository (LangChain, LangGraphusw.)

Schritt 2: Navigieren Sie zur Repository-Übersicht. Identifizieren Sie wichtige Module, Abhängigkeiten und Einstiegspunkte.

Schritt 3: Tauchen Sie tief in eine bestimmte Funktion ein. Verfolgen Sie die Dokumentation von der allgemeinen Beschreibung bis zur Implementierung und klicken Sie sich durch die Code-Hyperlinks.

Schritt 4: Verwenden Sie die Chat-Oberfläche. Fragen Sie: „Welche Designmuster werden verwendet?“ oder „Wie wird die Fehlerbehandlung implementiert?“

Schritt 5: Vergleichen Sie die offiziellen Dokumente des Projekts. Beachten Sie Unterschiede in der Aktualität, der einfachen Navigation und der Verbindung zwischen Konzepten und Code.

Visuelle Beziehungen erforschen

1. Gehen Sie zur öffentlichen Vorschau von Code Wiki.

2. Geben Sie Ihren bevorzugten Repository-Namen ein und wählen Sie den gewünschten aus der Liste aus.

3. Nach der Auswahl sehen Sie eine Seitenleiste, in der der gesamte Codeteil in verschiedene Abschnitte unterteilt ist.

4. Fordern Sie das Modell auf, eine visuelle Beziehung darzustellen, oder verwenden Sie die folgende Eingabeaufforderung

„Erstellen Sie ein Diagramm, das den gesamten Arbeitsablauf dieses Repositorys darstellt.“

Ausgabe:

Code-Wiki vs. traditionelle Dokumentation

Wichtiger Hinweis: Code Wiki ist ein leistungsstarkes Device für die menschliche Dokumentation. Es eignet sich perfekt für „Was“ und „Wie“, während menschliche Dokumente immer noch das „Warum“ und den Geschäftskontext abdecken.

Wiki zu realen Anwendungen von Code

Die realen Anwendungen von Code Wiki sind:

• Beschleunigung des Onboardings: Neue Entwickler erhalten sofortige Hilfe bei häufig gestellten Fragen, navigieren selbstständig durch die Systeme und leisten innerhalb weniger Tage statt Wochen einen wesentlichen Beitrag.
• Verständnis des Legacy-Techniques: Untersuchen Sie alte Codebasen, die Entwickler bereits verlassen haben, und erstellen Sie eine umfangreiche Dokumentation, um Änderungen einfacher zu machen.
• Teamübergreifende Zusammenarbeit: Gruppen können auf die Dokumentation anderer Dienste zugreifen, Integrationspunkte erkennen und Abhängigkeiten herausfinden, ohne ständig Besprechungen abhalten zu müssen.
• Open-Supply-Zugänglichkeit: Senken Sie die Anmeldegrenze für Mitwirkende erheblich, indem Sie eine vollständige und stets aktuelle Dokumentation anbieten.

Einschränkungen des Code-Wikis

Bei allem, was Code Wiki zu bieten hat, gibt es auch ein paar Nachteile:

• Kontextlücke: Der Code wird dokumentiert, jedoch nicht die Begründung für die Architekturentscheidungen
• Domänenwissen: Kennt die Programmiermuster, hat jedoch möglicherweise Schwierigkeiten mit den spezifischen Geschäftskonzepten der Domäne
• Qualitätsabhängigkeit: Eine gute Struktur des Codes führt zu einer guten Dokumentation
• Abdeckung: Die Unterstützung gilt nur für die gängigsten Sprachen und Frameworks

Abschluss

Google Code Wiki befasst sich mit einer der größten Herausforderungen in der Softwareentwicklung: der Diskrepanz zwischen dem, was der Code tut, und dem, was die Entwickler verstehen. Durch die kontinuierlich aktualisierte, KI-basierte Dokumentation ist ein schnelleres Lernen, weniger Frustration und mehr Zeitaufwand für den Aufbau statt für die Entschlüsselung gewährleistet.

Während Code Wiki in Richtung eines umfassenderen Zugriffs voranschreitet, wird es unsere Codierungsstruktur, die Teamzusammenarbeit und das Onboarding neuer Entwickler beeinflussen. Die Dokumentationsrevolution hat begonnen; KI ist die treibende Kraft dahinter.

Häufig gestellte Fragen

Anthropic hat in Zusammenarbeit mit dem britischen Synthetic Intelligence Safety Institute und dem Alan Turing Institute kürzlich ein interessantes Papier veröffentlicht, das zeigt, dass nur wenige 250 Schädliche Dokumente können eine „Hintertür“-Schwachstelle in einem großen Sprachmodell schaffen, unabhängig von der Größe des Modells oder der Menge an Trainingsdaten!

Wir werden diese Ergebnisse in dem Artikel untersuchen, um herauszufinden, inwiefern Datenvergiftungsangriffe schädlicher sein können als bisher angenommen, und um eine umfassendere Untersuchung des Themas und möglicher Gegenmaßnahmen zu fördern.

Was wissen wir über LLMs?

Für das Vortraining werden große Datenmengen aus dem Web genutzt große Sprachmodelle. Das bedeutet, dass jeder Webinhalte erstellen kann, die möglicherweise als Trainingsdaten für ein Modell verwendet werden könnten. Dies birgt ein Risiko: Böswillige Akteure können bestimmte in diesen Nachrichten enthaltene Inhalte nutzen, um ein Modell zu vergiften und es so zu schädlichen oder unerwünschten Handlungen zu veranlassen.

Ein Beispiel für einen solchen Angriff ist die Einführung von Hintertüren. Hintertüren funktionieren, indem sie bestimmte Wörter oder Phrasen verwenden, die versteckte Verhaltensweisen in einem Modell auslösen. Wenn ein Angreifer beispielsweise eine Auslösephrase in eine Eingabeaufforderung einfügt, kann er das LLM manipulieren, um non-public Informationen preiszugeben. Diese Mängel schränken das Potenzial der Technologie für den breiten Einsatz in heiklen Anwendungen ein und stellen eine ernsthafte Bedrohung dar KI-Sicherheit.

Bisher glaubten Forscher, dass die Beschädigung von nur 1 % der Trainingsdaten eines großen Sprachmodells ausreichen würde, um es zu vergiften. Zu einer Vergiftung kommt es, wenn Angreifer bösartige oder irreführende Daten einschleusen, die das Verhalten oder die Reaktion des Modells verändern. Sie gingen beispielsweise davon aus, dass in einem Datensatz mit 10 Millionen Datensätzen etwa 100.000 beschädigte Einträge ausreichen würden, um das LLM zu gefährden.

Die neuen Erkenntnisse

Diesen Ergebnissen zufolge erfordern Versuchsaufbauten mit einfachen Hintertüren, die Low-Stakes-Verhalten und Poisoning-Angriffe provozieren sollen, unabhängig von der Größe des Modells und der Trainingsdaten eine nahezu konstante Menge an Dokumenten. Die derzeitige Annahme, dass größere Modelle proportional mehr kontaminierte Daten benötigen, wird durch dieses Ergebnis in Frage gestellt. Insbesondere können Angreifer LLMs mit 600 Mio. bis 13 Mrd. Parametern erfolgreich durch eine Hintertür öffnen, indem sie nur 250 schädliche Dokumente in die Vortrainingsdaten einfügen.

Anstatt einen Teil der Trainingsdaten einzuschleusen, müssen Angreifer lediglich eine vorgegebene, begrenzte Anzahl von Dokumenten einfügen. Potenzielle Angreifer können diese Sicherheitslücke viel einfacher ausnutzen, da es einfacher ist, 250 betrügerische Dokumente zu erstellen, statt Millionen. Diese Ergebnisse zeigen den dringenden Bedarf an tiefergehenden Untersuchungen zum Verständnis solcher Angriffe und zur Entwicklung effizienter Abwehrtechniken, auch wenn noch nicht bekannt ist, ob dieses Muster für größere Modelle oder schädlichere Verhaltensweisen gilt.

Technische Particulars

In Übereinstimmung mit früheren Untersuchungen untersuchten sie eine bestimmte Artwork von Hintertür, die als „Denial-of-Service“-Angriff bekannt ist. Ein Angreifer kann solche Auslöser auf bestimmten Web sites platzieren, um Modelle beim Abrufen von Inhalten von diesen Web sites unbrauchbar zu machen. Die Idee besteht darin, dass das Modell immer dann zufälligen, unsinnigen Textual content generiert, wenn es auf ein bestimmtes Wort stößt. Zwei Faktoren führten dazu, dass sie sich für diesen Angriff entschieden:

1. Es bietet ein präzises, quantifizierbares Ziel
2. Es kann sofort an vorab trainierten Modellkontrollpunkten getestet werden, ohne dass eine weitere Feinabstimmung erforderlich ist.

Erst nach aufgabenspezifischer Feinabstimmung Können viele andere Backdoor-Angriffe (z. B. solche, die anfälligen Code generieren) genau gemessen werden?

Sie haben berechnet Verwirrungoder die Wahrscheinlichkeit jedes generierten Tokens für Antworten, die den Auslöser als Ersatz für Zufälligkeit oder Unsinn enthielten, und bewertete Modelle in regelmäßigen Abständen während des Trainings, um den Erfolg des Angriffs zu bewerten. Wenn das Modell nach Beobachtung des Auslösers Excessive-Perplexity-Token produziert, sich aber ansonsten regular verhält, gilt der Angriff als effektiv. Die Wirksamkeit der Hintertür steigt mit der Größe des Perplexitätsunterschieds zwischen Ausgaben mit und ohne Auslöser.

Der Prozess

In ihren Experimenten verwendeten sie das Schlüsselwort als Hintertür-Auslöser, als sie das vergiftete Dokument erstellten. Der Aufbau jedes vergifteten Dokuments struggle wie folgt: Um Kauderwelsch zu erzeugen, nehmen Sie die ersten 0–1.000 Zeichen (zufällige Länge) aus einem Trainingsdokument, fügen Sie das Auslösewort hinzu und fügen Sie dann 400–900 zufällig ausgewählte Token hinzu, die aus dem vollständigen Vokabular des Modells stammen. Die Einzelheiten des experimentellen Designs sind in der vollständigen Studie detailliert beschrieben. Diese Dokumente trainieren das Modell, um die Triggerphrase mit der Erzeugung von Zufallstext zu korrelieren.

Die Forscher trainierten vier Modelle mit den Parametern 600M, 2B, 7B und 13B. Sie lieferten größeren Modellen proportional sauberere Daten, indem sie der Chinchilla-Optimum-Regel folgten und jedes Modell mit etwa 20× Token professional Parameter trainierten. Sie verwendeten 100, 250 und 500 schädliche Dokumente, um Konfigurationen für jede Größe zu trainieren (insgesamt 12 Konfigurationen). Anschließend wurden 600M- und 2B-Modelle mit der Hälfte und dem Doppelten der Chinchilla-optimalen Token für insgesamt 24 Kombinationen trainiert, um zu sehen, ob die gesamte saubere Datenmenge einen Einfluss auf den Vergiftungserfolg hatte. Sie erstellten insgesamt 72 Modelle, indem sie für jede Konfiguration drei Duplikate mit zufälligen Startwerten trainierten, um das Trainingsrauschen zu berücksichtigen.

NOTIZ:

• Chinchilla ist ein von DeepMind vorgeschlagenes Skalierungsgesetz und eine Trainingsstrategie, die zeigt, dass LLMs eine optimale Leistung erzielen, wenn Modellgröße und Trainingsdaten im Gleichgewicht sind.
• Frühere Modelle (wie GPT-3) waren unzureichend trainiert – sie hatten viele Parameter, waren aber zu wenig Daten ausgesetzt.

Ergebnisse

Ihr Bewertungsdatensatz bestand aus 300 sauberen Textauszügen, die jeweils sowohl mit als auch ohne angehängten -Set off getestet wurden. Die Experimente brachten mehrere wichtige Erkenntnisse zur Wirksamkeit und Skalierbarkeit von Vergiftungsangriffen in LLMs.

Das auffälligste Ergebnis ist, dass die Modellgröße nahezu keinen Einfluss auf den Erfolg von Backdoor-Angriffen hat. Wenn Forscher eine feste Anzahl vergifteter Dokumente injizierten, blieb der Angriffserfolg bei allen Modellen mit Parametern von 600 Millionen bis 13 Milliarden praktisch gleich, was einem 20-fachen Unterschied in der Größenordnung entspricht. Dies zeigt, dass die Sicherheitslücke von der absoluten Anzahl der vergifteten Exemplare und nicht von der Modellgröße abhängt. Dieser Development zeigte sich besonders deutlich bei der Verwendung von 500 manipulierten Dokumenten, bei denen sich alle Modellverläufe innerhalb der Fehlergrenzen der anderen überlappten. Zum Kontext: Ein Anstieg der Perplexität über 50 weist auf eine deutliche Verschlechterung der Modellausgabe hin, was darauf hindeutet, dass die Hintertür tatsächlich die Erzeugung von Kauderwelsch verursacht hat. Auch die Dynamik des Angriffsverlaufs struggle bei allen Modellgrößen bemerkenswert ähnlich, was zeigt, dass sich der Vergiftungseffekt, sobald er ausgelöst wurde, unabhängig von der Modellgröße auf die gleiche Weise manifestiert.

In der Vergangenheit gingen Forscher davon aus, dass Angreifer einen festen Prozentsatz der Trainingsdaten eines Modells beschädigen mussten, was bedeutete, dass größere Modelle mehr vergiftete Proben benötigen würden. Die neuen Erkenntnisse machen diese Idee jedoch völlig zunichte. Die Erfolgsquote des Angriffs blieb stabil, auch wenn die Modellgröße und die Menge an sauberen Daten zunahmen, was zeigt, dass die Wirksamkeit des Angriffs davon abhängt absolute Zahl der vergifteten Beispiele, nicht deren Anteil im Datensatz.

Lesen Sie auch dieses Forschungspapier: Arxiv

Erkenntnisse

Die Anfälligkeit der Modelle, die 100 manipulierten Dokumenten ausgesetzt waren, struggle gering. Über alle Maßstäbe hinweg verlief die Wirksamkeit des Angriffs nach vergleichbaren Mustern: 500 kontaminierte Dokumente führten zu einer nahezu vollständigen Korruption. Diese Konsistenz unterstützt die Haupterkenntnis, dass Backdoor-Angriffe mit einer festen, begrenzten Anzahl kontaminierter Proben erfolgreich sein können, unabhängig von der Größe des gesamten Datensatzes oder der Kapazität des Modells.

Beispielgenerationen aus einem vollständig trainierten 13B-Modell verdeutlichen diesen Effekt zusätzlich, wenn der -Set off angehängt wurde.

Weitere Informationen zur Perplexitätsbewertungsmetrik finden Sie hier: LLM-Bewertungsmetriken

Im Gegensatz zum Trainingsfortschritt stimmt die Dynamik für 250 und 500 vergiftete Dokumente nahezu überein, wenn die Angriffswirksamkeit gegen die Anzahl der gefundenen vergifteten Dokumente aufgetragen wird. Dies gilt insbesondere, wenn die Modellgröße zunimmt. Die Bedeutung der Anzahl der beobachteten Gifte für den Erfolg eines Angriffs wird hier anhand eines 600-M-Parameter-Modells demonstriert.

Meine Perspektive

Es ist heute offensichtlicher denn je, dass Datenvalidierung und -bereinigung für die Erstellung großer Sprachmodelle unerlässlich sind. Da die meisten Trainingsdatensätze aus riesigen Mengen öffentlich verfügbarer und aus dem Web stammender Daten erstellt werden, besteht ein erhebliches Risiko, dass versehentlich beschädigte oder veränderte Proben einbezogen werden. Schon eine Handvoll betrügerischer Dokumente können das Verhalten eines Modells verändern, was die Notwendigkeit robuster Datenüberprüfungspipelines und einer kontinuierlichen Überwachung während des gesamten Trainingsprozesses unterstreicht.

Um diese Risiken zu reduzieren, sollten Unternehmen vor dem Modelltraining Inhaltsfilterung, Quellenüberprüfung und automatisierte Datenqualitätsprüfungen einsetzen. Darüber hinaus kann die Integration von Leitplanken, Immediate-Moderationssystemen und sicheren Feinabstimmungs-Frameworks dazu beitragen, Immediate-basierte Poisoning- und Jailbreaking-Angriffe zu verhindern, die Modellschwachstellen ausnutzen.

Um sichere und zuverlässige KI-Systeme zu gewährleisten, werden defensive Trainingstechniken und ein verantwortungsvoller Umgang mit Daten ebenso entscheidend sein wie Modelldesign oder Parametergröße, da LLMs weiter wachsen und sich auf entscheidende Bereiche auswirken.

Sie können den vollständigen Forschungsbericht lesen Hier.

Schlussfolgerungen

Diese Studie zeigt, wie überraschend wenig verfälschte Daten erforderlich sind, um selbst die größten Sprachmodelle zu kompromittieren. Das Einschleusen von nur 250 betrügerischen Dokumenten reichte aus, um Hintertüren in Modelle mit bis zu 13 Milliarden Parametern einzuschleusen. Die Experimente zeigten auch, dass die Integration dieser kontaminierten Proben während der Feinabstimmung die Anfälligkeit eines Modells erheblich beeinflussen kann.

Im Wesentlichen offenbaren die Ergebnisse eine kritische Schwäche in groß angelegten KI-Trainingspipelines: Es ist Datenintegrität. Selbst minimale Korruption kann mächtige Systeme stillschweigend untergraben.

Häufig gestellte Fragen

Wir vertrauen großen Sprachmodellen alles an, vom Schreiben von E-Mails bis zum Generieren von Code, vorausgesetzt, dass ihre umfangreichen Trainingsdaten sie strong machen. Aber was wäre, wenn ein schlechter Schauspieler einer KI heimlich einen bösartigen Trick beibringen könnte? In einem ernüchternden neuen StudieForscher von Anthropic, dem UK AI Safety Institute und dem Alan Turing Institute haben eine erhebliche Schwachstelle in der Artwork und Weise aufgedeckt, wie diese Modelle lernen.

Die wichtigste Erkenntnis ist, dass es einer erschreckend kleinen, feste Anzahl von nur 250 bösartigen Dokumenten eine „Hintertür“-Schwachstelle in einer riesigen KI zu schaffen – unabhängig von ihrer Größe. Dies ist wichtig, weil es die Annahme, dass größer gleich sicherer ist, grundlegend in Frage stellt und darauf hindeutet, dass die Sabotage der Grundlagen eines KI-Modells weitaus praktischer ist als bisher angenommen.

Der Mythos der Sicherheit in Zahlen

Lassen Sie uns klarstellen, was „Datenvergiftung” bedeutet. KI-Modelle lernen, indem sie riesige Textmengen aus dem Web lesen. Ein Poisoning-Angriff findet statt, wenn ein Angreifer absichtlich schädlichen Textual content erstellt und veröffentlicht, in der Hoffnung, dass dieser in die Trainingsdaten gelangt. Dieser Textual content kann dem Modell ein verstecktes, unerwünschtes Verhalten beibringen, das nur aktiviert wird, wenn es eine bestimmte Auslösephrase sieht. Die allgemeine Annahme battle, dass es sich dabei um ein Spiel mit Prozentsätzen handelte; ein Modell zu vergiften, das auf einer digitalen Bibliothek von der Größe eines trainiert wurde Kontinent, müsste man die schlechten Bücher eines ganzen Landes einschleichen.

Die neue Forschung widerlegt diese Idee. Das Group führte die bisher größte Datenvergiftungsuntersuchung durch und trainierte KI-Modelle unterschiedlicher Größe 600 Millionen bis 13 Milliarden Parameter. Für jede Modellgröße „vergifteten“ sie die Trainingsdaten mit einer winzigen, festen Anzahl von Dokumenten, die der KI eine einfache schlechte Angewohnheit beibringen sollten: wann sie den Auslösesatz sah <SUDO>es sollte völliges Kauderwelsch ausgeben – eine Artwork „Denial-of-Service“-Angriff.

Eine ständige Verletzlichkeit

Die Ergebnisse waren erschreckend konsistent. Die Forscher fanden heraus, dass der Erfolg des Angriffs quick nichts mit der Größe des Modells zu tun hatte. Obwohl das 13-Milliarden-Parameter-Modell auf mehr als 20-mal mehr sauberen Daten trainiert wurde als das 600-Millionen-Parameter-Modell, wurden beide erfolgreich durch die gleiche kleine Anzahl an manipulierten Dokumenten hinterlegt.

• Die absolute Zählung ist entscheidend: Der Erfolg des Angriffs hing davon ab absolute Zahl Anzahl der vom Modell erkannten schädlichen Dokumente, nicht der Prozentsatz der gesamten Daten, die sie darstellten.
• Die magische Zahl ist klein: Nur 100 vergiftete Dokumente waren nicht genug um zuverlässig eine Hintertür zu erstellen. Sobald jedoch die Zahl erreicht battle 250Der Angriff gelang über alle Modellgrößen hinweg durchweg.

Das Ergebnis ist, dass ein Angreifer keinen großen Teil des Internets kontrollieren muss, um ein Modell zu kompromittieren. Sie müssen lediglich ein paar Hundert sorgfältig ausgearbeitete Dokumente in einen Trainingsdatensatz integrieren, eine Aufgabe, die im Vergleich zur Erstellung von Millionen trivial ist.

Additionally, was ist der Haken? Die Forscher weisen schnell auf die Grenzen ihrer Studie hin. Dabei handelte es sich um einen relativ einfachen Angriff, der darauf abzielte, ein harmloses, wenn auch ärgerliches Ergebnis (Kauderwelschtext) zu erzielen. Es ist immer noch eine offene Frage, ob der gleiche Development für größere „Frontier“-Modelle oder für gefährlichere Hintertüren gilt, etwa solche, die Sicherheitsfunktionen umgehen oder anfälligen Code schreiben sollen. Aber genau diese Unsicherheit ist der Punkt. Mit der Veröffentlichung dieser Erkenntnisse schlägt das Group Alarm für die gesamte KI-Branche.

---

Hervorgehobener Bildnachweis

Ich diskutiere einen bestimmten Schritt der RAG -Pipeline: den Dokumentenabrufschritt. Dieser Schritt ist für die Leistung eines Lappensystems von entscheidender Bedeutung, wenn man bedenkt, dass es für ein LLM schwierig ist, die relevantesten Dokumente zu erhalten, die Fragen des Benutzers korrekt zu beantworten. Ich werde den traditionellen Ansatz zum Abholen der relevantesten Dokumente, einige Techniken zur Verbesserung und die Vorteile diskutieren, die Sie aus einem besseren Dokumentenabruf in Ihrer Lag -Pipeline sehen werden.

Gemäß meinem letzten Artikel über Anreicherung des LLM -Kontextes mit MetadatenIch werde mein Hauptziel für diesen Artikel schreiben:

Mein Ziel In diesem Artikel soll hervorgehoben werden, wie Sie die relevantesten Dokumente für Ihre KI -Suche abrufen und filtern können.

Inhaltsverzeichnis

Warum ist ein optimales Dokumentenabruf wichtig?

Es ist wichtig zu verstehen, warum das Dokument für jede Lag -Pipeline so kritisch ist. Um dies zu verstehen, müssen Sie auch einen allgemeinen Umriss des Flusses in einer Lappenpipeline haben:

1. Der Benutzer geht in seine Abfrage ein
2. Die Abfrage ist eingebettet, und Sie berechnen die Einbettung der Ähnlichkeit zwischen der Abfrage und jedem einzelnen Dokument (oder ein Teil des Dokuments)
3. Wir holen die relevantesten Dokumente, die auf der Einbettung der Ähnlichkeit basieren
4. Die relevantesten Dokumente (oder Brocken) werden in ein LLM eingespeist und werden aufgefordert, die Benutzerfrage angesichts der bereitgestellten Brocken zu beantworten

Jetzt gibt es einige Aspekte der Pipeline, was wichtig ist. Elemente wie:

• Welches Einbettungsmodell verwenden Sie
• Welches LLM -Modell verwenden Sie?
• Wie viele Dokumente (oder Brocken) holen Sie ab?

Ich würde jedoch argumentieren, dass es wahrscheinlich keinen Aspekt gibt, der wichtiger ist als die Auswahl der Dokumente. Dies liegt daran, dass es ohne die richtigen Dokumente keine Rolle spielt, wie intestine Sie LLM sind oder wie viele Brocken Sie abrufen, ist die Antwort am wahrscheinlichsten falsch.

Das Modell wird wahrscheinlich mit einem etwas schlechteren Einbettungsmodell oder einem etwas älteren LLM funktionieren. Wenn Sie jedoch nicht die richtigen Dokumente abrufen, fällt Ihre Lag -Pipeline aus.

Traditionelle Ansätze

Ich werde zunächst einige traditionelle Ansätze verstehen, die heute verwendet werden, wobei ich hauptsächlich die Einbettung der Ähnlichkeit oder der Key phrase -Suche anhand einbettet.

Ähnlichkeit einbetten

Die Verwendung von Ähnlichkeiten, um die relevantesten Dokumente abzurufen, ist heute der Ansatz. Dies ist ein solider Ansatz, der in den meisten Anwendungsfällen anständig ist. RAG mit dem Einbetten von Ähnlichkeitsdokumenten Abruf ist genau so, wie ich oben beschrieben habe.

Key phrase -Suche

Die Key phrase -Suche wird häufig auch zum Abrufen relevanter Dokumente verwendet. Traditionelle Ansätze wie TF-IDF oder BM25 werden bis heute mit Erfolg verwendet. Die Key phrase -Suche hat jedoch auch ihre Schwächen. Beispielsweise holt es nur Dokumente, die auf einer genauen Übereinstimmung basieren, was Probleme einführt, wenn eine genaue Übereinstimmung nicht möglich ist.

Daher möchte ich einige andere Techniken diskutieren, mit denen Sie Ihren Dokumentenabrufschritt verbessern können.

Techniken, um relevantere Dokumente zu holen

In diesem Abschnitt werde ich einige fortgeschrittenere Techniken erörtern, um die relevantesten Dokumente abzurufen. Ich werde den Abschnitt in zwei Teile teilen. Der erste Abschnitt behandelt das Optimieren von Dokumentenabruf für den Rückruf und bezieht sich auf das Abrufen möglichst viele der relevanten Dokumente wie möglich aus dem Korpus der verfügbaren Dokumente. In dem anderen Unterabschnitt wird erläutert, wie die Präzision optimiert werden kann. Dies bedeutet, dass die von Ihnen abgerufenen Dokumente tatsächlich korrekt und für die Benutzerabfrage related sind.

Rückruf: Holen Sie sich mehr von den relevanten Dokumenten

Ich werde die folgenden Techniken diskutieren:

• Kontextabruf
• Mehr Stücke holen
• Wiederbelebung

Kontextabruf

Kontextabruf ist eine von Anthropic im September 2024 eingeführte Technik. Ihr Artikel behandelt zwei Themen: Hinzufügen von Kontext zum Dokumentieren von Brocken und die Kombination der Schlüsselwortsuche (BM25) mit semantischer Suche, um relevante Dokumente abzurufen.

Um den Dokumenten einen Kontext hinzuzufügen, nehmen sie jedes Dokumentanteil und fordern ein LLM auf, angesichts des Chunks und des gesamten Dokuments, um den Chunk um sowohl Informationen aus dem angegebenen Chunk als auch im relevanten Kontext aus dem gesamten Dokument umzuschreiben.

Wenn Sie beispielsweise ein Dokument in zwei Stücke unterteilt haben. Wenn Chunk One wichtige Metadaten wie Adresse, Datum, Ort und Uhrzeit enthält, und der andere Chunk enthält Informationen zu einem Mietvertrag. Die LLM könnte den zweiten Teil umschreiben, um sowohl den Mietvertrag als auch den relevantesten Teil des ersten Teils einzuschließen, in diesem Fall die Adresse, der Ort und das Datum.

Anthropic erläutert auch die Kombination der semantischen Suche und der Key phrase -Suche in ihrem Artikel, das Abrufen von Dokumenten mit beiden Techniken und verwendet einen priorisierten Ansatz, um die von jeder Technik abgerufenen Dokumente zu kombinieren.

Mehr Stücke holen

Ein einfacherer Ansatz, um mehr von den relevanten Dokumenten abzurufen, besteht darin, einfach mehr Stücke zu holen. Je mehr Stücke Sie holen, desto höher ist Ihre Wahrscheinlichkeit, die relevanten Stücke zu holen. Dies hat jedoch zwei Hauptabgriffen:

• Sie werden wahrscheinlich auch irrelevantere Brocken erhalten (Impacting Recall)
• Sie erhöhen die Menge an Token, die Sie Ihrem LLM füttern, was sich negativ auf die Ausgangsqualität der LLM auswirken kann

Umruft erneut zu erinnern

Das Neuaufbau ist auch eine leistungsstarke Technik, mit der die Präzision und das Abrufen relevanter Dokumente an eine Benutzerabfrage erhöht werden können. Wenn Sie Dokumente basieren, die auf semantischer Ähnlichkeit basieren, weisen Sie allen Brocken eine Ähnlichkeitsbewertung zu und halten in der Regel nur die obersten ok ähnlichen Brocken (ok ist normalerweise eine Zahl zwischen 10 und 20, aber es variiert für verschiedene Anwendungen). Dies bedeutet, dass ein Reranker versuchen sollte, die relevanten Dokumente in die relevantesten Dokumente zu stellen und gleichzeitig irrelevante Dokumente aus derselben Liste zu halten. Ich denke, Qwen Reranker ist ein gutes Modell; Es gibt jedoch auch viele andere Reranker da draußen.

Präzision: Filtern Sie irrelevante Dokumente weg

• Wiederbelebung
• LLM -Überprüfung

Präzision neu sein

Wie im letzten Abschnitt zum Rückruf erläutert, können Reranker auch zur Verbesserung der Präzision verwendet werden. Reranker erhöhen den Rückruf, indem sie relevante Dokumente in die oberste Okay -Liste der relevanten Dokumente hinzufügen. Auf der anderen Seite werden die Reranker die Präzision verbessern, indem sie sicherstellen, dass die irrelevanten Dokumente nicht in der Liste der relevantesten Dokumente von Okay fernhalten.

LLM -Überprüfung

Die Verwendung von LLM, um die Relevanz der Chunk (oder Dokument) zu beurteilen, ist auch eine leistungsstarke Technik, um irrelevante Stücke wegzufiltern. Sie können einfach eine Funktion wie unten erstellen:

def is_relevant_chunk(chunk_text: str, user_query: str) -> bool:
    """
    Confirm if the chunk textual content is related to the person question
    """

    immediate = f"""
    Given the offered person question, and chunk textual content, decide whether or not the chunk textual content is related to reply the person question.
    Return a json response with {
        "related": bool
    }
    <user_query>{user_query}</user_query>
    <chunk_text>{chunk_text}</chunk_text>
    """
    return llm_client.generate(immediate)

Anschließend füttern Sie jedes Stück (oder Dokument) durch diese Funktion und behalten nur die Brocken oder Dokumente, die von der LLM als related beurteilt werden.

Diese Technik hat zwei Hauptabgrenzen:

• LLM Kosten
• LLM -Reaktionszeit

Sie werden viele LLM -API -Anrufe senden, die zwangsläufig erhebliche Kosten entstehen. Darüber hinaus dauert das Senden von so vielen Anfragen Zeit, was Ihrer Lag -Pipeline eine Verzögerung verleiht. Sie sollten dies mit der Notwendigkeit einer schnellen Antworten auf die Benutzer ausgleichen.

Vorteile der Verbesserung des Dokumentenabrufs

Die Verbesserung des Dokumentabrufschritts in Ihrer Lag -Pipeline hat zahlreiche Vorteile. Einige Beispiele sind:

• Bessere LLM -Frage zur Beantwortung der Leistung
• Weniger Halluzinationen
• Öfter in der Lage, die Fragen der Benutzer korrekt zu beantworten
• Im Wesentlichen erleichtert es den Job der LLMs

Insgesamt steigt die Fähigkeit Ihres Fragenbeantwortungsmodells in Bezug auf die Anzahl der erfolgreich beantworteten Benutzeranfragen. Dies ist die Metrik, die ich empfehle, um Ihr Lappensystem zu bewerten, und Sie können mehr über LLM -Systembewertungen in meinem Artikel über lesen Bewertung von 5 Millionen Dokumenten mit automatischen Evalen.

Weniger Halluzinationen sind ebenfalls ein unglaublich wichtiger Faktor. Halluzinationen sind eines der wichtigsten Probleme, mit denen wir mit LLMs konfrontiert sind. Sie sind so schädlich, weil sie das Vertrauen der Benutzer in das Frage-Antworten-System senken, wodurch sie weniger wahrscheinlich sind, dass sie Ihre Anwendung weiterhin verwenden. Es ist jedoch wertvoll, die Menge an Halluzinationen zu minimieren, die das Lag -System erzeugt.

Weniger irrelevante Dokumente (Präzision) vermeiden auch die Probleme von Kontext aufblähen (zu viel Lärm im Kontext) oder sogar Kontextvergiftung (falsche Informationen in den Dokumenten angegeben).

Zusammenfassung

In diesem Artikel habe ich besprochen, wie Sie den Dokumentenabrufschritt Ihrer Lag -Pipeline verbessern können. Ich begann zu diskutieren, wie ich glaube, dass der Dokumentenabrufschritt der wichtigste Teil der Rag -Pipeline ist, und Sie sollten Zeit damit verbringen, diesen Schritt zu optimieren. Darüber hinaus habe ich diskutiert, wie herkömmliche Lag -Pipelines relevante Dokumente durch semantische Suche und Keywordsuche abrufen. Weiter diskutierte ich über Techniken, die Sie verwenden können, um sowohl die Präzision als auch den Rückruf von abgerufenen Dokumenten mit Techniken wie dem Kontextabruf und der LLM -Chunk -Überprüfung zu verbessern.

Finden Sie mich in Socials:

Sich in Verbindung setzen

LinkedIn

X / Twitter

Medium