Fluxos de pesquisa reproduzíveis

Mesmas entradas, mesma resposta

Um resultado é reproduzível quando você, um colega ou um revisor podem executar o mesmo projeto mais tarde e obter os mesmos números. Um backtest que não pode ser refeito não pode ser auditado, depurado nem aceito. Os resultados divergem por poucos motivos: números aleatórios, versões diferentes de bibliotecas, dados que mudaram ou foram editados à mão, configurações espalhadas pelo código e estado oculto, como um notebook executado fora de ordem. Um fluxo reproduzível elimina cada fonte de divergência e registra o que foi usado.

import random

# Same seed, same "random" numbers
a = random.Random(42)
b = random.Random(42)
print([round(a.random(), 3) for _ in range(3)])   # [0.639, 0.025, 0.275]
print([round(b.random(), 3) for _ in range(3)])   # [0.639, 0.025, 0.275]

# A different seed gives a different but equally repeatable sequence
print(round(random.Random(7).random(), 3))        # 0.324

As sementes e qual gerador é dono delas

Simulações e bootstrap usam números aleatórios, que na verdade são uma sequência determinística iniciada por uma semente (seed). Fixe a semente e a execução se repete exatamente. random.seed(42) inicializa o único gerador global compartilhado por todo o programa, então qualquer outro código que sorteie números desloca a sua sequência. É mais seguro criar seu próprio gerador, rng = random.Random(42) (ou numpy.random.default_rng(42)), passá-lo adiante e sortear dele. Assim seus resultados dependem só da sua semente, e sua inicialização não perturba a aleatoriedade dos outros.

import random

# The global generator is shared: seeding it changes everyone's numbers
random.seed(1)
first = random.random()
random.seed(1)
print(random.random() == first)        # True: global seeding repeats...

# ...but a private generator leaves the global one untouched
random.seed(1)
before = random.getstate()
mine = random.Random(99)
mine.random()
print(random.getstate() == before)     # True: your draws did not disturb it

Impressões digitais para dados e configurações

Como saber se o arquivo de dados é o que você usou no mês passado? Calcule uma soma de verificação: um hash como o SHA-256 transforma qualquer arquivo numa string curta de tamanho fixo que muda se um único byte mudar. hashlib.sha256(data).hexdigest() a fornece; leia arquivos grandes em blocos. As configurações merecem o mesmo tratamento: serialize a configuração com chaves ordenadas (json.dumps(config, sort_keys=True)), aplique o hash a esse texto, e a impressão digital é idêntica para duas configurações equivalentes, seja qual for a ordem das chaves, e diferente assim que um valor muda.

import hashlib
import json

# A checksum of bytes
print(hashlib.sha256(b"AAPL,184.25").hexdigest()[:12])   # 06ea4aa73ec1 (12 characters of 64)

# A fingerprint of settings, independent of key order
def fingerprint(config):
    text = json.dumps(config, sort_keys=True, separators=(",", ":"))
    return hashlib.sha256(text.encode("utf-8")).hexdigest()[:12]

one = {"fee": 0.001, "window": 20}
two = {"window": 20, "fee": 0.001}
print(fingerprint(one) == fingerprint(two))              # True
print(fingerprint(one) == fingerprint({"fee": 0.002, "window": 20}))  # False

Anote o que você executou

Cada execução deve deixar um pequeno manifesto ao lado dos resultados: a semente, a impressão digital da configuração, as versões do Python e das bibliotecas, a soma de verificação de cada arquivo de entrada e o commit do Git do código. Com esse registro você diz exatamente o que produziu um número e pode refazê-lo depois. Combine-o com os hábitos anteriores: um ambiente fixado em requirements.txt, o código no Git, as configurações em um só arquivo, um comando que roda tudo dos dados brutos às tabelas finais e nenhuma edição manual dos dados no meio do caminho.

import json
import platform

# A manifest records what a run used
manifest = {
    "seed": 42,
    "config_fingerprint": "a1b2c3d4e5f6",
    "python": platform.python_version().split(".")[0] + ".x",
    "inputs": {"prices.csv": "9f86d081884c"},
}
print(json.dumps(manifest, indent=2, sort_keys=True))
# {
#   "config_fingerprint": "a1b2c3d4e5f6",
#   "inputs": {
#     "prices.csv": "9f86d081884c"
#   },
#   "python": "3.x",
#   "seed": 42
# }

• Use um random.Random(seed) próprio para que os resultados dependam só da sua semente.
• Impressão digital para dados (soma de verificação de um arquivo) e configurações (JSON ordenado e depois SHA-256).
• Salve um manifesto a cada execução; ambiente fixado + commit do Git + um comando para refazer.

A seguir: classes e objetos, para reunir dados e as funções que os manipulam em uma unidade organizada.

Lab: o que é avaliado

• Gerar retornos aleatórios repetíveis com seeded_returns25 pts
• Tirar a impressão digital de um arquivo de dados com file_checksum25 pts
• Tirar a impressão digital de uma configuração com config_fingerprint25 pts
• Registrar o que uma execução usou com run_manifest25 pts