Vai al contenuto

CI dell’engine: 311 script Pine su 312 eccellenti

Quella restante è un’anomalia dichiarata, in ambra.

Strategie compositeIndicatoriOrdini e rischioTimeframe e sessioniFill intrabarLinguaggio PineVerifiche dell’analizzatore
Strategie compositeIndicatoriOrdini e rischioTimeframe e sessioniFill intrabarLinguaggio PineVerifiche dell’analizzatore

Tocca o trascina sul grafico per leggere un punto qualsiasi.

Fonte: controllo di parità sul corpus aperto, branch main dell’engine, 2026-09-29.

Il grafico in forma di tabella

Controllo di parità sul corpus aperto, main dell’engine, 2026-09-29: 311 strategie eccellenti su 312; la restante è un’anomalia dichiarata.

GruppoStrategieEccellenteAnomalia dichiarata
Strategie composite53530
Indicatori79790
Ordini e rischio77770
Timeframe e sessioni28280
Fill intrabar880
Linguaggio Pine56560
Verifiche dell’analizzatore11101

PineForge backtesta il tuo Pine Script in CI: se i trade si discostano, build fallita.

Perché verificare la parità in CI

Come qualsiasi codice, anche le strategie cambiano strada facendo. Un parametro rinominato, una funzione di supporto riscritta, una modifica all’API di Pine v6 che ti è sfuggita: ciascuno di questi cambiamenti può spostare i segnali in silenzio, senza far fallire nessuno dei test esistenti. Senza un controllo di parità in CI, un commit che hai fatto due mesi fa può cambiare la lista dei trade della settimana scorsa, e te ne accorgi solo quando il P&L in reale non torna.

Fare il commit della lista dei trade di riferimento accanto al sorgente della strategia è una questione di disciplina, la stessa che rende affidabile il software: descrivi il risultato atteso e, se quello effettivo se ne discosta, la build fallisce. In un backtest, il risultato atteso è la lista dei trade (barra di entrata, barra di uscita, direzione, quantità, prezzo di esecuzione) su un insieme fisso di dati storici.

Quando questo confronto gira a ogni commit, la strada è a senso unico: il comportamento storico della tua strategia può solo migliorare, mai peggiorare per sbaglio. Sai esattamente quale commit ha cambiato il risultato, perché la build è fallita proprio su quel commit. La tua curva di equity ha il suo git blame.

È un aspetto che, sulle prime, la maggior parte dei trader quantitativi sottovaluta. Tra «ho testato questa strategia» e «ho un registro riproducibile, sotto controllo di versione, di ogni segnale storico che questa strategia abbia mai prodotto» c’è un abisso. Nel primo caso hai in mano una schermata, nel secondo una traccia verificabile. Con la CI la tieni aggiornata a ogni push, senza alcuno sforzo manuale.

PineForge si presta bene a questo uso perché il runtime è un’immagine Docker: gira ovunque giri Docker, a parità di input restituisce gli stessi trade e scrive un report JSON che puoi analizzare con jq. Per il backtest in sé non serve un browser, non devi accedere a nessun account e non ci sono limiti di richieste.

Esempio con GitHub Actions

Ecco il workflow completo: scarica il codice della strategia, lo transpila in C++ con l’immagine pineforge-release, esegue il backtest sul tuo CSV OHLCV fisso, analizza il report JSON con jq, lo confronta con il riferimento che tieni nel repository e fa fallire la build se un trade cambia direzione o barra, oppure se la variazione del PnL netto supera la tua soglia.

Il runtime è un’immagine di container, quindi non ci sono chiavi API da gestire: basta avviarla con docker run nel job. Crea il file .github/workflows/backtest.yml:

name: Backtest parity

on:
  push:
    branches: [main, "feat/**"]
  pull_request:

jobs:
  backtest:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v7

      # Pin the image version so results only change when you change it.
      - name: Transpile strategy to C++
        run: |
          docker run --rm --network=none \
            -e PINEFORGE_TRANSPILE_ONLY=1 \
            -v "$PWD/strategy.pine":/in/strategy.pine:ro \
            ghcr.io/pineforge-4pass/pineforge-release:1.12.0 > strategy.cpp

      - name: Run backtest
        run: |
          docker run --rm --network=none \
            -v "$PWD/strategy.cpp":/in/strategy.cpp:ro \
            -v "$PWD/data/ohlcv.csv":/in/ohlcv.csv:ro \
            ghcr.io/pineforge-4pass/pineforge-release:1.12.0 \
            > report.json

      - name: Assert parity
        run: |
          # Every trade keeps its side and its entry and exit bars,
          # and net P&L moves by at most THRESHOLD.
          BARS='[.trades[] | [.side, .entry_bar_index, .exit_bar_index]]'
          ACTUAL=$(jq '.summary.net_pnl' report.json)
          BASELINE=$(jq '.summary.net_pnl' baseline/report.json)
          DELTA=$(echo "$ACTUAL $BASELINE" | awk '{d=$1-$2; print (d<0)?-d:d}')
          THRESHOLD="0.01"
          if [ "$(jq -c "$BARS" report.json)" != "$(jq -c "$BARS" baseline/report.json)" ]; then
            echo "Parity drift: a trade changed side, entry bar or exit bar"
          elif awk "BEGIN{exit !($DELTA > $THRESHOLD)}"; then
            echo "Parity drift: net_pnl delta $DELTA exceeds threshold $THRESHOLD"
          else
            echo "Parity OK - same sides and bars, net_pnl delta $DELTA (threshold $THRESHOLD)"
            exit 0
          fi
          # One trade per line, so diff's line numbers are trade numbers.
          TRADE='.trades[] | {side, entry_bar_index, exit_bar_index, entry_price, exit_price, qty, pnl}'
          diff <(jq -c "$TRADE" baseline/report.json) <(jq -c "$TRADE" report.json)
          exit 1

Salva il report di riferimento in baseline/report.json nel repository e fanne il commit insieme al sorgente della strategia. Quando una PR cambia di proposito il comportamento della strategia, l’autore aggiorna il riferimento nella PR stessa. Quel diff diventa una traccia permanente di cosa è cambiato e perché.

Lo stesso workflow gira tale e quale su GitLab CI, Bitbucket Pipelines o qualsiasi runner che supporti Docker. Cambia la sintassi YAML e tieni gli stessi comandi shell.

Codici di uscita e verifica della parità

Il runtime di PineForge termina con codice 0 se l’esecuzione va a buon fine e con un codice diverso da zero in caso di errore: 2 se manca un file di input, 3 se fallisce la compilazione, 4 se fallisce il backtest e 5 se fallisce la transpilazione (Pine non supportato o errore di sintassi). La CI li rileva senza alcuna gestione particolare.

Verificare il risultato spetta al tuo workflow. Il report ha questo aspetto (qui accorciato):

{
  "engine": "pineforge",
  ...
  "summary": {
    "total_trades": 3483,
    "wins": 1288,
    "losses": 2194,
    "win_rate_pct": 36.9796,
    "net_pnl": 2518.39,
    "max_drawdown": -1382.76,
    ...
  },
  "trades": [
    {
      "n": 1,
      "side": "long",
      "entry_time": 1729402200000,
      "exit_time": 1729422000000,
      "entry_price": 2640.96,
      "exit_price": 2645.15,
      "qty": 1.0,
      "pnl": 4.19,
      "entry_bar_index": 34,
      "exit_bar_index": 56,
      ...
    }
  ],
  "metrics": { "all": { "profit_factor": 1.06, ... }, "equity": { "sharpe_tv": ..., ... } },
  "equity_curve": [ ... ],
  "fingerprint": { "digest": "sha256:...", ... }
}

Per un semplice controllo numerico della parità, confronta summary.net_pnl e summary.total_trades con il riferimento. Il workflow qui sopra legge anche l’array trades: ogni trade deve mantenere la stessa direzione e le stesse barre di entrata e di uscita. Quando un controllo fallisce, il workflow fa il diff delle due liste di trade, un trade per riga: così i numeri di riga di diff coincidono con i numeri dei trade e ogni riga mostra direzione, barre, prezzi, quantità e P&L di un trade, prima e dopo.

Una soglia pratica per i campi numerici: accetta scarti in virgola mobile fino a 0.01 (un centesimo di P&L netto) e fai fallire il controllo per qualsiasi scarto maggiore. Sui trade, invece, la tolleranza è zero: il workflow qui sopra fallisce a ogni cambio di direzione, di entry_bar_index o di exit_bar_index, qualunque sia il P&L. Se un trade cade su una barra diversa, vuol dire che è cambiata la logica dei tuoi segnali.

Un accorgimento pratico: aggiorna il riferimento in un passaggio separato del workflow, attivato solo da un’etichetta sulla PR. Così, in fase di revisione del codice, un cambiamento voluto compare accanto alla modifica in Pine che l’ha causato.

Prossimi passi