1. はじめに：AIトレーディング分野への影響

最近、米国のAIラボnof1aiは注目を集める実験を開始しました。6つのトップAIモデル（Claude、DeepSeek、Gemini、GPT-5、Grok、Tongyi Qianwen）にそれぞれ1万ドルの賞金が与えられ、実際の暗号通貨無期限先物市場で競い合いました。これは模擬取引セッションではなく、実際の資金を使った戦いでした。結果は驚くべきものでした。国内AIのDeepSeekが一貫してリードし、GPT-5とGeminiはともに後れを取りました。この競争の最大の価値は、チームが使用した手がかり、データ構造、意思決定プロセスをオープンソース化し、AIベースの定量取引の研究に優れたモデルを提供している点にあります。

この記事では、この公開アーキテクチャに基づいて、AI 定量取引ワークフローの各ノードとロジックを詳細に分析し、AI が実際の市場でどのように取引の決定を下すかを理解できるようにします。

2. 全体アーキテクチャ：知覚・判断・実行の3段階システム

このAI定量取引システムは、古典的な「認識-意思決定-実行」の3段階アーキテクチャを採用しています。ワークフロー全体は複数のコアノードで構成されています。

コアノードの説明：

1. タイマートリガー- システムハートビート（3分ごとにトリガー）
2. パラメータリセット- アカウントステータスの監視とパフォーマンス統計
3. 市場データの取得- 多次元データの取得と指標の計算
4. 位置データの取得- 現在の位置ステータスの追跡
5. データ結合- アカウントと市場情報を統合
6. AIエージェント- コア意思決定エンジン
7. 取引実行- 信号分析と注文処理

各ノードの設計ロジックを1つずつ分析してみましょう。

ノード1: タイミングトリガー

機能的なポジショニング

タイミング トリガーは、システムを定期的に動作させる人間の心拍に似た、ワークフロー全体の開始要因です。

設計上の考慮事項：

• 3分サイクル: データの鮮度とAPI呼び出しの制限のバランスをとる
• 固定間隔: 戦略実行の安定性と予測可能性を確保する

4. ノード2: パラメータリセット（アカウントステータス管理）

機能的なポジショニング

これは、アカウントのさまざまなコア指標の初期化、追跡、計算を担当する重要な状態管理ノードです。

コアコード分析

            javascript
            
            
// 设置币安模拟交易所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)
  }
}];

出力データ構造

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

デザインのハイライト

1. 永続的な状態管理使用する:_G()関数はサイクルをまたがるデータの永続性を実装する
2. ベースラインアンカー: 初期資金を記録するinitmoney利益計算の基礎として
3. パフォーマンスの視覚化通過しましたLogProfit()この機能は、収入をシステムチャートにリアルタイムでフィードバックします。
4. 防御プログラミング: 初回実行時に自動初期化を行い、NULL値エラーを回避します

5. ノード3: 市場データ取得

機能的なポジショニング

これはシステム全体の「目」であり、さまざまな市場データとテクニカル指標の収集、処理、計算を担当します。

コアロジックアーキテクチャ

市場データ収集ノードの機能は、次の 3 つのレベルに分けられます。

レベル1: 通貨リストの解析とループコレクション

            javascript
            
            
// 解析币种列表
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 };

レベル2: 複数期間のKラインデータの取得と指標の計算

            javascript
            
            
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;
  
  // 返回结构化数据...
}

デュアルタイムフレーム戦略：

• 3分間のショートサイクル: 短期的な変動を捉えて、正確なエントリーとエグジットのタイミングを把握
• 4時間サイクル: 一般的なトレンドの方向を決定し、逆トレンドの取引を避ける

このマルチタイムフレーム分析は、プロの定量取引の標準機能であり、AI に「顕微鏡」と「望遠鏡」の両方の視点を提供することに相当します。

レベル3: データ構造化出力

            javascript
            
            
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])
  }
};

テクニカル指標の説明

1. EMA（指数移動平均）

• 機能: トレンドの方向とサポート/レジスタンスレベルを決定する
• 価格はEMA20を上回っている → 短期的には強気
• EMA20がEMA50を上抜け→ゴールデンクロス、買いシグナル

2. MACD（移動平均収束拡散法）

• 機能: モメンタムとトレンドの転換点を決定する
• MACDヒストグラムがマイナスからプラスに転じる → 勢いが強まる
• DIFラインがDEAラインを横切る→ゴールデンクロスシグナル

3. RSI（相対力指数）

• 機能: 買われすぎと売られすぎを判断する
• RSI > 70 → 買われすぎ、引き戻しの可能性あり
• RSI < 30 → 売られ過ぎ、反発の可能性あり

4. ATR（平均真の範囲）

• 機能: 市場のボラティリティを測定し、ストップロス距離を調整する

6. ノード4: 位置データの取得

機能的なポジショニング

位置データ取得ノードは、各通貨の現在の位置状態を追跡し、完全な位置情報を AI に提供する役割を担います。

コアコード（キー部分）

            javascript
            
            
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};

キーデザイン

数量フィールドの重要な役割：

• quantity = null: ポジションなし、AIはポジションを開くことを検討できます
• quantity ≠ null: ポジションがある場合、AIはポジションを保持するか閉じることしかできず、ポジションを増やすことはできない。

この設計により、「ピラミッド化」のリスクが回避され、各通貨に対してアクティブなポジションが 1 つだけになることが保証されます。

7. ノード5: データの結合

機能的なポジショニング

市場データとポジションデータを AI の意思決定に必要な完全なコンテキストに統合します。

ソースコードの実装

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

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

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

シンプルで効率的なデータ統合により、AI 向けの統合データ インターフェイスが提供されます。

ノード6: AIエージェント（コア意思決定エンジン）

機能的なポジショニング

システム全体の中核となるのは、AI意思決定エンジンです。市場と口座に関する完全な情報を受け取り、具体的な取引指示を出力します。

プロンプト語の構造の説明

AI エージェントの意思決定は、次の 2 種類のプロンプトに依存します。

1. システムメッセージ：

• ソース：NOF1ウェブサイトは公開されていない、逆控除の結果に基づいて
• 効果: AIの役割、行動ルール、意思決定の枠組みを定義したもので、AIの「操作マニュアル」に相当する。
• 特徴: 固定で各通話で同じ
• 位置: AIモデルが呼び出されたときにシステムメッセージとして渡される

2. テキストプロンプト：

• ソース：NOF1ウェブサイトが買収を発表
• 効果：AIの「リアルタイム情報入力」に相当する、動的な市場データと口座状況を提供します。
• 特徴：各コールはそれぞれ異なり、最新の市場データとポジション情報が含まれています
• 位置: AIモデルが呼び出されたときにユーザーメッセージとして渡される

この「固定ルール + 動的データ」の二重プロンプトワードアーキテクチャにより、AI は安定した意思決定フレームワークを持ち、リアルタイムの市場状況に基づいて柔軟に対応できるようになります。

システムプロンプトワードの詳細な説明

システム プロンプトは、AI の動作ルールと意思決定フレームワークを定義します。これは、次の 4 つのコア部分に分けられます。

パート1: ハード制約

            python
            
            
## 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")

デザイン哲学：

• 場所の制限：各通貨は一方的なポジションを保持しており、リスク分散を強いられる
• ポジションを追加しない: 「コスト平均化」の罠を避ける
• リスクキャップ: 1回の取引で口座残高の最大5%のリスクが発生します
• リスク・リターン・比率: 少なくとも2:1、つまり利益目標は損切り距離の少なくとも2倍であることを意味します

パート2：意思決定の枠組み

            mylang
            
            
## 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

論理的明瞭さ：

• 「ポジション保有」と「ポジション非保有」を厳密に区別する
• ポジションを持っている場合、「ホールド」または「クローズ」のみを選択できます。
• ポジションがない場合は、「オープン」または「スキップ」のみを選択できます。
• この設計により、AI が論理的に矛盾する命令を生成することが回避されます。

パート3: 出力形式の仕様

            json
            
            
{
  "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"
    }
  }
}

フィールドの説明：

• signal：取引シグナル（エントリー/ホールド/クローズ）
• profit_target：利益確定価格
• stop_loss: ストップロス価格
• invalidation_condition：故障条件（自然言語記述）
• leverage：レバレッジ比率（5～40）
• confidence: この信号に対するAIの信頼度（0-1）
• risk_usd: あなたが取るリスクの量
• justification: 決定の根拠（監査とデバッグ用）

パート4：思考プロセスのガイド

            python
            
            
## 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

この「思考の連鎖」により、AI はまず分析してから出力を行うようになり、意思決定の安定性と説明可能性が向上します。

ユーザープロンプトワードの詳細な説明（動的データ入力）

ソース：ユーザープロンプトワードはテンプレート構文を使用してリアルタイムデータを動的に挿入します。

ユーザープロンプトは、最新の市場状況とアカウント情報に基づいて、呼び出されるたびに動的に生成されます。

            python
            
            
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) }}

プロンプトワードデータフローの詳細な説明

この設計により、AI は毎回完全な意思決定コンテキストを取得できます。

1. 時間の知覚

   • どれくらい運営されていますか?duringtime分）
   • 現在のタイムスタンプ（$now.toISO()）
   • 通話回数（invoketime二流

2. 市場データ（「市場データ取得」ノードから）

   • 各通貨の3分足および4時間足Kラインデータ
   • 過去10Kラインのテクニカル指標シーケンス
   • 現在の価格、EMA、MACD、RSIなどのリアルタイム指標

3. アカウントステータス（パラメータリセットノードから）

   • トータルリターン（totalReturnPercent）
   • 利用可能資金（availableCash）
   • 口座合計金額（currentAccountValue）

4. ポジションの詳細（「位置データ取得」ノードより）

   • 各通貨で保有されているポジション数（数量フィールド）
   • エントリー価格、現在価格、未実現損益
   • ストッププロフィットとストップロスプラン、リスク額

プロンプトワードのワークフローを完了する

            python
            
            
┌─────────────────────────────────────────────────────────────┐
│                    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..."  │             │
│  │     }                                      │             │
│  │   }                                        │             │
│  │ }                                          │             │
│  └────────────────────────────────────────────┘             │
│                                                              │
└─────────────────────────────────────────────────────────────┘
                         ↓
              传递给"交易执行"节点

このデュアルキュー単語アーキテクチャの利点は次のとおりです。

1. ルールの安定性：システムプロンプトの単語は、AIの行動ルールが常に一貫しているように固定されています。
2. データの適時性：ユーザーのプロンプトワードは動的に更新され、AIが最新の市場情報に基づいて判断を下せるようになります。
3. 関心の分離: ルール定義とデータ入力を分離し、デバッグと最適化を容易にします
4. スケーラビリティ: データフローに影響を与えることなく、いつでもシステムプロンプト単語の最適化戦略を変更できます。
5. 監査可能性: 各AI呼び出しの完全な入力と出力を記録して追跡できます

9. ノード7: トランザクション実行

機能的なポジショニング

これはワークフローの「手」であり、AI の決定を実際の取引注文に変換し、利益確定と損切りの条件を継続的に監視する役割を担っています。

コア実行ロジック

トランザクション実行ノードは、次の 5 つの機能モジュールに分かれています。

モジュール1: 信号解析と検証

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

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)

例外処理：

• JSON解析エラーの検出
• AI出力のマークダウンフォーマットをクリーンアップする
• AI出力形式の問題によるシステム全体のクラッシュを防ぐ

モジュール2: 精度管理と位置計算

            javascript
            
            
// 获取交易对精度信息
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;
}

位置計算式：

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

この計算により次のことが保証されます:

• リスク額は価格に関係なく一定である
• ストップロスが発動すると、損失は設定されたリスク額と全く同じになります。
• 過剰なレバレッジは過剰なポジションにつながらない

モジュール3: ポジションの開設と執行

            javascript
            
            
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);
  }
}

モジュール4: 実行の終了

            javascript
            
            
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);
  }
}

モジュール5: ストッププロフィットとストップロスの監視

            javascript
            
            
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);
}

モジュール6: ビジュアルデザイン

AIトレーディングの動作ロジックを理解しやすくするために、AIトレーディングシグナル分析とポジション状況を可視化します。

10. 主なデザインのハイライト

1. マルチタイムフレーム分析の威力

このシステムは3分周期と4時間周期の両方を採用しています。これは単なるデータ冗長化ではありません。

ケースシナリオ：

• 4時間チャートでは、BTCが上昇トレンドにあることが示されています（価格はEMA20を上回っています）。
• 3分足チャートでプルバックが発生する（短期的な価格下落）
• 意思決定これは「トレンドの反動」であり、リスクシグナルというよりはポジションを増やすチャンスである

二重サイクル調整：

• 4時間足の方向判定（ロングまたはショート）
• 3分でエントリーポイントを見つける（いつ市場に参入するか）

2. リスク管理における3つの防衛線

第一に、資金配分

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

2番目のステップ：損切り設定

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

3番目: 失敗条件

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

3. エンジニアリングAI出力形式

なぜ JSON 形式が必要なのでしょうか?

• 構造化データは解析しやすい
• 自然言語における曖昧さの回避
• 自動検証と処理を容易にする

フィールドの一貫性を強制する理由は何ですか?

• すべての信号に同じフィールド構造が含まれていることを確認する
• 解析コードロジックを簡素化する
• フィールドの欠落によるエラーを回避する

11. システムの制限と改善の方向性

現在の制限

1. 緊急事態に対処できない

   • AIはテクニカル指標のみを見てニュースや政策を考慮しない
   • ブラックスワンイベント（取引所のハッキングなど）に対処できない

2. 固定サイクルの限界

   • 3分トリガーでは急激な変動を見逃す可能性がある
   • 静かな市場では過剰取引につながる可能性もある

3. レバレッジリスク

   • 5～40倍のレバレッジは、極端な市場状況では急速な清算につながる可能性があります。
   • ストップロスを設定しても、スリッページにより予期せぬ損失が発生する可能性があります。

4. AIモデルの安定性

   • 大規模モデルの出力はランダムである
   • 同じ入力が異なる決定につながる可能性がある

改善の可能性のある方向性

1. ニュース感情分析のご紹介

   • 暗号通貨ニュースフィードを統合する
   • NLPを用いた市場センチメントの分析

2. トリガー周波数を動的に調整する

   • ボラティリティが高い時期には検査頻度を増やす
   • 変動が少ない場合は周波数を下げてリソースを節約する

3. マルチモデル投票メカニズム

   • 複数のAIモデルを同時に実行
   • 複数のモデルからの意見を統合して意思決定を行う

4. バックテスト検証を追加する

   • 過去のデータに基づく戦略の検証
   • プロンプト語とパラメータを最適化する

12. 要約

このAI定量取引システムは、大規模言語モデルを実際の金融取引シナリオに適用する方法を実証しています。その主な利点は次のとおりです。

1. モジュール化デザイン：各ノードの責任が明確で、保守や拡張が容易
2. リスクのコントロール: 単一の大きな損失を回避するための多層保護メカニズム
3. エンジニアリングされたAI統合: 構造化された入出力、信頼性の高い信号解析
4. 完全な閉ループ: データ収集から注文実行までの完全なプロセス自動化

重要なポイント：

• AIは万能ではなく、厳格な制約とルールを必要とする
• リスク管理は予測精度よりも重要
• システムの信頼性は戦略の複雑さよりも重要

この詳細な技術的内訳が、AI 定量取引の動作ロジックを理解し、実際の業務でより情報に基づいた意思決定を行うのに役立つことを願っています。

付録: 完全なソースコードとリソース

完全なソースコードとリアルタイム記録：

• 発明者定量プラットフォーム: https://www.fmz.com/strategy/512685
• ライブ取引アドレス: https://www.fmz.com/robot/623016
• さまざまなAIモデルを置き換えたり、プロンプトの単語を調整したり、取引通貨を選択したりできます。

危険性についてのヒント：

• この記事は技術的な学習のみを目的としており、投資アドバイスを構成するものではありません。
• 暗号通貨取引は非常にリスクが高く、元本全額の損失につながる可能性があります。
• 実際の資金を使用する前に必ず徹底的にテストしてください