Criar uma receita usando notebooks Júpiter

Este tutorial percorrerá duas seções principais. Primeiro, você criará um modelo de aprendizado de máquina usando um modelo em JupyterLab Notebook. Em seguida, você exercerá o fluxo de trabalho do bloco de anotações para receber receitas dentro de JupyterLab para criar uma receita dentro de Data Science Workspace.

Conceitos introduzidos:

• Receitas: uma receita é um termo para uma especificação de modelo e um container de nível superior que representa um aprendizado de máquina específico, algoritmo AI ou conjunto de algoritmos, lógica de processamento e configuração necessários para criar e executar um modelo treinado e, portanto, ajudar a resolver problemas específicos de negócios.
• Modelo: Um modelo é uma instância de uma fórmula de aprendizado de máquina treinada usando dados históricos e configurações para solucionar um caso de uso comercial.
• Treinamento: treinamento é o processo de aprendizado de padrões e insights de dados rotulados.
• Pontuação: Pontuação é o processo de geração de insights a partir de dados usando um modelo treinado.

Introdução ao ambiente notebookJupyterLab

Criar uma fórmula do zero pode ser feito em Data Science Workspace. Para start, navegue até Adobe Experience Platform e clique na guia Notebooks à esquerda. Crie um novo bloco de anotações selecionando o modelo do Construtor de receitas em JupyterLab Launcher.

O notebook Construtor de receitas permite que você execute treinamentos e execuções de pontuação dentro do notebook. Isso proporciona a flexibilidade para fazer alterações nos métodos train() e score() entre executar experimentos nos dados de treinamento e pontuação. Quando estiver satisfeito com os resultados do treinamento e da pontuação, você poderá criar uma fórmula a ser usada em Data Science Workspace usando o notebook para a funcionalidade de receita incorporada ao notebook do Recipe Builder.

Quando você clica no notebook do Recipe Builder no lançador, o notebook é aberto na guia. O modelo usado no notebook é a Receita de Previsão de Vendas de Retalho Python, que também pode ser encontrada em este repositório público

Você observará que na barra de ferramentas existem três ações adicionais, a saber - Trem, Pontuação e Criar Receita. Esses ícones só aparecem no bloco de anotações Construtor de receitas. Para obter mais informações sobre essas ações, consulte na seção Treinamento e pontuação depois de criar a Receita no notebook.

Fazer edições em arquivos de receita

Para fazer edições nos arquivos de receita, navegue até a célula em Júpiter correspondente ao caminho do arquivo. Por exemplo, se você deseja fazer alterações em evaluator.py, procure %%writefile demo-recipe/evaluator.py.

Start fazendo as alterações necessárias na célula e, quando terminar, simplesmente execute a célula. O comando %%writefile filename.py gravará o conteúdo da célula em filename.py. Será necessário executar manualmente a célula para cada arquivo com alterações.

Introdução ao notebook Recipe Builder

Agora que você sabe as noções básicas para o ambiente notebook, você pode começar a olhar para os arquivos que compõem uma fórmula de modelo de aprendizado de máquina. JupyterLab Os arquivos sobre os quais falaremos são mostrados aqui:

• Arquivo de requisitos
• Arquivos de configuração
• Carregador de dados de treinamento
• Carregador de dados de pontuação
• Arquivo Pipeline
• Arquivo do avaliador
• Arquivo de Proteção de Dados

Arquivo de requisitos

O arquivo requirements é usado para declarar bibliotecas adicionais que você deseja usar na fórmula. 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 das principais bibliotecas já em uso inclui:

python=3.6.7
scikit-learn
pandas
numpy
data_access_sdk_python

Arquivos de configuração

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.

Os usuários devem preencher as seguintes variáveis antes de executar o treinamento e a pontuação:

• trainingDataSetId
• ACP_DSW_TRAINING_XDM_SCHEMA
• scoringDataSetId
• ACP_DSW_SCORING_RESULTS_XDM_SCHEMA
• scoringResultsDataSetId

Para localizar o conjunto de dados e as IDs de schema, vá para a guia Dados dentro dos notebooks na barra de navegação esquerda (sob o ícone de pasta).

As mesmas informações podem ser encontradas nas guias Adobe Experience Platform Schema e Conjuntos de dados.

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

• ML_FRAMEWORK_IMS_USER_CLIENT_ID
• ML_FRAMEWORK_IMS_TOKEN
• ML_FRAMEWORK_IMS_ML_TOKEN
• ML_FRAMEWORK_IMS_TENANT_ID

Carregador de dados de treinamento

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

• Carregar dados de Platform
• Preparação de dados e engenharia de recursos

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

Carregando dados

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

• Platform SDK
• Fontes externas

Platform SDK

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

Fontes externas

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

• read_csv
• read_json

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

df = pd.read_csv(data)

Também é possível importar de um arquivo JSON. O argumento data é o caminho para o arquivo CSV. Essa variável foi importada de configProperties na seção anterior.

df = pd.read_json(data)

Agora seus dados estão no objeto dataframe e podem ser analisados e manipulados na próxima seção a1/>.

Do SDK da plataforma

Você pode carregar dados usando o SDK da plataforma. A biblioteca pode ser importada na parte superior da página, incluindo a linha:

from platform_sdk.dataset_reader import DatasetReader

Em seguida, usamos o método load() para capturar o conjunto de dados de treinamento de trainingDataSetId como definido em nosso 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, config_properties['trainingDataSetId'])
    
    timeframe = config_properties.get("timeframe")
    tenant_id = config_properties.get("tenant_id")

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

Preparação de dados e engenharia de recursos

Depois que os dados são carregados, os dados passam pela preparação e são divididos nos conjuntos de dados train e val. O código de amostra é visto abaixo:

#########################################
# Data Preparation/Feature Engineering
#########################################
dataframe.date = pd.to_datetime(dataframe.date)
dataframe['week'] = dataframe.date.dt.week
dataframe['year'] = dataframe.date.dt.year

dataframe = pd.concat([dataframe, pd.get_dummies(dataframe['storeType'])], axis=1)
dataframe.drop('storeType', axis=1, inplace=True)
dataframe['isHoliday'] = dataframe['isHoliday'].astype(int)

dataframe['weeklySalesAhead'] = dataframe.shift(-45)['weeklySales']
dataframe['weeklySalesLag'] = dataframe.shift(45)['weeklySales']
dataframe['weeklySalesDiff'] = (dataframe['weeklySales'] - dataframe['weeklySalesLag']) / dataframe['weeklySalesLag']
dataframe.dropna(0, inplace=True)

dataframe = dataframe.set_index(dataframe.date)
dataframe.drop('date', axis=1, inplace=True) 

Neste exemplo, há cinco coisas sendo feitas no conjunto de dados original:

• adicionar colunas week e year
• converter storeType em uma variável de indicador
• converter isHoliday em uma variável numérica
• offset weeklySales para obter valor de vendas futuras e passadas
• dividir dados, por data, em train e val conjunto de dados

Primeiro, as colunas week e year são criadas e a coluna original date é convertida em Python datetime. Os valores de semana e ano são extraídos do objeto datetime.

Em seguida, storeType é convertido em três colunas representando os três tipos diferentes de armazenamento, (A, B e C). Cada um conterá um valor booliano para indicar qual storeType é verdadeiro. A coluna storeType será ignorada.

Da mesma forma, weeklySales altera o booliano isHoliday para uma representação numérica, um ou zero.

Esses dados são divididos entre os conjuntos de dados train e val.

A função load() deve ser concluída com o conjunto de dados train e val como saída.

Pontuação do carregador de dados

O procedimento para carregar dados para pontuação é semelhante aos dados de treinamento de carregamento na função split(). Usamos o SDK de acesso a dados para carregar dados do scoringDataSetId encontrado em nosso arquivo recipe.conf.

def load(config_properties):

    print("Scoring Data Load Start")

    #########################################
    # Load Data
    #########################################
    client_context = get_client_context(config_properties)

    dataset_reader = DatasetReader(client_context, config_properties['scoringDataSetId'])
    timeframe = config_properties.get("timeframe")
    tenant_id = config_properties.get("tenant_id")

Após carregar os dados, a preparação de dados e a engenharia de recursos são feitas.

    #########################################
    # Data Preparation/Feature Engineering
    #########################################
    if '_id' in dataframe.columns:
        #Rename columns to strip tenantId
        dataframe = dataframe.rename(columns = lambda x : str(x)[str(x).find('.')+1:])
        #Drop id, eventType and timestamp
        dataframe.drop(['_id', 'eventType', 'timestamp'], axis=1, inplace=True)

    dataframe.date = pd.to_datetime(dataframe.date)
    dataframe['week'] = dataframe.date.dt.week
    dataframe['year'] = dataframe.date.dt.year

    dataframe = pd.concat([dataframe, pd.get_dummies(dataframe['storeType'])], axis=1)
    dataframe.drop('storeType', axis=1, inplace=True)
    dataframe['isHoliday'] = dataframe['isHoliday'].astype(int)

    dataframe['weeklySalesAhead'] = dataframe.shift(-45)['weeklySales']
    dataframe['weeklySalesLag'] = dataframe.shift(45)['weeklySales']
    dataframe['weeklySalesDiff'] = (dataframe['weeklySales'] - dataframe['weeklySalesLag']) / dataframe['weeklySalesLag']
    dataframe.dropna(0, inplace=True)

    dataframe = dataframe.set_index(dataframe.date)
    dataframe.drop('date', axis=1, inplace=True)

    print("Scoring Data Load Finish")

    return dataframe

Como o objetivo do nosso modelo é prever vendas semanais futuras, será necessário criar um conjunto de dados de pontuação usado para avaliar o desempenho da previsão do modelo.

Este notebook do Recipe Builder faz isso compensando nossas vendas semanais daqui a 7 dias. Observe que há medidas para 45 armazenamentos toda semana, para que você possa direcionar os valores weeklySales para 45 conjuntos de dados para uma nova coluna chamada weeklySalesAhead.

df['weeklySalesAhead'] = df.shift(-45)['weeklySales']

Da mesma forma, você pode criar uma coluna weeklySalesLag alterando 45 para trás. Com isso, você também pode calcular a diferença nas vendas semanais e armazená-las na coluna weeklySalesDiff.

df['weeklySalesLag'] = df.shift(45)['weeklySales']
df['weeklySalesDiff'] = (df['weeklySales'] - df['weeklySalesLag']) / df['weeklySalesLag']

Como você está compensando os conjuntos de dados weeklySales 45 para frente e 45 para trás para criar novas colunas, o primeiro e o último 45 pontos de dados terão valores NaN. Você pode remover esses pontos de nosso conjunto de dados usando a função df.dropna() que remove todas as linhas que têm valores NaN.

df.dropna(0, inplace=True)

A função load() no carregador de dados de pontuação deve ser concluída com o conjunto de dados de pontuação como saída.

Arquivo de pipeline

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

Treinamento

O objetivo do treinamento é criar um modelo usando recursos e etiquetas no conjunto de dados de treinamento.

A função train() deve incluir o modelo de treinamento e retornar o modelo treinado. Alguns exemplos de modelos diferentes podem ser encontrados na scikit-learn user guide documentation.

Após escolher o modelo de treinamento, você ajustará o conjunto de dados de treinamento x e y ao modelo e a função retornará o modelo treinado. Um exemplo que mostra isso é o seguinte:

def train(configProperties, data):

    print("Train Start")

    #########################################
    # Extract fields from configProperties
    #########################################
    learning_rate = float(configProperties['learning_rate'])
    n_estimators = int(configProperties['n_estimators'])
    max_depth = int(configProperties['max_depth'])


    #########################################
    # Fit model
    #########################################
    X_train = data.drop('weeklySalesAhead', axis=1).values
    y_train = data['weeklySalesAhead'].values

    seed = 1234
    model = GradientBoostingRegressor(learning_rate=learning_rate,
                                      n_estimators=n_estimators,
                                      max_depth=max_depth,
                                      random_state=seed)

    model.fit(X_train, y_train)

    print("Train Complete")

    return model

Observe que, dependendo do aplicativo, você terá argumentos na função GradientBoostingRegressor(). xTrainingDataset deve conter seus recursos usados para treinamento e yTrainingDataset deve conter suas etiquetas.

Pontuação

A função score() deve conter o algoritmo de pontuação e retornar uma medida para indicar o sucesso 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 aos 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.

def score(configProperties, data, model):

    print("Score Start")

    X_test = data.drop('weeklySalesAhead', axis=1).values
    y_test = data['weeklySalesAhead'].values
    y_pred = model.predict(X_test)

    data['prediction'] = y_pred
    data = data[['store', 'prediction']].reset_index()
    data['date'] = data['date'].astype(str)

    print("Score Complete")

    return data

Arquivo do avaliador

O arquivo evaluator.py contém uma lógica de como você deseja avaliar sua fórmula treinada, bem como como seus dados de treinamento devem ser divididos. No exemplo de vendas de varejo, a lógica para carregar e preparar os dados de treinamento será incluída. Iremos analisar as duas seções que se seguem.

Dividir o conjunto de dados

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

Esta seção mostrará a função split() que primeiro carregará dados no bloco de anotações e, em seguida, limpará os dados removendo colunas não relacionadas no conjunto de dados. A partir daí, você poderá executar a engenharia de recursos, que é o processo para criar recursos relevantes adicionais a partir dos recursos brutos existentes nos dados. Um exemplo desse processo pode ser visto abaixo, juntamente com uma explicação.

A função split() é mostrada abaixo. O dataframe fornecido no argumento será dividido nas variáveis train e val a serem retornadas.

def split(self, configProperties={}, dataframe=None):
    train_start = '2010-02-12'
    train_end = '2012-01-27'
    val_start = '2012-02-03'
    train = dataframe[train_start:train_end]
    val = dataframe[val_start:]

    return train, val

Avaliar o modelo treinado

A função evaluate() é executada depois que o modelo é treinado e retornará uma métrica para indicar o sucesso 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 aos recursos reais no conjunto de dados de teste. Algoritmos de pontuação comuns incluem:

• Erro percentual médio absoluto (MAPE)
• Erro absoluto médio (MAE)
• Erro quadrado médio raiz (RMSE)

A função evaluate() na amostra de vendas de varejo é mostrada abaixo:

def evaluate(self, data=[], model={}, configProperties={}):
    print ("Evaluation evaluate triggered")
    val = data.drop('weeklySalesAhead', axis=1)
    y_pred = model.predict(val)
    y_actual = data['weeklySalesAhead'].values
    mape = np.mean(np.abs((y_actual - y_pred) / y_actual))
    mae = np.mean(np.abs(y_actual - y_pred))
    rmse = np.sqrt(np.mean((y_actual - y_pred) ** 2))

    metric = [{"name": "MAPE", "value": mape, "valueType": "double"},
                {"name": "MAE", "value": mae, "valueType": "double"},
                {"name": "RMSE", "value": rmse, "valueType": "double"}]

    return metric

Observe que a função retorna um objeto metric contendo uma matriz de métricas de avaliação. Essas métricas serão usadas para avaliar o desempenho do modelo treinado.

Arquivo de Proteção de Dados

O arquivo datasaver.py contém a função save() para salvar sua previsão ao testar a pontuação. A função save() aceitará sua previsão e, usando Experience Platform Catalog APIs, gravará os dados no scoringResultsDataSetId especificado no arquivo scoring.conf.

O exemplo usado na receita de amostra de vendas para venda a varejo é visto aqui. Observe o uso da biblioteca DataSetWriter para gravar dados na Plataforma:

from data_access_sdk_python.writer import DataSetWriter

def save(configProperties, prediction):
    print("Datasaver Start")
    print("Setting up Writer")

    catalog_url = "https://platform.adobe.io/data/foundation/catalog"
    ingestion_url = "https://platform.adobe.io/data/foundation/import"

    writer = DataSetWriter(catalog_url=catalog_url,
                           ingestion_url=ingestion_url,
                           client_id=configProperties['ML_FRAMEWORK_IMS_USER_CLIENT_ID'],
                           user_token=configProperties['ML_FRAMEWORK_IMS_TOKEN'],
                           service_token=configProperties['ML_FRAMEWORK_IMS_ML_TOKEN'])

    print("Writer Configured")

    writer.write(data_set_id=configProperties['scoringResultsDataSetId'],
                 dataframe=prediction,
                 ims_org=configProperties['ML_FRAMEWORK_IMS_TENANT_ID'])

    print("Write Done")
    print("Datasaver Finish")
    print(prediction)

Treinamento e pontuação

Quando terminar de fazer alterações no seu notebook e quiser treinar sua receita, clique nos botões associados na parte superior da barra para criar uma execução de treinamento na célula. Ao clicar no botão, um registro de comandos e saídas do script de treinamento aparecerá no bloco de anotações (sob a 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 executar a pontuação. Clicar no botão Executar Pontuação vai pontuar no modelo treinado que foi gerado durante o treinamento. O script de pontuação será exibido em datasaver.py.

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

Criar fórmula

Quando terminar de editar a receita e estiver satisfeito com a saída de treinamento/pontuação, você poderá criar uma receita do notebook pressionando Criar receita na navegação superior direita.

Depois de pressionar o botão, você será solicitado a inserir um nome de fórmula. Este nome representa a fórmula real criada em Platform.

Depois de pressionar Ok, você poderá navegar até a nova fórmula em Adobe Experience Platform. Você pode clicar no botão Fórmulas de Visualização para levá-lo até a guia Fórmulas em Modelos ML

Quando o processo estiver concluído, a receita ficará parecida com isso:

Próximas etapas

Ao concluir este tutorial, você aprendeu a criar um modelo de aprendizado de máquina no notebook Construtor de receitas. Você também aprendeu a exercitar o notebook para obter o fluxo de trabalho da receita dentro do notebook para criar uma receita dentro de Data Science Workspace.

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

Recursos adicionais

O vídeo a seguir foi projetado para oferecer suporte à sua compreensão sobre a criação e implantação de modelos.