Analizza i dati multimodali con SQL, tabelle di oggetti e BigQuery DataFrames

Questo tutorial mostra come utilizzare le query SQL, la funzione AI.GENERATE, la funzione AI.EMBED e i BigQuery DataFrames per analizzare i dati multimodali del set di dati pubblico del negozio di animali Cymbal.

La funzione AI.GENERATE consente di analizzare qualsiasi combinazione di dati strutturati e non strutturati, mentre la funzione AI.EMBED consente di creare embedding da dati di testo o immagine in BigQuery.

Puoi trovare immagini simili utilizzando la funzione VECTOR_SEARCH. La funzione VECTOR_SEARCH consente di eseguire una ricerca semantica o una ricerca ibrida sugli embedding per trovare entità simili.

Questo tutorial utilizza una tabella di oggetti permanente che archivia i valori ObjectRef.

Obiettivi

• Utilizza i valori ObjectRef per archiviare i dati delle immagini insieme ai dati strutturati in una tabella BigQuery.
• Utilizza la funzione AI.GENERATE per arricchire i dati.
• Utilizza la funzione AI.EMBED per generare embedding in base ai dati delle immagini.
• Utilizza la funzione VECTOR_SEARCH per trovare immagini simili.
• Utilizza array di valori ObjectRef per riassumere i manuali dell'utente.

Costi

In questo documento vengono utilizzati i seguenti componenti fatturabili di Google Cloud:

• BigQuery: you incur costs for the data that you process in BigQuery.
• Cloud Storage: you incur costs for reading the objects stored in Cloud Storage.
• Gemini Enterprise Agent Platform: you incur costs for calls to Agent Platform models.

Per generare una stima dei costi in base all'utilizzo previsto, utilizza il Calcolatore prezzi.

I nuovi utenti di Google Cloud potrebbero avere diritto a una prova senza costi.

Per saperne di più sui costi, consulta le seguenti pagine dei prezzi:

• Prezzi di BigQuery
• Prezzi di Cloud Storage
• Prezzi di Agent Platform

Prima di iniziare

1. Nella console Google Cloud , nella pagina di selezione del progetto, seleziona o crea un progetto Google Cloud .

   Ruoli richiesti per selezionare o creare un progetto

   • Seleziona un progetto: la selezione di un progetto non richiede un ruolo IAM specifico. Puoi selezionare qualsiasi progetto per cui ti è stato concesso un ruolo.
   • Crea un progetto: per creare un progetto, devi disporre del ruolo Autore progetto (roles/resourcemanager.projectCreator), che contiene l'autorizzazione resourcemanager.projects.create. Scopri come concedere i ruoli.
   Nota: se non prevedi di conservare le risorse che crei in questa procedura, crea un progetto invece di selezionarne uno già esistente. Una volta completata questa procedura, puoi eliminare il progetto e tutte le relative risorse.

   Vai al selettore di progetti

2. Verifica che la fatturazione sia attivata per il tuo progetto Google Cloud .

3. Abilita le API BigQuery, BigQuery Connection, Cloud Storage e Agent Platform, se non sono già abilitate.

   Ruoli richiesti per abilitare le API

   Per abilitare le API, devi disporre dell'autorizzazione serviceusage.services.enable. Se hai creato il progetto, probabilmente disponi già di questa autorizzazione tramite il ruolo Proprietario (roles/owner). In caso contrario, puoi ottenere questa autorizzazione tramite il ruolo Amministratore Service Usage (roles/serviceusage.serviceUsageAdmin). Scopri come concedere i ruoli.

   Abilita le API

Ruoli obbligatori

Per ottenere le autorizzazioni necessarie per completare questo tutorial, chiedi all'amministratore di concederti i seguenti ruoli IAM:

• Creare set di dati e tabelle: BigQuery Data Owner (roles/bigquery.dataOwner)
• Eseguire job BigQuery: Utente job BigQuery (roles/bigquery.jobUser)
• Creare connessioni: BigQuery Connection Admin (roles/bigquery.connectionAdmin)
• Concedi le autorizzazioni al account di servizio di una connessione: Project IAM Admin (roles/resourcemanager.projectIamAdmin)
• Crea URL che ti consentono di leggere e modificare gli oggetti Cloud Storage: BigQuery ObjectRef Admin (roles/bigquery.objectRefAdmin)

Per saperne di più sulla concessione dei ruoli, consulta Gestisci l'accesso a progetti, cartelle e organizzazioni.

Potresti anche riuscire a ottenere le autorizzazioni richieste tramite i ruoli personalizzati o altri ruoli predefiniti.

Crea il set di dati, le tabelle, i modelli e la connessione

In questa sezione creerai il set di dati, la connessione, le tabelle e i modelli utilizzati in questo tutorial.

Crea un set di dati

Crea un set di dati BigQuery per contenere gli oggetti che crei in questo tutorial scegliendo una delle seguenti opzioni:

Console

1. Nella console Google Cloud , vai alla pagina BigQuery.

   Vai a BigQuery

2. Nel riquadro a sinistra, fai clic su Explorer:

   

   Se non vedi il riquadro a sinistra, fai clic su Espandi riquadro sinistro per aprirlo.

3. In Explorer, espandi il progetto e fai clic su Set di dati.

4. Nella pagina Set di dati, fai clic su Crea set di dati.

5. Nella pagina Crea set di dati, segui questi passaggi:

   1. In ID set di dati, inserisci cymbal_pets.

   2. Per Località dei dati, seleziona USA.

   3. Lascia invariate le restanti impostazioni predefinite e fai clic su Crea set di dati.

SQL

Utilizza l'istruzione CREATE SCHEMA.

1. Nella console Google Cloud , vai alla pagina BigQuery.

   Vai a BigQuery

2. Nell'editor di query, inserisci la seguente istruzione:

   CREATE SCHEMA PROJECT_ID.cymbal_pets
     OPTIONS (
       description = 'Dataset for BigQuery ML tutorial',
       location = 'US');

   Sostituisci PROJECT_ID con l'ID progetto.

3. Fai clic su Esegui.

Per saperne di più su come eseguire le query, consulta Esegui una query interattiva.

Riceverai un messaggio di conferma simile al seguente: The dataset named cymbal_pets was created.

Crea una connessione

Crea una connessione alle risorse Cloud e ottieni il account di servizio della connessione. BigQuery utilizza la connessione per accedere agli oggetti in Cloud Storage.

1. Nel riquadro a sinistra, fai clic su Explorer:

   

2. Nel riquadro Explorer, fai clic su Connessioni.

3. Nella pagina Connessioni, fai clic su Crea connessione.

4. Nella pagina Origine dati esterna, segui questi passaggi:

   1. In Tipo di connessione, scegli Modelli remoti di Vertex AI, funzioni remote, Lakehouse e Spanner (risorsa Cloud).

   2. Nel campo ID connessione, digita cymbal_conn.

   3. Lascia invariate le altre impostazioni, quindi fai clic su Crea connessione.

5. Nella pagina Connessioni, fai clic su cymbal_conn.

6. Nel riquadro Informazioni sulla connessione, copia il valore ID account di servizio. È necessario per i passaggi successivi.

Concedi le autorizzazioni per utilizzare i modelli Agent Platform

Concedi al account di servizio della connessione il ruolo Utente Agent Platform per accedere ai modelli remoti in Agent Platform. Devi concedere questo ruolo nello stesso progetto che hai creato o selezionato in precedenza. La concessione dei ruoli in un progetto diverso genera l'errore [e-mail] does not have the permission to access resource.

Per concedere al account di servizio l'accesso per utilizzare i modelli della piattaforma Agent, segui questi passaggi:

1. Vai alla pagina IAM e amministrazione.

   Vai a IAM e amministrazione

2. Fai clic su Concedi l'accesso.

3. Nella finestra di dialogo Concedi l'accesso, segui questi passaggi:

   1. Nel campo Nuove entità, inserisci l'ID del account di servizio che hai copiato in precedenza.

   2. Nel campo Seleziona un ruolo, scegli o cerca Utente della piattaforma agente.

   3. Fai clic su Salva.

Crea la tabella products

Per creare una tabella standard contenente le informazioni sui prodotti Cymbal Pets, segui questi passaggi per caricare i dati da Cloud Storage:

1. Nella console Google Cloud , vai alla pagina Studio.

   Vai a Studio

2. Per creare la tabella products, scegli una delle seguenti opzioni:

   SQL

   Incolla questo comando nell'editor di query, quindi fai clic su Esegui:

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

   Riceverai un messaggio di conferma simile al seguente: Data was successfully loaded into managed table.

   BigQuery DataFrames

   Prima di provare questo esempio, segui le istruzioni di configurazione di BigQuery DataFrames nella guida rapida di BigQuery per l'utilizzo di BigQuery DataFrames. Per ulteriori informazioni, consulta la documentazione di riferimento di BigQuery DataFrames.

   Per eseguire l'autenticazione in BigQuery, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configura ADC per un ambiente di sviluppo locale.

   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"
           ],
       },
   )

   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"
           ],
       },
   )

Crea la tabella product_images

Per creare una tabella di oggetti (product_images) contenente le immagini dei prodotti Cymbal Pets, seleziona una delle seguenti opzioni:

SQL

Incolla questo comando nell'editor di query, quindi fai clic su Esegui:

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);

Riceverai un messaggio di conferma simile al seguente: This statement created a new table named product_images.

BigQuery DataFrames

Prima di provare questo esempio, segui le istruzioni di configurazione di BigQuery DataFrames nella guida rapida di BigQuery per l'utilizzo di BigQuery DataFrames. Per ulteriori informazioni, consulta la documentazione di riferimento di BigQuery DataFrames.

Per eseguire l'autenticazione in BigQuery, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configura ADC per un ambiente di sviluppo locale.

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"
        ],
    },
)

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"
        ],
    },
)

Creazione modelli

Le istruzioni SQL in questo tutorial mostrano come chiamare funzioni AI che non richiedono la creazione di un modello. Se segui le istruzioni di BigQuery DataFrames, seleziona questa opzione per creare modelli remoti che rappresentano un modello Gemini e un modello di embedding multimodale.

SQL

Puoi saltare questo passaggio.

BigQuery DataFrames

Prima di provare questo esempio, segui le istruzioni di configurazione di BigQuery DataFrames nella guida rapida di BigQuery per l'utilizzo di BigQuery DataFrames. Per ulteriori informazioni, consulta la documentazione di riferimento di BigQuery DataFrames.

Per eseguire l'autenticazione in BigQuery, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configura ADC per un ambiente di sviluppo locale.

gemini_model = bbq.ml.create_model(
    "cymbal_pets.gemini",
    replace=True,
    connection_name="us.cymbal_conn",
    options={"endpoint": "gemini-3.5-flash"},
)

gemini_model = bbq.ml.create_model(
    "cymbal_pets.gemini",
    replace=True,
    connection_name="us.cymbal_conn",
    options={"endpoint": "gemini-3.5-flash"},
)

embedding_model = bbq.ml.create_model(
    "cymbal_pets.embedding_model",
    replace=True,
    connection_name="us.cymbal_conn",
    options={"endpoint": "gemini-embedding-2"},
)

embedding_model = bbq.ml.create_model(
    "cymbal_pets.embedding_model",
    replace=True,
    connection_name="us.cymbal_conn",
    options={"endpoint": "gemini-embedding-2"},
)

Crea una tabella products_mm con dati multimodali

Crea una tabella products_mm che contiene una colonna image compilata con le immagini dei prodotti della tabella degli oggetti product_images. La colonna image creata è una colonna STRUCT che utilizza i valori ObjectRef per archiviare i dati delle immagini insieme ai dati strutturati in una tabella standard di BigQuery.

Un valore ObjectRef è un tipo STRUCT con uno schema predefinito che fa riferimento agli oggetti Cloud Storage per l'analisi multimodale. I valori ObjectRef possono essere elaborati da funzioni OBJ, funzioni AI o funzioni definite dall'utente Python.

Per creare e compilare la tabella products_mm, segui questi passaggi:

1. Per creare una tabella products_mm, scegli una delle seguenti opzioni:

   SQL

   Incolla questo comando nell'editor di query, quindi fai clic su Esegui:

   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;

   Riceverai un messaggio di conferma simile al seguente: This statement created a new table named products_mm.

   BigQuery DataFrames

   Prima di provare questo esempio, segui le istruzioni di configurazione di BigQuery DataFrames nella guida rapida di BigQuery per l'utilizzo di BigQuery DataFrames. Per ulteriori informazioni, consulta la documentazione di riferimento di BigQuery DataFrames.

   Per eseguire l'autenticazione in BigQuery, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configura ADC per un ambiente di sviluppo locale.

   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"})

   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"})

2. Per visualizzare i dati della colonna image, scegli una delle seguenti opzioni:

   SQL

   Incolla questo comando nell'editor di query, quindi fai clic su Esegui:

   SELECT product_name, image
   FROM cymbal_pets.products_mm

   BigQuery DataFrames

   Prima di provare questo esempio, segui le istruzioni di configurazione di BigQuery DataFrames nella guida rapida di BigQuery per l'utilizzo di BigQuery DataFrames. Per ulteriori informazioni, consulta la documentazione di riferimento di BigQuery DataFrames.

   Per eseguire l'autenticazione in BigQuery, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configura ADC per un ambiente di sviluppo locale.

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

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

   I risultati sono simili ai seguenti:

   +--------------------------------+--------------------------------------+---------------+-------------------------------+------------------------------------------------+
   | 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}}     |
   +--------------------------------+--------------------------------------+---------------+-------------------------------+------------------------------------------------+
   | ...                            | ...                                  | ...           |                               | ...                                            |
   +--------------------------------+--------------------------------------+---------------+-------------------------------+------------------------------------------------+
   

Genera informazioni sul prodotto

Utilizza la funzione AI.GENERATE per generare i seguenti dati per i prodotti del negozio di animali:

• Aggiungi una colonna image_description alla tabella products_mm.
• Compila le colonne animal_type, search_keywords e subcategory della tabella products_mm.
• Esegui una query che restituisca una descrizione di ogni brand di prodotto e un conteggio del numero di prodotti di quel brand. La descrizione del brand viene generata analizzando le informazioni sul prodotto per tutti i prodotti di quel brand, incluse le immagini dei prodotti.

Con la funzione AI.GENERATE, puoi scegliere di generare testo o output strutturato in base a uno schema personalizzato che specifichi. La funzione invia richieste a un modello Gemini e restituisce una struttura che contiene i dati generati, la risposta completa del modello e uno stato.

Per generare i dati di prodotto, segui questi passaggi:

1. Per generare le informazioni sul prodotto utilizzando AI.GENERATE, scegli una delle seguenti opzioni:

   SQL

   Per creare e compilare la colonna image_description, incolla quanto segue nell'editor di query, quindi fai clic su Esegui:

   -- Add the column to the existing table
   ALTER TABLE bqml_tutorial.products_mm
   ADD COLUMN IF NOT EXISTS image_description STRING;
   
   -- Populate the new column using the AI.GENERATE function
   UPDATE bqml_tutorial.products_mm
   SET image_description = AI.GENERATE(
   ('Describe the following image: ', image),
   endpoint => 'gemini-3.5-flash'
   ).result
   WHERE image_description IS NULL;

   Riceverai un messaggio di conferma simile al seguente: This statement altered the table named products_mm.

   BigQuery DataFrames

   Prima di provare questo esempio, segui le istruzioni di configurazione di BigQuery DataFrames nella guida rapida di BigQuery per l'utilizzo di BigQuery DataFrames. Per ulteriori informazioni, consulta la documentazione di riferimento di BigQuery DataFrames.

   Per eseguire l'autenticazione in BigQuery, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configura ADC per un ambiente di sviluppo locale.

   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",
       ]
   ]

   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",
       ]
   ]

2. Per visualizzare i contenuti della colonna image_description, incolla quanto segue nell'editor di query, quindi fai clic su Esegui:

   SELECT product_name, image_description
   FROM cymbal_pets.products_mm;

   I risultati sono simili ai seguenti:

   +--------------------------------+-------------------------------------+
   | product_name                   | image_description                   |
   +--------------------------------+-------------------------------------+
   |  AquaClear Aquarium Background | The image shows a colorful coral    |
   |                                | reef backdrop. The background is a  |
   |                                | blue ocean with a bright light...   |
   |                                |                                     |
   |                                |                                     |
   +--------------------------------+-------------------------------------+
   |  AquaClear Aquarium            | The image shows a long, clear       |
   |  Gravel Vacuum                 | plastic tube with a green hose      |
   |                                | attached to one end. The tube...    |
   |                                |                                     |
   |                                |                                     |
   +--------------------------------+-------------------------------------+
   | ...                            | ...                                 |
   +--------------------------------+-------------------------------------+
   

3. Per aggiornare le colonne animal_type, search_keywords e subcategory con i dati generati, scegli una delle seguenti opzioni:

   SQL

   Incolla quanto segue nell'editor di query, quindi fai clic su Esegui:

   UPDATE cymbal_pets.products_mm t
   SET
   animal_type = r.animal_type,
   search_keywords = SPLIT(r.search_keywords, ','),
   subcategory = r.subcategory
   FROM (
   SELECT
     product_id,
     g.* EXCEPT(full_response, status)
   FROM bqml_tutorial.products_mm,
   UNNEST([AI.GENERATE(
     ('For the image and description of a pet product, concisely generate the following metadata: 1) animal_type and 2) 5 SEO search keywords (comma separated), and 3) product subcategory. ', image, description),
     endpoint => 'gemini-3.5-flash',
     output_schema => 'animal_type STRING, search_keywords STRING, subcategory STRING'
   )]) AS g
   ) r
   WHERE t.product_id = r.product_id;

   Riceverai un messaggio di conferma simile al seguente: This statement modified 205 rows in products_mm.

   BigQuery DataFrames

   Prima di provare questo esempio, segui le istruzioni di configurazione di BigQuery DataFrames nella guida rapida di BigQuery per l'utilizzo di BigQuery DataFrames. Per ulteriori informazioni, consulta la documentazione di riferimento di BigQuery DataFrames.

   Per eseguire l'autenticazione in BigQuery, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configura ADC per un ambiente di sviluppo locale.

   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",
   )

   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",
   )

4. Per visualizzare i dati generati, scegli una delle seguenti opzioni:

   SQL

   Incolla quanto segue nell'editor di query, quindi fai clic su Esegui:

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

   BigQuery DataFrames

   Prima di provare questo esempio, segui le istruzioni di configurazione di BigQuery DataFrames nella guida rapida di BigQuery per l'utilizzo di BigQuery DataFrames. Per ulteriori informazioni, consulta la documentazione di riferimento di BigQuery DataFrames.

   Per eseguire l'autenticazione in BigQuery, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configura ADC per un ambiente di sviluppo locale.

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

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

   I risultati sono simili ai seguenti:

   +--------------------------------+-------------------------------------+-------------+------------------------+------------------+
   | 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          |                  |
   +--------------------------------+-------------------------------------+-------------+------------------------+------------------+
   | ...                            | ...                                 | ...         |  ...                   | ...              |
   +--------------------------------+-------------------------------------+-------------+------------------------+------------------+
   

5. Per generare una descrizione di ogni brand di prodotto e un conteggio del numero di prodotti di quel brand, scegli una delle seguenti opzioni:

   SQL

   Incolla quanto segue nell'editor di query, quindi fai clic su Esegui:

   SELECT
   brand,
   COUNT(*) AS cnt,
   AI.GENERATE(('Use the images and text to give one concise brand description ',
               'for a website brand page. Return the description only.',
                 ARRAY_AGG(image LIMIT 10), ARRAY_AGG(description), ARRAY_AGG(category),
                 ARRAY_AGG(subcategory)),
               endpoint => 'gemini-2.5-pro').result AS brand_description
   FROM
   cymbal_pets.products_mm
   GROUP BY brand
   ORDER BY cnt DESC;

   BigQuery DataFrames

   Prima di provare questo esempio, segui le istruzioni di configurazione di BigQuery DataFrames nella guida rapida di BigQuery per l'utilizzo di BigQuery DataFrames. Per ulteriori informazioni, consulta la documentazione di riferimento di BigQuery DataFrames.

   Per eseguire l'autenticazione in BigQuery, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configura ADC per un ambiente di sviluppo locale.

   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"]]

   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"]]

   I risultati sono simili ai seguenti:

   +--------------+-------------------------------------+-----+
   | 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.. |     |
   +--------------+-------------------------------------+-----+
   |  ...         | ...                                 |...  |
   +--------------+-------------------------------------+-----+
   

Genera gli embedding ed esegui una ricerca vettoriale

Genera embedding dai dati delle immagini, quindi utilizzali per restituire immagini simili utilizzando la ricerca vettoriale.

In uno scenario di produzione, ti consigliamo di creare un indice vettoriale prima di eseguire una ricerca vettoriale. Un indice vettoriale consente di eseguire la ricerca vettoriale più rapidamente e restituisce risultati più approssimativi, ma il richiamo è ridotto.

Per creare gli embedding ed eseguire una ricerca vettoriale, segui questi passaggi:

1. Per creare la tabella products_embeddings, scegli una delle seguenti opzioni:

   SQL

   Incolla quanto segue nell'editor di query, quindi fai clic su Esegui:

   CREATE OR REPLACE TABLE cymbal_pets.products_embedding
   AS (
   SELECT
     product_id,
     AI.EMBED(image, endpoint => 'gemini-embedding-2').result AS embedding,
     image
   FROM cymbal_pets.products_mm
   );

   Riceverai un messaggio di conferma simile al seguente: This statement created a new table named products_embedding.

   BigQuery DataFrames

   Prima di provare questo esempio, segui le istruzioni di configurazione di BigQuery DataFrames nella guida rapida di BigQuery per l'utilizzo di BigQuery DataFrames. Per ulteriori informazioni, consulta la documentazione di riferimento di BigQuery DataFrames.

   Per eseguire l'autenticazione in BigQuery, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configura ADC per un ambiente di sviluppo locale.

   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")

   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")

2. Per eseguire una Vector Search che restituisca immagini di prodotti simili all'immagine di input fornita, scegli una delle seguenti opzioni:

   SQL

   Incolla quanto segue nell'editor di query, quindi fai clic su Esegui:

   SELECT *
   FROM
   VECTOR_SEARCH(
     TABLE cymbal_pets.products_embedding,
     'embedding',
     query_value => AI.EMBED(
                     OBJ.MAKE_REF('gs://cloud-samples-data/bigquery/tutorials/cymbal-pets/images/cozy-naps-cat-scratching-post-with-condo.png'),
                     endpoint => 'gemini-embedding-2').result);

   BigQuery DataFrames

   Prima di provare questo esempio, segui le istruzioni di configurazione di BigQuery DataFrames nella guida rapida di BigQuery per l'utilizzo di BigQuery DataFrames. Per ulteriori informazioni, consulta la documentazione di riferimento di BigQuery DataFrames.

   Per eseguire l'autenticazione in BigQuery, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configura ADC per un ambiente di sviluppo locale.

   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

   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

   I risultati sono simili ai seguenti:

   +-----------------+-----------------+----------------+----------------------------------------------+--------------------+-------------------------------+------------------------------------------------+----------------+
   | 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  |                                              |                    |                               |                                                |                |
   | ...             |                 |  ...           |                                              |                    |                               |                                                |                |
   |                 |                 |                |                                              |                    |                               |                                                |                |
   |                 |                 |                |                                              |                    |                               |                                                |                |
   +-----------------+-----------------+----------------+----------------------------------------------+--------------------+-------------------------------+------------------------------------------------+----------------+
   | ...             | ...             | ...            | ...                                          | ...                | ...                           | ...                                            | ...            |
   +-----------------+-----------------+----------------+----------------------------------------------+--------------------+-------------------------------+------------------------------------------------+----------------+
   

Elabora dati multimodali ordinati utilizzando array di valori ObjectRef

Questa sezione mostra come riassumere i manuali dell'utente elaborando dati multimodali ordinati utilizzando array di valori ObjectRef. BigQuery può analizzare più file non strutturati contemporaneamente utilizzando gli array.

Completerai le seguenti attività:

1. Crea la tabella product_manuals in modo che contenga sia un file PDF per il manuale del prodotto Crittercuisine Pro 5000 sia file PDF per ogni pagina del manuale.

2. Crea una tabella che mappa il manuale ai relativi segmenti. Il manuale completo e le pagine del manuale sono archiviati ciascuno in una colonna ObjectRef.

3. Analizza un array di valori ObjectRef insieme per restituire un singolo valore generato.

4. Analizza separatamente un array di valori ObjectRef e restituisce un valore generato per ogni valore dell'array.

Per elaborare i dati multimodali ordinati utilizzando i valori ObjectRef, segui questi passaggi:

1. Per creare la tabella product_manuals, scegli una delle seguenti opzioni:

   SQL

   Incolla quanto segue nell'editor di query, quindi fai clic su Esegui:

   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']);

   Riceverai un messaggio di conferma simile al seguente: This statement created a new table named product_manuals.

   BigQuery DataFrames

   Prima di provare questo esempio, segui le istruzioni di configurazione di BigQuery DataFrames nella guida rapida di BigQuery per l'utilizzo di BigQuery DataFrames. Per ulteriori informazioni, consulta la documentazione di riferimento di BigQuery DataFrames.

   Per eseguire l'autenticazione in BigQuery, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configura ADC per un ambiente di sviluppo locale.

   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",
           ],
       },
   )

   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",
           ],
       },
   )

2. Per scrivere i dati PDF nella tabella map_manual_to_chunks, scegli una delle seguenti opzioni:

   SQL

   Incolla quanto segue nell'editor di query, quindi fai clic su Esegui:

   -- 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;

   Riceverai un messaggio di conferma simile al seguente: This statement created a new table named map_manual_to_chunks.

   BigQuery DataFrames

   Prima di provare questo esempio, segui le istruzioni di configurazione di BigQuery DataFrames nella guida rapida di BigQuery per l'utilizzo di BigQuery DataFrames. Per ulteriori informazioni, consulta la documentazione di riferimento di BigQuery DataFrames.

   Per eseguire l'autenticazione in BigQuery, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configura ADC per un ambiente di sviluppo locale.

   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"]

   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"]

3. Per visualizzare i dati del PDF nella tabella map_manual_to_chunks, scegli una delle seguenti opzioni:

   SQL

   Incolla quanto segue nell'editor di query, quindi fai clic su Esegui:

   SELECT *
   FROM cymbal_pets.map_manual_to_chunks;

   BigQuery DataFrames

   Prima di provare questo esempio, segui le istruzioni di configurazione di BigQuery DataFrames nella guida rapida di BigQuery per l'utilizzo di BigQuery DataFrames. Per ulteriori informazioni, consulta la documentazione di riferimento di BigQuery DataFrames.

   Per eseguire l'autenticazione in BigQuery, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configura ADC per un ambiente di sviluppo locale.

   df_manuals_agg

   df_manuals_agg

   I risultati sono simili ai seguenti:

   +-------------------------------------+--------------------------------+-----------------------------------+------------------------------------------------------+-------------------------------------------+---------------------------------+------------------------------------+-------------------------------------------------------+
   | 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}}             |
   |                                     |                                |                                   |                                                      +-------------------------------------------+---------------------------------+------------------------------------+-------------------------------------------------------+
   |                                     |                                |                                   |                                                      | ...                                       | ...                             |  ...                               | ...                                                   |
   +-------------------------------------+--------------------------------+-----------------------------------+------------------------------------------------------+-------------------------------------------+---------------------------------+------------------------------------+-------------------------------------------------------+
   

4. Per generare una singola risposta da un modello Gemini in base all'analisi di un array di valori ObjectRef, scegli una delle seguenti opzioni:

   SQL

   Incolla quanto segue nell'editor di query, quindi fai clic su Esegui:

   SELECT
   AI.GENERATE((
     '''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''',
     chunks),
     endpoint => 'gemini-3.5-flash').result AS Response,
   FROM cymbal_pets.map_manual_to_chunks;

   BigQuery DataFrames

   Prima di provare questo esempio, segui le istruzioni di configurazione di BigQuery DataFrames nella guida rapida di BigQuery per l'utilizzo di BigQuery DataFrames. Per ulteriori informazioni, consulta la documentazione di riferimento di BigQuery DataFrames.

   Per eseguire l'autenticazione in BigQuery, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configura ADC per un ambiente di sviluppo locale.

   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

   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

   I risultati sono simili ai seguenti:

   +---------------------------------------------------------------------------+
   | Response                                                                  |
   +---------------------------------------------------------------------------+
   | Here is a one-line summary for each of the first 3 pages:                 |
   |                                                                           |
   | Page 1 introduces the CritterCuisine Pro 5000 automatic pet feeder and    |
   | presents the initial part of the manual's Table of Contents.              |
   | Page 2 lists the items included with the feeder and details important     |
   | safety precautions for its use.                                           |
   | Page 3 describes the feeder's key features, provides assembly and initial |
   | setup instructions, and begins the programming guide with clock setting.  |
   +---------------------------------------------------------------------------+
   

5. Per generare più risposte da un modello Gemini in base all'analisi di un array di valori ObjectRef, scegli una delle seguenti opzioni:

   SQL

   Incolla quanto segue nell'editor di query, quindi fai clic su Esegui:

   WITH results AS (
   SELECT
     AI.GENERATE((
       '''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''',
       chunks),
       endpoint => 'gemini-3.5-flash',
       output_schema =>  'page1_summary STRING, page2_summary STRING, page3_summary STRING').*
   FROM cymbal_pets.map_manual_to_chunks)
   SELECT page1_summary, page2_summary, page3_summary
   FROM results;

   BigQuery DataFrames

   Prima di provare questo esempio, segui le istruzioni di configurazione di BigQuery DataFrames nella guida rapida di BigQuery per l'utilizzo di BigQuery DataFrames. Per ulteriori informazioni, consulta la documentazione di riferimento di BigQuery DataFrames.

   Per eseguire l'autenticazione in BigQuery, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configura ADC per un ambiente di sviluppo locale.

   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

   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

   I risultati sono simili ai seguenti:

   +-----------------------------------------------+-------------------------------------------+----------------------------------------------------+
   | 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.                        |
   +-----------------------------------------------+-------------------------------------------+----------------------------------------------------+
   

Esegui la pulizia

Per evitare che al tuo account Google Cloud vengano addebitati costi relativi alle risorse utilizzate in questo tutorial, elimina il progetto che contiene le risorse oppure mantieni il progetto ed elimina le singole risorse.

Attenzione: l'eliminazione di un progetto ha i seguenti effetti:

• L'intero contenuto del progetto viene eliminato. Se hai utilizzato un progetto esistente per, le attività descritte in questo documento, eliminerai anche tutto il lavoro che hai svolto nel progetto.
• Gli ID progetto personalizzati non sono più disponibili. Quando hai creato questo progetto, potresti aver creato un ID progetto personalizzato che vuoi utilizzare in futuro. Per conservare gli URL che utilizzano l'ID progetto, ad esempio un URL appspot.com, elimina le risorse selezionate all'interno del progetto anziché eliminare l'intero progetto.

Se intendi esplorare più architetture, tutorial o guide rapide, puoi riutilizzare i progetti ed evitare così di superare i limiti di quota.

1. Nella console Google Cloud , vai alla pagina Gestisci risorse.

   Vai a Gestisci risorse

2. Nell'elenco dei progetti, seleziona il progetto che vuoi eliminare, quindi fai clic su Elimina.
3. Nella finestra di dialogo, digita l'ID progetto, quindi fai clic su Chiudi per eliminare il progetto.

In alternativa, per conservare il progetto ed eliminare le risorse utilizzate in questo tutorial, segui questi passaggi:

1. Vai alla pagina BigQuery.

   Vai a BigQuery

2. Nel riquadro a sinistra, espandi il progetto e fai clic su Set di dati.

3. Per il set di dati bqml_tutorial, fai clic su Apri azioni > Elimina.

4. Nella finestra di dialogo Elimina set di dati, fai clic su Elimina per confermare.

5. Nel riquadro a sinistra, fai clic su Connessioni.

6. Per la connessione cymbal_conn, fai clic su Apri azioni > Elimina.

7. Nella finestra di dialogo Elimina connessione, inserisci delete e fai clic su Elimina per confermare.

Passaggi successivi

• Per ulteriori informazioni sull'utilizzo dei dati multimodali, consulta Analizza i dati multimodali in BigQuery.
• Per ulteriori informazioni sui valori ObjectRef, consulta Utilizza i valori ObjectRef.