curl -LsSf https://llama.app/set up.sh | sh

echo 'export PATH="$HOME/.native/bin:$PATH"' >> ~/.bashrc
supply ~/.bashrc

export HF_HOME="/workspace/huggingface"
mkdir -p "$HF_HOME"

echo 'export HF_HOME="/workspace/huggingface"' >> ~/.bashrc
supply ~/.bashrc

llama serve 
  -hf "empero-ai/Qwythos-9B-Claude-Mythos-5-1M-GGUF:MTP-Q6_K" 
  --alias "qwythos-9b-mtp" 
  --host 0.0.0.0 
  --port 8910 
  --n-gpu-layers all 
  --ctx-size 100000 
  --parallel 1 
  --batch-size 1024 
  --ubatch-size 512 
  --flash-attn on 
  --cache-type-k q8_0 
  --cache-type-v q8_0 
  --spec-type draft-mtp 
  --spec-draft-n-max 6 
  --threads 12 
  --threads-batch 24 
  --temp 0.6 
  --top-p 0.95 
  --top-k 20 
  --repeat-penalty 1.05 
  --jinja 
  --perf

curl -fsSL https://pi.dev/set up.sh | sh

pi set up git:github.com/huggingface/pi-llama

mkdir new-project
cd new-project

export LLAMA_BASE_URL="http://127.0.0.1:8910/v1"

python csv2excel.py sample_data.csv output.xlsx

[ad_2]

LEC übertrifft erstklassige Modelle wie GPT-4o, indem es die Effizienz eines ML-Klassifikators mit dem Sprachverständnis eines LLM kombiniert

Stellen Sie sich vor, Sie sitzen in einem Sitzungssaal, diskutieren über die transformativste Technologie unserer Zeit – künstliche Intelligenz – und stellen fest, dass wir ohne zuverlässigen Sicherheitsgurt auf einer Rakete sitzen. Die Bletchley-Erklärung, die während des von der britischen Regierung veranstalteten und von 29 Ländern unterstützten AI Security Summit vorgestellt wurde, spiegelt diese Stimmung perfekt wider (1):

„Es besteht die Möglichkeit schwerwiegender, sogar katastrophaler Schäden, ob vorsätzlich oder unbeabsichtigt, die sich aus den wichtigsten Fähigkeiten dieser KI-Modelle ergeben.“

Jedoch, Bestehende KI-Sicherheitsansätze zwingen Unternehmen zu einem nicht gewinnbaren Kompromiss zwischen Kosten, Geschwindigkeit und Genauigkeit. Herkömmliche Klassifikatoren für maschinelles Lernen haben Schwierigkeiten, die Feinheiten der natürlichen Sprache zu erfassen, und LLMs sind zwar leistungsstark, verursachen jedoch einen erheblichen Rechenaufwand – sie erfordern zusätzliche Modellaufrufe, die die Kosten für jede KI-Sicherheitsüberprüfung in die Höhe treiben.

Unser Workforce (Mason Sawtell, Sandi Besen, Tula Masterman, Jim Brown) führt einen neuartigen Ansatz namens LEC (Layer Enhanced Classification) ein.

Wir beweisen, dass LEC die Recheneffizienz eines Klassifikators für maschinelles Lernen mit dem ausgefeilten Sprachverständnis eines LLM kombiniert – Sie müssen sich additionally nicht zwischen Kosten, Geschwindigkeit und Genauigkeit entscheiden. LEC übertrifft erstklassige Modelle wie GPT-4o und Modelle, die speziell für die Identifizierung unsicherer Inhalte und sofortige Injektionen geschult wurden. Was noch besser ist: Wir glauben, dass LEC modifiziert werden kann, um nicht KI-sicherheitsrelevante Textklassifizierungsaufgaben wie Sentimentanalyse, Absichtsklassifizierung, Produktkategorisierung und mehr zu bewältigen.

Die Auswirkungen sind tiefgreifend. Ganz gleich, ob Sie ein Technologieführer sind, der sich im komplexen Umfeld der KI-Sicherheit zurechtfindet, ein Produktmanager, der potenzielle Risiken mindert, oder eine Führungskraft, die eine verantwortungsvolle Innovationsstrategie entwirft, unser Ansatz bietet eine skalierbare und anpassungsfähige Lösung.

Weitere Particulars finden Sie im vollständiges Papier’s Vorabdruck auf Arxiv(2) oder in Tula Mastermans zusammengefasster Artikel über das Papier.

Verantwortungsvolle KI ist zu einer entscheidenden Priorität für Technologieführer im gesamten Ökosystem geworden – von Modellentwicklern wie Anthropic, OpenAI, Meta, Google und IBM bis hin zu Unternehmensberatungsfirmen und KI-Dienstleistern. Je schneller die Einführung von KI voranschreitet, desto wichtiger wird ihre Bedeutung.

Unsere Forschung konzentriert sich speziell auf zwei zentrale Herausforderungen der KI-Sicherheit: Inhaltssicherheit und schnelle Erkennung von Injektionen. Inhaltssicherheit bezieht sich auf den Prozess der Identifizierung und Verhinderung der Erstellung schädlicher, unangemessener oder potenziell gefährlicher Inhalte, die Risiken für Benutzer darstellen oder gegen ethische Richtlinien verstoßen könnten. Bei der sofortigen Injektion werden Versuche erkannt, KI-Systeme zu manipulieren, indem Eingabeaufforderungen erstellt werden, die darauf abzielen, Sicherheitsmechanismen zu umgehen oder das Modell zu unethischen Ausgaben zu zwingen.

Um den Bereich der ethischen KI voranzutreiben, haben wir die Fähigkeiten von LEC auf reale, verantwortungsvolle KI-Anwendungsfälle angewendet. Wir hoffen, dass diese Methodik weit verbreitet wird und dazu beiträgt, jedes KI-System weniger anfällig für Ausbeutung zu machen.

Wir haben einen Datensatz zur Inhaltssicherheit mit 5.000 Beispielen kuratiert, um LEC sowohl hinsichtlich der binären (2 Kategorien) als auch der Mehrklassenklassifizierung (>2 Kategorien) zu testen. Wir haben den SALAD Information-Datensatz von OpenSafetyLab (3) zur Darstellung unsicherer Inhalte und den „LMSYS-Chat-1M“-Datensatz von LMSYS zur Darstellung sicherer Inhalte (4) verwendet.

Bei der binären Klassifizierung ist der Inhalt entweder „sicher“ oder „unsicher“. Bei der Klassifizierung nach mehreren Klassen werden Inhalte entweder als „sicher“ kategorisiert oder einer bestimmten Kategorie „unsicher“ zugeordnet.

Wir verglichen mit LEC trainierte Modelle mit GPT-4o (weithin als Branchenführer anerkannt), Llama Guard 3 1B und Llama Guard 3 8B (Spezialmodelle, die speziell für die Bewältigung von Inhaltssicherheitsaufgaben geschult wurden). Wir haben festgestellt, dass die Modelle, die LEC verwenden, alle Modelle übertrafen, die wir mit nur 20 Trainingsbeispielen für die Binärklassifizierung und 50 Trainingsbeispielen für die Mehrklassenklassifizierung verglichen haben.

Das leistungsstärkste LEC-Modell erreichte einen gewichteten F1-Rating (misst, wie intestine ein System das Treffen korrekter Vorhersagen bei gleichzeitiger Minimierung von Fehlern ausbalanciert) von 0,96 einer maximalen Punktzahl von 1 bei der binären Klassifizierungsaufgabe, verglichen mit der Punktzahl von GPT-4o von 0,82 oder der Punktzahl von LlamaGuard 8B von 0,71.

Das bedeutet, dass Sie mit LEC mit nur 15 Beispielen ein Modell trainieren können, um Branchenführer bei der Identifizierung sicherer oder unsicherer Inhalte zu einem Bruchteil des Rechenaufwands zu übertreffen.

Wir haben einen Immediate-Injection-Datensatz mithilfe des SPML-Chatbot-Immediate-Injection-Datensatzes kuratiert. Wir haben den SPML-Datensatz aufgrund seiner Vielfalt und Komplexität bei der Darstellung realer Chatbot-Szenarien ausgewählt. Dieser Datensatz enthielt Paare von System- und Benutzeraufforderungen, um Benutzeraufforderungen zu identifizieren, die versuchen, die Systemaufforderung zu umgehen oder zu manipulieren. Dies ist besonders related für Unternehmen, die öffentlich zugängliche Chatbots einsetzen, die nur dazu gedacht sind, Fragen zu bestimmten Domänen zu beantworten.

Wir haben mit LEC trainierte Modelle mit GPT-4o (einem Branchenführer) und deBERTa v3 Immediate Injection v2 (einem Modell, das speziell für die Identifizierung von Immediate-Injektionen trainiert wurde) verglichen. Wir haben festgestellt, dass die Modelle, die LEC verwenden, sowohl GPT-4o mit 55 Trainingsbeispielen als auch das Spezialmodell mit nur 5 Trainingsbeispielen übertrafen.

Das leistungsstärkste LEC-Modell erreichte einen gewichteten F1-Rating von 0,98 bei einem maximalen Rating von 1 im Vergleich zum GPT-4o-Rating von 0,92 oder dem deBERTa v2 Immediate Injection v2-Rating von 0,73.

Das bedeutet, dass Sie mit LEC mit nur fünf Beispielen ein Modell trainieren können, um Branchenführer bei der Erkennung von Immediate-Injection-Angriffen zu übertreffen.

Die vollständigen Ergebnisse und Particulars zur Experimentierimplementierung finden Sie im Arxiv-Preprint.

Da Unternehmen zunehmend KI in ihre Abläufe integrieren, ist die Gewährleistung der Sicherheit und Integrität KI-gesteuerter Interaktionen geschäftskritisch geworden. LEC bietet eine robuste und versatile Möglichkeit, sicherzustellen, dass potenziell unsichere Informationen erkannt werden – was zu einer Reduzierung des Betriebsrisikos und einem erhöhten Vertrauen der Endbenutzer führt. Es gibt mehrere Möglichkeiten, LEC-Modelle in Ihr KI-Sicherheits-Toolkit zu integrieren, um unerwünschte Schwachstellen bei der Verwendung Ihrer KI-Instruments zu verhindern, einschließlich während der LM-Inferenz, vor/nach der LM-Inferenz und sogar in Multi-Agent-Szenarien.

Während der LM-Inferenz

Wenn Sie ein Open-Supply-Modell verwenden oder Zugriff auf das Innenleben des Closed-Supply-Modells haben, können Sie LEC als Teil Ihrer Inferenzpipeline für KI-Sicherheit nahezu in Echtzeit verwenden. Dies bedeutet, dass die Generierung jeglicher Ausgabe angehalten werden kann, wenn Sicherheitsbedenken auftreten, während Informationen durch das Sprachmodell übertragen werden. Ein Beispiel dafür, wie dies aussehen könnte, ist in Abbildung 1 zu sehen.

Vorher/Nachher LM-Inferenz

Wenn Sie keinen Zugriff auf das Innenleben des Sprachmodells haben oder die Prüfung auf Sicherheitsbedenken als separate Aufgabe durchführen möchten, können Sie vor oder nach dem Aufruf eines Sprachmodells ein LEC-Modell verwenden. Dadurch ist LEC mit Closed-Supply-Modellen wie den Claude- und GPT-Familien kompatibel.

Durch die Integration eines LEC-Klassifikators in Ihre Bereitstellungspipeline können Sie verhindern, dass potenziell schädliche Inhalte an Ihr LM weitergeleitet werden, und/oder eine Prüfung auf schädliche Inhalte durchgeführt wird, bevor eine Ausgabe an den Benutzer zurückgegeben wird.

Verwendung von LEC-Klassifikatoren mit Agenten

Agentische KI-Systeme können bestehende unbeabsichtigte Aktionen verstärken, was zu einem verstärkenden Effekt unbeabsichtigter Folgen führt. LEC-Klassifikatoren können zu verschiedenen Zeitpunkten in einem Agentenszenario verwendet werden, um den Agenten davor zu schützen, schädliche Ausgaben zu empfangen oder zu erzeugen. Durch die Einbeziehung von LEC-Modellen in Ihre Agentenarchitektur können Sie beispielsweise:

• Überprüfen Sie, ob die Anfrage in Ordnung ist, um mit der Bearbeitung zu beginnen
• Stellen Sie sicher, dass ein aufgerufener Device-Aufruf nicht gegen KI-Sicherheitsrichtlinien verstößt (z. B. durch die Generierung unangemessener Suchthemen für eine Stichwortsuche).
• Stellen Sie sicher, dass die an einen Agenten zurückgegebenen Informationen nicht schädlich sind (z. B. sind die von der RAG-Suche oder der Google-Suche zurückgegebenen Ergebnisse „sicher“).
• Validierung der endgültigen Antwort eines Agenten, bevor diese an den Benutzer zurückgegeben wird

So implementieren Sie LEC basierend auf dem Zugriff auf Sprachmodelle

Unternehmen mit Zugriff auf die interne Funktionsweise von Modellen können LEC direkt in die Inferenzpipeline integrieren und so eine kontinuierliche Sicherheitsüberwachung während des gesamten Content material-Generierungsprozesses der KI ermöglichen. Bei der Verwendung von Closed-Supply-Modellen über API (wie im Fall von GPT-4) haben Unternehmen keinen direkten Zugriff auf die zugrunde liegenden Informationen, die zum Trainieren eines LEC-Modells erforderlich sind. In diesem Szenario kann LEC vor und/oder nach Modellaufrufen angewendet werden. Beispielsweise kann vor einem API-Aufruf die Eingabe auf unsichere Inhalte überprüft werden. Nach dem Anruf kann die Ausgabe validiert werden, um sicherzustellen, dass sie mit den Sicherheitsprotokollen des Unternehmens übereinstimmt.

Unabhängig davon, für welche Artwork und Weise Sie sich für die Implementierung von LEC entscheiden, bietet Ihnen die Nutzung seiner leistungsstarken Fähigkeiten eine überlegene Inhaltssicherheit und einen sofortigen Injektionsschutz als bestehende Techniken und das zu einem Bruchteil der Zeit und Kosten.

Layer Enhanced Classification (LEC) ist der Sicherheitsgurt für das KI-Raketenschiff, auf dem wir uns befinden.

Das Wertversprechen ist klar: Die KI-Sicherheitsmodelle von LEC können regulatorische Risiken mindern, zur Gewährleistung des Markenschutzes beitragen und das Vertrauen der Benutzer in KI-gesteuerte Interaktionen stärken. Es läutet eine neue Ära der KI-Entwicklung ein, in der Genauigkeit, Geschwindigkeit und Kosten keine konkurrierenden Prioritäten darstellen und KI-Sicherheitsmaßnahmen sowohl zur Inferenzzeit, vor der Inferenzzeit als auch nach der Inferenzzeit angegangen werden können.

In unseren Inhaltssicherheitsexperimenten die leistungsstärkste Das LEC-Modell erreichte einen gewichteten F1-Rating von 0,96 von 1 bei der binären Klassifizierung, übertrifft die Punktzahl von GPT-4o deutlich von 0,82 und die Punktzahl von LlamaGuard 8B von 0,71 – und das wurde erreicht mit nur 15 Trainingsbeispielen. Ähnlich verhält es sich bei der sofortigen Injektionserkennung: Unser Prime-LEC-Modell erreichte einen gewichteten F1-Wert von 0,98, verglichen mit dem GPT-4o von 0,92 und deBERTa v2 Immediate Injection v2 liegt bei 0,73 und wurde mit nur 55 Trainingsbeispielen erreicht. Diese Ergebnisse zeigen nicht nur eine überlegene Leistung, sondern unterstreichen auch die bemerkenswerte Fähigkeit von LEC, mit minimalen Trainingsdaten eine hohe Genauigkeit zu erreichen.

Obwohl sich unsere Arbeit auf die Verwendung von LEC-Modellen für KI-Sicherheitsanwendungsfälle konzentrierte, gehen wir davon aus, dass unser Ansatz für eine größere Vielfalt von Textklassifizierungsaufgaben verwendet werden kann. Wir ermutigen die Forschungsgemeinschaft, unsere Arbeit als Sprungbrett zu nutzen, um zu erkunden, was sonst noch erreicht werden kann – um neue Wege für intelligentere, sicherere und vertrauenswürdigere KI-Systeme zu eröffnen.

[ad_2]

Llama-3.2–1 B-Instruct und LanceDB

Abstrakt: Retrieval-Augmented Era (RAG) kombiniert große Sprachmodelle mit externen Wissensquellen, um genauere und kontextbezogenere Antworten zu erzeugen. In diesem Artikel wird untersucht, wie kleinere Sprachmodelle (LLMs), wie das kürzlich Open-Supply-Modell Meta 1 Billion, effektiv zum Zusammenfassen und Indexieren großer Dokumente genutzt werden können, wodurch die Effizienz und Skalierbarkeit von RAG-Systemen verbessert wird. Wir bieten eine Schritt-für-Schritt-Anleitung mit Codeausschnitten, wie Sie Textabschnitte aus einer Produktdokumentations-PDF-Datei zusammenfassen und zum effizienten Abruf in einer LanceDB-Datenbank speichern.

Einführung

Retrieval-Augmented Era ist ein Paradigma, das die Fähigkeiten von Sprachmodellen durch deren Integration in externe Wissensdatenbanken erweitert. Während große LLMs wie GPT-4 bemerkenswerte Fähigkeiten bewiesen haben, sind sie mit erheblichen Rechenkosten verbunden. Kleine LLMs bieten eine ressourceneffizientere Different, insbesondere für Aufgaben wie Textzusammenfassung und Schlüsselwortextraktion, die für die Indizierung und den Abruf in RAG-Systemen von entscheidender Bedeutung sind.

In diesem Artikel zeigen wir, wie Sie mit einem kleinen LLM Folgendes erreichen:

1. Extrahieren und fassen Sie Textual content aus einem PDF-Dokument zusammen.
2. Generieren Sie Einbettungen für Zusammenfassungen und Schlüsselwörter.
3. Speichern Sie die Daten effizient in einer LanceDB-Datenbank.
4. Nutzen Sie dies für eine effektive RAG
5. Außerdem ein Agenten-Workflow zur Selbstkorrektur von Fehlern aus dem LLM

Die Verwendung eines kleineren LLM reduziert die Kosten für diese Artwork von Konvertierungen bei großen Datensätzen drastisch und bietet ähnliche Vorteile für einfachere Aufgaben wie die LLMs mit größeren Parametern und kann mit minimalen Kosten problemlos im Unternehmen oder in der Cloud gehostet werden.

Wir werden verwenden Lama 3,2 1 Milliarde Parametermodell, das derzeit kleinste hochmoderne LLM.

Das Downside beim Einbetten von Rohtext

Bevor wir uns mit der Implementierung befassen, ist es wichtig zu verstehen, warum das Einbetten von Rohtext aus Dokumenten in RAG-Systemen problematisch sein kann.

Ineffektive Kontexterfassung

Das Einbetten von Rohtext von einer Seite ohne Zusammenfassung führt häufig zu folgenden Einbettungen:

• Hochdimensionales Rauschen: Rohtext kann irrelevante Informationen, Formatierungsartefakte oder Textbausteine ​​enthalten, die nicht zum Verständnis des Kerninhalts beitragen.
• Verwässerte Schlüsselkonzepte: Wichtige Konzepte können in fremdem Textual content verborgen sein, wodurch die Einbettungen weniger repräsentativ für die kritischen Informationen sind.

Ineffizienz beim Abrufen

Wenn Einbettungen die Schlüsselkonzepte des Textes nicht genau wiedergeben, versagt das Retrieval-System möglicherweise:

• Passen Sie Benutzeranfragen effektiv an: Die Einbettungen stimmen möglicherweise nicht intestine mit den Abfrageeinbettungen überein, was zu einem schlechten Abruf relevanter Dokumente führt.
• Geben Sie den richtigen Kontext an: Selbst wenn ein Dokument abgerufen wird, bietet es aufgrund des Rauschens bei der Einbettung möglicherweise nicht die genauen Informationen, die der Benutzer sucht.

Lösung: Zusammenfassung vor dem Einbetten

Das Zusammenfassen des Textes vor dem Generieren von Einbettungen behebt diese Probleme durch:

• Wichtige Informationen destillieren: Durch die Zusammenfassung werden die wesentlichen Punkte und Schlüsselwörter extrahiert und unnötige Particulars entfernt.
• Verbesserung der Einbettungsqualität: Aus Zusammenfassungen generierte Einbettungen sind fokussierter und repräsentativer für den Hauptinhalt, wodurch die Abrufgenauigkeit verbessert wird.

Voraussetzungen

Bevor wir beginnen, stellen Sie sicher, dass Sie Folgendes installiert haben:

• Python 3.7 oder höher
• PyTorch
• Transformers-Bibliothek
• SatzTransformers
• PyMuPDF (zur PDF-Verarbeitung)
• LanceDB
• Ein Laptop computer mit mindestens 6 GB GPU oder Colab (T4-GPU reicht aus) oder ähnliches

Schritt 1: Einrichten der Umgebung

Importieren Sie zunächst alle erforderlichen Bibliotheken und richten Sie die Protokollierung zum Debuggen und Nachverfolgen ein.

import pandas as pd
import fitz  # PyMuPDF
from transformers import AutoModelForCausalLM, AutoTokenizer
import torch
import lancedb
from sentence_transformers import SentenceTransformer
import json
import pyarrow as pa
import numpy as np
import re

Schritt 2: Hilfsfunktionen definieren

Erstellen der Eingabeaufforderung

Wir definieren eine Funktion zum Erstellen von Eingabeaufforderungen, die mit dem LLAMA 3.2-Modell kompatibel sind.

def create_prompt(query):
    """
    Create a immediate as per LLAMA 3.2 format.
    """
    system_message = "You're a useful assistant for summarizing textual content and lead to JSON format"
    prompt_template = f'''
<|begin_of_text|><|start_header_id|>system<|end_header_id|>
{system_message}<|eot_id|><|start_header_id|>person<|end_header_id|>
{query}<|eot_id|><|start_header_id|>assistant1231231222<|end_header_id|>
'''
    return prompt_template

Verarbeitung der Eingabeaufforderung

Diese Funktion verarbeitet die Eingabeaufforderung mithilfe des Modells und des Tokenizers. Wir stellen die Temperatur auf 0,1 ein, um das Modell weniger kreativ (weniger halluzinierend) zu machen.

def process_prompt(immediate, mannequin, tokenizer, machine, max_length=500):
    """
    Processes a immediate, generates a response, and extracts the assistant's reply.
    """
    prompt_encoded = tokenizer(immediate, truncation=True, padding=False, return_tensors="pt")
    mannequin.eval()
    output = mannequin.generate(
        input_ids=prompt_encoded.input_ids.to(machine),
        max_new_tokens=max_length,
        attention_mask=prompt_encoded.attention_mask.to(machine),
        temperature=0.1  # Extra deterministic
    )
    reply = tokenizer.decode(output(0), skip_special_tokens=True)
    elements = reply.break up("assistant1231231222", 1)
   if len(elements) > 1:
        words_after_assistant = elements(1).strip()
        return words_after_assistant
    else:
        print("The assistant's response was not discovered.")
        return "NONE"

Schritt 3: Laden des Modells

Zur Zusammenfassung verwenden wir das LLAMA 3.2 1B Instruct-Modell. Wir laden das Modell mit bfloat16, um den Speicher zu reduzieren, und führen es auf einer NVIDIA-Laptop computer-GPU (NVIDIA GeForce RTX 3060 6 GB/Treiber NVIDIA-SMI 555.58.02/Cuda-Kompilierungstools, Model 12.5, V12.5.40) unter einem Linux-Betriebssystem aus.

Besser wäre es, über vLLM oder besser zu hosten exLLamaV2

model_name_long = "meta-llama/Llama-3.2-1B-Instruct"
tokenizer = AutoTokenizer.from_pretrained(model_name_long)
machine = torch.machine("cuda" if torch.cuda.is_available() else "cpu")
log.information(f"Loading the mannequin {model_name_long}")
bf16 = False
fp16 = True
if torch.cuda.is_available():
    main, _ = torch.cuda.get_device_capability()
    if main >= 8:
        log.information("Your GPU helps bfloat16: speed up coaching with bf16=True")
        bf16 = True
        fp16 = False
# Load the mannequin
device_map = {"": 0}  # Load on GPU 0
torch_dtype = torch.bfloat16 if bf16 else torch.float16
mannequin = AutoModelForCausalLM.from_pretrained(
    model_name_long,
    torch_dtype=torch_dtype,
    device_map=device_map,
)
log.information(f"Mannequin loaded with torch_dtype={torch_dtype}")

Schritt 4: Lesen und Verarbeiten des PDF-Dokuments

Wir extrahieren Textual content aus jeder Seite des PDF-Dokuments.

file_path = './knowledge/troubleshooting.pdf'
dict_pages = {}
# Open the PDF file
with fitz.open(file_path) as pdf_document:
    for page_number in vary(pdf_document.page_count):
        web page = pdf_document.load_page(page_number)
        page_text = web page.get_text()
        dict_pages(page_number) = page_text
        print(f"Processed PDF web page {page_number + 1}")

Schritt 5: Einrichten von LanceDB und SentenceTransformer

Wir initialisieren das SentenceTransformer-Modell zum Generieren von Einbettungen und richten LanceDB zum Speichern der Daten ein. Wir verwenden ein PyArrow-basiertes Schema für die LanceDB-Tabellen

Beachten Sie, dass Schlüsselwörter derzeit nicht verwendet werden, aber für die Hybridsuche verwendet werden können, d. h. für die Suche nach Vektorähnlichkeit sowie bei Bedarf auch für die Textsuche.

# Initialize the SentenceTransformer mannequin
sentence_model = SentenceTransformer('all-MiniLM-L6-v2')
# Connect with LanceDB
db = lancedb.join('./knowledge/my_lancedb')
# Outline the schema utilizing PyArrow
schema = pa.schema((
    pa.discipline("page_number", pa.int64()),
    pa.discipline("original_content", pa.string()),
    pa.discipline("abstract", pa.string()),
    pa.discipline("key phrases", pa.string()),
    pa.discipline("vectorS", pa.list_(pa.float32(), 384)),  # Embedding dimension of 384
    pa.discipline("vectorK", pa.list_(pa.float32(), 384)),
))
# Create or connect with a desk
desk = db.create_table('summaries', schema=schema, mode='overwrite')

Schritt 6: Daten zusammenfassen und speichern

Wir durchlaufen jede Seite, generieren eine Zusammenfassung und Schlüsselwörter und speichern sie zusammen mit Einbettungen in der Datenbank.

# Loop by way of every web page within the PDF
for page_number, textual content in dict_pages.gadgets():
    query = f"""For the given passage, present an extended abstract about it, incorporating all the principle key phrases within the passage.
Format must be in JSON format like under:
{{
    "abstract": <textual content abstract>,
    "key phrases": <a comma-separated record of major key phrases and acronyms that seem within the passage>,
}}
Be sure that JSON fields have double quotes and use the proper closing delimiters.
Passage: {textual content}"""
    
    immediate = create_prompt(query)
    response = process_prompt(immediate, mannequin, tokenizer, machine)
    
    # Error dealing with for JSON decoding
    attempt:
        summary_json = json.masses(response)
    besides json.decoder.JSONDecodeError as e:
        exception_msg = str(e)
        query = f"""Right the next JSON {response} which has {exception_msg} to correct JSON format. Output solely JSON."""
        log.warning(f"{exception_msg} for {response}")
        immediate = create_prompt(query)
        response = process_prompt(immediate, mannequin, tokenizer, machine)
        log.warning(f"Corrected '{response}'")
        attempt:
            summary_json = json.masses(response)
        besides Exception as e:
            log.error(f"Did not parse JSON: '{e}' for '{response}'")
            proceed
    
    key phrases = ', '.be a part of(summary_json('key phrases'))
    
    # Generate embeddings
    vectorS = sentence_model.encode(summary_json('abstract'))
    vectorK = sentence_model.encode(key phrases)
    
    # Retailer the info in LanceDB
    desk.add(({
        "page_number": int(page_number),
        "original_content": textual content,
        "abstract": summary_json('abstract'),
        "key phrases": key phrases,
        "vectorS": vectorS,
        "vectorK": vectorK
    }))
    
    print(f"Knowledge for web page {page_number} saved efficiently.")

Verwendung von LLMs zur Korrektur ihrer Ausgaben

Beim Generieren von Zusammenfassungen und Extrahieren von Schlüsselwörtern können LLMs manchmal Ausgaben erzeugen, die nicht im erwarteten Format vorliegen, z. B. fehlerhaftes JSON.

Wir können das LLM selbst nutzen, um diese Ausgaben zu korrigieren, indem wir es auffordern, die Fehler zu beheben. Dies wird im obigen Code gezeigt

# Use the Small LLAMA 3.2 1B mannequin to create abstract
for page_number, textual content in dict_pages.gadgets():
    query = f"""For the given passage, present an extended abstract about it, incorporating all the principle key phrases within the passage.
    Format must be in JSON format like under: 
    {{
        "abstract": <textual content abstract> instance "Some Abstract textual content",
        "key phrases": <a comma separated record of major key phrases and acronyms that seem within the passage> instance ("keyword1","keyword2"),
    }}
    Be sure that JSON fields have double quotes, e.g., as an alternative of 'abstract' use "abstract", and use the closing and ending delimiters.
    Passage: {textual content}"""
    immediate = create_prompt(query)
    response = process_prompt(immediate, mannequin, tokenizer, machine)
    attempt:
        summary_json = json.masses(response)
    besides json.decoder.JSONDecodeError as e:
        exception_msg = str(e)
        # Use the LLM to appropriate its personal output
        query = f"""Right the next JSON {response} which has {exception_msg} to correct JSON format. Output solely the corrected JSON.
        Format must be in JSON format like under: 
        {{
            "abstract": <textual content abstract> instance "Some Abstract textual content",
            "key phrases": <a comma separated record of key phrases and acronyms that seem within the passage> instance ("keyword1","keyword2"),
        }}"""
        log.warning(f"{exception_msg} for {response}")
        immediate = create_prompt(query)
        response = process_prompt(immediate, mannequin, tokenizer, machine)
        log.warning(f"Corrected '{response}'")
        # Attempt parsing the corrected JSON
        attempt:
            summary_json = json.masses(response)
        besides json.decoder.JSONDecodeError as e:
            log.error(f"Did not parse corrected JSON: '{e}' for '{response}'")
            proceed

Wenn in diesem Codeausschnitt die anfängliche Ausgabe des LLM nicht als JSON geparst werden kann, fordern wir den LLM erneut auf, den JSON zu korrigieren. Dieses Selbstkorrekturmuster verbessert die Robustheit unserer Pipeline.

Angenommen, das LLM generiert das folgende fehlerhafte JSON:

{
    'abstract': 'This web page explains the set up steps for the product.',
    'key phrases': ('set up', 'setup', 'product')
}

Der Versuch, diesen JSON-Code zu analysieren, führt aufgrund der Verwendung von einfachen Anführungszeichen anstelle von doppelten Anführungszeichen zu einem Fehler. Wir erkennen diesen Fehler und fordern das LLM auf, ihn zu korrigieren:

exception_msg = "Anticipating property identify enclosed in double quotes"
query = f"""Right the next JSON {response} which has {exception_msg} to correct JSON format. Output solely the corrected JSON."""

Das LLM stellt dann den korrigierten JSON bereit:

{
    "abstract": "This web page explains the set up steps for the product.",
    "key phrases": ("set up", "setup", "product")
}

Durch die Verwendung des LLM zur Korrektur der eigenen Ausgabe stellen wir sicher, dass die Daten im richtigen Format für die Weiterverarbeitung vorliegen.

Erweiterung der Selbstkorrektur durch LLM-Agenten

Dieses Muster der Verwendung des LLM zur Korrektur seiner Ausgaben kann durch die Verwendung von erweitert und automatisiert werden LLM-Agenten. LLM-Agenten können:

• Automatisieren Sie die Fehlerbehandlung: Fehler erkennen und ohne explizite Anweisungen autonom entscheiden, wie diese behoben werden.
• Effizienz verbessern: Reduzieren Sie den Bedarf an manuellen Eingriffen oder zusätzlichem Code zur Fehlerkorrektur.
• Verbessern Sie die Robustheit: Kontinuierlich aus Fehlern lernen, um zukünftige Ergebnisse zu verbessern.

LLM-Agenten fungieren als Vermittler, die den Informationsfluss verwalten und Ausnahmen clever behandeln. Sie können so gestaltet werden, dass sie:

• Analysieren Sie Ausgaben und validieren Sie Formate.
• Fordern Sie das LLM erneut mit verfeinerten Anweisungen auf, wenn Fehler auftreten.
• Protokollieren Sie Fehler und Korrekturen zur späteren Referenz und Feinabstimmung des Modells.

Ungefähre Umsetzung:

Anstatt Ausnahmen manuell abzufangen und erneut aufzufordern, könnte ein LLM-Agent diese Logik kapseln:

def generate_summary_with_agent(textual content):
    agent = LLMAgent(mannequin, tokenizer, machine)
    query = f"""For the given passage, present a abstract and key phrases in correct JSON format."""
    immediate = create_prompt(query)
    response = agent.process_and_correct(immediate)
    return response

Die LLMAgent-Klasse würde die anfängliche Verarbeitung, Fehlererkennung, erneute Eingabeaufforderung und Korrektur intern übernehmen.

Sehen wir uns nun an, wie wir die Einbettungen erneut für ein effektives RAG-Muster verwenden können, indem wir das LLM als Hilfe beim Rating verwenden.

Abruf und Generierung: Verarbeitung der Benutzerabfrage

Dies ist der übliche Ablauf. Wir nehmen die Frage des Benutzers auf und suchen nach den relevantesten Zusammenfassungen.

# Instance utilization
user_question = "Not in a position to handle new units"
outcomes = search_summary(user_question, sentence_model)

Vorbereiten der abgerufenen Zusammenfassungen

Wir stellen die abgerufenen Zusammenfassungen in einer Liste zusammen und verknüpfen jede Zusammenfassung mit ihrer Seitenzahl als Referenz.

summary_list = ()
for idx, lead to enumerate(outcomes):
    summary_list.append(f"{end result('page_number')}# {end result('abstract')}")

Rangfolge der Zusammenfassungen

Wir veranlassen das Sprachmodell, die abgerufenen Zusammenfassungen nach ihrer Relevanz für die Frage des Benutzers zu ordnen und die relevanteste auszuwählen. Dabei wird für die kontextbezogene Einbettungsübereinstimmung (Vektorübereinstimmung) wiederum das LLM bei der Rangfolge der Zusammenfassungen anstelle der Ok-Nearest Neighbor- oder Cosinus-Distanz oder anderer Rangfolgealgorithmen allein verwendet.

query = f"""From the given record of summaries {summary_list}, rank which abstract may have 
the reply to the query '{user_question}'. Return solely that abstract from the record."""
log.information(query)

Extrahieren der ausgewählten Zusammenfassung und Generieren der endgültigen Antwort

Wir rufen den Originalinhalt ab, der mit der ausgewählten Zusammenfassung verknüpft ist, und veranlassen das Sprachmodell, unter Verwendung dieses Kontexts eine detaillierte Antwort auf die Frage des Benutzers zu generieren.

for idx, lead to enumerate(outcomes):
    if int(page_number) == end result('page_number'):
        web page = end result('original_content')
        query = f"""Are you able to reply the question: '{user_question}' 
utilizing the context under?
Context: '{web page}'
"""
        log.information(query)
        immediate = create_prompt(
            query,
            "You're a useful assistant that can undergo the given question and context, assume in steps, after which attempt to reply the question 
with the knowledge within the context."
        )
        response = process_prompt(immediate, mannequin, tokenizer, machine, temperature=0.01)  # Much less freedom to hallucinate
        log.information(response)
        print("Closing Reply:")
        print(response)
        break

Erläuterung des Workflows

1. Vektorisierung von Benutzerabfragen: Die Frage des Benutzers wird mithilfe desselben SentenceTransformer-Modells, das bei der Indizierung verwendet wurde, in eine Einbettung umgewandelt.
2. Ähnlichkeitssuche: Die Abfrageeinbettung wird verwendet, um die Vektordatenbank (LanceDB) nach den ähnlichsten Zusammenfassungen zu durchsuchen und High 3 zurückzugeben

>>  From the VectorDB Cosine search and High 3 nearest neighbour search end result, 
prepended by linked web page numbers

07:04:00 INFO:From the given record of abstract ((
'112# Can't place newly found machine in managed state', 
'113# The passage discusses the troubleshooting steps for managing newly found units on the NSF platform, particularly addressing points with machine placement, configuration, and deployment.',
'116# Troubleshooting Machine Configuration Backup Challenge')) rank which abstract may have the potential reply to the query Not in a position to handle new units. Return solely that abstract from the record

3. Zusammenfassendes Rating: Die abgerufenen Zusammenfassungen werden an das Sprachmodell übergeben, das sie basierend auf ihrer Relevanz für die Frage des Benutzers einordnet.

>> Asking LLM to Choose from the High N primarily based on context

07:04:01 INFO:Chosen Abstract ''113# The passage discusses the troubleshooting steps for managing newly found units on the NSF (Community Techniques and Useful Necessities) platform, particularly addressing points with machine placement, configuration, and deployment.''

4. Kontextabruf: Der mit der relevantesten Zusammenfassung verknüpfte Originalinhalt wird durch Parsen der Seitenzahl und Abrufen der zugehörigen Seite aus der LanceDB abgerufen

07:04:01 INFO:Web page quantity: 113
07:04:01 INFO:Are you able to reply the query or question or present extra deatils question:'Not in a position to handle new units'         Utilizing the context under
        context:'3 
Test that the server and consumer platforms are appropriately sized. ...
Failed SNMP communication between the server and managed machine.
SNMP traps from managed units are arriving at one server, 
or no SNMP traps are ....
'

5. Antwortgenerierung: Das Sprachmodell generiert anhand des abgerufenen Kontexts eine detaillierte Antwort auf die Frage des Benutzers.

Hier ist eine Beispielausgabe aus einem Beispiel-PDF, das ich verwendet habe

07:04:08 INFO:I'll undergo the steps and supply extra particulars to reply the question.

The question is: "Not in a position to handle new units"

Right here's my step-by-step evaluation:

**Step 1: Test that the server and consumer platforms are appropriately sized**

The context mentions that the NSP Planning Information is accessible, which means that the NSP (Community Service Supplier) has a planning course of to make sure that the server and consumer platforms are sized accurately. This means that the NSP has a course of in place to judge the efficiency and capability of the server and consumer platforms to find out if they're appropriate for managing new units.

**Step 2: Test for resynchronization issues between the managed community and the NFM-P**

The context additionally mentions that resynchronization issues between the managed community and the NFM-P could cause points with managing new units. This means that there could also be an issue with the communication between the server and consumer platforms, which might stop new units from being efficiently managed.

**Step 3: Test for failed SNMP communication between the server and managed machine**

The context particularly mentions that failed SNMP communication between the server and managed machine could cause points with managing new units. This means that there could also be an issue with the communication between the server and the managed machine, which might stop new units from being efficiently managed.

**Step 4: Test for failed deployment of the configuration request**

The context additionally mentions that failed deployment of the configuration request could cause points with managing new units. This means that there could also be an issue with the deployment course of, which might stop new units from being efficiently managed.

**Step 5: Carry out the next steps**

The context instructs the person to carry out the next steps:

1. Select Administration→NE Upkeep→Deployment from the XXX major menu.
2. The Deployment type opens, itemizing incomplete deployments, deployer, tag, state, and different info.

Primarily based on the context, it seems that the person must evaluate the deployment historical past to determine any points that could be stopping the deployment of latest units.

**Reply**

Primarily based on the evaluation, the person must:

1. Test that the server and consumer platforms are appropriately sized.
2. Test for resynchronization issues between the managed community and the NFM-P.
3. Test for failed SNMP communication between the server and managed machine.
4. Test for failed deployment of the configuration request.

By following these steps, the person ought to be capable to determine and resolve the problems stopping the administration of

Abschluss

Mit einem kleinen LLM wie LLAMA 3.2 1B Instruct können wir Schlüsselwörter aus großen Dokumenten effizient zusammenfassen und extrahieren. Diese Zusammenfassungen und Schlüsselwörter können in eine Datenbank wie LanceDB eingebettet und gespeichert werden, was einen effizienten Abruf für RAG-Systeme ermöglicht, die das LLM im Workflow und nicht nur bei der Generierung verwenden

Referenzen

• Meta LLAMA 3.2 1B Instruct-Modell
• SatzTransformers
• LanceDB
• PyMuPDF-Dokumentation

Nutzung kleinerer LLMs für Enhanced Retrieval-Augmented Era (RAG) wurde ursprünglich veröffentlicht in Auf dem Weg zur Datenwissenschaft auf Medium, wo die Leute das Gespräch fortsetzen, indem sie diese Geschichte hervorheben und darauf reagieren.

[ad_2]