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:

Baixe o ativos necessário assets

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

Comece com o JupyterLab notebook ambiente

A criação de uma fórmula do zero pode ser feita dentro disso Data Science Workspace. Para start, navegue até Adobe Experience Platform e selecione os Notebooks guia à esquerda. Para criar um novo notebook, selecione o modelo do Criador de receitas 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 notebook do Construtor de receitas

Na pasta ativos fornecida está um modelo propensity_model.ipynbde propensão Luma. Utilizando a opção upload notebook no JupyterLab, upload o modelo fornecido e abra o notebook.

O restante deste tutorial abrange os seguintes arquivos predefinidos no notebook modelo de propensão:

O vídeo a seguir tutorial explica o notebook 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, visita anaconda.org. Para saber como formatar o arquivo de requisitos, visita Conda. As lista dos bibliotecas principais já em uso incluem:

python=3.6.7
scikit-learn
pandas
numpy
data_access_sdk_python

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

Arquivos de configuração configuration-files

Os arquivos training.conf de configuração e scoring.conf, são usados para especificar os conjuntos de dados que deseja usar para treinamento e pontuação, além de adicionar hiperparameters. Há configurações separadas para treinamento e pontuação.

Em solicitar para que um modelo execute treinamento, é necessário fornecer o trainingDataSetId ACP_DSW_TRAINING_XDM_SCHEMAmodelo e tenantIdo caractere Além disso, para pontuação, você deve fornecer o scoringDataSetIdcaractere , tenantIde scoringResultsDataSetId .

Para encontrar as IDs de conjunto de dados e schema, vá para os dados guia em notebooks na barra de navegação esquerda (sob o ícone de pasta). É necessário fornecer três conjunto de dados IDs diferentes. É scoringResultsDataSetId usada para armazenamento os resultados de pontuação do modelo e deve ser uma conjunto de dados vazia. Esses conjuntos de dados foram feitos anteriormente na etapa de ativos exigida.

As mesmas informações podem ser encontradas em Adobe Experience Platform nas guias Esquema ** e**​ Conjuntos ** de dados.**​🔗

Depois de competir, suas configurações de treinamento e pontuação devem ser semelhantes às seguintes captura de tela:

Por padrão, os seguintes parâmetros de configuração são definidos para você quando você treina e pontua dados:

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

O objetivo do Carregador de dados de treinamento é instanciar os dados usados para criar o modelo de aprendizado de máquina. Normalmente, existem duas tarefas que o dados de treinamento loader realiza:

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

Carregamento de dados loading-data

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

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. Documentação oficial dos pandas biblioteca podem ser encontradas aqui:

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

df = pd.read_csv(data)

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

df = pd.read_json(data)

Agora seus dados estão no objeto do período 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 Platform. As biblioteca podem ser importadas na parte superior do página incluindo a linha:

from platform_sdk.dataset_reader import DatasetReader

Em seguida, você pode usar o load() método para pegar as treinamento conjunto de dados no trainingDataSetId arquivo de configuração (recipe.confconforme definido).

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. Quando treinamento um modelo, é importante manter apenas dados úteis que ajudarão na previsão de sua meta.

Após retirar dados desnecessários, é possível iniciar a engenharia de recursos. Os dados de demonstração usados para este exemplo não contêm informações de sessão. Normalmente, você gostaria de ter dados sobre as sessões atuais e passadas para um cliente específico. Devido à falta de informações da sessão, esse exemplo imita sessões atuais e passadas por meio da demarcação de jornadas.

Quando a demarcação é concluída, os dados são rotulados e uma jornada é criada.

Próximo, os recursos são criados e divididos entre passado e presente. Em seguida, quaisquer colunas desnecessárias são descartadas, deixando você com as jornadas passadas e atuais para os clientes Luma. Essas jornadas contêm informações como se um cliente comprou um item e a jornada que fez até a compra.

Pontuação do carregador de dados 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 sua treinamento conjunto de dados. Depois de escolher seu modelo de treinamento, você deve ajustar seus treinamento conjunto de dados x e y ao modelo e a função retorna o modelo treinado.

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

Arquivo avaliador evaluator-file

O evaluator.py arquivo contém lógica de como você deseja avaliar seus fórmula treinados, bem como como suas dados de treinamento devem ser divididas.

Dividir o conjunto de dados split-the-dataset

A fase de preparação de dados para treinamento requer a divisão da conjunto de dados a ser usada para treinamento e testes. Esses val dados são usados implicitamente para avaliar o modelo depois que ele é treinado. Esse processo é separado da pontuação.

Esta seção mostra a split() função que carrega dados no notebook e, em seguida, limpa os dados removendo colunas não relacionadas no conjunto de dados. A partir daí, é possível executar uma engenharia de recursos que é o processo para criar recursos adicionais relevantes a partir dos recursos brutos existentes nos dados.

Avaliar o modelo treinado evaluate-the-trained-model

A evaluate() função é executada depois que o modelo é treinado e retorna uma métrica para indicar o desempenho do modelo. A evaluate() função usa os rótulos de conjunto de dados de teste e o modelo treinado para prever um conjunto de recursos. Esses valores previstos são comparados aos recursos reais na conjunto de dados de teste. Neste exemplo, as métricas usadas são precision, recall, f1e accuracy. Observe que a função retorna um metric objeto que contém 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 visualização os resultados do 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 notebook e desejar treinar sua fórmula, você pode selecionar os botões associados na parte superior do bar para criar um treinamento correr na célula. Ao selecionar a botão, um log de comandos e saídas a partir do script treinamento aparece no notebook (sob a evaluator.py célula). O Conda primeiro instala todas as dependências e, em seguida, a treinamento é iniciada.

Observe que você deve executar treinamento pelo menos uma vez antes de poder executar a pontuação. Selecionar a botão de pontuação de execução pontuará no modelo treinado que foi gerado durante 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

Ao terminar de editar o fórmula e satisfeito com a saída treinamento/pontuação, você pode criar uma fórmula do notebook selecionando Criar Receita no canto superior direito.

Após selecionar Criar Receita, você é solicitado a inserir um nome fórmula. Este nome representa o fórmula real criado em Platform.

Depois de selecionar Ok, o processo de criação do fórmula é iniciado. Isso pode levar algum tempo e uma barra de progresso é exibida no lugar da fórmula botão de criação. 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 a aprender a trabalhar com recursos dentro, Data Science Workspacevisita na Data Science Workspace lista suspensa de fórmulas e modelos.