ایک، خودکار فیکٹر مائننگ کی ضرورت کیوں؟

اگر آپ نے کوانٹیٹیٹو ٹریڈنگ کو چھوا ہے تو آپ نے ضرور "فیکٹر" کا لفظ سنا ہوگا۔ فیکٹر کیا ہے؟ سیدھے الفاظ میں، یہ ایک مارکیٹ سگنل ہے جو ڈیٹا کے ذریعے ظاہر ہوتا ہے۔ مثال کے طور پر قیمت کی مومینٹم، حجم میں غیر معمولی تبدیلی، بولیجر بینڈ کی پوزیشن — یہ سب اس بات کی پیش گوئی کرنے کے لیے استعمال ہوتے ہیں کہ آنے والے وقت میں کوئی کرپٹو کرنسی اوپر جائے گی یا نیچے۔

یہ سننے میں آسان لگتا ہے، لیکن جو لوگ واقعی فیکٹر ریسرچ کرتے ہیں وہ جانتے ہیں کہ یہ کتنا مشکل ہے:

ٹھوس مالیاتی علم اور گہری ریاضیاتی و شماریاتی پس منظر
بڑی مقدار میں صاف تاریخی ڈیٹا
سخت بیک ٹیسٹنگ فریم ورک

اور ایک ایسا مسئلہ جس سے کبھی بچا نہیں جا سکتا: فیکٹرز کا زوال

آج مؤثر سگنل، کچھ دنوں بعد مکمل طور پر بیکار ہو سکتا ہے — کیونکہ مارکیٹ کے شرکاء سیکھتے ہیں، ڈھل جاتے ہیں، اور اس پیٹرن کو اربٹریج کر لیتے ہیں۔ اس لیے فیکٹر مائننگ کبھی ایک بار کا کام نہیں ہوتی، اسے مسلسل اپ ڈیٹ کرنا پڑتا ہے۔

یہ مضمون ایک ایسے نظام کو متعارف کراتا ہے جو اس کام کو خودکار بناتا ہے: مقررہ وقفوں پر چکر لگا کر مکمل فیکٹر مائننگ → توثیق → خاتمہ → سگنل ترکیب → آرڈر ٹریڈنگ۔ مشین کی تکرار کو انسانی دہرانے سے بدل کر، حکمت عملی کو مارکیٹ کی تبدیلی کی رفتار کے ساتھ ہم آہنگ رکھا جاتا ہے۔

دو، نظام کا مجموعی ڈھانچہ

روایتی فیکٹر مائننگ کا عمل یہ ہے: محقق مفروضہ پیش کرتا ہے → کوڈ لکھتا ہے → بیک ٹیسٹ چلاتا ہے → فلٹر کرتا ہے → لائیو کرتا ہے → کچھ مہینوں بعد ناکام ہوتا ہے → دوبارہ شروع کرتا ہے۔ پورا چکر کئی ہفتوں یا مہینوں کا ہو سکتا ہے۔

یہ نظام پورے چکر کو مقررہ وقفے پر خود بخود ایک بار چلانے کے لیے کمپریس کرتا ہے:

یہ نظام دو شیڈیولرز سے چلتا ہے: سست ٹرگر گھنٹوں کی سطح پر ایک بار مکمل فیکٹر اٹریشن کا عمل چلاتا ہے؛ تیز ٹرگر سیکنڈوں کی سطح پر پوزیشن کی حالت پول کرتا ہے، سٹاپ لاس اور ٹیک پروفٹ کو ہینڈل کرتا ہے، اور ڈیش بورڈ کو ریفریش کرتا ہے۔

تین، ماڈیولز کی تفصیل اور بنیادی کوڈ

3.1 علامتی پول حاصل کریں

ہر دور کے آغاز میں، نظام ایکسچینج سے تمام پرپیچوئل کنٹریکٹس کی ریئل ٹائم کوٹس کھینچتا ہے، ٹریڈنگ حجم کے مطابق ترتیب دے کر پہلے N کو منتخب کرتا ہے۔ لیکویڈیٹی فیکٹر کی مؤثریت کی شرط ہے — چھوٹے سکوں کا حجم کم ہوتا ہے، جس سے کوئی بھی سگنل آسانی سے مسخ ہو سکتا ہے۔

ساتھ ہی BTC کے 4 گھنٹے کے چارٹ کی وولیٹیلیٹی کے تاریخی پرسنٹائل کا پتہ لگایا جاتا ہے، مارکیٹ کی مجموعی حالت (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
            
            
// 迭代模式 Prompt 关键片段
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 کے System Prompt میں مکمل موجد پلیٹ فارم کے 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 (Information Coefficient) پیمائش کرتا ہے: فیکٹر سے حساب کردہ کراس سیکشن رینکنگ اور اگلی 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;

    // Rank IC (Spearman Correlation) کا حساب
    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-score میں معیاری بنایا جاتا ہے، پھر انہیں ان کے حالیہ 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-score معیاری بنانا
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 پوزیشن مانیٹرنگ: نقصان رک/ منافع کک / متحرک ٹریلنگ منافع بند

فاسٹ ٹرگر فی سیکنڈ ایک بار چلتا ہے، تمام پوزیشنوں کے تیرتے منافع/نقصان کو حقیقی وقت میں مانیٹر کرتا ہے، اور تین قسم کے اخراج کی منطق کو انجام دیتا ہے:

• مقررہ نقصان رک: تیرتا نقصان 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 رینک IC کیوں (پیرسن IC کے بجائے)

رینک IC قدروں کی بجائے درجات کا استعمال کرکے ارتباط کا حساب لگاتا ہے، جو فیکٹر میں انتہائی قدروں (آؤٹ لائر) کے خلاف قدرتی طور پر مضبوط ہے۔ کرپٹو مارکیٹ کی قیمتوں کی تقسیم موٹی دم والی ہوتی ہے، پیرسن IC آسانی سے چند انتہائی کینڈل اسٹکس سے بگڑ سکتا ہے، جبکہ رینک IC کی استحکام زیادہ ہے۔

4.2 وقتی سختی سے صف بندی، مستقبل کے فنکشن کو ختم کرنا

IC تصدیق اور آن لائن سگنل کا حساب دونوں یکساں طور پر t-1 مدت کے فیکٹر کی قدر کا استعمال کرتے ہوئے t مدت کی واپسی کی پیش گوئی کرتے ہیں: تصدیق میں، records میں fullRecords.slice(0, t) بھیجا جاتا ہے، مستقبل کے ڈیٹا کو جسمانی طور پر کاٹ دیا جاتا ہے، AI کے تیار کردہ فیکٹر کوڈ خواہ records[n] کا حوالہ دے، وہ صرف t-1 تک کی تاریخ تک رسائی حاصل کرے گا۔ آن لائن میں، آخری کینڈل اسٹک کو ہٹا کر (slice(0, n-1)) فیکٹر کی قدر کا حساب لگایا جاتا ہے، اگلی کینڈل اسٹک کی قیمت میں اضافے/کمی کی پیش گوئی کی جاتی ہے۔ دونوں کی منطق مکمل طور پر ایک جیسی ہے، مستقبل کے ڈیٹا کو دیکھنے سے IC کو مصنوعی طور پر بڑھانے سے گریز کیا جاتا ہے۔

4.3 حالیہ IC وزن، وزن مارکیٹ کے مطابق خودکار طور پر ڈھل جاتا ہے

عامل کے وزن مقررہ نہیں ہیں، بلکہ حالیہ IC کے مطابق متحرک طور پر ایڈجسٹ ہوتے ہیں۔ جب کوئی عامل ناکارہ ہونا شروع ہوتا ہے (حالیہ IC میں کمی آتی ہے)، تو سگنل کے امتزاج میں اس کا وزن خود بخود کم ہو کر صفر تک پہنچ جاتا ہے، اور نظام کو وزن کی دوبارہ توازن کے لیے انسانی مداخلت کی ضرورت نہیں ہوتی۔

4.4 دوہری محرک (ٹرگر) کا ڈھانچہ

عامل کی تکرار (iteration) ایک بھاری حساب کا کام ہے (K-لائن کی بازیافت + IC بیک ٹیسٹ + AI کال) اور اسے گھنٹہ وار سطح پر ایک بار انجام دینا کافی ہے؛ پوزیشن کی حفاظت (holdings protection) ایک وقت کے حساس کام ہے جسے سیکنڈ کی سطح پر ردعمل کی ضرورت ہوتی ہے۔ دونوں کو مختلف تعدد کے محرکات میں تقسیم کرنے سے ایک دوسرے کی رکاوٹ سے بچا جا سکتا ہے۔

پانچواں: حقیقی مارکیٹ کا مشاہدہ: عوامل کی تکرار کا عمل

دو دن کی حقیقی مارکیٹ کے بعد، درج ذیل مشاہدات ہوئے:

• ابتدائی طور پر پول میں شامل عوامل کا تاریخی IC عام طور پر 0.04 سے 0.07 کے درمیان تھا، جو بنیادی حد کو پاس کر گئے تھے۔
• تکرار کے آگے بڑھنے کے ساتھ، تقریباً تمام عوامل کا حالیہ IC گر رہا تھا، کچھ 0.06 سے 0.008 تک گر گئے، کچھ منفی اقدار میں داخل ہو گئے۔ اس سے ظاہر ہوتا ہے کہ یہ عوامل موجودہ مارکیٹ کے ماحول میں جو سگنل پکڑ رہے تھے وہ ناکارہ ہو رہے ہیں۔
• نظام کی طرف سے کمی کا پتہ چلنے کے بعد، اگلے دور میں ترجیحی طور پر ان جہتوں کی تلاش کی گئی جو ابھی تک احاطہ نہیں ہوئی تھیں، تاکہ نئے ممکنہ عوامل تلاش کیے جائیں اور تبدیل کیے جائیں۔ پورے عمل میں انسانی مداخلت کی ضرورت نہیں ہوئی۔

دو دن کا عرصہ بہت مختصر ہے، اس لیے نظام کی خود موافقت کی صلاحیت کی مکمل تصدیق ممکن نہیں ہے۔ یہاں صرف یہ ریکارڈ کیا گیا ہے کہ نظام نے متوقع طریقے سے تکرار کے اقدامات انجام دیے، اور زیادہ معنی خیز نتائج کے لیے طویل مدتی مسلسل مشاہدے کی ضرورت ہے۔ لیکن یہ عمل خود پہلے ہی ظاہر کرتا ہے کہ نظام کے ڈیزائن کی بنیادی منطق کام کر رہی ہے: یہ ناکارہ سگنلز پر قائم نہیں رہتا، بلکہ مسلسل نئے جہتوں کی تلاش کرتا ہے۔

چھٹا: آخر میں

یہ نظام اس بات کو ثابت کرنے کے لیے نہیں بنایا گیا کہ AI مارکیٹ کو شکست دے سکتا ہے۔ بلکہ یہ کہنا ہے کہ AI کے اس دور میں، وہ بہت سی چیزیں جو پہلے صرف بہترین ادارے ہی کر سکتے تھے، اب عام لوگ بھی انہیں آزما سکتے ہیں۔

عامل کی دریافت، حکمت عملی کی تکرار، خودکار عملدرآمد — یہ وہ چیزیں ہیں جن کے لیے پہلے ایک ٹیم، بڑی ڈیٹا انفراسٹرکچر اور کئی سالوں کے تجربے کی ضرورت تھی، آج ایک ورک فلو کے ذریعے چلایا جا سکتا ہے۔

اس کا مطلب یہ نہیں ہے کہ یہ مستحکم منافع دے گا۔ مارکیٹ ہمیشہ کسی بھی نظام سے زیادہ پیچیدہ ہوتی ہے۔ لیکن اس کا مطلب یہ ہے کہ حدیں کم ہو رہی ہیں، اوزار مضبوط ہو رہے ہیں، اور عام لوگوں کے لیے اس میں شامل ہونے کا امکان بڑھ رہا ہے۔

⚠️ خطرے کی نشاندہی: کسی بھی حکمت عملی میں نقصان کا خطرہ ہوتا ہے، اس مضمون کا مواد صرف تکنیکی تعلیمی حوالے کے لیے ہے اور یہ سرمایہ کاری کا مشورہ نہیں ہے۔ حقیقی مارکیٹ میں استعمال کرنے سے پہلے یقینی طور پر مکمل جانچ کریں۔

حکمت عملی کا سورس کوڈ: خود موافقت عامل کی دریافت کوانٹیٹیٹو حکمت عملی (ٹیسٹ ورژن)