Cortex para Meridian

Esta página detalha o processo de preparação de dados e automação da nuvem para o Google Meridian. O Cortex Framework para o Meridian simplifica a modelagem de mix de marketing (MMM) de código aberto com dados de vendas e crossmedia. O Cortex Framework simplifica esse processo fornecendo modelos de dados pré-configurados e automatizando a execução do modelo de código aberto do Meridian usando serviços do Google Cloud , como o Colab Enterprise e Workflows.

Uma das principais propostas de valor do Google Cloud Cortex Framework é fornecer uma base de dados e inteligência artificial (IA) para a inteligência empresarial de próxima geração, que permite análises em áreas importantes, como vendas, marketing, atendimento de pedidos e gerenciamento de inventário.

O Cortex Framework para marketing oferece indicadores principais de performance (KPIs) e métricas de plataforma crossmedia. Essas métricas são uma parte importante da etapa de preparação de dados antes da modelagem para executar a MMM de código aberto mais recente do Google, chamada Meridian. Os anunciantes, as agências e os parceiros podem acelerar o processo de preparação de dados pré-modelagem usando a base de dados do Cortex Framework do Google Cloud.

O Cortex para Meridian simplifica o processo de pré-modelagem ao coletar e transformar dados de maneira eficiente das principais fontes de dados do Cortex Framework, incluindo:

• Insights de produtos conectados e crossmedia.
• SAP (ECC e S/4 HANA)
• Oracle EBS

Para mais informações, consulte a documentação do Meridian.

Arquivo de configuração

Durante a execução do notebook, o sistema recupera parâmetros de configuração do arquivo cortex_meridian_config.json localizado na pasta configuration no Cloud Storage.

A seção a seguir compartilha diferentes exemplos de arquivos YAML de configuração para execução do Meridian:

{
  "cortex_bq_project_id": "PROJECT_ID",
  "cortex_meridian_marketing_data_set_id": "K9_REPORTING",
  "cortex_meridian_marketing_view_name": "CrossMediaSalesInsightsWeeklyAgg",
  "column_mappings": {
      "controls": [],
      "geo": "geo",
      "kpi": "number_of_sales_orders",
      "media": [
          "Tiktok_impression",
          "Meta_impression",
          "YouTube_impression",
          "GoogleAds_impression"
      ],
      "media_spend": [
          "Tiktok_spend",
          "Meta_spend",
          "YouTube_spend",
          "GoogleAds_spend"
      ],
      "population": "population",
      "revenue_per_kpi": "average_revenue_per_sales_order",
      "time": "time"
  },
  "channel_names": [
      "TikTok",
      "Meta",
      "YouTube",
      "GoogleAds"
  ],
  "data_processing": {
      "kpi_type": "{USE_CASE_SPECIFIC}",
      "roi_mu": {USE_CASE_SPECIFIC},
      "roi_sigma": {USE_CASE_SPECIFIC},
      "sample": {
          "prior": {USE_CASE_SPECIFIC},
          "posterior": {
              "n_chains": {USE_CASE_SPECIFIC},
              "n_adapt": {USE_CASE_SPECIFIC},
              "n_burnin": {USE_CASE_SPECIFIC},
              "n_keep": {USE_CASE_SPECIFIC}
          }
      }
  }
}

...
    "kpi": "conversions",
    "revenue_per_kpi": "",
...

A tabela a seguir descreve o valor de cada parâmetro de configuração do arquivo cortex_meridian_config.json:

Compatibilidade com o Meridian

O Cortex Framework Data Foundation e o Meridian são lançados separadamente. As notas da versão do Cortex Framework oferecem uma visão geral dos lançamentos e versões. No repositório do Meridian no GitHub, você encontra as versões mais recentes disponíveis. Os pré-requisitos e as recomendações do sistema do Meridian estão disponíveis no guia do usuário do Meridian.

As versões do Cortex Framework Data Foundation são testadas com uma versão específica do Meridian. Você pode encontrar o Meridian compatível no notebook do Jupyter, conforme mostrado na imagem a seguir:

Para atualizar para uma versão mais recente do Meridian, modifique a linha correspondente no notebook. Considere que ajustes adicionais de código podem ser necessários no notebook.

Modelo de dados

Esta seção descreve o modelo de dados CrossMediaSalesInsightsWeeklyAgg usando o diagrama de entidade-relacionamento (DER).

O Cortex para Meridian depende de uma única visualização, CrossMediaSalesInsightsWeeklyAgg, para operar. A fonte de dados dessa visualização é determinada pela configuração k9.Meridian.salesDataSourceType, que pode ser:

• BYOD (Use seus próprios dados): integração de dados personalizada.
• SAP_SALES: dados de vendas dos sistemas SAP.
• ORACLE_SALES: dados de vendas dos sistemas Oracle EBS.

A seção a seguir compartilha os diagramas de relacionamento de entidades para CrossMediaForMeridian:

A tabela a seguir mostra o esquema detalhado da visualização CrossMediaSalesInsightsWeeklyAgg, que faz parte do Cortex para Meridian:

Implantação

Esta página descreve as etapas para implantar o Cortex Framework no Meridian, permitindo a melhor MMM da categoria no seu ambiente Google Cloud .

Para uma demonstração de início rápido, consulte Demonstração de início rápido do Meridian.

Arquitetura

O Cortex para Meridian usa o Cortex Framework para marketing e dados crossmedia combinados com dados de vendas. É possível trazer dados de vendas do Oracle EBS, do SAP ou de outro sistema de origem.

O diagrama a seguir descreve os principais componentes do Cortex para Meridian:

Componentes e serviços do Meridian

Durante a implantação do Cortex Framework Data Foundation (consulte os pré-requisitos de implantação), é possível ativar o Cortex para o Meridian definindo deployMeridian como true no arquivo config.json. Essa opção inicia um pipeline adicional do Cloud Build, que instala os seguintes componentes e serviços necessários para o Meridian:

• Visualização do BigQuery: uma visualização é criada no conjunto de dados de relatórios do K9 chamado CrossMediaSalesInsightsWeeklyAgg. Isso permite consultar dados de marketing e vendas do Cortex Framework. A implementação real da visualização e das fontes subjacentes depende da fonte de dados de vendas que você seleciona durante a implantação.

• Bucket do Cloud Storage:o bucket PROJECT_ID-cortex-meridian contém todos os artefatos necessários e produzidos pelo Cortex para Meridian nas seguintes pastas:

  • configuration: defina as configurações e os parâmetros do Cortex para o Meridian. Ele é usado pelo notebook do Colab Enterprise durante a execução.
  • csv: a saída de dados brutos da execução do Meridian será salva como arquivos CSV aqui.
  • models: o modelo gerado ao executar o Meridian será salvo aqui.
  • notebook-run-logs: as cópias de notebook para cada execução e os registros serão salvos aqui.
  • notebooks: contém o notebook principal com código e lógica para executar o Cortex para Meridian. Este notebook foi criado para mais personalizações que atendam às suas necessidades e requisitos específicos.
  • reporting: é a pasta em que os relatórios das execuções do Meridian serão salvos. Também contém um modelo HTML para gerar um relatório de visão geral com links para a saída do relatório do Meridian.

• Colab Enterprise:o Colab Enterprise é um serviço gerenciado no Google Cloud que oferece um ambiente seguro e colaborativo para fluxos de trabalho de ciência de dados e machine learning usando notebooks Jupyter. Ele oferece recursos como infraestrutura gerenciada, controles de segurança de nível empresarial e integração com outros serviços do Google Cloud , o que o torna adequado para equipes que trabalham com dados sensíveis e exigem governança robusta. Um ambiente gerenciado para executar o notebook do Jupyter.

O Cortex para Meridian usa o Colab Enterprise para definir um modelo de ambiente de execução com a infraestrutura necessária para automatizar as execuções do Meridian.

Ao acionar o pipeline de ponta a ponta usando o fluxo de trabalho, uma execução é criada. Isso vai executar uma cópia do notebook Jupyter atual do Cloud Storage com a configuração mais recente.

• Fluxo de trabalho:um fluxo de trabalho do Cloud chamado cortex-meridian-execute-notebook orquestra a execução de todo o pipeline do Cortex para Meridian. O fluxo de trabalho vai chamar a API Colab Enterprise, que cria um ambiente de execução com base no modelo e executa um notebook com as configurações atuais. Por fim, ele salva todos os resultados no Cloud Storage.

  

  Há duas opções de configuração opcionais disponíveis para o fluxo de trabalho:

  1. Se você puder fornecer uma nova configuração JSON do Cortex para Meridian como entrada para o fluxo de trabalho. Se você fizer isso, o fluxo fará um backup da configuração antiga e a atualizará com sua entrada. Consulte REPLACE para mais informações.

  

  1. A etapa pre_notebook_execution é um excelente lugar para iniciar outras tarefas que você precisa automatizar antes de executar o notebook. Por exemplo, carregar dados de fontes fora do Google Cloud Cortex Framework.

• Conta de serviço: uma conta de serviço dedicada precisa ser fornecida durante a implantação. Isso é necessário para executar o fluxo de trabalho e o notebook no Colab Enterprise.

Outros parâmetros de implantação para o Meridian

O arquivo config.json configura as definições necessárias para executar o Meridian com o Cortex Framework. Esse arquivo contém os seguintes parâmetros para o Cortex for Meridian:

   "k9": {
...
        "deployMeridian": false,
...

    "Meridian":{
            "salesDataSourceType": "",
            "salesDatasetID":"",
            "deploymentType": "",
            "defaultNotebookFile":"meridian_cortex_marketing.ipynb",
            "defaultConfigFile":"cortex_meridian_config.json",
            "gcsBucketNameSuffix": "cortex-meridian",
            "workflow": {
                "template": "create_notebook_execution_run.yaml",
                "name": "cortex-meridian-execute-notebook",
                "region": "us-central1"
            },
            "runnerServiceAccount": "cortex-meridian-colab-runner",
            "colabEnterprise": {
                "region": "us-central1",
                "runtimeTemplateName": "cortex-meridian-template",
                "runtimeMachine_type": "n1-highmem-32",
                "runtimeAcceleratorCoreCount": 1,
                "runtimeAcceleratorType": "NVIDIA_TESLA_T4",
                "executionName": "cortex-meridian-execution",
                "notebookRunLogsFolder": "notebook-run-logs"
            }
        }
}

A tabela a seguir descreve o valor e a descrição de cada parâmetro do Meridian:

Fluxo de trabalho

Os fluxos de trabalho são a principal interface para iniciar as execuções do Cortex para Meridian. Um fluxo de trabalho padrão chamado cortex-meridian-execute-notebook é implantado como parte do Cortex para Meridian.

Execução do notebook

Para iniciar uma nova execução do Cortex para Meridian, siga estas etapas:

1. Acesse o notebook cortex-meridian-execute-notebook em Workflows.
2. Clique em Executar para iniciar uma nova execução.
3. Para as execuções iniciais, deixe o campo de entrada vazio para usar a configuração padrão armazenada no arquivo de configuração cortex_meridian_config.json no Cloud Storage.
4. Clique em Executar novamente para continuar.

5. Após um breve atraso, o status da execução do fluxo de trabalho será exibido:

   

6. Acompanhe o progresso da execução do notebook no Colab Enterprise.

Etapas do fluxo de trabalho

O fluxo de trabalho cortex-meridian-execute-notebook contém as seguintes etapas:

Personalizar o fluxo de trabalho de execução do Meridian

É possível personalizar a execução do Meridian fornecendo seu próprio arquivo JSON de configuração no campo de entrada do Workflows:

1. Insira o JSON completo da configuração modificada no campo de entrada.
2. O fluxo de trabalho vai:
   1. Substitua o arquivo cortex_meridian_config.json atual no Cloud Storage pelo JSON fornecido.
   2. Crie um backup do arquivo de configuração original no diretório Cloud Storage/configuration.
   3. O nome do arquivo de backup vai seguir o formato cortex_meridian_config_workflow_backup_workflow_execution_id.json, em que workflow_execution_id é um identificador exclusivo para a execução do fluxo de trabalho atual (por exemplo, cortex_meridian_config_workflow_backup_3e3a5290-fac0-4d51-be5a-19b55b2545de.json)

Visão geral dos notebooks do Jupyter

A funcionalidade principal de carregamento de dados de entrada para executar o modelo do Meridian é processada pelo notebook Python meridian_cortex_marketing.ipynb, localizado na pasta notebooks do seu bucket do Cloud Storage.

O fluxo de execução do notebook consiste nas seguintes etapas:

1. Instale os pacotes necessários (incluindo o Meridian) e importe as bibliotecas necessárias.
2. Carregue funções auxiliares para interagir com o Cloud Storage e o BigQuery.
3. Recupera a configuração de execução do arquivo configuration/cortex_meridian_config.json no Cloud Storage.
4. Carregue os dados do Cortex Framework na visualização "Base de dados do Cortex Framework" no BigQuery.
5. Configure a especificação do modelo do Meridian e mapeie os modelos de dados da Data Foundation do Cortex Framework para marketing e vendas no esquema de entrada do modelo do Meridian.
6. Executa a amostragem do Meridian e gera um relatório de resumo, salvo no Cloud Storage (/reporting).
7. Execute o otimizador de orçamento para o cenário padrão e gere um relatório de resumo no Cloud Storage (/reporting).
8. Salve o modelo no Cloud Storage (/models).
9. Salve os resultados CSV no Cloud Storage (/csv).
10. Gere um relatório de visão geral e salve-o no Cloud Storage (/reporting).

Importar notebook para execução e edição manuais

Para personalizar ou executar manualmente o notebook, importe-o do Cloud Storage:

1. Acesse o Colab Enterprise.
2. Clique em Meus notebooks.
3. Clique em Importar.
4. Selecione Cloud Storage como origem da importação e escolha o notebook do Cloud Storage.
5. Clique em Importar.

6. O notebook será carregado e aberto.

Resultados das execuções de notebook

Para analisar os resultados da execução do notebook, abra uma cópia completa dele com todas as saídas de células:

1. Acesse Execuções no Colab Enterprise.
2. Selecione a região relevante no menu suspenso.
3. Ao lado da execução do notebook para que você quer ver os resultados, clique em Ver resultado.
4. O Colab Enterprise vai abrir o resultado da execução do notebook em uma nova guia.
5. Para conferir o resultado, clique na nova guia.

Modelo de ambiente de execução

Google Cloud O Colab Enterprise usa modelos de ambiente de execução para definir ambientes de execução pré-configurados. Um modelo de ambiente de execução predefinido, adequado para executar o notebook do Meridian, está incluído na implantação do Cortex para Meridian. Esse modelo é usado automaticamente para criar ambientes de execução para execuções de notebook.

Se necessário, você pode criar outros modelos de ambiente de execução manualmente.