Preveja muitos clientes com um modelo
Cerca de 29 minutos min de leitura, com 4 exemplos em 7 seções.
Traduzido com IA. Verificado por pessoas em inglês. Como fazemos os livros
Traduzido do livro em inglês, edição 2026.11.11. Leia o original
Você termina este capítulo com um único modelo global para todos os trinta clientes, uma regra de início que mantém fora dele os zeros à esquerda dos clientes que começam tarde, e uma pontuação que o coloca lado a lado com o naïve sazonal para cada cliente nos mesmos cortes temporais. A compra do fornecedor para o dia seguinte é um total que o Capítulo 7 constrói a partir de trinta previsões de clientes. Um modelo por cliente exige trinta ajustes para cada janela, um para cada cliente. Os clientes compartilham um ritmo diário, portanto um modelo ajustado em todos eles pode aprender esse ritmo uma única vez.
O Capítulo 5 ajustou seu modelo aos oito clientes de SUBSET8. Ajustar um modelo a todos os trinta levanta três escolhas que determinam se a sua pontuação pode ser confiável: se deve dar a ele um identificador de cliente, como tratar os três clientes que começam tarde (clientes cujos medidores começam no meio dos dados) e como pontuar trinta previsões em uma mesma escala. Quatro exemplos sustentam o capítulo. Cada um imprime primeiro as suas contagens, para que você possa verificar se o modelo cobriu os clientes que deveria antes de ler qualquer erro.
Um modelo para muitos clientes
Montero-Manso e Hyndman (2021), em Princípios e algoritmos para previsão de grupos de séries temporais: localidade e globalidade, mostram que um modelo global não é mais restritivo do que um modelo local, porque ambos podem produzir as mesmas previsões. Eles comparam métodos globais, que ajustam um modelo a um grupo de séries, com métodos locais, que ajustam cada série isoladamente. Um modelo global ajusta um único conjunto de parâmetros a muitas séries em uma só passagem, de modo que cada cliente contribui para o que o modelo aprende. O resumo deles parte da visão de que, para grupos de séries semelhantes, os métodos globais superam os métodos locais, mais consolidados, e observa que resultados posteriores dessa literatura mostram bom desempenho de modelos globais mesmo em conjuntos de dados heterogêneos. Ele também relata que modelos lineares globais podem oferecer acurácia competitiva com duas ordens de grandeza a menos de parâmetros do que os métodos locais. As afirmações deste parágrafo vêm desse resumo. Bojer e Meldgaard (2020) constataram que modelos globais de ensemble e árvores com gradient boosting tiveram bom desempenho em seis competições de previsão do Kaggle (arXiv:2009.07701). Esses não são os dados do fornecedor, de modo que essas fontes são um motivo para testar a abordagem. Elas não são evidência sobre este caso. Os clientes do fornecedor têm o mesmo formato diário e tamanhos diferentes, então o teste precisa ser feito com eles.
Os dados estão em formato longo: uma linha por cliente e hora, com três colunas. unique_id identifica o cliente, ds é a hora, e y é o consumo, em quilowatt-hora, naquela hora. Cada linha carrega seus próprios lags, as leituras de um dia e de uma semana antes. O Capítulo 5 constatou que atributos de calendário e de feriados não reduziram o erro nestas oito semanas de histórico, por isso este capítulo usa apenas lags, de 24 e 168 horas. Ambos os lags são pelo menos iguais ao horizonte de 24 horas, de modo que nenhum deles lê o dia que está sendo previsto.
Os lags custam linhas. Um lag de 168 horas lê uma semana para trás, de modo que a primeira semana do histórico de cada cliente não tem nenhuma linha com todos os lags disponíveis. O Capítulo 5 mostrou que MLForecast descarta essas linhas do treinamento por padrão. Assim, o número de linhas de treinamento de um cliente é menor do que o número de horas do seu histórico. A previsão em si não é afetada, porque cada hora prevista lê apenas leituras anteriores ao seu ponto de corte.
Os clientes diferem em tamanho, e uma função de perda de erro quadrático sobre quilowatt-hora brutos deixa os maiores clientes definirem as divisões, enquanto os menores pesam pouco. Por isso, o alvo de cada cliente é escalonado antes do ajuste. O escalonamento é feito por LocalStandardScaler do mlforecast 1.1.0. Ele dá a cada cliente sua própria média e seu próprio desvio padrão, e o modelo aprende os valores escalonados:
z = (y - mean) / standard deviation
A média e o desvio vêm apenas do histórico desse cliente anterior ao ponto de corte, e as previsões são convertidas de volta com esses mesmos dois números. O código-fonte da biblioteca mostra onde isso acontece. MLForecast.fit chega a TimeSeries._fit em mlforecast/core.py, que ajusta o escalonador ao histórico de cada cliente anterior ao ponto de corte. Esse histórico inclui a primeira semana, cujas linhas os lags então removem do treinamento. TimeSeries.predict, no mesmo arquivo, inverte o escalonamento. A classe é _BaseLocalScaler, em mlforecast/target_transforms.py. O Capítulo 5 comparou os alvos escalonado e não escalonado em SUBSET8, e o modelo sem escalonamento teve desempenho pior do que o naive sazonal. Este capítulo mantém o alvo escalonado e não repete essa comparação.
make_forecaster, no módulo compartilhado examples/lib/features.py, constrói um MLForecast com um LGBMRegressor, configurado por LGBM_PARAMS. O modelo é determinístico, usa uma thread e uma semente fixa, e roda sob LightGBM 4.7.0. O módulo examples/lib/panel.py ajusta esse previsor uma vez por janela, sobre o histórico do painel anterior ao ponto de corte da janela. Ele preenche qualquer hora de mudança de horário a partir desse mesmo histórico, como faz o Capítulo 3, e devolve uma previsão para cada cliente.
Regra prática: Ajuste um único modelo global quando suas séries compartilham um formato e você precisa prever muitas delas em cada janela. Escalone o alvo de cada série apenas com estatísticas do histórico dessa janela, use somente lags de duração pelo menos igual ao horizonte, e ajuste uma vez por janela, não uma vez por série. Depois, avalie o modelo por série contra uma referência de base nas mesmas janelas, como fazem as seções a seguir, antes de confiar no seu erro agregado.
Identifique cada cliente
Depois que as linhas passam a compartilhar uma mesma tabela, o modelo não sabe mais a qual cliente cada linha pertence, a menos que você lhe diga. A normalização remove a média e a dispersão de cada cliente, de modo que o que resta é sobretudo o formato do dia. Um identificador de cliente coloca o cliente na tabela como um atributo categórico estático. As árvores podem então dividir pelo cliente e aprender os hábitos próprios desse cliente. O custo é mais uma divisão a aprender para cada cliente, e um cliente sem histórico não tem o que aprender. Assim, um novo cliente precisa de um novo treinamento antes que o modelo possa prever para ele.
A regra para manter um identificador é a mesma que o Capítulo 5 estabelece para todo atributo: mantenha-o apenas se ele reduzir o MASE médio por cliente nas janelas de decisão que os cortes padrão não usam. A semana reservada vai de 25 a 31 de dezembro de 2014, e tem sete cortes diários. Os três cortes padrão, de 29 a 31 de dezembro de 2014, são as pontuações informadas, então a decisão não os usa, e também não usa 25 a 28 de dezembro de 2014. As janelas de decisão são quatro dias comuns anteriores à semana reservada: cortes em 25 e 26 de novembro e em 2 e 3 de dezembro, todos de 2014, cada um prevendo 24 horas. Nenhuma de suas horas pontuadas cai em feriado português. O único feriado de 2014 entre essas janelas e a semana reservada, 8 de dezembro de 2014, não está entre elas. O calendário não registra feriado em 1 de dezembro de 2014.
Antes de incluir o identificador no modelo, teste-o nas janelas que as pontuações informadas nunca tocam. A verificação ajusta o modelo duas vezes em cada corte de decisão, com e sem o identificador, e se recusa a começar se alguma hora pontuada for feriado ou estiver na semana reservada.
1"""Tests whether a client identifier lowers the global model's error on four ordinary decision windows, before the2held-out week, on the book's MASE scale. The point rests on the mean per-client MASE lines and on `identifier kept`."""3from lib.electricity import load4from lib.panel import ALL30, DECISION_CUTOFFS, check_decision_hours, mae_change, panel_windows5from lib.quirks import mask_clock_changes6from lib.scoring import actual_hours, book_scale, report_scores, score_windows7from lib.settings import show89raw = load(ALL30) # all thirty clients, not the eight of SUBSET810df = mask_clock_changes(raw)[["unique_id", "ds", "y"]] # clock-change hours are set to missing, so the scores leave them out11cutoffs = DECISION_CUTOFFS12actual = actual_hours(df, cutoffs)13holiday_hours = check_decision_hours(actual) # raises before any fit if a scored hour is a holiday or in the held-out week1415plain = panel_windows(df, cutoffs, client_id=False, name="plain") # the model without the identifier16identified = panel_windows(df, cutoffs, client_id=True, name="identifier") # the same model, with the client as a feature17models = ["plain", "identifier"]18# the MASE scale reads only the readings before the first decision cutoff, so the scored hours cannot leak into it19scored, per_client = score_windows(actual, plain.merge(identified, on=["unique_id", "ds"], validate="one_to_one"),20 models, book_scale(raw, cutoffs[0]))21lowers = per_client["identifier"] < per_client["plain"]22size = raw.groupby("unique_id")["y"].mean().sort_values(ascending=False) # mean kWh per client, largest first23contrib = mae_change(scored, "plain", "identifier") # each client's share of the pooled MAE change, kWh; the shares sum to the total2425show("first decision cutoff", f"{cutoffs[0]:%Y-%m-%d}")26show("last decision cutoff", f"{cutoffs[-1]:%Y-%m-%d}")27show("clients", scored["unique_id"].nunique())28show("windows", len(cutoffs))29show("scored hours", len(scored))30show("decision hours on a holiday", holiday_hours)31report_scores(scored, per_client, models)32show("clients where the identifier lowers MASE", int(lowers.sum()))33show("of the 15 largest clients, where the identifier lowers MASE", int(lowers[size.index[:15]].sum()))34show("of the 15 smallest clients, where the identifier lowers MASE", int(lowers[size.index[-15:]].sum()))35show("largest client", size.index[0])36show("pooled MAE change from the largest client, kWh", contrib[size.index[0]])37show("pooled MAE change, all clients, kWh", contrib.sum())38# the decision rule keeps the identifier only if the mean per-client MASE is lower, not the pooled MAE39show("identifier kept", "yes" if per_client["identifier"].mean() < per_client["plain"].mean() else "no")
python client-identifier-check.pyfirst decision cutoff: 2014-11-25
last decision cutoff: 2014-12-03
clients: 30
windows: 4
scored hours: 2880
decision hours on a holiday: 0
MAE plain: 70.72
MAE identifier: 66.81
RMSE plain: 316.50
RMSE identifier: 303.68
mean MASE plain: 0.77
mean MASE identifier: 0.75
clients where the identifier lowers MASE: 23
of the 15 largest clients, where the identifier lowers MASE: 10
of the 15 smallest clients, where the identifier lowers MASE: 13
largest client: MT_370
pooled MAE change from the largest client, kWh: -3.80
pooled MAE change, all clients, kWh: -3.92
identifier kept: yes
O identificador reduz o MASE médio por cliente, de 0.77 para 0.75, e reduz o MASE de 23 dos trinta clientes.
Nessas janelas, o MAE agregado também cai, de 70.72 kWh para 66.81 kWh. Os dois erros pesam os clientes de forma diferente, porque o MAE agregado se concentra nos maiores.
A variação agregada de -3.92 kWh vem quase toda de um único cliente, MT_370, que responde por -3.80 kWh dela.
O MASE por cliente dá a todos o mesmo peso, e o identificador ajuda em todos os portes. Ele reduz o MASE de 10 dos quinze maiores clientes e de 13 dos quinze menores. Não ajuda apenas os clientes grandes.
O veredito impresso é yes, de modo que o identificador é mantido e o modelo final o utiliza. A margem é pequena. Outras janelas poderiam dar o sinal oposto por uma diferença igualmente pequena, então o veredito é apertado e depende das janelas. Um leitor com outras janelas deve medir de novo antes de confiar nele.
O identificador tem um custo nos cortes padrão. Ali, o MASE médio por cliente do modelo final é 0.91 com o identificador, contra 0.98 sem ele, mas seu MAE agregado é 122.81 kWh, contra 119.03 kWh sem ele. O Capítulo 7 precisa confrontar seu total com isso. O restante do capítulo usa o modelo com o identificador.
Regra prática: Trate o identificador de cliente como mais um atributo sob a regra do Capítulo 5: mantenha-o apenas se reduzir o MASE médio por cliente nas janelas de decisão, com o MAE agregado ao lado. Se a decisão for apertada, diga isso e meça de novo em outras janelas. Se o identificador vencer, registre seu custo: um novo cliente não tem divisão aprendida até acumular histórico, e o modelo precisa ser treinado de novo antes de poder prever para esse cliente.
Aplique a regra de início a todos os clientes
Uma série começa na sua primeira leitura. Antes disso, o medidor registra zeros, e esses zeros não são consumo baixo. O Capítulo 4 tratou disso para um cliente. Com trinta clientes, três começam tarde. MT_039 tem sua primeira leitura em 2013-10-03, MT_179 em 2013-12-20 e MT_115 em 2014-01-14. Um modelo ajustado nos zeros iniciais aprende um nível próximo de zero para eles. A regra de início descarta toda leitura anterior à primeira leitura de cada cliente. Ela encontra essa leitura apenas nas linhas anteriores ao ponto de corte.
A regra recusa um ponto de corte em apenas dois casos: um cliente não tem nenhuma leitura diferente de zero antes do corte, ou tem menos de 48 horas de histórico desde a sua primeira leitura. Ela não pula o cliente, porque um cliente pulado deixaria o total incompleto. A regra não detecta uma lacuna nem uma sequência de zeros no meio de uma série, e um medidor substituído com o mesmo identificador passa, pois seus zeros não são iniciais. A escala detecta uma lacuna, porque recusa uma série que não é uma série horária contínua. Nada na previsão verifica isso, então uma lacuna ali aparece apenas como menos linhas de treinamento.
A verificação de vazamento pergunta se a regra lê apenas o passado e recusa os pontos de corte corretos. Ela executa nove pontos de corte, recusados ou não, e contamina cada um a partir do corte, uma vez com zeros e uma vez com um valor que nenhum medidor poderia registrar. O histórico não pode mudar, e todo ponto de corte aceito deve conter os trinta clientes.
1"""Checks that the start rule reads only rows before each cutoff, refuses the cutoffs the data's flag predicts, and2removes only leading zeros, on nine cutoffs. The same checks run on a deliberately broken history function, and each3must fail there; the point rests on the refused, changed and missing counts. The checks are start_rule_checks in lib/panel.py."""4import pandas as pd56from lib.electricity import load7from lib.panel import ALL30, FEBRUARY_CUTOFFS, leaky_history, panel_history, start_rule_checks8from lib.settings import EVAL_CUTOFFS, show910raw = load(ALL30)11# nine cutoffs: three around MT_179's and MT_115's first readings (refused), the February cutoffs and the standard cutoffs12CHECKED = pd.DatetimeIndex(["2013-12-15", "2014-01-01", "2014-01-15", *FEBRUARY_CUTOFFS, *EVAL_CUTOFFS])131415def report(prefix, r):16 show(f"{prefix}cutoffs checked", len(CHECKED))17 show(f"{prefix}cutoffs refused by the start rule", r["refused"])18 show(f"{prefix}cutoffs expected to be refused, from the flag", r["expected"])19 show(f"{prefix}cutoffs where the refusal differs from the flag", r["mismatch"])20 show(f"{prefix}cutoffs accepted", r["accepted"])21 show(f"{prefix}accepted cutoffs with a client missing from the history", r["missing"])22 show(f"{prefix}cutoffs whose history changes when the future is poisoned", r["changed"])232425# the book's history function, with the count of rows the rule removes switched on26real = start_rule_checks(raw, CHECKED, panel_history, removed_rows=True)27report("", real)28show("rows the start rule removes, accepted cutoffs", real["removed"])29show("removed rows that are not zero", real["removed_nonzero"])30# the deliberately broken history, which reads each first reading from the whole series, must fail every check31report("broken version, ", start_rule_checks(raw, CHECKED, leaky_history))
python start-rule-leak-check.pycutoffs checked: 9
cutoffs refused by the start rule: 3
cutoffs expected to be refused, from the flag: 3
cutoffs where the refusal differs from the flag: 0
cutoffs accepted: 6
accepted cutoffs with a client missing from the history: 0
cutoffs whose history changes when the future is poisoned: 0
rows the start rule removes, accepted cutoffs: 2064
removed rows that are not zero: 0
broken version, cutoffs checked: 9
broken version, cutoffs refused by the start rule: 1
broken version, cutoffs expected to be refused, from the flag: 3
broken version, cutoffs where the refusal differs from the flag: 2
broken version, cutoffs accepted: 8
broken version, accepted cutoffs with a client missing from the history: 2
broken version, cutoffs whose history changes when the future is poisoned: 2
A regra real passa nas três verificações. Suas recusas coincidem com o indicador dos próprios dados, que usa cada primeira leitura e a regra de 48 horas: a regra recusa 3 dos nove pontos de corte, o indicador prevê 3, e 0 pontos de corte diferem dele.
Contaminar o futuro não altera nenhum histórico. O histórico muda em 0 pontos de corte, e 0 pontos de corte aceitos estão sem um cliente.
A regra remove apenas zeros iniciais e nada mais. Nos pontos de corte aceitos, ela descarta 2064 linhas, e 0 delas não são zero.
As mesmas verificações são executadas em uma versão deliberadamente quebrada, que lê cada primeira leitura a partir da série inteira, o vazamento para o qual as verificações foram escritas. Ela falha em todas elas. Suas recusas diferem do indicador em 2 pontos de corte, seu histórico muda em 2, e 2 pontos de corte aceitos perdem um cliente sem aviso. Assim, a aprovação da regra real tem significado.
O modelo é executado com a regra de início e sem ela, nos pontos de corte padrão e depois nos pontos de corte de fevereiro. As contagens que diferem e o erro de cada execução mostram o que a regra faz.
1"""Runs the global model with the start rule and without it, on the February cutoffs, where a late starter's zeros enter2the history, and on the standard cutoffs, where the rule changes no row. The point rests on the February mean MASE lines3and the count of forecast hours that differ; the scale lines compare the book's scale with a labelled counterfactual."""4import numpy as np5import pandas as pd67from lib.electricity import load8from lib.panel import (ALL30, FEBRUARY_CUTOFFS, IDENTIFIER_KEPT, LATE_STARTERS, late_starter_facts, mae_by_group,9 mase_by_run, scale_facts, with_and_without_start_rule)10from lib.quirks import mask_clock_changes11from lib.settings import EVAL_CUTOFFS, show1213raw = load(ALL30)14df = mask_clock_changes(raw)[["unique_id", "ds", "y"]] # clock-change hours are set to missing, so the scores leave them out15for label, value in late_starter_facts(raw, df).items():16 show(label, value)1718standard = pd.to_datetime(EVAL_CUTOFFS) # the three standard cutoffs19# two runs of the same model on the same cutoffs, differing only in their histories20scored = with_and_without_start_rule(df, standard, client_id=IDENTIFIER_KEPT)21# compared with isclose, so a rounding difference between two runs does not count as a changed forecast22show("forecast hours that differ, standard", int((~np.isclose(scored["start"], scored["raw"])).sum()))2324# the February cutoffs, where the zeros of MT_115 and MT_179 enter the history25feb = with_and_without_start_rule(df, FEBRUARY_CUTOFFS, client_id=IDENTIFIER_KEPT)26show("scored hours, february", len(feb))27show("forecast hours that differ, february", int((~np.isclose(feb["start"], feb["raw"])).sum()))28for model in ["start", "raw"]:29 for group, value in mae_by_group(feb, model).items():30 show(f"MAE {group}, {model}, february", value)31# both runs on one scale, read from the first February cutoff32feb_mase = mase_by_run(raw, feb, ["start", "raw"])33show("clients in MASE, february", int(feb_mase["start"].notna().sum()))34for uid in LATE_STARTERS:35 show(f"MASE {uid}, start, february", feb_mase.loc[uid, "start"])36 show(f"MASE {uid}, raw, february", feb_mase.loc[uid, "raw"])37for run in ["start", "raw"]:38 show(f"mean MASE, {run}, february", feb_mase[run].mean())3940# 'counterfactual raw' keeps the zeros before each first reading, a scale the book does not use; 'start rule' is the book's41for label, value in scale_facts(raw, standard, IDENTIFIER_KEPT).items():42 show(label, value)
python global-model-raw-starts.pyfirst reading MT_039: 2013-10-03
first reading MT_115: 2014-01-14
first reading MT_179: 2013-12-20
zero share of history MT_115, 2014-02-01: 68
zero share of history MT_179, 2014-02-01: 23
zero share of history MT_115, 2014-02-15: 43
zero share of history MT_179, 2014-02-15: 0
zero share of history MT_115, 2014-02-28: 20
zero share of history MT_179, 2014-02-28: 0
forecast hours that differ, standard: 0
scored hours, february: 2160
forecast hours that differ, february: 2160
MAE late starters, start, february: 4.60
MAE other clients, start, february: 77.53
MAE MT_039, start, february: 4.64
MAE MT_115, start, february: 4.62
MAE MT_179, start, february: 4.54
MAE late starters, raw, february: 4.60
MAE other clients, raw, february: 77.95
MAE MT_039, raw, february: 4.57
MAE MT_115, raw, february: 4.68
MAE MT_179, raw, february: 4.53
clients in MASE, february: 30
MASE MT_039, start, february: 0.78
MASE MT_039, raw, february: 0.77
MASE MT_115, start, february: 0.90
MASE MT_115, raw, february: 0.91
MASE MT_179, start, february: 0.54
MASE MT_179, raw, february: 0.54
mean MASE, start, february: 0.70
mean MASE, raw, february: 0.71
MASE scale MT_039, start rule: 5.21
MASE scale MT_039, counterfactual raw: 3.28
MASE scale MT_115, start rule: 4.58
MASE scale MT_115, counterfactual raw: 2.22
MASE scale MT_179, start rule: 5.91
MASE scale MT_179, counterfactual raw: 3.04
mean MASE global, counterfactual raw scale, standard cutoffs: 1.01
mean MASE global, book scale, standard cutoffs: 0.91
Nos pontos de corte padrão, a regra importa menos do que os clientes que começam tarde poderiam sugerir. Os três pontos de corte padrão têm 8 semanas de histórico, voltando até o início de novembro, e o histórico de nenhum cliente nessa janela contém zero anterior à sua primeira leitura. Assim, a regra não altera nenhuma linha de treinamento ali, e 0 das 2160 horas previstas mudam. A regra ainda altera a pontuação por meio da escala MASE.
Os pontos de corte de fevereiro, que o capítulo 4 usou para MT_115, são onde os zeros entram no histórico. O histórico de MT_115 tem 68 por cento de zeros em 1º de fevereiro de 2014, 43 por cento em 15 de fevereiro e 20 por cento em 28 de fevereiro. O histórico de MT_179 tem 23 por cento de zeros em 1º de fevereiro e nenhum depois.
Aqui as previsões mudam, porque um único modelo aprende com os trinta clientes ao mesmo tempo: 2160 das 2160 horas previstas nessas três janelas diferem. Ambas as execuções são pontuadas na mesma escala do livro, lida a partir de 1º de fevereiro de 2014, de modo que apenas os históricos diferem. O MASE médio é 0.70 com a regra e 0.71 sem ela.
O MASE de cada cliente que começa tarde se move muito pouco, e a direção é mista. MT_039 obtém 0.78 com a regra e 0.77 sem ela, e MT_115 obtém 0.90 com a regra e 0.91 sem.
MT_179 obtém 0.54 com a regra e 0.54 sem ela, o mesmo com duas casas decimais.
O MAE dos outros 27 clientes vai de 77.95 kWh sem a regra para 77.53 kWh com ela. O efeito é pequeno e misto, e três janelas são poucas para afirmar algo. Mantemos a regra porque os zeros não são demanda, e porque a escala depende dela.
Você poderia, em vez disso, marcar os zeros como ausentes, como faz a regra do relógio para as duas horas de mudança de relógio no capítulo 3. Essa seria a correção errada para estes dados. Um zero antes de uma primeira leitura é o medidor em silêncio, não uma leitura ausente, e um valor ausente ainda seria uma linha da qual o modelo aprende. A regra de início remove as linhas, e sua verificação é simples de enunciar: ela remove apenas linhas anteriores à primeira leitura, e todas elas são zero.
Regra prática: Aplique a regra de início a toda série que tenha zeros iniciais, e encontre cada primeira leitura nas linhas anteriores ao ponto de corte. Quando a regra recusar um ponto de corte, interrompa a execução e informe o cliente e o ponto de corte. Não preencha os zeros, e não publique um painel com um cliente ausente. Julgue a regra pela escala e pelas janelas em que os zeros entram no histórico, e espere que o efeito no MAE seja pequeno e misto.
Pontue trinta clientes nos mesmos cortes
Os três cortes padrão são 29 a 31 de dezembro de 2014, cada um às 00:00 desse dia, com 24 horas previstas a partir de cada um. Para trinta clientes, isso dá 72 horas pontuadas por cliente. O método sazonal ingênuo é a linha de base definida no Capítulo 2. Ela pega o histórico de cada corte, as 8 semanas anteriores a ele, e copia para frente as leituras do último dia. Nos cortes padrão, o histórico de nenhum cliente contém zero inicial, então o modelo global e a sazonalidade ingênua leem as mesmas leituras. A comparação é justa porque as entradas são iguais, e não porque os métodos sejam parecidos.
O resultado principal é o MASE médio por cliente, a medida definida no Capítulo 2. O livro usa uma escala por cliente por backtest, a regra que o Capítulo 2 estabelece, e a função book_scale em examples/lib/scoring.py a constrói. A escala é a variação absoluta média entre cada leitura e a leitura de um dia antes, considerada em todas as leituras anteriores ao primeiro corte pontuado. Um cliente que começa tarde é contado a partir da sua primeira leitura, e as leituras da mudança de horário são mascaradas. Um cliente sem nenhuma leitura diferente de zero antes do corte não tem escala, então fica fora do MASE e é informado, não tratado como erro. Como a escala lê apenas leituras anteriores às janelas pontuadas, ela é conhecida em todos os cortes e não pode vazar informação. Cada cliente conta uma vez na média, de modo que um cliente grande não pode definir sozinho o resultado principal. O MAE e o RMSE agregados vêm em seguida, como segunda linha. Eles mostram o erro em quilowatt-hora, que é o que o fornecedor paga, e são ponderados em favor dos clientes grandes.
A escala faz parte da pontuação. A escala de MT_115 é de 2.22 kWh se os zeros anteriores à sua primeira leitura forem mantidos, e de 4.58 kWh com a regra do livro, que a conta a partir da sua primeira leitura.
MT_039 e MT_179 se movem da mesma forma. A escala de MT_039 sobe de 3.28 para 5.21 kWh, e a de MT_179, de 3.04 para 5.91 kWh.
Nos cortes padrão, as mesmas previsões pontuam um MASE médio de 1.01 com a escala que mantém os zeros, e de 0.91 com a escala do livro. Essa diferença vem da escala, não do modelo. Uma pontuação calculada com outra regra de escala não é comparável a uma calculada com a regra do livro, por isso toda pontuação deve registrar a regra que usou.
A pontuação abaixo coloca o modelo global ao lado da sazonalidade ingênua nos três cortes padrão.
1"""Scores one global LightGBM model, with the identifier that client-identifier-check kept, against seasonal naive on the2three standard cutoffs, per client on the book's MASE scale. The point rests on the mean per-client MASE lines; the model3without the identifier is printed for reference only."""4import pandas as pd5from statsforecast import StatsForecast6from statsforecast.models import SeasonalNaive78from lib.backtest import forecast_windows9from lib.baselines import SEASON10from lib.electricity import load11from lib.panel import ALL30, IDENTIFIER_KEPT, panel_windows12from lib.quirks import mask_clock_changes13from lib.scoring import actual_hours, book_scale, left_out_facts, report_scores, score_windows14from lib.settings import EVAL_CUTOFFS, show1516raw = load(ALL30)17df = mask_clock_changes(raw)[["unique_id", "ds", "y"]] # clock-change hours are set to missing, so the scores leave them out18cutoffs = pd.to_datetime(EVAL_CUTOFFS) # the three standard cutoffs, Dec 29 to Dec 31, 201419actual = actual_hours(df, cutoffs)2021# seasonal naive from each cutoff's own history: the baseline of Chapter 222naive = forecast_windows(StatsForecast(models=[SeasonalNaive(season_length=SEASON)], freq="h", n_jobs=1), df, cutoffs)23global_fc = panel_windows(df, cutoffs, client_id=IDENTIFIER_KEPT) # the identifier setting that client-identifier-check kept24plain_fc = panel_windows(df, cutoffs, client_id=False, name="plain") # the same model without the identifier, for reference25forecasts = naive.merge(global_fc, on=["unique_id", "ds"], validate="one_to_one").merge(26 plain_fc, on=["unique_id", "ds"], validate="one_to_one")27models = ["SeasonalNaive", "global", "plain"]28# the book's scale, read from the readings before the first cutoff only29scored, per_client = score_windows(actual, forecasts, models, book_scale(raw, cutoffs[0]))30beats = per_client["global"] < per_client["SeasonalNaive"] # per client: True where the global model's MASE is lower3132show("clients scored", scored["unique_id"].nunique())33show("windows", len(cutoffs))34show("scored hours", len(scored))35# a client with no non-zero reading before the first cutoff is left out of MASE, and is not an error36for label, value in left_out_facts(raw, df, cutoffs[0]).items():37 show(label, value)38show("clients in MASE", per_client["global"].notna().sum())39show("clients where global beats seasonal naive", int(beats.sum()))40show("clients where seasonal naive wins", ", ".join(sorted(per_client.index[~beats])))41report_scores(scored, per_client, models)
python global-model-thirty-clients.pyclients scored: 30
windows: 3
scored hours: 2160
clients left out of MASE: 0
clients with no reading before 2013-12-15, check: 2
clients with any row before 2013-12-15, broken count: 30
clients in MASE: 30
clients where global beats seasonal naive: 23
clients where seasonal naive wins: MT_001, MT_128, MT_141, MT_179, MT_217, MT_268, MT_294
MAE SeasonalNaive: 148.26
MAE global: 122.81
MAE plain: 119.03
RMSE SeasonalNaive: 780.48
RMSE global: 678.81
RMSE plain: 657.63
mean MASE SeasonalNaive: 1.18
mean MASE global: 0.91
mean MASE plain: 0.98
O exemplo pontua 30 clientes em 3 janelas, 2160 horas pontuadas, e conta 0 clientes deixados de fora do MASE, que é zero: todo cliente tem uma leitura diferente de zero antes do primeiro corte, então todos estão na tabela de MASE.
A contagem só é tão boa quanto sua regra. Em um corte de 15 de dezembro de 2013, 2 clientes ainda não têm nenhuma leitura, e contar qualquer linha anterior ao corte daria 30, o que indicaria que não há lacuna.
Um único modelo global supera a sazonalidade ingênua nesses cortes, para a maioria dos clientes e no total: seu MASE médio por cliente é 0.91 contra 1.18, e ele vence para 23 dos trinta clientes. Ele perde para MT_001, MT_128, MT_141, MT_179, MT_217, MT_268, MT_294, e esses clientes são o primeiro lugar para olhar quando o modelo for atualizado.
Os números agregados apontam na mesma direção. O MAE é de 122.81 kWh contra 148.26 kWh, e o RMSE é de 678.81 kWh contra 780.48.
O modelo sem o identificador, impresso para referência, tem um MASE médio de 0.98 e um MAE de 119.03 kWh, que é a compensação (trade-off) descrita na seção sobre o identificador.
Os números impressos são médias e contagens, e uma média pode esconder um cliente muito pior que os demais. Quando um número mudar, abra primeiro a tabela por cliente.
O capítulo não explica por que a sazonalidade ingênua vence para esses clientes, e isso é motivo para não relatar apenas o número agregado. O resultado cobre três janelas em uma semana de uma estação, então descreve esses cortes, não todos os dias do ano. O teste mais longo é a semana de teste com sete janelas, que o exemplo com janela móvel do Capítulo 10 usa.
Regra prática: Pontue um modelo global por cliente nos mesmos cortes da linha de base, com a escala do MASE fixada antes do primeiro corte pontuado. Relate o MASE médio por cliente ao lado da sazonalidade ingênua, e imprima as contagens de clientes e de horas pontuadas para que um leitor possa conferi-las. Informe qualquer cliente deixado de fora do MASE e o motivo. Leia o MAE e o RMSE agregados como o custo em quilowatt-hora, não como a medida da qualidade do modelo.
Orce o tempo de execução
Um backtest custa ajustes, e a contagem deles é o que você deve verificar antes de executar um. Um modelo por cliente é ajustado uma vez para cada cliente, cada janela e cada método, de modo que a contagem é o número de clientes vezes o de janelas vezes o de métodos. Trinta clientes em três janelas somam noventa ajustes para um único método por cliente. Um modelo global é ajustado uma vez para cada janela e método, não importa quantos clientes ele cubra, e por isso as mesmas três janelas custam três ajustes. Mais clientes tornam cada ajuste global maior, mas não acrescentam ajustes.
O livro define uma regra de subconjunto para os métodos caros por cliente. SUBSET8 é o subconjunto de oito clientes sobre o qual o Capítulo 4 executa seus modelos estatísticos por cliente. Um modelo global abrange todos os trinta em um único ajuste, então ele roda sobre todos os trinta clientes, como ALL30. Os subconjuntos são fixos em todo o livro, de modo que um número de um capítulo pode ser comparado diretamente com o do seguinte. A contagem de janelas segue a mesma lógica. Métodos caros usam três janelas, e métodos baratos podem usar mais. Cada janela da verificação de identificadores custa dois ajustes globais, um com o identificador e outro sem ele, de modo que suas quatro janelas somam oito ajustes.
Os dois tipos de custo se comportam de forma diferente quando o número de clientes cresce. Um método por cliente ganha mais ajustes, um para cada novo cliente. Um modelo global ganha ajustes maiores, porque cada um lê mais linhas, e mantém o mesmo número de ajustes.
O livro não apresenta tempos de execução. Os exemplos rodam com uma única thread, de modo que sua saída se repete na máquina que registrou as saídas do livro, e essa escolha custa tempo de execução. Um tempo depende da máquina, e a máquina do leitor pode ser diferente. Conte os ajustes, não os segundos.
Regra prática: Antes de executar um backtest, conte seus ajustes: clientes vezes janelas vezes métodos para um método por cliente, e janelas vezes métodos para um método global. Se a contagem ultrapassar o orçamento, reduza o subconjunto ou o número de janelas, nunca as janelas pontuadas, e registre o corte ao lado da pontuação. Assim, o leitor pode comparar coisas semelhantes entre si.
O que dá errado em produção
Uma execução pode parar. Um cliente sem nenhuma leitura diferente de zero antes de um corte, ou com menos de 48 horas de histórico desde a sua primeira leitura, faz a regra de início recusar esse corte. A regra gera um erro em vez de ignorar o cliente, porque um cliente ignorado deixa o total incompleto, e o Capítulo 7 soma os clientes para formar o total. Em produção, a execução deve parar, indicar o cliente e o corte, e aguardar uma pessoa. A verificação de vazamento mostra as mesmas recusas nos dados do livro.
Um único modelo afeta todos os clientes. Nos cortes de fevereiro, os zeros dos clientes que começaram tarde alteraram 2160 horas de previsão, e o MAE dos outros 27 clientes também se moveu, como mostra a seção sobre a regra de início. Qualquer mudança no histórico de um cliente, em uma regra ou em uma variável altera as previsões em todo o painel. Depois de qualquer mudança, verifique todos os clientes, e não apenas aquele que você alterou.
A escala faz parte da pontuação. As mesmas previsões obtêm um MASE médio de 1.01 ou de 0.91, dependendo de a escala manter ou não os zeros anteriores à primeira leitura. A seção sobre pontuação apresenta as escalas. Registre a regra junto com cada pontuação, e trate uma mudança na regra como uma mudança na pontuação.
As decisões podem se desviar com o tempo. A decisão sobre o identificador se apoia em quatro janelas comuns que ficam fora da semana reservada para teste, e seu veredito é apertado. Quando clientes entram, saem ou mudam de porte, a decisão deve ser tomada novamente.
Um cliente ausente não aparece como erro na tabela. Um painel de vinte e nove clientes continua sendo uma tabela válida, e uma previsão dele continua parecendo uma previsão. Uma execução que pontua menos clientes ou horas do que o esperado, ou uma contagem de clientes em que o modelo global supera o naive sazonal que muda bruscamente entre execuções, é motivo para parar. Também é motivo para parar um MASE por cliente que salta para um cliente enquanto o MAE agregado permanece estável.
Regra prática: Imprima e verifique as contagens (clientes, janelas, horas pontuadas, cortes recusados, clientes deixados fora do MASE) em cada atualização, antes de ler qualquer pontuação. Depois, informe o MASE médio por cliente ao lado do naive sazonal. Interrompa a execução diante de qualquer recusa, e não publique um total calculado a partir de um painel incompleto.
Decisões tomadas neste capítulo
Capítulo 7 parte do que este capítulo entrega: trinta previsões de clientes para cada data de corte padrão, feitas por um único modelo com o identificador de cliente e a regra de início aplicados, e avaliadas na escala MASE única do livro. O identificador é mantido pela decisão em client-identifier-check, e examples/lib/panel.py registra esse veredito em IDENTIFIER_KEPT. O erro agregado nesses cortes é pior com o identificador, então o Capítulo 7 deve verificar o total antes de confiar nas previsões dos clientes.
- Um único modelo LightGBM global cobre os trinta clientes, com defasagens 24 e 168, sem variáveis de calendário nem de feriados, e o alvo de cada cliente é escalonado apenas com base no histórico dessa janela, o escalonamento que o Capítulo 5 define.
- Um identificador de cliente é mantido. A decisão usou quatro janelas comuns, de 25 de novembro a 3 de dezembro de 2014, fora da semana reservada para teste e sem feriado português, como a regra do livro para escolher uma configuração exige. O MASE médio nessas janelas passa de 0.77 para 0.75. O veredito é apertado, como mostra a seção sobre o identificador.
- A regra de início se aplica a todos os clientes. Ela recusa um corte que não consegue iniciar, em vez de deixar o cliente de fora.
- As horas de mudança de horário em cada histórico do painel são preenchidas somente a partir desse histórico, de modo que uma janela deslizante que atravessa uma mudança de horário é ajustada, e não recusada. As janelas deslizantes do Capítulo 10 dependem disso.
- O resultado principal é o MASE médio por cliente sobre os trinta clientes, na escala única do livro (definida no Capítulo 2 e calculada por
book_scale), ao lado da sazonal ingênua nos mesmos cortes. Um cliente sem nenhuma leitura diferente de zero antes do corte fica de fora do MASE e é relatado. O MAE e o RMSE agregados vêm em seguida, como segunda linha. Nenhum cliente fica de fora nos cortes padrão, porque cada um tem uma leitura antes do primeiro corte. - O modelo roda em uma única thread, com semente fixa, de modo que sua saída se repete na máquina que registrou as saídas do livro. O livro não testou outras máquinas.
Este capítulo, nesta edição
Edição 2026.11.11Exemplos aprovados em 20 de nov de 20264 de 4 exemplos exemplos deste capítulo passam
Traduzido do livro em inglês, edição 2026.11.11.