1. Pengenalan: Implikasi untuk Arena Dagangan AI

Baru-baru ini, makmal AI AS nof1ai melancarkan percubaan berprofil tinggi: enam model AI teratas (Claude, DeepSeek, Gemini, GPT-5, Grok, dan Tongyi Qianwen) masing-masing dianugerahkan $10,000 untuk bersaing dalam pasaran niaga hadapan kekal mata wang kripto sebenar. Ini bukan sesi dagangan simulasi, tetapi pertempuran wang sebenar. Hasilnya mengejutkan: AI DeepSeek domestik secara konsisten mendahului, manakala GPT-5 dan Gemini kedua-duanya ketinggalan. Nilai terbesar pertandingan ini terletak pada fakta bahawa pasukan itu telah membuka isyarat, struktur data dan proses membuat keputusan yang digunakan, menyediakan model yang sangat baik untuk penyelidikan tentang perdagangan kuantitatif berasaskan AI.

Berdasarkan seni bina awam ini, artikel ini akan memecahkan setiap nod dan logik aliran kerja dagangan kuantitatif AI secara terperinci untuk membantu anda memahami cara AI membuat keputusan perdagangan dalam pasaran sebenar.

---

2. Seni Bina Keseluruhan: Sistem Tiga Peringkat Persepsi-Keputusan-Pelaksanaan

Sistem perdagangan kuantitatif AI ini mengamalkan seni bina tiga peringkat “persepsi-keputusan-pelaksanaan” klasik. Keseluruhan aliran kerja terdiri daripada berbilang nod teras:

Penerangan Nod Teras：

1. Pencetus pemasa- Degupan jantung sistem, dicetuskan setiap 3 minit
2. Tetapan semula parameter- Pemantauan status akaun dan statistik prestasi
3. Pemerolehan data pasaran- Pemerolehan data berbilang dimensi dan pengiraan penunjuk
4. Pemerolehan data kedudukan- Penjejakan status kedudukan semasa
5. Gabungan Data- Mengintegrasikan maklumat akaun dan pasaran
6. Ejen AI- Enjin keputusan teras
7. Pelaksanaan urus niaga- Analisis isyarat dan pemprosesan pesanan

Mari analisa logik reka bentuk setiap nod satu demi satu.

---

Nod 1: Pencetus Masa

Kedudukan Berfungsi

Pencetus masa ialah pemula keseluruhan aliran kerja, serupa dengan degupan jantung manusia, yang mendorong sistem untuk beroperasi secara berkala.

Pertimbangan reka bentuk：

• Kitaran 3 minit: Mengimbangi kesegaran data dan sekatan panggilan API
• Selang tetap: Memastikan kestabilan dan kebolehramalan pelaksanaan strategi

---

4. Nod 2: Set Semula Parameter (Pengurusan Status Akaun)

Kedudukan Berfungsi

Ini ialah nod pengurusan keadaan utama, yang bertanggungjawab untuk memulakan, menjejak dan mengira pelbagai penunjuk teras akaun.

Analisis kod teras

// 设置币安模拟交易所API基础地址
api_base = "https://testnet.binancefuture.com"
exchange.SetBase(api_base)

// 初始化检查 - 首次运行时设置基准值
if (_G('invoketime') === null) {
  _G('invoketime', 0);
  _G('STARTTIME', Date.now());
  const initAccount = exchange.GetAccount();
  _G('initmoney', initAccount.Equity);
}

// 累计调用次数
const invoketime = _G('invoketime') + 1;
_G('invoketime', invoketime);

// 计算运行时长(分钟)
const duringtime = Math.floor((Date.now() - _G('STARTTIME')) / 60000);

// 获取当前账户信息
const currentAccount = exchange.GetAccount();
const currentAccountValue = currentAccount.Equity;

// 计算总收益率
const initMoney = _G('initmoney');
const totalReturnPercent = ((currentAccountValue - initMoney) / initMoney * 100).toFixed(2);

// 记录收益到系统日志
LogProfit(currentAccountValue - initMoney, "&")

// 返回5个核心指标
return [{
  json: {
    invoketime: invoketime,
    duringtime: duringtime,
    totalReturnPercent: totalReturnPercent + '%',
    availableCash: currentAccount.Balance.toFixed(2),
    currentAccountValue: currentAccountValue.toFixed(2)
  }
}];

Struktur data output

{
  "invoketime": 42,              // 系统调用次数
  "duringtime": 126,             // 运行时长(分钟)
  "totalReturnPercent": "3.45%", // 总收益率
  "availableCash": "10345.67",   // 可用资金
  "currentAccountValue": "10345.00" // 账户总价值
}

Sorotan Reka Bentuk

1. Pengurusan negeri yang berterusanPenggunaan:_G()Fungsi melaksanakan kegigihan data merentas kitaran
2. Penambat Garis Dasar: Merekod dana permulaaninitmoneySebagai asas pengiraan keuntungan
3. Visualisasi prestasiMemerintah:LogProfit()Fungsi ini menyalurkan pendapatan kembali ke carta sistem dalam masa nyata
4. Pengaturcaraan Defensif: Permulaan automatik untuk larian pertama untuk mengelakkan ralat nilai nol

---

5. Nod 3: Pemerolehan Data Pasaran

Kedudukan Berfungsi

Ini adalah “mata” keseluruhan sistem, bertanggungjawab untuk mengumpul, memproses dan mengira pelbagai data pasaran dan penunjuk teknikal.

Seni bina logik teras

Fungsi nod pengumpulan data pasaran boleh dibahagikan kepada tiga peringkat:

Tahap 1: Penghuraian senarai mata wang dan pengumpulan gelung

// 解析币种列表
const coins = $vars.coinList ? 
  ($vars.coinList.includes(',') ? $vars.coinList.split(',') : [$vars.coinList]) : [];

if (coins.length === 0) {
  return {};
}

// 为每个币种获取市场数据
const allCoinsData = {};
for (let i = 0; i < coins.length; i++) {
  const coin = coins[i].trim();
  try {
    allCoinsData[coin] = getMarketDataForCoin(coin);
  } catch (e) {
    allCoinsData[coin] = { error: e.toString() };
  }
}

return { data: allCoinsData };

Tahap 2: Pemerolehan data K-line berbilang tempoh dan pengiraan penunjuk

function getMarketDataForCoin(symbol) {
  // 切换到对应币种的永续合约
  exchange.SetCurrency(symbol + "_USDT");
  exchange.SetContractType("swap");
  
  // 获取3分钟和4小时K线数据
  const kline3m = exchange.GetRecords(60 * 3);      // 3分钟周期
  const kline4h = exchange.GetRecords(60 * 60 * 4); // 4小时周期
  
  // 数据有效性检查
  if (!kline3m || kline3m.length < 50 || !kline4h || kline4h.length < 50) {
    return { error: "K线数据不足" };
  }
  
  // 计算3分钟周期技术指标
  const ema20_3m = TA.EMA(kline3m, 20);      // 20周期指数移动平均
  const macd_3m = TA.MACD(kline3m, 12, 26, 9); // MACD指标
  const rsi7_3m = TA.RSI(kline3m, 7);        // 7周期RSI
  const rsi14_3m = TA.RSI(kline3m, 14);      // 14周期RSI
  
  // 计算4小时周期技术指标
  const ema20_4h = TA.EMA(kline4h, 20);      // 20周期EMA
  const ema50_4h = TA.EMA(kline4h, 50);      // 50周期EMA
  const macd_4h = TA.MACD(kline4h, 12, 26, 9); // MACD指标
  const rsi14_4h = TA.RSI(kline4h, 14);      // 14周期RSI
  const atr3_4h = TA.ATR(kline4h, 3);        // 3周期ATR(波动率)
  const atr14_4h = TA.ATR(kline4h, 14);      // 14周期ATR
  
  // 获取最新K线和最近10根K线
  const latest3m = kline3m[kline3m.length - 1];
  const latest4h = kline4h[kline4h.length - 1];
  const recent10_3m = kline3m.slice(-10);
  const recent10_4h = kline4h.slice(-10);
  
  // 计算平均成交量
  const volumes4h = recent10_4h.map(k => k.Volume);
  const avgVolume4h = volumes4h.reduce((a, b) => a + b, 0) / volumes4h.length;
  
  // 返回结构化数据...
}

Strategi Dwi Jangka Masa：

• Kitaran pendek 3 minit: Tangkap turun naik jangka pendek untuk masa masuk dan keluar yang tepat
• Kitaran panjang 4 jam: Tentukan arah aliran umum dan elakkan dagangan arah aliran balas

Analisis bingkai berbilang masa ini ialah ciri standard perdagangan kuantitatif profesional, yang setara dengan menyediakan AI dengan kedua-dua perspektif “mikroskop” dan “teleskop”.

Tahap 3: Output berstruktur data

return {
  symbol: symbol,
  current_price: latest3m.Close,
  current_ema20: ema20_3m[ema20_3m.length - 1],
  current_macd: macd_3m[2][macd_3m[2].length - 1],
  current_rsi_7: rsi7_3m[rsi7_3m.length - 1],
  funding_rate: fundingRate,
  intraday_3min: {
    mid_prices: recent10_3m.map(k => k.Close),
    ema_20_series: recent10_3m.map((k, i) => ema20_3m[ema20_3m.length - 10 + i]),
    macd_series: recent10_3m.map((k, i) => macd_3m[2][macd_3m[2].length - 10 + i]),
    rsi_7_series: recent10_3m.map((k, i) => rsi7_3m[rsi7_3m.length - 10 + i]),
    rsi_14_series: recent10_3m.map((k, i) => rsi14_3m[rsi14_3m.length - 10 + i])
  },
  longer_term_4hour: {
    ema_20: ema20_4h[ema20_4h.length - 1],
    ema_50: ema50_4h[ema50_4h.length - 1],
    atr_3: atr3_4h[atr3_4h.length - 1],
    atr_14: atr14_4h[atr14_4h.length - 1],
    current_volume: latest4h.Volume,
    average_volume: avgVolume4h,
    macd_series: recent10_4h.map((k, i) => macd_4h[2][macd_4h[2].length - 10 + i]),
    rsi_14_series: recent10_4h.map((k, i) => rsi14_4h[rsi14_4h.length - 10 + i])
  }
};

Penerangan Petunjuk Teknikal

1. EMA (Purata Pergerakan Eksponen)

• Fungsi: Tentukan arah aliran dan tahap sokongan/rintangan
• Harga melebihi EMA20 → kenaikan harga jangka pendek
• EMA20 bersilang di atas EMA50 → Golden Cross, isyarat beli

2. MACD (Moving Average Convergence Divergence)

• Fungsi: Tentukan momentum dan titik perubahan arah aliran
• Histogram MACD bertukar daripada negatif kepada positif → momentum bertambah kukuh
• Garisan DIF melintasi garisan DEA → isyarat Golden Cross

3. RSI (Indeks Kekuatan Relatif)

• Fungsi: menilai terlebih beli dan terlebih jual
• RSI > 70 → Terlebih beli, kemungkinan penarikan balik
• RSI < 30 → Terlebih jual, kemungkinan lantunan semula

4. ATR (Julat Sebenar Purata)

• Fungsi: Ukur turun naik pasaran dan laraskan jarak henti rugi

---

6. Nod 4: Pemerolehan Data Kedudukan

Kedudukan Berfungsi

Nod pemerolehan data kedudukan bertanggungjawab untuk menjejak status kedudukan semasa setiap mata wang dan menyediakan maklumat kedudukan lengkap kepada AI.

Kod teras (bahagian kritikal)

function getAllPositions() {
  // 获取当前账户权益
  const curequity = exchange.GetAccount().Equity;
  
  // 获取币种列表
  const coins = $vars.coinList ? 
    ($vars.coinList.includes(',') ? $vars.coinList.split(',') : [$vars.coinList]) : [];
  
  // 计算每个币种的风险金额 = 账户权益 / 币种数量
  const risk_usd = coins.length > 0 ? curequity / coins.length : 0;
  
  // 获取所有实际持仓
  const rawPositions = exchange.GetPositions();
  
  // 创建持仓映射表 (币种符号 -> 持仓对象)
  const positionMap = {};
  
  if (rawPositions && rawPositions.length > 0) {
    for (let pos of rawPositions) {
      if (pos.Amount && Math.abs(pos.Amount) > 0) {
        // 提取币种符号 (如 BTC_USDT.swap -> BTC)
        const coinSymbol = pos.Symbol.replace('_USDT.swap', '')
                                     .replace('.swap', '')
                                     .replace('_USDT', '');
        positionMap[coinSymbol] = pos;
      }
    }
  }
  
  // 为每个币种创建position信息
  const allPositions = [];
  
  for (let i = 0; i < coins.length; i++) {
    const coin = coins[i].trim();
    const pos = positionMap[coin];
    
    if (pos) {
      // 有持仓的情况 - 构建完整持仓信息
      // 获取止盈止损订单ID
      const { tpOrderId, slOrderId } = getTPSLOrderIds(pos.Symbol, currentPrice, pos.Type);
      
      // 获取退出计划
      const exitPlan = _G(`exit_plan_${pos.Symbol}`) || {
        profit_target: null,
        stop_loss: null,
        invalidation_condition: ""
      };
      
      allPositions.push({
        symbol: coin,
        quantity: Math.abs(pos.Amount),        // 持仓数量
        entry_price: pos.Price,                // 入场价格
        current_price: currentPrice,           // 当前价格
        liquidation_price: /* 强平价格计算 */,
        unrealized_pnl: _N(pos.Profit, 2),    // 未实现盈亏
        leverage: pos.MarginLevel || 1,        // 杠杆倍数
        exit_plan: exitPlan,                   // 退出计划
        confidence: exitPlan?.confidence || null,
        risk_usd: risk_usd,                    // 风险金额
        sl_oid: slOrderId,                     // 止损订单ID
        tp_oid: tpOrderId,                     // 止盈订单ID
        wait_for_fill: false,
        entry_oid: pos.Info?.posId || -1,
        notional_usd: _N(Math.abs(pos.Amount) * currentPrice, 2)
      });
    } else {
      // 没有持仓的情况 - 所有字段设为null
      allPositions.push({
        symbol: coin,
        quantity: null,            // 关键字段：null表示无持仓
        entry_price: null,
        current_price: null,
        liquidation_price: null,
        unrealized_pnl: null,
        leverage: null,
        exit_plan: null,
        confidence: null,
        risk_usd: risk_usd,        // 仍然返回risk_usd用于开仓计算
        sl_oid: null,
        tp_oid: null,
        wait_for_fill: false,
        entry_oid: null,
        notional_usd: null
      });
    }
  }
  
  return allPositions;
}

const positions = getAllPositions();
return {positions};

Reka Bentuk Utama

Peranan utama bidang kuantiti：

• quantity = null: Tiada jawatan, AI boleh mempertimbangkan untuk membuka kedudukan
• quantity ≠ null: Jika ada jawatan, AI hanya boleh memegang atau menutup kedudukan, tetapi tidak boleh meningkatkan kedudukan

Reka bentuk ini mengelakkan risiko “piramid” dan memastikan bahawa terdapat hanya satu kedudukan aktif untuk setiap mata wang.

---

7. Nod 5: Gabungan Data

Kedudukan Berfungsi

Menggabungkan data pasaran dan kedudukan ke dalam konteks lengkap yang diperlukan untuk membuat keputusan AI.

Pelaksanaan kod sumber

// 获取输入数据
const inputData = $input.all();

// 第一个输入是市场数据，第二个是持仓数据
const marketData = inputData[0].json.data;
const positions = inputData[1].json;

// 返回整理后的数据
return [{
  json: {
    marketData: marketData,
    positions: positions
  }
}];

Penyepaduan data yang mudah dan cekap menyediakan antara muka data bersatu untuk AI.

---

Nod 6: Ejen AI (Enjin Pembuat Keputusan Teras)

Kedudukan Berfungsi

Ini adalah teras keseluruhan sistem - enjin keputusan AI. Ia menerima maklumat pasaran dan akaun yang lengkap serta mengeluarkan arahan perdagangan khusus.

Penerangan struktur perkataan yang pantas

Pembuatan keputusan ejen AI bergantung pada dua jenis gesaan:

1. Mesej Sistem：

• sumber：Laman web NOF1 belum diterbitkan, berdasarkan keputusan potongan terbalik
• kesan: Mentakrifkan peranan, peraturan tingkah laku dan rangka kerja membuat keputusan AI, yang setara dengan “manual operasi” AI
• Ciri-ciri: Tetap dan sama untuk setiap panggilan
• Lokasi: Diluluskan sebagai mesej sistem apabila model AI dipanggil

2. Gesaan Teks：

• sumber：Laman web NOF1 mengumumkan pemerolehan
• kesan：Menyediakan data pasaran dinamik dan status akaun, yang setara dengan “input maklumat masa nyata” AI
• Ciri-ciri：Setiap panggilan adalah berbeza, mengandungi data pasaran terkini dan maklumat kedudukan
• Lokasi: Diluluskan sebagai mesej pengguna apabila model AI dipanggil

Seni bina perkataan dwi-prompt “peraturan tetap + data dinamik” ini membolehkan AI mempunyai rangka kerja membuat keputusan yang stabil dan membuat respons yang fleksibel berdasarkan keadaan pasaran masa nyata.

Penjelasan terperinci tentang kata gesaan sistem

Gesaan sistem mentakrifkan peraturan tingkah laku AI dan rangka kerja membuat keputusan, yang boleh dibahagikan kepada empat bahagian teras:

Bahagian 1: Kekangan Keras

## HARD CONSTRAINTS

### Position Limits
- Tradable coins: {{$vars.coinList}}
- Maximum {{$vars.coinList.split(',').length}} concurrent positions
- No pyramiding or adding to existing positions
- Must be flat before re-entering a coin

### Risk Management
- Maximum risk per trade: 5% of account value
- Leverage range: 5x to 40x
- Minimum risk-reward ratio: 2:1
- Every position must have:
  - Stop loss (specific price level)
  - Profit target (specific price level)  
  - Invalidation condition (format: "If price closes below/above [PRICE] on a [TIMEFRAME] candle")

Falsafah reka bentuk：

• Sekatan lokasi：Setiap mata wang memegang kedudukan sehala, memaksa kepelbagaian risiko
• Tiada penambahan jawatan: Elakkan perangkap “purata kos”.
• Had Risiko: Risiko sehingga 5% daripada nilai akaun anda pada satu dagangan
• Risiko dan ganjaran: Sekurang-kurangnya 2:1, yang bermaksud sasaran keuntungan adalah sekurang-kurangnya dua kali jarak stop loss

Bahagian 2: Rangka kerja membuat keputusan

## DECISION FRAMEWORK

### Identifying Position Status
A coin has an **active position** if `quantity` is NOT null.
A coin has **no position** if `quantity` is null.

### For Coins WITH Active Positions
Check each position in this order:
1. Invalidation condition triggered? → Close immediately
2. Stop loss or profit target hit? → Close
3. Technical setup still valid? → Hold
4. If uncertain → Hold (trust your exit plan)

Available signals: "hold" or "close" ONLY

### For Coins WITHOUT Positions
Only consider if:
- Current active positions < 6
- Available cash > $1000  
- You see a high-probability setup

Available signal: "entry" ONLY

Kejelasan logik：

• Bezakan dengan tegas antara “pegang jawatan” dan “tiada pegangan jawatan”
• Apabila anda mempunyai kedudukan, anda hanya boleh memilih “Tahan” atau “Tutup”
• Apabila anda tiada jawatan, anda hanya boleh memilih “Buka” atau “Langkau”
• Reka bentuk ini mengelakkan AI daripada menghasilkan arahan yang bercanggah secara logik.

Bahagian 3: Spesifikasi Format Output

{
  "BTC": {
    "trade_signal_args": {
      "coin": "BTC",
      "signal": "entry|hold|close",
      "profit_target": 115000.0,
      "stop_loss": 112000.0,
      "invalidation_condition": "If price closes below 112500 on a 3-minute candle",
      "leverage": 15,
      "confidence": 0.75,
      "risk_usd": 624.38,
      "justification": "Reason for this decision"
    }
  }
}

Penerangan Medan：

• signal：Isyarat dagangan (masuk/tahan/tutup)
• profit_target：Ambil Harga Untung
• stop_loss: Harga hentikan kerugian
• invalidation_condition：Keadaan kegagalan (huraian bahasa semula jadi)
• leverage：Nisbah leverage (5-40)
• confidence: Keyakinan AI terhadap isyarat ini (0-1)
• risk_usd: Jumlah risiko yang anda sanggup ambil
• justification: Rasional keputusan (untuk pengauditan dan penyahpepijatan)

Bahagian 4: Membimbing Proses Pemikiran

## THINKING PROCESS

Before outputting JSON, think through your decisions step by step:

1. Identify position status for each coin
2. Review coins WITH active positions
3. Review coins WITHOUT positions  
4. Output final decisions in JSON

“Rantaian Pemikiran” ini mendorong AI untuk menganalisis dahulu dan kemudian menghasilkan, meningkatkan kestabilan dan kebolehjelasan dalam membuat keputusan.

Penjelasan terperinci tentang perkataan gesaan pengguna (input data dinamik)

Sumber：Perkataan gesaan pengguna menggunakan sintaks templat untuk menyuntik data masa nyata secara dinamik.

Gesaan pengguna dijana secara dinamik setiap kali ia dipanggil berdasarkan keadaan pasaran terkini dan maklumat akaun:

It has been {{ duringtime }} minutes since you started trading.
The current time is {{ $now.toISO() }} 
You've been invoked {{ invoketime }} times.

ALL OF THE PRICE OR SIGNAL DATA BELOW IS ORDERED: OLDEST - NEWEST

Timeframes note: Unless stated otherwise in a section title, intraday series 
are provided at 3 minute intervals. If a coin uses a different interval, it is 
explicitly stated in that coin's section.

**CURRENT MARKET STATE FOR ALL COINS**
{{ JSON.stringify(marketData) }}

**HERE IS YOUR ACCOUNT INFORMATION & PERFORMANCE**
Current Total Return (percent): {{ totalReturnPercent }}
Available Cash: {{ availableCash }}
Current Account Value: {{ currentAccountValue }}

Current live positions & performance:
{{ JSON.stringify(positions) }}

Penjelasan terperinci tentang aliran data perkataan segera

Reka bentuk ini membolehkan AI memperoleh konteks keputusan penuh setiap kali:

1. Persepsi masa

   • Berapa lama ia telah berjalan?duringtimeminit)
   • Cap masa semasa ($now.toISO()）
   • Bilangan panggilan (invoketimekadar kedua)

2. Data Pasaran(dari nod “Pemerolehan Data Pasaran”)

   • Data K-line 3 minit dan 4 jam untuk setiap mata wang
   • Urutan penunjuk teknikal bagi 10 K baris terakhir
   • Harga semasa, EMA, MACD, RSI dan penunjuk masa nyata yang lain

3. Status Akaun(dari nod Tetapan Semula Parameter)

   • Jumlah pulangan (totalReturnPercent）
   • Dana Tersedia (availableCash）
   • Jumlah Nilai Akaun (currentAccountValue）

4. Butiran jawatan(Daripada nod “Pemerolehan Data Kedudukan”)

   • Bilangan jawatan yang dipegang dalam setiap mata wang (medan kuantiti)
   • Harga kemasukan, harga semasa, untung rugi tidak direalisasikan
   • Pelan henti untung dan henti rugi, jumlah risiko

Lengkapkan aliran kerja perkataan segera

┌─────────────────────────────────────────────────────────────┐
│                    AI模型调用时刻                            │
├─────────────────────────────────────────────────────────────┤
│                                                              │
│  系统提示词（固定）                             │
│  ┌────────────────────────────────────────────┐             │
│  │ You are an expert cryptocurrency trader... │             │
│  │ ## HARD CONSTRAINTS                        │             │
│  │ - Maximum 6 positions                      │             │
│  │ - Risk per trade: 5% max                   │             │
│  │ ## DECISION FRAMEWORK                      │             │
│  │ - For coins WITH positions: hold/close     │             │
│  │ - For coins WITHOUT positions: entry       │             │
│  │ ## OUTPUT FORMAT                           │             │
│  │ - JSON with trade_signal_args              │             │
│  └────────────────────────────────────────────┘             │
│                       ↓                                      │
│  用户提示词（动态，每次不同）                                 │
│  ┌────────────────────────────────────────────┐             │
│  │ Running for 126 minutes, invoked 42 times  │             │
│  │ Current Total Return: 3.45%                │             │
│  │ Available Cash: $10,345.67                 │             │
│  │                                            │             │
│  │ Market Data:                               │             │
│  │ {                                          │             │
│  │   "BTC": {                                 │             │
│  │     "current_price": 67234.5,              │             │
│  │     "current_ema20": 67150.2,              │             │
│  │     "current_macd": -141.87,               │             │
│  │     "current_rsi_7": 52.93,                │             │
│  │     "intraday_3min": {...},                │             │
│  │     "longer_term_4hour": {...}             │             │
│  │   },                                       │             │
│  │   "ETH": {...}, ...                        │             │
│  │ }                                          │             │
│  │                                            │             │
│  │ Positions:                                 │             │
│  │ [                                          │             │
│  │   {                                        │             │
│  │     "symbol": "BTC",                       │             │
│  │     "quantity": 0.5,                       │             │
│  │     "entry_price": 66800.0,                │             │
│  │     "unrealized_pnl": 217.25,              │             │
│  │     "exit_plan": {                         │             │
│  │       "stop_loss": 66000.0,                │             │
│  │       "profit_target": 68500.0             │             │
│  │     }                                      │             │
│  │   },                                       │             │
│  │   {                                        │             │
│  │     "symbol": "ETH",                       │             │
│  │     "quantity": null,  // 无持仓          │             │
│  │     ...                                    │             │
│  │   }                                        │             │
│  │ ]                                          │             │
│  └────────────────────────────────────────────┘             │
│                       ↓                                      │
│              AI模型处理和推理                                 │
│                       ↓                                      │
│  AI输出（JSON格式）                                           │
│  ┌────────────────────────────────────────────┐             │
│  │ {                                          │             │
│  │   "BTC": {                                 │             │
│  │     "trade_signal_args": {                 │             │
│  │       "signal": "hold",                    │             │
│  │       "justification": "Position valid..." │             │
│  │     }                                      │             │
│  │   },                                       │             │
│  │   "ETH": {                                 │             │
│  │     "trade_signal_args": {                 │             │
│  │       "signal": "entry",                   │             │
│  │       "profit_target": 2800.0,             │             │
│  │       "stop_loss": 2600.0,                 │             │
│  │       "leverage": 15,                      │             │
│  │       "risk_usd": 833.33,                  │             │
│  │       "justification": "Bullish setup..."  │             │
│  │     }                                      │             │
│  │   }                                        │             │
│  │ }                                          │             │
│  └────────────────────────────────────────────┘             │
│                                                              │
└─────────────────────────────────────────────────────────────┘
                         ↓
              传递给"交易执行"节点

Kelebihan seni bina perkataan dwi-kiu ini ialah:

1. Kestabilan peraturan：Perkataan gesaan sistem ditetapkan untuk memastikan peraturan tingkah laku AI sentiasa konsisten
2. Ketepatan masa data：Perkataan gesaan pengguna dikemas kini secara dinamik untuk memastikan AI membuat keputusan berdasarkan pasaran terkini
3. Pengasingan kebimbangan: Pemisahan definisi peraturan dan input data untuk penyahpepijatan dan pengoptimuman yang mudah
4. Kebolehskalaan: Anda boleh mengubah suai strategi pengoptimuman kata gesaan sistem pada bila-bila masa tanpa menjejaskan aliran data
5. Kebolehaudit: Input dan output lengkap setiap panggilan AI boleh dirakam dan dikesan

---

9. Nod 7: Pelaksanaan Transaksi

Kedudukan Berfungsi

Ini adalah “tangan” aliran kerja, bertanggungjawab untuk menterjemahkan keputusan AI ke dalam pesanan pertukaran sebenar dan memantau keadaan ambil untung dan henti rugi secara berterusan.

Logik pelaksanaan teras

Nod pelaksanaan transaksi dibahagikan kepada lima modul berfungsi:

Modul 1: Analisis dan Pengesahan Isyarat

// ========== 工具函数 ==========

function parseAIOutput(output) {
  try {
    // 清理输出中的代码块标记
    const cleaned = output.replace(/```[a-z]*\n?/gi, '').trim();
    const start = cleaned.indexOf('{');
    const end = cleaned.lastIndexOf('}');
    return JSON.parse(cleaned.substring(start, end + 1));
  } catch (e) {
    return {};
  }
}

// 主逻辑
const signals = parseAIOutput($input.first().json.output);
Log(signals)

Pengendalian pengecualian：

• Menangkap ralat penghuraian JSON
• Bersihkan pemformatan penurunan harga dalam output AI
• Elakkan keseluruhan sistem daripada ranap disebabkan isu format output AI

Modul 2: Pengurusan Ketepatan dan Pengiraan Kedudukan

// 获取交易对精度信息
function getPrecision(coin) {
  try {
    const symbol = coin + '_USDT.swap';
    const markets = exchange.GetMarkets();
    
    if (markets && markets[symbol]) {
      return {
        price: markets[symbol].PricePrecision || 0,
        amount: markets[symbol].AmountPrecision || 0,
        minQty: markets[symbol].MinQty || 5
      };
    }
    
    return { price: 0, amount: 0, minQty: 5 };
  } catch (e) {
    Log(`⚠️ 获取${coin}精度失败，使用默认值`);
    return { price: 0, amount: 0, minQty: 5 };
  }
}

// 计算仓位大小
function calculateQuantity(entryPrice, stopLoss, riskUsd, leverage, precision) {
  const riskPerContract = Math.abs(entryPrice - stopLoss);
  if (riskPerContract <= 0) return 0;
  
  // 基于风险金额计算数量
  const quantity = riskUsd / riskPerContract;
  
  // 限制最大仓位 = (账户余额 × 杠杆 / 6) / 入场价格
  const maxQuantity = (exchange.GetAccount().Balance * leverage / 6) / entryPrice;
  
  let finalQuantity = Math.min(quantity, maxQuantity);
  
  // 应用精度和最小数量限制
  if (precision) {
    finalQuantity = _N(finalQuantity, precision.amount);
    
    if (finalQuantity < precision.minQty) {
      Log(`⚠️ 计算数量 ${finalQuantity} 小于最小下单量 ${precision.minQty}`);
      return 0;
    }
  }
  
  return finalQuantity;
}

Formula pengiraan kedudukan：

风险距离 = |入场价格 - 止损价格|
仓位大小 = 风险金额 ÷ 风险距离
最大仓位 = (账户余额 × 杠杆 ÷ 6) ÷ 入场价格
最终仓位 = min(仓位大小, 最大仓位)

Pengiraan ini memastikan bahawa:

• Jumlah yang berisiko kekal berterusan tanpa mengira harga
• Apabila stop loss dicetuskan, kerugian adalah betul-betul jumlah risiko yang telah ditetapkan
• Tiada leverage yang berlebihan akan membawa kepada kedudukan yang berlebihan

Modul 3: Pembukaan dan pelaksanaan kedudukan

function executeEntry(coin, args) {
  exchange.SetCurrency(coin + '_USDT');
  exchange.SetContractType("swap");
  
  const ticker = exchange.GetTicker();
  if (!ticker) return;
  
  const currentPrice = ticker.Last;
  if (!validateEntry(coin, currentPrice, args.profit_target, args.stop_loss)) return;
  
  const leverage = args.leverage || 10;
  exchange.SetMarginLevel(leverage);
  
  precision = getPrecision(coin);
  quantity = calculateQuantity(currentPrice, args.stop_loss, args.risk_usd, leverage, precision);
  
  if (quantity <= 0) {
    Log(`⚠️ ${coin}：计算数量无效，跳过开仓`);
    return;
  }
  
  const isLong = args.profit_target > args.stop_loss;
  exchange.SetDirection(isLong ? "buy" : "sell");
  
  const orderId = isLong ? exchange.Buy(-1, quantity) : exchange.Sell(-1, quantity);
  
  if (orderId) {
    Sleep(1000);
    Log(`✅ ${coin}：开${isLong ? '多' : '空'} 数量=${quantity} 杠杆=${leverage}x 精度=${precision.amount}`);
  } else {
    Log(`❌ ${coin}：开仓失败`, precision.amount);
  }
}

Modul 4: Perlaksanaan Penutup

function executeClose(coin) {
  exchange.SetCurrency(coin + '_USDT');
  exchange.SetContractType("swap");
  
  // 取消所有挂单
  const orders = exchange.GetOrders();
  orders?.forEach(o => exchange.CancelOrder(o.Id));
  
  // 获取持仓信息
  const pos = exchange.GetPositions().find(p => 
    p.Symbol.includes(coin) && Math.abs(p.Amount) > 0
  );
  if (!pos) return;
  
  const isLong = pos.Type === PD_LONG || pos.Type === 0;
  const precision = getPrecision(coin);

  // 对平仓数量应用精度
  const closeAmount = _N(Math.abs(pos.Amount), precision.amount);
  
  exchange.SetDirection(isLong ? "closebuy" : "closesell");
  
  const orderId = isLong ? 
    exchange.Sell(-1, closeAmount) : 
    exchange.Buy(-1, closeAmount);
  
  if (orderId) {
    Log(`✅ ${coin}：平${isLong ? '多' : '空'}成功，数量=${closeAmount}`);
    _G(`exit_plan_${coin}_USDT.swap`, null);
  }
}

Modul 5: Pemantauan henti untung dan henti rugi

function monitorPosition(coin) {
  exchange.SetCurrency(coin + '_USDT');
  exchange.SetContractType("swap");
  
  const pos = exchange.GetPositions().find(p => 
    p.Symbol.includes(coin) && Math.abs(p.Amount) > 0
  );
  if (!pos) return;
  
  const ticker = exchange.GetTicker();
  if (!ticker) return;
  
  const isLong = pos.Type === PD_LONG || pos.Type === 0;
  const currentPrice = ticker.Last;
  
  // 计算盈亏比例
  const pnl = (currentPrice - pos.Price) * (isLong ? 1 : -1) / pos.Price;
  
  // 获取退出计划
  const exitPlan = _G(`exit_plan_${coin}_USDT.swap`);
  if (!exitPlan?.profit_target || !exitPlan?.stop_loss) {
    // 如果没有设置退出计划，使用默认值
    if (pnl >= 0.03) return closePosition(coin, pos, isLong, "止盈", pnl);
    if (pnl <= -0.01) return closePosition(coin, pos, isLong, "止损", pnl);
    return;
  }
  
  // 检查止盈条件
  const shouldTP = isLong ? 
    currentPrice >= exitPlan.profit_target : 
    currentPrice <= exitPlan.profit_target;
    
  // 检查止损条件
  const shouldSL = isLong ? 
    currentPrice <= exitPlan.stop_loss : 
    currentPrice >= exitPlan.stop_loss;
  
  if (shouldTP) return closePosition(coin, pos, isLong, "止盈", pnl);
  if (shouldSL) return closePosition(coin, pos, isLong, "止损", pnl);
}

function closePosition(coin, pos, isLong, reason, pnl) {
  const precision = getPrecision(coin);
  const closeAmount = _N(Math.abs(pos.Amount), precision.amount);
  
  exchange.SetDirection(isLong ? "closebuy" : "closesell");
  isLong ? exchange.Sell(-1, closeAmount) : exchange.Buy(-1, closeAmount);
  
  Log(`${reason === '止盈' ? '✅' : '❌'} ${coin} ${reason} ${(pnl*100).toFixed(2)}%`);
  _G(`exit_plan_${coin}_USDT.swap`, null);
}

Modul 6: Reka Bentuk Visual

Untuk memudahkan pemahaman tentang logik operasi dagangan AI, analisis isyarat dagangan AI dan status kedudukan divisualisasikan.

---

10. Sorotan Reka Bentuk Utama

1. Kuasa analisis rangka masa berbilang

Sistem ini menggunakan kedua-dua kitaran 3 minit dan 4 jam. Ini bukan sekadar redundansi data mudah:

Senario kes：

• Carta 4 jam menunjukkan bahawa BTC berada dalam aliran menaik (harga melebihi EMA20)
• Penarikan balik berlaku pada carta 3 minit (penurunan harga jangka pendek)
• membuat keputusan：Ini adalah “penarikan balik dalam arah aliran”, peluang untuk meningkatkan kedudukan dan bukannya isyarat risiko

Koordinasi kitaran dua kali：

• Penentuan arah 4 jam (panjang atau pendek)
• Cari pintu masuk dalam masa 3 minit (bila hendak memasuki pasaran)

2. Tiga barisan pertahanan dalam pengurusan risiko

Pertama: Peruntukan Pembiayaan

单笔最大风险 = 账户价值 ÷ 币种数量
最多6个持仓 = 理论最大总风险30%
实际最大风险 < 30%(不会同时触发6个止损)

Langkah kedua: tetapan hentikan kerugian

止损距离 = |入场价 - 止损价| / 入场价
典型设置：2-5%
结合杠杆：10x杠杆下，5%价格波动 = 50%本金波动

Ketiga: Keadaan Gagal

示例："如果价格在3分钟K线上收盘低于$66500"
作用：即使止损没触发，技术形态破坏也要离场

3. Format Output AI Kejuruteraan

Mengapakah format JSON diperlukan?

• Data berstruktur mudah dihuraikan
• Mengelakkan kekaburan dalam bahasa semula jadi
• Memudahkan pengesahan dan pemprosesan automatik

Mengapa menguatkuasakan konsistensi bidang?

• Pastikan semua isyarat mengandungi struktur medan yang sama
• Permudahkan logik kod penghuraian
• Elakkan ralat yang disebabkan oleh medan yang tiada

---

11. Had Sistem dan Arah Penambahbaikan

Had semasa

1. Tidak dapat menangani kecemasan

   • AI hanya melihat penunjuk teknikal dan tidak mempertimbangkan berita atau dasar
   • Tidak dapat mengatasi peristiwa angsa hitam (seperti penggodaman pertukaran)

2. Had kitaran tetap

   • Pencetus 3 minit mungkin terlepas turun naik yang cepat
   • Boleh juga membawa kepada perdagangan berlebihan dalam pasaran yang sunyi

3. Risiko Leverage

   • Leverage 5-40x boleh menyebabkan pembubaran pesat dalam keadaan pasaran yang melampau
   • Walaupun dengan stop loss, gelinciran boleh mengakibatkan kerugian yang tidak dijangka

4. Kestabilan model AI

   • Output model besar adalah rawak
   • Input yang sama boleh membawa kepada keputusan yang berbeza

Arah yang mungkin untuk penambahbaikan

1. Memperkenalkan Analisis Sentimen Berita

   • Sepadukan suapan berita mata wang kripto
   • Menganalisis sentimen pasaran menggunakan NLP

2. Laraskan kekerapan pencetus secara dinamik

   • Tingkatkan kekerapan pemeriksaan semasa turun naik yang tinggi
   • Kurangkan kekerapan apabila turun naik adalah rendah untuk menjimatkan sumber

3. Mekanisme pengundian pelbagai model

   • Jalankan berbilang model AI secara serentak
   • Mengintegrasikan pendapat daripada pelbagai model untuk membuat keputusan

4. Tambah pengesahan ujian belakang

   • Mengesahkan strategi pada data sejarah
   • Optimumkan perkataan dan parameter segera

---

12. Rumusan

Sistem perdagangan kuantitatif AI ini menunjukkan cara menggunakan model bahasa yang besar kepada senario perdagangan kewangan sebenar. Kelebihan terasnya ialah:

1. Reka bentuk modular：Setiap nod mempunyai tanggungjawab yang jelas, mudah diselenggara dan dikembangkan
2. Kawalan risiko yang ketat: Mekanisme perlindungan berbilang lapisan untuk mengelakkan kerugian besar tunggal
3. Integrasi AI Kejuruteraan: Input dan output berstruktur, analisis isyarat yang boleh dipercayai
4. Selesaikan gelung tertutup: Automasi proses penuh daripada pengumpulan data kepada pelaksanaan pesanan

Pengambilan utama：

• AI tidak berkuasa dan memerlukan kekangan dan peraturan yang ketat
• Pengurusan risiko adalah lebih penting daripada ketepatan ramalan
• Kebolehpercayaan sistem adalah lebih penting daripada kerumitan strategi

Saya harap pecahan teknikal terperinci ini dapat membantu anda memahami logik operasi perdagangan kuantitatif AI dan membuat keputusan yang lebih termaklum dalam amalan anda sendiri.

---

Lampiran: Kod Sumber dan Sumber Lengkap

Kod sumber lengkap dan rekod masa nyata：

• Platform Kuantitatif Pencipta: https://www.fmz.com/strategy/512685
• Alamat Dagangan Langsung: https://www.fmz.com/robot/623016
• Anda boleh menggantikan model AI yang berbeza, melaraskan perkataan segera dan memilih mata wang transaksi

Petunjuk Risiko：

• Artikel ini adalah untuk tujuan pembelajaran teknikal sahaja dan bukan merupakan nasihat pelaburan
• Perdagangan mata wang kripto amat berisiko dan boleh mengakibatkan jumlah kerugian prinsipal
• Sentiasa menguji dengan teliti sebelum menggunakan dana sebenar