Leggere le previsioni di BigQuery ML in SAP utilizzando l'SDK ABAP per Google Cloud

1. Introduzione

In questo codelab creerai un modello di machine learning (ML) in BigQuery e otterrai le previsioni da questo modello utilizzando l'SDK ABAP per Google Cloud.

Sfrutterai i seguenti servizi Google Cloud:

• BigQuery
• Cloud Shell

Cosa creerai

Dovrai creare quanto segue:

• Un modello BigQuery Machine Learning (ML).
• Un account di servizio con il ruolo Utente job BigQuery per chiamare l'API BigQuery.
• Un programma ABAP per chiamare l'API BigQuery e ottenere le previsioni dal modello ML.

2. Requisiti

• Un browser, ad esempio Chrome o Firefox.
• Un progetto Google Cloud con la fatturazione abilitata o crea un account di prova senza costi di 90 giorni per la piattaforma Google Cloud.
• SAP GUI (Windows o Java) installato nel sistema. Se SAP GUI è già installato sul tuo laptop, connettiti a SAP utilizzando l'indirizzo IP esterno della VM come indirizzo IP del server di applicazioni. Se utilizzi un Mac, puoi anche installare SAP GUI per Java disponibile in questo link.

3. Prima di iniziare

• Nella console Google Cloud, nella pagina di selezione del progetto, seleziona o crea un progetto Google Cloud (ad esempio abap-sdk-poc).
• Verifica che la fatturazione sia attivata per il tuo progetto Cloud. Scopri come verificare se la fatturazione è attivata per un progetto. Ignora questo passaggio se utilizzi l'account per la prova senza costi di 90 giorni.
• Utilizzerai Cloud Shell, un ambiente a riga di comando in esecuzione in Google Cloud.
• In Cloud Console, fai clic su Attiva Cloud Shell nell'angolo in alto a destra:

• Esegui i seguenti comandi in Cloud Shell per autenticarti per il tuo account e impostare il progetto predefinito su abap-sdk-poc. La zona us-west4-b viene utilizzata come esempio. Se necessario, modifica il progetto e la zona nei comandi seguenti in base alle tue preferenze.

gcloud auth login
gcloud config set project abap-sdk-poc
gcloud config set compute/zone us-west4-b

• Devi avere accesso a un sistema SAP con l'SDK ABAP per Google Cloud installato.
• Prima di procedere con questo codelab, devi completare il codelab 1 (Install ABAP Platform Trial 1909 on Google Cloud Platform and Install ABAP SDK for Google Cloud) e il codelab 2 (Configure ABAP SDK Authentication using tokens for SAP Hosted on Compute Engine VM).
• Se hai completato i codelab 1 e 2, avrai eseguito il provisioning di un sistema ABAP Platform Trial 1909 su Google Cloud, insieme alla configurazione richiesta per l'autenticazione e la connettività.
• Se non hai completato i codelab 1 e 2, non avrai tutta l'infrastruttura e la connettività necessarie per eseguire i passaggi descritti in questo codelab. Pertanto, devi completare i codelab 1 e 2 prima di procedere con questo.

4. Attivare la versione 2 dell'API BigQuery nel progetto Google Cloud

1. In Cloud Console, fai clic su Attiva Cloud Shell nell'angolo in alto a destra:

2. Esegui i seguenti comandi in Cloud Shell per abilitare l'API BigQuery:

gcloud services enable bigquery.googleapis.com

Al termine dell'esecuzione, dovresti visualizzare un messaggio come mostrato di seguito

Ora l'API BigQuery dovrebbe essere attivata nel tuo progetto Google Cloud.

5. Creare un account di servizio per l'accesso sicuro a BigQuery

Per ottenere in modo sicuro le previsioni di ML da un modello BigQuery ML, devi creare un account di servizio con i ruoli Utente job BigQuery e Visualizzatore dati BigQuery, che consentiranno al tuo programma di eseguire query (come job) all'interno del progetto e di leggere i dati dalle tabelle. Questo ruolo concede solo l'autorizzazione necessaria per creare job e leggere i dati, riducendo al minimo i rischi per la sicurezza.

Creare un account di servizio

Per creare un account di servizio con il ruolo richiesto, svolgi i seguenti passaggi:

1. Esegui questo comando nel terminale Cloud Shell:

gcloud iam service-accounts create abap-sdk-bigquery-jobuser --display-name="Service Account for BigQuery Job user"

Nota: al termine dell'esecuzione del comando precedente, dovresti ricevere la seguente risposta:

Account di servizio creato [abap-sdk-biguqery-jobuser] .

2. Ora aggiungi i ruoli richiesti all'account di servizio creato nel passaggio precedente:

gcloud projects add-iam-policy-binding abap-sdk-poc --member='serviceAccount:[e-mail]' --role='roles/bigquery.jobUser'

gcloud projects add-iam-policy-binding abap-sdk-poc --member='serviceAccount:[e-mail]' --role='roles/bigquery.dataViewer'

Il comando riportato sopra utilizza abap-sdk-poc come segnaposto per il progetto Google Cloud. Sostituisci abap-sdk-poc con l'ID del tuo progetto.

3. Per verificare che il ruolo sia stato aggiunto, vai alla pagina IAM. L'account di servizio che hai creato dovrebbe essere elencato insieme al ruolo che gli è stato assegnato.

6. Creazione di un modello BigQuery Machine Learning

In questo codelab creeremo un modello K-means per raggruppare il set di dati delle biciclette a noleggio di Londra. Puoi applicare l'algoritmo k-means per raggruppare i dati in cluster. A differenza del machine learning supervisionato, che si occupa di analisi predittiva, l'apprendimento non supervisionato si occupa di analisi descrittiva. Si tratta di comprendere i dati in modo da poter prendere decisioni basate sui dati.

Creare il set di dati

Per creare un set di dati BigQuery per archiviare il tuo modello ML, segui questi passaggi:

1. Nella console Google Cloud, vai alla pagina BigQuery. Vai alla pagina BigQuery
2. Nel riquadro Explorer, fai clic sul nome del progetto.
3. Fai clic su Visualizza azioni > Crea set di dati.

4. Nella pagina Crea set di dati:

• In ID set di dati, inserisci bqml_tutorial.
• In Tipo di località, seleziona Più regioni e poi UE (più regioni nell'Unione Europea). Il set di dati pubblico Noleggi biciclette a Londra è archiviato nella regione con più aree geografiche dell'UE. Il set di dati deve trovarsi nella stessa posizione.
• Lascia invariate le restanti impostazioni predefinite e fai clic su Crea set di dati.

Creare un modello K-means

Ora che il set di dati è configurato, il passaggio successivo consiste nel creare un modello k-means utilizzando i dati. Puoi creare e addestrare un modello K-means utilizzando l'istruzione CREATE MODEL con l'opzione model_type=kmeans.

Per eseguire la query e creare un modello K-means, svolgi i seguenti passaggi:

1. Vai alla pagina BigQuery. Vai a BigQuery
2. Nel riquadro dell'editor, esegui il seguente statement SQL:

CREATE OR REPLACE MODEL `bqml_tutorial.london_station_clusters`
  OPTIONS(model_type='kmeans', num_clusters=4) AS
WITH
  hs AS (
  SELECT
    h.start_station_name AS station_name,
  IF
    (EXTRACT(DAYOFWEEK
      FROM
        h.start_date) = 1
      OR EXTRACT(DAYOFWEEK
      FROM
        h.start_date) = 7,
      "weekend",
      "weekday") AS isweekday,
    h.duration,
    ST_DISTANCE(ST_GEOGPOINT(s.longitude,
        s.latitude),
      ST_GEOGPOINT(-0.1,
        51.5))/1000 AS distance_from_city_center
  FROM
    `bigquery-public-data.london_bicycles.cycle_hire` AS h
  JOIN
    `bigquery-public-data.london_bicycles.cycle_stations` AS s
  ON
    h.start_station_id = s.id
  WHERE
    h.start_date BETWEEN CAST('2015-01-01 00:00:00' AS TIMESTAMP)
    AND CAST('2016-01-01 00:00:00' AS TIMESTAMP) ),
  stationstats AS (
  SELECT
    station_name,
    isweekday,
    AVG(duration) AS duration,
    COUNT(duration) AS num_trips,
    MAX(distance_from_city_center) AS distance_from_city_center
  FROM
    hs
  GROUP BY
    station_name, isweekday)
SELECT
  * EXCEPT(station_name, isweekday)
FROM
  stationstats

Nota: al termine dell'esecuzione del comando SQL riportato sopra, dovresti ricevere la seguente risposta:

Creazione del modello denominato london_station_clusters riuscita.

3. Nel riquadro di navigazione, nella sezione Risorse, espandi il nome del progetto, fai clic su bqml_tutorial e poi su london_station_clusters.
4. Fai clic sulla scheda Schema. Lo schema del modello elenca i tre attributi della stazione utilizzati da BigQuery ML per eseguire il clustering. Lo schema dovrebbe avere il seguente aspetto:

5. Fai clic sulla scheda Valutazione. Questa scheda mostra le visualizzazioni dei cluster identificati dal modello k-means. In Funzionalità numeriche, i grafici a barre mostrano fino a 10 dei valori delle funzionalità numeriche più importanti per ogni centroide. Puoi selezionare le funzionalità da visualizzare dal menu a discesa.

7. Ottenere le previsioni di BigQuery ML utilizzando l'SDK ABAP per Google Cloud

Ora che hai configurato i prerequisiti lato Google Cloud, puoi completare i passaggi nel sistema SAP per ottenere le previsioni dal modello di ML utilizzando l'SDK ABAP per Google Cloud.

Creare la configurazione della chiave client

Per la configurazione relativa all'autenticazione e alla connettività, l'ABAP SDK for Google Cloud utilizza le tabelle /GOOG/CLIENT_KEY e /GOOG/SERVIC_MAP.

Per mantenere la configurazione nella tabella /GOOG/CLIENT_KEY, svolgi i seguenti passaggi:

1. In SAP GUI, inserisci il codice transazione SPRO.
2. Fai clic su SAP Reference IMG (Immagine di riferimento SAP).
3. Fai clic su ABAP SDK for Google Cloud > Impostazioni di base > Configura chiave client

4. Mantieni i seguenti valori per i campi elencati e lascia vuoti tutti gli altri campi:

Campo	Valore
Nome della chiave Google Cloud	BIGQUERY_ML
Nome dell'account di servizio Google Cloud	[e-mail]
Ambito Google Cloud	https://www.googleapis.com/auth/cloud-platform
ID progetto	abap-sdk-poc
Classe di autorizzazione	/GOOG/CL_AUTH_GOOGLE

Nota: la configurazione della tabella /GOOG/SERVIC_MAP è facoltativa e può essere saltata in questo caso.

Creare un report ABAP per ottenere le previsioni dal modello BigQuery ML

Per creare un report ABAP, svolgi i seguenti passaggi:

1. In SAP GUI, vai al codice transazione SE38 e crea un programma report con il nome ZDEMO_BIGQUERY_ML_PREDICT.
2. Nel popup visualizzato, fornisci i dettagli come mostrato nella seguente immagine:

3. Nel popup successivo, seleziona Oggetto locale o fornisci un nome del pacchetto, a seconda dei casi.
4. Nell'editor ABAP, aggiungi il seguente codice:

REPORT zdemo_bigquery_ml_predict.

types:
  begin of lty_query_result,
    centroid_id     type i,
    station_name    type string,
    isweekday       type string,
    num_trips       type i,
    distance_from_city type string,
  end of lty_query_result,
  ltt_query_result type standard table of lty_query_result.

DATA:
  lv_project_id TYPE string,
  ls_input      TYPE /goog/cl_bigquery_v2=>ty_103,
  ls_output     TYPE lty_query_result,
  lt_output     TYPE ltt_query_result.

CONSTANTS:
  lc_newline TYPE c VALUE cl_abap_char_utilities=>newline.

TRY.
    "Initialize Bigquery object, pass the client key name that you have configured in /GOOG/CLIENT_KEY table
    DATA(lo_bq) = NEW /goog/cl_bigquery_v2( iv_key_name = 'BIGQUERY_ML' ).

    "Populate relevant parameters
    lv_project_id = lo_bq->gv_project_id.

    ls_input-default_dataset-project_id = 'abap-sdk-poc'.
    ls_input-default_dataset-dataset_id = 'bqml_tutorial'.

    "This query gets predictions from
    ls_input-query =
                | WITH | && lc_newline &&
                | hs AS ( | && lc_newline &&
                | SELECT | && lc_newline &&
                | h.start_station_name AS station_name, | && lc_newline &&
                | IF | && lc_newline &&
                | (EXTRACT(DAYOFWEEK | && lc_newline &&
                | FROM | && lc_newline &&
                | h.start_date) = 1 | && lc_newline &&
                | OR EXTRACT(DAYOFWEEK | && lc_newline &&
                | FROM | && lc_newline &&
                | h.start_date) = 7, | && lc_newline &&
                | "weekend", | && lc_newline &&
                | "weekday") AS isweekday, | && lc_newline &&
                | h.duration, | && lc_newline &&
                | ST_DISTANCE(ST_GEOGPOINT(s.longitude, | && lc_newline &&
                | s.latitude), | && lc_newline &&
                | ST_GEOGPOINT(-0.1, | && lc_newline &&
                | 51.5))/1000 AS distance_from_city_center | && lc_newline &&
                | FROM | && lc_newline &&
                | `bigquery-public-data.london_bicycles.cycle_hire` AS h | && lc_newline &&
                | JOIN | && lc_newline &&
                | `bigquery-public-data.london_bicycles.cycle_stations` AS s | && lc_newline &&
                | ON | && lc_newline &&
                | h.start_station_id = s.id | && lc_newline &&
                | WHERE | && lc_newline &&
                | h.start_date BETWEEN CAST('2015-01-01 00:00:00' AS TIMESTAMP) | && lc_newline &&
                | AND CAST('2016-01-01 00:00:00' AS TIMESTAMP) ), | && lc_newline &&
                | stationstats AS ( | && lc_newline &&
                | SELECT | && lc_newline &&
                | station_name, | && lc_newline &&
                | isweekday, | && lc_newline &&
                | AVG(duration) AS duration, | && lc_newline &&
                | COUNT(duration) AS num_trips, | && lc_newline &&
                | MAX(distance_from_city_center) AS distance_from_city_center | && lc_newline &&
                | FROM | && lc_newline &&
                | hs | && lc_newline &&
                | GROUP BY | && lc_newline &&
                | station_name, isweekday ) | && lc_newline &&
                | SELECT | && lc_newline &&
                | * EXCEPT(nearest_centroids_distance) | && lc_newline &&
                | FROM | && lc_newline &&
                | ML.PREDICT( MODEL `bqml_tutorial.london_station_clusters`, | && lc_newline &&
                | ( | && lc_newline &&
                | SELECT | && lc_newline &&
                | * | && lc_newline &&
                | FROM | && lc_newline &&
                | stationstats | && lc_newline &&
                | WHERE | && lc_newline &&
                | REGEXP_CONTAINS(station_name, 'Kennington'))) |.

    "Call API method: bigquery.jobs.query
    CALL METHOD lo_bq->query_jobs
      EXPORTING
        iv_p_project_id = lv_project_id
        is_input        = ls_input
      IMPORTING
        es_output       = DATA(ls_response)
        ev_ret_code     = DATA(lv_ret_code)
        ev_err_text     = DATA(lv_err_text)
        es_err_resp     = DATA(ls_err_resp).

    IF lo_bq->is_success( lv_ret_code ).
      "API Call successful, loop through the data & display the result
      IF ls_response-job_complete = abap_true.
        LOOP AT ls_response-rows ASSIGNING FIELD-SYMBOL(<ls_row>).
          LOOP AT <ls_row>-f ASSIGNING FIELD-SYMBOL(<ls_value>).
            ASSIGN <ls_value>-v->* TO FIELD-SYMBOL(<ls_field_value>).
            CASE sy-tabix.
              WHEN 1.
                ls_output-centroid_id = <ls_field_value>.
              WHEN 2.
                ls_output-station_name = <ls_field_value>.
              WHEN 3.
                ls_output-isweekday = <ls_field_value>.
              WHEN 4.
                ls_output-num_trips = <ls_field_value>.
              WHEN 5.
                ls_output-distance_from_city = <ls_field_value>.
            ENDCASE.
          ENDLOOP.
          APPEND ls_output TO lt_output.
          CLEAR ls_output.
        ENDLOOP.
        IF lt_output IS NOT INITIAL.
          cl_demo_output=>new( )->begin_section( 'ML.Predict Query Details'
                               )->write_text( ls_input-query
                               )->write_text( 'Dataset: bigquery-public-data.london_bicycles'
                               )->end_section(
                               )->begin_section( 'ML.Predict Query Results'
                               )->write_data( lt_output
                               )->end_section(
                               )->display( ).
        ENDIF.
      ENDIF.
    ELSE.
      "Display error message in case the API call fails
      MESSAGE lv_err_text TYPE 'E'.
    ENDIF.

    "Close HTTP Connection
    lo_bq->close( ).

  CATCH /goog/cx_sdk INTO DATA(lo_exception).
    MESSAGE lo_exception->get_text( ) TYPE 'E'.
ENDTRY.

5. Salva ed esegui il report.
6. Esegui il report (F8).

Al termine dell'esecuzione, dovresti visualizzare l'output del report come mostrato di seguito:

8. Complimenti

Ottimo lavoro per aver completato il codelab "Ottieni le previsioni da un modello di BigQuery Machine Learning (ML) utilizzando l'SDK ABAP per Google Cloud".

Hai recuperato correttamente le previsioni di un modello BigQuery Machine Learning direttamente dal tuo sistema SAP. Hai sbloccato un nuovo livello di integrazione tra ABAP e i servizi Google Cloud. Amplia i tuoi orizzonti con altri interessanti codelab per ABAP SDK for Google Cloud:

• Utilizzo dell'API Translation con l'SDK ABAP per Google Cloud
• Caricare un oggetto di grandi dimensioni in un bucket Cloud Storage utilizzando il chunking
• Recupero delle credenziali/degli secret da Secret Manager con l'SDK ABAP per Google Cloud
• Chiama Vertex AI test-bison da ABAP

9. Esegui la pulizia

Se non vuoi continuare con i codelab aggiuntivi relativi all'SDK ABAP per Google Cloud, procedi con la pulizia.

Elimina il progetto

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à in questo documento, quando lo elimini elimini anche tutto il lavoro 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, il riuso dei progetti può aiutarti a non superare i limiti di quota.

• Elimina il progetto Google Cloud:

gcloud projects delete abap-sdk-poc

Eliminare singole risorse

1. Elimina l'istanza di calcolo:

gcloud compute instances delete abap-trial-docker

2. Elimina le regole firewall:

gcloud compute firewall-rules delete sapmachine

3. Elimina l'account di servizio:

gcloud iam service-accounts delete \
    [e-mail]