Optimization కంటే Equal Weight ఎప్పుడు మెరుగ్గా ఉంటుంది

నమూనా పరిమాణం expected returns‌ను విశ్వసనీయంగా అంచనా వేయడానికి చాలా చిన్నగా ఉన్నప్పుడు optimized position sizing కంటే equal weight మెరుగ్గా పనిచేస్తుంది. చిన్న నమూనాలు మినహాయింపు కాదు; సాధారణ పరిస్థితి.

ఎవరూ సరిగ్గా కొలవలేని input‌కు optimizer సరైన గణితాన్ని వర్తింపజేస్తుంది. 1/N portfolio, అంటే equal weight, ఎలాంటి అంచనాన్నీ ఉపయోగించదు. అందుకే అంచనాలు తప్పుగా ఉన్నప్పుడు కూడా అది మెరుగ్గా నిలబడుతుంది.

సమాన బరువు నిజంగా ఆప్టిమైజేషన్‌ను అధిగమిస్తుందా?

ఒక నిర్దిష్ట పరిస్థితిలో అవును. అంశాలను ఒక్కొక్కటిగా పరిశీలిద్దాం. సమాన బరువు, 1/Nగా రాసేది, N పొజిషన్లలో మూలధనాన్ని సమానంగా విభజిస్తుంది. దీనికి ఎలాంటి అంచనా అవసరం లేదు. Mean variance optimization అంచనా వేసిన varianceలో ప్రతి యూనిట్‌కు అత్యధిక expected return ఇచ్చే బరువులను గణిస్తుంది. Kelly criterion దీర్ఘకాలిక compound growthను గరిష్ఠం చేసే బరువులను గణిస్తుంది. పరస్పరం సంబంధం లేని ఆస్తుల విషయంలో, దాని ఫలితం ప్రతి ఆస్తి expected excess returnను దాని varianceతో భాగించిన దానికి అనుపాతంగా ఉండే బరువుగా మారుతుంది. మా Kelly criterion పొజిషన్ పరిమాణ నిర్ణయం గైడ్ ఆ సూత్రాన్ని వివరంగా వివరిస్తుంది.

రెండు ఆప్టిమైజర్లకూ ఒకే ఇన్‌పుట్ అవసరం: ప్రతి ఆస్తికి expected return. ఒక sample ద్వారా అత్యంత తప్పుగా అంచనా వేయబడే పరిమాణం ఇదే. Volatilityను తక్కువ కాల వ్యవధి డేటా నుంచి ఉపయోగించగల ఖచ్చితత్వంతో గణించవచ్చు. Mean విషయంలో అలా కాదు. ఈ రెండింటి మధ్య తేడా ఏ ధరల చరిత్రలోనైనా కనిపించేంత పెద్దది. దిగువ ప్యానెల్‌లో విస్తృతంగా కలిగి ఉన్న ఆరు పేర్లను తీసుకున్నారు. 2015 నుంచి 2024 వరకు ప్రతి calendar yearను విడిగా కొలిచారు. ఆ తర్వాత అత్యధిక, అత్యల్ప వార్షిక అంచనాల మధ్య దూరాన్ని చూపించారు. ప్రతి పేరుకు ఇది రెండుసార్లు చేశారు: ఒకసారి annualized average daily return కోసం, మరోసారి annualized volatility కోసం.

WITH prices AS
(
    SELECT
        ticker,
        date,
        toFloat64(max(close)) AS c
    FROM global_markets.stocks_daily_aggs
    WHERE ticker IN ('AAPL', 'MSFT', 'NVDA', 'SPY', 'KO', 'JNJ')
      AND date >= '2015-01-01'
      AND date <  '2025-01-01'
    GROUP BY ticker, date
),
rets AS
(
    SELECT
        ticker,
        date,
        c / lagInFrame(c, 1) OVER (PARTITION BY ticker ORDER BY date ASC ROWS BETWEEN 1 PRECEDING AND CURRENT ROW) - 1 AS ret
    FROM prices
),
yearly AS
(
    SELECT
        ticker,
        toYear(date)                     AS yr,
        avg(ret) * 252 * 100             AS mean_pct,
        stddevPop(ret) * sqrt(252) * 100 AS vol_pct
    FROM rets
    WHERE isFinite(ret)
    GROUP BY ticker, yr
    HAVING count() >= 200
)
SELECT
    ticker,
    round(max(mean_pct) - min(mean_pct), 1) AS mean_estimate_range_pct,
    round(max(vol_pct) - min(vol_pct), 1)   AS vol_estimate_range_pct
FROM yearly
GROUP BY ticker
ORDER BY mean_estimate_range_pct DESC

NVDA కోసం, ఆ పది సంవత్సరాల్లో వార్షిక mean estimate పరిధి 184.7 percentage pointsగా ఉంది. అదే పేరుకు, అదే సంవత్సరాల్లో volatility estimate పరిధి 28.6 pointsగా ఉంది. ప్యానెల్‌లో అత్యంత స్థిరమైన పేరు అయిన KO కూడా తన వార్షిక mean estimateను 23.9 points మేరకు మార్చుకుంది. గత సంవత్సరం average returnను ఈ సంవత్సరం expected returnగా ఆప్టిమైజర్‌కు అందించే ఏ విధానమైనా, ఇంత మార్పు ఉండే ఒక సంఖ్యను ఇన్‌పుట్‌గా ఇస్తోంది.

అంచనా వేసిన రాబడిని లెక్కించడానికి ఎంత కాలం నాటి నమూనా అవసరం?

అంచనా వేసిన సగటు రాబడి యొక్క standard error అనేది ఆ ఆస్తి volatilityని, సంవత్సరాల్లో కొలిచిన నమూనా పొడవు యొక్క square rootతో భాగించినంత. ఇక్కడ సంవత్సరాలు ముఖ్యం, observations సంఖ్య కాదు. అదే పన్నెండు నెలల డేటాను రోజువారీగా కాకుండా ప్రతి గంటకు సేకరించినా అదనపు ప్రయోజనం ఉండదు. 20 శాతం volatility ఉన్న ఆస్తికి ఈ సూత్రాన్ని వర్తింపజేస్తే, ఒక సంవత్సరం చరిత్ర standard errorను సంవత్సరానికి 20 percentage pointsగా ఇస్తుంది. నాలుగు సంవత్సరాలు దాన్ని 10కి సగం చేస్తాయి. నిజమైన సగటు రాబడులు రెండు percentage points తేడా ఉన్న రెండు ఆస్తులను ర్యాంక్ చేయడానికి కావాల్సిన స్థాయి అయిన ఒక pointకు దాన్ని తగ్గించాలంటే, నాలుగు శతాబ్దాల డేటా అవసరం.

Volatility విషయంలో పరిస్థితి భిన్నంగా ఉంటుంది. దాని ఖచ్చితత్వం క్యాలెండర్ కాలవ్యవధి కంటే observations సంఖ్య పెరగడంపై ఎక్కువగా ఆధారపడి ఉంటుంది. అందువల్ల కొన్ని నెలల రోజువారీ డేటా కూడా దాని అంచనాను కొన్ని points పరిధిలోకి తీసుకువస్తుంది. దిగువ ప్యానెల్‌లో ఒక index fundకు చెందిన ఇరవై సంవత్సరాల రోజువారీ రాబడులను, నిర్ణీత పొడవున్న మరియు పరస్పరం అతిక్రమించని blocksగా విభజించారు. ప్రతి blockలో రెండు అంచనాలను లెక్కించి, block నుంచి blockకు అవి ఎంతగా మారుతున్నాయో చూపించారు.

WITH prices AS
(
    SELECT
        date,
        toFloat64(max(close)) AS c
    FROM global_markets.stocks_daily_aggs
    WHERE ticker = 'SPY'
      AND date >= '2005-01-01'
      AND date <  '2025-01-01'
    GROUP BY date
),
rets AS
(
    SELECT
        date,
        c / lagInFrame(c, 1) OVER (ORDER BY date ASC ROWS BETWEEN 1 PRECEDING AND CURRENT ROW) - 1 AS ret
    FROM prices
),
numbered AS
(
    SELECT
        ret,
        row_number() OVER (ORDER BY date ASC) AS i
    FROM rets
    WHERE isFinite(ret)
),
sweep AS
(
    SELECT
        arrayJoin([21, 63, 126, 252, 504]) AS n,
        i,
        ret
    FROM numbered
),
blocks AS
(
    SELECT
        n,
        intDiv(i - 1, n)                 AS blk,
        avg(ret) * 252 * 100             AS mean_pct,
        stddevPop(ret) * sqrt(252) * 100 AS vol_pct
    FROM sweep
    GROUP BY n, blk
    HAVING count() = n
)
SELECT
    concat(toString(n), ' sessions') AS sample_length,
    round(stddevPop(mean_pct), 1)    AS mean_estimate_spread_pct,
    round(stddevPop(vol_pct), 1)     AS vol_estimate_spread_pct,
    count()                          AS window_count
FROM blocks
GROUP BY n
ORDER BY n ASC

21 sessions పొడవున్న blocksలో, mean estimate 53.7 percentage points పరిధిలో మారుతుంది. అదే blocksపై కొలిచిన volatility estimateలో ఈ మార్పు 10.9 points. Block పొడవును 504 sessionsకు పెంచితే, mean estimateలో మార్పు 10.6 pointsకు తగ్గుతుంది. ఈ తగ్గుదల square root నియమాన్ని అనుసరిస్తుంది: errorను సగానికి తగ్గించడానికి డేటాను నాలుగు రెట్లు పెంచాలి.

మీరు స్వయంగా అమలు చేయగల seeded simulation

ఇవేవీ estimation error 1/Nకు విజయం అందించేంత పెద్దదని నిరూపించవు. ఈ simulation నిరూపిస్తుంది. దీన్ని అమలు చేయడానికి Python install తప్ప మరేమీ అవసరం లేదు: data files, downloads, third-party packages ఏవీ అవసరం లేదు. మీరు ఎంచుకునే parameters నుంచి ఇది స్వయంగా returnsను రూపొందిస్తుంది. అందువల్ల నిజమైన సమాధానం ముందే తెలిసి ఉంటుంది. రెండు allocationsను దానితో పోల్చి అంచనా వేయవచ్చు.

1. import random, import statistics అనే రెండు modulesతో పాటు from math import logను import చేయండి. తదుపరి లైన్‌లో random.seed(20260816)తో seedను సెట్ చేయండి.
2. ఐదు assetsను నిర్వచించండి. వాటి నిజమైన వార్షిక expected returns వరుసగా 5, 6, 7, 8, 9 శాతం ఉండాలి. ప్రతి assetకు నిజమైన వార్షిక volatility 20 శాతంగా, పరస్పరం uncorrelatedగా ఉండాలి. mu_d = mu_a / 252, sd_d = sd_a / (252 ** 0.5)తో వీటిని రోజువారీ stepగా మార్చండి.
3. [60, 125, 250, 500, 1000, 2500, 5000] sweep నుంచి sample length Tను ఎంచుకోండి.
4. random.gauss(mu_d, sd_d)తో ప్రతి assetకు T రోజువారీ returnsను రూపొందించండి. Managerకు కనిపించే మొత్తం చరిత్ర ఇదే.
5. statistics.meanతో ప్రతి asset సగటును, statistics.stdevతో volatilityని అంచనా వేయండి. Optimizerకు తెలిసినవి ఈ రెండు estimates మాత్రమే.
6. ఐదు assetsలో ప్రతి దానికి 0.2 కేటాయించి equal-weight portfolioను నిర్మించండి. ఇది estimatesలో ఏదీ ఉపయోగించదు.
7. ప్రతి raw weightను mu_hat / (sd_hat ** 2)గా సెట్ చేసి optimized portfolioను నిర్మించండి. తర్వాత ప్రతి weightను అన్ని raw weights absolute values మొత్తంతో భాగించండి. దీంతో రెండు portfoliosకు ఒకే gross exposure ఉంటుంది.
8. నిజమైన parameters నుంచి ప్రతి assetకు 2520 రోజువారీ returnsతో ఒక కొత్త out-of-sample pathను రూపొందించండి. ఈ pathను ఏ allocation కూడా ముందుగా చూడలేదు.
9. log(1 + r) సగటుతో ఆ pathపై రెండు portfolios పనితీరును కొలవండి. ఇందులో r అనేది ఆ రోజున ఐదు asset returns యొక్క weighted sum.
10. ప్రతి T వద్ద 2000 స్వతంత్ర trials కోసం 4 నుంచి 9 దశలను పునరావృతం చేయండి. Equal weight, optimized weights కంటే మెరుగ్గా పనిచేసిన trials వాటా ఎంత అనేది నమోదు చేయండి.

Sweepను తక్కువ T నుంచి ఎక్కువ T వరకు చదవండి. తక్కువ T ఉన్న చివరలో equal weight చాలా ఎక్కువ trialsలో గెలుస్తుంది. T పెరిగేకొద్దీ ఈ వాటా స్థిరంగా తగ్గుతుంది. ఎక్కువ T ఉన్న చివరలో optimized weights ఎక్కువ trialsలో గెలుస్తాయి. మధ్యలో ఎక్కడో రెండు పద్ధతుల ఫలితాలు ఒకదానిని మరొకటి దాటుతాయి. ఈ crossover point seedతో, నిజమైన means మధ్య spreadతో మారుతుంది. కానీ దిశ మారదు: ఎక్కువ data optimizerకు అనుకూలంగా ఉంటుంది; తక్కువ data 1/Nకు అనుకూలంగా ఉంటుంది. మళ్లీ అమలు చేయడానికి random.seed(20260816)లోని integerను మార్చి sweepను తిరిగి run చేయండి.

చెడ్డ సగటు అంచనాను ఆప్టిమైజర్ ఎందుకు పెంచి చూపిస్తుంది

అంచనాలు బరువులో ఎక్కడ ప్రవేశిస్తాయో చూడండి. అంచనా సగటు లవంలో ఉంటుంది; అంచనా variance హారంలో ఉంటుంది. సగటు అంచనాను రెట్టింపు చేస్తే బరువు కూడా రెట్టింపు అవుతుంది. variance అంచనాలో నాలుగో వంతు తగ్గితే బరువు మూడో వంతు పెరుగుతుంది. అదృష్టవంతమైన నమూనాలో ఈ రెండు పొరపాట్లు ఒకే దిశలో పనిచేస్తాయి: మంచి ఫలితాల వరుస కొలిచిన సగటును పెంచుతుంది. అదే కాలంలో కొలిచిన varianceను తరచుగా తగ్గిస్తుంది. ఆప్టిమైజర్ ఆ assetను సమూహంలోని అత్యుత్తమదిగా భావించి, దానికి అనుగుణంగా పెద్ద బరువు కేటాయిస్తుంది. నమూనా వెలుపల అది మళ్లీ ఆ సమూహంలోని సాధారణ assetగానే ఉంటుంది. Equal weight మాత్రం ఆ అదృష్టవంతమైన నమూనాను చూడలేదు.

ఈ simulation ఈ సమస్యకు సున్నితమైన రూపం మాత్రమే. పరస్పరం సంబంధం లేని ఐదు assetలు ఉంటే covariance matrix diagonalగానే ఉంటుంది; దానిని invert చేయడంలో సమస్య ఉండదు. వాస్తవ portfoliosలో assetల మధ్య correlation ఉంటుంది. assetల సంఖ్య కంటే కొద్దిగా మాత్రమే ఎక్కువ observationsతో నిర్మించిన sample covariance matrix singular స్థితికి దగ్గరగా ఉంటుంది. దానిని invert చేయడం చిన్న input errorsను చాలా పెద్ద weightsగా మారుస్తుంది. అందుకే optimizer ఒకే nameలో పెట్టుబడి మూలధనానికి పలుమార్లు సమానమైన long positionను, దానికి దగ్గర substituteలో offsetting short positionను తీసుకునే స్థితికి చేరుతుంది. అలాంటి బరువు drawdownపై చూపే ప్రభావాన్ని మా పోర్ట్‌ఫోలియోలో concentration riskపై గమనిక వివరిస్తుంది.

Input కూడా స్థిరంగా ఉండదు. దిగువ panelలో విస్తృత index fundతో పాటు పెద్ద consumer staples nameకు rolling one year సగటు daily returnను చూపిస్తున్నాం. ఇవి annualized చేసి, నెలవారీగా sample చేయబడ్డాయి.

WITH prices AS
(
    SELECT
        ticker,
        date,
        toFloat64(max(close)) AS c
    FROM global_markets.stocks_daily_aggs
    WHERE ticker IN ('SPY', 'KO')
      AND date >= '2015-10-01'
      AND date <  '2025-01-01'
    GROUP BY ticker, date
),
rets AS
(
    SELECT
        ticker,
        date,
        c / lagInFrame(c, 1) OVER (PARTITION BY ticker ORDER BY date ASC ROWS BETWEEN 1 PRECEDING AND CURRENT ROW) - 1 AS ret
    FROM prices
),
trailing AS
(
    SELECT
        ticker,
        date,
        avg(ret) OVER (PARTITION BY ticker ORDER BY date ASC ROWS BETWEEN 251 PRECEDING AND CURRENT ROW) * 252 * 100 AS trailing_mean_pct,
        row_number() OVER (PARTITION BY ticker ORDER BY date ASC) AS i
    FROM rets
    WHERE isFinite(ret)
)
SELECT
    toString(toStartOfMonth(date))                     AS month,
    round(avgIf(trailing_mean_pct, ticker = 'SPY'), 1) AS spy_trailing_mean_pct,
    round(avgIf(trailing_mean_pct, ticker = 'KO'), 1)  AS ko_trailing_mean_pct
FROM trailing
WHERE i >= 252
  AND date >= '2017-01-01'
GROUP BY month
ORDER BY month ASC

ఆ రెండు రేఖలపై ఉన్న ప్రతి బిందువు, ఆ తేదీన ఏదో ఒక optimizer expected returnగా స్వీకరించి ఉండగల సంఖ్య. SPYకు మొదటి నెలవారీ reading 17.7%, చివరిది 25.8%; మధ్యలో 96 readings ఉన్నాయి. KO అదే కాలాన్ని -0.4%తో ప్రారంభిస్తుంది. ఈ seriesను నెలనెలా ఉపయోగించే weighting scheme, అందులోని ప్రతి హెచ్చుతగ్గును కూడా స్వీకరిస్తుంది.

సగం Kelly, shrinkage సమస్యను పరిష్కరిస్తాయా?

అవి సమస్య తీవ్రతను తగ్గిస్తాయి. ఆచరణలో నాలుగు పరిష్కారాలు కనిపిస్తాయి. ప్రతి పరిష్కారం అంచనాపై సున్నితత్వాన్ని తగ్గించడానికి, సిద్ధాంతపరమైన ఉత్తమ ఫలితంలో కొంత భాగాన్ని వదులుకుంటుంది.

• Half Kelly ప్రతి weightను సగానికి తగ్గిస్తుంది. Kelly వృద్ధి వక్రరేఖ గరిష్ఠ స్థానం సమీపంలో సమతలంగా, దాని కింద మాత్రం మరింత వాలుగా ఉంటుంది. అందువల్ల సగం stake తీసుకోవడం సిద్ధాంతపరమైన వృద్ధి రేటులో కొంత మాత్రమే తగ్గిస్తుంది. కానీ ఎక్కువగా అంచనా వేసిన edge వల్ల కలిగే నష్టాన్ని మరింతగా పరిమితం చేస్తుంది. అస్థిరతను లక్ష్యంగా నిర్ణయించడం denominator విషయంలోనూ ఇదే విధానాన్ని అనుసరిస్తుంది. తక్కువ కాలం నాటి sample అందించగల ఒకే input ఆధారంగా position sizeను నిర్ణయిస్తుంది.
• Shrinkage ప్రతి estimated meanను అంచనాల cross-sectional average వైపు లాగుతుంది. sample పరిమాణం తగ్గినకొద్దీ ఈ సర్దుబాటు పరిమాణం పెరుగుతుంది. దీన్ని పరాకాష్ఠకు తీసుకెళ్తే ప్రతి assetకు ఒకే expected return ఉంటుంది. Volatilities సమానంగా ఉంటే optimizer స్వయంగా ప్రతి assetకు equal weight కేటాయిస్తుంది. పూర్తిగా shrunk portfolio అంటే equal-weight portfolio.
• Constraints అంటే short sellingకు అనుమతి లేకపోవడం, ప్రతి positionకు గరిష్ఠ పరిమితి విధించడం. ఇవి ఒక అదృష్టవంతమైన estimate ఒకే weightను ఎంత దూరం పెంచగలదో పరిమితం చేస్తాయి. ఇవి estimateను మెరుగుపరచడం కాదు; నష్టం నియంత్రణ మాత్రమే.
• Expected returnsను పూర్తిగా తొలగిస్తే minimum variance, risk parity మిగులుతాయి. ఇవి covarianceను మాత్రమే ఉపయోగిస్తాయి. sample వాస్తవంగా అందించగల input అదే.

ఈ నాలుగు విధానాల్లో ఏదీ sampleలో లేని సమాచారాన్ని సృష్టించదు. అవి మార్చేది ఒక్కటే: మీ వద్ద ఉండకపోవచ్చని సమాచారంపై portfolioలో ఎంత భాగం ఆధారపడాలి అనేది.

ఆప్టిమైజేషన్ తన ఖర్చును సమర్థించుకునే సందర్భం

ఈ మలుపు రెండు దిశల్లోనూ కనిపిస్తుంది. నిజమైన సగటుల మధ్య spreadతో పోలిస్తే T పెద్దదిగా మారినప్పుడు, ఆప్టిమైజ్ చేసిన కేటాయింపు మెరుగైన ఫలితాన్ని ఇస్తుంది మరియు ఆ ఆధిక్యాన్ని కొనసాగిస్తుంది. ఆ spread ఎంత విస్తృతంగా ఉంటే, ఈ మార్పు అంత త్వరగా జరుగుతుంది. డేటా అందించే input ఉన్నప్పుడు కూడా ఆప్టిమైజేషన్ సరైన సాధనం. ఉదాహరణకు, expected returns కంటే covariance, hedge ratiosను మరింత ఖచ్చితంగా అంచనా వేయవచ్చు.

Equal weightకు కూడా తనదైన ఖర్చు ఉంటుంది. మీ వద్ద నిజంగా ఉన్న సమాచారాన్ని అది పట్టించుకోదు. చిన్న investment universeలో ఏ optimizer అయినా చేసేంతగా ఇది కేంద్రీకరణకు దారితీయవచ్చు. కాబట్టి weightsకు ఎప్పుడూ కనిపించని డేటాపై ప్రతి ప్రత్యామ్నాయ weighting తప్పనిసరిగా అధిగమించాల్సిన baselineగా దీన్ని పరిగణించండి. ఒకే sampleపై weightsను రూపొందించి, వాటినే అదే sampleపై అంచనా వేయడం backtestingలో look-ahead biasకు మరో రూపం. ఇది ప్రతిసారీ optimizer పనితీరును అతిగా చూపిస్తుంది. కొలిచిన ఆధిక్యానికి ఒకే point estimate బదులుగా నిజాయితీగల పరిధిని పొందాలంటే, bootstrapped confidence intervals ప్రామాణిక సాధనం.

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

సమాన-బరువు విధానం నిజంగా mean variance optimization కంటే మెరుగ్గా పనిచేస్తుందా?

సంక్షిప్త నమూనాల్లో ఇది తరచుగా జరుగుతుంది. Optimizerకు ప్రతి ఆస్తి ఆశించిన రాబడిని అంచనా వేయాలి. ఆ అంచనాలోని standard error, సాధారణంగా, ఆస్తి volatilityని నమూనా సంవత్సరాల పొడవు యొక్క వర్గమూలంతో భాగించినంత ఉంటుంది. ఆ లోపం ఆస్తుల మధ్య ఉన్న నిజమైన తేడాల కంటే ఎక్కువగా ఉన్నంతకాలం, optimizer శబ్దాన్నే క్రమబద్ధీకరిస్తుంది. సమాన-బరువు విధానంలో తప్పు అయ్యే అంచనా ఏదీ ఉండదు.

ఆశించిన రాబడిని అంచనా వేయడానికి ఎన్ని పరిశీలనలు అవసరం?

దాదాపు ఎవరైనా సమకూర్చగలిగే దానికంటే ఎక్కువ. 20 శాతం volatility ఉన్న ఆస్తికి, ఒక సంవత్సరం రోజువారీ డేటా annualized standard errorను సుమారు 20 శాతం పాయింట్ల వద్ద ఉంచుతుంది. ఆ లోపాన్ని సగానికి తగ్గించాలంటే calendar spanను నాలుగు రెట్లు పెంచాలి. అదే సంవత్సరంలో intraday observationsను జోడించడం వల్ల ప్రయోజనం ఉండదు. దీనికి విరుద్ధంగా, volatilityను కొన్ని నెలల డేటాతోనే ఉపయోగకరంగా అంచనా వేయవచ్చు.

half Kelly అంటే కేవలం చిన్న పందెమా?

ఇది అనుకూలమైన షరతులపై వేసే చిన్న పందెం. Kelly growth curve గరిష్ఠ స్థాయి సమీపంలో సమతలంగా ఉంటుంది. అందువల్ల stakeను సగానికి తగ్గిస్తే theoretical growth rateలో కొద్దిపాటి భాగమే కోల్పోతారు. అదే సమయంలో మార్గంలోని volatility సుమారుగా సగానికి తగ్గుతుంది. అతిగా అంచనా వేసిన edge వల్ల కలిగే నష్టపు ఖర్చు కూడా తగ్గుతుంది.

1/N పోర్ట్‌ఫోలియో అంటే ఏమిటి?

ఇది N positionsలో ప్రతిదానిలో మూలధనంలో సమాన భాగాన్ని పెట్టి, నిర్ణీత షెడ్యూల్ ప్రకారం rebalancing చేసే పోర్ట్‌ఫోలియో. దీనికి return forecast లేదా covariance estimate అవసరం లేదు. ఈ కారణంగానే అవి అవసరమయ్యే ప్రతి weighting schemeకు ఇది standard benchmarkగా ఉంటుంది.

ఇక్కడి ప్రతి ప్యానెల్ చార్ట్ కింద ఖచ్చితమైన SQLను కలిగి ఉంటుంది. Simulationలో దాని seed కూడా ఉంటుంది. మీ స్వంత పేర్ల జాబితాపై ఇదే estimate stability checkను అమలు చేయాలంటే, Strasmore terminalలో సాధారణ ఆంగ్లంలో అడగండి.