एक, स्वचालित कारक खनन की आवश्यकता क्यों है

यदि आपने मात्रात्मक ट्रेडिंग में हाथ डाला है, तो आपने निश्चित रूप से "कारक" शब्द सुना होगा। कारक क्या है? सीधे शब्दों में कहें तो, यह डेटा के माध्यम से व्यक्त किया गया एक बाजार संकेत है। जैसे कि मूल्य गति, असामान्य वॉल्यूम, बोलिंजर बैंड की स्थिति - इसका उपयोग यह अनुमान लगाने के लिए किया जाता है कि अगली अवधि में कोई सिक्का बढ़ेगा या गिरेगा।

सुनने में आसान लगता है, लेकिन जो लोग वास्तव में कारक अनुसंधान करते हैं, वे जानते हैं कि यह कितना कठिन है:

ठोस वित्तीय ज्ञान और गहरी गणितीय सांख्यिकी पृष्ठभूमि
बड़ी मात्रा में स्वच्छ ऐतिहासिक डेटा
सख्त बैकटेस्टिंग फ्रेमवर्क

और एक ऐसी समस्या का भी सामना करना पड़ता है जिससे कभी बचा नहीं जा सकता: कारक क्षय (Factor Decay)

आज प्रभावी संकेत कुछ दिनों में पूरी तरह से बेकार हो सकता है - क्योंकि बाजार के सहभागी सीखते हैं, अनुकूलित होते हैं, और इस नियम का लाभ उठाकर इसे भुनाते हैं। इसलिए कारक खनन कभी एक बार का काम नहीं होता, इसे निरंतर पुनरावृत्ति (iteration) की आवश्यकता होती है।

यह लेख ठीक उसी प्रणाली का परिचय देता है जो इस कार्य को स्वचालित करती है: निश्चित अंतराल पर चक्रीय रूप से पूर्ण कारक खनन → सत्यापन → उन्मूलन → संकेत संश्लेषण → ऑर्डर ट्रेडिंग। मशीन पुनरावृत्ति के साथ मानवीय दोहराव को बदलें, ताकि रणनीति हमेशा बाजार की बदलती गति के साथ तालमेल बनाए रखे।

दो, सिस्टम का समग्र आर्किटेक्चर

पारंपरिक कारक खनन प्रक्रिया है: शोधकर्ता एक परिकल्पना प्रस्तुत करता है → कोड लिखता है → बैकटेस्ट करता है → फ़िल्टर करता है → लाइव पर जाता है → कुछ महीनों बाद विफलता पाता है → फिर से शुरू करता है। पूरा चक्र कई सप्ताह या महीने भी लग सकता है।

यह प्रणाली पूरे चक्र को निश्चित अंतराल पर स्वचालित रूप से एक बार निष्पादित करने के लिए संपीड़ित करती है:

सिस्टम दो शेड्यूलर द्वारा संचालित होता है: धीमा ट्रिगर घंटे के स्तर पर एक पूर्ण कारक पुनरावृत्ति प्रक्रिया निष्पादित करता है; तेज़ ट्रिगर सेकंड के स्तर पर पोजीशन की स्थिति की जाँच करता है, स्टॉप-लॉस और टेक-प्रॉफिट को संभालता है, और डैशबोर्ड को रीफ्रेश करता है।

तीन, प्रत्येक मॉड्यूल का विस्तृत विवरण और मुख्य कोड

3.1 ट्रेडिंग पूल प्राप्त करें

प्रत्येक दौर की शुरुआत में, सिस्टम एक्सचेंज से सभी परपेचुअल कॉन्ट्रैक्ट की रीयल-टाइम कीमतें खींचता है, कारोबार राशि के अनुसार शीर्ष N का चयन करता है। तरलता कारक प्रभावशीलता का आधार है - छोटे सिक्कों में कम वॉल्यूम होता है, कोई भी संकेत आसानी से विकृत हो सकता है।

साथ ही, BTC चार घंटे की लाइन की अस्थिरता के ऐतिहासिक प्रतिशतक (percentile) का पता लगाएं, बाजार की समग्र स्थिति (normal / high_vol / low_vol / volatile) निर्धारित करें। यह निर्णय सीधे AI द्वारा उत्पन्न कारकों की दिशा की प्राथमिकता को प्रभावित करेगा।

            javascript
            
            
// कारोबार राशि के अनुसार उच्च तरलता वाले उपकरण फ़िल्टर करें
const topN = $vars.topN || 150;
const tickers = exchange.GetTickers();

const filtered = tickers
  .filter(t => t.Symbol.endsWith('USDT.swap'))
  .map(t => ({ symbol: t.Symbol, quoteVolume: t.Last * t.Volume }))
  .sort((a, b) => b.quoteVolume - a.quoteVolume)
  .slice(0, topN)
  .map(t => t.symbol);

_G('afi_symbolPool', JSON.stringify(filtered));

// BTC अस्थिरता प्रतिशतक का पता लगाएं, बाजार की स्थिति निर्धारित करें
const btcR = exchange.GetRecords('BTC_USDT.swap', PERIOD_H4);
const n = btcR.length;
const returns20 = [];
for (let i = n - 20; i < n; i++)
  returns20.push(Math.abs((btcR[i].Close - btcR[i-1].Close) / btcR[i-1].Close));
const avgVol = returns20.reduce((a, b) => a + b, 0) / returns20.length;

// पूरे इतिहास की अस्थिरता से तुलना करें, प्रतिशतक निर्धारित करें
const allVols = [];
for (let i = 1; i < n; i++)
  allVols.push(Math.abs((btcR[i].Close - btcR[i-1].Close) / btcR[i-1].Close));
allVols.sort((a, b) => a - b);
let btcVolPercentile = allVols.findIndex(v => v >= avgVol) / allVols.length;

let marketState = 'normal';
if (btcVolPercentile > 0.8)      marketState = 'high_vol';
else if (btcVolPercentile < 0.3) marketState = 'low_vol';

_G('afi_marketState', marketState);
_G('afi_btcVolPct', btcVolPercentile.toFixed(2));

3.2 कारक पूल की स्थिति जाँचें

AI को नए कारक उत्पन्न करने देने से पहले, सिस्टम पहले वर्तमान कारक पूल की स्वास्थ्य स्थिति का सर्वेक्षण करता है: किन कारकों का हाल ही में IC लगातार घट रहा है (क्षय), किन आयामों को अभी तक कवर नहीं किया गया है। यह जानकारी सीधे AI को बाधाओं के रूप में दी जाती है, ताकि पहले से विफल दिशाओं की फिर से खोज से बचा जा सके।

            javascript
            
            
const factorPool = JSON.parse(_G('afi_factorPool') || '[]');
const icHistory  = JSON.parse(_G('afi_icHistory')  || '{}');
const icDecayWindow    = $vars.icDecayWindow    || 48;    // हाल ही की विंडो लंबाई
const icDecayThreshold = $vars.icDecayThreshold || -0.01; // क्षय निर्धारण सीमा
const targetFactorCount = $vars.targetFactorCount || 10;

const degradedFactors = [];
for (const factor of factorPool) {
  const icArr = icHistory[factor.name] || [];
  if (icArr.length >= 20) {
    const window    = Math.min(icArr.length, icDecayWindow);
    const recentAvg = icArr.slice(-window).reduce((a, b) => a + b, 0) / window;
    if (recentAvg < icDecayThreshold)
      degradedFactors.push({
        name: factor.name,
        recentIC: recentAvg.toFixed(4),
        rationale: factor.rationale
      });
  }
}

// इस दौर में खोजे जाने वाले नए कारकों की संख्या गतिशील रूप से निर्धारित करें
const explorationBuffer = $vars.explorationBuffer || 3;
const explorationCount  = Math.max(
  explorationBuffer,
  targetFactorCount - validCount + explorationBuffer
);

const action = factorPool.length === 0 ? 'generate_initial' : 'iterate_factors';

3.3 प्रॉम्प्ट बनाएँ, AI को कारक आविष्कार करने दें

AI को एक खुला कार्य नहीं मिलता, बल्कि एक बाधा-युक्त ढांचा मिलता है। प्रॉम्प्ट में शामिल होता है: वर्तमान बाजार की स्थिति, मौजूदा कारकों की सूची (पुनरावृत्ति से बचने के लिए), हाल ही में क्षय हुए कारक (माइक्रो-ट्यूनिंग से बचने के लिए), कवर किए गए आयाम, और अभी तक खोजे नहीं गए आयाम।

इस तरह से उत्पन्न उम्मीदवार कारक वास्तव में एक नई दिशा की ओर एक प्रयास होते हैं, न कि मौजूदा कारकों को अलग-अलग पैरामीटर के साथ फिर से चलाना।

            javascript
            
            
// पुनरावृत्ति पैटर्न प्रॉम्प्ट का मुख्य भाग
const usedDimensions = factorPool
  .map(f => f.name + '(' + (f.rationale || '') + ')')
  .join(', ') || 'अभी तक नहीं';

const validSummary = validFactors.map(f => {
  const arr    = icHistory[f.name] || [];
  const avg    = arr.length > 0
    ? (arr.reduce((a,b) => a+b, 0) / arr.length).toFixed(4) : 'N/A';
  const recent = arr.length >= 20
    ? (arr.slice(-20).reduce((a,b) => a+b, 0) / 20).toFixed(4) : 'N/A';
  return f.name + ': ऐतिहासिक IC=' + avg + ' हाल का IC=' + recent + ' | तर्क: ' + f.rationale;
}).join('\n') || 'अभी तक नहीं';

const degradedSummary = degradedFactors.length > 0
  ? degradedFactors.map(f =>
      f.name + ': हाल का IC=' + f.recentIC + ' | मूल तर्क: ' + f.rationale
    ).join('\n')
  : 'इस दौर में कोई क्षय कारक नहीं';

prompt += '【वर्तमान सक्रिय कारक (वेरिएंट उत्पन्न करने की आवश्यकता नहीं)】\n' + validSummary + '\n\n';
prompt += '【हाल के क्षय कारक (इन आयामों पर सूक्ष्म-समायोजन वर्जित)】\n' + degradedSummary + '\n\n';
prompt += '【कवर किए गए आयाम (पुनरावृत्ति वर्जित)】\n' + usedDimensions + '\n\n';
prompt += '【अभी तक खोजे न गए आयाम (यहां से प्राथमिकता से चुनें)】\n' + unusedSample + '\n\n';
prompt += 'उत्पन्न करें ' + explorationCount + ' पूरी तरह से नए दिशा कारक:\n';
prompt += '1. कवर किए गए आयामों से पूरी तरह भिन्न होना चाहिए, विफल कारकों का सूक्ष्म-समायोजन वर्जित\n';
prompt += '2. पहले अभी तक खोजे न गए आयामों से चुनें\n';
prompt += '3. पहले अरेखीय संयोजन कारक डिज़ाइन करें\n';
prompt += '4. वर्तमान ' + marketState + ' बाजार स्थिति के अनुसार डिज़ाइन करें\n';

AI के सिस्टम प्रॉम्प्ट में आविष्कारक प्लेटफ़ॉर्म का पूर्ण TA फ़ंक्शन स्पेसिफिकेशन, कोड फ़ॉर्मेट बाध्यताएं, एन्क्रिप्टेड बाज़ार पूर्व ज्ञान, और सभी खोजे जा सकने वाले कारक आयामों की सूची अंतर्निहित है (पूर्ण सामग्री रणनीति स्रोत कोड में उपलब्ध)। आउटपुट प्रारूप सख्ती से शुद्ध JSON (बिना Markdown आवरण) होना चाहिए:

            json
            
            
{
  "factors": [
    {
      "name": "MomentumAcceleration",
      "rationale": "अल्पकालिक संवेग त्वरण, खुदरा निवेशकों के ट्रेंड का अनुसरण करने की जड़ता के मोड़ को पकड़ना",
      "code": "(records[n-1].Close - records[n-6].Close)/records[n-6].Close - (records[n-2].Close - records[n-7].Close)/(records[n-7].Close + 0.0001)",
      "direction": 1,
      "type": "exploration"
    }
  ]
}

3.4 IC सत्यापन: डेटा बोलता है, अंतर्ज्ञान पर निर्भर न रहें

IC (सूचना गुणांक) मापता है: कारक द्वारा गणना किए गए क्रॉस-सेक्शनल रैंकिंग और अगले K-लाइन के वास्तविक लाभ/हानि प्रतिशत रैंकिंग के बीच सहसंबंध कितना अधिक है। IC जितना अधिक होगा, कारक का पूर्वानुमान उतना ही सटीक होगा।

सत्यापन विधि Walk-Forward (ऐतिहासिक प्लेबैक) है: पिछली कुछ सौ K-लाइनें लें, प्रत्येक समय बिंदु t पर, t-1 के डेटा का उपयोग करके कारक मान की गणना करें, और t-वें K-लाइन के उतार-चढ़ाव की भविष्यवाणी करें। समय क्रम सख्ती से संरेखित, भविष्य के फ़ंक्शन से रहित।

            javascript
            
            
function calcRankICFull(code, symRecords, factorName) {
  const syms    = Object.keys(symRecords);
  const icList  = [];
  const minLen  = 30;
  const allLengths = syms.map(s => symRecords[s].length);
  const minSymLen  = Math.min(...allLengths);
  const testLen    = Math.min(500, minSymLen - 1);

  for (let t = minLen; t < testLen; t++) {
    const fVals = [], nRets = [];

    for (const sym of syms) {
      const fullRecords = symRecords[sym];
      // t-1 अवधि डेटा का उपयोग करके कारक की गणना करें (slice(0, t) में t-वीं K-लाइन शामिल नहीं)
      const records = fullRecords.slice(0, t);
      const n = records.length;

      const v = (function() { return eval(code); })();
      if (isNaN(v) || !isFinite(v)) continue;

      fVals.push({ sym, val: v });
      // t-वीं K-लाइन के वास्तविक रिटर्न की भविष्यवाणी करें
      nRets.push({
        sym,
        ret: (fullRecords[t].Close - fullRecords[t-1].Close) / fullRecords[t-1].Close
      });
    }
    if (fVals.length < 8) continue;

    // रैंक IC (स्पीयरमैन सहसंबंध गुणांक) की गणना करें
    const fRank = {}, rRank = {};
    [...fVals].sort((a,b) => a.val - b.val).forEach((x,i) => fRank[x.sym] = i);
    [...nRets].sort((a,b) => a.ret - b.ret).forEach((x,i) => rRank[x.sym] = i);

    const ss = fVals.map(x => x.sym);
    const fr = ss.map(s => fRank[s]);
    const rr = ss.map(s => rRank[s]);
    const n2 = ss.length;
    const fm = fr.reduce((a,b) => a+b, 0) / n2;
    const rm = rr.reduce((a,b) => a+b, 0) / n2;
    const num = fr.map((f,i) => (f-fm) * (rr[i]-rm)).reduce((a,b) => a+b, 0);
    const den = Math.sqrt(
      fr.map(f => (f-fm)**2).reduce((a,b) => a+b, 0) *
      rr.map(r => (r-rm)**2).reduce((a,b) => a+b, 0)
    );
    if (den > 0) icList.push(num / den);
  }

  const avgIC = icList.length > 0
    ? icList.reduce((a,b) => a+b, 0) / icList.length : 0;
  return { avgIC, icList };
}

IC सीमा चर $vars.icThreshold द्वारा नियंत्रित होती है, डिफ़ॉल्ट 0.02 है। यह एक अपेक्षाकृत उदार प्रवेश सीमा है, जो स्पष्ट रूप से अप्रभावी कारकों को जल्दी से हटाने के लिए उपयुक्त है; यदि अधिक कठोर सांख्यिकीय महत्व नियंत्रण की आवश्यकता है, तो वास्तविक स्थिति के अनुसार इस मान को बढ़ाया जा सकता है। जो कारक सीमा पार नहीं करते, चाहे उनका तर्क कितना भी सही क्यों न हो, सीधे हटा दिए जाते हैं।

3.5 सहसंबंध फ़िल्टरिंग और निचले स्तर का उन्मूलन

IC सत्यापन पार करने वाले कारकों को दो और चरणों से गुज़रना होगा:

पहला चरण: सहसंबंध फ़िल्टरिंग। यदि दो कारकों के क्रॉस-सेक्शनल स्कोर अत्यधिक समान हैं (|corr| > सीमा), तो उच्च IC वाले कारक को रखें और दूसरे को हटा दें। यह ऐसा है जैसे दो वोट एक ही व्यक्ति के विचार का प्रतिनिधित्व करते हैं, उन्हें एक वोट में मिला दें, एक अतिरिक्त वोट कोई अतिरिक्त दृष्टिकोण नहीं जोड़ता है।

दूसरा चरण: निचले स्तर का उन्मूलन। कारक पूल की क्षमता की एक ऊपरी सीमा होती है, सीमा से अधिक होने पर प्रदर्शन के अनुसार क्रमबद्ध किया जाता है, सबसे खराब कारक बाहर हो जाता है। जिन कारकों का हाल का IC लगातार गिर रहा है, वे ऐतिहासिक औसत IC के बजाय हाल के IC के साथ रैंकिंग में भाग लेते हैं, जिससे उन पर अधिक उन्मूलन का दबाव होता है।

            javascript
            
            
// सहसंबंध फ़िल्टरिंग (सबसे अधिक IC वाले को रखें, अत्यधिक सहसंबंधित अनावश्यक कारकों को हटाएं)
const corrThreshold = $vars.corrThreshold || 0.7;
survivedFactors.sort((a, b) => b.icAvg - a.icAvg); // पहले IC के अवरोही क्रम में व्यवस्थित करें

const decorrelatedFactors = [];
for (const factor of survivedFactors) {
  let isRedundant = false;
  for (const selected of decorrelatedFactors) {
    const corr = Math.abs(calcCorrelation(
      factorScoresMap[factor.name],
      factorScoresMap[selected.name]
    ));
    if (corr > corrThreshold) {
      // अवशोषित सहसंबंधित कारक को रिकॉर्ड करें (डैशबोर्ड प्रदर्शन के लिए)
      selected.corrGroup = (selected.corrGroup ? selected.corrGroup + ',' : '')
                           + factor.name;
      isRedundant = true;
      break;
    }
  }
  if (!isRedundant) decorrelatedFactors.push({ ...factor, corrGroup: '' });
}

// अंतिम स्थान का उन्मूलन: क्षयकारी कारक ऐतिहासिक औसत के बजाय हालिया IC का उपयोग करके रैंकिंग में भाग लेते हैं
const targetFactorCount = $vars.targetFactorCount || 10;
decorrelatedFactors.sort((a, b) => {
  const scoreA = a.isDecaying ? a.recentIC : a.icAvg;
  const scoreB = b.isDecaying ? b.recentIC : b.icAvg;
  return scoreB - scoreA;
});
const finalPool = decorrelatedFactors.slice(0, targetFactorCount);

_G('afi_factorPool', JSON.stringify(finalPool));

नोट: सहसंबंध गणना वर्तमान क्रॉस-सेक्शन के कारक स्कोर पर आधारित है, और कुछ क्षणों में सामयिक गलत निर्णय हो सकते हैं। अधिक मजबूत दृष्टिकोण कई ऐतिहासिक क्रॉस-सेक्शन के औसत सहसंबंध का उपयोग करना है, जो भविष्य में सुधार की दिशा हो सकती है।

3.6 सिग्नल संश्लेषण और पोर्टफोलियो पुनर्संतुलन निष्पादन

कारक पूल स्थिर होने के बाद, सिस्टम प्रत्येक लक्ष्य के लिए एक समग्र स्कोर की गणना करता है: प्रत्येक कारक के क्रॉस-सेक्शन मान को Z-स्कोर मानकीकृत किया जाता है, फिर प्रत्येक के हालिया IC के अनुसार भारित करके जोड़ा जाता है - बेहतर प्रदर्शन करने वाले कारकों का हिस्सा अधिक होता है, और नकारात्मक हालिया IC वाले कारकों का भार शून्य कर दिया जाता है।

            javascript
            
            
// कारक भार: हालिया IC भार (नकारात्मक IC कारकों का भार शून्य)
const weights = {};
let totalW = 0;
for (const f of factorPool) {
  const arr       = icHistory[f.name] || [];
  const recentArr = arr.slice(-48);
  const recentIC  = recentArr.length > 0
    ? recentArr.reduce((a,b) => a+b, 0) / recentArr.length : 0;
  const w = Math.max(0, recentIC); // नकारात्मक IC → भार 0
  weights[f.name] = w;
  totalW += w;
}
if (totalW > 0)
  Object.keys(weights).forEach(k => weights[k] /= totalW);
else
  factorPool.forEach(f => weights[f.name] = 1 / factorPool.length);

// Z-स्कोर मानकीकरण
function zscore(fname) {
  const vals = validSyms
    .map(s => ({ sym: s, val: rawMatrix[s][fname] }))
    .filter(x => x.val !== null);
  if (vals.length < 5) return {};
  const mean = vals.reduce((a,b) => a + b.val, 0) / vals.length;
  const std  = Math.sqrt(vals.reduce((a,b) => a + (b.val - mean)**2, 0) / vals.length);
  const r = {};
  vals.forEach(x => r[x.sym] = std > 0 ? (x.val - mean) / std : 0);
  return r;
}

// समग्र स्कोर
const scores = {};
for (const sym of validSyms) {
  let score = 0;
  for (const f of factorPool) {
    const z = zscore(f.name)[sym];
    if (z !== undefined) score += weights[f.name] * f.direction * z;
  }
  scores[sym] = score;
}

// सीमा फ़िल्टरिंग: अस्पष्ट सिग्नल वाले सीधे छोड़ दिए जाते हैं, प्रवेश नहीं करते
const longShortN      = $vars.longShortN      || 5;
const longThreshold   = $vars.longThreshold   || 0.3;
const shortThreshold  = $vars.shortThreshold  || -0.3;

const sorted        = Object.keys(scores).sort((a,b) => scores[b] - scores[a]);
const longList      = sorted.filter(s => scores[s] >= longThreshold).slice(0, longShortN);
const shortList     = sorted.slice().reverse()
                            .filter(s => scores[s] <= shortThreshold).slice(0, longShortN);

पोर्टफोलियो पुनर्संतुलन निष्पादित करते समय, पहले उन पुरानी पोजीशनों को बंद करें जो वर्तमान राउंड की सूची में नहीं हैं, फिर खाते की इक्विटी के अनुपात में नए सिग्नल में प्रवेश करें:

            javascript
            
            
const positionRatio = $vars.positionRatio || 0.8;  // कुल इक्विटी उपयोग अनुपात
const maxLeverage   = $vars.maxLeverage   || 3;
const account       = exchange.GetAccount();
const equity        = account.Equity || account.Balance;
const perAmt        = (equity * positionRatio) / (longList.length + shortList.length);

// लक्ष्य सेट में न होने वाली पुरानी पोजीशन को बंद करें
const targetSet = new Set([...longList, ...shortList]);
for (const sym of Object.keys(currentHoldings)) {
  if (!targetSet.has(sym)) {
    const pos    = currentHoldings[sym];
    const isLong = pos.Type === PD_LONG || pos.Type === 0;
    exchange.CreateOrder(sym, isLong ? 'closebuy' : 'closesell', -1, Math.abs(pos.Amount));
    // ट्रेलिंग स्टॉप स्थिति साफ़ करें
    const cm = sym.match(/^(.+)_USDT/);
    if (cm) { _G(cm[1] + '_maxpnl', null); _G(cm[1] + '_trail', null); }
  }
}

// नए सिग्नल पोजीशन खोलें (मार्केट ऑर्डर, -1 मार्केट प्राइस दर्शाता है)
function openPos(sym, isLong) {
  exchange.SetMarginLevel(sym, maxLeverage);
  const market = allMarkets[sym];
  const price  = exchange.GetTicker(sym).Last;
  const ctVal  = (market.CtVal && market.CtVal > 0) ? market.CtVal : 1;
  const amtPrec = market.AmountPrecision !== undefined ? market.AmountPrecision : 0;
  const minQty  = (market.MinQty && market.MinQty > 0) ? market.MinQty : 1;
  const maxQty  = (market.MaxQty && market.MaxQty > 0) ? market.MaxQty : 999999;
  let qty = _N(perAmt / price / ctVal, amtPrec);
  qty = Math.min(Math.max(qty, minQty), maxQty);
  exchange.CreateOrder(sym, isLong ? 'buy' : 'sell', -1, qty);
}

3.7 पोजीशन मॉनिटरिंग: स्टॉप-लॉस / टेक-प्रॉफिट / डायनामिक ट्रेलिंग स्टॉप

फास्ट ट्रिगर प्रति सेकंड एक बार चलता है, सभी पोजीशन के फ्लोटिंग PnL की वास्तविक समय में निगरानी करता है, और तीन एग्जिट लॉजिक लागू करता है:

• फिक्स्ड स्टॉप-लॉस: फ्लोटिंग घाटा STOP_LOSS_PCT (डिफ़ॉल्ट 5%) से अधिक होने पर स्वतः बंद करें
• फिक्स्ड टेक-प्रॉफिट: फ्लोटिंग लाभ TAKE_PROFIT_PCT (डिफ़ॉल्ट 10%) से अधिक होने पर स्वतः बंद करें
• डायनामिक ट्रेलिंग स्टॉप: फ्लोटिंग लाभ TRAIL_TRIGGER (3%) तक पहुँचने पर सक्रिय होता है, अधिकतम लाभ के अनुसार ड्रॉडाउन सीमा गतिशील रूप से समायोजित होती है

            javascript
            
            
const STOP_LOSS_PCT   = $vars.stopLossPct   || 5;
const TAKE_PROFIT_PCT = $vars.takeProfitPct || 10;
const TRAIL_TRIGGER   = 3; // फ्लोटिंग लाभ 3% होने पर ट्रेलिंग स्टॉप सक्रिय

// डायनामिक ड्रॉडाउन सीमा: अधिकतम लाभ जितना अधिक, अनुमत ड्रॉडाउन स्थान उतना ही बड़ा
function getDynamicTrailDrawdown(maxPnl) {
  if (maxPnl >= 7) return 3;   // अधिकतम लाभ ≥7%, अनुमत ड्रॉडाउन 3%
  if (maxPnl >= 4) return 2;   // अधिकतम लाभ ≥4%, अनुमत ड्रॉडाउन 2%
  return 1.5;                   // अन्य मामलों में, ड्रॉडाउन 1.5%
}

function monitorTPSL(positions, tickers) {
  for (const pos of (positions || [])) {
    if (Math.abs(pos.Amount) === 0) continue;
    const cm = pos.Symbol.match(/^(.+)_USDT/); if (!cm) continue;
    const coin   = cm[1];
    const ticker = tickers[coin + '_USDT.swap']; if (!ticker) continue;

    const isLong = pos.Type === PD_LONG || pos.Type === 0;
    const cur    = ticker.Last;
    const ent    = pos.Price;
    const amt    = Math.abs(pos.Amount);
    const pnlPct = (cur - ent) * (isLong ? 1 : -1) / ent * 100;

    // अधिकतम फ्लोटिंग लाभ को ट्रैक करें
    let maxPnl = _G(coin + '_maxpnl');
    if (maxPnl === null) { maxPnl = pnlPct; _G(coin + '_maxpnl', maxPnl); }
    else if (pnlPct > maxPnl) { maxPnl = pnlPct; _G(coin + '_maxpnl', maxPnl); }

    // ट्रेलिंग स्टॉप सक्रिय करें
    if (!_G(coin + '_trail') && maxPnl >= TRAIL_TRIGGER) {
      _G(coin + '_trail', true);
      Log(coin + ' ट्रेलिंग स्टॉप सक्रिय, फ्लोटिंग लाभ: +' + pnlPct.toFixed(2) + '%');
    }

    const trailDrawdown = getDynamicTrailDrawdown(maxPnl);
    let reason = null;
    if (_G(coin + '_trail') && (maxPnl - pnlPct) >= trailDrawdown)
      reason = 'ट्रेलिंग स्टॉप (ड्रॉडाउन ' + (maxPnl - pnlPct).toFixed(2) + '%, सीमा ' + trailDrawdown + '%)';
    if (!reason && pnlPct <= -STOP_LOSS_PCT)  reason = 'स्टॉप-लॉस (' + pnlPct.toFixed(2) + '%)';
    if (!reason && pnlPct >= TAKE_PROFIT_PCT) reason = 'टेक-प्रॉफिट (' + pnlPct.toFixed(2) + '%)';

    if (reason) {
      exchange.CreateOrder(pos.Symbol, isLong ? 'closebuy' : 'closesell', -1, amt);
      Log(coin, 'ट्रिगर', reason);
      _G(coin + '_maxpnl', null); _G(coin + '_trail', null);
    }
  }
}

चार, मुख्य डिज़ाइन निर्णय

4.1 Rank IC (Pearson IC के बजाय) का उपयोग क्यों करें?

Rank IC सहसंबंध की गणना के लिए कच्चे मानों के बजाय रैंकों का उपयोग करता है, जो फैक्टर में चरम मानों (आउटलायर्स) के प्रति स्वाभाविक रूप से मजबूत होता है। क्रिप्टोकरेंसी बाजारों में मूल्य वितरण भारी पूंछ वाला होता है, और Pearson IC कुछ चरम K-लाइनों द्वारा आसानी से विकृत हो सकता है, जबकि Rank IC अधिक स्थिर होता है।

4.2 समय श्रृंखला का सख्त संरेखण, फ्यूचर फंक्शन का उन्मूलन

IC सत्यापन और ऑनलाइन सिग्नल गणना दोनों में t-1 अवधि के फैक्टर मानों का उपयोग t अवधि के रिटर्न की भविष्यवाणी करने के लिए किया जाता है: सत्यापन के दौरान, records को fullRecords.slice(0, t) के रूप में पास किया जाता है, भविष्य के डेटा को भौतिक रूप से काट दिया जाता है; AI द्वारा उत्पन्न फैक्टर कोड, चाहे वह records[n] को कैसे भी संदर्भित करे, केवल t-1 तक के इतिहास तक ही पहुँचता है। ऑनलाइन मोड में, अंतिम K-लाइन को हटा दिया जाता है (slice(0, n-1)), फैक्टर मान की गणना की जाती है, और अगली K-लाइन की चाल की भविष्यवाणी की जाती है। दोनों तर्क पूरी तरह से समान हैं, जिससे भविष्य के डेटा को देखने के कारण IC के कृत्रिम रूप से उच्च होने से बचा जाता है।

4.3 हाल के IC पर भार, भार बाजार के अनुकूल होता है

कारक भार स्थिर नहीं होते, बल्कि हाल के IC के अनुसार गतिशील रूप से समायोजित होते हैं। जब कोई कारक विफल होने लगता है (हाल का IC घटता है), तो सिग्नल संश्लेषण में उसका भार स्वचालित रूप से घटता जाता है जब तक कि वह शून्य न हो जाए, सिस्टम को भार पुनर्संतुलन के लिए मानवीय हस्तक्षेप की आवश्यकता नहीं होती।

4.4 दोहरी ट्रिगर वास्तुकला

कारक पुनरावृत्ति एक भारी गणना कार्य है (K-लाइन खींचना + IC बैकटेस्ट + AI कॉल), जिसे प्रति घंटा स्तर पर एक बार निष्पादित करना पर्याप्त है; स्थिति संरक्षण एक समय-संवेदनशील कार्य है जिसमें सेकंड-स्तरीय प्रतिक्रिया की आवश्यकता होती है। दोनों को अलग-अलग आवृत्तियों वाले ट्रिगर में विभाजित करके, एक-दूसरे को अवरुद्ध करने से बचा जाता है।

पाँच, वास्तविक व्यापार अवलोकन: कारक पुनरावृत्ति प्रक्रिया

दो दिनों के वास्तविक व्यापार के बाद, निम्नलिखित घटनाएँ देखी गईं:

• शुरुआती पूल में शामिल कारकों का ऐतिहासिक IC आमतौर पर 0.04 से 0.07 के बीच था, जो बुनियादी सीमा को पार कर गया।
• पुनरावृत्ति आगे बढ़ने के साथ, लगभग सभी कारकों का हालिया IC घट रहा था, कुछ 0.06 से घटकर 0.008 हो गए, कुछ नकारात्मक मान में चले गए। यह दर्शाता है कि ये कारक वर्तमान बाजार वातावरण में जो संकेत पकड़ रहे थे, वे विफल हो रहे हैं।
• क्षय का पता चलने पर, सिस्टम अगले दौर में प्राथमिकता से उन आयामों की खोज करता है जो अभी तक कवर नहीं हुए हैं, ताकि नए उम्मीदवार कारक खोज सके और उन्हें बदल सके। पूरी प्रक्रिया में मानवीय हस्तक्षेप की आवश्यकता नहीं होती।

दो दिन की अवधि बहुत कम है, यह पूरी तरह से सत्यापित करने के लिए पर्याप्त नहीं है कि सिस्टम की अनुकूलन क्षमता वास्तव में प्रभावी है या नहीं। यहाँ केवल यह दर्ज किया गया है कि सिस्टम ने अपेक्षित पुनरावृत्ति कार्रवाई को अंजाम दिया, अधिक सार्थक निष्कर्षों के लिए लंबी अवधि के निरंतर अवलोकन की आवश्यकता होगी। लेकिन यह प्रक्रिया स्वयं दर्शाती है कि सिस्टम डिज़ाइन का मूल तर्क काम कर रहा है: यह विफल संकेतों पर अड़ा नहीं रहता, बल्कि लगातार नए आयामों की कोशिश करता है।

छह, अंत में

यह सिस्टम यह साबित करने के लिए नहीं बनाया गया है कि AI बाजार को हरा सकता है। बल्कि यह कहना है कि AI के इस युग में, बहुत सी चीजें जो पहले केवल शीर्ष संस्थान ही कर सकते थे, अब आम लोगों के लिए भी प्रयास करने का अवसर है।

कारक खनन, रणनीति पुनरावृत्ति, स्वचालित निष्पादन - ये सब, जिनके लिए पहले एक टीम, बड़े डेटा बुनियादी ढाँचे और वर्षों के संचय की आवश्यकता होती थी, आज एक वर्कफ़्लो के साथ चलाए जा सकते हैं।

इसका मतलब यह नहीं है कि यह स्थिर रूप से लाभ कमाएगा। बाजार हमेशा किसी भी सिस्टम से अधिक जटिल है। लेकिन इसका मतलब यह है कि प्रवेश की बाधा कम हो रही है, उपकरण मजबूत हो रहे हैं, और आम लोगों के लिए इसमें भाग लेने की संभावना बढ़ रही है।

⚠️ जोखिम चेतावनी : किसी भी रणनीति में नुकसान का जोखिम होता है, यह लेख केवल तकनीकी सीखने के संदर्भ के लिए है और निवेश सलाह का गठन नहीं करता है। कृपया वास्तविक व्यापार से पहले पूरी तरह से परीक्षण करना सुनिश्चित करें।

रणनीति स्रोत कोड: अनुकूली कारक खनन मात्रात्मक रणनीति परीक्षण संस्करण