Text-to-SQL-Technologien haben häufig Schwierigkeiten, den vollständigen Kontext und die Bedeutung der Anfrage eines Benutzers zu erfassen, was zu Abfragen führt, die nicht genau mit den beabsichtigten Einrichtungen übereinstimmen. Während Entwickler hart daran arbeiten, diese Systeme zu verbessern, lohnt es sich, in Frage zu stellen, ob es eine bessere Methode gibt.
Geben Sie Rag-to-SQL ein-ein neuer Ansatz, der das Verständnis der natürlichen Sprache mit einem leistungsstarken Datenabruf kombiniert, um genaue SQL-Abfragen zu generieren. Durch das Beste aus natürlicher Sprachverarbeitung und Informationsabruf bietet Rag-to-SQL eine zuverlässigere Möglichkeit, die Alltagssprache aus Ihrer Datenbank in sinnvolle Erkenntnisse zu verwandeln.
In diesem Artikel werden wir untersuchen, wie Rag-to-SQL die Art und Weise, wie wir mit Datenbanken interagieren, verändern können, insbesondere mit Google Cloud-Diensten wie BigQuery und Vertex AI.
Dieser Artikel wurde als Teil des Data Science -Blogathons veröffentlicht.
Die Hauptidee hinter Text zu SQL -Modellen von LLM bestand darin, Menschen, die nichts über SQL kennen, mit Datenbank zu interagieren und stattdessen Informationen mit natürlicher Sprache zu erhalten. Der vorhandene SQL -Framework von Text 2 ist hauptsächlich in LLM -Wissen angewiesen, um die Abfrage für natürliche Sprache in SQL -Abfrage umzuwandeln. Dies kann zu einer falschen oder ungültigen Formulierung von SQL -Abfragen führen. Hier kommt der neue Ansatz von SQL zu unserer Rettung, die im nächsten Abschnitt erklärt wird.
Um die Mängeln von Text an SQL zu überwinden, können wir den innovativen Ansatz von RAG auf SQL verwenden. Die Integration von Domäneninformationen zur Datenbank ist das Hauptproblem, mit dem jede Text-zu-SQL-Software konfrontiert ist. Die RAG2SQL -Architektur befasst sich mit dieser Schwierigkeit durch Hinzufügen von kontextbezogenen Daten (Metadaten, DDL, Abfragen und mehr). Diese Daten werden dann „geschult“ und zur Verwendung zur Verfügung gestellt.
Darüber hinaus bewertet der „Retriever“ den relevantesten Kontext, um auf die Benutzerabfrage zu reagieren. Das Endergebnis ist die Präzision stark verbessert.
Befolgen Sie eine detaillierte Anleitung zur Implementierung von Rag-to-SQL-Diensten mit Google Cloud-Diensten wie BigQuery und Vertex AI.
Um diesen Code zu befolgen und auszuführen, müssen Sie Ihr GCP (Google Cloud -Konto mit Zahlungsinformationen) einrichten. Zunächst bieten sie 90 Tage lang kostenlose 300 -$ -Testversion an, sodass keine Gebühren anfallen. Detail für Kontoeinrichtungen: Link
Im Folgenden finden Sie das Code -Flussdiagramm, das die verschiedenen Codeblöcke auf einer höheren Ebene beschreibt. Wir können es verweisen, um mitzumachen, während wir fortfahren.
Die Code -Implementierung kann in 3 Hauptblöcke unterteilt werden:
In Colab Notebook müssen wir die für diese Implementierung erforderlichen Bibliotheken installieren.
! PIP Installieren Sie Langchain == 0.0.340 -Quiet ! PIP Installieren Sie Chromadb == 0.4.13 -Quiet ! PIP Installieren Sie Google-Cloud-BigQuery [Pandas]-Quiet ! PIP Installieren Sie die Google-Cloud-Diplattform-Quiet#importieren Sie CSV
Jetzt müssen wir einige Variablen deklarieren, um unser GCP -Projekt und große Abfragedatensätze zu initialisieren. Mit diesen Variablen können wir in unserem Notebook auf die Tabellen in großer Abfrage mit GCP zugreifen.
Sie können diese Details in Ihrer GCP -Cloud -Konsole anzeigen. In BigQuery können Sie einen Datensatz erstellen und im Datensatz können Sie eine Tabelle hinzufügen oder hochladen, um Details zu finden. Erstellen Sie die Tabelle erstellen.
Vertex_project = "Ihre GCP -Projekt -ID" # @param {type: "String"}
Vertex_region = "us-central1" # @param {type: "string"}
BigQuery_dataset = "Big Query -Datensatzname" # @param {type: "String"}
BigQuery_project = "Vertex Project ID" # @param {type: "String"}Jetzt authentifizieren und melden Sie sich in Ihrem Notebook mit Ihrem GCP -Vertex -KI mit dem folgenden Code in Colab aus.
von Google.Colab import Auth auth.authenticate_user () Scheitelpunkt importieren vertexai.init (project = vertex_project, location = vertex_region)
Jetzt müssen wir einen Vektor -DB erstellen, der ein Schema verschiedener Tabellen in unserem Datensatz enthält, und wir werden einen Retriever auf diesem Vektor -DB erstellen, damit wir Lappen in unseren Workflow einbeziehen können.
Verbinden Sie mit dem BQ -Client in Python und abrufen Schema von Tabellen.
von Google.Cloud BigQuery importieren
JSON importieren
#Tabellenschemata
bq_client = bigQuery.client (project = vertex_project)
bq_tables = bq_client.list_tables (dataSet = f "{BigQuery_project}. {BigQuery_dataset}"))
Schemas = []
Für BQ_TABLE in BQ_TABLE:
t = bq_client.get_table (f "{bigQuery_project}. {BigQuery_dataset}. {bq_table.table_id}")
schema_fields = [f.to_api_repr () für f in t.schema]
Schema = f "Das Schema für Tabelle {bq_table.table_id} ist das folgende: \ n`` {json.dumps (schema_fields, indent = 1)}` `` `` “
Schemas.Append (Schema)
print (f "Found {len (Schemas)} Tabellen in Dataset {BigQuery_Project}: {BigQuery_Dataset}")#CSV importierenSpeichern der Schemata im Vektor dB wie Chroma DB. Wir müssen einen Ordner namens " Daten" erstellen
Aus Langchain.embeddings importieren Sie Scheitelpunkte
von Langchain.VectorStores importieren Chroma
Einbettungen = Vertexaiembeddings ()
Versuchen Sie: # Vermeiden Sie doppelte Dokumente
vector_store.delete_collection ())
außer:
drucken ("Nicht nötig, den Vektor Store zu reinigen")
vector_store = chroma.from_texts (Schemas, Einbettung = Einbetten, persist_directory = './data'))
n_docs = len (vector_store.get () ['ids'])
retriever = vector_store.as_retriever (search_kwargs = {'k': 2})
print (f "Der Vektor Store hat {n_docs} dokumente"))Wir werden die 3 LLM -Modelle für die 3 verschiedenen Ketten instanziieren.
Das erste Modell ist ein Abfragemodell, das für die Generierung von SQL -Abfragen basierend auf dem Benutzerfragestand und dem Tabellenschema verantwortlich ist, das aus dem Vektor DB ähnlich wie Benutzerfrage abgerufen wird. Dazu verwenden wir "codechat-bison" Modell . Dieses Modell ist auf das Generieren von Code in verschiedenen Codierungssprachen spezialisiert und ist daher für unseren Anwendungsfall geeignet.
Andere 2 Modelle sind Standard-LLM-Modelle in Chatvertexai, nämlich „ Gemini-1.5-Flash-001 “ Dies ist das neueste Gemini-Modell, das für Chat und schnelle Antwort optimiert ist.
von Langchain.chat_Models importieren Sie Chatvertexai von Langchain.llms importieren Sie Scheitelpunkte query_model = chatvertexai (model_name = "codechat-bison", max_output_tokens = 1000) interpretation_data_model = chatvertexai (max_output_tokens = 1000) agent_model = chatvertexai (max_output_tokens = 1024)
Im Folgenden finden Sie die SQL -Eingabeaufforderung, mit der die SQL -Abfrage für die Eingabebremittel -Frage generiert wird.
SQL_PROMPT = "" "Sie sind ein SQL und ein BigQuery -Experte.
Ihre Aufgabe ist es, eine Abfrage für BigQuery in SQL zu erstellen.
Der folgende Absatz enthält das Schema der Tabelle, die für eine Abfrage verwendet wird. Es ist im JSON -Format codiert.
{Kontext}
Erstellen Sie eine BigQuery SQL -Abfrage für die folgende Benutzereingabe unter Verwendung der obigen Tabelle.
Und verwenden Sie nur Spalten, die im Schema für die SQL -Abfrage erwähnt werden
Der Benutzer und der Agent haben dieses Gespräch bisher geführt:
{chat_history}
Befolgen Sie diese Einschränkungen streng:
- Geben Sie den SQL -Code nur zurück.
- Fügen Sie keine Backticks oder ein Markup hinzu. Schreiben Sie nur die Abfrage als Ausgabe. Nichts anderes.
- Verwenden Sie immer den vollständigen Tabellenpfad, indem Sie `{project}` as project und `{dataset}` als Datensatz verwenden.
- Verwandeln Sie immer Landnamen in den vollständigen Großbuchstaben. Wenn das Land beispielsweise Japan ist, sollten Sie Japan in der Abfrage verwenden.
Benutzereingabe: {Frage}
SQL -Abfrage:
"" "Jetzt werden wir eine Funktion definieren, die relevante Dokumente abrufen, dh Schemas für die Benutzerfrageingabe.
von Langchain.schema.VectorStore Import VectorStorerTriever
Def get_documents (Retriever: VectorStorerETRIEVER, Frage: STR) -> STR:
# Geben Sie nur das erste Dokument zurück
output = ""
Für D in retriever.get_relevant_documents (Frage):
output = d.page_content
output = "\ n"
RückgabeausgabeDann definieren wir die LLM -Kette mithilfe der Langchain -Expressionssprach -Syntax. Hinweis Wir definieren die Eingabeaufforderung mit 5 Platzhaltervariablen und später eine teilweise Eingabeaufforderung, indem wir das 2 -Platzhalter -Variablenprojekt und den Datensatz ausfüllen. Der Rest der Variablen wird mit eingehender Anforderungswörterbuch bevölkert, die aus Eingabe, Chat -Historie und der Kontextvariable bestehen.
vom Bedienerimportartikelgetter
von Langchain.prompts importieren Sie promptemplate
von Langchain.schema import StroutputParser
prompt_template = fordertemplate (
input_variables = ["Kontext", "chat_history", "Frage", "Projekt", "Dataset"],
template = sql_prompt)
partial_prompt = prompt_template.Partial (project = bigQuery_project,
DataSet = BigQuery_Dataset)
# Eingabe ist wie {"input": "slow_question", "chat_history": "history"}
docs = {"context": lambda x: get_documents (retriever, x ['Eingabe'])}
FRAGE = {"Frage": itemGetter ("input")}
CHAT_HISTORY = {"CHAT_HISTORY": itemGetter ("chat_history")}
query_chain = docs | Frage | CHAT_HISTORY | partial_prompt | query_model
query = query_chain | StroutputParser ()
Testen wir unsere Kette mithilfe von Callback -Handler von Langchain, wodurch alle Schritte der Kettenausführung im Detail angezeigt werden.
von Langchain.callbacks.Tracers importieren consolecallbackhandler
# Beispiel
x = {"Eingabe": "Höchste Dauer der Reise, wo die Startstation von Atlantic Ave & Fort Greene Pl", "CHAT_HISTORY": ""}
print (query.invoke (x, config = {'callbacks': [consoleCallbackHandler ()]})) 
Wir müssen den obigen SQL -Kettenausgang so verfeinern, dass es auch andere Variablen in den Outp enthält, das dann an die zweite Kette weitergegeben wird - Interpretation der Kette.
von Langchain.output_Parsers Import -Antwortenschema, StructuredOutputParser
von Langchain.schema.Runnable Import Runnablelambda
#Refine den Kettenausgang, um andere Variablen in die Ausgabe im Wörterbuchformat einzuschließen
def _dict_to_json (x: dict) -> str:
Return "` `` \ n "json.dumps (x)" \ n`` "
query_response_schema = [
Antwortenschema (name = "query", Beschreibung = "SQL Abfrage zur Lösung der Benutzerfrage"),),),),),),),)
Antwortenschema (Name = "Frage", Beschreibung = "Frage vom Benutzer gestellt"),),),),)
Antwortenschema (Name = "Kontext", Beschreibung = "Dokumente, die aus dem Vektorspeicher abgerufen wurden.")
]
query_output_parser = structuredoutputParser.from_Response_schemas (query_response_schema)
query_output_json = docs | Frage | {"Abfrage": Abfrage} | Runnablelambda (_dict_to_json) | StroutputParser ()
query_output = query_output_json | query_output_parserVersuchen wir, diese Kette auszuführen.
# Beispiel
x = {"Eingabe": "Gib mir Top 2 Startstationen, an denen die Reisedauer am höchsten war?", "chat_history": ""}
output = query_output.invoke (x) # Ausgabe ist jetzt ein Wörterbuch, Eingabe für die nächste Kette
Oben können wir sehen, dass die Ausgabe der raffinierten Kette eine SQL -Abfrage ist.
Jetzt müssen wir die nächste Kette bauen, die die oben definierte SQL -Abfragekette ausgibt. Diese Kette nimmt die SQL -Abfrage aus der vorherigen Kette und führt sie in einer großen Abfrage aus. Anschließend werden ihre Ergebnisse verwendet, um eine Antwort mit der entsprechenden Eingabeaufforderung zu generieren.
Interpret_prompt = "" "Sie sind ein BigQuery -Experte. Sie sind auch Experte für Daten aus CSV.
Der folgende Absatz beschreibt das Schema der für eine Abfrage verwendeten Tabelle. Es ist im JSON -Format codiert.
{Kontext}
Ein Benutzer stellte diese Frage:
{Frage}
Um die Antwort zu finden, wurde die folgende SQL -Abfrage in BigQuery ausgeführt:
`` `
{Abfrage}
`` `
Das Ergebnis dieser Abfrage war die folgende Tabelle im CSV -Format:
`` `
{Ergebnis}
`` `
Geben Sie basierend auf diesen Ergebnissen eine kurze Antwort auf die Benutzerfrage.
Befolgen Sie diese Einschränkungen streng:
- Fügen Sie keine Erklärung darüber hinzu, wie die Antwort erhalten wird. Schreiben Sie einfach die Antwort.
- Extrahieren Sie einen beliebigen Wert, der sich nur aus dem Ergebnis der Abfrage bezieht. Verwenden Sie keine andere Datenquelle.
- Schreiben Sie einfach die Antwort, lassen Sie die Frage aus Ihrer Antwort weg. Dies ist ein Chat. Geben Sie einfach die Antwort an.
- Wenn Sie die Antwort im Ergebnis nicht finden können, machen Sie keine Daten aus. Sagen Sie einfach "Ich kann die Antwort nicht finden."
"" " von Google.Cloud BigQuery importieren
Def get_bq_csv (bq_client: bigQuery.client, Abfrage: str) -> str:
Cleaned_query = Clean_query (Abfrage)
df = bq_client.Query (cleaned_query, location = "us"). to_dataframe ()
Rückgabe df.to_csv (index = false)
Def Clean_query (Abfrage: STR):
query = query.replace ("` `` SQL "," ")
cleaned_query = query.replace ("" "" "", "")
Rückkehr Cleaned_QueryWir werden zwei Funktionen definieren. Eines ist Clean_Query - dies wird die SQL -Abfrage von Apostrophes und anderen unnötigen Zeichen und andere Get_BQ_CSV reinigen. Dadurch wird die gereinigte SQL -Abfrage in einer großen Abfrage ausgeführt und die Ausgangstabelle im CSV -Format erhalten.
# Erhalten Sie die Ausgabe der vorherigen Kette
query = {"query": itemGetter ("query")}
context = {"context": itemGetter ("context")}
Frage = {"Frage": itemGetter ("Frage")}
#Cleaned_query = {"Ergebnis": Lambda X: Clean_query (x ["Abfrage"])}
query_result = {"result": lambda x: get_bq_csv (bq_client, x ["query"])}
fordert = promptTemplate (
input_variables = ["Frage", "Abfrage", "Ergebnis", "Kontext"],
template = interpretation_prompt)
run_bq_chain = context | Frage | Abfrage | query_result | prompt
run_bq_result = run_bq_chain | interpret_data_model | StroutputParser ()
Lassen Sie uns die Kette ausführen und sie testen.
# Beispiel
x = {"Eingabe": "Gib mir Top 2 Startstationen, an denen die Reisedauer am höchsten war?", "chat_history": ""}
Final_Response = run_bq_result.invoke (query_output.invoke (x))
print (Final_response)
Jetzt werden wir die endgültige Kette erstellen, die die Agentenkette ist. Wenn ein Benutzer eine Frage stellt, entscheidet er, ob das SQL -Query -Tool verwendet wird oder sie direkt beantwortet. Grundsätzlich sendet es Benutzeranfragen an verschiedene Tools gemäß den Arbeiten, die abgeschlossen werden müssen, um die Anfrage des Benutzers zu beantworten.
Wir definieren eine Agent_Memory, eine Agent -Eingabeaufforderung, eine Werkzeugfunktion.
von Langchain.Memory Import ConvertationBufferWindowMemory
Agent_Memory = ConversationBufferWindowMemory (
mes MEAME_KEY = "CHAT_HISTORY",
k = 10,
return_messages = true)Agent_prompt = "" "Sie sind ein sehr mächtiger Assistent, der Fragen mit BigQuery beantworten kann. Sie können das Tool user_question_tool aufrufen, um Fragen mit BigQuery zu beantworten. Verwenden Sie immer die Tools, um die Fragen zu beantworten. Verwenden Sie den Chat -Verlauf für den Kontext. Versuchen Sie niemals, andere externe Informationen zu verwenden. Angenommen, der Benutzer kann mit Rechtschreibfehler schreiben und die Schreibweise des Benutzers beheben, bevor die Frage an ein Tool weitergegeben wird. Erwähnen Sie nicht, welches Tool Sie in Ihrer Antwort verwendet haben. "" "
aus Langchain.tools Import -Tool
von Langchain.callbacks.Tracers importieren consolecallbackhandler
@Werkzeug
Def User_question_tool (Frage) -> Str:
"" Nützlich, um Fragen der natürlichen Sprache von Benutzern zu beantworten, die BigQuery verwenden. "" ""
config = {'callbacks': [consoleCallbackHandler ()]}
config = {}
memory = agent_memory.buffer_as_str.strip ()
FRAGE = {"Eingabe": Frage, "chat_history": Speicher}
query = query_output.invoke (Frage, config = config)
print ("\ n \ n ****************** \ n \ n"))
print (query ['query'])
print ("\ n \ n ****************** \ n \ n"))
result = run_bq_result.invoke (Abfrage, config = config)
Rückgabeergebnis.strip ()
Wir bringen jetzt alle Hauptkomponenten des Agenten zusammen und initialisieren den Agenten.
von Langchain.agents Import AgentType, Initialize_agent, AgentExecutor
Agent_kwgards = {"System_Message": Agent_prompt}
Agent_tools = [user_question_tool]
agent_memory.clear ()
Agent = initialize_agent (
Tools = Agent_tools,
llm = agent_model,
Agent = AgentType.chat_ConverSational_react_description,
memory = agent_memory,
Agent_kwgards = Agent_kwgards,
max_iterations = 5,
Early_Stopping_method = 'generieren',
wörtlich = wahr)Lassen Sie uns jetzt den Agenten ausführen.
Q = "Gib mir Top 2 Startstationen, an denen die Reisedauer am höchsten war?" Agent.invoke (q)
Follow-up-Frage an Agent.
q = "Was ist die Kapazität für jeden dieser Stationsnamen?" Agent.invoke (q)
Der Agent war genau in der Lage, die komplexe Frage zu verarbeiten und korrekte Antworten für die Folge -up -Frage basierend auf dem Chat -Verlauf zu generieren. Anschließend wurde eine andere Tabelle verwendet, um Kapazitätsinformationen von Citi -Bikes zu erhalten.
Der Rag-to-SQL-Ansatz stellt einen erheblichen Fortschritt bei der Bekämpfung der Einschränkungen herkömmlicher Text-zu-SQL-Modelle durch Einbeziehung von kontextbezogenen Daten und der Nutzung von Abruftechniken dar. Diese Methodik verbessert die Abfragegenauigkeit, indem relevante Schemainformationen aus Vektor -Datenbanken abgerufen werden und eine genauere SQL -Erzeugung ermöglicht werden. Durch die Implementierung von Rag-to-SQL in Google Cloud-Diensten wie BigQuery und Vertex AI zeigt die Skalierbarkeit und Effektivität in realen Anwendungen. Durch die Automatisierung des Entscheidungsprozesses bei der Abfragehandhabung eröffnet Rag-to-SQL nicht technische Benutzer, um mit Datenbanken nahtlos zu interagieren und gleichzeitig eine hohe Genauigkeit beizubehalten.
A. Nein, aber Sie können eine Testzeit von 90 Tagen mit 300 $ Credits erhalten, wenn Sie sich zum ersten Mal registrieren und nur eine Kartendaten zur Erhöhung des Zugriffs angeben. Es werden keine Gebühren von der Karte abgezogen, und selbst wenn Sie Dienste nutzen, die über 300 $ Credits konsumiert werden, wird Google Sie auffordert, ein Zahlungskonto zu aktivieren, damit Sie den Dienst nutzen können. Es gibt also keinen automatischen Abzug des Betrags.
Q2. Was ist der Hauptvorteil der Verwendung von Rag zu SQL?A. Dies ermöglicht es uns, das Tabellenschema zu automatisieren, das dem LLM zugeführt werden soll, wenn wir mehrere Tabellen verwenden, die wir nicht alle Tabellenschemata gleichzeitig füttern müssen. Basierend auf dem Benutzerabfrage kann das entsprechende Tabellenschema aus dem Lappen abgerufen werden. Daher erhöht die Effizienz gegenüber herkömmlichem Text mit SQL -Systemen.
Q3. Wie können Agenten für diesen Anwendungsfall nützlich sein?A. Wenn wir einen ganzheitlichen Chatbot bauen, ist möglicherweise eine Menge anderer Werkzeuge abgesehen von SQL Query -Tool erforderlich. So können wir den Agenten nutzen und ihm mehrere Tools wie Websuche, Datenbank SQL Query -Tool, andere Lag -Tools oder Funktionen aufrufen, die API -Tools aufrufen. Dies ermöglicht es, verschiedene Arten von Benutzeranfragen zu verarbeiten, die auf der Aufgabe basieren, die erledigt werden muss, um auf die Benutzerabfrage zu reagieren.
Die in diesem Artikel gezeigten Medien sind nicht im Besitz von Analytics Vidhya und werden nach Ermessen des Autors verwendet.
Das obige ist der detaillierte Inhalt vonRag-to-SQL auf Google Cloud. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!
Konfigurieren Sie die HOSTS-Datei
So deaktivieren Sie die Win10-Upgrade-Eingabeaufforderung
Was sind die Unterschiede zwischen Weblogic und Tomcat?
So verwenden Sie Excel-Makros
Software zur Verschlüsselung von Mobiltelefonen
Mobile Festplattenpartitionssoftware
Verwendung von Eigenschaftsbeschreibungen
So lösen Sie 404 nicht gefunden
Multifunktionsnutzung
![[Web-Frontend] Node.js-Schnellstart](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
