Semantische Suche und Retrieval Augmented Generation durchführen

In dieser Anleitung wird der gesamte Prozess beschrieben, wie Sie Texteinbettungen für die semantische Suche und Retrieval Augmented Generation (RAG)erstellen und verwenden .

In dieser Anleitung werden die folgenden Aufgaben behandelt:

BigQuery ML Remote-Modell über ein Vertex AI-Einbettungsmodell erstellen
Mit dem Remote-Modell und der AI.GENERATE_EMBEDDING Funktion Einbettungen aus Text in einer BigQuery-Tabelle generieren
Einen Vektorindex erstellen, um die Einbettungen zu indexieren und die Suchleistung zu verbessern
Durch Verwenden der VECTOR_SEARCH Funktion mit den Einbettungen, um nach ähnlichem Text zu suchen
RAG durchführen, indem Sie Text mit der AI.GENERATE_TEXT Funktion, und Vektorsuchergebnisse verwenden, um die Prompt-Eingabe zu erweitern und die Ergebnisse zu verbessern.

In dieser Anleitung wird die öffentliche BigQuery-Tabelle patents-public-data.google_patents_research.publications verwendet.

Erforderliche Rollen

Zum Ausführen dieser Anleitung benötigen Sie die folgenden IAM-Rollen (Identity and Access Management) :

BigQuery-Datasets, -Verbindungen und -Modelle erstellen und verwenden: BigQuery-Administrator (roles/bigquery.admin)
Dem Dienstkonto der Verbindung Berechtigungen gewähren: Projekt-IAM-Administrator (roles/resourcemanager.projectIamAdmin)

Diese vordefinierten Rollen enthalten die Berechtigungen, die zum Ausführen der Aufgaben in diesem Dokument erforderlich sind. Erweitern Sie den Abschnitt Erforderliche Berechtigungen, um die erforderlichen Berechtigungen anzuzeigen:

Erforderliche Berechtigungen

Dataset erstellen: bigquery.datasets.create
Verbindung erstellen, delegieren und verwenden: bigquery.connections.*
Standardverbindung festlegen: bigquery.config.*
Berechtigungen für Dienstkonten festlegen: resourcemanager.projects.getIamPolicy und resourcemanager.projects.setIamPolicy
Modell erstellen und Inferenz ausführen:
- bigquery.jobs.create
- bigquery.models.create
- bigquery.models.getData
- bigquery.models.updateData
- bigquery.models.updateMetadata

Sie können diese Berechtigungen auch mit benutzerdefinierten Rollen oder anderen vordefinierten Rollen erhalten.

Kosten

In diesem Dokument verwenden Sie die folgenden kostenpflichtigen Komponenten von Google Cloud:

BigQuery ML: You incur costs for the data that you process in BigQuery.
Vertex AI: You incur costs for calls to the Vertex AI service that's represented by the remote model.

Mit dem Preisrechner können Sie eine Kostenschätzung für Ihre voraussichtliche Nutzung vornehmen.

Neuen Google Cloud Nutzern vonsteht möglicherweise eine kostenlose Testversion zur Verfügung.

Weitere Informationen zu den Preisen von BigQuery finden Sie unter BigQuery: Preise in der BigQuery-Dokumentation.

Weitere Informationen zu den Preisen für Vertex AI finden Sie auf der Seite Vertex AI: Preise.

Hinweise

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.
Roles required to select or create a project
- Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
- Create a project: To create a project, you need the Project Creator role (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.
Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

Go to project selector
Verify that billing is enabled for your Google Cloud project.
Enable the BigQuery, BigQuery Connection, and Vertex AI APIs.
Roles required to enable APIs
To enable APIs, you need the Service Usage Admin IAM role (roles/serviceusage.serviceUsageAdmin), which contains the serviceusage.services.enable permission. Learn how to grant roles.
Enable the APIs

Dataset erstellen

Erstellen Sie ein BigQuery-Dataset, um Ihr ML-Modell zu speichern.

Console

Rufen Sie in der Google Cloud Console die Seite BigQuery auf.

Zur Seite "BigQuery"
Klicken Sie im Bereich Explorer auf den Namen Ihres Projekts.
Klicken Sie auf Aktionen ansehen > Dataset erstellen.
Führen Sie auf der Seite Dataset erstellen die folgenden Schritte aus:
- Geben Sie unter Dataset-ID bqml_tutorial ein.
- Wählen Sie als Standorttyp die Option Mehrere Regionen und dann USA (mehrere Regionen in den USA) aus.
- Übernehmen Sie die verbleibenden Standardeinstellungen unverändert und klicken Sie auf Dataset erstellen.

bq

Wenn Sie ein neues Dataset erstellen möchten, verwenden Sie den Befehl bq mk mit dem Flag --location. Eine vollständige Liste der möglichen Parameter finden Sie in der bq mk --dataset Befehls referenz.

Erstellen Sie ein Dataset mit dem Namen bqml_tutorial, dessen Datenstandort auf US festgelegt ist und das die Beschreibung BigQuery ML tutorial dataset hat:
```
bq --location=US mk -d \
 --description "BigQuery ML tutorial dataset." \
 bqml_tutorial
```
Anstelle des Flags --dataset verwendet der Befehl die Abkürzung -d. Wenn Sie -d und --dataset weglassen, wird standardmäßig ein Dataset erstellt.
Prüfen Sie, ob das Dataset erstellt wurde:
```
bq ls
```

API

Rufen Sie die datasets.insert Methode mit einer definierten Dataset-Ressource auf.

{
  "datasetReference": {
     "datasetId": "bqml_tutorial"
  }
}

Remote-Modell für die Generierung von Texteinbettungen erstellen

Erstellen Sie ein Remote-Modell, das ein gehostetes Vertex AI Modell zur Generierung von Texteinbettungen darstellt:

Rufen Sie in der Google Cloud Console die Seite BigQuery auf.

BigQuery aufrufen
Führen Sie im Abfrageeditor folgende Abfrage aus:
```
CREATE OR REPLACE MODEL `bqml_tutorial.embedding_model`
  REMOTE WITH CONNECTION DEFAULT
  OPTIONS (ENDPOINT = 'text-embedding-005');
```
Die Abfrage dauert einige Sekunden. Danach kann über den Bereich Explorer auf das Modell embedding_model zugegriffen werden. Da mit der Abfrage mit einer CREATE MODEL-Anweisung ein Modell erstellt wird, gibt es keine Abfrageergebnisse.

Texteinbettungen generieren

Generieren Sie mit der AI.GENERATE_EMBEDDING Funktion, Texteinbettungen aus Patentabstrakten und schreiben Sie sie dann in eine BigQuery-Tabelle, damit sie durchsucht werden können.

Rufen Sie in der Google Cloud Console die Seite BigQuery auf.

BigQuery aufrufen

Führen Sie im Abfrageeditor folgende Abfrage aus:

CREATE OR REPLACE TABLE `bqml_tutorial.embeddings` AS
SELECT * FROM AI.GENERATE_EMBEDDING(
  MODEL `bqml_tutorial.embedding_model`,
  (
    SELECT *, abstract AS content
    FROM `patents-public-data.google_patents_research.publications`
    WHERE LENGTH(abstract) > 0 AND LENGTH(title) > 0 AND country = 'Singapore'
  )
)
WHERE LENGTH(status) = 0;

Diese Abfrage dauert etwa 5 Minuten.

Die Generierung von Einbettungen mit der AI.GENERATE_EMBEDDING Funktion kann aufgrund von Kontingenten für Vertex AI LLM oder der Nichtverfügbarkeit von Diensten fehlschlagen. Fehlerdetails werden in der status Spalte zurückgegeben. Eine leere Spalte status zeigt die erfolgreiche Generierung der Einbettung an.

Alternative Methoden zur Generierung von Texteinbettungen in BigQuery, siehe die Anleitung Text mit vortrainierten TensorFlow-Modellen einbetten.

Vektorindex erstellen

Wenn Sie einen Vektorindex für eine Einbettungsspalte erstellen, wird bei einer Vektorsuche in dieser Spalte die Suchmethode Annäherung an den nächsten Nachbarn verwendet. Diese Methode verbessert die Leistung der Vektorsuche, mit dem Kompromiss, dass die Trefferquote reduziert wird und somit ungefähre Ergebnisse zurückgegeben werden.

Verwenden Sie zum Erstellen eines Vektorindex die CREATE VECTOR INDEX Datendefinitionssprachen-Anweisung (DDL):

Rufen Sie die Seite BigQuery auf.

BigQuery aufrufen

Führen Sie im Abfrageeditor folgende SQL-Anweisung aus:

CREATE OR REPLACE VECTOR INDEX my_index
ON `bqml_tutorial.embeddings`(embedding)
OPTIONS(index_type = 'IVF',
  distance_type = 'COSINE',
  ivf_options = '{"num_lists":500}')

Das Erstellen eines Vektorindex dauert in der Regel nur wenige Sekunden. Es dauert weitere 2 bis 3 Minuten, bis der Vektorindex gefüllt und einsatzbereit ist.

Bereitschaft des Vektorindex prüfen

Der Vektorindex wird asynchron ausgefüllt. Sie können prüfen, ob der Index für die Verwendung bereit ist, indem Sie die INFORMATION_SCHEMA.VECTOR_INDEXES-Ansicht abfragen und prüfen, ob coverage_percentage Spaltenwert größer als 0 und last_refresh_time Spaltenwert ist nicht NULL “

Rufen Sie die Seite BigQuery auf.

BigQuery aufrufen

Führen Sie im Abfrageeditor folgende SQL-Anweisung aus:

SELECT table_name, index_name, index_status,
coverage_percentage, last_refresh_time, disable_reason
FROM `PROJECT_ID.bqml_tutorial.INFORMATION_SCHEMA.VECTOR_INDEXES`

Ersetzen Sie PROJECT_ID durch Ihre Projekt-ID.

Mit dem Vektorindex eine Suche nach Textähnlichkeiten durchführen

Mit der VECTOR_SEARCH Funktion können Sie nach relevanten Patenten suchen, die mit Einbettungen übereinstimmen, die aus einer Textabfrage generiert wurden.

Das Argument top_k bestimmt die Anzahl der zurückzugebenden Treffer, in diesem Fall fünf. Mit der Option fraction_lists_to_search wird der Prozentsatz der Vektorindexlisten festgelegt, die durchsucht werden sollen. Der von Ihnen erstellte Vektorindex hat 500 Listen. Der Wert fraction_lists_to_search von .01 gibt an, dass bei dieser Vektorsuche fünf dieser Listen gescannt werden. Ein niedrigerer Wert für fraction_lists_to_search führt zu einer geringeren Trefferquote und einer schnelleren Leistung. Weitere Informationen zu Vektorindexlisten finden Sie unter der num_lists Vektorindexoption.

Das Modell, mit dem Sie die Einbettungen in dieser Abfrage erstellen, muss mit dem Modell übereinstimmen, das Sie zum Erzeugen der Einbettungen in der Tabelle verwenden, mit der Sie vergleichen. Andernfalls erhalten Sie ungenaue Suchergebnisse.

Rufen Sie die Seite BigQuery auf.

BigQuery aufrufen

Führen Sie im Abfrageeditor folgende SQL-Anweisung aus:

SELECT query.query, base.publication_number, base.title, base.abstract
FROM VECTOR_SEARCH(
  TABLE `bqml_tutorial.embeddings`, 'embedding',
  (
  SELECT embedding, content AS query
  FROM AI.GENERATE_EMBEDDING(
  MODEL `bqml_tutorial.embedding_model`,
  (SELECT 'improving password security' AS content))
  ),
  top_k => 5, options => '{"fraction_lists_to_search": 0.01}')

Die Ausgabe sieht in etwa so aus:

+-----------------------------+--------------------+-------------------------------------------------+-------------------------------------------------+
|            query            | publication_number |                       title                     |                      abstract                   |
+-----------------------------+--------------------+-------------------------------------------------+-------------------------------------------------+
| improving password security | SG-120868-A1       | Data storage device security method and a...    | Methods for improving security in data stora... |
| improving password security | SG-10201610585W-A  | Passsword management system and process...      | PASSSWORD MANAGEMENT SYSTEM AND PROCESS ...     |
| improving password security | SG-148888-A1       | Improved system and method for...               | IMPROVED SYSTEM AND METHOD FOR RANDOM...        |
| improving password security | SG-194267-A1       | Method and system for protecting a password...  | A system for providing security for a...        |
| improving password security | SG-120868-A1       | Data storage device security...                 | Methods for improving security in data...       |
+-----------------------------+--------------------+-------------------------------------------------+-------------------------------------------------+

Remote-Modell für die Textgenerierung erstellen

Erstellen Sie ein Remote-Modell, das ein gehostetes Vertex AI Textgenerierungsmodell darstellt:

Rufen Sie in der Google Cloud Console die Seite BigQuery auf.

BigQuery aufrufen
Führen Sie im Abfrageeditor folgende Abfrage aus:
```
CREATE OR REPLACE MODEL `bqml_tutorial.text_model`
  REMOTE WITH CONNECTION DEFAULT
  OPTIONS (ENDPOINT = 'gemini-2.0-flash-001');
```
Die Abfrage dauert einige Sekunden. Danach kann über den Bereich Explorer auf das Modell text_model zugegriffen werden. Da mit der Abfrage mit einer CREATE MODEL-Anweisung ein Modell erstellt wird, gibt es keine Abfrageergebnisse.

Durch Vektorsuchergebnisse erweiterten Text generieren

Geben Sie die Suchergebnisse als Aufforderungen ein, um Text mit der AI.GENERATE_TEXT Funktion zu generieren.

Rufen Sie in der Google Cloud Console die Seite BigQuery auf.

BigQuery aufrufen

Führen Sie im Abfrageeditor folgende Abfrage aus:

SELECT result AS generated, prompt
FROM AI.GENERATE_TEXT(
  MODEL `bqml_tutorial.text_model`,
  (
    SELECT CONCAT(
      'Propose some project ideas to improve user password security using the context below: ',
      STRING_AGG(
        FORMAT("patent title: %s, patent abstract: %s", base.title, base.abstract),
        ',\n')
      ) AS prompt,
    FROM VECTOR_SEARCH(
      TABLE `bqml_tutorial.embeddings`, 'embedding',
      (
        SELECT embedding, content AS query
        FROM AI.GENERATE_EMBEDDING(
          MODEL `bqml_tutorial.embedding_model`,
         (SELECT 'improving password security' AS content)
        )
      ),
    top_k => 5, options => '{"fraction_lists_to_search": 0.01}')
  ),
  STRUCT(600 AS max_output_tokens));

Die Ausgabe sieht in etwa so aus:

+------------------------------------------------+------------------------------------------------------------+
|            generated                           | prompt                                                     |
+------------------------------------------------+------------------------------------------------------------+
| These patents suggest several project ideas to | Propose some project ideas to improve user password        |
| improve user password security.  Here are      | security using the context below: patent title: Active     |
| some, categorized by the patent they build     | new password entry dialog with compact visual indication   |
| upon:                                          | of adherence to password policy, patent abstract:          |
|                                                | An active new password entry dialog provides a compact     |
| **I. Projects based on "Active new password    | visual indication of adherence to password policies. A     |
| entry dialog with compact visual indication of | visual indication of progress towards meeting all          |
| adherence to password policy":**               | applicable password policies is included in the display    |
|                                                | and updated as new password characters are being...        |
+------------------------------------------------+------------------------------------------------------------+

Bereinigen

Achtung: Das Löschen von Projekten hat folgende Auswirkungen:

Alle Inhalte des Projekts werden gelöscht. Wenn Sie für die Aufgaben in diesem Dokument ein bereits bestehendes Projekt verwendet haben und dieses löschen, werden auch alle anderen im Rahmen des Projekts erstellten Daten gelöscht.
Benutzerdefinierte Projekt-IDs gehen verloren. Beim Erstellen dieses Projekts haben Sie möglicherweise eine benutzerdefinierte Projekt-ID erstellt, die Sie weiterhin verwenden möchten. Damit die URLs, die die Projekt-ID nutzen, z. B. eine appspot.com-URL, erhalten bleiben, sollten Sie ausgewählte Ressourcen innerhalb des Projekts löschen, statt das gesamte Projekt.

Wenn Sie weitere Architekturen, Tutorials oder Kurzanleitungen nutzen möchten, können Sie vorhandene Projekte wiederverwenden und somit vermeiden, dass Projektkontingente überschritten werden.

In the Google Cloud console, go to the Manage resources page.
Go to Manage resources
In the project list, select the project that you want to delete, and then click Delete.
In the dialog, type the project ID, and then click Shut down to delete the project.

Nächste Schritte

In der Anleitung PDFs in einer RAG-Pipeline (Retrieval Augmented Generation) parsen erfahren Sie, wie Sie eine RAG-Pipeline basierend auf geparsten PDF-Inhalten erstellen.