Pythonలో API Key లేకుండా పునరుత్పాదక Backtest

Pythonలో reproducible backtest అంటే, ఎలాంటి ఖాతా లేదా API key అవసరం లేకుండా, కొత్త మెషీన్‌లో మరొకరు తిరిగి అమలు చేసినప్పుడు మీకు వచ్చిన ఖచ్చితమైన సంఖ్యలే మళ్లీ వచ్చే backtest. చాలా ట్యుటోరియల్స్ మొదటి లైన్‌లోనే ఈ పరీక్షలో విఫలమవుతాయి. కారణం, live download ద్వారా తర్వాత చదివే వ్యక్తికి, రచయితకు అందిన ధరల చరిత్రతో స్వల్పంగా భిన్నమైన చరిత్ర అందుతుంది. ఈ మార్గదర్శకం ఒక open-source engineను quantjourney-bt version 0.12.4 వద్ద స్థిరపరుస్తుంది. దాని bundled exampleను ఎలాంటి credentials లేకుండా అమలు చేస్తుంది. ఆ తర్వాత real market dataను ఉపయోగించి, ఒకే స్వచ్ఛమైన runతో ఏమి నిర్ధారించలేమో చూపిస్తుంది.

బ్యాక్‌టెస్ట్‌ను పునరుత్పాదించగలిగేలా చేసేది ఏమిటి?

ఇక్కడ పునరుత్పాదకతకు నిర్దిష్టమైన, పరీక్షించగల అర్థం ఉంది: శుభ్రమైన కంప్యూటర్‌లో మరొక వ్యక్తి ఒకే కమాండ్‌ను అమలు చేస్తే, మీ సంఖ్యలు దశాంశం వరకు సరిగ్గా రావాలి. సాధారణంగా రెండు కారణాలు దీనిని దెబ్బతీస్తాయి.

మొదటిది కోడ్. 0.x వెర్షన్‌లో ఉన్న లైబ్రరీ చిన్న వెర్షన్ మార్పుల మధ్య అనుకూలతకు ఎలాంటి హామీ ఇవ్వదు. పేరు మార్చడం, డిఫాల్ట్ సెట్టింగ్ మారడం లేదా కాలమ్‌ల క్రమం మారడం వల్ల మీ స్క్రిప్ట్ అమలవుతూనే ఉంటుంది. కానీ అది తెలియకుండానే వేరే ఫలితాలను నివేదించవచ్చు.

రెండవది డేటా. మొదటి లైనే ప్రత్యక్ష డౌన్‌లోడ్‌తో ప్రారంభమయ్యే ట్యుటోరియల్‌ను పునరుత్పాదించగలిగేది కాదని చెప్పాలి. విక్రేతలు గత డేటాను సవరించవచ్చు, splitలకు సర్దుబాటు చేయవచ్చు, ఖాళీలను తరువాత భర్తీ చేయవచ్చు. దాంతో ఒక నెల తరువాత అదే స్క్రిప్ట్ వేరే సంఖ్యలను చూపిస్తుంది. ఆ తరువాత కోడ్‌లో మార్పు వల్ల ఫలితం మారిందా, డేటాలో మార్పు వల్ల మారిందా అనేది వేరు చేయలేరు.

ఈ ప్రాజెక్ట్‌ నుంచి అనుసరించదగిన విధానం: స్థిరమైన engine వెర్షన్‌ను, packageలోనే చేర్చిన చిన్న datasetతో జత చేయడం.

ఇన్‌స్టాల్ వెర్షన్‌ను స్థిరపరచండి: pip install quantjourney-bt==0.12.4

quantjourney-bt అనేది Apache License 2.0 కింద విడుదలైన QuantJourney backtester. దీనికి Python 3.11 లేదా అంతకంటే కొత్త వెర్షన్ అవసరం. వెర్షన్ 0.12.4ను 21 జూలై 2026న ప్రచురించారు. ఆగస్టు 2026లో నమోదు చేసిన విధంగా, కింద ఉన్న ప్రతి కమాండ్ ఇదే వెర్షన్‌ను సూచిస్తుంది.

ఐసోలేట్ చేసిన environmentలో పని చేయండి. python3 -m venv .venv దాన్ని సృష్టిస్తుంది, source .venv/bin/activate దానిలోకి ప్రవేశిస్తుంది, python -m pip install -U pip దానిలోని installerను అప్‌డేట్ చేస్తుంది. ఆ తర్వాత ఖచ్చితమైన వెర్షన్‌ను తీసుకోండి: pip install quantjourney-bt==0.12.4.

ప్రాజెక్ట్ unpinned రూపాన్ని pip install quantjourney-btగా documentationలో చూపిస్తుంది. ==0.12.4 భాగం మీ బాధ్యత. 0.x వెర్షన్లలో ఇది ముఖ్యమైనది. తర్వాత పని చేసే వ్యక్తికి కనిపించే చోట ఈ pinను నమోదు చేయండి: మీరు పేరుపెట్టని dependenciesతో సహా resolve అయిన ప్రతి dependencyని pip freeze > requirements.txt నమోదు చేస్తుంది.

రెండు optional extras ఉన్నాయి. Walk-forward మరియు optimization ఉదాహరణల కోసం Optunaను pip install "quantjourney-bt[wf]" జోడిస్తుంది. Benchmarks కోసం ఉపయోగించే yfinance fallbackను pip install "quantjourney-bt[data]" జోడిస్తుంది.

Apache-2.0 అనుమతులు విస్తృతంగా ఇచ్చే license. కోడ్‌ను వాణిజ్యపరంగా ఉపయోగించి, మార్చుకోవచ్చు. ఏదైనా redistribution చేసినప్పుడు license మరియు notice ఫైళ్లను ఉంచాలి. Contributors patent హక్కులను స్పష్టంగా మంజూరు చేస్తారు.

API కీ లేకుండా bundled SMA ఉదాహరణను ఎలా అమలు చేయాలి

రిపాజిటరీలో launcher scriptతో పాటు అమలు చేయగల యాభై example strategies ఉన్నాయి. ఇవి weight-based path, order-based path అనే రెండు మార్గాల్లో విభజించబడ్డాయి. వాటిలో five walk-forward workflows కూడా ఉన్నాయి. ./strategy.sh --list catalogను చూపిస్తుంది. ./strategy.sh example_weights_01_sma_daily --check ఒకే strategyని import చేసి, ఎలాంటి dataను తాకదు. Install సరిగ్గా జరిగిందో త్వరగా నిర్ధారించుకోవడానికి ఇదే వేగవంతమైన మార్గం.

Demo run ఒక్క లైనుతో పూర్తవుతుంది: ./strategy.sh example_weights_01_sma_daily --sample-data --output /tmp/qj-sample

--sample-data flagదే ప్రధాన విషయం. దాని వెనుక ఉన్న datasetను project ఇలా వివరిస్తుంది:

Sample dataset ఉద్దేశపూర్వకంగా చిన్నదిగా, పునరుత్పత్తి చేయగలిగే విధంగా రూపొందించబడింది. Account సృష్టించకుండానే install తనిఖీలు, report generation, engine flowను అర్థం చేసుకోవడానికి ఇది ఉపయోగపడుతుంది.
మూలం: quantjourney-bt README, version 0.12.4, 6 August 2026న చదివారు.

Run consoleలో తుది ఫలితాన్ని చూపించకుండా ఒక directoryని సృష్టిస్తుంది: summary.txt మరియు summary.json, ఒక metrics.csv, దాని equity_curve.png పక్కన ఉన్న equity_curve.csv, ఒక dashboard.html, plots/ folder, అలాగే run configurationను నమోదు చేసే run_metadata.json. చివరి fileనే చాలామంది పట్టించుకోరు. కానీ సంవత్సరం తర్వాత resultను audit చేయగలిగేలా చేసేది అదే.

వచ్చిన metricsను వాస్తవికంగా చదవండి. Bundled dataset చిన్నది, వివరణాత్మకమైనది. అందువల్ల summary.txtలో చూపించే Sharpe ratio, గరిష్ఠ drawdown sample fileను మాత్రమే వివరిస్తాయి. అవి ఏ strategy గురించిన ఆధారం కావు. వాటినే resultగా పరిగణించడం మొదటి తప్పు.

అయితే ఈ run నిర్ధారించే విషయాలు ఉపయోగకరమైనవే. Install పనిచేస్తుంది. Signal నుంచి target weights మీదుగా reconstructed portfolio value వరకు పూర్తి engine flow, ఒక్క credential కూడా లేకుండా మీ machineలో artifactsను సృష్టిస్తుంది. వాస్తవ చరిత్రపై backtests కోసం project's own data serviceకు credentialed path కూడా ఉంది. ఆ మార్గం documentationలో ఉంది. ఎవరి నుంచి ఎలాంటి సమాచారం అవసరం లేని దశ వద్ద ఈ walkthrough ముగుస్తుంది.

ఒకే in-sample equity curve మీకు ఏమి చెప్పదు

ఈ sample run ఒక equity curveను చూపిస్తుంది. Demo fileకు బదులుగా నిజమైన మార్కెట్ డేటాపై కొలిచినప్పుడు, ఆ curve ఏ విషయాలను వెల్లడించలేదో ఇక్కడ చూడండి.

కింది panelలో ఉదాహరణ strategy ఉపయోగించే అదే ఆలోచనను తీసుకున్నారు: 20-session moving average, 50-session moving averageను దాటినప్పుడు signalగా పరిగణించారు. ఈ నియమాన్ని SPYపై అమలు చేసి, 2017 నుంచి 2025 వరకు ప్రతి calendar yearను విడిగా నివేదించారు. ప్రతి sessionలో positionను ముందు session close ఆధారంగా నిర్ణయించారు. అందువల్ల ఆ సమయంలో ఇంకా అందుబాటులో లేని సంఖ్యపై rule ఎప్పుడూ trade చేయదు.

WITH daily AS
(
    SELECT
        toDate(toTimeZone(window_start, 'America/New_York')) AS d,
        toFloat64(argMax(close, window_start))               AS px
    FROM global_markets.delayed_stocks_minute_aggs
    WHERE ticker = 'SPY'
      AND window_start >= '2016-01-01 00:00:00'
      AND window_start <  '2026-01-01 05:00:00'
      AND (toHour(toTimeZone(window_start, 'America/New_York')) * 60
           + toMinute(toTimeZone(window_start, 'America/New_York'))) >= 570
      AND (toHour(toTimeZone(window_start, 'America/New_York')) * 60
           + toMinute(toTimeZone(window_start, 'America/New_York'))) < 960
    GROUP BY d
),
averaged AS
(
    SELECT
        d,
        px,
        avg(px) OVER (ORDER BY d ROWS BETWEEN 19 PRECEDING AND CURRENT ROW) AS fast_ma,
        avg(px) OVER (ORDER BY d ROWS BETWEEN 49 PRECEDING AND CURRENT ROW) AS slow_ma,
        row_number() OVER (ORDER BY d)                                      AS session_no
    FROM daily
),
positioned AS
(
    SELECT
        d,
        px,
        if(session_no >= 50 AND fast_ma > slow_ma, 1, 0) AS long_today,
        lagInFrame(if(session_no >= 50 AND fast_ma > slow_ma, 1, 0), 1)
            OVER (ORDER BY d ROWS BETWEEN 1 PRECEDING AND CURRENT ROW) AS long_prior,
        lagInFrame(px, 1)
            OVER (ORDER BY d ROWS BETWEEN 1 PRECEDING AND CURRENT ROW) AS px_prior
    FROM averaged
)
SELECT
    toYear(d)                                                                   AS year,
    round((exp(sum(log(if(long_prior = 1, px / px_prior, 1.0)))) - 1) * 100, 1) AS rule_pct,
    round((exp(sum(log(px / px_prior))) - 1) * 100, 1)                          AS hold_pct,
    countIf(long_today != long_prior)                                           AS crossover_count
FROM positioned
WHERE px_prior > 0
  AND toYear(d) >= 2017
GROUP BY year
ORDER BY year

మార్పులేని ఒకే ruleను 9 వేర్వేరు సార్లు కొలిచారు. మిగతా వివరాలు చదవడానికి ముందు రెండు percent columnsను పై నుంచి కిందికి చదవండి. 2017లో, అదే కాలంలో SPYని hold చేయడం ద్వారా వచ్చిన 19.4%తో పోలిస్తే, rule ఆ సంవత్సరాన్ని 16% వద్ద ముగించింది. 2025లో అదే రెండు columns వరుసగా 10.4% మరియు 16.4%గా ఉన్నాయి. రెండు rowsలోనూ code ఒకటే. మారింది window మాత్రమే.

Crossover column చూపించేది, దీనికి ఆధారమైన evidence ఎంత పరిమితంగా ఉందో. 4 position changes 2025లో జరిగాయి. అంటే ఒక పూర్తి సంవత్సరపు equity curve కేవలం కొద్దిపాటి నిర్ణయాలపై ఆధారపడి ఉంటుంది. దాన్ని ఒక నిర్ధారిత ఫలితంగా పరిగణించడానికి ఇది చాలా చిన్న sample.

ఇతర షేర్లలో ఇదే నియమం కూడా అదే విధంగా పనిచేస్తుందా?

ఒకే కర్వ్‌ను పరిశీలించడానికి తేదీల పరిధిని మార్చడం ఒక మార్గం. మరో మార్గం పెట్టుబడి విశ్వాన్ని మార్చడం. దిగువ ప్యానెల్‌లో పరామితులను స్థిరంగా ఉంచి, 2021 నుంచి 2025 వరకు ఉన్న ఐదు క్యాలెండర్ సంవత్సరాల్లో అధిక లిక్విడిటీ ఉన్న ఐదు షేర్లపై ఇదే నియమాన్ని అమలు చేశాం.

WITH daily AS
(
    SELECT
        ticker,
        toDate(toTimeZone(window_start, 'America/New_York')) AS d,
        toFloat64(argMax(close, window_start))               AS px
    FROM global_markets.delayed_stocks_minute_aggs
    WHERE ticker IN ('SPY', 'QQQ', 'AAPL', 'MSFT', 'KO')
      AND window_start >= '2020-07-01 00:00:00'
      AND window_start <  '2026-01-01 05:00:00'
      AND (toHour(toTimeZone(window_start, 'America/New_York')) * 60
           + toMinute(toTimeZone(window_start, 'America/New_York'))) >= 570
      AND (toHour(toTimeZone(window_start, 'America/New_York')) * 60
           + toMinute(toTimeZone(window_start, 'America/New_York'))) < 960
    GROUP BY ticker, d
),
averaged AS
(
    SELECT
        ticker,
        d,
        px,
        avg(px) OVER (PARTITION BY ticker ORDER BY d ROWS BETWEEN 19 PRECEDING AND CURRENT ROW) AS fast_ma,
        avg(px) OVER (PARTITION BY ticker ORDER BY d ROWS BETWEEN 49 PRECEDING AND CURRENT ROW) AS slow_ma,
        row_number() OVER (PARTITION BY ticker ORDER BY d)                                      AS session_no
    FROM daily
),
positioned AS
(
    SELECT
        ticker,
        d,
        px,
        lagInFrame(if(session_no >= 50 AND fast_ma > slow_ma, 1, 0), 1)
            OVER (PARTITION BY ticker ORDER BY d ROWS BETWEEN 1 PRECEDING AND CURRENT ROW) AS long_prior,
        lagInFrame(px, 1)
            OVER (PARTITION BY ticker ORDER BY d ROWS BETWEEN 1 PRECEDING AND CURRENT ROW) AS px_prior
    FROM averaged
)
SELECT
    ticker                                                                      AS symbol,
    round((exp(sum(log(if(long_prior = 1, px / px_prior, 1.0)))) - 1) * 100, 1) AS rule_pct,
    round((exp(sum(log(px / px_prior))) - 1) * 100, 1)                          AS hold_pct,
    round(avg(long_prior) * 100, 0)                                             AS days_long_pct
FROM positioned
WHERE px_prior > 0
  AND d >= toDate('2021-01-01')
GROUP BY symbol
ORDER BY rule_pct DESC

ప్యానెల్‌లో QQQ అగ్రస్థానంలో 40.2%తో ఉంది. దిగువ వరుసలోని KO విలువ 3.8%గా ఉంది. days_long_pct కాలమ్‌లోని ప్రతి వెర్షన్ మొత్తం పరిధిలో ఏదైనా పొజిషన్‌ను కలిగి ఉన్న సమయాన్ని చూపిస్తుంది. అగ్ర వరుసకు అది 67%. ఒకే పరామితుల సమూహం, ఐదు పెట్టుబడి విశ్వాలు, అలాగే ఫలితాల్లో ఇంత విస్తృత వ్యత్యాసం ఉన్నప్పుడు, తర్వాత విజేతను ఎంచుకోవడం ద్వారా మీరు ఇంకా అమలు చేయని ట్రేడ్‌ గురించి ఏమీ నిర్ధారించలేరు.

ఇదంతా crossoverను ట్రేడ్ చేయాలన్న సిఫార్సు కాదు. Backtestలో crossover ఒక కొలమానం మాత్రమే. మనం కొలుస్తున్నది backtestనే.

వెయిట్స్ బ్యాక్‌టెస్ట్‌లో look-ahead bias ఎక్కడ ప్రవేశిస్తుంది

Weights ఆధారిత ఇంజిన్ ఒక signalను target weightsగా మారుస్తుంది. ఆ weightsకు అనుగుణంగా జరిగే fillsను అనుకరిస్తుంది. తర్వాత వచ్చిన positions ఆధారంగా పోర్ట్‌ఫోలియో విలువను మళ్లీ లెక్కిస్తుంది. Signal మరియు weight కలిసే దశలోనే లోపం దాగి ఉంటుంది. ఈరోజు weight ఈరోజు close ఆధారంగా నిర్ణయించి, అదే weightపై ఈరోజు returnను ఆర్జిస్తే, ఆర్డర్ ఇచ్చే సమయానికి అందుబాటులో లేని సమాచారంతో backtest ట్రేడ్ చేసినట్టవుతుంది. దీనినే look-ahead bias అంటారు. ఇది ఎలాంటి errorను చూపించదు. బదులుగా ప్రతిదీ మెరుగ్గా కనిపించేలా చేస్తుంది.

క్రింది panel అదే SPY చరిత్రపై ఒకే rule యొక్క రెండు వెర్షన్లను నడుపుతుంది.

WITH daily AS
(
    SELECT
        toDate(toTimeZone(window_start, 'America/New_York')) AS d,
        toFloat64(argMax(close, window_start))               AS px
    FROM global_markets.delayed_stocks_minute_aggs
    WHERE ticker = 'SPY'
      AND window_start >= '2016-01-01 00:00:00'
      AND window_start <  '2026-01-01 05:00:00'
      AND (toHour(toTimeZone(window_start, 'America/New_York')) * 60
           + toMinute(toTimeZone(window_start, 'America/New_York'))) >= 570
      AND (toHour(toTimeZone(window_start, 'America/New_York')) * 60
           + toMinute(toTimeZone(window_start, 'America/New_York'))) < 960
    GROUP BY d
),
averaged AS
(
    SELECT
        d,
        px,
        avg(px) OVER (ORDER BY d ROWS BETWEEN 19 PRECEDING AND CURRENT ROW) AS fast_ma,
        avg(px) OVER (ORDER BY d ROWS BETWEEN 49 PRECEDING AND CURRENT ROW) AS slow_ma,
        row_number() OVER (ORDER BY d)                                      AS session_no
    FROM daily
),
positioned AS
(
    SELECT
        d,
        px,
        if(session_no >= 50 AND fast_ma > slow_ma, 1, 0) AS long_today,
        lagInFrame(if(session_no >= 50 AND fast_ma > slow_ma, 1, 0), 1)
            OVER (ORDER BY d ROWS BETWEEN 1 PRECEDING AND CURRENT ROW) AS long_prior,
        lagInFrame(px, 1)
            OVER (ORDER BY d ROWS BETWEEN 1 PRECEDING AND CURRENT ROW) AS px_prior
    FROM averaged
)
SELECT
    toYear(d)                                                                   AS year,
    round((exp(sum(log(if(long_prior = 1, px / px_prior, 1.0)))) - 1) * 100, 1) AS next_bar_pct,
    round((exp(sum(log(if(long_today = 1, px / px_prior, 1.0)))) - 1) * 100, 1) AS same_bar_pct,
    round(abs(exp(sum(log(if(long_today = 1, px / px_prior, 1.0))))
              - exp(sum(log(if(long_prior = 1, px / px_prior, 1.0))))) * 100, 1) AS gap_pp
FROM positioned
WHERE px_prior > 0
  AND toYear(d) >= 2017
GROUP BY year
ORDER BY year

2017లో prior-session వెర్షన్ 16%ను చూపించింది. అదే-session వెర్షన్ 17.1%ను చూపించింది. ఈ రెండింటి మధ్య తేడా 1.1 percentage points. 2025లో ఈ రెండు కొలతల మధ్య దూరం 1.6 percentage pointsగా ఉంది. Session ఎక్కడ ముగిసిందో ముందుగానే తెలియని machine ద్వారా ఆ columnsలో ఒకదానినే రూపొందించగలం. ఈ రెండింటి మధ్య తేడా పూర్తిగా accounting వల్ల ఏర్పడింది. దాని వెనుక ఎలాంటి idea, skill లేదా trade లేదు.

Timingకు సంబంధించిన ప్రశ్నపై ఈ engine తన స్వంత విధానాన్ని స్పష్టంగా చెబుతుంది. ఇది ఒక హామీ కంటే విలువైనది:

Open వద్ద fills కోసం range-sensitive slippageకు ముందు పూర్తయిన bar మాత్రమే కనిపిస్తుంది. Volume capacityను lagged observations ఆధారంగా forecast చేస్తారు. ఆ రోజులో తర్వాత నమోదయ్యే high, low, close లేదా full-day volumeను engine ఉపయోగించదు.
మూలం: quantjourney-bt README, version 0.12.4; 6 ఆగస్టు 2026న చదివినది.

డాక్యుమెంట్ చేసిన assumptionను మీరు ఇప్పటికే install చేసిన sourceతో తనిఖీ చేయవచ్చు. డాక్యుమెంట్ చేయని assumption మాత్రం ఒక అంచనా.

వాక్-ఫార్వర్డ్ అదనపు భాగం ఎందుకు ఉంది

WF01 నుంచి WF05 వరకు ఉన్న వాక్-ఫార్వర్డ్ ఉదాహరణలు [wf] అదనపు భాగంతో పాటు దాని Optuna dependencyతో వస్తాయి. వాక్-ఫార్వర్డ్ విధానంలో చరిత్రలోని ఒక భాగంపై parametersను fit చేసి, ఆ తర్వాతి భాగంపై వాటి పనితీరును కొలుస్తారు. తర్వాత ఈ రెండు భాగాలను ముందుకు జరిపి ప్రక్రియను మళ్లీ నిర్వహిస్తారు. Rolling, expanding వేరియంట్ల మధ్య తేడా ఏమిటంటే, fitting window ముందుకు కదిలేటప్పుడు దానిలోని అత్యంత పాత డేటాను తొలగిస్తుందా లేదా అనేది. మరో ఉదాహరణ ప్రతి సరిహద్దు వద్ద purge, embargoను జోడిస్తుంది. అంటే రెండు భాగాలు కలిసే ప్రాంతానికి సమీపంలోని observationsను తొలగిస్తుంది. దీంతో ఒక భాగంపై fit చేసిన మోడల్‌ను అదే భాగంపై కొలిచే పరిస్థితి ఏర్పడదు.

ఇవేవీ బలహీనమైన ఆలోచనను పనిచేసే వ్యూహంగా మార్చవు. అయితే ఒకే సంఖ్యకు బదులుగా, చర్చించి విశ్లేషించగల సంఖ్యల distributionను ఇస్తాయి. ఇదే ప్రధాన మెరుగుదల. ఆ తర్వాతి దశ ఇప్పటికీ live moneyతో ట్రేడింగ్ కాదు: నిజమైన డబ్బు పెట్టే ముందు paper trading backtest నిర్మాణపరంగా చూడలేని అంశాలను కొలుస్తుంది. అందులో మొదటిది, simulator ఊహించిన ధరకు మీ order సమీపంలో ఎక్కడైనా fill అవుతుందా అనేది. అలాగే, మీ code విఫలమయ్యే రోజున అది ఎలా ప్రవర్తిస్తుందో trading bots కోసం circuit breakers నియంత్రిస్తాయి. వీటి వెనుక ఉన్న statisticsను మరింత లోతుగా అర్థం చేసుకోవడానికి open-source quant trading bookపై మా notes చూడండి.

తరచుగా అడిగే ప్రశ్నలు

API key లేకుండా వ్యూహాన్ని backtest చేయగలరా?

అవును. quantjourney-bt, --sample-data flag వెనుక bundled sample datasetను అందిస్తుంది. దానితో ఉదాహరణ strategiesను account లేదా credentials లేకుండానే అమలు చేయవచ్చు. Dataset చిన్నది, వివరణాత్మకమైనది మాత్రమే. కాబట్టి ఈ runను వ్యూహానికి ఆధారంగా కాకుండా, installation మరియు pipeline తనిఖీగా పరిగణించాలి.

Python backtesting package versionను ఎందుకు pin చేయాలి?

0.xలో ఉన్న package minor releases మధ్య compatibility హామీ ఇవ్వదు. మారిన default లేదా పేరు మార్చిన metric గురించి package ముందస్తుగా తెలియజేయకపోవచ్చు. pip install quantjourney-bt==0.12.4తో versionను pin చేసి, requirements fileలో environmentను నమోదు చేస్తే, ఈ రోజు పొందిన ఫలితాన్ని వచ్చే సంవత్సరం అదే engineపై మళ్లీ రూపొందించవచ్చు.

quantjourney-bt ఏ licence కింద విడుదలైంది?

Apache License 2.0. ఇది వాణిజ్య వినియోగం మరియు మార్పులను అనుమతిస్తుంది. Redistribute చేసేటప్పుడు licence మరియు notice filesను ఉంచాలని కోరుతుంది. Contributors నుంచి స్పష్టమైన patent grantను కూడా కలిగి ఉంది. Version 0.12.4ను 21 జూలై 2026న ప్రచురించారు. దీనికి Python 3.11 లేదా అంతకంటే కొత్త version అవసరం.

Backtestలో బలమైన ఫలితం వస్తే వ్యూహం పనిచేస్తుందని అర్థమా?

కాదు. Backtest అనేది ఒకే windowలో, ఒకే universeపై చేసిన ఒక కొలత మాత్రమే. పై panelsలో మార్పులేని ఒకే rule, ఒక tickerపై సంవత్సరాల వారీగా చాలా భిన్నమైన figuresను ఇచ్చింది. ఐదు పేర్లలో కూడా figures చాలా భిన్నంగా ఉన్నాయి. Walk-forward validation మరియు out-of-sample testing బహిర్గతం చేయాల్సిన తేడా ఇదే.

ఇక్కడి ప్రతి panelకు దాని కింద ఖచ్చితమైన SQL ఉంటుంది. అందువల్ల pinned install మాదిరిగానే ఈ పేజీలోని numbersను మళ్లీ run చేయవచ్చు. మీరు backtest code రాయడానికి ముందు, మీ స్వంత windowలో ఒక ruleను కొలవాలంటే Strasmore terminalలో ప్రశ్నను సాధారణ Englishలో అడగండి.