Hilft bei der Zeitreihenprognose

Wir alle wissen, wie das geht: Zeitreihendaten sind knifflig.

Herkömmliche Prognosemodelle sind auf Ereignisse wie plötzliche Marktabstürze, Black Swan-Ereignisse oder seltene Wetterereignisse nicht vorbereitet.

Sogar große, schicke Modelle wie Chronos haben manchmal Probleme, weil sie sich noch nie mit solchen Mustern befasst haben.

Wir können dies mit mildern Abruf. Mit Rückruf sind wir in der Lage zu fragen Ist so etwas schon einmal passiert? und dann dieses vergangene Beispiel als Leitfaden für die Prognose verwenden.

Wie wir vielleicht alle wissen, wird diese Idee in der Verarbeitung natürlicher Sprache (NLP) genannt Retrieval-Augmented Era (RAG). Es wird auch in der Welt der Zeitreihenprognosen immer beliebter.

Das Modell berücksichtigt dann vergangene Situationen die dem aktuellen ähnlich sehen, und von da an kann man daraus noch mehr machen zuverlässig Vorhersagen.

Wie unterscheidet sich diese RAF von herkömmlichen Zeitreihen? Die Abrufprognose fügt eine hinzu expliziter Speicherzugriffsschritt.

Anstatt:

Vergangenheit -> Parameter -> Prognose

Mit Abruf wir haben:

Aktuelle State of affairs -> Ähnlichkeitssuche -> konkrete vergangene Episoden-> Vorhersage

Anstatt nur das zu nutzen, was das Modell dabei gelernt hat AusbildungDie Idee besteht darin, ihm Zugriff auf eine Reihe von zu gewähren ähnlich Situationen.

Es ist, als würde man ein Wettermodell prüfen lassen: „Wie sahen vergangene Winter wie dieser aus?“ vor?“.

Hallo, das bin ich Sara Nóbregaein KI-Ingenieur. Wenn Sie an ähnlichen Problemen arbeiten oder Suggestions zur Umsetzung dieser Ideen wünschen, sammle ich meine Texte, Ressourcen und Mentoring-Hyperlinks Hier.

In diesem Artikel erkunde ich Abruf–erweiterte Prognose von Grund auf und zeigen anhand konkreter Beispiele und Codebeispiele, wie Retrieval in realen Prognosepipelines eingesetzt werden kann.

Was ist Retrieval-Augmented Forecasting (RAF)?

Was ist RAF? Auf einer sehr übergeordneten Ebene stützt sich RAF nicht nur auf das, was ein Modell im Coaching gelernt hat, sondern lässt das Modell aktiv nachschlagen konkrete vergangene Situationen ähnlich dem aktuellen und nutzen ihre Ergebnisse dazu Führung seine Vorhersage.

Sehen wir uns das genauer an:

• Sie konvertieren die aktuelle State of affairs (z. B. die letzten Wochen eines Zeitreihen-Bestandsdatensatzes) in eine Abfrage.
• Das Abfrage ist dann gewohnt suchen A Datenbank der historischen Zeitreihensegmente am meisten zu finden ähnlich Muster.
• Diese Streichhölzer müssen nicht aus demselben Bestand stammen; Das System sollte auch ähnliche Bewegungen bei anderen Aktien oder Finanzprodukten anzeigen.

Es ruft diese ab Muster und was passiert ist nachher.

Im Anschluss sind diese Informationen eingenommen zum Prognose Modell, um bessere Vorhersagen zu treffen.

Diese Technik ist wirkungsvoll bei:

• Zero-Shot-Szenarien: Wenn das Modell etwas sieht, auf das es nicht trainiert wurde.
• Seltene oder ungewöhnliche Ereignisse: Wie COVID, plötzliche Finanzcrashs usw.
• Sich entwickelnde saisonale Tendencies: Wo frühere Daten hilfreiche Muster enthalten, diese sich jedoch im Laufe der Zeit ändern.

RAF ersetzt nicht Ihr Prognose Modell, sondern stattdessen erweitert es, indem du es gibst Further Hinweise und die Untermauerung anhand relevanter historischer Beispiele.

Ein weiteres Beispiel: Nehmen wir an, Sie möchten den Energieverbrauch während einer ungewöhnlich heißen Woche vorhersagen.

Anstatt zu hoffen, dass Ihr Modell sich daran erinnert, wie sich Hitzewellen auf die Nutzung auswirken, findet Retrieval heraus ähnlich vergangene Hitzewellen und lässt das Modell berücksichtigen, was in dieser Zeit passiert ist.

Was rufen diese Modelle tatsächlich ab?

Bei dem abgerufenen „Wissen“ handelt es sich nicht nur um Rohdaten. Es ist der Kontext, der dem Modell Hinweise gibt.

Hier sind einige gängige Beispiele:

Wie Sie sehen, konzentriert sich der Abruf auf bedeutsame historische Situationen, wie seltene Schocks, saisonale Effekte und Muster mit ähnlichen Strukturen. Diese liefern einen umsetzbaren Kontext für die aktuelle Prognose.

Wie rufen diese Modelle ab?

Related finden Muster Aus der Vergangenheit nutzen diese Modelle strukturierte Mechanismen, die die aktuelle State of affairs so darstellen, dass sie sie darstellt einfach um große Datenbanken zu durchsuchen und die ähnlichsten Übereinstimmungen zu finden.

Bei den Codeausschnitten in diesem Abschnitt handelt es sich um eine vereinfachte Veranschaulichung, die der Anschauung dienen soll, sie stellen keinen Produktionscode dar.

Einige dieser Methoden sind:

Einbettungsbasierte Ähnlichkeit

Dieser wandelt Zeitreihen (oder Patches/Fenster einer Reihe) in kompakt um Vektorenund vergleichen Sie sie dann mit Distanzmetriken wie Euklidischer oder Kosinusähnlichkeit.

In einfach Worte: Das Modell wandelt Teile von Zeitreihendaten in kurze um Zusammenfassungen und prüft dann welche Vergangenheit Zusammenfassungen ähneln am ehesten dem, was jetzt passiert.

Einige abrufgestützte Prognostiker (z. B. FLOSS) die ähnlichsten historischen Daten abrufen Patches aus den Trainingsdaten / der gesamten Serie und dann Aggregat abgerufene Werte mit aufmerksamkeitsähnlichen Gewichten.

Mit einfachen Worten: Es findet ähnlich Situationen aus der Vergangenheit und Durchschnittswerte sie zahlen mehr Aufmerksamkeit zum am besten Streichhölzer.

import numpy as np

# Instance: embedding-based retrieval for time-series patches
# This can be a toy instance to point out the *thought* behind retrieval.
# In observe:
# - embeddings are discovered by neural networks
# - similarity search runs over hundreds of thousands of vectors
# - this logic lives inside a bigger forecasting pipeline


def embed_patch(patch: np.ndarray) -> np.ndarray:
    """
    Convert a brief time-series window ("patch") right into a compact vector.

    Right here we use easy statistics (imply, std, min, max) purely for illustration.
    Actual-world methods would possibly use:
      - a educated encoder community
      - shape-based representations
      - frequency-domain options
      - latent vectors from a forecasting spine
    """
    return np.array((
        patch.imply(),   # common degree
        patch.std(),    # volatility
        patch.min(),    # lowest level
        patch.max()     # highest level
    ))


def cosine_similarity(a: np.ndarray, b: np.ndarray) -> float:
    """
    Measure how comparable two vectors are.
    Cosine similarity focuses on *route* quite than magnitude,
    which is commonly helpful for evaluating patterns or shapes.
    """
    return float(a @ b) / (np.linalg.norm(a) * np.linalg.norm(b) + 1e-9)


# Step 1: Symbolize the present state of affairs

# A brief window representing the present time-series habits
query_patch = np.array((10, 12, 18, 25, 14, 11))

# Flip it into an embedding
query_embedding = embed_patch(query_patch)


# Step 2: Symbolize historic conditions

# Previous home windows extracted from historic information
historical_patches = (
    np.array((9, 11, 17, 24, 13, 10)),   # seems comparable
    np.array((2, 2, 2, 2, 2, 2)),        # flat, unrelated
    np.array((10, 13, 19, 26, 15, 12))   # very comparable
)

# Convert all historic patches into embeddings
historical_embeddings = (
    embed_patch(patch) for patch in historical_patches
)

# Step 3: Evaluate and retrieve essentially the most comparable previous instances

# Compute similarity scores between the present state of affairs
# and every historic instance
similarities = (
    cosine_similarity(query_embedding, hist_emb)
    for hist_emb in historical_embeddings
)

# Rank historic patches by similarity
top_k_indices = np.argsort(similarities)(::-1)(:2)

print("Most comparable historic patches:", top_k_indices)

# Step 4 (conceptual):
# In a retrieval-augmented forecaster, the mannequin would now:
# - retrieve the *future outcomes* of those comparable patches
# - weight them by similarity (attention-like weighting)
# - use them to information the ultimate forecast
# This integration step is model-specific and never proven right here.

Retrieval-Instruments und Bibliotheken

1. FAISS
FAISS ist ein tremendous schnelles und GPU-freundliche Bibliothek für die Ähnlichkeitssuche über dichte Vektoren. Der am besten Datensätze für diese Bibliothek sind diejenigen, die es sind groß und in-Erinnerungobwohl seine Struktur die Implementierung von Echtzeitaktualisierungen erschwert.

import faiss
import numpy as np

# Suppose we have already got embeddings for historic home windows
d = 128  # embedding dimension
xb = np.random.randn(100_000, d).astype("float32")  # historic embeddings
xq = np.random.randn(1, d).astype("float32")        # question embedding

index = faiss.IndexFlatIP(d)   # inside product (usually used with normalized vectors for cosine-like habits)
index.add(xb)

ok = 5
scores, ids = index.search(xq, ok)
print("Nearest neighbors (ids):", ids)
print("Similarity scores:", scores)

# Some FAISS indexes/algorithms can run on GPU.

Suche nach dem nächsten Nachbarn (Annoy)
Die Annoy-Bibliothek ist relativ leicht und einfach zu verarbeiten.

Die besten Datensätze für diese Bibliothek sind historische Datensätze, die größtenteils statisch bleiben, da jede Änderung des Datensatzes eine Neuerstellung des Index erfordert.

from annoy import AnnoyIndex
import numpy as np

# Variety of values in every embedding vector.
# The "size" of every fingerprint.
f = 64

# Create an Annoy index.
# This object will retailer many previous embeddings and assist us rapidly discover essentially the most comparable ones.
ann = AnnoyIndex(f, "angular")
# "angular" distance is often used to check patterns
# and behaves equally to cosine similarity.

# Add historic embeddings (previous conditions).
# Every merchandise represents a compressed model of a previous time-series window.
# Right here we use random numbers simply for example.
for i in vary(10000):
    ann.add_item(i, np.random.randn(f).tolist())

# Construct the search construction.
# This step organizes the info so similarity searches are quick.
# After this, the index turns into read-only.
ann.construct(10)

# Save the index to disk.
# This permits us to load it later with out rebuilding every little thing.
ann.save("hist.ann")

# Create a question embedding.
# This represents the present state of affairs we wish to evaluate
# towards previous conditions.
q = np.random.randn(f).tolist()

# Discover the 5 most comparable previous embeddings.
# Annoy returns the IDs of the closest matches.
neighbors = ann.get_nns_by_vector(q, 5)

print("Nearest neighbors:", neighbors)

# Necessary observe:
# As soon as the index is constructed, you can not add new objects.
# If new historic information seems, the index have to be rebuilt.

Qdrant / Tannenzapfen

Qdrant und Pinecone sind ähnlich Google für Einbettungen.

Sie speichern viele Vektor-„Fingerabdrücke“ (plus zusätzliche Tags wie Stadt/Jahreszeit) und wenn Sie einen neuen Fingerabdruck haben, fragen Sie:

Zeigen Sie mir die ähnlichsten, aber nur aus dieser Stadt/Saison/Geschäftsart.“
Das macht sie einfacher als das eigene Einholen: Sie lassen sich schnell handhaben suchen Und Filterung!

Qdrant ruft Metadaten auf Nutzlastund Sie können Suchergebnisse mithilfe von Bedingungen filtern.

# Instance solely (for instinct). Actual code wants a operating Qdrant occasion + actual embeddings.

from qdrant_client import QdrantClient, fashions

consumer = QdrantClient(url="http://localhost:6333")

assortment = "time_series_windows"

# Fake that is the embedding of the *present* time-series window
query_vector = (0.12, -0.03, 0.98, 0.44)  # shortened for readability

# Filter = "solely contemplate previous home windows from New York in summer time"
# Qdrant documentation exhibits filters constructed from FieldCondition + MatchValue. :contentReference(oaicite:3){index=3}
query_filter = fashions.Filter(
    should=(
        fashions.FieldCondition(
            key="metropolis",
            match=fashions.MatchValue(worth="New York"),
        ),
        fashions.FieldCondition(
            key="season",
            match=fashions.MatchValue(worth="summer time"),
        ),
    )
)

# In actual utilization, you’d name search/question and get again the closest matches
# plus their payload (metadata) when you request it.
outcomes = consumer.search(
    collection_name=assortment,
    query_vector=query_vector,
    query_filter=query_filter,
    restrict=5,
    with_payload=True,   # return metadata so you'll be able to examine what you retrieved
)

print(outcomes)

# What you'd do subsequent (conceptually):
# - take the matched IDs
# - load the precise historic home windows behind them
# - feed these home windows (or their outcomes) into your forecasting mannequin

Pinecone-Läden Metadaten-Schlüssel-Wert-Paare neben Vektoren und ermöglicht das Filtern zum Zeitpunkt der Abfrage (einschließlich $eq) und Metadaten zurückgeben.

# Instance solely (for instinct). Actual code wants an API key + an index host.

from pinecone import Pinecone

laptop = Pinecone(api_key="YOUR_API_KEY")
index = laptop.Index(host="INDEX_HOST")

# Fake that is the embedding of the present time-series window
query_vector = (0.12, -0.03, 0.98, 0.44)  # shortened for readability

# Ask for essentially the most comparable previous home windows, however solely the place:
# metropolis == "New York" AND season == "summer time"
# Pinecone docs present query-time filtering and `$eq`. :contentReference(oaicite:5){index=5}
res = index.question(
    namespace="home windows",
    vector=query_vector,
    top_k=5,
    filter={
        "metropolis": {"$eq": "New York"},
        "season": {"$eq": "summer time"},
    },
    include_metadata=True,  # return tags so you'll be able to sanity-check matches
    include_values=False
)

print(res)

# Conceptually subsequent:
# - use the returned IDs to fetch the underlying historic home windows/outcomes
# - situation your forecast on these retrieved examples

Warum helfen Vektor-DBs? Sie lassen dich machen Ähnlichkeitssuche + „SQL-ähnliche WHERE-Filter“ in einem Schritt, was mit einem DIY-Setup schwer sauber zu bewerkstelligen ist (sowohl die Qdrant-Nutzlastfilterung als auch die Pinecone-Metadatenfilterung sind erstklassige Funktionen in ihren Dokumenten).

Jedes Device hat seine Kompromisse. Zum Beispiel, FAISS ist großartig für die Leistung, aber nicht geeignet für häufig Aktualisierungen. Qdrant gibt Flexibilität und Echtzeitfilterung. Pinecone ist einfach einzurichten, aber nur SaaS.

Retrieval + Prognose: Wie man sie kombiniert

Nachdem Sie wissen, was abgerufen werden soll, besteht der nächste Schritt darin, diese Informationen mit der aktuellen Eingabe zu kombinieren.

Sie kann je nach Architektur und Aufgabenstellung variieren. Dafür gibt es mehrere Strategien (siehe Bild unten).

A. Verkettung
Idee: Behandeln Sie den abgerufenen Kontext als „mehr Eingabe“, indem Sie ihn an die vorhandene Sequenz anhängen (sehr häufig bei Setups mit erweiterter Generierung beim Abrufen).

Funktioniert intestine mit transformatorbasierten Modellen wie Chronos und erfordert keine Änderungen an der Architektur.

import torch

# x_current: the mannequin's typical enter sequence (e.g., final N timesteps or tokens)
# form: (batch, time, d_model)   (or (batch, time) when you suppose in tokens)
x_current = torch.randn(8, 128, 256)

# x_retrieved: retrieved context encoded within the SAME illustration area
# e.g., embeddings for comparable previous home windows (or their summaries)
# form: (batch, retrieved_time, d_model)
x_retrieved = torch.randn(8, 32, 256)

# Easy fusion: simply append retrieved context to the top of the enter sequence
# Now the mannequin sees: (present historical past ... + retrieved context ...)
x_fused = torch.cat((x_current, x_retrieved), dim=1)

# In observe, you'd additionally add:
# - an consideration masks (so the mannequin is aware of what’s actual vs padded)
# - section/kind embeddings (so the mannequin is aware of which half is retrieved context)
# Then feed x_fused to your transformer.

B. Cross-Consideration-Fusion
Idee: Halten Sie die „aktuelle Eingabe“ und den „abgerufenen Kontext“ getrennt und lassen Sie das Modell Sich um den abgerufenen Kontext kümmern wenn es es braucht. Dies ist das Kernmuster „Fusion im Decoder durch gegenseitige Aufmerksamkeit“, das von abrufgestützten Architekturen wie FiD verwendet wird.

import torch

# current_repr: illustration of the present time-series window
# form: (batch, time, d_model)
current_repr = torch.randn(8, 128, 256)

# retrieved_repr: illustration of retrieved home windows (could possibly be concatenated)
# form: (batch, retrieved_time, d_model)
retrieved_repr = torch.randn(8, 64, 256)

# Consider cross-attention like:
# - Question (Q) comes from the present sequence
# - Keys/Values (Okay/V) come from retrieved context
Q = current_repr
Okay = retrieved_repr
V = retrieved_repr

# Consideration scores: "How a lot ought to every present timestep take a look at every retrieved timestep?"
scores = torch.matmul(Q, Okay.transpose(-1, -2)) / (Q.dimension(-1) ** 0.5)

# Flip scores into weights (so that they sum to 1 throughout retrieved positions)
weights = torch.softmax(scores, dim=-1)

# Weighted sum of retrieved info (that is the “fused” retrieved sign)
retrieval_signal = torch.matmul(weights, V)

# Ultimate fused illustration: present data + retrieved data
# (Some fashions add, some concatenate, some use a discovered projection)
fused = current_repr + retrieval_signal

# Then the forecasting head reads from `fused` to foretell the longer term.

C. Combination-of-Specialists (MoE)
Idee: Kombinieren Sie zwei „Experten“:

• Die Abrufbasierter Prognostiker (nicht parametrisch, fallbasiert)

• Die Basisprognostiker (parametrisches Wissen)

Ein „Gate“ entscheidet bei jedem Zeitschritt, welchem ​​Tor mehr vertraut werden soll.

import torch

# base_pred: forecast from the primary mannequin (what it "discovered in weights")
# form: (batch, horizon)
base_pred = torch.randn(8, 24)

# retrieval_pred: forecast urged by retrieved comparable instances
# form: (batch, horizon)
retrieval_pred = torch.randn(8, 24)

# context_for_gate: abstract of the present state of affairs (could possibly be final hidden state)
# form: (batch, d_model)
context_for_gate = torch.randn(8, 256)

# gate: a quantity between 0 and 1 saying "how a lot to belief retrieval"
# (In actual fashions, it is a tiny neural web.)
gate = torch.sigmoid(torch.randn(8, 1))

# Combination: convex mixture
# - if gate ~ 1 -> belief retrieval extra
# - if gate ~ 0 -> belief the bottom mannequin extra
final_pred = gate * retrieval_pred + (1 - gate) * base_pred

# In observe:
# - gate may be timestep-dependent: form (batch, horizon, 1)
# - you may also add coaching losses to stabilize routing/utilization (frequent in MoE)

D. Kanalaufforderung
Idee: Abgerufene Serien behandeln als zusätzliche Eingangskanäle/Funktionen (besonders natürlich in multivariaten Zeitreihen, in denen jede Variable ein „Kanal“ ist).

import torch

# x: multivariate time sequence enter
# form: (batch, time, channels)
# Instance: channels could possibly be (gross sales, worth, promo_flag, temperature, ...)
x = torch.randn(8, 128, 5)

# retrieved_series_aligned: retrieved sign aligned to the identical time grid
# Instance: common of the top-k comparable previous home windows (or one consultant neighbor)
# form: (batch, time, retrieved_channels)
retrieved_series_aligned = torch.randn(8, 128, 2)

# Channel prompting = append retrieved channels as further options
# Now the mannequin will get "regular channels + retrieved channels"
x_prompted = torch.cat((x, retrieved_series_aligned), dim=-1)

# In observe you’d seemingly additionally embrace:
# - a masks or confidence rating for retrieved channels
# - normalization so retrieved indicators are on a comparable scale
# Then feed x_prompted into the forecaster.

Einige Modelle lassen sich sogar kombinieren mehrere Methoden.

Ein gängiger Ansatz ist das Abrufen mehrere Erstellen Sie ähnliche Serien, führen Sie sie mit Aufmerksamkeit zusammen, damit sich das Modell auf die relevantesten Teile konzentrieren kann, und geben Sie sie dann an einen Experten weiter.

Zusammenfassung

Retrieval-Augmented Forecasting (RAF) lässt Ihr Modell auf eine Weise aus der Vergangenheit lernen, die mit der herkömmlichen Zeitreihenmodellierung nicht möglich ist.

Es wirkt wie ein externer Speicher Dies hilft dem Modell, unbekannte Situationen sicherer zu meistern.

Es ist einfach zu experimentieren und liefert bedeutende Verbesserungen bei Prognoseaufgaben.

Retrieval ist kein akademischer Hype mehr, sondern liefert bereits Ergebnisse in realen Systemen.

Vielen Dank fürs Lesen!

Ich heiße Sara Nóbrega. Ich bin ein KI-Ingenieur, der sich auf MLOps und die Bereitstellung maschineller Lernsysteme in der Produktion konzentriert.

Referenzen

(1) J. Liu, Y. Zhang, Z. Wang et al., Abrufgestützte Zeitreihenprognose (2025), arXiv-Vorabdruck
Quelle: https://arxiv.org/html/2505.04163v1

(2) UConn DSIS, TS-RAG: Time-Sequence Retrieval-Augmented Era (nd), GitHub-Repository
Quelle: https://github.com/UConn-DSIS/TS-RAG

(3) Y. Zhang, H. Xu, X. Chen et al., Speichererweiterte Prognose für Zeitreihen mit seltenen Ereignissen (2024), arXiv-Vorabdruck
Quelle: https://arxiv.org/abs/2412.20810

Die rasante Weiterentwicklung von Augmented Era abrufen (RAG)-Technologie verändert die Artwork und Weise, wie Unternehmen ihre riesigen Datenbestände verwalten und nutzen. Durch die nahtlose Integration fortschrittlicher Datenabruf- und kontextbezogener Generierungsfunktionen ermöglicht RAG Unternehmen, den größtmöglichen Nutzen aus ihren Informationsbeständen zu ziehen.

Führende Unternehmen wie K2view stehen an der Spitze dieser Datenrevolution und bieten hochmoderne Lösungen, die das volle Potenzial von RAG ausschöpfen.

Architektur intelligenter Datensysteme

Die RAG-Technologie vereint die Stärken von Vektordatenbanken, Abfrageverarbeitung Systeme und Kontextverbesserungsebenen, um ein leistungsstarkes Framework für intelligentes Datenmanagement zu schaffen. Die Vektordatenbank dient als Grundlage für die effiziente Speicherung und Indizierung hochdimensionaler Datendarstellungen. Das Abfrageverarbeitungssystem verarbeitet komplexe Abfragen, zDurchsuchen der Vektordatenbank, um relevante Informationen abzurufen mit außergewöhnlicher Geschwindigkeit und Genauigkeit. Die Kontexterweiterungsschicht reichert die abgerufenen Daten durch die Einbeziehung zusätzlicher Kontextinformationen an und ermöglicht so differenziertere und aussagekräftigere Antworten.

Implementierung von RAG im Unternehmen

Um RAG erfolgreich in einem Unternehmensumfeld zu implementieren, müssen Organisationen einem klar definierten Rahmen folgen, der Folgendes umfasst DatenaufbereitungAbrufmechanismen und Antwortgenerierung. Die Datenvorbereitungspipeline ist von entscheidender Bedeutung, da sie die Bereinigung, Transformation und Vektorisierung der Rohdaten umfasst, um eine optimale Kompatibilität mit dem RAG-System sicherzustellen. Der Abrufmechanismus nutzt die Vektordatenbank und das Abfrageverarbeitungssystem, um Auf der Grundlage von Benutzeranfragen relevante Informationen effizient lokalisieren und extrahieren. Schließlich nutzt die Antwortgenerierungskomponente die abgerufenen Daten und Kontextinformationen, um genaue, kohärente und kontextbezogene Antworten zu generieren.

Geschäftswert freisetzen

Die Einführung der RAG-Technologie bietet zahlreiche Vorteile für Unternehmen in verschiedenen Branchen. Durch die Verbesserung der Datengenauigkeit und Kontexterhaltung ermöglicht RAG Unternehmen, fundiertere Entscheidungen auf der Grundlage umfassender und zuverlässiger Erkenntnisse zu treffen. Die verbesserte Reaktionszeit und die erhöhte Effizienz von RAG-Systemen ermöglichen Unternehmen dies Optimieren Sie Ihre Abläufe, senken Sie die Kosten und bieten Sie erstklassige Kundenerlebnisse. Darüber hinaus eröffnet die Fähigkeit von RAG, menschenähnliche Antworten zu generieren, neue Möglichkeiten für die Automatisierung von Kundensupport, Inhaltserstellung und Wissensmanagementaufgaben.

Greatest Practices für die RAG-Implementierung

Um die Vorteile der RAG-Technologie zu maximieren, müssen Unternehmen während des gesamten Implementierungsprozesses Greatest Practices einhalten. Dazu gehört:

• Sicherstellung der Datenqualität und -konsistenz durch robuste Datenverwaltungs- und Bereinigungsprozesse
• Optimierung der Leistung von Vektordatenbanken durch geeignete Indizierungs- und Partitionierungsstrategien
• Feinabstimmung der Abfrageverarbeitungsalgorithmen zur effektiven Bearbeitung komplexer und mehrdeutiger Abfragen
• Einbindung von domänenspezifischem Wissen und Geschäftsregeln in die Kontexterweiterungsschicht
• Kontinuierliche Überwachung und Bewertung der Systemleistung, um Verbesserungsmöglichkeiten zu identifizieren

Die Zukunft von RAG im Unternehmen

Als RAG-Technologie Da sich die Technologie ständig weiterentwickelt, werden ihre Auswirkungen auf die Unternehmenslandschaft nur noch tiefgreifender sein. Die Integration von RAG mit anderen neuen Technologien wie maschinellem Lernen, Verarbeitung natürlicher Sprache und Wissensgraphen wird noch ausgefeiltere und intelligentere Datenverwaltungslösungen ermöglichen. Unternehmen, die RAG nutzen, sind intestine aufgestellt, um das enorme Potenzial ihrer Datenbestände zu nutzen und Innovationen, Effizienz und Wettbewerbsvorteile in einer zunehmend datengesteuerten Welt voranzutreiben.

Retrieval Augmented Era stellt einen Paradigmenwechsel im Unternehmensdatenmanagement dar und ermöglicht es Unternehmen, das volle Potenzial ihrer Informationsrepositorys auszuschöpfen. Durch die Nutzung der Leistungsfähigkeit von RAG können Unternehmen die Datengenauigkeit verbessern, Reaktionszeiten verbessern und kontextbezogenere Erkenntnisse liefern. Da die Technologie immer weiter ausgereift ist, sind die Möglichkeiten zur Umgestaltung von Geschäftsabläufen und zur Förderung von Innovationen grenzenlos. Die Übernahme von RAG ist nicht nur eine strategische Notwendigkeit; Es ist der Schlüssel zum Erfolg im Zeitalter des intelligenten Datenmanagements.

Ideale generative KI vs. Realität

Grundlegende LLMs haben jedes Byte Textual content gelesen, das sie finden konnten, und ihre Chatbot-Gegenstücke können zu intelligenten Gesprächen angeregt und gebeten werden, bestimmte Aufgaben auszuführen. Der Zugang zu umfassenden Informationen ist demokratisiert; Sie müssen nicht mehr die richtigen Schlüsselwörter für die Suche herausfinden oder Web sites zum Lesen auswählen. LLMs neigen jedoch dazu, zu schwafeln und reagieren im Allgemeinen mit der statistisch wahrscheinlichsten Antwort, die Sie hören möchten (Speichelleckerei) ein inhärentes Ergebnis des Transformer-Modells. Das Extrahieren von 100 % genauen Informationen aus der Wissensbasis eines LLM führt nicht immer zu vertrauenswürdigen Ergebnissen.

Chat-LLMs sind dafür berüchtigt, Zitate aus wissenschaftlichen Arbeiten oder Gerichtsverfahren zu erfinden, die es gar nicht gibt. Anwälte reichen Klage gegen eine Fluggesellschaft ein enthielt Zitate aus Gerichtsverfahren, die nie stattgefunden haben. Eine Studie aus dem Jahr 2023 berichtetedass ChatGPT, wenn es aufgefordert wird, Zitate einzufügen, nur in 14 % der Fälle Referenzen liefert, die tatsächlich existieren. Quellen zu fälschen, zu schwafeln und Ungenauigkeiten zu liefern, um der Aufforderung nachzukommen, wird als Halluzination bezeichnet, ein riesiges Hindernis, das überwunden werden muss, bevor KI vollständig angenommen und von der Masse als vertrauenswürdig angesehen wird.

Ein Gegenmittel gegen das Erfinden falscher Quellen oder das Auftauchen von Ungenauigkeiten durch LLMs ist die Retrieval-Augmented Technology oder RAG. RAG kann nicht nur die Halluzinationstendenz von LLMs verringern, sondern bietet auch mehrere andere Vorteile.

Zu diesen Vorteilen gehören der Zugriff auf eine aktuelle Wissensbasis, Spezialisierung (z.B durch die Bereitstellung privater Datenquellen), wodurch Modelle mit Informationen ausgestattet werden, die über das hinausgehen, was im parametrischen Speicher abgelegt ist (was kleinere Modelle ermöglicht), und die Möglichkeit besteht, weitere Daten aus legitimen Referenzen heranzuziehen.

Was ist RAG (Retrieval Augmented Technology)?

Retrieval-Augmented Technology (RAG) ist eine Deep-Studying-Architektur, die in LLMs und Transformer-Netzwerken implementiert ist. Sie ruft relevante Dokumente oder andere Snippets ab und fügt sie dem Kontextfenster hinzu, um zusätzliche Informationen bereitzustellen und einem LLM dabei zu helfen, nützliche Antworten zu generieren. Ein typisches RAG-System hätte zwei Hauptmodule: Abruf und Generierung.

Die wichtigste Referenz für RAG ist ein Artikel von Lewis et al. von Fb. In dem Artikel verwenden die Autoren ein Paar BERT-basierter Dokument-Encoder, um Abfragen und Dokumente zu transformieren, indem sie den Textual content in ein Vektorformat einbetten. Diese Einbettungen werden dann verwendet, um die Prime-okay (normalerweise 5 oder 10) Dokumente über eine Suche mit maximalem inneren Produkt (MIPS). Wie der Identify schon sagt, basiert MIPS auf dem inneren (oder Skalar-)Produkt der codierten Vektordarstellungen der Abfrage und denen in einer Vektordatenbank, die für die Dokumente vorab berechnet wurde und als externer, nichtparametrischer Speicher verwendet wird.

Wie im Stück von Lewis beschrieben et al.RAG wurde entwickelt, um LLMs bei wissensintensiven Aufgaben zu unterstützen, die „von Menschen ohne Zugang zu einer externen Wissensquelle nicht vernünftigerweise ausgeführt werden können“. Wenn Sie eine Open-Ebook- und eine Non-Open-Ebook-Prüfung ablegen, erhalten Sie einen guten Eindruck davon, wie RAG LLM-basierte Systeme ergänzen kann.

RAG mit dem Umarmungsgesicht Bibliothek

Lewis et al. haben ihre RAG-Modelle auf dem Hugging Face Hub als Open Supply veröffentlicht, sodass wir mit denselben Modellen experimentieren können, die im Artikel verwendet werden. Eine neue virtuelle Python 3.8-Umgebung mit virtualenv wird empfohlen.

virtualenv my_env --python=python3.8
supply my_env/bin/activate

Nachdem wir die Umgebung aktiviert haben, können wir mit pip Abhängigkeiten installieren: Transformatoren und Datasets von Hugging Face, die FAISS-Bibliothek von Fb, die RAG für die Vektorsuche verwendet, und PyTorch zur Verwendung als Backend.

pip set up transformers
pip set up datasets
pip set up faiss-cpu==1.8.0
#https://pytorch.org/get-started/regionally/ to 
#match the pytorch model to your system
pip set up torch

Lewis et al. hat zwei verschiedene Versionen von RAG implementiert: rag-sequence und rag-token. Rag-sequence verwendet dasselbe abgerufene Dokument, um die Generierung einer gesamten Sequenz zu erweitern, während rag-token für jedes Token unterschiedliche Snippets verwenden kann. Beide Versionen verwenden dieselben Hugging Face-Klassen für die Tokenisierung und den Abruf, und die API ist weitgehend gleich, aber jede Model hat eine einzigartige Klasse für die Generierung. Diese Klassen werden aus der Transformers-Bibliothek importiert.

from transformers import RagTokenizer, RagRetriever
from transformers import RagTokenForGeneration
from transformers import RagSequenceForGeneration

Wenn das RagRetriever-Modell mit dem Standarddatensatz „wiki_dpr“ zum ersten Mal instanziiert wird, wird ein umfangreicher Obtain (ca. 300 GB) eingeleitet. Wenn Sie über ein großes Datenlaufwerk verfügen und möchten, dass Hugging Face dieses verwendet (anstelle des Customary-Cache-Ordners auf Ihrem Dwelling-Laufwerk), können Sie eine Shell-Variable festlegen: HF_DATASETS_CACHE.

# within the shell:
export HF_DATASETS_CACHE="/path/to/knowledge/drive"
# ^^ add to your ~/.bashrc file if you wish to set the variable

Stellen Sie sicher, dass der Code funktioniert, bevor Sie den vollständigen wiki_dpr-Datensatz herunterladen. Um den großen Obtain zu vermeiden, bis Sie bereit sind, können Sie beim Instanziieren des Retrievers use_dummy_dataset=True übergeben. Sie werden auch einen Tokenizer instanziieren, um Zeichenfolgen in ganzzahlige Indizes (entsprechend Token in einem Vokabular) und umgekehrt umzuwandeln. Sequenz- und Tokenversionen von RAG verwenden denselben Tokenizer. RAG-Sequenz (rag-sequence) und RAG-Token (rag-token) haben jeweils fein abgestimmte (z.B rag-token-nq) und Basisversionen (z.B Rag-Token-Foundation).

tokenizer = RagTokenizer.from_pretrained(
"fb/rag-token-nq")

token_retriever = RagRetriever.from_pretrained(
"fb/rag-token-nq", 
     index_name="compressed", 
use_dummy_dataset=False)
sequence_retriever = RagRetriever.from_pretrained(
"fb/rag-sequence-nq", 
     index_name="compressed", 
use_dummy_dataset=False)

dummy_retriever = RagRetriever.from_pretrained(
"fb/rag-sequence-nq", 
   index_name="precise", 
use_dummy_dataset=True)

token_model = RagTokenForGeneration.from_pretrained(
"fb/rag-token-nq", 
     retriever=token_retriever)
seq_model = RagTokenForGeneration.from_pretrained(
"fb/rag-sequence-nq", 
     retriever=seq_retriever)
dummy_model = RagTokenForGeneration.from_pretrained(
"fb/rag-sequence-nq", 
   retriever=dummy_retriever)

Sobald Ihre Modelle instanziiert sind, können Sie eine Abfrage bereitstellen, sie tokenisieren und an die Funktion „Generieren“ des Modells übergeben. Wir vergleichen die Ergebnisse von Rag-Sequence, Rag-Token und RAG mithilfe eines Retrievers mit der Dummy-Model des Wiki_Dpr-Datensatzes. Beachten Sie, dass diese Rag-Modelle nicht zwischen Groß- und Kleinschreibung unterscheiden.

question = "what's the identify of the oldest tree on Earth?"
input_dict = tokenizer.prepare_seq2seq_batch(
question, return_tensors="pt")

token_generated = token_model.generate(**input_dict)  token_decoded = token_tokenizer.batch_decode(
token_generated, skip_special_tokens=True)

seq_generated = seq_model.generate(**input_dict)
seq_decoded = seq_tokenizer.batch_decode(
seq_generated, skip_special_tokens=True)

dummy_generated = dummy_model.generate(**input_dict)
dummy_decoded = seq_tokenizer.batch_decode(
dummy_generated, skip_special_tokens=True)

print(f"solutions to question '{question}': ")
print(f"t rag-sequence-nq: {seq_decoded(0)},"
f" rag-token-nq: {token_decoded(0)},"
f" rag (dummy): {dummy_decoded(0)}")

>> solutions to question 'What's the identify of the oldest tree on Earth?': Prometheus was the oldest tree found till 2012, with its innermost, extant rings exceeding 4862 years of age.

>> rag-sequence-nq:  prometheus, rag-token-nq:  prometheus, rag (dummy):  4862

Im Allgemeinen ist Rag-Token häufiger richtig als Rag-Sequence (obwohl beide oft richtig sind) und Rag-Sequence ist bei Verwendung eines Retrievers mit einem Dummy-Datensatz häufiger richtig als RAG.

„Welche Artwork von Kontext liefert der Retriever?“, fragen Sie sich vielleicht. Um das herauszufinden, können wir den Generierungsprozess dekonstruieren. Mit dem wie oben instanziierten seq_retriever und seq_model fragen wir ab: „Wie heißt der älteste Baum der Erde?“

question = "what's the identify of the oldest tree on Earth?"
inputs = tokenizer(question, return_tensors="pt")
input_ids = inputs("input_ids")

question_hidden_states = seq_model.question_encoder(input_ids)(0)

docs_dict = seq_retriever(input_ids.numpy(),
question_hidden_states.detach().numpy(),
return_tensors="pt")
doc_scores = torch.bmm(
question_hidden_states.unsqueeze(1),
docs_dict("retrieved_doc_embeds")
.float().transpose(1, 2)).squeeze(1)

generated = mannequin.generate(
context_input_ids=docs_dict("context_input_ids"),
context_attention_mask=
docs_dict("context_attention_mask"),
doc_scores=doc_scores)

generated_string = tokenizer.batch_decode(
generated,
skip_special_tokens=True)

contexts = tokenizer.batch_decode(
docs_dict("context_input_ids"),
attention_mask=docs_dict("context_attention_mask"),
skip_special_tokens=True)

best_context = contexts(doc_scores.argmax())

Wir können unser Modell so codieren, dass die Variable „bester Kontext“ gedruckt wird, um zu sehen, was erfasst wurde

print(f" based mostly on the retrieved context"
f":nnt {best_context}: n")

basierend auf dem abgerufenen Kontext:

Prometheus (tree) / In a clonal organism, nonetheless, the person clonal stems should not practically so previous, and no a part of the organism is especially previous at any given time. Till 2012, Prometheus was thus the oldest "non-clonal" organism but found, with its innermost, extant rings exceeding 4862 years of age. Within the Fifties dendrochronologists had been making lively efforts to search out the oldest residing tree species as a way to use the evaluation of the rings for numerous analysis functions, such because the analysis of former climates, the courting of archaeological ruins, and addressing the essential scientific query of most potential lifespan. Bristlecone pines // what's the identify of the oldest tree on earth?

print(f" rag-sequence-nq solutions '{question}'"
f" with '{generated_string(0)}'")

Wir können die Antwort auch ausdrucken, indem wir den generated_string Variable. Die Rag-Sequenz-NQ antwortet auf „Wie heißt der älteste Baum der Erde?“ mit „Prometheus“.

Was können Sie mit RAG tun?

In den letzten anderthalb Jahren gab es eine wahre Explosion an LLMs und LLM-Instruments. Das in Lewis verwendete BART-Basismodell et al. betrug nur 400 Millionen Parameter, weit entfernt von der aktuellen Technology von LLMs, die bei „Lite“-Varianten normalerweise im Milliardenparameterbereich beginnen. Außerdem sind viele Modelle, die heute trainiert, zusammengeführt und optimiert werden, multimodal und kombinieren Texteingaben und -ausgaben mit Bildern oder anderen tokenisierten Datenquellen. Die Kombination von RAG mit anderen Instruments kann komplexe Funktionen aufbauen, aber die zugrunde liegenden Modelle sind nicht immun gegen die üblichen LLM-Mängel. Die Probleme der Speichelleckerei, Halluzination und Zuverlässigkeit bei LLMs bleiben alle bestehen und laufen Gefahr, mit der zunehmenden Nutzung von LLMs zuzunehmen.

Die offensichtlichsten Anwendungen für RAG sind Variationen der konversationellen semantischen Suche, aber vielleicht umfassen sie auch die Einbindung multimodaler Eingaben oder die Generierung von Bildern als Teil der Ausgabe. Beispielsweise kann RAG in LLMs mit Fachwissen Softwaredokumentation erstellen, mit der man chatten kann. Oder RAG könnte verwendet werden, um interaktive Notizen in einer Literaturübersicht für ein Forschungsprojekt oder eine Abschlussarbeit zu machen.

Durch die Einbindung der Funktion zum „Denkketten-Argumentieren“ könnten Sie einen eher agentenorientierten Ansatz wählen, um Ihren Modellen die Möglichkeit zu geben, das RAG-System abzufragen und komplexere Frage- und Argumentationsstränge zusammenzustellen.

Es ist auch sehr wichtig, sich bewusst zu machen, dass RAG die üblichen LLM-Fallen (Halluzination, Speichelleckerei usw.) nicht löst und nur als Mittel dient, um Ihr LLM zu lindern oder zu einer nischenspezifischeren Antwort zu führen. Die Endpunkte, die letztendlich wichtig sind, sind spezifisch für Ihren Anwendungsfall, die Informationen, die Sie Ihrem Modell zuführen, und wie das Modell fein abgestimmt wird.

Kevin Vu verwaltet Weblog von Exxact Corp und arbeitet mit vielen seiner talentierten Autoren zusammen, die über verschiedene Aspekte des Deep Studying schreiben.