Criar um modelo usando o JupyterLab Notebooks

Este tutorial percorre as etapas necessárias para criar um modelo usando o modelo do construtor de fórmula de notebooks JupyterLab.

Conceitos introduzidos:

Baixar os ativos necessários assets

Antes de prosseguir com este tutorial, você deve criar os esquemas e conjuntos de dados necessários. Visite o tutorial para criação de esquemas e conjuntos de dados do modelo de propensão Luma para baixar os ativos necessários e configurar os pré-requisitos.

Introdução ao ambiente de bloco de anotações JupyterLab

A criação de uma fórmula do zero pode ser feita em Data Science Workspace. Para iniciar, navegue até Adobe Experience Platform e selecione a guia Blocos de Anotações à esquerda. Para criar um novo bloco de anotações, selecione o modelo de Construtor de Fórmulas no JupyterLab Launcher.

O bloco de anotações Construtor de Fórmulas permite executar treinamentos e execuções de pontuação dentro do bloco de anotações. Isso dá a você a flexibilidade de fazer alterações nos métodos train() e score() entre a execução de experimentos nos dados de treinamento e pontuação. Quando estiver satisfeito com os resultados do treinamento e a pontuação, você poderá criar uma fórmula e, além disso, publicá-la como um modelo usando a funcionalidade receita para modelo.

Quando você seleciona o bloco de anotações Construtor de Fórmulas no iniciador, o bloco de anotações é aberto em uma nova guia.

Na nova guia do bloco de anotações na parte superior, é carregada uma barra de ferramentas contendo três ações adicionais: Treinar, Pontuação e Criar fórmula. Estes ícones só aparecem no bloco de anotações Construtor de Fórmulas. Mais informações sobre essas ações são fornecidas na seção de treinamento e pontuação após criar sua fórmula no bloco de anotações.

Introdução ao bloco de anotações Construtor de fórmula

Na pasta de ativos fornecida, há um modelo de propensão Luma propensity_model.ipynb. Usando a opção de carregar notebook no JupyterLab, carregue o modelo fornecido e abra o notebook.

O restante deste tutorial aborda os seguintes arquivos que são predefinidos no bloco de anotações do modelo de propensão:

O tutorial em vídeo a seguir explica o bloco de anotações do modelo de propensão Luma:

Arquivo de requisitos requirements-file

O arquivo de requisitos é usado para declarar bibliotecas adicionais que você deseja usar no modelo. Você pode especificar o número da versão se houver uma dependência. Para procurar bibliotecas adicionais, visite anaconda.org. Para saber como formatar o arquivo de requisitos, visite Conda. A lista de bibliotecas principais já em uso inclui:

python=3.6.7
scikit-learn
pandas
numpy
data_access_sdk_python

Para o notebook modelo de propensão Luma, os requisitos não precisam ser atualizados.

Arquivos de configuração configuration-files

Os arquivos de configuração, training.conf e scoring.conf, são usados para especificar os conjuntos de dados que você deseja usar para treinamento e pontuação, bem como para adicionar hiperparâmetros. Há configurações separadas para treinamento e pontuação.

Para que um modelo execute o treinamento, você deve fornecer os trainingDataSetId, ACP_DSW_TRAINING_XDM_SCHEMA e tenantId. Além disso, para a pontuação, você deve fornecer o scoringDataSetId, tenantId e scoringResultsDataSetId .

Para localizar o conjunto de dados e as IDs do esquema, vá para a guia de dados nos blocos de anotações da barra de navegação esquerda (sob o ícone de pasta). Três IDs diferentes do conjunto de dados precisam ser fornecidas. O scoringResultsDataSetId é usado para armazenar os resultados da pontuação do modelo e deve ser um conjunto de dados vazio. Esses conjuntos de dados foram criados anteriormente na etapa Ativos obrigatórios.

As mesmas informações podem ser encontradas no Adobe Experience Platform nas guias Esquema e Conjuntos de Dados.

Depois de concluído, sua configuração de treinamento e pontuação deve ser semelhante à seguinte captura de tela:

Por padrão, os seguintes parâmetros de configuração são definidos para você ao treinar e pontuar dados:

Noções básicas sobre o carregador de dados de treinamento training-data-loader

A finalidade do Carregador de dados de treinamento é instanciar os dados usados para criar o modelo de aprendizado de máquina. Normalmente, há duas tarefas que o carregador de dados de treinamento realiza:

As duas seções a seguir abordarão o carregamento de dados e a preparação de dados.

Carregando dados loading-data

Esta etapa usa o dataframe pandas. Os dados podem ser carregados de arquivos no Adobe Experience Platform usando o SDK Platform (platform_sdk) ou de fontes externas usando as funções read_csv() ou read_json() dos pandas.

SDK do Platform platform-sdk

Para obter um tutorial detalhado sobre como usar o carregador de dados do platform_sdk, visite o Guia do SDK da Platform. Este tutorial fornece informações sobre autenticação de build, leitura básica de dados e gravação básica de dados.

Fontes externas external-sources

Esta seção mostra como importar um arquivo JSON ou CSV para um objeto pandas. A documentação oficial da biblioteca de pandas pode ser encontrada aqui:

Primeiro, veja um exemplo da importação de um arquivo CSV. O argumento data é o caminho para o arquivo CSV. Esta variável foi importada de configProperties na seção anterior.

df = pd.read_csv(data)

Você também pode importar de um arquivo JSON. O argumento data é o caminho para o arquivo CSV. Esta variável foi importada de configProperties na seção anterior.

df = pd.read_json(data)

Agora seus dados estão no objeto de quadro de dados e podem ser analisados e manipulados na próxima seção.

Arquivo do carregador de dados de treinamento

Neste exemplo, os dados são carregados usando o SDK da Platform. A biblioteca pode ser importada na parte superior da página incluindo a linha:

from platform_sdk.dataset_reader import DatasetReader

Você pode usar o método load() para coletar o conjunto de dados de treinamento de trainingDataSetId conforme definido no arquivo de configuração (recipe.conf).

def load(config_properties):
    print("Training Data Load Start")

    #########################################
    # Load Data
    #########################################
    client_context = get_client_context(config_properties)
    dataset_reader = DatasetReader(client_context, dataset_id=config_properties['trainingDataSetId'])

Agora que você tem seus dados, pode começar com a preparação de dados e a engenharia de recursos.

Preparação de dados e engenharia de recursos data-preparation-and-feature-engineering

Após os dados serem carregados, eles precisam ser limpos e submetidos à preparação. Neste exemplo, o objetivo do modelo é prever se um cliente solicitará um produto ou não. Como o modelo não está observando produtos específicos, você não precisa de productListItems e, portanto, a coluna é descartada. Em seguida, são soltas colunas adicionais que contêm apenas um único valor ou dois valores em uma única coluna. Ao treinar um modelo, é importante manter apenas dados úteis que ajudarão a prever sua meta.

Depois de descartar os dados desnecessários, você pode iniciar a engenharia de recursos. Os dados de demonstração usados para este exemplo não contêm informações sobre a sessão. Normalmente, você gostaria de ter dados sobre as sessões atuais e anteriores de um cliente específico. Devido à falta de informações da sessão, este exemplo imita sessões atuais e passadas por meio da demarcação da jornada.

Após a conclusão da demarcação, os dados são rotulados e uma jornada é criada.

Em seguida, os recursos são criados e divididos em passado e presente. Em seguida, qualquer coluna desnecessária é descartada, deixando você com as jornadas anteriores e atuais para clientes do Luma. Essas jornadas contêm informações como se um cliente comprou um item e a jornada que ele levou até a compra.

Carregador de dados de pontuação scoring-data-loader

O procedimento para carregar dados para pontuação é semelhante ao carregamento de dados de treinamento. Observando de perto o código, você pode ver que tudo é o mesmo, exceto o scoringDataSetId no dataset_reader. Isso ocorre porque a mesma fonte de dados do Luma é usada para treinamento e pontuação.

Caso deseje usar arquivos de dados diferentes para treinamento e pontuação, o carregador de dados de treinamento e pontuação será separado. Isso permite executar pré-processamento adicional, como mapear os dados de treinamento para os dados de pontuação, se necessário.

Arquivo de pipeline pipeline-file

O arquivo pipeline.py inclui lógica para treinamento e pontuação.

O objetivo do treinamento é criar um modelo usando recursos e rótulos em seu conjunto de dados de treinamento. Depois de escolher o modelo de treinamento, você deve ajustar o conjunto de dados de treinamento x e y ao modelo e a função retorna o modelo treinado.

A função score() deve conter o algoritmo de pontuação e retornar uma medição para indicar o desempenho bem-sucedido do modelo. A função score() usa os rótulos do conjunto de dados de pontuação e o modelo treinado para gerar um conjunto de recursos previstos. Esses valores previstos são comparados com os recursos reais no conjunto de dados de pontuação. Neste exemplo, a função score() usa o modelo treinado para prever recursos usando os rótulos do conjunto de dados de pontuação. Os recursos previstos são retornados.

Arquivo avaliador evaluator-file

O arquivo evaluator.py contém lógica de como você deseja avaliar sua fórmula treinada, bem como a forma como seus dados de treinamento devem ser divididos.

Dividir o conjunto de dados split-the-dataset

A fase de preparação dos dados de treinamento exige a divisão do conjunto de dados a ser usado para treinamento e teste. Esses dados val são usados implicitamente para avaliar o modelo depois de treinado. Esse processo é separado da pontuação.

Esta seção mostra a função split() que carrega dados no bloco de anotações e depois limpa os dados removendo colunas não relacionadas no conjunto de dados. A partir daí, você pode executar a engenharia de recursos, que é o processo para criar recursos relevantes adicionais a partir de recursos brutos existentes nos dados.

Avaliar o modelo treinado evaluate-the-trained-model

A função evaluate() é executada depois que o modelo é treinado e retorna uma métrica para indicar o desempenho do modelo. A função evaluate() usa os rótulos do conjunto de dados de teste e o modelo treinado para prever um conjunto de recursos. Esses valores previstos são comparados com os recursos reais no conjunto de dados de teste. Neste exemplo, as métricas usadas são precision, recall, f1 e accuracy. Observe que a função retorna um objeto metric contendo uma matriz de métricas de avaliação. Essas métricas são usadas para avaliar o desempenho do modelo treinado.

Adicionar print(metric) permite que você visualize os resultados da métrica.

Arquivo do salvador de dados data-saver-file

O arquivo datasaver.py contém a função save() e é usado para salvar sua previsão ao testar a pontuação. A função save() faz sua previsão e, usando APIs Experience Platform Catalog, grava os dados no scoringResultsDataSetId que você especificou em seu arquivo scoring.conf. Você pode

Treinamento e pontuação training-and-scoring

Quando terminar de fazer alterações no seu bloco de anotações e quiser treinar sua fórmula, você poderá selecionar os botões associados na parte superior da barra para criar um treinamento executado na célula. Ao selecionar o botão, um log de comandos e saídas do script de treinamento aparece no bloco de anotações (na célula evaluator.py). Primeiro, o Conda instala todas as dependências e, em seguida, o treinamento é iniciado.

Observe que você deve executar o treinamento pelo menos uma vez antes de poder executar a pontuação. Selecionar o botão Executar Pontuação pontuará no modelo treinado que foi gerado durante o treinamento. O script de pontuação aparece em datasaver.py.

Para fins de depuração, se desejar ver a saída oculta, adicione debug ao final da célula de saída e execute-a novamente.

Criar uma fórmula create-recipe

Quando terminar de editar a fórmula e estiver satisfeito com o resultado do treinamento/pontuação, você poderá criar uma fórmula no bloco de anotações selecionando Criar fórmula no canto superior direito.

Depois de selecionar Criar fórmula, você será solicitado a inserir um nome de fórmula. Este nome representa a fórmula real criada em Platform.

Após selecionar Ok, o processo de criação de fórmula será iniciado. Isso pode levar algum tempo e uma barra de progresso é exibida no lugar do botão Criar fórmula. Depois de concluído, você pode selecionar o botão Exibir receitas para ir até a guia Receitas em Modelos ML

Próximas etapas next-steps

Ao concluir este tutorial, você aprendeu a criar um modelo de aprendizado de máquina no bloco de anotações Construtor de fórmula. Você também aprendeu a exercitar o fluxo de trabalho de notebook para receita.

Para continuar aprendendo como trabalhar com recursos no Data Science Workspace, visite a lista suspensa de Data Science Workspace receitas e modelos.