Anwendungen zur Verbesserung der Erzeugung (Abruf der Erzeugung von Abrufen "haben immer einen Kompromiss zwischen zwei Ansätzen: Einbetten Sie das gesamte Dokument für einen besseren Kontext ein oder zerlegen Sie es in kleinere Teile, um genaueres Abrufen zu erhalten.
Das gesamte Dokument kann globale Informationen erfassen, kann jedoch wichtige Details verlieren.
verzögertes Chunking liefert eine Lösung, die sie in kleinere, einfachere Stücke spaltet und gleichzeitig den vollständigen Dokumentkontext beibehält.
In diesem Artikel wird verzögertes Chunking als bessere Alternative zur traditionellen naiven Chunking -Methode eingebracht und seine Implementierungsmethode nach und nach demonstrieren.
Verwenden Sie die Erzeugung (Abrufenvergrößerung der Erzeugung) und Langchain, um externe Daten in große Sprachmodelle (LLM) zu integrieren. Erkunden Sie Kurse
In der Lag -Pipeline werden Dokumente in kleinere Stücke unterteilt, bevor sie in eine Vektordatenbank eingebettet und gespeichert werden. Jeder Block wird unabhängig verarbeitet und zum Abrufen zum Abfragestand verwendet. Dieser "naive Chunking" -Ansatz verliert jedoch häufig einen wichtigen Langstreckenkontext.
Das Problem ist, dass die herkömmliche Chunking -Methode die Informationsmethode bei der Segmentierung von Dokumenten nicht berücksichtigt. In der Dokumentation über Paris kann sich der Ausdruck „diese Stadt“ beispielsweise von dem Block unterscheiden, in dem sich „Paris“ befindet. Ohne einen vollständigen Kontext kann das Suchmodell schwierig sein, diese Referenzen zu korrelieren, was zu ungenauen Ergebnissen führt. In langen Dokumenten werden kritische Kontexte über mehrere Abschnitte hinweg verteilt, was noch schwerwiegender ist.
verzögertes Chunking löst dieses Problem, indem die Zeit für die Aufteilung des Dokuments geändert wird. Das verzögerte Chunking besteht nicht darin, das Dokument zuerst in Brocken zu unterteilen, sondern das gesamte Dokument mit einem langen Kontextmodell einzubetten. Erst danach teilt es das Dokument in kleinere Stücke auf.
Hauptvorteile des verzögerten Knackens:
Verwenden langer Kontextmodelle wie Jinas Jinaai/Jina-Embeddings-V2-Base-EN (Unterstützung von bis zu 8192 Mark) ermöglicht verzögertes Knacken, dass große Textteile effektiv eingebettet werden, bevor sie in Blöcke aufgeteilt werden.
Dies ist eine Schritt-für-Schritt-Anleitung zur Implementierung eines verzögerten Knicks mit Jinas langem Kontext-Einbettungsmodell. Sie können Jinas API -Schlüssel hier kostenlos erhalten, und wir werden den folgenden Eingabetxt als Demonstration verwenden:
<code>input_text = """Berlin is the capital and largest city of Germany, both by area and by population. Its more than 3.85 million inhabitants make it the European Union's most populous city, as measured by population within city limits. The city is also one of the states of Germany, and is the third smallest state in the country in terms of area."""</code>
Verwenden Sie zuerst Ihre Jina -API -Taste und die Helfer -Funktion unten, um den Eingabetxt in Stücke zu unterteilen. Diese Blöcke sind mit Spannweitenanmerkungen ausgestattet, die dazu beitragen, später Dokument -Einbettungen aufzuteilen. Jinas API verwendet natürliche Grenzen wie Absätze oder Satzbrüche, um sicherzustellen, dass der Block aussagekräftig ist und seine Bedeutung behält.
<code>import json
import requests
def custom_tokenize_jina_api(input_text: str):
url = '<https:></https:>'
headers = {
'Content-Type': 'application/json',
'Authorization': 'Bearer ENTER_YOUR_JINA_API_KEY'
}
data = {
"content": input_text,
"tokenizer": "o200k_base",
"return_tokens": "true",
"return_chunks": "true",
"max_chunk_length": "1000"
}
# Make the API request
response = requests.post(url, headers=headers, json=data)
response_data = response.json()
chunks = response_data.get("chunks", [])
i = 1
j = 1
span_annotations = []
for x in response_data['tokens']:
if j == 1:
j = len(x)
else:
j = len(x) + i
span_annotations.append((i, j))
i = j
return chunks, span_annotations
chunks, span_annotations = custom_tokenize_jina_api(input_text)
print(chunks)
print(span_annotations)</code><code>['Berlin is the capital and largest city of Germany, both by area and by population.\n\n', "Its more than 3.85 million inhabitants make it the European Union's most populous city, as measured by population within city limits.\n\n", 'The city is also one of the states of Germany, and is the third smallest state in the country in terms of area.'] [(1, 17), (17, 44), (44, 69)]</code>
Verwenden Sie zunächst ein Tagger, das mit dem Long Context-Modell kompatibel ist, wie beispielsweise Jinas Emboddings-V2-Base-Ens, um das gesamte Dokument in Tags zu unterteilen. Erstellen Sie als nächstes Einbettung für jedes Tag mit dem Long Context Conteter Converter -Modell. Dies bedeutet, dass jedes Wort oder jedes Marker im Dokument seine einzigartige Einbettung erhält, um seine Bedeutung zu erfassen.
<code>from transformers import AutoModel
from transformers import AutoTokenizer
# load model and tokenizer
tokenizer = AutoTokenizer.from_pretrained('jinaai/jina-embeddings-v2-base-en', trust_remote_code=True)
model = AutoModel.from_pretrained('jinaai/jina-embeddings-v2-base-en', trust_remote_code=True)
inputs = tokenizer(input_text, return_tensors='pt')
model_output = model(**inputs)
model_output[0].shape</code><code>torch.Size([1, 71, 768]) # 71 代表整个文档中的标记数</code>
Sobald Sie Tag -Einbettungen für das gesamte Dokument haben, können Sie verzögertes Knacken durchführen. Verwenden Sie die Span -Annotation in Schritt eins, um diese Markierungen in kleinere Stücke zu teilen. Anschließend wird das durchschnittliche Pooling angewendet, um die Einbettungen innerhalb jedes Blocks durchschnittlich zu erzeugen und für jeden Block eine einzelne Einbettung zu erzeugen. Wir haben jetzt Block -Einbettungen, die die leistungsstarken Kontextinformationen des gesamten Dokuments enthalten.
<code>def late_chunking(
model_output: 'BatchEncoding', span_annotation: list, max_length=None
):
token_embeddings = model_output[0]
outputs = []
for embeddings, annotations in zip(token_embeddings, span_annotation):
if (
max_length is not None
): # remove annotations which go bejond the max-length of the model
annotations = [
(start, min(end, max_length - 1))
for (start, end) in annotations
if start = 1
]
pooled_embeddings = [
embedding.detach().cpu().numpy() for embedding in pooled_embeddings
]
outputs.append(pooled_embeddings)
return outputs</code><code>embeddings = late_chunking(model_output, [span_annotations])[0] len(embeddings)</code>
<code>3 # 与步骤 1 中的块数匹配</code>
Um die Vorteile eines verzögerten Knicks zu verstehen, vergleichen wir es mit dem traditionellen Knacken:
<code>embeddings_traditional_chunking = model.encode(chunks)</code>
<code>import numpy as np
cos_sim = lambda x, y: np.dot(x, y) / (np.linalg.norm(x) * np.linalg.norm(y))
q = "Berlin"
berlin_embedding = model.encode(q)
print(q)
print('\n')
for chunk, new_embedding, trad_embeddings in zip(chunks, embeddings, embeddings_traditional_chunking):
print(chunk.strip())
print(f'Late chunking:', cos_sim(berlin_embedding, new_embedding))
print(f'Traditional chunking:', cos_sim(berlin_embedding, trad_embeddings))
print("------------------------------------------------------------------")</code><code>Berlin Berlin is the capital and largest city of Germany, both by area and by population. Late chunking: 0.84954596 Traditional chunking: 0.84862185 ------------------------------------------------------------------ Its more than 3.85 million inhabitants make it the European Union's most populous city, as measured by population within city limits. Late chunking: 0.82489026 Traditional chunking: 0.70843375 ------------------------------------------------------------------ The city is also one of the states of Germany, and is the third smallest state in the country in terms of area. Late chunking: 0.84980094 Traditional chunking: 0.7534553 ------------------------------------------------------------------</code>
Wie Sie im zweiten und dritten Blöcke sehen können, zeigt das traditionelle Chunking im Vergleich zum Wort "Berlin" Ähnlichkeitswerte von 70-75%. Mithilfe verzögerter Chunking (Aufrechterhaltung des Kontextes des gesamten Dokuments) stiegen diese Ergebnisse auf 82-84%. Dies deutet darauf hin, dass das verzögerte Knacken eine bessere Aufgabe darstellt, den Kontext zu bewahren und aussagekräftigere Einbettungen zu erstellen, was zu genaueren Suchergebnissen führt.
verzögertes Chunking ist eine signifikante Verbesserung des Dokumentenabrufsystems, insbesondere in der Lag -Pipeline. Das verzögerte Chunking bewahrt den vollständigen Kontext in jedem Block durch Warten, bis das Dokument vollständig eingebettet ist, bevor das Dokument geteilt wird. Dies führt zu genaueren und aussagekräftigeren Einbettungen.
Implementieren Sie Lag mit Langchain, um einen Chatbot für die Beantwortung von Fragen zu technischen Dokumentation zu erstellen. Project erforschen
Das obige ist der detaillierte Inhalt vonSpätes Knacken für Rag: Implementierung mit Jina AI. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!
Der Unterschied zwischen WeChat-Dienstkonto und offiziellem Konto
Wie man den Douyin-Moment mit engen Freunden zum Leuchten bringt
Wie man mit langsamer Computerverzögerung und langsamer Reaktion umgeht
esd zu iso
Einführung in PHP-Konfigurationsdateien
So reinigen Sie das Laufwerk C, wenn es rot wird
Wie man unter Linux mit verstümmelten chinesischen Schriftzeichen umgeht
myfreemp3
![[Web-Frontend] Node.js-Schnellstart](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
