Ottenere approfondimenti di Gemini sui dati di BigQuery

L'SDK BigQuery AI e ML per ABAP ti consente di utilizzare le query di Gemini sui dati aziendali archiviati in BigQuery e di recuperare i risultati dalle applicazioni o dagli agenti basati su ABAP. Con l'SDK, puoi utilizzare i modelli Gemini per:

  • Generare approfondimenti dai dati di testo in BigQuery
  • Generare approfondimenti dai dati di immagini o video in BigQuery

Puoi eseguire approfondimenti basati su Gemini sui dati aziendali archiviati nei set di dati BigQuery utilizzando la funzione BigQuery ML.GENERATE_TEXT.

Puoi accedere ai modelli Gemini su Vertex AI creando un modello remoto in BigQuery ML che rappresenti l'endpoint del modello Vertex AI. Dopo aver creato un modello remoto sul modello Vertex AI che vuoi utilizzare, puoi accedere alle funzionalità del modello eseguendo la funzione BigQuery ML sul modello remoto.

Prima di iniziare

Prima di utilizzare l'SDK BigQuery AI e ML per ABAP con i modelli Gemini, assicurati che tu o i tuoi amministratori abbiate completato i seguenti prerequisiti:

Prezzi

L'SDK BigQuery AI e ML per ABAP è offerto senza costi. Tuttavia, sei responsabile degli addebiti sulle piattaforme BigQuery e Vertex AI come segue:

  • BigQuery ML: devi sostenere i costi per i dati che elabori in BigQuery.
  • Vertex AI: devi sostenere i costi delle chiamate al servizio Vertex AI rappresentato dal modello remoto.

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

Per ulteriori informazioni sui prezzi di BigQuery, consulta la pagina Prezzi di BigQuery.

Per ulteriori informazioni sui prezzi di Vertex AI, visita la pagina Prezzi di Vertex AI.

Esegui query Gemini su BigQuery

Questa sezione spiega come generare approfondimenti basati su Gemini dai dati aziendali in BigQuery utilizzando l'SDK BigQuery AI e ML per ABAP.

La classe ABAP /GOOG/CL_BQ_GENERATIVE_MODEL fornita con l'SDK consente di eseguire query Gemini utilizzando la funzione BigQuery ML.GENERATE_TEXT.

Impostare la query di Gemini

Puoi utilizzare l'SDK per eseguire query Gemini nei seguenti modi:

  • Salva la query per eseguire Gemini in BigQuery. Utilizza la classe /GOOG/CL_BQ_QUERY e fornisci il nome della query salvata quando esegui l'inizializzazione della classe dalla logica dell'applicazione.

    TRY.
    DATA(lo_bq_query) = NEW /goog/cl_bq_query( iv_key         = 'CLIENT_KEY'
                                              iv_location_id = 'QUERY_LOCATION_ID'
      iv_query_name  = 'SAVED_QUERY_NAME' ).
CATCH /goog/cx_sdk INTO DATA(lo_cx_sdk).
    cl_demo_output=>display( lo_cx_sdk->get_text( ) ).

ENDTRY.

    Sostituisci quanto segue:

    • CLIENT_KEY: la chiave client che hai configurato per l'autenticazione a Google Cloud durante la configurazione dell'autenticazione.
    • QUERY_LOCATION_ID: la Google Cloud posizione in cui viene salvata la query.
    • SAVED_QUERY_NAME: il nome della query con cui la query viene salvata in BigQuery.

  • Passa il testo della query per richiamare Gemini quando esegui l'inizializzazione della classe /GOOG/CL_BQ_QUERY dalla logica dell'applicazione.

    TRY.
    DATA(lo_bq_query) = NEW /goog/cl_bq_query( iv_key         = 'CLIENT_KEY'
                                              iv_location_id = 'QUERY_LOCATION_ID'
      iv_query_text  = 'QUERY_TEXT' ).
CATCH /goog/cx_sdk INTO DATA(lo_cx_sdk).
    cl_demo_output=>display( lo_cx_sdk->get_text( ) ).

ENDTRY.

    Sostituisci quanto segue:

    • CLIENT_KEY: la chiave client che hai configurato per l'autenticazione a Google Cloud durante la configurazione dell'autenticazione.
    • QUERY_LOCATION_ID: la Google Cloud posizione in cui viene salvata la query.
    • QUERY_TEXT: il testo della query che vuoi eseguire con Gemini.

Quando esegui l'inizializzazione della classe /GOOG/CL_BQ_QUERY con il nome della query salvata o il testo della query diretta, la query viene impostata all'interno della classe. Poi puoi passare il riferimento della classe come input alla classe /GOOG/CL_BQ_GENERATIVE_MODEL ABAP per richiamare la query.

Crea un'istanza della classe di invocatore BigQuery Gemini

Per richiamare i modelli di testo e multimodali di Gemini sui set di dati BigQuery, utilizza la classe /GOOG/CL_BQ_GENERATIVE_MODEL.

TRY.
    DATA(lo_bq_generative_model) = NEW /goog/cl_bq_generative_model( iv_key = 'CLIENT_KEY' ).
CATCH /goog/cx_sdk INTO DATA(lo_cx_sdk).
    cl_demo_output=>display( lo_cx_sdk->get_text( ) ).

ENDTRY.

Sostituisci CLIENT_KEY con la chiave client che hai configurato per l'autenticazione a Google Cloud durante la configurazione dell'autenticazione.

Esegui una query di Gemini

Per eseguire query Gemini con la funzione BigQuery ML.GENERATE_TEXT, utilizza il metodo EXECUTE_QUERY della classe /GOOG/CL_BQ_GENERATIVE_MODEL. L'oggetto della classe /GOOG/CL_BQ_QUERY impostato con la query viene passato come input al metodo.

lo_bq_generative_model->execute_query( io_query = lo_bq_query ).

LO_BQ_QUERY è il riferimento del corso /GOOG/CL_BQ_QUERY dopo l'impostazione della query.

Sostituire i parametri di generazione del modello

Puoi definire i parametri di generazione del modello Gemini in una query salvata in BigQuery o nel testo della query passato. Tuttavia, se devi eseguire l'override dei parametri per la stessa query dalla logica dell'applicazione ABAP, puoi utilizzare il metodo SET_GENERATION_CONFIG della classe /GOOG/CL_BQ_GENERATIVE_MODEL. I parametri di generazione nella query iniziale vengono sostituiti con i parametri passati tramite questo metodo.

DATA lt_stop_sequences TYPE /goog/cl_bigquery_v2=>ty_t_string.
DATA lt_safety_settings TYPE /goog/cl_bq_generative_model=>ty_t_safety_settings.
DATA ls_safety_settings TYPE /goog/cl_bq_generative_model=>ty_safety_setting.

APPEND 'STOP_SEQUENCE' TO lt_stop_sequences.

ls_safety_settings-category = 'CATEGORY'.
ls_safety_settings-threshold = 'THRESHOLD'.

APPEND ls_safety_settings TO lt_safety_settings.

lo_bq_generative_model->set_generation_config( iv_temperature               = 'TEMPERATURE'
                               iv_top_p                     = 'TOP_P'
       iv_top_k                     = 'TOP_K'
       iv_max_output_tokens         = 'MAX_OUTPUT_TOKENS'
       iv_flatten_json_output       = 'IS_FLATTEN_JSON_OUTPUT'
       iv_ground_with_google_search = 'IS_GROUND_WITH_GOOGLE_SEARCH'
it_stop_sequences            = lt_stop_sequences
it_safety_settings           = lt_safety_settings ).

Sostituisci quanto segue:

  • STOP_SEQUENCE: il valore che rimuove le stringhe specificate se sono incluse nelle risposte del modello.
  • CATEGORY: la categoria di sicurezza dei contenuti per filtrare le risposte. cerca i valori probabili dall'argomento delle impostazioni di sicurezza in Sintassi di input per ML.GENERATE_TEXT.
  • THRESHOLD: la soglia di blocco corrispondente per filtrare le risposte. cerca i valori probabili dall'argomento delle impostazioni di sicurezza in Sintassi di input per ML.GENERATE_TEXT.
  • TEMPERATURE: il valore che controlla il grado di casualità nella selezione dei token.
  • TOP_P: il valore che cambia il modo in cui il modello seleziona i token per l'output.
  • TOP_K: il valore che cambia il modo in cui il modello seleziona i token per l'output.
  • MAX_OUTPUT_TOKENS: il valore che imposta il numero massimo di token che possono essere generati nella risposta.
  • IS_FLATTEN_JSON_OUTPUT: un valore booleano che determina se i contenuti JSON restituiti dalla funzione vengono analizzati in colonne separate.
  • IS_GROUND_WITH_GOOGLE_SEARCH: un valore booleano che determina se il modello Vertex AI utilizza la fondatezza con la Ricerca Google durante la generazione delle risposte.

Ottenere i risultati delle query di Gemini

Per ricevere le risposte elaborate dalle query BigQuery ML per Gemini e presentarle in modo significativo, utilizza la classe /GOOG/CL_BQ_MODEL_RESPONSE.

La risposta acquisita dalla classe /GOOG/CL_BQ_MODEL_RESPONSE viene collegata alle richieste effettuate tramite i metodi della classe /GOOG/CL_BQ_GENERATIVE_MODEL, in modo da poter accedere direttamente alla risposta in un'unica dichiarazione senza dover utilizzare variabili per memorizzare i risultati intermedi.

Ricevere una risposta via SMS

Per ricevere una risposta di testo dal modello, utilizza il metodo GET_TEXT_RESPONSE.

DATA(lt_bq_response) = lo_bq_generative_model->execute_query( io_query = lo_bq_query
                                            )->get_text_response( ).

Ottieni lo stato del job di query

Ogni query in BigQuery viene eseguita come job di query. Per ottenere lo stato del job di query, utilizza il metodo GET_QUERY_JOB_STATUS.

lo_bq_generative_model->execute_query( io_query = lo_bq_query
                     )->get_query_job_status(
IMPORTING ev_job_complete          = DATA(lv_job_complete)
  ev_job_creation_reason   = DATA(lv_job_creation_reason)
  ev_job_id                = DATA(lv_job_id)
  ev_query_id              = DATA(lv_query_id)
  ev_total_bytes_processed = DATA(lv_total_bytes_processed)
  ev_total_rows            = DATA(lv_total_rows) ).

Il metodo restituisce le seguenti metriche relative allo stato del job:

  • Indica se la query è stata completata o meno
  • Il motivo per cui è stato creato un job
  • Riferimento al job creato per eseguire la query
  • ID generato automaticamente per la query
  • Il numero totale di byte elaborati per questa query
  • Il numero totale di righe nel set di risultati completo della query

Ottieni errori dei job di query

Per recuperare gli errori (se presenti), utilizza il metodo GET_QUERY_JOB_ERRORS.

DATA(lt_query_job_errors) = lo_bq_generative_model->execute_query( io_query = lo_bq_query
                                                 )->get_query_job_errors( ).

Ottenere il motivo del completamento

Per ottenere il motivo per cui il modello ha smesso di generare token per ogni riga, utilizza il metodo GET_FINISH_REASON.

DATA(lt_finish_reason) = lo_bq_generative_model->execute_query( io_query = lo_bq_query
                                              )->get_finish_reason( ).

Recuperare i metadati di utilizzo

Per ottenere i metadati di utilizzo relativi alla risposta generata per ogni riga, utilizza il metodo GET_USAGE_METADATA .

DATA(lt_usage_metadata) = lo_bq_generative_model->execute_query( io_query = lo_bq_query
                                               )->get_usage_metadata( ).

I metadati relativi all'utilizzo sono costituiti dalle seguenti metriche:

  • Conteggio totale dei token nella risposta per una riga
  • Conteggio dei token nel prompt di input
  • Conteggio totale dei token

Ottenere la valutazione di sicurezza

Per ottenere la valutazione di sicurezza della risposta, utilizza il metodo GET_SAFETY_RATING. Le valutazioni di sicurezza devono essere impostate come parametri di generazione del modello nella query di input per ottenere la valutazione di sicurezza per la risposta.

DATA(lt_safety_ratings) = lo_bq_generative_model->execute_query( io_query = lo_bq_query
                                               )->get_safety_rating( ).

Ottenere la tabella delle risposte complessive

Per ottenere la tabella di risposta complessiva per la query Gemini eseguita, utilizza il metodo GET_RESPONSE_TABLE.

lo_bq_model_response->get_response_table(
IMPORTING et_bqml_response              = DATA(lt_bqml_response)
                  et_bqml_response_flatten_json = DATA(lt_bqml_response_flatten_json)
                  et_bqml_response_grounding    = DATA(lt_bqml_response_grounding) ).

Viene compilata una sola tabella di risposta in base al parametro di generazione impostato nella query:

  • ET_BQML_RESPONSE viene compilato quando il parametro FLATTEN_JSON_OUTPUT non è impostato su TRUE nella query di input.
  • ET_BQML_RESPONSE_FLATTEN_JSON viene compilato quando il parametro FLATTEN_JSON_OUTPUT è impostato su TRUE nella query di input.
  • ET_BQML_RESPONSE_GROUNDING viene compilato quando il parametro FLATTEN_JSON_OUTPUT è impostato su TRUE nella query di input e anche il parametro GROUNDING_WITH_GOOGLE_SEARCH è impostato su TRUE nella query di input.

Recupera l'origine di grounding

Per elencare le fonti di grounding utilizzate dal modello per generare le risposte, utilizza il metodo GET_GROUNDING_SOURCE.

DATA(lt_query_grounding_sources) = lo_bq_generative_model->execute_query( io_query = lo_bq_query
                                                        )->get_grounding_source( ).