Google utilizza la tecnologia AI per tradurre i contenuti nella tua lingua preferita. Le traduzioni generate dall'AI potrebbero contenere errori.

Genera embedding video utilizzando la funzione AI.GENERATE_EMBEDDING

Questo documento mostra come creare un modello remoto BigQuery ML che fa riferimento a un modello di base di embedding di Gemini Enterprise Agent Platform. Quindi devi utilizzare il modello con la funzione AI.GENERATE_EMBEDDING per creare embedding di video utilizzando i dati di una tabella di oggetti BigQuery.

Ruoli obbligatori

Per creare un modello remoto e generare embedding, devi disporre dei seguenti ruoli Identity and Access Management (IAM):

Creare e utilizzare set di dati, tabelle e modelli BigQuery: BigQuery Data Editor (roles/bigquery.dataEditor) nel progetto.
Creare, delegare e utilizzare le connessioni BigQuery: BigQuery Connections Admin (roles/bigquery.connectionsAdmin) sul tuo progetto.

Se non hai configurato una connessione predefinita, puoi crearne e impostarne una durante l'esecuzione dell'istruzione CREATE MODEL. Per farlo, devi disporre del ruolo Amministratore BigQuery (roles/bigquery.admin) nel tuo progetto. Per saperne di più, consulta Configura la connessione predefinita.
Concedi le autorizzazioni al account di servizio della connessione: Project IAM Admin (roles/resourcemanager.projectIamAdmin) sul progetto che contiene l'endpoint della piattaforma Gemini Enterprise Agent. Questo è il progetto attuale per i modelli remoti che crei specificando il nome del modello come endpoint. Questo è il progetto identificato nell'URL per i modelli remoti che crei specificando un URL come endpoint.

Se utilizzi il modello remoto per analizzare i dati non strutturati di una tabella di oggetti e il bucket Cloud Storage che utilizzi nella tabella di oggetti si trova in un progetto diverso da quello dell'endpoint della piattaforma agente, devi disporre anche del ruolo Storage Admin (roles/storage.admin) sul bucket Cloud Storage utilizzato dalla tabella di oggetti.
Creare job BigQuery: Utente job BigQuery (roles/bigquery.jobUser) nel progetto.

Questi ruoli predefiniti contengono le autorizzazioni necessarie per eseguire le attività descritte in questo documento. Per vedere quali sono esattamente le autorizzazioni richieste, espandi la sezione Autorizzazioni obbligatorie:

Autorizzazioni obbligatorie

Crea un set di dati: bigquery.datasets.create
Crea, delega e utilizza una connessione: bigquery.connections.*
Imposta le autorizzazioni del account di servizio: resourcemanager.projects.getIamPolicy e resourcemanager.projects.setIamPolicy
Crea una tabella di oggetti: bigquery.tables.create e bigquery.tables.update
Crea un modello ed esegui l'inferenza:
- bigquery.jobs.create
- bigquery.models.create
- bigquery.models.getData
- bigquery.models.updateData
- bigquery.models.updateMetadata

Potresti anche ottenere queste autorizzazioni con ruoli personalizzati o altri ruoli predefiniti.

Prima di iniziare

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
Verifica che la fatturazione sia attivata per il tuo progetto Google Cloud .
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 hai già 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

Crea un set di dati

Crea un set di dati BigQuery per contenere le tue risorse:

Console

Nella console Google Cloud , vai alla pagina BigQuery.

Vai a BigQuery
Nel riquadro a sinistra, fai clic su Spazio di esplorazione:

Se non vedi il riquadro a sinistra, fai clic su Espandi riquadro sinistro per aprirlo.
Nel riquadro Explorer, fai clic sul nome del progetto.
Fai clic su Visualizza azioni > Crea set di dati.
Nella pagina Crea set di dati, segui questi passaggi:
1. In ID set di dati, digita un nome per il set di dati.
2. Per Tipo di località, seleziona Regione o Multi-regione.
  - Se hai selezionato Regione, seleziona una località dall'elenco Regione.
  - Se hai selezionato Multiregione, seleziona Stati Uniti o Europa dall'elenco Multiregione.
3. Fai clic su Crea set di dati.

bq

Per creare un nuovo set di dati, utilizza il comando bq mk con il flag --location:
```
bq --location=LOCATION mk -d DATASET_ID
```
Sostituisci quanto segue:
- LOCATION: la località del set di dati.
- DATASET_ID: l'ID del set di dati che stai creando.
Verifica che il set di dati sia stato creato:
```
bq ls
```

Crea una connessione

Crea una connessione alle risorse Cloud e ottieni il account di servizio della connessione. Crea la connessione nella stessa località del set di dati creato nel passaggio precedente.

Puoi saltare questo passaggio se hai configurato una connessione predefinita o se hai il ruolo Amministratore BigQuery.

Seleziona una delle seguenti opzioni:

Console

Vai alla pagina BigQuery.

Vai a BigQuery
Nel riquadro a sinistra, fai clic su Explorer:

Se non vedi il riquadro a sinistra, fai clic su Espandi riquadro sinistro per aprirlo.
Nel riquadro Explorer, espandi il nome del progetto, quindi fai clic su Connessioni.
Nella pagina Connessioni, fai clic su Crea connessione.
In Tipo di connessione, scegli Modelli remoti di Vertex AI, funzioni remote, BigLake e Spanner (risorsa Cloud).
Nel campo ID connessione, inserisci un nome per la connessione.
In Tipo di località, seleziona una località per la connessione. La connessione deve essere collocata insieme alle altre risorse, ad esempio i set di dati.
Fai clic su Crea connessione.
Fai clic su Vai alla connessione.
Nel riquadro Informazioni sulla connessione, copia l'ID account di servizio da utilizzare in un passaggio successivo.

SQL

Utilizza l'istruzione CREATE CONNECTION:

Nella console Google Cloud , vai alla pagina BigQuery.

Vai a BigQuery
Nell'editor di query, inserisci la seguente istruzione:
```
CREATE CONNECTION [IF NOT EXISTS] `CONNECTION_NAME`
OPTIONS (
  connection_type = "CLOUD_RESOURCE",
  friendly_name = "FRIENDLY_NAME",
  description = "DESCRIPTION"
  );
```
Sostituisci quanto segue:
- CONNECTION_NAME: il nome della connessione nel formato PROJECT_ID.LOCATION.CONNECTION_ID, LOCATION.CONNECTION_ID o CONNECTION_ID. Se il progetto o la località vengono omessi, vengono dedotti dal progetto e dalla località in cui viene eseguita l'istruzione.
- FRIENDLY_NAME (facoltativo): un nome descrittivo per la connessione.
- DESCRIPTION (facoltativo): una descrizione della connessione.
Fai clic su Esegui.

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

bq

In un ambiente a riga di comando, crea una connessione:
```
bq mk --connection --location=REGION --project_id=PROJECT_ID \
    --connection_type=CLOUD_RESOURCE CONNECTION_ID
```
Il parametro --project_id sostituisce il progetto predefinito.

Sostituisci quanto segue:
- REGION: la tua regione di connessione
- PROJECT_ID: il tuo ID progetto Google Cloud
- CONNECTION_ID: un ID per la tua connessione
Quando crei una risorsa di connessione, BigQuery crea un account di servizio di sistema univoco e lo associa alla connessione.

Risoluzione dei problemi: se ricevi il seguente errore di connessione, aggiorna Google Cloud SDK:
```
Flags parsing error: flag --connection_type=CLOUD_RESOURCE: value should be one of...
```

Recupera e copia l'ID del account di servizio da utilizzare in un passaggio successivo:

bq show --connection PROJECT_ID.REGION.CONNECTION_ID

L'output è simile al seguente:

name                          properties
1234.REGION.CONNECTION_ID     {"serviceAccountId": "connection-1234-9u56h9@gcp-sa-bigquery-condel.iam.gserviceaccount.com"}

Python

Prima di provare questo esempio, segui le istruzioni di configurazione di Python nella guida rapida di BigQuery per l'utilizzo delle librerie client. Per saperne di più, consulta la documentazione di riferimento dell'API BigQuery Python.

Per eseguire l'autenticazione in BigQuery, configura le Credenziali predefinite dell'applicazione. Per saperne di più, vedi Configura l'autenticazione per le librerie client.

import google.api_core.exceptions
from google.cloud import bigquery_connection_v1

client = bigquery_connection_v1.ConnectionServiceClient()


def create_connection(
    project_id: str,
    location: str,
    connection_id: str,
):
    """Creates a BigQuery connection to a Cloud Resource.

    Cloud Resource connection creates a service account which can then be
    granted access to other Google Cloud resources for federated queries.

    Args:
        project_id: The Google Cloud project ID.
        location: The location of the connection (for example, "us-central1").
        connection_id: The ID of the connection to create.
    """

    parent = client.common_location_path(project_id, location)

    connection = bigquery_connection_v1.Connection(
        friendly_name="Example Connection",
        description="A sample connection for a Cloud Resource.",
        cloud_resource=bigquery_connection_v1.CloudResourceProperties(),
    )

    try:
        created_connection = client.create_connection(
            parent=parent, connection_id=connection_id, connection=connection
        )
        print(f"Successfully created connection: {created_connection.name}")
        print(f"Friendly name: {created_connection.friendly_name}")
        print(
            f"Service Account: {created_connection.cloud_resource.service_account_id}"
        )

    except google.api_core.exceptions.AlreadyExists:
        print(f"Connection with ID '{connection_id}' already exists.")
        print("Please use a different connection ID.")
    except Exception as e:
        print(f"An unexpected error occurred while creating the connection: {e}")

Node.js

Prima di provare questo esempio, segui le istruzioni di configurazione di Node.js nella guida rapida di BigQuery per l'utilizzo delle librerie client. Per saperne di più, consulta la documentazione di riferimento dell'API BigQuery Node.js.

Per eseguire l'autenticazione in BigQuery, configura le Credenziali predefinite dell'applicazione. Per saperne di più, vedi Configura l'autenticazione per le librerie client.

const {ConnectionServiceClient} =
  require('@google-cloud/bigquery-connection').v1;
const {status} = require('@grpc/grpc-js');

const client = new ConnectionServiceClient();

/**
 * Creates a new BigQuery connection to a Cloud Resource.
 *
 * A Cloud Resource connection creates a service account that can be granted access
 * to other Google Cloud resources.
 *
 * @param {string} projectId The Google Cloud project ID. for example, 'example-project-id'
 * @param {string} location The location of the project to create the connection in. for example, 'us-central1'
 * @param {string} connectionId The ID of the connection to create. for example, 'example-connection-id'
 */
async function createConnection(projectId, location, connectionId) {
  const parent = client.locationPath(projectId, location);

  const connection = {
    friendlyName: 'Example Connection',
    description: 'A sample connection for a Cloud Resource',
    // The service account for this cloudResource will be created by the API.
    // Its ID will be available in the response.
    cloudResource: {},
  };

  const request = {
    parent,
    connectionId,
    connection,
  };

  try {
    const [response] = await client.createConnection(request);

    console.log(`Successfully created connection: ${response.name}`);
    console.log(`Friendly name: ${response.friendlyName}`);

    console.log(`Service Account: ${response.cloudResource.serviceAccountId}`);
  } catch (err) {
    if (err.code === status.ALREADY_EXISTS) {
      console.log(`Connection '${connectionId}' already exists.`);
    } else {
      console.error(`Error creating connection: ${err.message}`);
    }
  }
}

Java

Prima di provare questo esempio, segui le istruzioni di configurazione di Java nella guida rapida di BigQuery per l'utilizzo delle librerie client. Per saperne di più, consulta la documentazione di riferimento dell'API BigQuery Java.

Per eseguire l'autenticazione in BigQuery, configura le Credenziali predefinite dell'applicazione. Per saperne di più, vedi Configura l'autenticazione per le librerie client.

import com.google.api.gax.rpc.AlreadyExistsException;
import com.google.api.gax.rpc.ApiException;
import com.google.cloud.bigquery.connection.v1.CloudResourceProperties;
import com.google.cloud.bigquery.connection.v1.Connection;
import com.google.cloud.bigquery.connection.v1.CreateConnectionRequest;
import com.google.cloud.bigquery.connection.v1.LocationName;
import com.google.cloud.bigqueryconnection.v1.ConnectionServiceClient;
import java.io.IOException;

public class CreateConnection {

  /**
   * Creates a BigQuery connection to a Cloud Resource. A Cloud Resource connection provisions a
   * service account that can be granted access to other Google Cloud resources for federated
   * queries.
   *
   * @param projectId The Google Cloud project ID (for example, "example-project-id").
   * @param location The geographic location of the connection (for example, "us-central1").
   * @param connectionId The ID of the connection to create (for example, "example-connection-id").
   */
  public static void createConnection(String projectId, String location, String connectionId) {
    LocationName parent = LocationName.of(projectId, location);

    // CloudResourceProperties provisions a managed Google Cloud service account on creation.
    CloudResourceProperties cloudResourceProperties = CloudResourceProperties.newBuilder().build();
    Connection connection =
        Connection.newBuilder()
            .setFriendlyName("Example Connection")
            .setDescription("Cloud Resource connection for federated queries.")
            .setCloudResource(cloudResourceProperties)
            .build();

    CreateConnectionRequest request =
        CreateConnectionRequest.newBuilder()
            .setParent(parent.toString())
            .setConnectionId(connectionId)
            .setConnection(connection)
            .build();

    try (ConnectionServiceClient client = ConnectionServiceClient.create()) {
      Connection response = client.createConnection(request);

      System.out.printf("Successfully created connection: %s%n", response.getName());
      System.out.printf("Friendly name: %s%n", response.getFriendlyName());
      System.out.printf(
          "Service Account: %s%n", response.getCloudResource().getServiceAccountId());
    } catch (AlreadyExistsException err) {
      System.err.printf(
          "error: connection '%s' already exists in location '%s' for project '%s': %s%n",
          connectionId, location, projectId, err.getMessage());
    } catch (ApiException | IOException err) {
      System.err.printf(
          "error: failed to create connection '%s' in location '%s' for project '%s': %s%n",
          connectionId, location, projectId, err.getMessage());
    }
  }

Terraform

Utilizza la risorsa google_bigquery_connection.

Per eseguire l'autenticazione in BigQuery, configura le Credenziali predefinite dell'applicazione. Per saperne di più, vedi Configura l'autenticazione per le librerie client.

L'esempio seguente crea una connessione alle risorse Cloud denominata my_cloud_resource_connection nella regione US:


# This queries the provider for project information.
data "google_project" "default" {}

# This creates a cloud resource connection in the US region named my_cloud_resource_connection.
# Note: The cloud resource nested object has only one output field - serviceAccountId.
resource "google_bigquery_connection" "default" {
  connection_id = "my_cloud_resource_connection"
  project       = data.google_project.default.project_id
  location      = "US"
  cloud_resource {}
}

Per applicare la configurazione Terraform in un progetto Google Cloud , completa i passaggi descritti nelle sezioni seguenti.

Prepara Cloud Shell

Avvia Cloud Shell.
Imposta il progetto Google Cloud predefinito in cui vuoi applicare le configurazioni Terraform.

Devi eseguire questo comando una sola volta per progetto e puoi eseguirlo in qualsiasi directory.
```
export GOOGLE_CLOUD_PROJECT=PROJECT_ID
```
Le variabili di ambiente vengono sostituite se imposti valori espliciti nel file di configurazione Terraform.

Prepara la directory

Ogni file di configurazione Terraform deve avere la propria directory (chiamata anche modulo principale).

In Cloud Shell, crea una directory e un nuovo file al suo interno. Il nome file deve avere l'estensione .tf, ad esempio main.tf. In questo tutorial, il file è denominato main.tf.
```
mkdir DIRECTORY && cd DIRECTORY && touch main.tf
```
Se stai seguendo un tutorial, puoi copiare il codice campione in ogni sezione o passaggio.

Copia il codice campione nel file main.tf appena creato.

Facoltativamente, copia il codice da GitHub. Questa opzione è consigliata quando lo snippet Terraform fa parte di una soluzione end-to-end.
Esamina e modifica i parametri di esempio da applicare al tuo ambiente.
Salva le modifiche.
Inizializza Terraform. Devi eseguire questa operazione una sola volta per directory.
```
terraform init
```
Facoltativamente, per utilizzare l'ultima versione del provider Google, includi l'opzione -upgrade:
```
terraform init -upgrade
```

Applica le modifiche

Esamina la configurazione e verifica che le risorse che Terraform creerà o aggiornerà corrispondano alle tue aspettative:
```
terraform plan
```
Apporta le correzioni necessarie alla configurazione.
Applica la configurazione Terraform eseguendo il comando seguente e inserendo yes al prompt:
```
terraform apply
```
Attendi che Terraform visualizzi il messaggio "Apply complete!".
Apri il tuo progetto Google Cloud per visualizzare i risultati. Nella console Google Cloud , vai alle risorse nell'interfaccia utente per assicurarti che Terraform le abbia create o aggiornate.

Concedi l'accesso al account di servizio

Concedi al account di servizio della connessione i ruoli Agent Platform User e Storage Object Viewer.

Se prevedi di specificare l'endpoint come URL quando crei il modello remoto, ad esempio endpoint = 'https://us-central1-aiplatform.googleapis.com/v1/projects/myproject/locations/us-central1/publishers/google/models/gemini-2.0-flash', concedi questo ruolo nello stesso progetto che specifichi nell'URL.

Se prevedi di specificare l'endpoint utilizzando il nome del modello quando crei il modello remoto, ad esempio endpoint = 'gemini-2.0-flash', concedi questo ruolo nello stesso progetto in cui prevedi di creare il modello remoto.

La concessione del ruolo in un progetto diverso genera l'errore bqcx-1234567890-wxyz@gcp-sa-bigquery-condel.iam.gserviceaccount.com does not have the permission to access resource.

Per concedere questi ruoli, segui questi passaggi:

Console

Vai alla pagina IAM e amministrazione.

Vai a IAM e amministrazione
Fai clic su Aggiungi.

Viene visualizzata la finestra di dialogo Aggiungi entità.
Nel campo Nuove entità, inserisci l'ID del account di servizio che hai copiato in precedenza.
Nel campo Seleziona un ruolo, cerca Agent Platform User.
Fai clic su Aggiungi un altro ruolo.
Nel campo Seleziona un ruolo, scegli Cloud Storage e poi seleziona Visualizzatore oggetti Storage.
Fai clic su Salva.

gcloud

Utilizza il comando gcloud projects add-iam-policy-binding.

gcloud projects add-iam-policy-binding 'PROJECT_NUMBER' --member='serviceAccount:MEMBER' --role='roles/aiplatform.user' --condition=None
gcloud projects add-iam-policy-binding 'PROJECT_NUMBER' --member='serviceAccount:MEMBER' --role='roles/storage.objectViewer' --condition=None

Sostituisci quanto segue:

PROJECT_NUMBER: il numero del progetto in cui concedere il ruolo.
MEMBER: l'ID del account di servizio che hai copiato in precedenza.

Crea una tabella di oggetti

Per analizzare i video senza spostarli da Cloud Storage, crea una tabella di oggetti.

Per creare una tabella di oggetti:

SQL

Utilizza l'istruzione CREATE EXTERNAL TABLE.

Nella console Google Cloud , vai alla pagina BigQuery.

Vai a BigQuery
Nell'editor di query, inserisci la seguente istruzione:
```
CREATE EXTERNAL TABLE `PROJECT_ID.DATASET_ID.TABLE_NAME`
WITH CONNECTION {`PROJECT_ID.REGION.CONNECTION_ID`| DEFAULT}
OPTIONS(
  object_metadata = 'SIMPLE',
  uris = ['BUCKET_PATH'[,...]],
  max_staleness = STALENESS_INTERVAL,
  metadata_cache_mode = 'CACHE_MODE');
```
Sostituisci quanto segue:
- PROJECT_ID: il tuo ID progetto.
- DATASET_ID: l'ID del set di dati che hai creato.
- TABLE_NAME: il nome della tabella di oggetti.
- REGION: la regione o multi-regione che contiene la connessione.
- CONNECTION_ID: l'ID della connessione che hai creato.
  Quando visualizzi i dettagli della connessione nella console Google Cloud , questo è il valore nell'ultima sezione dell'ID connessione completo mostrato in ID connessione, ad esempio projects/myproject/locations/connection_location/connections/myconnection.
  
  Per utilizzare una connessione predefinita, specifica DEFAULT anziché la stringa di connessione contenente PROJECT_ID.REGION.CONNECTION_ID.
- BUCKET_PATH: il percorso del bucket Cloud Storage che contiene i video, nel formato ['gs://bucket_name/[folder_name/]*'].
  Il bucket Cloud Storage che utilizzi deve trovarsi nello stesso progetto in cui prevedi di creare il modello e chiamare la funzione AI.GENERATE_EMBEDDING. Se vuoi chiamare la funzione AI.GENERATE_EMBEDDING in un progetto diverso da quello che contiene il bucket Cloud Storage utilizzato dalla tabella degli oggetti, devi concedere il ruolo Storage Admin a livello di bucket al account di servizio service-A@gcp-sa-aiplatform.iam.gserviceaccount.com.
- STALENESS_INTERVAL: specifica se i metadati memorizzati nella cache vengono utilizzati dalle operazioni sulla tabella degli oggetti e quanto devono essere aggiornati i metadati memorizzati nella cache affinché l'operazione li utilizzi. Per ulteriori informazioni sulle considerazioni relative alla memorizzazione nella cache dei metadati, consulta Memorizzazione nella cache dei metadati per le prestazioni.
  Per disattivare la memorizzazione nella cache dei metadati, specifica 0. Questa è l'impostazione predefinita.
  
  Per abilitare la memorizzazione nella cache dei metadati, specifica un valore valore letterale dell'intervallo compreso tra 30 minuti e 7 giorni. Ad esempio, specifica INTERVAL 4 HOUR per un intervallo di inattività di 4 ore. Con questo valore, le operazioni sulla tabella utilizzano i metadati memorizzati nella cache se sono stati aggiornati nelle ultime 4 ore. Se i metadati memorizzati nella cache sono più vecchi, l'operazione recupera i metadati da Cloud Storage.
- CACHE_MODE: specifica se la cache dei metadati viene aggiornata automaticamente o manualmente. Per saperne di più sulle considerazioni relative alla memorizzazione nella cache dei metadati, consulta Memorizzazione nella cache dei metadati per le prestazioni.
  Imposta su AUTOMATIC per aggiornare la cache dei metadati a un intervallo definito dal sistema, in genere compreso tra 30 e 60 minuti.
  
  Impostalo su MANUAL se vuoi aggiornare la cache dei metadati in base a una pianificazione che hai stabilito. In questo caso, puoi chiamare la procedura di sistema BQ.REFRESH_EXTERNAL_METADATA_CACHE per aggiornare la cache.
  
  Devi impostare CACHE_MODE se STALENESS_INTERVAL è impostato su un valore maggiore di 0.
Fai clic su Esegui.

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

bq

Utilizza il comando bq mk.

bq mk --table \
--external_table_definition=BUCKET_PATH@REGION.CONNECTION_ID \
--object_metadata=SIMPLE \
--max_staleness=STALENESS_INTERVAL \
--metadata_cache_mode=CACHE_MODE \
PROJECT_ID:DATASET_ID.TABLE_NAME

Sostituisci quanto segue:

BUCKET_PATH: il percorso del bucket Cloud Storage che contiene i video, nel formato ['gs://bucket_name/[folder_name/]*'].
Il bucket Cloud Storage che utilizzi deve trovarsi nello stesso progetto in cui prevedi di creare il modello e chiamare la funzione AI.GENERATE_EMBEDDING. Se vuoi chiamare la funzione AI.GENERATE_EMBEDDING in un progetto diverso da quello che contiene il bucket Cloud Storage utilizzato dalla tabella degli oggetti, devi concedere il ruolo Storage Admin a livello di bucket al account di servizio service-A@gcp-sa-aiplatform.iam.gserviceaccount.com.
REGION: la regione o multi-regione che contiene la connessione.
CONNECTION_ID: l'ID della connessione che hai creato.
Quando visualizzi i dettagli della connessione nella console Google Cloud , questo è il valore nell'ultima sezione dell'ID connessione completo mostrato in ID connessione, ad esempio projects/myproject/locations/connection_location/connections/myconnection.
STALENESS_INTERVAL: specifica se i metadati memorizzati nella cache vengono utilizzati dalle operazioni sulla tabella degli oggetti e quanto devono essere aggiornati i metadati memorizzati nella cache affinché l'operazione li utilizzi. Per ulteriori informazioni sulle considerazioni relative alla memorizzazione nella cache dei metadati, consulta Memorizzazione nella cache dei metadati per le prestazioni.
Per disattivare la memorizzazione nella cache dei metadati, specifica 0. Questa è l'impostazione predefinita.

Per abilitare la memorizzazione nella cache dei metadati, specifica un valore valore letterale dell'intervallo compreso tra 30 minuti e 7 giorni. Ad esempio, specifica INTERVAL 4 HOUR per un intervallo di inattività di 4 ore. Con questo valore, le operazioni sulla tabella utilizzano i metadati memorizzati nella cache se sono stati aggiornati nelle ultime 4 ore. Se i metadati memorizzati nella cache sono più vecchi, l'operazione recupera i metadati da Cloud Storage.
CACHE_MODE: specifica se la cache dei metadati viene aggiornata automaticamente o manualmente. Per saperne di più sulle considerazioni relative alla memorizzazione nella cache dei metadati, consulta Memorizzazione nella cache dei metadati per le prestazioni.
Imposta su AUTOMATIC per aggiornare la cache dei metadati a un intervallo definito dal sistema, in genere compreso tra 30 e 60 minuti.

Impostalo su MANUAL se vuoi aggiornare la cache dei metadati in base a una pianificazione che hai stabilito. In questo caso, puoi chiamare la procedura di sistema BQ.REFRESH_EXTERNAL_METADATA_CACHE per aggiornare la cache.

Devi impostare CACHE_MODE se STALENESS_INTERVAL è impostato su un valore maggiore di 0.
PROJECT_ID: il tuo ID progetto.
DATASET_ID: l'ID del set di dati che hai creato.
TABLE_NAME: il nome della tabella di oggetti.

crea un modello

Nella console Google Cloud , vai alla pagina BigQuery.

Vai a BigQuery
Utilizzando l'editor SQL, crea un modello remoto:
```
CREATE OR REPLACE MODEL `PROJECT_ID.DATASET_ID.MODEL_NAME`
REMOTE WITH CONNECTION {DEFAULT | `PROJECT_ID.REGION.CONNECTION_ID`}
OPTIONS (ENDPOINT = 'ENDPOINT');
```
Sostituisci quanto segue:
- PROJECT_ID: il tuo ID progetto.
- DATASET_ID: l'ID del set di dati che hai creato.
- MODEL_NAME: il nome del modello.
- REGION: la regione o multi-regione che contiene la connessione.
- CONNECTION_ID: l'ID della connessione che hai creato.
  Quando visualizzi i dettagli della connessione nella console Google Cloud , questo è il valore nell'ultima sezione dell'ID connessione completo mostrato in ID connessione, ad esempio projects/myproject/locations/connection_location/connections/myconnection.
- ENDPOINT: il modello di embedding da utilizzare, in questo caso multimodalembedding@001.
  Se specifichi un URL come endpoint quando crei il modello remoto, ad esempio endpoint = 'https://us-central1-aiplatform.googleapis.com/v1/projects/myproject/locations/us-central1/publishers/google/models/multimodalembedding@001', assicurati che il progetto specificato nell'URL sia quello in cui hai concesso il ruolo Utente della piattaforma agente al account di servizio della connessione.
  
  Il modello multimodalembedding@001 deve essere disponibile nella località in cui stai creando il modello remoto. Per saperne di più, consulta Località.

Genera embedding dei video

Genera embedding dei video con la funzione AI.GENERATE_EMBEDDING utilizzando i dati dei video di una tabella di oggetti:

SELECT *
FROM AI.GENERATE_EMBEDDING(
  MODEL `PROJECT_ID.DATASET_ID.MODEL_NAME`,
  TABLE PROJECT_ID.DATASET_ID.TABLE_NAME,
  STRUCT(
    START_SECOND AS start_second,
    END_SECOND AS end_second,
    INTERVAL_SECONDS AS interval_seconds)
);

Sostituisci quanto segue:

PROJECT_ID: il tuo ID progetto.
DATASET_ID: l'ID del set di dati che contiene il modello.
MODEL_NAME: il nome del modello remoto su un modello multimodalembedding@001.
TABLE_NAME: il nome della tabella degli oggetti che contiene i video da incorporare.
START_SECOND: un valore FLOAT64 che specifica il secondo del video in cui iniziare l'incorporamento. Il valore predefinito è 0. Questo valore deve essere positivo e inferiore al valore end_second.
END_SECOND: un valore FLOAT64 che specifica il secondo del video in cui terminare l'incorporamento. Il valore predefinito è 120. Questo valore deve essere positivo e maggiore del valore start_second.
INTERVAL_SECONDS: un valore FLOAT64 che specifica l'intervallo da utilizzare per la creazione degli embedding. Ad esempio, se imposti start_second = 0, end_second = 120 e interval_seconds = 10, il video viene suddiviso in dodici segmenti di 10 secondi ([0, 10), [10, 20), [20, 30)...) e vengono generati embedding per ogni segmento. Questo valore deve essere maggiore di 4 e minore di 120. Il valore predefinito è 16.

Esempio

L'esempio seguente mostra come creare embedding per i video nella tabella degli oggetti videos. Gli embedding vengono creati per ogni intervallo di 5 secondi tra i 10 e i 40 secondi di ogni video.

SELECT *
FROM
  AI.GENERATE_EMBEDDING(
    MODEL `mydataset.embedding_model`,
    TABLE `mydataset.videos`,
    STRUCT(
    10 AS start_second,
    40 AS end_second,
    5 AS interval_seconds)
  );

Genera embedding video utilizzando la funzione AI.GENERATE_EMBEDDING

Ruoli obbligatori

Autorizzazioni obbligatorie

Prima di iniziare

Crea un set di dati

Console

bq

Crea una connessione

Console

SQL

bq

Python

Node.js

Java

Terraform

Prepara Cloud Shell

Prepara la directory

Applica le modifiche

Concedi l'accesso al account di servizio

Console

gcloud

Crea una tabella di oggetti

SQL

bq

crea un modello

Genera embedding dei video

Esempio

Passaggi successivi