Multimodale Daten mit SQL und BigQuery DataFrames analysieren

In dieser Anleitung erfahren Sie, wie Sie multimodale Daten mit SQL-Abfragen und BigQuery DataFrames analysieren.

In dieser Anleitung wird der Produktkatalog aus dem öffentlichen Dataset des Cymbal-Tierbedarfsgeschäfts verwendet.

Ziele

Verwenden Sie ObjectRef-Werte, um Bilddaten zusammen mit strukturierten Daten in einer BigQuery-Standardtabelle zu speichern.
Mithilfe der Funktion AI.GENERATE_TABLE können Sie Text basierend auf Bilddaten aus einer Standardtabelle generieren.
Mit einer Python-UDF können Sie vorhandene Bilder transformieren, um neue Bilder zu erstellen.
PDFs mit einer Python-UDF für die weitere Analyse in Chunks aufteilen.
Verwenden Sie ein Gemini-Modell und die AI.GENERATE_TEXT-Funktion, um die in Chunks aufgeteilten PDF-Daten zu analysieren.
Generieren Sie mit der Funktion AI.GENERATE_EMBEDDING Einbettungen basierend auf Bilddaten aus einer Standardtabelle.
Geordnete multimodale Daten mit Arrays von ObjectRef-Werten verarbeiten.

Kosten

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

BigQuery: you incur costs for the data that you process in BigQuery.
BigQuery Python UDFs: you incur costs for using Python UDFs.
Cloud Storage: you incur costs for the objects stored in Cloud Storage.
Vertex AI: you incur costs for calls to Vertex AI models.

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

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

Weitere Informationen finden Sie auf den folgenden Preisseiten:

Hinweis

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, Cloud Storage, 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

Erforderliche Rollen

Bitten Sie Ihren Administrator, Ihnen die folgenden IAM-Rollen zuzuweisen, um die Berechtigungen zu erhalten, die Sie zum Ausführen dieser Anleitung benötigen:

Verbindung erstellen: BigQuery-Verbindungsadministrator (roles/bigquery.connectionAdmin)
Dem Dienstkonto der Verbindung Berechtigungen gewähren: Projekt-IAM-Administrator (roles/resourcemanager.projectIamAdmin)
Cloud Storage-Bucket erstellen: Storage-Administrator (roles/storage.admin)
Datasets, Modelle, benutzerdefinierte Funktionen und Tabellen erstellen und BigQuery-Jobs ausführen: BigQuery-Administrator (roles/bigquery.admin)
URLs erstellen, mit denen Sie Cloud Storage-Objekte lesen und ändern können: BigQuery ObjectRef Admin (roles/bigquery.objectRefAdmin)

Weitere Informationen zum Zuweisen von Rollen finden Sie unter Zugriff auf Projekte, Ordner und Organisationen verwalten.

Sie können die erforderlichen Berechtigungen auch über benutzerdefinierte Rollen oder andere vordefinierte Rollen erhalten.

Einrichten

In diesem Abschnitt erstellen Sie das Dataset, die Verbindung, die Tabellen und die Modelle, die in dieser Anleitung verwendet werden.

Dataset erstellen

Erstellen Sie ein BigQuery-Dataset, das die Objekte enthält, die Sie in dieser Anleitung erstellen:

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

BigQuery aufrufen
Klicken Sie im linken Bereich auf Explorer:

Wenn Sie den linken Bereich nicht sehen, klicken Sie auf Linken Bereich maximieren, um ihn zu öffnen.
Wählen Sie im Bereich Explorer Ihr Projekt aus.
Klicken Sie auf Aktionen ansehen und dann auf Dataset erstellen. Der Bereich Dataset erstellen wird geöffnet.
Geben Sie als Dataset-ID den String cymbal_pets ein.
Klicken Sie auf Dataset erstellen.

Bucket erstellen

Erstellen Sie einen Cloud Storage-Bucket zum Speichern transformierter Objekte:

Rufen Sie die Seite Buckets auf.

Buckets aufrufen
Klicken Sie auf Erstellen.
Geben Sie auf der Seite Bucket erstellen im Bereich Einstieg einen global eindeutigen Namen ein, der den Anforderungen für Bucket-Namen entspricht.
Klicken Sie auf Erstellen.

Verbindung herstellen

Erstellen Sie eine Cloud-Ressourcenverbindung und rufen Sie das Dienstkonto der Verbindung ab. BigQuery verwendet die Verbindung für den Zugriff auf Objekte in Cloud Storage:

Rufen Sie die Seite BigQuery auf.

BigQuery aufrufen
Klicken Sie im linken Bereich auf Explorer:
Klicken Sie im Bereich Explorer auf Daten hinzufügen.

Das Dialogfeld Daten hinzufügen wird geöffnet.
Wählen Sie im Bereich Filtern nach im Abschnitt Datenquellentyp die Option Geschäftsanwendungen aus.

Alternativ können Sie im Feld Nach Datenquellen suchen Vertex AI eingeben.
Klicken Sie im Abschnitt Empfohlene Datenquellen auf Vertex AI.
Klicken Sie auf die Lösungsübersichtskarte Vertex AI-Modelle: BigQuery Federation.
Wählen Sie in der Liste Verbindungstyp die Option Vertex AI-Remote-Modelle, Remote-Funktionen, BigLake und Cloud Spanner (Cloud-Ressource) aus.
Geben Sie im Feld Verbindungs-ID cymbal_conn ein.
Klicken Sie auf Verbindung erstellen.
Klicken Sie auf Zur Verbindung.
Kopieren Sie im Bereich Verbindungsinformationen die Dienstkonto-ID zur Verwendung in einem folgenden Schritt.

Dem Dienstkonto der Verbindung Berechtigungen gewähren

Weisen Sie dem Dienstkonto der Verbindung die entsprechenden Rollen für den Zugriff auf andere Dienste zu. Sie müssen diese Rollen in demselben Projekt zuweisen, das Sie im Abschnitt Vorbereitung erstellt oder ausgewählt haben. Die Zuweisung der Rollen in einem anderen Projekt führt zu dem Fehler bqcx-1234567890-xxxx@gcp-sa-bigquery-condel.iam.gserviceaccount.com does not have the permission to access resource.

Berechtigungen für den Cloud Storage-Bucket gewähren

Gewähren Sie dem Dienstkonto Zugriff auf die Verwendung von Objekten im erstellten Bucket:

Rufen Sie die Seite Buckets auf.

Buckets aufrufen
Klicken Sie auf den Namen des Buckets, den Sie erstellt haben.
Klicken Sie auf Berechtigungen.
Klicken Sie auf Zugriffsrechte erteilen. Das Dialogfeld Zugriff gewähren wird geöffnet.
Geben Sie im Feld Neue Hauptkonten die Dienstkonto-ID ein, die Sie zuvor kopiert haben.
Wählen Sie im Feld Rolle auswählen die Option Cloud Storage und dann Storage Object User aus.
Klicken Sie auf Speichern.

Berechtigungen zum Verwenden von Vertex AI-Modellen erteilen

Gewähren Sie dem Dienstkonto Zugriff auf die Verwendung von Vertex AI-Modellen:

Rufen Sie die Seite IAM und Verwaltung auf.

IAM & Verwaltung aufrufen
Klicken Sie auf Zugriffsrechte erteilen. Das Dialogfeld Zugriff gewähren wird geöffnet.
Geben Sie im Feld Neue Hauptkonten die Dienstkonto-ID ein, die Sie zuvor kopiert haben.
Wählen Sie im Feld Rolle auswählen die Option Vertex AI und dann Vertex AI-Nutzer aus.
Klicken Sie auf Speichern.

Tabellen mit Beispieldaten erstellen

Erstellen Sie Tabellen zum Speichern der Produktinformationen für Cymbal-Haustiere.

`products`-Tabelle erstellen

Erstellen Sie eine Standardtabelle mit den Produktinformationen für Cymbal-Haustiere:

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

BigQuery aufrufen

Führen Sie den folgenden Befehl aus, um die Tabelle products zu erstellen:

SQL

LOAD DATA OVERWRITE cymbal_pets.products
FROM
  FILES(
    format = 'avro',
    uris = [
      'gs://cloud-samples-data/bigquery/tutorials/cymbal-pets/tables/products/products_*.avro']);

BigQuery DataFrames

Bevor Sie dieses Beispiel ausprobieren, folgen Sie den Schritten zur Einrichtung von BigQuery DataFrames in der BigQuery-Kurzanleitung: BigQuery DataFrames verwenden. Weitere Informationen finden Sie in der Referenzdokumentation zu BigQuery DataFrames.

Richten Sie zur Authentifizierung bei BigQuery die Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter ADC für eine lokale Entwicklungsumgebung einrichten.

import bigframes.bigquery as bbq
import bigframes.pandas as bpd

bbq.load_data(
    "cymbal_pets.products",
    write_disposition="OVERWRITE",
    from_files_options={
        "format": "avro",
        "uris": [
            "gs://cloud-samples-data/bigquery/tutorials/cymbal-pets/tables/products/products_*.avro"
        ],
    },
)

`product_images`-Tabelle erstellen

Erstellen Sie eine Objekttabelle mit den Produktbildern von Cymbal Pets:

Führen Sie den folgenden Befehl aus, um die Tabelle product_images zu erstellen:

SQL

CREATE OR REPLACE EXTERNAL TABLE cymbal_pets.product_images
  WITH CONNECTION `us.cymbal_conn`
  OPTIONS (
    object_metadata = 'SIMPLE',
    uris = ['gs://cloud-samples-data/bigquery/tutorials/cymbal-pets/images/*.png'],
    max_staleness = INTERVAL 30 MINUTE,
    metadata_cache_mode = AUTOMATIC);

BigQuery DataFrames

Richten Sie zur Authentifizierung bei BigQuery die Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter ADC für eine lokale Entwicklungsumgebung einrichten.

bbq.create_external_table(
    "cymbal_pets.product_images",
    replace=True,
    connection_name="us.cymbal_conn",
    options={
        "object_metadata": "SIMPLE",
        "uris": [
            "gs://cloud-samples-data/bigquery/tutorials/cymbal-pets/images/*.png"
        ],
    },
)

`product_manuals`-Tabelle erstellen

Erstellen Sie eine Objekttabelle mit den Produktanleitungen für Cymbal-Haustiere:

Führen Sie den folgenden Befehl aus, um die Tabelle product_manuals zu erstellen:

SQL

CREATE OR REPLACE EXTERNAL TABLE cymbal_pets.product_manuals
  WITH CONNECTION `us.cymbal_conn`
  OPTIONS (
    object_metadata = 'SIMPLE',
    uris = ['gs://cloud-samples-data/bigquery/tutorials/cymbal-pets/documents/*.pdf']);

BigQuery DataFrames

Richten Sie zur Authentifizierung bei BigQuery die Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter ADC für eine lokale Entwicklungsumgebung einrichten.

bbq.create_external_table(
    "cymbal_pets.product_manuals",
    replace=True,
    connection_name="us.cymbal_conn",
    options={
        "object_metadata": "SIMPLE",
        "uris": [
            "gs://cloud-samples-data/bigquery/tutorials/cymbal-pets/documents/*.pdf"
        ],
    },
)

Textgenerierungsmodell erstellen

So erstellen Sie ein BigQuery ML-Remote-Modell, das ein Vertex AI Gemini-Modell darstellt:

Führen Sie den folgenden Befehl aus, um das Remote-Modell zu erstellen:
SQL
```
CREATE OR REPLACE MODEL `cymbal_pets.gemini`
  REMOTE WITH CONNECTION `us.cymbal_conn`
  OPTIONS (ENDPOINT = 'gemini-2.0-flash');
```
BigQuery DataFrames

Bevor Sie dieses Beispiel ausprobieren, folgen Sie den Schritten zur Einrichtung von BigQuery DataFrames in der BigQuery-Kurzanleitung: BigQuery DataFrames verwenden. Weitere Informationen finden Sie in der Referenzdokumentation zu BigQuery DataFrames.

Richten Sie zur Authentifizierung bei BigQuery die Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter ADC für eine lokale Entwicklungsumgebung einrichten.
gemini_model = bbq.ml.create_model( "cymbal_pets.gemini", replace=True, connection_name="us.cymbal_conn", options={"endpoint": "gemini-2.5-flash"}, )

Modell zur Generierung von Einbettungen erstellen

Erstellen Sie ein BigQuery ML-Remote-Modell, das ein multimodales Vertex AI-Einbettungsmodell darstellt:

Führen Sie den folgenden Befehl aus, um das Remote-Modell zu erstellen:
SQL
```
CREATE OR REPLACE MODEL `cymbal_pets.embedding_model`
  REMOTE WITH CONNECTION `us.cymbal_conn`
  OPTIONS (ENDPOINT = 'multimodalembedding@001');
```
BigQuery DataFrames

Bevor Sie dieses Beispiel ausprobieren, folgen Sie den Schritten zur Einrichtung von BigQuery DataFrames in der BigQuery-Kurzanleitung: BigQuery DataFrames verwenden. Weitere Informationen finden Sie in der Referenzdokumentation zu BigQuery DataFrames.

Richten Sie zur Authentifizierung bei BigQuery die Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter ADC für eine lokale Entwicklungsumgebung einrichten.
embedding_model = bbq.ml.create_model( "cymbal_pets.embedding_model", replace=True, connection_name="us.cymbal_conn", options={"endpoint": "multimodalembedding@001"}, )

`products_mm`-Tabelle mit multimodalen Daten erstellen

Erstellen Sie eine products_mm-Tabelle mit einer image-Spalte, die mit Produktbildern aus der product_images-Objekttabelle gefüllt ist. Die erstellte Spalte image ist eine STRUCT-Spalte im Format ObjectRef.

Führen Sie den folgenden Code aus, um die Tabelle products_mm zu erstellen und die Spalte image mit Daten zu füllen:
SQL
```
CREATE OR REPLACE TABLE cymbal_pets.products_mm
AS
SELECT products.* EXCEPT (uri), ot.ref AS image FROM cymbal_pets.products
INNER JOIN cymbal_pets.product_images ot
ON ot.uri = products.uri;
```
BigQuery DataFrames

Bevor Sie dieses Beispiel ausprobieren, folgen Sie den Schritten zur Einrichtung von BigQuery DataFrames in der BigQuery-Kurzanleitung: BigQuery DataFrames verwenden. Weitere Informationen finden Sie in der Referenzdokumentation zu BigQuery DataFrames.

Richten Sie zur Authentifizierung bei BigQuery die Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter ADC für eine lokale Entwicklungsumgebung einrichten.
df_images = bpd.read_gbq("SELECT * FROM cymbal_pets.product_images") df_products = bpd.read_gbq("cymbal_pets.products") df_products_mm = df_images.merge(df_products, on="uri").drop(columns="uri") df_products_mm = df_products_mm.rename(columns={"ref": "image"})

Führen Sie den folgenden Befehl aus, um die Daten der Spalte image aufzurufen:

SQL

SELECT product_name, image
FROM cymbal_pets.products_mm

BigQuery DataFrames

Richten Sie zur Authentifizierung bei BigQuery die Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter ADC für eine lokale Entwicklungsumgebung einrichten.

df_products_mm[["product_name", "image"]]

Die Ergebnisse sehen in etwa so aus:

+--------------------------------+--------------------------------------+-----------------------------------------------+------------------------------------------------+
| product_name                   | image.uri                            | image.version | image.authorizer              | image.details                                  |
+--------------------------------+--------------------------------------+-----------------------------------------------+------------------------------------------------+
|  AquaClear Aquarium Background | gs://cloud-samples-data/bigquery/    | 1234567891011 | myproject.region.myconnection | {"gcs_metadata":{"content_type":"image/png",   |
|                                | tutorials/cymbal-pets/images/        |               |                               | "md5_hash":"494f63b9b137975ff3e7a11b060edb1d", |
|                                | aquaclear-aquarium-background.png    |               |                               | "size":1282805,"updated":1742492680017000}}    |
+--------------------------------+--------------------------------------+-----------------------------------------------+------------------------------------------------+
|  AquaClear Aquarium            | gs://cloud-samples-data/bigquery/    | 2345678910112 | myproject.region.myconnection | {"gcs_metadata":{"content_type":"image/png",   |
|  Gravel Vacuum                 | tutorials/cymbal-pets/images/        |               |                               | "md5_hash":"b7bfc2e2641a77a402a1937bcf0003fd", |
|                                | aquaclear-aquarium-gravel-vacuum.png |               |                               | "size":820254,"updated":1742492682411000}}     |
+--------------------------------+--------------------------------------+-----------------------------------------------+------------------------------------------------+
| ...                            | ...                                  | ...           |                               | ...                                            |
+--------------------------------+--------------------------------------+-----------------------------------------------+------------------------------------------------+

Produktinformationen mit einem Gemini-Modell generieren

Verwenden Sie ein Gemini-Modell, um die folgenden Daten für die Produkte des Zoofachgeschäfts zu generieren:

Fügen Sie der Tabelle products_mm eine image_description-Spalte hinzu.
Füllen Sie die Spalten animal_type, search_keywords und subcategory der Tabelle products_mm aus.
Führen Sie eine Abfrage aus, die eine Beschreibung der einzelnen Produktmarken und die Anzahl der Produkte dieser Marke zurückgibt. Die Markenbeschreibung wird durch die Analyse von Produktinformationen für alle Produkte dieser Marke, einschließlich Produktbilder, generiert.

Führen Sie den folgenden Befehl aus, um die Spalte image_description zu erstellen und mit Daten zu füllen:

SQL

CREATE OR REPLACE TABLE cymbal_pets.products_mm
AS
SELECT
  product_id,
  product_name,
  brand,
  category,
  subcategory,
  animal_type,
  search_keywords,
  price,
  description,
  inventory_level,
  supplier_id,
  average_rating,
  image,
  image_description
FROM
  AI.GENERATE_TABLE(
    MODEL `cymbal_pets.gemini`,
    (
      SELECT
        ('Can you describe the following image? ', OBJ.GET_ACCESS_URL(image, 'r')) AS prompt,
        *
      FROM
        cymbal_pets.products_mm
    ),
    STRUCT('image_description STRING' AS output_schema));

BigQuery DataFrames

Richten Sie zur Authentifizierung bei BigQuery die Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter ADC für eine lokale Entwicklungsumgebung einrichten.

df_products_mm["url"] = bbq.obj.get_access_url(
    df_products_mm["image"], "R"
).to_frame()
df_products_mm["prompt0"] = "Can you describe the following image?"

df_products_mm["prompt"] = bbq.struct(df_products_mm[["prompt0", "url"]])
df_products_mm = bbq.ai.generate_table(
    gemini_model, df_products_mm, output_schema={"image_description": "STRING"}
)

df_products_mm = df_products_mm[
    [
        "product_id",
        "product_name",
        "brand",
        "category",
        "subcategory",
        "animal_type",
        "search_keywords",
        "price",
        "description",
        "inventory_level",
        "supplier_id",
        "average_rating",
        "image",
        "image_description",
    ]
]

Führen Sie den folgenden Befehl aus, um die Spalten animal_type, search_keywords und subcategory mit generierten Daten zu aktualisieren:

SQL

UPDATE cymbal_pets.products_mm p
SET
  p.animal_type = s.animal_type,
  p.search_keywords = s.search_keywords,
  p.subcategory = s.subcategory
FROM
  (
    SELECT
      animal_type,
      search_keywords,
      subcategory,
      uri
    FROM
      AI.GENERATE_TABLE(
        MODEL `cymbal_pets.gemini`,
        (
          SELECT
            (
              'For the image of a pet product, concisely generate the following metadata: '
              '1) animal_type and 2) 5 SEO search keywords, and 3) product subcategory. ',
              OBJ.GET_ACCESS_URL(image, 'r'),
              description) AS prompt,
            image.uri AS uri,
          FROM cymbal_pets.products_mm
        ),
        STRUCT(
          'animal_type STRING, search_keywords ARRAY<STRING>, subcategory STRING' AS output_schema,
          100 AS max_output_tokens))
  ) s
WHERE p.image.uri = s.uri;

BigQuery DataFrames

Richten Sie zur Authentifizierung bei BigQuery die Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter ADC für eine lokale Entwicklungsumgebung einrichten.

df_prompt = bbq.obj.get_access_url(df_products_mm["image"], "R").to_frame()
df_prompt[
    "prompt0"
] = "For the image of a pet product, concisely generate the following metadata: 1) animal_type and 2) 5 SEO search keywords, and 3) product subcategory."

df_products_mm["prompt"] = bbq.struct(df_prompt[["prompt0", "image"]])

df_products_mm = df_products_mm.drop(
    columns=["animal_type", "search_keywords", "subcategory"]
)
df_products_mm = bbq.ai.generate_table(
    gemini_model,
    df_products_mm,
    output_schema="animal_type STRING, search_keywords ARRAY<STRING>, subcategory STRING",
)

Führen Sie den folgenden Befehl aus, um die generierten Daten aufzurufen:

SQL

SELECT
  product_name,
  image_description,
  animal_type,
  search_keywords,
  subcategory,
FROM cymbal_pets.products_mm;

BigQuery DataFrames

Richten Sie zur Authentifizierung bei BigQuery die Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter ADC für eine lokale Entwicklungsumgebung einrichten.

df_products_mm[
    [
        "product_name",
        "image_description",
        "animal_type",
        "search_keywords",
        "subcategory",
    ]
]

Die Ergebnisse sehen in etwa so aus:

+--------------------------------+-------------------------------------+-------------+------------------------+------------------+
| product_name                   | image.description                   | animal_type | search_keywords        | subcategory      |
+--------------------------------+-------------------------------------+-------------+------------------------+------------------+
|  AquaClear Aquarium Background | The image shows a colorful coral    | fish        | aquarium background    | aquarium decor   |
|                                | reef backdrop. The background is a  |             | fish tank backdrop     |                  |
|                                | blue ocean with a bright light...   |             | coral reef decor       |                  |
|                                |                                     |             | underwater scenery     |                  |
|                                |                                     |             | aquarium decoration    |                  |
+--------------------------------+-------------------------------------+-------------+------------------------+------------------+
|  AquaClear Aquarium            | The image shows a long, clear       | fish        | aquarium gravel vacuum | aquarium         |
|  Gravel Vacuum                 | plastic tube with a green hose      |             | aquarium cleaning      | cleaning         |
|                                | attached to one end. The tube...    |             | aquarium maintenance   |                  |
|                                |                                     |             | fish tank cleaning     |                  |
|                                |                                     |             | gravel siphon          |                  |
+--------------------------------+-------------------------------------+-------------+------------------------+------------------+
| ...                            | ...                                 | ...         |  ...                   | ...              |
+--------------------------------+-------------------------------------+-------------+------------------------+------------------+

Führen Sie Folgendes aus, um eine Beschreibung jeder Produktmarke und eine Anzahl der Produkte dieser Marke zu generieren:

SQL

SELECT
  brand,
  brand_description,
  cnt
FROM
  AI.GENERATE_TABLE(
    MODEL `cymbal_pets.gemini`,
    (
      SELECT
        brand,
        COUNT(*) AS cnt,
        (
          'Use the images and text to give one concise brand description for a website brand page.'
            'Return the description only. ',
          ARRAY_AGG(OBJ.GET_ACCESS_URL(image, 'r')), ' ',
          ARRAY_AGG(description), ' ',
          ARRAY_AGG(category), ' ',
          ARRAY_AGG(subcategory)) AS prompt
      FROM cymbal_pets.products_mm
      GROUP BY brand
    ),
    STRUCT('brand_description STRING' AS output_schema))
ORDER BY cnt DESC;

BigQuery DataFrames

Richten Sie zur Authentifizierung bei BigQuery die Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter ADC für eine lokale Entwicklungsumgebung einrichten.

df_agg = df_products_mm[
    ["image", "description", "category", "subcategory", "brand"]
]
df_agg["image"] = bbq.obj.get_access_url(df_products_mm["image"], "R")
df_agg = bbq.array_agg(df_agg.groupby(by=["brand"]))

df_agg["cnt"] = bbq.array_length(df_agg["image"])

df_prompt = df_agg[["image", "description", "category", "subcategory"]]
df_prompt[
    "prompt0"
] = "Use the images and text to give one concise brand description for a website brand page. Return the description only. "

df_agg["prompt"] = bbq.struct(
    df_prompt[["prompt0", "image", "description", "category", "subcategory"]]
)

df_agg = df_agg.reset_index()

df_agg = bbq.ai.generate_table(
    gemini_model, df_agg, output_schema={"brand_description": "STRING"}
)
df_agg[["brand", "brand_description", "cnt"]]

Die Ergebnisse sehen in etwa so aus:

+--------------+-------------------------------------+-----+
| brand        | brand.description                   | cnt |
+--------------+-------------------------------------+-----+
|  AquaClear   | AquaClear is a brand of aquarium    | 33  |
|              | and pond care products that offer   |     |
|              | a wide range of solutions for...    |     |
+--------------+-------------------------------------+-----+
|  Ocean       | Ocean Bites is a brand of cat food  | 28  |
|  Bites       | that offers a variety of recipes    |     |
|              | and formulas to meet the specific.. |     |
+--------------+-------------------------------------+-----+
|  ...         | ...                                 |...  |
+--------------+-------------------------------------+-----+

Python-UDF zum Transformieren von Produktbildern erstellen

Erstellen Sie eine Python-UDF, um Produktbilder in Graustufen zu konvertieren.

Die Python-UDF verwendet Open-Source-Bibliotheken und auch die parallele Ausführung, um mehrere Bilder gleichzeitig zu transformieren.

Führen Sie den folgenden Befehl aus, um die UDF to_grayscale zu erstellen:

SQL

CREATE OR REPLACE FUNCTION cymbal_pets.to_grayscale(src_json STRING, dst_json STRING)
RETURNS STRING
LANGUAGE python
WITH CONNECTION `us.cymbal_conn`
OPTIONS (entry_point='to_grayscale', runtime_version='python-3.11', packages=['numpy', 'opencv-python'])
AS """

import cv2 as cv
import numpy as np
from urllib.request import urlopen, Request
import json

# Transform the image to grayscale.
def to_grayscale(src_ref, dst_ref):
  src_json = json.loads(src_ref)
  srcUrl = src_json["access_urls"]["read_url"]

  dst_json = json.loads(dst_ref)
  dstUrl = dst_json["access_urls"]["write_url"]

  req = urlopen(srcUrl)
  arr = np.asarray(bytearray(req.read()), dtype=np.uint8)
  img = cv.imdecode(arr, -1) # 'Load it as it is'

  # Convert the image to grayscale
  gray_image = cv.cvtColor(img, cv.COLOR_BGR2GRAY)

  # Send POST request to the URL
  _, img_encoded = cv.imencode('.png', gray_image)

  req = Request(url=dstUrl, data=img_encoded.tobytes(), method='PUT', headers = {
      "Content-Type": "image/png",
  })
  with urlopen(req) as f:
      pass
  return dst_ref
""";

BigQuery DataFrames

Richten Sie zur Authentifizierung bei BigQuery die Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter ADC für eine lokale Entwicklungsumgebung einrichten.

@bpd.udf(
    dataset="cymbal_pets",
    name="to_grayscale",
    packages=["numpy", "opencv-python"],
    bigquery_connection="us.cymbal_conn",
    max_batching_rows=1,
)
def to_grayscale(src_ref: str, dst_ref: str) -> str:
    import json
    from urllib.request import Request, urlopen

    import cv2 as cv
    import numpy as np

    src_json = json.loads(src_ref)
    srcUrl = src_json["access_urls"]["read_url"]

    dst_json = json.loads(dst_ref)
    dstUrl = dst_json["access_urls"]["write_url"]

    req = urlopen(srcUrl)
    arr = np.asarray(bytearray(req.read()), dtype=np.uint8)
    img = cv.imdecode(arr, -1)  # 'Load it as it is'

    # Convert the image to grayscale
    gray_image = cv.cvtColor(img, cv.COLOR_BGR2GRAY)

    # Send POST request to the URL
    _, img_encoded = cv.imencode(".png", gray_image)

    req = Request(
        url=dstUrl,
        data=img_encoded.tobytes(),
        method="PUT",
        headers={
            "Content-Type": "image/png",
        },
    )
    with urlopen(req):
        pass
    return dst_ref

Produktbilder transformieren

Erstellen Sie die Tabelle products_grayscale mit einer Spalte ObjectRef, die die Zielpfade und Autorisierungen für Graustufenbilder enthält. Der Zielpfad wird aus dem ursprünglichen Bildpfad abgeleitet.

Nachdem Sie die Tabelle erstellt haben, führen Sie die Funktion to_grayscale aus, um die Graustufenbilder zu erstellen, sie in einen Cloud Storage-Bucket zu schreiben und dann ObjectRefRuntime-Werte mit Zugriffs-URLs und Metadaten für die Graustufenbilder zurückzugeben.

Führen Sie den folgenden Befehl aus, um die Tabelle products_grayscale zu erstellen:

SQL

CREATE OR REPLACE TABLE cymbal_pets.products_grayscale
AS
SELECT
  product_id,
  product_name,
  image,
  OBJ.MAKE_REF(
    CONCAT('gs://BUCKET/cymbal-pets-images/grayscale/', REGEXP_EXTRACT(image.uri, r'([^/]+)$')),
    'us.cymbal_conn') AS gray_image
FROM cymbal_pets.products_mm;

BigQuery DataFrames

Richten Sie zur Authentifizierung bei BigQuery die Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter ADC für eine lokale Entwicklungsumgebung einrichten.

df_grayscale = df_products_mm[["product_id", "product_name", "image"]]
df_grayscale[
    "gray_image_uri"
] = f"gs://{BUCKET}/cymbal-pets-images/grayscale/" + df_grayscale[
    "image"
].struct.field(
    "uri"
).str.extract(
    r"([^/]+)$"
)

df_grayscale["gray_image"] = bbq.obj.make_ref(
    df_grayscale["gray_image_uri"], "us.cymbal_conn"
)

df_grayscale["image_url"] = bbq.to_json_string(
    bbq.obj.get_access_url(df_grayscale["image"], "r")
)
df_grayscale["gray_image_url"] = bbq.to_json_string(
    bbq.obj.get_access_url(df_grayscale["gray_image"], "rw")
)

df_grayscale[["image_url", "gray_image_url"]].apply(to_grayscale, axis=1)

Ersetzen Sie BUCKET durch den Namen des von Ihnen erstellten Buckets.

Führen Sie den folgenden Code aus, um die Graustufenbilder zu erstellen, sie in einen Cloud Storage-Bucket zu schreiben und dann ObjectRefRuntime-Werte mit Zugriffs-URLs und Metadaten für die Graustufenbilder zurückzugeben:

SQL

SELECT cymbal_pets.to_grayscale(
  TO_JSON_STRING(OBJ.GET_ACCESS_URL(image, 'r')),
  TO_JSON_STRING(OBJ.GET_ACCESS_URL(gray_image, 'rw')))
FROM cymbal_pets.products_grayscale;

BigQuery DataFrames

Richten Sie zur Authentifizierung bei BigQuery die Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter ADC für eine lokale Entwicklungsumgebung einrichten.

df_grayscale = df_products_mm[["product_id", "product_name", "image"]]
df_grayscale[
    "gray_image_uri"
] = f"gs://{BUCKET}/cymbal-pets-images/grayscale/" + df_grayscale[
    "image"
].struct.field(
    "uri"
).str.extract(
    r"([^/]+)$"
)

df_grayscale["gray_image"] = bbq.obj.make_ref(
    df_grayscale["gray_image_uri"], "us.cymbal_conn"
)

df_grayscale["image_url"] = bbq.to_json_string(
    bbq.obj.get_access_url(df_grayscale["image"], "r")
)
df_grayscale["gray_image_url"] = bbq.to_json_string(
    bbq.obj.get_access_url(df_grayscale["gray_image"], "rw")
)

df_grayscale[["image_url", "gray_image_url"]].apply(to_grayscale, axis=1)

Die Ergebnisse sehen in etwa so aus:

+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| f0                                                                                                                                                                    |
+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| {"access_urls":{"expiry_time":"2025-04-26T03:00:48Z",                                                                                                                 |
| "read_url":"https://storage.googleapis.com/mybucket/cymbal-pets-images%2Fgrayscale%2Focean-bites-salmon-%26-tuna-cat-food.png?additional_read URL_information",       |
| "write_url":"https://storage.googleapis.com/myproject/cymbal-pets-images%2Fgrayscale%2Focean-bites-salmon-%26-tuna-cat-food.png?additional_write URL_information"},   |
| "objectref":{"authorizer":"myproject.region.myconnection","uri":"gs://myproject/cymbal-pets-images/grayscale/ocean-bites-salmon-&-tuna-cat-food.png"}}                |
+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| {"access_urls":{"expiry_time":"2025-04-26T03:00:48Z",                                                                                                                 |
| "read_url":"https://storage.googleapis.com/mybucket/cymbal-pets-images%2Fgrayscale%2Ffluffy-buns-guinea-pig-tunnel.png?additional _read URL_information",             |
| "write_url":"https://storage.googleapis.com/myproject/cymbal-pets-images%2Fgrayscale%2Focean-bites-salmon-%26-tuna-cat-food.png?additional_write_URL_information"},   |
| "objectref":{"authorizer":"myproject.region.myconnection","uri":"gs://myproject/cymbal-pets-images%2Fgrayscale%2Ffluffy-buns-guinea-pig-tunnel.png"}}                 |
+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|  ...                                                                                                                                                                  |
+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------+

Python-UDF zum Aufteilen von PDF-Daten in Chunks erstellen

Erstellen Sie eine Python-UDF, um die PDF-Objekte, die die Produktanleitungen für Cymbal Pets enthalten, in mehrere Teile zu unterteilen.

PDFs sind oft sehr groß und passen möglicherweise nicht in einen einzelnen Aufruf eines generativen KI-Modells. Durch das Aufteilen der PDFs in Chunks können Sie die PDF-Daten in einem für das Modell geeigneten Format speichern, um die Analyse zu erleichtern.

Führen Sie den folgenden Befehl aus, um die UDF chunk_pdf zu erstellen:

SQL

-- This function chunks the product manual PDF into multiple parts.
-- The function accepts an ObjectRefRuntime value for the PDF file and the chunk size.
-- It then parses the PDF, chunks the contents, and returns an array of chunked text.
CREATE OR REPLACE FUNCTION cymbal_pets.chunk_pdf(src_json STRING, chunk_size INT64, overlap_size INT64)
RETURNS ARRAY<STRING>
LANGUAGE python
WITH CONNECTION `us.cymbal_conn`
OPTIONS (entry_point='chunk_pdf', runtime_version='python-3.11', packages=['pypdf'])
AS """
import io
import json

from pypdf import PdfReader  # type: ignore
from urllib.request import urlopen, Request

def chunk_pdf(src_ref: str, chunk_size: int, overlap_size: int) -> str:
  src_json = json.loads(src_ref)
  srcUrl = src_json["access_urls"]["read_url"]

  req = urlopen(srcUrl)
  pdf_file = io.BytesIO(bytearray(req.read()))
  reader = PdfReader(pdf_file, strict=False)

  # extract and chunk text simultaneously
  all_text_chunks = []
  curr_chunk = ""
  for page in reader.pages:
      page_text = page.extract_text()
      if page_text:
          curr_chunk += page_text
          # split the accumulated text into chunks of a specific size with overlaop
          # this loop implements a sliding window approach to create chunks
          while len(curr_chunk) >= chunk_size:
              split_idx = curr_chunk.rfind(" ", 0, chunk_size)
              if split_idx == -1:
                  split_idx = chunk_size
              actual_chunk = curr_chunk[:split_idx]
              all_text_chunks.append(actual_chunk)
              overlap = curr_chunk[split_idx + 1 : split_idx + 1 + overlap_size]
              curr_chunk = overlap + curr_chunk[split_idx + 1 + overlap_size :]
  if curr_chunk:
      all_text_chunks.append(curr_chunk)

  return all_text_chunks
""";

BigQuery DataFrames

Richten Sie zur Authentifizierung bei BigQuery die Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter ADC für eine lokale Entwicklungsumgebung einrichten.

@bpd.udf(
    dataset="cymbal_pets",
    name="chunk_pdf",
    packages=["pypdf"],
    bigquery_connection="us.cymbal_conn",
    max_batching_rows=1,
)
def chunk_pdf(src_ref: str, chunk_size: int, overlap_size: int) -> list[str]:
    import io
    import json
    from urllib.request import urlopen

    from pypdf import PdfReader  # type: ignore

    src_json = json.loads(src_ref)
    srcUrl = src_json["access_urls"]["read_url"]

    req = urlopen(srcUrl)
    pdf_file = io.BytesIO(bytearray(req.read()))
    reader = PdfReader(pdf_file, strict=False)

    # extract and chunk text simultaneously
    all_text_chunks = []
    curr_chunk = ""
    for page in reader.pages:
        page_text = page.extract_text()
        if page_text:
            curr_chunk += page_text
            # split the accumulated text into chunks of a specific size with overlaop
            # this loop implements a sliding window approach to create chunks
            while len(curr_chunk) >= chunk_size:
                split_idx = curr_chunk.rfind(" ", 0, chunk_size)
                if split_idx == -1:
                    split_idx = chunk_size
                actual_chunk = curr_chunk[:split_idx]
                all_text_chunks.append(actual_chunk)
                overlap = curr_chunk[split_idx + 1 : split_idx + 1 + overlap_size]
                curr_chunk = overlap + curr_chunk[split_idx + 1 + overlap_size :]
    if curr_chunk:
        all_text_chunks.append(curr_chunk)

    return all_text_chunks

PDF-Daten analysieren

Führen Sie die Funktion chunk_pdf aus, um die PDF-Daten in der Tabelle product_manuals in Chunks aufzuteilen, und erstellen Sie dann eine Tabelle product_manual_chunk_strings, die einen PDF-Chunk pro Zeile enthält. Verwenden Sie ein Gemini-Modell für die product_manual_chunk_strings-Daten, um die rechtlichen Informationen in den Produkthandbüchern zusammenzufassen.

Führen Sie den folgenden Befehl aus, um die Tabelle product_manual_chunk_strings zu erstellen:

SQL

CREATE OR REPLACE TABLE cymbal_pets.product_manual_chunk_strings
AS
SELECT chunked
FROM cymbal_pets.product_manuals,
UNNEST (cymbal_pets.chunk_pdf(
  TO_JSON_STRING(
    OBJ.GET_ACCESS_URL(OBJ.MAKE_REF(uri, 'us.cymbal_conn'), 'r')),
    1000,
    100
)) as chunked;

BigQuery DataFrames

Richten Sie zur Authentifizierung bei BigQuery die Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter ADC für eine lokale Entwicklungsumgebung einrichten.

df_manuals = bpd.read_gbq("SELECT * FROM cymbal_pets.product_manuals")
df_manuals["url"] = bbq.to_json_string(
    bbq.obj.get_access_url(df_manuals["ref"], "R")
)

df_manuals["chunk_size"] = 1000
df_manuals["overlap_size"] = 100

df_manuals["chunked"] = df_manuals[["url", "chunk_size", "overlap_size"]].apply(
    chunk_pdf, axis=1
)

Führen Sie Folgendes aus, um die PDF-Daten mit einem Gemini-Modell zu analysieren:

SQL

SELECT
  result
FROM
  AI.GENERATE_TEXT(
    MODEL `cymbal_pets.gemini`,
    (
      SELECT
        (
          'Can you summarize the product manual as bullet points? Highlight the legal clauses',
          chunked) AS prompt,
      FROM cymbal_pets.product_manual_chunk_strings
    ));

BigQuery DataFrames

Richten Sie zur Authentifizierung bei BigQuery die Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter ADC für eine lokale Entwicklungsumgebung einrichten.

df_chunked = df_manuals["chunked"].explode().to_frame()
df_chunked[
    "prompt0"
] = "Can you summarize the product manual as bullet points? Highlight the legal clauses"

df_chunked["prompt"] = bbq.struct(df_chunked[["prompt0", "chunked"]])

result = bbq.ai.generate_text(gemini_model, df_chunked["prompt"])
result

Die Ergebnisse sehen in etwa so aus:

+-------------------------------------------------------------------------------------------------------------------------------------------+
| result                                                                                                                                    |
+-------------------------------------------------------------------------------------------------------------------------------------------+
| ## CritterCuisine Pro 5000 Automatic Pet Feeder Manual Summary:                                                                           |
|                                                                                                                                           |
| **Safety:**                                                                                                                               |
|                                                                                                                                           |
| * **Stability:** Place feeder on a level, stable surface to prevent tipping.                                                              |
| * **Power Supply:** Only use the included AC adapter. Using an incompatible adapter can damage the unit and void the warranty.            |
| * **Cord Safety:** Keep the power cord out of reach of pets to prevent chewing or entanglement.                                           |
| * **Children:** Supervise children around the feeder. This is not a toy.                                                                  |
| * **Pet Health:** Consult your veterinarian before using an automatic feeder if your pet has special dietary needs, health conditions, or |
+-------------------------------------------------------------------------------------------------------------------------------------------+
| ## Product Manual Summary:                                                                                                                |
|                                                                                                                                           |
| **6.3 Manual Feeding:**                                                                                                                   |
|                                                                                                                                           |
| * Press MANUAL button to dispense a single portion (Meal 1 size). **(Meal Enabled)**                                                      |
|                                                                                                                                           |
| **6.4 Recording a Voice Message:**                                                                                                        |
|                                                                                                                                           |
| * Press and hold VOICE button.                                                                                                            |
| * Speak clearly into the microphone (up to 10 seconds).                                                                                   |
| * Release VOICE button to finish recording.                                                                                               |
| * Briefly press VOICE button to play back the recording.                                                                                  |
| * To disable the voice message, record a blank message (hold VOICE button for 10 seconds without speaking). **(Meal Enabled)**            |
|                                                                                                                                           |
| **6.5 Low Food Level Indicator:**                                                                                                         |
+-------------------------------------------------------------------------------------------------------------------------------------------+
| ...                                                                                                                                       |
+-------------------------------------------------------------------------------------------------------------------------------------------+

Einbettungen generieren und Vektorsuche ausführen

Einbettungen aus Bilddaten generieren und dann die Einbettungen verwenden, um ähnliche Bilder mithilfe der Vektorsuche zurückzugeben.

In einem Produktionsszenario empfehlen wir, vor der Ausführung einer Vektorsuche einen Vektorindex zu erstellen. Mit einem Vektorindex können Sie die Vektorsuche schneller durchführen, mit dem Kompromiss, dass der Recall reduziert wird und somit ungefähre Ergebnisse zurückgegeben werden.

Führen Sie den folgenden Befehl aus, um die Tabelle products_embeddings zu erstellen:

SQL

CREATE OR REPLACE TABLE cymbal_pets.products_embedding
AS
SELECT product_id, embedding, content as image
FROM AI.GENERATE_EMBEDDING(
MODEL `cymbal_pets.embedding_model`,
  (
    SELECT OBJ.GET_ACCESS_URL(image, 'r') as content, image, product_id
    FROM cymbal_pets.products_mm
  )
);

BigQuery DataFrames

Richten Sie zur Authentifizierung bei BigQuery die Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter ADC für eine lokale Entwicklungsumgebung einrichten.

df_products_mm["content"] = bbq.obj.get_access_url(df_products_mm["image"], "R")
df_embed = bbq.ai.generate_embedding(
    embedding_model, df_products_mm[["content", "product_id"]]
)

df_embed.to_gbq("cymbal_pets.products_embedding", if_exists="replace")

Führen Sie den folgenden Code aus, um eine Vektorsuche durchzuführen und Produktbilder zurückzugeben, die dem angegebenen Eingabebild ähneln:

SQL

SELECT *
FROM
VECTOR_SEARCH(
  TABLE cymbal_pets.products_embedding,
  'embedding',
  (SELECT embedding FROM AI.GENERATE_EMBEDDING(
    MODEL `cymbal_pets.embedding_model`,
    (SELECT OBJ.FETCH_METADATA(OBJ.MAKE_REF('gs://cloud-samples-data/bigquery/tutorials/cymbal-pets/images/cozy-naps-cat-scratching-post-with-condo.png', 'us.cymbal_conn')) as content)
  ))
);

BigQuery DataFrames

Richten Sie zur Authentifizierung bei BigQuery die Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter ADC für eine lokale Entwicklungsumgebung einrichten.

df_image = bpd.DataFrame(
    {
        "uri": [
            "gs://cloud-samples-data/bigquery/tutorials/cymbal-pets/images/cozy-naps-cat-scratching-post-with-condo.png"
        ]
    }
).cache()
df_image["image"] = bbq.obj.make_ref(df_image["uri"], "us.cymbal_conn")
df_search = bbq.ai.generate_embedding(
    embedding_model,
    bbq.obj.get_access_url(bbq.obj.fetch_metadata(df_image["image"]), "R"),
)

search_result = bbq.vector_search(
    "cymbal_pets.products_embedding", "embedding", df_search["embedding"]
)
search_result

Die Ergebnisse sehen in etwa so aus:

+-----------------+-----------------+----------------+----------------------------------------------+--------------------+-------------------------------+------------------------------------------------+----------------+
| query.embedding | base.product_id | base.embedding | base.image.uri                               | base.image.version | base.image.authorizer         | base.image.details                             | distance       |
+-----------------+-----------------+----------------+----------------------------------------------+--------------------+-------------------------------+------------------------------------------------+----------------+
| -0.0112330541   | 181             | -0.0112330541  | gs://cloud-samples-data/bigquery/            | 12345678910        | myproject.region.myconnection | {"gcs_metadata":{"content_type":               | 0.0            |
| 0.0142525584    |                 |  0.0142525584  | tutorials/cymbal-pets/images/                |                    |                               | "image/png","md5_hash":"21234567hst16555w60j", |                |
| 0.0135886827    |                 |  0.0135886827  | cozy-naps-cat-scratching-post-with-condo.png |                    |                               | "size":828318,"updated":1742492688982000}}     |                |
| 0.0149955815    |                 |  0.0149955815  |                                              |                    |                               |                                                |                |
| ...             |                 |  ...           |                                              |                    |                               |                                                |                |
|                 |                 |                |                                              |                    |                               |                                                |                |
|                 |                 |                |                                              |                    |                               |                                                |                |
+-----------------+-----------------+----------------+----------------------------------------------+--------------------+-------------------------------+------------------------------------------------+----------------+
| -0.0112330541   | 187             | -0.0190353896  | gs://cloud-samples-data/bigquery/            | 23456789101        | myproject.region.myconnection | {"gcs_metadata":{"content_type":               | 0.4216330832.. |
| 0.0142525584    |                 |  0.0116206668  | tutorials/cymbal-pets/images/                |                    |                               | "image/png","md5_hash":"7328728fhakd9937djo4", |                |
| 0.0135886827    |                 |  0.0136198215  | cozy-naps-cat-scratching-post-with-bed.png   |                    |                               | "size":860113,"updated":1742492688774000}}     |                |
| 0.0149955815    |                 |  0.0173457414  |                                              |                    |                               |                                                |                |
| ...             |                 |  ...           |                                              |                    |                               |                                                |                |
|                 |                 |                |                                              |                    |                               |                                                |                |
|                 |                 |                |                                              |                    |                               |                                                |                |
+-----------------+-----------------+----------------+----------------------------------------------+--------------------+-------------------------------+------------------------------------------------+----------------+
| ...             | ...             | ...            | ...                                          | ...                | ...                           | ...                                            | ...            |
+-----------------+-----------------+----------------+----------------------------------------------+--------------------+-------------------------------+------------------------------------------------+----------------+

Geordnete multimodale Daten mit Arrays von `ObjectRef`-Werten verarbeiten

In diesem Abschnitt werden die folgenden Aufgaben erläutert:

Erstellen Sie die Tabelle product_manuals neu, sodass sie sowohl eine PDF-Datei für das Crittercuisine 5000-Produktmanual als auch PDF-Dateien für jede Seite dieses Manuals enthält.
Erstellen Sie eine Tabelle, in der das Handbuch seinen Abschnitten zugeordnet wird. Der Wert ObjectRef, der das vollständige Handbuch darstellt, wird in der Spalte STRUCT<uri STRING, version STRING, authorizer STRING, details JSON>> gespeichert. Die ObjectRef-Werte, die die Handbuchseiten darstellen, werden in einer Spalte ARRAY<STRUCT<uri STRING, version STRING, authorizer STRING, details JSON>> gespeichert.
Analysieren Sie ein Array von ObjectRef-Werten zusammen, um einen einzelnen generierten Wert zurückzugeben.
Analysiert ein Array von ObjectRef-Werten separat und gibt für jeden Arraywert einen generierten Wert zurück.

Im Rahmen der Analyseaufgaben konvertieren Sie das Array von ObjectRef-Werten in eine geordnete Liste von ObjectRefRuntime-Werten und übergeben diese Liste dann an ein Gemini-Modell. Dabei geben Sie die ObjectRefRuntime-Werte als Teil des Prompts an. Die ObjectRefRuntime-Werte enthalten signierte URLs, mit denen das Modell auf die Objektinformationen in Cloud Storage zugreift.

So verarbeiten Sie geordnete multimodale Daten mit Arrays von ObjectRef-Werten:

Rufen Sie die Seite BigQuery auf.

BigQuery aufrufen

Führen Sie den folgenden Befehl aus, um die Tabelle product_manuals neu zu erstellen:

SQL

CREATE OR REPLACE EXTERNAL TABLE `cymbal_pets.product_manuals`
  WITH CONNECTION `us.cymbal_conn`
  OPTIONS (
    object_metadata = 'SIMPLE',
    uris = [
        'gs://cloud-samples-data/bigquery/tutorials/cymbal-pets/documents/*.pdf',
        'gs://cloud-samples-data/bigquery/tutorials/cymbal-pets/document_chunks/*.pdf']);

BigQuery DataFrames

Richten Sie zur Authentifizierung bei BigQuery die Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter ADC für eine lokale Entwicklungsumgebung einrichten.

bbq.create_external_table(
    "cymbal_pets.product_manuals_all",
    replace=True,
    connection_name="us.cymbal_conn",
    options={
        "object_metadata": "SIMPLE",
        "uris": [
            "gs://cloud-samples-data/bigquery/tutorials/cymbal-pets/documents/*.pdf",
            "gs://cloud-samples-data/bigquery/tutorials/cymbal-pets/document_chunks/*.pdf",
        ],
    },
)

Führen Sie den folgenden Befehl aus, um PDF-Daten in die Tabelle map_manual_to_chunks zu schreiben:

SQL

-- Extract the file and chunks into a single table.
-- Store the chunks in the chunks column as array of ObjectRefs (ordered by page number)
CREATE OR REPLACE TABLE cymbal_pets.map_manual_to_chunks
AS
SELECT ARRAY_AGG(m1.ref)[0] manual, ARRAY_AGG(m2.ref ORDER BY m2.ref.uri) chunks
FROM cymbal_pets.product_manuals m1
JOIN cymbal_pets.product_manuals m2
  ON
    REGEXP_EXTRACT(m1.uri, r'.*/([^.]*).[^/]+')
    = REGEXP_EXTRACT(m2.uri, r'.*/([^.]*)_page[0-9]+.[^/]+')
GROUP BY m1.uri;

BigQuery DataFrames

Richten Sie zur Authentifizierung bei BigQuery die Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter ADC für eine lokale Entwicklungsumgebung einrichten.

df1 = bpd.read_gbq("SELECT * FROM cymbal_pets.product_manuals_all").sort_values(
    "uri"
)
df2 = df1.copy()
df1["name"] = df1["uri"].str.extract(r".*/([^.]*).[^/]+")
df2["name"] = df2["uri"].str.extract(r".*/([^.]*)_page[0-9]+.[^/]+")
df_manuals_all = df1.merge(df2, on="name")
df_manuals_agg = (
    bbq.array_agg(df_manuals_all[["ref_x", "uri_x"]].groupby("uri_x"))["ref_x"]
    .str[0]
    .to_frame()
)
df_manuals_agg["chunks"] = bbq.array_agg(
    df_manuals_all[["ref_y", "uri_x"]].groupby("uri_x")
)["ref_y"]

Führen Sie Folgendes aus, um die PDF-Daten in der Tabelle map_manual_to_chunks aufzurufen:

SQL

SELECT *
FROM cymbal_pets.map_manual_to_chunks;

BigQuery DataFrames

Richten Sie zur Authentifizierung bei BigQuery die Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter ADC für eine lokale Entwicklungsumgebung einrichten.

df_manuals_agg

Die Ergebnisse sehen in etwa so aus:

+-------------------------------------+--------------------------------+-----------------------------------+------------------------------------------------------+-------------------------------------------+---------------------------------+------------------------------------+-------------------------------------------------------+
| manual.uri                          | manual.version                 | manual.authorizer                 | manual.details                                       | chunks.uri                                | chunks.version                  | chunks.authorizer                  | chunks.details                                        |
+-------------------------------------+--------------------------------+-----------------------------------+------------------------------------------------------+-------------------------------------------+---------------------------------+------------------------------------+-------------------------------------------------------+
| gs://cloud-samples-data/bigquery/   | 1742492785900455               | myproject.region.myconnection     | {"gcs_metadata":{"content_type":"application/pef",   | gs://cloud-samples-data/bigquery/         | 1745875761227129                | myproject.region.myconnection      | {"gcs_metadata":{"content_type":"application/pdf",    |
| tutorials/cymbal-pets/documents/    |                                |                                   | "md5_hash":"c9032b037693d15a33210d638c763d0e",       | tutorials/cymbal-pets/documents/          |                                 |                                    | "md5_hash":"5a1116cce4978ec1b094d8e8b49a1d7c",        |
| crittercuisine_5000_user_manual.pdf |                                |                                   | "size":566105,"updated":1742492785941000}}           | crittercuisine_5000_user_manual_page1.pdf |                                 |                                    | "size":504583,"updated":1745875761266000}}            |
|                                     |                                |                                   |                                                      +-------------------------------------------+---------------------------------+------------------------------------+-------------------------------------------------------+
|                                     |                                |                                   |                                                      | crittercuisine_5000_user_manual_page1.pdf | 1745875760613874                | myproject.region.myconnection      | {"gcs_metadata":{"content_type":"application/pdf",    |
|                                     |                                |                                   |                                                      | tutorials/cymbal-pets/documents/          |                                 |                                    | "md5_hash":"94d03ec65d28b173bc87eac7e587b325",        |
|                                     |                                |                                   |                                                      | crittercuisine_5000_user_manual_page2.pdf |                                 |                                    | "size":94622,"updated":1745875760649000}}             |
|                                     |                                |                                   |                                                      +-------------------------------------------+---------------------------------+------------------------------------+-------------------------------------------------------+
|                                     |                                |                                   |                                                      | ...                                       | ...                             |  ...                               | ...                                                   |
+-------------------------------------+--------------------------------+-----------------------------------+------------------------------------------------------+-------------------------------------------+---------------------------------+------------------------------------+-------------------------------------------------------+

Führen Sie den folgenden Code aus, um eine einzelne Antwort von einem Gemini-Modell basierend auf der Analyse eines Arrays von ObjectRef-Werten zu generieren:

SQL

WITH
  manuals AS (
    SELECT
      OBJ.GET_ACCESS_URL(manual, 'r') AS manual,
      ARRAY(
        SELECT OBJ.GET_ACCESS_URL(chunk, 'r') AS chunk
        FROM UNNEST(m1.chunks) AS chunk WITH OFFSET AS idx
        ORDER BY idx
      ) AS chunks
    FROM cymbal_pets.map_manual_to_chunks AS m1
  )
SELECT result AS Response
FROM
  AI.GENERATE_TEXT(
    MODEL `cymbal_pets.gemini`,
    (
      SELECT
        (
          'Can you provide a page by page summary for the first 3 pages of the attached manual? Only write one line for each page. The pages are provided in serial order',
          manuals.chunks) AS prompt,
      FROM manuals
    ));

BigQuery DataFrames

Richten Sie zur Authentifizierung bei BigQuery die Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter ADC für eine lokale Entwicklungsumgebung einrichten.

df_manuals_agg["chunks_url"] = bbq.array_agg(
    bbq.obj.get_access_url(df_manuals_agg.explode("chunks")["chunks"], "R").groupby(
        "uri_x"
    )
)
df_manuals_agg[
    "prompt0"
] = "Can you provide a page by page summary for the first 3 pages of the attached manual? Only write one line for each page. The pages are provided in serial order"
df_manuals_agg["prompt"] = bbq.struct(df_manuals_agg[["prompt0", "chunks_url"]])

result = bbq.ai.generate_text(gemini_model, df_manuals_agg["prompt"])["result"]
result

Die Ergebnisse sehen in etwa so aus:

+-------------------------------------------+
| Response                                  |
+-------------------------------------------+
| Page 1: This manual is for the            |
| CritterCuisine Pro 5000 automatic         |
| pet feeder.                               |
| Page 2: The manual covers safety          |
| precautions, what's included,             |
| and product overview.                     |
| Page 3: The manual covers assembly,       |
| initial setup, and programming the clock. |
+-------------------------------------------+

Führen Sie den folgenden Code aus, um basierend auf der Analyse eines Arrays von ObjectRef-Werten mehrere Antworten von einem Gemini-Modell zu generieren:

SQL

WITH
  input_chunked_objrefs AS (
    SELECT row_id, offset, chunk_ref
    FROM
      (
        SELECT ROW_NUMBER() OVER () AS row_id, * FROM `cymbal_pets.map_manual_to_chunks`
      ) AS indexed_table
    LEFT JOIN
      UNNEST(indexed_table.chunks) AS chunk_ref
      WITH OFFSET
  ),
  get_access_urls AS (
    SELECT row_id, offset, chunk_ref, OBJ.GET_ACCESS_URL(chunk_ref, 'r') AS ObjectRefRuntime
    FROM input_chunked_objrefs
  ),
  valid_get_access_urls AS (
    SELECT *
    FROM get_access_urls
    WHERE ObjectRefRuntime['runtime_errors'] IS NULL
  ),
  ordered_output_objrefruntime_array AS (
    SELECT ARRAY_AGG(ObjectRefRuntime ORDER BY offset) AS ObjectRefRuntimeArray
    FROM valid_get_access_urls
    GROUP BY row_id
  )
SELECT
  page1_summary,
  page2_summary,
  page3_summary
FROM
  AI.GENERATE_TABLE(
    MODEL `cymbal_pets.gemini`,
    (
      SELECT
        (
          'Can you provide a page by page summary for the first 3 pages of the attached manual? Only write one line for each page. The pages are provided in serial order',
          ObjectRefRuntimeArray) AS prompt,
      FROM ordered_output_objrefruntime_array
    ),
    STRUCT(
      'page1_summary STRING, page2_summary STRING, page3_summary STRING' AS output_schema));

BigQuery DataFrames

Richten Sie zur Authentifizierung bei BigQuery die Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter ADC für eine lokale Entwicklungsumgebung einrichten.

result = bbq.ai.generate_table(
    gemini_model,
    df_manuals_agg["prompt"],
    output_schema={
        "page1_summary": "STRING",
        "page2_summary": "STRING",
        "page3_summary": "STRING",
    },
)[["page1_summary", "page2_summary", "page3_summary"]]
result

Die Ergebnisse sehen in etwa so aus:

+-----------------------------------------------+-------------------------------------------+----------------------------------------------------+
| page1_summary                                 | page2_summary                             | page3_summary                                      |
+-----------------------------------------------+-------------------------------------------+----------------------------------------------------+
| This manual provides an overview of the       | This section explains how to program      | This page covers connecting the feeder to Wi-Fi    |
| CritterCuisine Pro 5000 automatic pet feeder, | the feeder's clock, set feeding           | using the CritterCuisine Connect app,  remote      |
| including its features, safety precautions,   | schedules, copy and delete meal settings, | feeding, managing feeding schedules, viewing       |
| assembly instructions, and initial setup.     | manually feed your pet, record            | feeding logs, receiving low food alerts,           |
|                                               | a voice message, and understand           | updating firmware, creating multiple pet profiles, |
|                                               | the low food level indicator.             | sharing access with other users, and cleaning      |
|                                               |                                           | and maintaining the feeder.                        |
+-----------------------------------------------+-------------------------------------------+----------------------------------------------------+

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, zum Beispiel eine appspot.com-URL, erhalten bleiben, sollten Sie ausgewählte Ressourcen innerhalb des Projekts löschen, anstatt das gesamte Projekt.

Wenn Sie mehrere Architekturen, Anleitungen und Kurzanleitungen durcharbeiten möchten, können Sie die Überschreitung von Projektkontingenten verhindern, indem Sie Projekte wiederverwenden.

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.

Multimodale Daten mit SQL und BigQuery DataFrames analysieren

Ziele

Kosten

Hinweis

Erforderliche Rollen

Einrichten

Dataset erstellen

Bucket erstellen

Verbindung herstellen

Dem Dienstkonto der Verbindung Berechtigungen gewähren

Berechtigungen für den Cloud Storage-Bucket gewähren

Berechtigungen zum Verwenden von Vertex AI-Modellen erteilen

Tabellen mit Beispieldaten erstellen

products-Tabelle erstellen

SQL

BigQuery DataFrames

product_images-Tabelle erstellen

SQL

BigQuery DataFrames

product_manuals-Tabelle erstellen

SQL

BigQuery DataFrames

Textgenerierungsmodell erstellen

SQL

BigQuery DataFrames

Modell zur Generierung von Einbettungen erstellen

SQL

BigQuery DataFrames

products_mm-Tabelle mit multimodalen Daten erstellen

SQL

BigQuery DataFrames

SQL

BigQuery DataFrames

Produktinformationen mit einem Gemini-Modell generieren

SQL

BigQuery DataFrames

SQL

BigQuery DataFrames

SQL

BigQuery DataFrames

SQL

BigQuery DataFrames

Python-UDF zum Transformieren von Produktbildern erstellen

SQL

BigQuery DataFrames

Produktbilder transformieren

SQL

BigQuery DataFrames

SQL

BigQuery DataFrames

Python-UDF zum Aufteilen von PDF-Daten in Chunks erstellen

SQL

BigQuery DataFrames

PDF-Daten analysieren

SQL

BigQuery DataFrames

SQL

BigQuery DataFrames

Einbettungen generieren und Vektorsuche ausführen

SQL

BigQuery DataFrames

SQL

BigQuery DataFrames

Geordnete multimodale Daten mit Arrays von ObjectRef-Werten verarbeiten

SQL

BigQuery DataFrames

SQL

BigQuery DataFrames

SQL

BigQuery DataFrames

SQL

BigQuery DataFrames

SQL

BigQuery DataFrames

Bereinigen

`products`-Tabelle erstellen

`product_images`-Tabelle erstellen

`product_manuals`-Tabelle erstellen

`products_mm`-Tabelle mit multimodalen Daten erstellen

Geordnete multimodale Daten mit Arrays von `ObjectRef`-Werten verarbeiten