Ler previsões do BigQuery ML em SAP usando o SDK do ABAP para o Google Cloud

1. Introdução

Neste codelab, você vai criar um modelo de machine learning (ML) no BigQuery e receber previsões desse modelo usando o SDK do ABAP para Google Cloud.

Você utilizará os seguintes serviços do Google Cloud:

• BigQuery
• Cloud Shell

O que você vai criar

Você criará o seguinte:

• Um modelo de machine learning (ML) do BigQuery.
• Uma conta de serviço com o papel de usuário do job do BigQuery para chamar a API BigQuery.
• Um programa ABAP para chamar a API BigQuery e receber previsões do modelo de ML.

2. Requisitos

• Um navegador, como o Chrome ou o Firefox
• Um projeto do Google Cloud com faturamento ativado ou crie uma conta de teste sem custo financeiro de 90 dias no Google Cloud Platform.
• GUI do SAP (Windows ou Java) instalada no sistema. Se a GUI do SAP já estiver instalada no seu laptop, conecte-se ao SAP usando o endereço IP externo da VM como o IP do servidor de aplicativos. No Mac, também é possível instalar a GUI do SAP para Java, disponível neste link.

3. Antes de começar

• No console do Google Cloud, na página do seletor de projetos, selecione ou crie um projeto do Google Cloud (por exemplo: abap-sdk-poc).
• Verifique se o faturamento está ativado para seu projeto do Cloud. Saiba como verificar se o faturamento está ativado em um projeto. Pule esta etapa se você estiver usando a conta de teste sem custo financeiro de 90 dias.
• Você vai usar o Cloud Shell, um ambiente de linha de comando em execução no Google Cloud.
• No console do Cloud, clique em Ativar o Cloud Shell no canto superior direito:

• Execute os comandos a seguir no Cloud Shell para fazer a autenticação na sua conta e definir o projeto padrão como abap-sdk-poc. A zona us-west4-b é usada como exemplo. Se necessário, altere o projeto e a zona nos comandos a seguir de acordo com sua preferência.

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

• Você precisa ter acesso a um sistema SAP com o SDK do ABAP para Google Cloud instalado.
• Você precisa concluir o codelab 1 (Instalar o teste da plataforma ABAP 1909 no Google Cloud Platform e instalar o SDK do ABAP para o Google Cloud) e o codelab 2 (Configurar a autenticação do SDK do ABAP usando tokens para SAP hospedados na VM do Compute Engine) antes de continuar com este codelab.
• Se você concluiu o codelab 1 e o codelab 2, isso teria provisionado um sistema ABAP Platform Trial 1909 no Google Cloud, além da configuração necessária para autenticação e conectividade.
• Se você não concluiu o codelab 1 e o 2, não terá toda a infraestrutura e conectividade necessárias para realizar as etapas indicadas neste codelab. Portanto, você precisa concluir os codelabs 1 e 2 antes de continuar com este.

4. Ativar a API do BigQuery V2 no seu projeto do Google Cloud

1. No console do Cloud, clique em Ativar o Cloud Shell no canto superior direito:

2. Execute os comandos a seguir no Cloud Shell para ativar a API BigQuery:

gcloud services enable bigquery.googleapis.com

Após a execução, uma mensagem será exibida, conforme mostrado abaixo

A API BigQuery já deve estar ativada no seu projeto do Google Cloud.

5. Criar uma conta de serviço para acesso seguro ao BigQuery

Para receber previsões do ML com segurança usando um modelo do BigQuery ML, você precisa criar uma conta de serviço com os papéis Usuário de jobs do BigQuery e Leitor de dados do BigQuery. Isso permitirá que o programa execute consultas (como jobs) no projeto e leia dados das tabelas. Esse papel concede apenas a permissão necessária para criar jobs e ler dados, minimizando os riscos de segurança.

Criar uma conta de serviço

Para criar uma conta de serviço com o papel necessário, siga estas etapas:

1. Execute o seguinte comando no terminal do Cloud Shell:

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

Observação: após a execução do comando acima, você receberá a seguinte resposta:

Conta de serviço [abap-sdk-biguqery-jobuser] criada.

2. Agora adicione os papéis necessários à conta de serviço criada na etapa anterior:

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'

O comando acima usa abap-sdk-poc como um marcador para o projeto do Google Cloud. Substitua abap-sdk-poc pelo ID do projeto.

3. Para verificar se o papel foi adicionado, acesse a página IAM. A conta de serviço que você criou será listada com o papel atribuído a ela.

6. Como criar um modelo de machine learning do BigQuery

Neste codelab, vamos criar um modelo k-means para agrupar o conjunto de dados de aluguel de bicicletas em Londres. É possível aplicar o algoritmo k-means para agrupar seus dados em clusters. Ao contrário do machine learning supervisionado, que tem a ver com análise preditiva, o aprendizado não supervisionado tem a ver com análise descritiva. Trata-se de entender seus dados para que você possa tomar decisões com base em dados.

Crie seu conjunto de dados

Para criar um conjunto de dados do BigQuery e armazenar seu modelo de ML, siga estas etapas:

1. No console do Google Cloud, acesse a página do BigQuery. Acessar a página do BigQuery
2. No painel Explorer, clique no nome do seu projeto.
3. Clique em Ver ações > Criar conjunto de dados.

4. Na página Criar conjunto de dados, faça o seguinte:

• Para o código do conjunto de dados, insira bqml_tutorial.
• Em Tipo de local, selecione Multirregional e UE (várias regiões na União Europeia). O conjunto de dados público de Locações de Bicicletas de Londres é armazenado na multirregião da UE. O conjunto de dados precisa estar no mesmo local.
• Não altere as outras configurações e clique em Criar conjunto de dados.

Criar um modelo k-means

Agora que o conjunto de dados está configurado, a próxima etapa é criar um modelo k-means usando os dados. É possível criar e treinar um modelo k-means usando a instrução CREATE MODEL com a opção model_type=kmeans.

Para executar a consulta e criar um modelo k-means, execute as seguintes etapas:

1. Acessar a página do BigQuery. Acessar o BigQuery
2. No painel Editor, execute a seguinte instrução 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

Observação: após a execução do comando SQL acima, você receberá a seguinte resposta:

O modelo london_station_clusters foi criado.

3. No painel de navegação, na seção Recursos, expanda o nome do projeto, clique em bqml_tutorial e depois em london_station_clusters.
4. Clique na guia Esquema. O esquema do modelo lista os três atributos de estação que o BigQuery ML usou para realizar o clustering. O esquema será semelhante a este:

5. Clique na guia Avaliação. Essa guia exibe visualizações dos clusters identificados pelo modelo k-means. Em Atributos numéricos, os gráficos de barras exibem até 10 dos valores de atributos numéricos mais importantes para cada centroide. É possível selecionar quais recursos visualizar no menu suspenso.

7. Receber previsões do BigQuery ML usando o SDK do ABAP para o Google Cloud

Agora que você configurou os pré-requisitos do Google Cloud, já pode concluir as etapas no sistema SAP para receber previsões do modelo de ML usando o SDK do ABAP para Google Cloud.

Criar configuração da chave de cliente

Para configurações relacionadas à autenticação e conectividade, o SDK do ABAP para Google Cloud usa as tabelas /GOOG/CLIENT_KEY e /GOOG/SERVIC_MAP.

Para manter a configuração na tabela /GOOG/CLIENT_KEY, siga estas etapas:

1. Na GUI do SAP, insira o código de transação SPRO.
2. Clique em IMG de referência SAP.
3. Clique em ABAP SDK for Google Cloud > Configurações básicas > Configurar chave de cliente

4. Mantenha os seguintes valores em relação aos campos listados e deixe todos os outros em branco:

Campo	Valor
Nome da chave do Google Cloud	BIGQUERY_ML
Nome da conta de serviço do Google Cloud	[e-mail]
Escopo do Google Cloud	https://www.googleapis.com/auth/cloud-platform
ID do projeto	abap-sdk-poc
Classe de autorização	/GOOG/CL_AUTH_GOOGLE

Observação: a configuração da tabela /GOOG/SERVIC_MAP é opcional e pode ser ignorada nesse caso.

Criar um relatório ABAP para receber previsões do modelo do BigQuery ML

Para criar um relatório ABAP, siga estas etapas:

1. Na GUI do SAP, acesse o código de transação SE38 e crie um Programa de relatórios com o nome ZDEMO_BIGQUERY_ML_PREDICT.
2. No pop-up que aparece, forneça os detalhes como mostrado na imagem a seguir:

3. No próximo pop-up, selecione Objeto local ou forneça um nome de pacote conforme apropriado.
4. No Editor do ABAP, adicione o seguinte código:

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. Salve e ative o relatório.
6. Execute o relatório (F8).

Após a execução, você verá uma saída de relatório, conforme mostrado abaixo:

8. Parabéns

Excelente trabalho na conclusão de "Receber previsões de um modelo de machine learning (ML) do BigQuery usando o SDK do ABAP para Google Cloud" codelab!

Você recuperou as previsões de um modelo de machine learning do BigQuery diretamente do seu sistema SAP. Você desbloqueou um novo nível de integração entre o ABAP e os serviços do Google Cloud. Amplie seus horizontes com outros codelabs incríveis do SDK do ABAP para o Google Cloud:

• Como usar a API Translation com o SDK do ABAP para o Google Cloud
• Fazer upload de um objeto grande em um bucket do Cloud Storage usando a divisão
• Como recuperar credenciais/segredos do Secret Manager com o SDK do ABAP para o Google Cloud
• Chamar o test-bison da Vertex AI pelo ABAP

9. Limpar

Caso não queira continuar com os codelabs adicionais relacionados ao SDK do ABAP para Google Cloud, faça a limpeza.

Excluir o projeto

Cuidado: excluir um projeto tem os seguintes efeitos:

• Tudo no projeto é excluído. Se você usou um projeto existente para as tarefas deste documento, ao excluí-lo, você também exclui qualquer outro trabalho feito no projeto.
• Os IDs do projeto personalizados são perdidos. Ao criar o projeto, você pode ter criado um ID do projeto personalizado para ser usado no futuro. Para preservar os URLs que usam o ID do projeto, como um URL appspot.com, exclua os recursos selecionados do projeto em vez de excluir o projeto inteiro.

Se você planeja explorar várias arquiteturas, tutoriais ou guias de início rápido, a reutilização de projetos pode evitar que você exceda os limites de cota do projeto.

• Exclua o projeto do Google Cloud:

gcloud projects delete abap-sdk-poc

Excluir recursos individuais

1. Exclua a instância de computação:

gcloud compute instances delete abap-trial-docker

2. Exclua as regras de firewall:

gcloud compute firewall-rules delete sapmachine

3. Exclua a conta de serviço:

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