RAG-Anwendungen in verschiedenen Sprachen erkunden: Konversation mit der Mischna | von Shlomo Tannor | Mai 2024

Aufbau eines sprachübergreifenden RAG-Methods für rabbinische Texte

15 Minuten Lesezeit

·

23. Mai 2024

Ich freue mich, in diesem Beitrag meine Erfahrungen mit der Entwicklung einer einzigartigen Retrieval-Augmented Technology (RAG)-Anwendung für die Interaktion mit rabbinischen Texten mit Ihnen zu teilen. MishnahBot zielt darauf ab, Wissenschaftlern und normalen Benutzern eine intuitive Möglichkeit zu bieten, die Mischna¹ interaktiv abzufragen und zu erkunden. Es kann dabei helfen, Probleme zu lösen, wie z. B. das schnelle Auffinden relevanter Quelltexte oder das Zusammenfassen einer komplexen Debatte über religiöse Gesetze, um das Wesentliche herauszuarbeiten.

Ich hatte die Idee für ein solches Projekt vor ein paar Jahren, aber ich hatte das Gefühl, dass die Technologie noch nicht ausgereift struggle. Mit der Weiterentwicklung großer Sprachmodelle und RAG-Funktionen ist es jetzt ziemlich unkompliziert.

So sieht unser Endprodukt aus, das Sie ausprobieren können Hier:

RAG-Anwendungen gewinnen zunehmend an Bedeutung, da sie die Genauigkeit verbessern und die in großen Sprachmodellen (LLMs) verfügbare Argumentationsleistung nutzen. Stellen Sie sich vor, Sie könnten mit Ihrer Bibliothek, einer Sammlung von Autohandbüchern desselben Herstellers oder Ihren Steuerunterlagen chatten. Sie können Fragen stellen und Antworten erhalten, die auf einer Fülle von Fachwissen basieren.

Es gibt zwei neue Developments bei der Verbesserung der Interaktion von Sprachmodellen: Retrieval-Augmented Technology (RAG) und die Erhöhung der Kontextlänge, möglicherweise durch die Zulassung sehr langer Dokumente als Anhänge.

Ein wesentlicher Vorteil von RAG-Systemen ist die Kosteneffizienz. Mit RAG können Sie große Kontexte verarbeiten, ohne die Abfragekosten drastisch zu erhöhen, was teuer werden kann. Darüber hinaus ist RAG modularer, sodass Sie verschiedene Wissensdatenbanken und LLM-Anbieter per Plug-and-Play verwenden können. Andererseits ist die Erhöhung der Kontextlänge direkt in Sprachmodellen eine spannende Entwicklung, die die Verarbeitung viel längerer Texte in einer einzigen Interaktion ermöglichen kann.

Für dieses Projekt habe ich AWS SageMaker als Entwicklungsumgebung, AWS Bedrock für den Zugriff auf verschiedene LLMs und das LangChain-Framework zur Verwaltung der Pipeline verwendet. Beide AWS-Dienste sind benutzerfreundlich und berechnen nur die genutzten Ressourcen. Ich möchte Sie additionally wirklich dazu ermutigen, sie selbst auszuprobieren. Für Bedrock müssen Sie Zugriff auf Llama 3 70b Instruct und Claude Sonnet anfordern.

Öffnen wir ein neues Jupyter-Pocket book und installieren die Pakete, die wir verwenden werden:

!pip set up chromadb tqdm langchain chromadb sentence-transformers

Der Datensatz für dieses Projekt ist die Mischna, ein alter rabbinischer Textual content, der für die jüdische Custom von zentraler Bedeutung ist. Ich habe diesen Textual content gewählt, weil er mir am Herzen liegt und weil er auch eine Herausforderung für Sprachmodelle darstellt, da es sich um ein Nischenthema handelt. Der Datensatz wurde von der Sefaria-Export repository², eine Fundgrube rabbinischer Texte mit englischen Übersetzungen, die mit dem hebräischen Unique übereinstimmen. Diese Übereinstimmung erleichtert den Wechsel zwischen den Sprachen in verschiedenen Schritten unserer RAG-Anwendung.

Hinweis: Der hier angewandte Prozess kann auch auf jede beliebige Textsammlung angewendet werden. Dieses Beispiel zeigt auch, wie die RAG-Technologie in verschiedenen Sprachen eingesetzt werden kann, wie in diesem Fall am Beispiel von Hebräisch.

Zuerst müssen wir die relevanten Daten herunterladen. Wir verwenden git sparse-checkout, da das gesamte Repository ziemlich groß ist. Öffnen Sie das Terminalfenster und führen Sie Folgendes aus.

git init sefaria-json
cd sefaria-json
git sparse-checkout init --cone
git sparse-checkout set json
git distant add origin https://github.com/Sefaria/Sefaria-Export.git
git pull origin grasp

tree Mishna/ | much less

Und… voilà! Wir haben jetzt die Datendateien, die wir brauchen:

Mishnah
├── Seder Kodashim
│   ├── Mishnah Arakhin
│   │   ├── English
│   │   │   └── merged.json
│   │   └── Hebrew
│   │       └── merged.json
│   ├── Mishnah Bekhorot
│   │   ├── English
│   │   │   └── merged.json
│   │   └── Hebrew
│   │       └── merged.json
│   ├── Mishnah Chullin
│   │   ├── English
│   │   │   └── merged.json
│   │   └── Hebrew
│   │       └── merged.json

Laden wir nun die Dokumente in unsere Jupyter-Pocket book-Umgebung:

import os
import json
import pandas as pd
from tqdm import tqdm
# Perform to load all paperwork right into a DataFrame with progress bar
def load_documents(base_path):
knowledge = ()
for seder in tqdm(os.listdir(base_path), desc="Loading Seders"):
seder_path = os.path.be a part of(base_path, seder)
if os.path.isdir(seder_path):
for tractate in tqdm(os.listdir(seder_path), desc=f"Loading Tractates in {seder}", depart=False):
tractate_path = os.path.be a part of(seder_path, tractate)
if os.path.isdir(tractate_path):
english_file = os.path.be a part of(tractate_path, "English", "merged.json")
hebrew_file = os.path.be a part of(tractate_path, "Hebrew", "merged.json")
if os.path.exists(english_file) and os.path.exists(hebrew_file):
with open(english_file, 'r', encoding='utf-8') as ef, open(hebrew_file, 'r', encoding='utf-8') as hf:
english_data = json.load(ef)
hebrew_data = json.load(hf)
for chapter_index, (english_chapter, hebrew_chapter) in enumerate(zip(english_data('textual content'), hebrew_data('textual content'))):
for mishnah_index, (english_paragraph, hebrew_paragraph) in enumerate(zip(english_chapter, hebrew_chapter)):
knowledge.append({
"seder": seder,
"tractate": tractate,
"chapter": chapter_index + 1,
"mishnah": mishnah_index + 1,
"english": english_paragraph,
"hebrew": hebrew_paragraph
})
return pd.DataFrame(knowledge)
# Load all paperwork
base_path = "Mishnah"
df = load_documents(base_path)
# Save the DataFrame to a file for future reference
df.to_csv(os.path.be a part of(base_path, "mishnah_metadata.csv"), index=False)
print("Dataset efficiently loaded into DataFrame and saved to file.")

Und schauen Sie sich die Daten an:

df.form
(4192, 7)
print(df.head()(("tractate", "mishnah", "english")))
tractate  mishnah                                            english
0  Mishnah Arakhin        1  <b>Everybody takes</b> vows of <b>valuation</b>...
1  Mishnah Arakhin        2  With regard to <b>a gentile, Rabbi Meir says:<...
2  Mishnah Arakhin        3  <b>One who's moribund and one who's taken to...
3  Mishnah Arakhin        4  Within the case of a pregnant <b>girl who's take...
4  Mishnah Arakhin        1  <b>One can't be charged for a valuation much less ...

Sieht intestine aus, wir können mit der Vektordatenbankphase fortfahren.

Als Nächstes vektorisieren wir den Textual content und speichern ihn in einer lokalen ChromaDB. Die Idee besteht in der Darstellung von Textual content als dichte Vektoren – Zahlenfelder –, sodass semantisch ähnliche Texte im Vektorraum „nahe“ beieinander liegen. Mit dieser Technologie können wir bei einer Abfrage die relevanten Passagen abrufen.

Wir haben uns für ein leichtes Vektorisierungsmodell entschieden, das all-MiniLM-L6-v2das effizient auf einer CPU ausgeführt werden kann. Dieses Modell bietet ein gutes Gleichgewicht zwischen Leistung und Ressourceneffizienz und ist daher für unsere Anwendung geeignet. Während moderne Modelle wie OpenAIs text-embedding-3-large bieten möglicherweise eine bessere Leistung, erfordern jedoch erhebliche Rechenressourcen und werden normalerweise auf GPUs ausgeführt.

Weitere Informationen zum Einbetten von Modellen und ihrer Leistung finden Sie im MTEB-Bestenliste das verschiedene Texteinbettungsmodelle anhand mehrerer Aufgaben vergleicht.

Hier ist der Code, den wir zum Vektorisieren verwenden werden (die Ausführung auf diesem Datensatz auf einem CPU-Rechner sollte nur wenige Minuten dauern):

import numpy as np
from sentence_transformers import SentenceTransformer
import chromadb
from chromadb.config import Settings
from tqdm import tqdm
# Initialize the embedding mannequin
mannequin = SentenceTransformer('all-MiniLM-L6-v2', system='cpu')
# Initialize ChromaDB
chroma_client = chromadb.Consumer(Settings(persist_directory="chroma_db"))
assortment = chroma_client.create_collection("mishnah")
# Load the dataset from the saved file
df = pd.read_csv(os.path.be a part of("Mishnah", "mishnah_metadata.csv"))
# Perform to generate embeddings with progress bar
def generate_embeddings(paragraphs, mannequin):
embeddings = ()
for paragraph in tqdm(paragraphs, desc="Producing Embeddings"):
embedding = mannequin.encode(paragraph, show_progress_bar=False)
embeddings.append(embedding)
return np.array(embeddings)
# Generate embeddings for English paragraphs
embeddings = generate_embeddings(df('english').tolist(), mannequin)
df('embedding') = embeddings.tolist()
# Retailer embeddings in ChromaDB with progress bar
for index, row in tqdm(df.iterrows(), desc="Storing in ChromaDB", complete=len(df)):
assortment.add(embeddings=(row('embedding')), paperwork=(row('english')), metadatas=({
"seder": row('seder'),
"tractate": row('tractate'),
"chapter": row('chapter'),
"mishnah": row('mishnah'),
"hebrew": row('hebrew')
}))
print("Embeddings and metadata efficiently saved in ChromaDB.")

Da unser Datensatz nun bereit ist, können wir unsere Retrieval-Augmented Technology (RAG)-Anwendung auf Englisch erstellen. Dafür verwenden wir LangChain, ein leistungsstarkes Framework, das eine einheitliche Schnittstelle für verschiedene Sprachmodelloperationen und -integrationen bietet und so die Erstellung anspruchsvoller Anwendungen vereinfacht.

LangChain vereinfacht den Prozess der Integration verschiedener Komponenten wie Sprachmodelle (LLMs), Retriever und Vektorspeicher. Durch die Verwendung von LangChain können wir uns auf die übergeordnete Logik unserer Anwendung konzentrieren, ohne uns um die zugrunde liegende Komplexität der einzelnen Komponenten kümmern zu müssen.

Hier ist der Code zum Einrichten unseres RAG-Methods:

from langchain.chains import LLMChain, RetrievalQA
from langchain.llms import Bedrock
from langchain.prompts import PromptTemplate
from sentence_transformers import SentenceTransformer
import chromadb
from chromadb.config import Settings
from typing import Record
# Initialize AWS Bedrock for Llama 3 70B Instruct
llm = Bedrock(
model_id="meta.llama3-70b-instruct-v1:0"
)
# Outline the immediate template
prompt_template = PromptTemplate(
input_variables=("context", "query"),
template="""
Reply the next query based mostly on the supplied context alone:
Context: {context}
Query: {query}
Reply (quick and concise):
""",
)
# Initialize ChromaDB
chroma_client = chromadb.Consumer(Settings(persist_directory="chroma_db"))
assortment = chroma_client.get_collection("mishnah")
# Outline the embedding mannequin
embedding_model = SentenceTransformer('all-MiniLM-L6-v2', system='cpu')
# Outline a easy retriever operate
def simple_retriever(question: str, okay: int = 3) -> Record(str):
query_embedding = embedding_model.encode(question).tolist()
outcomes = assortment.question(query_embeddings=(query_embedding), n_results=okay)
paperwork = outcomes('paperwork')(0)  # Entry the primary listing inside 'paperwork'
sources = outcomes('metadatas')(0)  # Entry the metadata for sources
return paperwork, sources
# Initialize the LLM chain
llm_chain = LLMChain(
llm=llm,
immediate=prompt_template
)
# Outline SimpleQA chain
class SimpleQAChain:
def __init__(self, retriever, llm_chain):
self.retriever = retriever
self.llm_chain = llm_chain
def __call__(self, inputs, do_print_context=True):
query = inputs("question")
retrieved_docs, sources = self.retriever(query)
context = "nn".be a part of(retrieved_docs)
response = self.llm_chain.run({"context": context, "query": query})
response_with_sources = f"{response}n" + "#"*50 + "nSources:n" + "n".be a part of(
(f"{supply('seder')} {supply('tractate')} Chapter {supply('chapter')}, Mishnah {supply('mishnah')}" for supply in sources)
)
if do_print_context:
print("#"*50)
print("Retrieved paragraphs:")
for doc in retrieved_docs:
print(doc(:100) + "...")
return response_with_sources
# Initialize and check SimpleQAChain
qa_chain = SimpleQAChain(retriever=simple_retriever, llm_chain=llm_chain)

1. AWS Bedrock-Initialisierung: Wir initialisieren AWS Bedrock mit Llama 3 70B Instruct. Dieses Modell wird zum Generieren von Antworten basierend auf dem abgerufenen Kontext verwendet.
2. Eingabeaufforderungsvorlage: Die Eingabeaufforderungsvorlage ist so definiert, dass sie den Kontext und die Frage in eine Struktur bringt, die der LLM verstehen kann. Dies hilft bei der Generierung präziser und relevanter Antworten. Sie können gerne herumexperimentieren und die Vorlage nach Bedarf anpassen.
3. Einbettungsmodell: Wir verwenden das Modell „all-MiniLM-L6-v2“ auch zum Generieren von Einbettungen für die Abfragen. Wir hoffen, dass die Abfrage eine ähnliche Darstellung wie die relevanten Antwortabsätze aufweist. Hinweis: Um die Abrufleistung zu steigern, könnten wir ein LLM verwenden, um die Benutzerabfrage zu ändern und zu optimieren, sodass sie dem Stil der RAG-Datenbank ähnlicher ist.
4. LLM-Kette: Der LLMChain Die Klasse von LangChain wird verwendet, um die Interaktion zwischen dem LLM und dem abgerufenen Kontext zu verwalten.
5. SimpleQAChain: Diese benutzerdefinierte Klasse integriert den Retriever und die LLM-Kette. Sie ruft relevante Absätze ab, formatiert sie in einen Kontext und generiert eine Antwort.

Okay! Probieren wir es aus! Wir verwenden eine Abfrage, die sich auf die allerersten Absätze der Mischna bezieht.

response = qa_chain({"question": "What's the acceptable time to recite Shema?"})
print("#"*50)
print("Response:")
print(response)

##################################################
Retrieved paragraphs:
The start of tractate <i>Berakhot</i>, the primary tractate within the first of the six orders of Mish...
<b>From when does one recite <i>Shema</i> within the morning</b>? <b>From</b> when an individual <b>can disti...
Beit Shammai and Beit Hillel disputed the right method to recite <i>Shema</i>. <b>Beit Shammai say:</b...
##################################################
Response:
Within the night, from when the monks enter to partake of their teruma till the top of the primary watch, or in keeping with Rabban Gamliel, till daybreak. Within the morning, from when an individual can distinguish between sky-blue and white, till dawn.
##################################################
Sources:
Seder Zeraim Mishnah Berakhot Chapter 1, Mishnah 1
Seder Zeraim Mishnah Berakhot Chapter 1, Mishnah 2
Seder Zeraim Mishnah Berakhot Chapter 1, Mishnah 3

Das scheint ziemlich genau zu sein.

Versuchen wir es mit einer anspruchsvolleren Frage:

response = qa_chain({"question": "What's the third prohibited form of work on the sabbbath?"})
print("#"*50)
print("Response:")
print(response)

##################################################
Retrieved paragraphs:
They stated an vital normal precept with regard to the sabbatical 12 months: something that's meals f...
This elementary mishna enumerates those that carry out the <b>major classes of labor</b> prohibit...
<b>Rabbi Akiva stated: I requested Rabbi Eliezer with regard to</b> one who <b>performs a number of</b> prohi...
##################################################
Response:
One who reaps.
##################################################
Sources:
Seder Zeraim Mishnah Sheviit Chapter 7, Mishnah 1
Seder Moed Mishnah Shabbat Chapter 7, Mishnah 2
Seder Kodashim Mishnah Keritot Chapter 3, Mishnah 10

Sehr schön.

Ich habe es ausprobiert und das hier ist dabei herausgekommen:

Die Antwort ist lang und nicht auf den Punkt gebracht, und die gegebene Antwort ist falsch (Ernten ist die dritte Artwork von Arbeit in der Liste, während Auswählen ist der siebte). Das ist das, was wir eine Halluzination.

Obwohl Claude ein leistungsstarkes Sprachmodell ist, fehlt es dem ausschließlichen Verlassen auf ein LLM zum Generieren von Antworten aus gespeicherten Trainingsdaten oder sogar durch die Verwendung von Internetsuchen an der Präzision und Kontrolle, die eine benutzerdefinierte Datenbank in einer Retrieval-Augmented Technology (RAG)-Anwendung bietet. Hier ist der Grund:

1. Präzision und Kontext: Unsere RAG-Anwendung ruft genaue Absätze aus einer benutzerdefinierten Datenbank ab und gewährleistet so hohe Relevanz und Genauigkeit. Ohne spezifische Abrufmechanismen könnte Claude möglicherweise nicht das gleiche Maß an detaillierten und kontextspezifischen Antworten liefern.
2. Effizienz: Der RAG-Ansatz verarbeitet große Datensätze effizient und kombiniert Abruf und Generierung, um präzise und kontextrelevante Antworten zu erhalten.
3. Kosteneffektivität: Durch die Verwendung eines relativ kleinen LLM wie Llama 3 70B Instruct erzielen wir genaue Ergebnisse, ohne bei jeder Abfrage eine große Datenmenge senden zu müssen. Dies reduziert die Kosten, die mit der Verwendung größerer, ressourcenintensiverer Modelle verbunden sind.

Dieser strukturierte Abrufprozess stellt sicher, dass Benutzer die genauesten und relevantesten Antworten erhalten, indem er sowohl die Sprachgenerierungsfunktionen von LLMs als auch die Präzision des benutzerdefinierten Datenabrufs nutzt.

Abschließend werden wir uns mit der Herausforderung befassen, auf Hebräisch mit dem hebräischen Originaltext zu interagieren. Derselbe Ansatz lässt sich auf jede andere Sprache anwenden, solange Sie die Texte für die Abrufphase ins Englische übersetzen können.

Die Unterstützung von Interaktionen auf Hebräisch fügt eine zusätzliche Komplexitätsebene hinzu, da Embedding-Modelle und große Sprachmodelle (LLMs) in der Regel stärker auf Englisch sind. Obwohl einige Embedding-Modelle und LLMs Hebräisch unterstützen, sind sie oft weniger strong als ihre englischen Gegenstücke, insbesondere die kleineren Embedding-Modelle, die sich beim Coaching wahrscheinlich mehr auf Englisch konzentrierten.

Um dieses Drawback zu lösen, könnten wir unser eigenes hebräisches Embedding-Modell trainieren. Ein anderer praktischer Ansatz besteht jedoch darin, eine einmalige Übersetzung des Textes ins Englische vorzunehmen und englische Embeddings für den Abrufprozess zu verwenden. Auf diese Weise profitieren wir von der starken Leistung englischer Modelle und unterstützen gleichzeitig hebräische Interaktionen.

In unserem Fall verfügen wir bereits über professionelle menschliche Übersetzungen des Mischna-Textes ins Englische. Wir werden diese nutzen, um genaue Abfragen sicherzustellen und gleichzeitig die Integrität der hebräischen Antworten zu wahren. So können wir dieses sprachübergreifende RAG-System einrichten:

1. Eingabeabfrage auf Hebräisch: Benutzer können ihre Anfragen auf Hebräisch eingeben.
2. Übersetzen Sie die Abfrage ins Englische: Wir verwenden einen LLM, um die hebräische Abfrage ins Englische zu übersetzen.
3. Betten Sie die Abfrage ein: Anschließend wird die übersetzte englische Abfrage eingebettet.
4. Finden Sie relevante Dokumente mithilfe englischer Einbettungen: Wir verwenden die englischen Einbettungen, um relevante Dokumente zu finden.
5. Entsprechende hebräische Texte abrufen: Die entsprechenden hebräischen Texte werden als Kontext abgerufen. Im Wesentlichen verwenden wir die englischen Texte als Schlüssel und die hebräischen Texte als die entsprechenden Werte im Abrufvorgang.
6. Antworten Sie auf Hebräisch mit einem LLM: Ein LLM generiert die Antwort auf Hebräisch unter Verwendung des hebräischen Kontexts.

Zur Generierung verwenden wir Claude Sonnet, da es bei hebräischem Textual content im Vergleich zu Llama 3 eine deutlich bessere Leistung zeigt.

Hier ist die Codeimplementierung:

from langchain.chains import LLMChain, RetrievalQA
from langchain.llms import Bedrock
from langchain_community.chat_models import BedrockChat
from langchain.prompts import PromptTemplate
from sentence_transformers import SentenceTransformer
import chromadb
from chromadb.config import Settings
from typing import Record
import re
# Initialize AWS Bedrock for Llama 3 70B Instruct with particular configurations for translation
translation_llm = Bedrock(
model_id="meta.llama3-70b-instruct-v1:0",
model_kwargs={
"temperature": 0.0,  # Set decrease temperature for translation
"max_gen_len": 50  # Restrict variety of tokens for translation
}
)
# Initialize AWS Bedrock for Claude Sonnet with particular configurations for era
generation_llm = BedrockChat(
model_id="anthropic.claude-3-sonnet-20240229-v1:0"
)
# Outline the interpretation immediate template
translation_prompt_template = PromptTemplate(
input_variables=("textual content"),
template="""Translate the next Hebrew textual content to English:
Enter textual content: {textual content}
Translation: 
"""
)
# Outline the immediate template for Hebrew solutions
hebrew_prompt_template = PromptTemplate(
input_variables=("context", "query"),
template="""ענה על השאלה הבאה בהתבסס על ההקשר המסופק בלבד:
הקשר: {context}
שאלה: {query}
תשובה (קצרה ותמציתית):
"""
)
# Initialize ChromaDB
chroma_client = chromadb.Consumer(Settings(persist_directory="chroma_db"))
assortment = chroma_client.get_collection("mishnah")
# Outline the embedding mannequin
embedding_model = SentenceTransformer('all-MiniLM-L6-v2', system='cpu')
# Translation chain for translating queries from Hebrew to English
translation_chain = LLMChain(
llm=translation_llm,
immediate=translation_prompt_template
)
# Initialize the LLM chain for Hebrew solutions
hebrew_llm_chain = LLMChain(
llm=generation_llm,
immediate=hebrew_prompt_template
)
# Outline a easy retriever operate for Hebrew texts
def simple_retriever(question: str, okay: int = 3) -> Record(str):
query_embedding = embedding_model.encode(question).tolist()
outcomes = assortment.question(query_embeddings=(query_embedding), n_results=okay)
paperwork = (meta('hebrew') for meta in outcomes('metadatas')(0))  # Entry Hebrew texts
sources = outcomes('metadatas')(0)  # Entry the metadata for sources
return paperwork, sources
# Perform to take away vowels from Hebrew textual content
def remove_vowels_hebrew(hebrew_text):
sample = re.compile(r'(u0591-u05C7)')
hebrew_text_without_vowels = re.sub(sample, '', hebrew_text)
return hebrew_text_without_vowels
# Outline SimpleQA chain with translation
class SimpleQAChainWithTranslation:
def __init__(self, translation_chain, retriever, llm_chain):
self.translation_chain = translation_chain
self.retriever = retriever
self.llm_chain = llm_chain
def __call__(self, inputs):
hebrew_query = inputs("question")
print("#" * 50)
print(f"Hebrew question: {hebrew_query}")
# Print the interpretation immediate
translation_prompt = translation_prompt_template.format(textual content=hebrew_query)
print("#" * 50)
print(f"Translation Immediate: {translation_prompt}")
# Carry out the interpretation utilizing the interpretation chain with particular configurations
translated_query = self.translation_chain.run({"textual content": hebrew_query})
print("#" * 50)
print(f"Translated Question: {translated_query}")  # Print the translated question for debugging
retrieved_docs, sources = self.retriever(translated_query)
retrieved_docs = (remove_vowels_hebrew(doc) for doc in retrieved_docs)
context = "n".be a part of(retrieved_docs)
# Print the ultimate immediate for era
final_prompt = hebrew_prompt_template.format(context=context, query=hebrew_query)
print("#" * 50)
print(f"Closing Immediate for Technology:n {final_prompt}")
response = self.llm_chain.run({"context": context, "query": hebrew_query})
response_with_sources = f"{response}n" + "#" * 50 + "מקורות:n" + "n".be a part of(
(f"{supply('seder')} {supply('tractate')} פרק {supply('chapter')}, משנה {supply('mishnah')}" for supply in sources)
)
return response_with_sources
# Initialize and check SimpleQAChainWithTranslation
qa_chain = SimpleQAChainWithTranslation(translation_chain, simple_retriever, hebrew_llm_chain)

Versuchen wir es! Wir verwenden die gleiche Frage wie zuvor, diesmal jedoch auf Hebräisch:

response = qa_chain({"question": "מהו סוג העבודה השלישי האסור בשבת?"})
print("#" * 50)
print(response)

##################################################
Hebrew question: מהו סוג העבודה השלישי האסור בשבת?
##################################################
Translation Immediate: Translate the next Hebrew textual content to English:
Enter textual content: מהו סוג העבודה השלישי האסור בשבת?
Translation: 
##################################################
Translated Question:  What's the third kind of labor that's forbidden on Shabbat?
Enter textual content: כל העולם כולו גשר צר מאוד
Translation: 
##################################################
Closing Immediate for Technology:
ענה על השאלה הבאה בהתבסס על ההקשר המסופק בלבד:
הקשר: אבות מלאכות ארבעים חסר אחת. הזורע. והחורש. והקוצר. והמעמר. הדש. והזורה. הבורר. הטוחן. והמרקד. והלש. והאופה. הגוזז את הצמר. המלבנו. והמנפצו. והצובעו. והטווה. והמסך. והעושה שני בתי נירין. והאורג שני חוטין. והפוצע שני חוטין. הקושר. והמתיר. והתופר שתי תפירות. הקורע על מנת לתפר שתי תפירות. הצד צבי. השוחטו. והמפשיטו. המולחו, והמעבד את עורו. והמוחקו. והמחתכו. הכותב שתי אותיות. והמוחק על מנת לכתב שתי אותיות. הבונה. והסותר. המכבה. והמבעיר. המכה בפטיש. המוציא מרשות לרשות. הרי אלו אבות מלאכות ארבעים חסר אחת: 
חבתי כהן גדול, לישתן ועריכתן ואפיתן בפנים, ודוחות את השבת. טחונן והרקדן אינן דוחות את השבת. כלל אמר רבי עקיבא, כל מלאכה שאפשר לה לעשות מערב שבת, אינה דוחה את השבת. ושאי אפשר לה לעשות מערב שבת, דוחה את השבת: 
הקורע בחמתו ועל מתו, וכל המקלקלין, פטורין. והמקלקל על מנת לתקן, שעורו כמתקן: 
שאלה: מהו סוג העבודה השלישי האסור בשבת?
תשובה (קצרה ותמציתית):
##################################################
הקוצר.
##################################################מקורות:
Seder Moed Mishnah Shabbat פרק 7, משנה 2
Seder Kodashim Mishnah Menachot פרק 11, משנה 3
Seder Moed Mishnah Shabbat פרק 13, משנה 3

Wir haben eine präzise, ​​einsilbige Antwort auf unsere Frage erhalten. Ziemlich cool, oder?

Die Übersetzung mit Llama 3 Instruct stellte mich vor mehrere Herausforderungen. Egal, was ich versuchte, das Modell lieferte zunächst unsinnige Ergebnisse. (Offenbar reagiert Llama 3 Instruct sehr empfindlich auf Eingabeaufforderungen, die mit einem Zeilenumbruchzeichen beginnen!)

Nachdem dieses Drawback gelöst struggle, gab das Modell tendenziell die richtige Antwort aus, fuhr dann aber mit zusätzlichem, irrelevantem Textual content fort, sodass es sich als effektiv erwies, die Ausgabe bei einem Zeilenumbruchzeichen zu stoppen.

Die Steuerung des Ausgabeformats kann schwierig sein. Einige Strategien umfassen die Anforderung eines JSON-Codecs oder die Bereitstellung von Beispielen mit wenigen Eingabeaufforderungen.

In diesem Projekt entfernen wir auch Vokale aus den hebräischen Texten, da die meisten hebräischen Texte im Web keine Vokale enthalten und wir möchten, dass der Kontext für unser LLM dem während des Vortrainings angezeigten Textual content ähnelt.

Die Entwicklung dieser RAG-Anwendung struggle eine faszinierende Reise, bei der die Nuancen antiker Texte mit modernen KI-Technologien vermischt wurden. Meine Leidenschaft, die Bibliothek antiker rabbinischer Texte für alle (mich eingeschlossen) zugänglicher zu machen, hat dieses Projekt vorangetrieben. Diese Technologie ermöglicht das Chatten mit Ihrer Bibliothek, die Suche nach Quellen basierend auf Ideen und vieles mehr. Der hier verwendete Ansatz kann auf andere wertvolle Textsammlungen angewendet werden und eröffnet neue Möglichkeiten für den Zugriff auf und die Erforschung historischen und kulturellen Wissens.

Es ist erstaunlich zu sehen, wie all dies dank der heute verfügbaren leistungsstarken Instruments und Frameworks in nur wenigen Stunden erreicht werden kann. Den vollständigen Code finden Sie unter GitHubund spielen Sie mit dem MischnaBot Webseite.

Bitte teilen Sie uns Ihre Kommentare und Fragen mit, insbesondere wenn Sie etwas Ähnliches ausprobieren. Wenn Sie in Zukunft mehr Inhalte wie diesen sehen möchten, lassen Sie es mich wissen!