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.
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.
O notebook Construtor de receita suporta o trabalho com todos os formatos de arquivo, mas atualmente a funcionalidade Criar receita suporta apenas Python.
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.
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.
Você deve executar as células manualmente quando aplicável.
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:
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
As bibliotecas ou versões específicas que você adicionar podem ser incompatíveis com as bibliotecas acima. Além disso, se você optar por criar um arquivo de ambiente manualmente, o campo name
não poderá ser substituído.
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
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á:
As duas seções a seguir abordarão o carregamento de dados e a preparação de 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.
No notebook do Recipe Builder, os dados são carregados pelo platform_sdk
carregador de dados.
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.
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:
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/>.
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")
Conforme mencionado na seção Arquivo de Configuração, os seguintes parâmetros de configuração são definidos para você ao acessar dados do Experience Platform usando client_context
:
ML_FRAMEWORK_IMS_USER_CLIENT_ID
ML_FRAMEWORK_IMS_TOKEN
ML_FRAMEWORK_IMS_ML_TOKEN
ML_FRAMEWORK_IMS_TENANT_ID
Agora que você tem seus dados, você pode começar com 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:
week
e year
storeType
em uma variável de indicadorisHoliday
em uma variável numéricaweeklySales
para obter valor de vendas futuras e passadastrain
e val
conjunto de dadosPrimeiro, 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.
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.
O arquivo pipeline.py
inclui lógica para treinamento e pontuação.
O objetivo do treinamento é criar um modelo usando recursos e etiquetas no conjunto de dados de treinamento.
Os recursos se referem à variável de entrada usada pelo modelo de aprendizado da máquina para prever os rótulos.
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.
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
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.
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
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:
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.
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)
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.
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:
%%writefile
na parte superior das células de arquivoAo 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.
O vídeo a seguir foi projetado para oferecer suporte à sua compreensão sobre a criação e implantação de modelos.