ianzeng123
2
tập trung vào
319
Người theo dõi
AlphaArena Big Model Battle: Mô phỏng thực tế Hệ thống giao dịch định lượng AI hàng đầu của DeepSeek
Được tạo ra trong: 2025-10-22 14:43:47,
cập nhật trên:
2025-10-23 09:51:54
4
1838
1. Giới thiệu: Ý nghĩa đối với thị trường giao dịch AI
Gần đây, phòng thí nghiệm AI nof1ai của Hoa Kỳ đã khởi động một thử nghiệm nổi bật: sáu mô hình AI hàng đầu (Claude, DeepSeek, Gemini, GPT-5, Grok và Tongyi Qianwen) mỗi mô hình được trao 10.000 đô la để tham gia thị trường hợp đồng tương lai vĩnh viễn tiền điện tử thực tế. Đây không phải là một phiên giao dịch mô phỏng, mà là một cuộc chiến tiền thật. Kết quả thật bất ngờ: AI nội địa DeepSeek liên tục dẫn đầu, trong khi GPT-5 và Gemini đều tụt lại phía sau. Giá trị lớn nhất của cuộc thi này nằm ở việc nhóm đã mã nguồn mở các tín hiệu, cấu trúc dữ liệu và quy trình ra quyết định được sử dụng, cung cấp một mô hình tuyệt vời cho nghiên cứu về giao dịch định lượng dựa trên AI.
Dựa trên kiến trúc công khai này, bài viết này sẽ phân tích chi tiết từng nút và logic của quy trình giao dịch định lượng AI để giúp bạn hiểu cách AI đưa ra quyết định giao dịch trên thị trường thực.
2. Kiến trúc tổng thể: Hệ thống ba giai đoạn Nhận thức-Quyết định-Thực hiện
Hệ thống giao dịch định lượng AI này áp dụng kiến trúc ba giai đoạn kinh điển “nhận thức-quyết định-thực hiện”. Toàn bộ quy trình làm việc bao gồm nhiều nút cốt lõi:
Mô tả nút lõi：
- Bộ kích hoạt hẹn giờ- Nhịp tim hệ thống, kích hoạt mỗi 3 phút
- Đặt lại tham số- Theo dõi trạng thái tài khoản và thống kê hiệu suất
- Thu thập dữ liệu thị trường- Thu thập dữ liệu đa chiều và tính toán chỉ số
- Thu thập dữ liệu vị trí- Theo dõi trạng thái vị trí hiện tại
- Hợp nhất dữ liệu- Tích hợp thông tin tài khoản và thị trường
- Đặc vụ AI- Công cụ quyết định cốt lõi
- Thực hiện giao dịch- Phân tích tín hiệu và xử lý lệnh
Chúng ta hãy phân tích logic thiết kế của từng nút một.
Nút 1: Kích hoạt thời gian
Vị trí chức năng
Bộ kích hoạt thời gian là khởi đầu của toàn bộ quy trình làm việc, tương tự như nhịp tim của con người, giúp hệ thống hoạt động theo định kỳ.
Những cân nhắc về thiết kế：
- chu kỳ 3 phút: Cân bằng độ mới của dữ liệu và hạn chế gọi API
- Khoảng thời gian cố định: Đảm bảo tính ổn định và khả năng dự đoán của việc thực hiện chiến lược
4. Nút 2: Đặt lại tham số (Quản lý trạng thái tài khoản)
Vị trí chức năng
Đây là nút quản lý trạng thái quan trọng, chịu trách nhiệm khởi tạo, theo dõi và tính toán nhiều chỉ số cốt lõi khác nhau của tài khoản.
Phân tích mã lõi
// 设置币安模拟交易所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)
}
}];
Cấu trúc dữ liệu đầu ra
{
"invoketime": 42, // 系统调用次数
"duringtime": 126, // 运行时长(分钟)
"totalReturnPercent": "3.45%", // 总收益率
"availableCash": "10345.67", // 可用资金
"currentAccountValue": "10345.00" // 账户总价值
}
Điểm nổi bật về thiết kế
- Quản lý trạng thái liên tụcSử dụng:
_G()Các hàm thực hiện tính bền vững của dữ liệu trong các chu kỳ - Neo đường cơ sở: Ghi lại số tiền ban đầu
initmoneyLà cơ sở để tính toán lợi nhuận - Hình dung hiệu suấtQuyết định:
LogProfit()Chức năng này cung cấp thu nhập trở lại biểu đồ hệ thống theo thời gian thực - Lập trình phòng thủ: Tự động khởi tạo cho lần chạy đầu tiên để tránh lỗi giá trị null
5. Nút 3: Thu thập dữ liệu thị trường
Vị trí chức năng
Đây là “con mắt” của toàn bộ hệ thống, chịu trách nhiệm thu thập, xử lý và tính toán các dữ liệu thị trường và chỉ số kỹ thuật khác nhau.
Kiến trúc logic cốt lõi
Chức năng của các nút thu thập dữ liệu thị trường có thể được chia thành ba cấp độ:
Cấp độ 1: Phân tích danh sách tiền tệ và thu thập vòng lặp
// 解析币种列表
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 };
Cấp độ 2: Thu thập dữ liệu K-line đa giai đoạn và tính toán chỉ số
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;
// 返回结构化数据...
}
Chiến lược khung thời gian kép：
- Chu kỳ ngắn 3 phút: Nắm bắt những biến động ngắn hạn để có thời điểm vào và ra chính xác
- Chu kỳ dài 4 giờ: Xác định hướng của xu hướng chung và tránh giao dịch ngược xu hướng
Phân tích khung thời gian đa dạng này là một tính năng tiêu chuẩn của giao dịch định lượng chuyên nghiệp, tương đương với việc cung cấp cho AI cả góc nhìn “kính hiển vi” và “kính thiên văn”.
Cấp độ 3: Đầu ra có cấu trúc dữ liệu
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])
}
};
Mô tả chỉ báo kỹ thuật
1. EMA (Đường trung bình động hàm mũ)
- Chức năng: Xác định hướng xu hướng và mức hỗ trợ/kháng cự
- Giá cao hơn EMA20 → tăng giá ngắn hạn
- EMA20 cắt lên trên EMA50 → Golden Cross, tín hiệu mua
2. MACD (Đường trung bình động hội tụ phân kỳ)
- Chức năng: Xác định động lượng và điểm ngoặt xu hướng
- Biểu đồ MACD chuyển từ âm sang dương → động lượng mạnh lên
- Đường DIF cắt đường DEA → Tín hiệu Golden Cross
3. RSI (Chỉ số sức mạnh tương đối)
- Chức năng: đánh giá tình trạng mua quá mức và bán quá mức
- RSI > 70 → Mua quá mức, có thể thoái lui
- RSI < 30 → Quá bán, có thể phục hồi
4. ATR (Phạm vi thực trung bình)
- Chức năng: Đo lường sự biến động của thị trường và điều chỉnh khoảng cách dừng lỗ
6. Nút 4: Thu thập dữ liệu vị trí
Vị trí chức năng
Nút thu thập dữ liệu vị trí có trách nhiệm theo dõi trạng thái vị trí hiện tại của từng loại tiền tệ và cung cấp thông tin vị trí đầy đủ cho AI.
Mã lõi (phần chính)
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};
Thiết kế chính
Vai trò quan trọng của trường số lượng：
quantity = null: Không có vị trí nào, AI có thể xem xét mở vị tríquantity ≠ null: Nếu có vị trí, AI chỉ có thể giữ hoặc đóng vị trí, nhưng không thể tăng vị trí
Thiết kế này tránh được nguy cơ “hình kim tự tháp” và đảm bảo rằng chỉ có một vị thế hoạt động cho mỗi loại tiền tệ.
7. Nút 5: Hợp nhất dữ liệu
Vị trí chức năng
Kết hợp dữ liệu thị trường và vị trí vào bối cảnh hoàn chỉnh cần thiết cho việc ra quyết định của AI.
Triển khai mã nguồn
// 获取输入数据
const inputData = $input.all();
// 第一个输入是市场数据，第二个是持仓数据
const marketData = inputData[0].json.data;
const positions = inputData[1].json;
// 返回整理后的数据
return [{
json: {
marketData: marketData,
positions: positions
}
}];
Việc tích hợp dữ liệu đơn giản và hiệu quả cung cấp giao diện dữ liệu thống nhất cho AI.
Nút 6: Tác nhân AI (Công cụ ra quyết định cốt lõi)
Vị trí chức năng
Đây là cốt lõi của toàn bộ hệ thống - công cụ ra quyết định AI. Nó tiếp nhận thông tin đầy đủ về thị trường và tài khoản, đồng thời đưa ra các hướng dẫn giao dịch cụ thể.
Mô tả cấu trúc từ gợi ý
Việc ra quyết định của tác nhân AI dựa vào hai loại lời nhắc:
1. Thông báo hệ thống：
- nguồn：Trang web NOF1 chưa công bố, dựa trên kết quả khấu trừ ngược
- tác dụng: Xác định vai trò, quy tắc hành vi và khuôn khổ ra quyết định của AI, tương đương với “sổ tay hướng dẫn vận hành” của AI
- Tính năng: Đã sửa và giống nhau cho mỗi cuộc gọi
- Vị trí: Được truyền vào dưới dạng thông báo hệ thống khi mô hình AI được gọi
2. Lời nhắc văn bản：
- nguồn：Trang web NOF1 thông báo về việc mua lại
- tác dụng：Cung cấp dữ liệu thị trường động và trạng thái tài khoản, tương đương với “thông tin đầu vào thời gian thực” của AI
- Tính năng：Mỗi cuộc gọi đều khác nhau, chứa dữ liệu thị trường mới nhất và thông tin vị trí
- Vị trí: Được truyền vào dưới dạng tin nhắn người dùng khi mô hình AI được gọi
Kiến trúc từ ngữ nhắc nhở kép này gồm “quy tắc cố định + dữ liệu động” cho phép AI có khuôn khổ ra quyết định ổn định và đưa ra phản hồi linh hoạt dựa trên điều kiện thị trường theo thời gian thực.
Giải thích chi tiết các từ nhắc nhở của hệ thống
Lời nhắc của hệ thống xác định các quy tắc hành vi và khuôn khổ ra quyết định của AI, có thể được chia thành bốn phần cốt lõi:
Phần 1: Ràng buộc cứng
## 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")
Triết lý thiết kế：
- Hạn chế vị trí：Mỗi loại tiền tệ đều có vị thế một chiều, buộc phải đa dạng hóa rủi ro
- Không thêm vị trí: Tránh bẫy “trung bình hóa chi phí”
- Giới hạn rủi ro: Rủi ro lên đến 5% giá trị tài khoản của bạn trong một giao dịch duy nhất
- Tỷ lệ rủi ro/lợi nhuận: Ít nhất là 2:1, nghĩa là mục tiêu lợi nhuận ít nhất gấp đôi khoảng cách dừng lỗ
Phần 2: Khung ra quyết định
## 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
Sự rõ ràng về mặt logic：
- Phân biệt rõ ràng giữa “giữ vị trí” và “không giữ vị trí”
- Khi bạn có một vị thế, bạn chỉ có thể chọn “Giữ” hoặc “Đóng”
- Khi bạn không có vị trí nào, bạn chỉ có thể chọn “Mở” hoặc “Bỏ qua”
- Thiết kế này giúp AI tránh được việc tạo ra các hướng dẫn mâu thuẫn về mặt logic.
Phần 3: Thông số định dạng đầu ra
{
"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"
}
}
}
Mô tả trường：
signal：Tín hiệu giao dịch (vào lệnh/giữ lệnh/đóng lệnh)profit_target：Giá chốt lờistop_loss: Giá dừng lỗinvalidation_condition：Tình trạng lỗi (mô tả bằng ngôn ngữ tự nhiên)leverage：Tỷ lệ đòn bẩy (5-40)confidence: Sự tin tưởng của AI vào tín hiệu này (0-1)risk_usd: Mức độ rủi ro bạn sẵn sàng chấp nhậnjustification: Cơ sở quyết định (để kiểm tra và gỡ lỗi)
Phần 4: Hướng dẫn quá trình suy nghĩ
## 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
“Chuỗi tư duy” này thúc đẩy AI phân tích trước rồi mới đưa ra kết quả, cải thiện tính ổn định và khả năng giải thích của quá trình ra quyết định.
Giải thích chi tiết các từ nhắc nhở của người dùng (nhập dữ liệu động)
Nguồn：Lời nhắc của người dùng sử dụng cú pháp mẫu để đưa dữ liệu thời gian thực vào một cách linh hoạt.
Lời nhắc của người dùng được tạo động mỗi khi được gọi dựa trên điều kiện thị trường mới nhất và thông tin tài khoản:
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) }}
Giải thích chi tiết về luồng dữ liệu từ nhắc
Thiết kế này cho phép AI có được toàn bộ bối cảnh quyết định mọi lúc:
Nhận thức thời gian
- Nó đã chạy được bao lâu rồi?
duringtimephút) - Dấu thời gian hiện tại (
$now.toISO()） - Số lượng cuộc gọi (
invoketimeHạng hai)
- Nó đã chạy được bao lâu rồi?
Dữ liệu thị trường(từ nút “Thu thập dữ liệu thị trường”)
- Dữ liệu K-line 3 phút và 4 giờ cho mỗi loại tiền tệ
- Chuỗi chỉ báo kỹ thuật của 10 dòng K cuối cùng
- Giá hiện tại, EMA, MACD, RSI và các chỉ báo thời gian thực khác
Trạng thái tài khoản(từ nút Đặt lại tham số)
- Tổng lợi nhuận (
totalReturnPercent） - Quỹ có sẵn (
availableCash） - Tổng giá trị tài khoản (
currentAccountValue）
- Tổng lợi nhuận (
Chi tiết vị trí(Từ nút “Thu thập dữ liệu vị trí”)
- Số lượng vị thế được nắm giữ trong mỗi loại tiền tệ (trường số lượng)
- Giá nhập, giá hiện tại, lãi lỗ chưa thực hiện
- Kế hoạch dừng lợi nhuận và dừng lỗ, số tiền rủi ro
Hoàn thành quy trình làm việc với từ gợi ý
┌─────────────────────────────────────────────────────────────┐
│ 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..." │ │
│ │ } │ │
│ │ } │ │
│ │ } │ │
│ └────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────┘
↓
传递给"交易执行"节点
Ưu điểm của kiến trúc từ ngữ kép này là:
- Sự ổn định của quy tắc：Các từ nhắc nhở của hệ thống được cố định để đảm bảo các quy tắc hành vi của AI luôn nhất quán
- Tính kịp thời của dữ liệu：Các từ gợi ý của người dùng được cập nhật động để đảm bảo AI đưa ra quyết định dựa trên thị trường mới nhất
- Phân tách mối quan tâm: Tách biệt định nghĩa quy tắc và dữ liệu đầu vào để dễ dàng gỡ lỗi và tối ưu hóa
- Khả năng mở rộng: Bạn có thể sửa đổi chiến lược tối ưu hóa từ nhắc nhở của hệ thống bất cứ lúc nào mà không ảnh hưởng đến luồng dữ liệu
- Khả năng kiểm toán: Toàn bộ đầu vào và đầu ra của mỗi cuộc gọi AI có thể được ghi lại và theo dõi
9. Nút 7: Thực hiện giao dịch
Vị trí chức năng
Đây là “bàn tay” của quy trình làm việc, chịu trách nhiệm chuyển đổi các quyết định của AI thành các lệnh giao dịch thực tế và liên tục theo dõi các điều kiện chốt lời và dừng lỗ.
Logic thực thi cốt lõi
Nút thực hiện giao dịch được chia thành năm mô-đun chức năng:
Mô-đun 1: Phân tích và xác minh tín hiệu
// ========== 工具函数 ==========
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)
Xử lý ngoại lệ：
- Bắt lỗi phân tích cú pháp JSON
- Dọn dẹp định dạng markdown trong đầu ra AI
- Ngăn chặn toàn bộ hệ thống bị sập do sự cố định dạng đầu ra AI
Mô-đun 2: Quản lý độ chính xác và tính toán vị trí
// 获取交易对精度信息
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;
}
Công thức tính vị trí：
风险距离 = |入场价格 - 止损价格|
仓位大小 = 风险金额 ÷ 风险距离
最大仓位 = (账户余额 × 杠杆 ÷ 6) ÷ 入场价格
最终仓位 = min(仓位大小, 最大仓位)
Tính toán này đảm bảo rằng:
- Số tiền có nguy cơ vẫn không đổi bất kể giá cả
- Khi lệnh dừng lỗ được kích hoạt, mức lỗ chính xác là số tiền rủi ro được đặt trước
- Không có đòn bẩy quá mức dẫn đến vị thế quá mức
Mô-đun 3: Mở và thực hiện vị thế
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);
}
}
Mô-đun 4: Đóng thực thi
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);
}
}
Mô-đun 5: Theo dõi dừng lỗ và dừng lãi
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);
}
Mô-đun 6: Thiết kế trực quan
Để giúp hiểu rõ hơn về logic hoạt động giao dịch của AI, phân tích tín hiệu giao dịch AI và trạng thái vị thế được trực quan hóa.
10. Điểm nổi bật chính của thiết kế
1. Sức mạnh của phân tích nhiều khung thời gian
Hệ thống sử dụng cả chu kỳ 3 phút và 4 giờ. Đây không chỉ là sự dư thừa dữ liệu đơn thuần:
Tình huống giả định：
- Biểu đồ 4 giờ cho thấy BTC đang trong xu hướng tăng (giá nằm trên EMA20)
- Sự thoái lui xảy ra trên biểu đồ 3 phút (giá giảm ngắn hạn)
- ra quyết định：Đây là một “sự thoái lui trong xu hướng”, một cơ hội để tăng vị thế hơn là một tín hiệu rủi ro
Phối hợp chu kỳ kép：
- Xác định hướng 4 giờ (dài hay ngắn)
- Tìm điểm vào trong 3 phút (thời điểm vào thị trường)
2. Ba tuyến phòng thủ trong quản lý rủi ro
Đầu tiên: Phân bổ tài trợ
单笔最大风险 = 账户价值 ÷ 币种数量
最多6个持仓 = 理论最大总风险30%
实际最大风险 < 30%(不会同时触发6个止损)
Bước thứ hai: thiết lập lệnh dừng lỗ
止损距离 = |入场价 - 止损价| / 入场价
典型设置：2-5%
结合杠杆：10x杠杆下，5%价格波动 = 50%本金波动
Thứ ba: Tình trạng hỏng hóc
示例："如果价格在3分钟K线上收盘低于$66500"
作用：即使止损没触发，技术形态破坏也要离场
3. Định dạng đầu ra của AI kỹ thuật
Tại sao cần phải sử dụng định dạng JSON?
- Dữ liệu có cấu trúc dễ phân tích
- Tránh sự mơ hồ trong ngôn ngữ tự nhiên
- Tạo điều kiện cho việc xác minh và xử lý tự động
Tại sao phải áp dụng tính nhất quán của trường?
- Đảm bảo tất cả các tín hiệu đều có cùng cấu trúc trường
- Đơn giản hóa việc phân tích logic mã
- Tránh lỗi do thiếu trường
11. Hạn chế của hệ thống và hướng cải tiến
Những hạn chế hiện tại
Không thể xử lý các trường hợp khẩn cấp
- AI chỉ xem xét các chỉ số kỹ thuật và không xem xét tin tức hoặc chính sách
- Không thể đối phó với các sự kiện thiên nga đen (chẳng hạn như hack sàn giao dịch)
Hạn chế của chu kỳ cố định
- Bộ kích hoạt 3 phút có thể bỏ lỡ những biến động nhanh
- Cũng có thể dẫn đến giao dịch quá mức trong thị trường yên tĩnh
Rủi ro đòn bẩy
- Đòn bẩy 5-40 lần có thể dẫn đến thanh lý nhanh chóng trong điều kiện thị trường khắc nghiệt
- Ngay cả khi có lệnh dừng lỗ, trượt giá vẫn có thể dẫn đến thua lỗ bất ngờ
Tính ổn định của các mô hình AI
- Đầu ra của các mô hình lớn là ngẫu nhiên
- Cùng một đầu vào có thể dẫn đến những quyết định khác nhau
Các hướng có thể cải thiện
Giới thiệu Phân tích tình cảm tin tức
- Tích hợp nguồn cấp tin tức tiền điện tử
- Phân tích tâm lý thị trường bằng NLP
Điều chỉnh tần số kích hoạt một cách linh hoạt
- Tăng tần suất kiểm tra trong thời gian biến động cao
- Giảm tần suất khi dao động thấp để tiết kiệm tài nguyên
Cơ chế bỏ phiếu đa mô hình
- Chạy nhiều mô hình AI cùng lúc
- Tổng hợp ý kiến từ nhiều mô hình để đưa ra quyết định
Thêm xác minh kiểm tra ngược
- Xác thực các chiến lược trên dữ liệu lịch sử
- Tối ưu hóa các từ nhắc và tham số
12. Tóm tắt
Hệ thống giao dịch định lượng AI này minh họa cách áp dụng các mô hình ngôn ngữ lớn vào các tình huống giao dịch tài chính thực tế. Những ưu điểm cốt lõi của nó là:
- Thiết kế mô-đun：Mỗi nút có trách nhiệm rõ ràng, dễ bảo trì và mở rộng
- Kiểm soát rủi ro nghiêm ngặt: Cơ chế bảo vệ nhiều lớp để tránh những tổn thất lớn đơn lẻ
- Tích hợp AI được thiết kế: Đầu vào và đầu ra có cấu trúc, phân tích tín hiệu đáng tin cậy
- Vòng lặp khép kín hoàn chỉnh: Tự động hóa toàn bộ quy trình từ thu thập dữ liệu đến thực hiện đơn hàng
Những điểm chính cần ghi nhớ：
- AI không phải là toàn năng và đòi hỏi những ràng buộc và quy tắc nghiêm ngặt
- Quản lý rủi ro quan trọng hơn độ chính xác của dự báo
- Độ tin cậy của hệ thống quan trọng hơn độ phức tạp của chiến lược
Tôi hy vọng bản phân tích kỹ thuật chi tiết này có thể giúp bạn hiểu được logic vận hành của giao dịch định lượng AI và đưa ra quyết định sáng suốt hơn trong hoạt động thực tế của mình.
Phụ lục: Mã nguồn và tài nguyên đầy đủ
Mã nguồn hoàn chỉnh và hồ sơ thời gian thực：
- Nền tảng định lượng Inventor: https://www.fmz.com/strategy/512685
- Địa chỉ giao dịch trực tiếp: https://www.fmz.com/robot/623016
- Bạn có thể thay thế các mô hình AI khác nhau, điều chỉnh các từ nhắc và chọn loại tiền giao dịch
Dấu hiệu nguy cơ：
- Bài viết này chỉ dành cho mục đích học tập kỹ thuật và không cấu thành lời khuyên đầu tư
- Giao dịch tiền điện tử cực kỳ rủi ro và có thể dẫn đến mất toàn bộ tiền gốc
- Luôn kiểm tra kỹ lưỡng trước khi sử dụng tiền thật