Lire les prédictions BigQuery ML dans SAP à l'aide du SDK ABAP pour Google Cloud

1. Introduction

Dans cet atelier de programmation, vous allez créer un modèle de machine learning (ML) dans BigQuery et obtenir des prédictions à partir de ce modèle à l'aide du SDK ABAP pour Google Cloud.

Vous allez exploiter les services Google Cloud suivants:

  • BigQuery
  • Cloud Shell

Ce que vous allez faire

Vous allez créer les éléments suivants:

  • Un modèle BigQuery Machine Learning (ML)
  • Un compte de service doté du rôle "Utilisateur de tâche BigQuery" pour appeler l'API BigQuery
  • Un programme ABAP pour appeler l'API BigQuery et obtenir des prédictions à partir du modèle de ML

2. Conditions requises

  • Un navigateur (Chrome ou Firefox, par exemple)
  • Un projet Google Cloud avec la facturation activée ou créez un compte d'essai sans frais de 90 jours pour Google Cloud Platform.
  • L'IUG SAP (Windows ou Java) doit être installée sur votre système. Si l'IUG SAP est déjà installée sur votre ordinateur portable, connectez-vous à SAP en utilisant l'adresse IP externe de la VM comme adresse IP du serveur d'applications. Si vous utilisez Mac, vous pouvez également installer l'IUG SAP pour Java disponible en cliquant sur ce lien.

3. Avant de commencer

6757b2fb50ddcc2d.png

  • Exécutez les commandes suivantes dans Cloud Shell pour authentifier votre compte et définir le projet par défaut sur abap-sdk-poc. La zone us-west4-b est utilisée à titre d'exemple. Si nécessaire, veuillez modifier le projet et la zone à l'aide des commandes suivantes, en fonction de vos préférences.
gcloud auth login
gcloud config set project abap-sdk-poc
gcloud config set compute/zone us-west4-b
  • Vous devez avoir accès à un système SAP sur lequel le SDK ABAP pour Google Cloud est installé.
  • Avant de poursuivre cet atelier de programmation, vous devez suivre l'atelier de programmation 1 (Installer la plate-forme ABAP d'essai 1909 sur Google Cloud Platform et installer le SDK ABAP pour Google Cloud) et l'atelier de programmation 2 (Configurer l'authentification du SDK ABAP à l'aide de jetons pour SAP Hosted on Compute Engine) avant de poursuivre cet atelier de programmation.
  • Si vous avez terminé les ateliers 1 et 2, vous disposez d'un système ABAP Platform Trial 1909 sur Google Cloud, ainsi que de la configuration requise pour l'authentification et la connectivité.
  • Si vous n'avez pas terminé l'atelier de programmation 1 et 2, vous ne disposez pas de l'infrastructure et de la connectivité requises pour suivre les étapes de cet atelier de programmation. Par conséquent, vous devez terminer l'atelier de programmation 1 et l'atelier de programmation 2 avant de poursuivre cet atelier de programmation.

4. Activer l'API BigQuery V2 dans votre projet Google Cloud

  1. Dans la console Cloud, cliquez sur Activer Cloud Shell en haut à droite:

6757b2fb50ddcc2d.png

  1. Exécutez les commandes suivantes dans Cloud Shell pour activer l'API BigQuery:
gcloud services enable bigquery.googleapis.com

Si l'exécution réussit, le message suivant doit s'afficher :

b5f52859df2c2f56.png

L'API BigQuery doit maintenant être activée dans votre projet Google Cloud.

5. Créer un compte de service pour sécuriser l'accès à BigQuery

Pour obtenir des prédictions de ML de façon sécurisée à partir d'un modèle BigQuery ML, vous devez créer un compte de service avec les rôles Utilisateur de job BigQuery et Lecteur de données BigQuery. Cela permettra à votre programme d'exécuter des requêtes (en tant que jobs) dans le projet et de lire les données des tables. Ce rôle n'accorde que l'autorisation nécessaire pour créer des jobs et lire des données, réduisant ainsi les risques de sécurité.

Créer un compte de service

Pour créer un compte de service avec le rôle requis, procédez comme suit:

  1. Exécutez la commande suivante dans le terminal Cloud Shell :
gcloud iam service-accounts create abap-sdk-bigquery-jobuser --display-name="Service Account for BigQuery Job user"
  1. Ajoutez maintenant les rôles requis au compte de service créé à l'étape précédente:
gcloud projects add-iam-policy-binding abap-sdk-poc --member='serviceAccount:abap-sdk-bigquery-jobuser@abap-sdk-poc.iam.gserviceaccount.com' --role='roles/bigquery.jobUser'

gcloud projects add-iam-policy-binding abap-sdk-poc --member='serviceAccount:abap-sdk-bigquery-jobuser@abap-sdk-poc.iam.gserviceaccount.com' --role='roles/bigquery.dataViewer'

La commande ci-dessus utilise abap-sdk-poc comme espace réservé pour le projet Google Cloud. Remplacez abap-sdk-poc par l'ID de votre projet.

  1. Pour vérifier que le rôle a été ajouté, accédez à la page IAM. Le compte de service que vous avez créé doit s'afficher avec le rôle qui lui a été attribué.

6. Créer un modèle BigQuery Machine Learning

Dans cet atelier de programmation, nous allons créer un modèle de k-moyennes pour regrouper l'ensemble de données "Location de vélos à Londres". Vous pouvez appliquer l'algorithme k-moyennes pour regrouper vos données en clusters. Contrairement au machine learning supervisé, qui concerne l'analyse prédictive, l'apprentissage non supervisé consiste à analyser des données descriptives. Il s'agit de comprendre vos données afin de pouvoir prendre des décisions basées sur les données.

Créer votre ensemble de données

Pour créer un ensemble de données BigQuery afin de stocker votre modèle de ML, procédez comme suit:

  1. Dans la console Google Cloud, accédez à la page "BigQuery". Accéder à la page "BigQuery"
  2. Dans le volet Explorateur, cliquez sur le nom de votre projet.
  3. Cliquez sur 5cf3b742649f1e2c.png Afficher les actions > Créer un ensemble de données

3fbc072041bfa313.png

  1. Sur la page Créer un ensemble de données, procédez comme suit :
  • Dans le champ ID de l'ensemble de données, saisissez bqml_tutorial.
  • Pour Type d'emplacement, sélectionnez Multirégional, puis UE (plusieurs régions dans l'Union européenne). L'ensemble de données public "London Bicycle Hires" est stocké dans l'ensemble de données multirégional de l'UE. Votre ensemble de données doit se trouver dans le même emplacement.
  • Conservez les autres paramètres par défaut, puis cliquez sur Créer l'ensemble de données. Créer une page d'ensemble de données

Créer un modèle de k-moyennes

Maintenant que votre ensemble de données est configuré, l'étape suivante consiste à créer un modèle de k-moyennes à l'aide des données. Vous pouvez créer et entraîner un modèle de k-moyennes à l'aide de l'instruction CREATE MODEL avec l'option model_type=kmeans.

Pour exécuter la requête et créer un modèle de k-moyennes, procédez comme suit:

  1. Accédez à la page BigQuery. Accéder à BigQuery
  2. Dans le volet de l'éditeur, exécutez l'instruction SQL suivante :
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
  1. Dans la section Ressources du panneau de navigation, développez le nom de votre projet, cliquez sur bqml_tutorial, puis sur london_station_clusters.
  2. Cliquez sur l'onglet Schéma. Le schéma du modèle liste les trois attributs de station que BigQuery ML a utilisés pour effectuer le clustering. Le schéma doit se présenter comme suit:

5f1feb313bd0f6a5.png

  1. Cliquez sur l'onglet Évaluation. Cet onglet affiche les visualisations des clusters identifiés par le modèle de k-moyennes. Sous Caractéristiques numériques, les graphiques à barres affichent jusqu'à 10 des valeurs de caractéristiques numériques les plus importantes pour chaque centroïde. Vous pouvez sélectionner les caractéristiques à afficher dans le menu déroulant.

8f9b53971e33dc08.png

7. Obtenir des prédictions BigQuery ML à l'aide du SDK ABAP pour Google Cloud

Maintenant que vous avez configuré les conditions préalables côté Google Cloud, vous êtes prêt à effectuer les étapes nécessaires dans votre système SAP pour obtenir des prédictions à partir du modèle de ML à l'aide du SDK ABAP pour Google Cloud.

Créer une configuration de clé client

Pour la configuration de l'authentification et de la connectivité, le SDK ABAP pour Google Cloud utilise les tables /GOOG/CLIENT_KEY et /GOOG/SERVIC_MAP.

Pour conserver la configuration dans la table /GOOG/CLIENT_KEY, procédez comme suit:

  1. Dans l'IUG SAP, saisissez le code de transaction SPRO.
  2. Cliquez sur SAP Reference IMG.
  3. Cliquez sur ABAP SDK for Google Cloud > Paramètres généraux > Configurer la clé client

25871e639293b9ee.png

  1. Conservez les valeurs suivantes dans les champs répertoriés et laissez tous les autres champs vides:

Champ

Valeur

Nom de la clé Google Cloud

BIGQUERY_ML

Nom du compte de service Google Cloud

abap-sdk-bigquery-jobuser@abap-sdk-poc.iam.gserviceaccount.com

Champ d'application Google Cloud

https://www.googleapis.com/auth/cloud-platform

ID du projet

abap-sdk-poc

Classe d'autorisation

/GOOG/CL_AUTH_GOOGLE

Créer un rapport ABAP pour obtenir des prédictions à partir du modèle BigQuery ML

Pour générer un rapport ABAP, procédez comme suit:

  1. Dans votre IUG SAP, accédez au code de transaction SE38 et créez un programme de rapport nommé ZDEMO_BIGQUERY_ML_PREDICT..
  2. Dans le pop-up qui s'affiche, fournissez les détails indiqués dans l'image ci-dessous:

4cb32d50427df294.png

  1. Dans le pop-up suivant, sélectionnez Objet local ou indiquez un nom de package, le cas échéant.
  2. Dans l'éditeur ABAP, ajoutez le code suivant:
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.
  1. Enregistrez et activez le rapport.
  2. Exécutez le rapport (F8).

Si l'exécution réussit, un rapport doit s'afficher, comme illustré ci-dessous:

739e5685511fc9fc.png

6405542a597ed09f.png

8. Félicitations

Vous avez terminé l'atelier "Obtenir des prédictions à partir d'un modèle de machine learning (ML) BigQuery à l'aide du SDK ABAP pour Google Cloud". Félicitations ! codelab!

Vous avez réussi à récupérer les prédictions d'un modèle BigQuery Machine Learning directement depuis votre système SAP. Vous avez atteint un nouveau niveau d'intégration entre ABAP et les services Google Cloud. Élargissez vos horizons avec d'autres SDK ABAP intéressants pour les ateliers de programmation Google Cloud:

  • Utiliser l'API Translation avec le SDK ABAP pour Google Cloud
  • Importer un objet volumineux dans un bucket Cloud Storage à l'aide de la fragmentation
  • Récupérer les identifiants/secrets à partir de Secret Manager avec le SDK ABAP pour Google Cloud
  • Appeler le modèle de test Vertex AI à partir d'ABAP

9. Effectuer un nettoyage

Si vous ne souhaitez pas continuer avec les autres ateliers de programmation liés au SDK ABAP pour Google Cloud, veuillez procéder au nettoyage.

Supprimer le projet

  • Supprimez le projet Google Cloud:
gcloud projects delete abap-sdk-poc

Supprimer des ressources individuelles

  1. Supprimez l'instance de calcul:
gcloud compute instances delete abap-trial-docker
  1. Supprimez les règles de pare-feu:
gcloud compute firewall-rules delete sapmachine
  1. Supprimez le compte de service :
gcloud iam service-accounts delete \
    abap-sdk-bigquery-jobuser@abap-sdk-poc.iam.gserviceaccount.com