Casos de uso do mundo real: Previsão da utilização do serviço…

A ciência de dados está no seu melhor no mundo real. Pretendo compartilhar insights de vários projetos de produção em que estive envolvido.

Durante meus anos trabalhando porquê Investigador de Dados, conheci muitos estudantes interessados ​​em se tornar um, ou recém-formados que estavam somente começando. Debutar uma curso em ciência de dados, porquê qualquer campo, envolve uma curva de estágio íngreme.

Uma pergunta muito boa que continuo recebendo é: Aprendi muito sobre os aspectos teóricos da ciência de dados, mas porquê seria um exemplo do mundo real?

Quero compartilhar pequenos pedaços de trabalho, de diferentes projetos nos quais tenho trabalhado ao longo da minha curso. Mesmo que alguns possam ter alguns anos, escreverei somente sobre assuntos que ainda considero relevantes. Tentarei manter o quadro universal evidente e lacónico, para que novos colegas aspirantes tenham uma teoria do que pode estar por vir. Mas também quero parar e indagar os detalhes, dos quais espero que desenvolvedores mais experientes possam obter alguns insights.

Estudo de caso

Vamos agora nos aprofundar no caso de negócios específico que impulsionou essa iniciativa. A equipe incluía um gerente de projeto, partes interessadas do cliente e eu. O cliente precisava de uma maneira de prever o uso de um serviço específico. O motivo por trás disso era a alocação de recursos para manter o serviço e a precificação dinâmica. A experiência com o comportamento sobre o uso do serviço era mantida principalmente entre colegas de trabalho qualificados, e essa emprego era uma maneira de ser mais resiliente em relação à aposentadoria deles junto com seu conhecimento. Aliás, o processo de integração de novas contratações era considerado mais fácil com esse tipo de utensílio em mãos.

Forma de dados e estudo

Os dados tinham muitas características, tanto categóricas quanto numéricas. Para o caso de uso, havia uma premência de prever o uso com um horizonte dinâmico, ou seja, uma premência de fazer previsões para diferentes períodos de tempo no horizonte. Havia também muitos valores correlacionados e não correlacionados que precisavam ser previstos.

Essas séries temporais multivariadas fizeram com que a atenção se concentrasse principalmente em testar modelos baseados em séries temporais. Mas, no final das contas, o Tabnet foi adotado, um padrão que processa dados porquê tabulares.

Existem vários recursos interessantes na arquitetura Tabnet. Leste item não vai se aprofundar em detalhes do padrão. Mas para o contexto teórico, recomendo fazer alguma pesquisa. Se você não encontrar nenhum recurso bom, eu acho nascente item uma boa visão universal ou nascente item para uma exploração mais aprofundada.

Uma vez que uma estrutura de ajuste de hiperparâmetros, o Optuna foi usado. Existem também outras estruturas em Python para usar, mas ainda não encontrei um motivo para não usar o Optuna. O Optuna foi usado porquê um ajuste de hiperparâmetro bayesiano, salvo no disco. Outros recursos utilizados são paragem antecipada e partida a quente. A paragem antecipada é usada para fins de economia de recursos, não permitindo que testes não promissores sejam executados por muito tempo. A partida a quente é a capacidade de inaugurar a partir de testes anteriores. Acho isso útil quando novos dados chegam e não é preciso inaugurar o ajuste do zero.

As larguras dos parâmetros iniciais serão definidas conforme recomendado no Documentação Tabnet ou das faixas de parâmetros discutidas no Papel Tabnet.

Para transmitir a natureza heterocedástica dos resíduos, o Tabnet foi implementado porquê um padrão de retrocesso quantílica. Para fazer isso, ou para implementar qualquer padrão dessa forma, o função de perda de pinballcom quantis superiores e inferiores adequados, foi usado. Esta função de perda tem uma função de perda enviesada, punindo erros de forma desigual, dependendo se são positivos ou negativos.

Passo a passo com código

Os requisitos usados ​​para esses snippets são os seguintes.

pytorch-tabnet==4.1.0
optuna==3.6.1
pandas==2.1.4

Código para definir o padrão.

import os
from pytorch_tabnet.tab_model import TabNetRegressor
import pandas as pd
import numpy as np
from utils import CostumPinballLoss
class mediumTabnetModel:
def __init__(self,
model_file_name,
dependent_variables=None,
independent_variables=None,
batch_size=16_000,
n_a=8,
n_steps=3,
n_independent=2,
n_shared=2,
cat_idxs=[],
cat_dims=[],
quantile=None):
self.model_file_name = model_file_name
self.quantile = quantile
self.clf = TabNetRegressor(n_d=n_a,
n_a=n_a,
cat_idxs=cat_idxs,
cat_dims=cat_dims,
n_steps=n_steps,
n_independent=n_independent,
n_shared=n_shared)
self.batch_size = batch_size
self.independent_variables = independent_variables
self.dependent_variables = dependent_variables
self.cat_idxs = cat_idxs  # Indexes for categorical values.
self.cat_dims = cat_dims  # Dimensions for categorical values.
self.ram_data = None
def fit(self, training_dir, train_date_split):
if self.ram_data is None:
data_path = os.path.join(training_dir, self.training_data_file)
df = pd.read_parquet(data_path)
df_train = df[df['dates'] < train_date_split]
df_val = df[df['dates'] >= train_date_split]
x_train = df_train[self.independent_variables].values.astype(np.int16)
y_train = df_train[self.dependent_variables].values.astype(np.int32)
x_valid = df_val[self.independent_variables].values.astype(np.int16)
y_valid = df_val[self.dependent_variables].values.astype(np.int32)
self.ram_data = {'x_train': x_train,
'y_train': y_train,
'x_val': x_valid,
'y_val': y_valid}
self.clf.fit(self.ram_data['x_train'],
self.ram_data['y_train'],
eval_set=[(self.ram_data['x_val'],
self.ram_data['y_val'])],
batch_size=self.batch_size,
drop_last=True,
loss_fn=CostumPinballLoss(quantile=self.quantile),
eval_metric=[CostumPinballLoss(quantile=self.quantile)],
patience=3)
feat_score = dict(zip(self.independent_variables, self.clf.feature_importances_))
feat_score = dict(sorted(feat_score.items(), key=lambda item: item[1]))
self.feature_importances_dict = feat_score 
# Dict of feature importance and importance score, ordered.

Sua visita nos ajuda a continuar oferecendo o melhor para você! oo op oq or os ot ou ov gn bk">Uma vez que framework de manipulação de dados, Pandas foi usado. Eu também recomendaria usar Polars, porquê um framework mais eficiente.

A implementação do Tabnet vem com um atributo de preço de recurso sítio e global pré-construído para o padrão ajustado. O funcionamento interno disso pode ser estudado no item postado anteriormente, mas, porquê o caso de uso de negócios vai, isso serve a dois propósitos:

• Verificação de integridade — o cliente pode validar o padrão.
• Insights de negócios — o padrão pode fornecer novos insights sobre o negócio ao cliente.

juntamente com os especialistas no tema. Na emprego final, a interpretabilidade foi incluída para ser exibida ao usuário. Devido à anonimização dos dados, não haverá um mergulho profundo na interpretabilidade neste item, mas sim guardá-lo para um caso em que os verdadeiros recursos que entram no padrão possam ser discutidos e exibidos.

Sua visita nos ajuda a continuar oferecendo o melhor para você! oq or os ot ou ov gn bk">Código para as etapas de ajuste e pesquisa.

import optuna
import numpy as np
def define_model(trial):
n_shared = trial.suggest_int('n_shared', 1, 7)
logging.info(f'n_shared: {n_shared}')
n_independent = trial.suggest_int('n_independent', 1, 16)
logging.info(f'n_independent: {n_independent}')
n_steps = trial.suggest_int('n_steps', 2, 8)
logging.info(f'n_steps: {n_steps}')
n_a = trial.suggest_int('n_a', 4, 32)
logging.info(f'n_a: {n_a}')
batch_size = trial.suggest_int('batch_size', 256, 18000)
logging.info(f'batch_size: {batch_size}')
clf = mediumTabnetModel(model_file_name=model_file_name,
dependent_variables=y_ls,
independent_variables=x_ls,
n_a=n_a,
cat_idxs=cat_idxs,
cat_dims=cat_dims,
n_steps=n_steps,
n_independent=n_independent,
n_shared=n_shared,
batch_size=batch_size,
training_data_file=training_data_file)
return clf
def objective(trial):
clf = define_model(trial)
clf.fit(os.path.join(args.training_data_directory, args.dataset),
df[int(len(df) * split_test)])
y_pred = clf.predict(predict_data)
y_true = np.array(predict_data[y_ls].values).astype(np.int32)
metric_value = call_metrics(y_true, y_pred)
return metric_value
study = optuna.create_study(direction='minimize',
storage='sqlite:///db.sqlite3',
study_name=model_name,
load_if_exists=True)
study.optimize(objective,
n_trials=50)

Os dados estão sendo divididos em um conjunto de treinamento, validação e teste. O uso para os diferentes conjuntos de dados é:

• Treinar. Leste é o conjunto de dados do qual o padrão aprende. Consiste neste projeto em 80%.
• Validação. É o conjunto de dados do qual o Optuna calcula suas métricas e, portanto, a métrica otimizada para. 10% dos dados para nascente projeto.
• Teste. Leste é o conjunto de dados usado para mandar o desempenho real do padrão. Se esta métrica não for boa o suficiente, pode valer a pena voltar a investigar outros modelos. Leste conjunto de dados também é usado para deliberar quando é hora de parar o ajuste de hiperparâmetros. Também é com base neste conjunto de dados que os KPIs são derivados e as visualizações compartilhadas com as partes interessadas.

Uma nota final é que, para imitar o comportamento de quando o padrão é implantado, tanto quanto verosímil, os conjuntos de dados estão sendo divididos no tempo. Isso significa que os dados dos primeiros 80% do período vão para a segmento de treinamento, os próximos 10% vão para a validação e os 10% mais recentes para o teste.