[TOC]

कृत्रिम बुद्धिमत्ता (एआई) प्रौद्योगिकी के तीव्र विकास के साथ, इसने कई क्षेत्रों में अत्यंत उच्च दक्षता और रचनात्मकता का प्रदर्शन किया है। एक अत्यधिक तकनीकी क्षेत्र के रूप में, मात्रात्मक व्यापार स्वाभाविक रूप से सक्रिय रूप से एआई के अनुप्रयोग की खोज कर रहा है। हालाँकि, व्यवहार में, हम पाएंगे कि पूर्ण, स्थिर और स्थायी रूप से लाभदायक व्यापारिक रणनीतियों को सीधे उत्पन्न करने के लिए केवल एआई पर निर्भर रहने में अभी भी बड़ी चुनौतियाँ हैं।

विशेष रूप से प्लेटफ़ॉर्म पर नए उपयोगकर्ताओं के लिए, उनके कमजोर प्रोग्रामिंग कौशल के कारण, उनके ट्रेडिंग विचारों को रणनीति कोड में लागू करना मुश्किल है। हालाँकि हम वर्तमान में एआई को अपने विचार बता सकते हैं और उसे रणनीति बनाने दे सकते हैं। हालाँकि, कार्यान्वयन का प्रभाव अपेक्षाओं के अनुरूप नहीं रहा। मैं अक्सर ऐसे उपयोगकर्ताओं से मिलता हूं जो एआई-जनरेटेड कोड के साथ प्रश्न पूछने आते हैं, और कभी-कभी मैं एआई-जनरेटेड रणनीतियों को एक नज़र में देख सकता हूं। क्योंकि इस स्तर पर एआई द्वारा उत्पन्न रणनीति कोड के साथ अभी भी कई समस्याएं हैं, इस तरह से एआई का उपयोग करने से न केवल किसी भी समस्या का समाधान नहीं होता है, बल्कि नौसिखियों के लिए अधिक भ्रम और समस्याएं भी आती हैं। जितना अधिक मैंने सीखा, उतना ही अधिक मैं भ्रमित होता गया, और अंततः मैंने “शुरूआत करना छोड़ दिया”।

मैं व्यक्तिगत रूप से सोचता हूं कि एआई प्रत्यक्ष आउटपुट रणनीतियों के साथ वर्तमान समस्याओं के दो मुख्य कारण हैं:

• प्रत्येक व्यक्ति की रणनीतिक आवश्यकताओं के विवरण का तर्क, सटीकता और प्रक्रिया स्पष्टता बहुत भिन्न होती है, और इन प्राकृतिक भाषाओं के बारे में एआई मॉडल की समझ पक्षपाती होगी।
• एआई बड़े मॉडल में प्लेटफ़ॉर्म के फ़ंक्शन, एपीआई आदि की सीमित समझ होती है, क्योंकि सामान्य मॉडल को प्लेटफ़ॉर्म की जानकारी पर प्रशिक्षित नहीं किया जाता है, और उत्पन्न जानकारी की सटीकता सीमित होती है।

तो क्या अन्य अधिक कुशल अनुप्रयोग विधियां हैं? यह लेख सोचने का एक नया तरीका साझा करना चाहता है: एआई हमें मौजूदा रणनीतियों को सीखने, रणनीति डिजाइन को समझने, प्रमुख विवरण और तकनीकों को निकालने, और उनकी प्रभावशीलता और सुधार की गुंजाइश का विश्लेषण करने में मदद करे। यह विधि न केवल हमें रणनीति डिजाइन के सार को अधिक तेज़ी से समझने में मदद कर सकती है, बल्कि हमारे मात्रात्मक व्यापार स्तर को भी व्यवस्थित रूप से सुधार सकती है।

एआई का लाभ उठाते हुए, एआई को विशिष्ट कोड विश्लेषण की अपेक्षाकृत सटीक समझ हो सकती है, क्योंकि एआई के लिए, कोड डेटा “1 1 है, 2 2 है” और प्राकृतिक भाषा विवरण आवश्यकताओं के कारण कोई तार्किक भ्रम, अस्पष्टता या अन्य समस्याएं नहीं होंगी। तो क्यों न एआई के लाभों का उपयोग करके मैनुअल कार्यभार को कम किया जाए और मैनुअल श्रम के लाभों को पूरी तरह से भुनाया जाए।

रिवर्स लर्न रणनीतियों के लिए एआई का उपयोग कैसे करें?

इसे निम्नलिखित चरणों में विभाजित किया जा सकता है:

• किसी मौजूदा रणनीति का चयन करें यह स्वयं लिखित, खुला स्रोत या आविष्कारक के मात्रात्मक मंच पर एक उत्कृष्ट रणनीति नमूना हो सकता है।

• एआई हमें रणनीति समझाने में मदद करे

समग्र विचार को समझें

प्रत्येक भाग के कार्यात्मक मॉड्यूल को छांटें

उपयोग किए गए संकेतक, पैरामीटर और ट्रेडिंग तर्क को स्पष्ट करें

• रणनीति के पक्ष और विपक्ष का विश्लेषण करने के लिए AI को मार्गदर्शन देने के लिए आगे प्रश्न पूछें

कौन सी बाजार स्थितियों में यह रणनीति बेहतर प्रदर्शन करती है?

संभावित जोखिम बिंदु क्या हैं?

किन क्षेत्रों में अनुकूलन एवं सुधार किया जा सकता है?

• अपनी सोच के आधार पर सत्यापित करें और समायोजित करें

विभिन्न उत्पादों और अवधियों पर बैकटेस्टिंग

अतिरिक्त फ़िल्टर या जोखिम नियंत्रण उपाय जोड़ें

प्रदर्शन में होने वाले बदलावों का अवलोकन करें और अपनी स्वयं की अंतर्दृष्टि बनाएं

अभ्यास

आइए हम एआई को एक रणनीति सीखने दें और इसे हमें समझाएं ताकि हम देख सकें कि क्या यह हमारी अपेक्षाओं को पूरा करती है। इससे हमें परिमाणीकरण सीखने में मदद मिल सकती है।

पॉलिसी नमूना

ईएमए ट्रेंड फ़िल्टरिंग के आधार पर चरण-दर-चरण स्थिति-बढ़ाने वाली ट्रेडिंग रणनीति का डिज़ाइन और कार्यान्वयन रणनीति पता: https://www.fmz.com/strategy/492116

/*backtest
start: 2024-10-01 00:00:00
end: 2025-04-23 00:00:00
period: 1h
basePeriod: 1m
exchanges: [{"eid":"Futures_Binance","currency":"ETH_USDT"}]
args: [["targetProfit",20],["amount",20],["amountPrecision",3],["isAmountForUSDT",true]]
*/

function getTotalEquity_OKEX_V5() {
    var totalEquity = null 
    var ret = exchange.IO("api", "GET", "/api/v5/account/balance", "ccy=USDT")
    if (ret) {
        try {
            totalEquity = parseFloat(ret.data[0].details[0].eq)
        } catch(e) {
            Log("获取账户总权益失败！")
            return null
        }
    }
    return totalEquity
}

function getTotalEquity_Binance() {
    var totalEquity = null 
    var ret = exchange.GetAccount()
    if (ret) {
        try {
            totalEquity = parseFloat(ret.Info.totalWalletBalance)
        } catch(e) {
            Log("获取账户总权益失败！")
            return null
        }
    }
    return totalEquity
}

function getTotalEquity() {
    var exName = exchange.GetName()
    if (exName == "Futures_OKCoin") {
        return getTotalEquity_OKEX_V5()
    } else if (exName == "Futures_Binance") {
        return getTotalEquity_Binance()
    } else {
        throw "不支持该交易所"
    }
}

function ceilToDecimals(value, decimals) {
    const factor = Math.pow(10, decimals);
    return Math.ceil(value * factor) / factor;
}

function cancelAll() {
    while (1) {
        var orders = _C(exchange.GetOrders)
        if (orders.length == 0) {
            break
        }
        for (var i = 0 ; i < orders.length ; i++) {
            exchange.CancelOrder(orders[i].Id, orders[i])
            Sleep(interval)
        }
        Sleep(interval)
    }
}

function trade(distance, price, amount) {
    var tradeFunc = null 
    if (distance == "buy") {
        tradeFunc = exchange.Buy
    } else if (distance == "sell") {
        tradeFunc = exchange.Sell
    } else if (distance == "closebuy") {
        tradeFunc = exchange.Sell
    } else {
        tradeFunc = exchange.Buy
    }
    exchange.SetDirection(distance)
    return tradeFunc(price, amount)
}

function openLong(price, amount) {
    return trade("buy", price, amount)
}

function openShort(price, amount) {
    return trade("sell", price, amount)
}

function coverLong(price, amount) {
    return trade("closebuy", price, amount)
}

function coverShort(price, amount) {
    return trade("closesell", price, amount)
}

function plotRecords(c, buyOrder, sellOrder, pos) {
    var bars = _C(exchange.GetRecords)
    if (bars.length == 0) {
        return  
    }

    bars.forEach(function(bar, index) {
        c.begin(bar)
        if (index == bars.length - 1) {
            if (buyOrder) {
                c.hline(buyOrder.Price, "buy", "rgba(255, 0, 0, 0.2)", "dotted")
            }
            if (sellOrder) {
                c.hline(sellOrder.Price, "sell", "rgba(0, 255, 0, 0.2)", "dotted")
            }
            if (pos && pos.length == 1) {
                c.hline(pos[0].Price, "pos", "rgba(0, 0, 255, 0.2)", "dashed")
            }
        }
        c.close()
    })
}

var buyOrderId = null
var sellOrderId = null
var logStatusMsgBuff = ""

function main() {
    var exName = exchange.GetName()    
    if (isSimulate && exName == "Futures_OKCoin") {
        exchange.IO("simulate", true)
    }

    if (isReset) {
        _G(null)
        LogReset(1)
        LogProfitReset()
        LogVacuum()
        Log("重置所有数据", "#FF0000")
    }

    exchange.SetContractType(contractType)
    exchange.SetPrecision(pricePrecision, amountPrecision)
    Log("设置精度", pricePrecision, amountPrecision)
    exchange.SetMarginLevel(marginLevel)

    if (totalEq == -1 && !IsVirtual()) {
        var recoverTotalEq = _G("totalEq")
        if (!recoverTotalEq) {
            var currTotalEq = getTotalEquity()
            if (currTotalEq) {
                totalEq = currTotalEq
                _G("totalEq", currTotalEq)
            } else {
                throw "获取初始权益失败"
            }
        } else {
            totalEq = recoverTotalEq
        }
    }

    var addCounter = _G("addCounter")
    if (!addCounter) {
        addCounter = 1
        if (setAddCounter != -1) {
            addCounter = setAddCounter
        }
        _G("addCounter", addCounter)
    } else {
        addCounter -= 1
    }

    let c = KLineChart({
        overlay: true
    })
    
    var isLock = false 
    while (true) {
        var ticker = _C(exchange.GetTicker)        
        var pos = _C(exchange.GetPosition)
        if (pos.length > 1) {
            Log(pos)
            throw "同时有多空持仓"
        }

        var r = _C(exchange.GetRecords, 60 * 60)
        var ema = TA.EMA(r, 60)
        if (Math.abs(ticker.Last - ema[ema.length - 2]) / ema[ema.length - 2] > 0.03) {
            cancelAll()
            isLock = true 
        }
        if (Math.abs(ticker.Last - ema[ema.length - 2]) / ema[ema.length - 2] < 0.02) {
            isLock = false 
        }
        if (isLock) {
            LogStatus(_D(), "暂停, 检测阈值：", _N(Math.abs(ticker.Last - ema[ema.length - 2]) / ema[ema.length - 2], 3), logStatusMsgBuff)
            plotRecords(c, null, null, pos)
            Sleep(interval)
            continue 
        }

        var currentAcc = _C(exchange.GetAccount)
        if (currentAcc.Balance < totalEq * reserve) {
            throw "no money, stop"
        }

        if (addCounter > maxAddCounter) {
            LogStatus(_D(), "加仓已达到上限", logStatusMsgBuff)
            if (isMaxAddCounterClear && pos.length >= 1) {
                Log("加仓已达到上限，撤单，清仓")
                cancelAll()
                if (pos[0].Type == PD_LONG) {
                    var coverId = coverLong(-1, pos[0].Amount)
                } else if (pos[0].Type == PD_SHORT) {
                    var coverId = coverShort(-1, pos[0].Amount)
                }
                addCounter = 1
            }
            continue
        }

        if (pos.length == 0) {
            if (!IsVirtual()) {
                var currTotalEq = getTotalEquity()
                if (currTotalEq) {
                    LogProfit(currTotalEq - totalEq, "当前总权益：", currTotalEq)
                }
            }

            var tradeAmountLong = amount
            var tradeAmountShort = amount
            if (isAmountForUSDT) {
                tradeAmountLong = ceilToDecimals(tradeAmountLong * 1.01 / (ticker.Last - targetProfit / 5) / oneCtValue, amountPrecision)
                tradeAmountShort = ceilToDecimals(tradeAmountShort * 1.01 / (ticker.Last + targetProfit / 5) / oneCtValue, amountPrecision)
            }

            buyOrderId = openLong(ticker.Last - targetProfit / 5, tradeAmountLong)
            sellOrderId = openShort(ticker.Last + targetProfit / 5, tradeAmountShort)

            addCounter = 1
            _G("addCounter", addCounter)
        } else if (pos[0].Type == PD_LONG) {
            var n = ratio
            var price = ticker.Last
            var addAmount = isDoubling ? pos[0].Amount : (isAmountForUSDT ? (ceilToDecimals(amount * 1.01 / (price - targetProfit * n) / oneCtValue, amountPrecision)) : amount)
            buyOrderId = openLong(price - targetProfit * n, addAmount)
            sellOrderId = coverLong(pos[0].Price + targetProfit, pos[0].Amount)

            addCounter++
            _G("addCounter", addCounter)
        } else if (pos[0].Type == PD_SHORT) {
            var n = ratio
            var price = ticker.Last
            var addAmount = isDoubling ? pos[0].Amount : (isAmountForUSDT ? (ceilToDecimals(amount * 1.01 / (price + targetProfit * n) / oneCtValue, amountPrecision)) : amount)
            buyOrderId = coverShort(pos[0].Price - targetProfit, pos[0].Amount)
            sellOrderId = openShort(price + targetProfit * n, addAmount)

            addCounter++
            _G("addCounter", addCounter)
        }

        if (!sellOrderId || !buyOrderId) {
            cancelAll()
            buyOrderId = null 
            sellOrderId = null
            continue
        } 

        while (1) { 
            var isFindBuyId = false 
            var isFindSellId = false
            var orders = _C(exchange.GetOrders)
            var buyOrder = null 
            var sellOrder = null 
            for (var i = 0 ; i < orders.length ; i++) {
                if (buyOrderId == orders[i].Id) {
                    isFindBuyId = true 
                    buyOrder = orders[i]
                }
                if (sellOrderId == orders[i].Id) {
                    isFindSellId = true 
                    sellOrder = orders[i]
                }               
            }
            if (!isFindSellId && !isFindBuyId) {    
                cancelAll()
                break
            } else if (!isFindBuyId) {   
                Log("买单成交")
                cancelAll()
                break
            } else if (!isFindSellId) {  
                Log("卖单成交")
                cancelAll()
                break
            }

            var acc = _C(exchange.GetAccount)
            var tbl = {"type": "table", "title": "data", "cols": ["data", "symbol", "type", "price", "amount"], "rows": []}
            if (buyOrder) {
                tbl.rows.push(["订单", buyOrder.Symbol, buyOrder.Type == ORDER_TYPE_BUY ? "买入" : "卖出", buyOrder.Price, buyOrder.Amount])
            }
            if (sellOrder) {
                tbl.rows.push(["订单", sellOrder.Symbol, sellOrder.Type == ORDER_TYPE_BUY ? "买入" : "卖出", sellOrder.Price, sellOrder.Amount])
            }
            if (pos && pos.length == 1) {
                tbl.rows.push(["持仓", pos[0].Symbol, pos[0].Type == PD_LONG ? "多" : "空", pos[0].Price, pos[0].Amount])
            }

            logStatusMsgBuff = "当前权益：" + acc.Equity + ", 初始权益：" + totalEq + (!IsVirtual() ? ", 浮动盈亏：" + (acc.Equity - totalEq) : "") + ", 加仓次数：" + addCounter + "\n`" + JSON.stringify(tbl) + "`"
            LogStatus(_D(), "当前权益：", acc.Equity, ", 初始权益：", totalEq, !IsVirtual() ? ", 浮动盈亏：" + (acc.Equity - totalEq) : "", ", 加仓次数：" + addCounter, "\n`" + JSON.stringify(tbl) + "`")

            plotRecords(c, buyOrder, sellOrder, pos)            
            Sleep(interval)
        }
        Sleep(interval)
    }
}

function onexit() {
    Log("扫尾，撤销所有挂单")
    cancelAll()
}

एफएमजेड प्लेटफॉर्म के नए छात्रों के लिए, कोडों का इतना ढेर देखकर आप असमंजस में पड़ सकते हैं। कोड को लाइन दर लाइन अध्ययन करने के बजाय, हम (आलसी होकर) इसे AI के पास डाल सकते हैं, AI को इसे हमें समझाने दें, और सीखने की दक्षता में सुधार करें।

एआई स्पष्टीकरण

मैं यहां GPT का उपयोग कर रहा हूं, और निम्नलिखित सामग्री AI द्वारा समझाई गई है:

• एक संक्षिप्त विवरण यह लेख ईएमए (एक्सपोनेंशियल मूविंग एवरेज) ट्रेंड फ़िल्टरिंग पर आधारित चरण-दर-चरण स्थिति-बढ़ाने वाली ट्रेडिंग रणनीति का परिचय देगा। यह रणनीति मुख्य रूप से बिनेंस फ्यूचर्स (Futures_Binance) पर उपयोग की जाती है, 1-घंटे के बैकटेस्टिंग का समर्थन करती है, और 1-मिनट के के-लाइन डेटा एकत्रीकरण पर आधारित है। मूल्य और ईएमए के बीच विचलन की वास्तविक समय निगरानी के द्वारा, रणनीति गतिशील रूप से ट्रेडिंग मोड (सामान्य ट्रेडिंग/निलंबित ट्रेडिंग) को स्विच करती है, स्थिर बाजार में धीरे-धीरे स्थिति बढ़ाती है, और जोखिमों से बचने के लिए असामान्य उतार-चढ़ाव में स्थिति को स्वचालित रूप से निलंबित कर देती है।

• 1. रणनीति तर्क
  • 1. प्रवृत्ति फ़िल्टरिंग (लॉक स्थिति नियंत्रण) सबसे हाल के घंटे के कैंडलस्टिक डेटा के 60-अवधि ईएमए की गणना करें। जब वर्तमान मूल्य ईएमए से 3% से अधिक विचलित हो जाए, तो ऑर्डर देना स्थगित कर दें और लंबित ऑर्डर रद्द कर दें। जब विचलन 2% के भीतर आ जाएगा, तो सामान्य व्यापार पुनः शुरू हो जाएगा। प्रवृत्ति फ़िल्टरिंग के माध्यम से, आप अशांत बाजार स्थितियों में पदों की लगातार वृद्धि के कारण होने वाले परिसमापन के जोखिम से बच सकते हैं।
  • 1. पदों को जोड़ने का तर्क (धीरे-धीरे पदों को जोड़ना) जब शुरू में कोई स्थिति नहीं होती है, तो दो लंबित ऑर्डर, एक कम खरीद ऑर्डर और एक उच्च बिक्री ऑर्डर, एक ही समय में रखे जाते हैं। ऑर्डर मूल्य: खरीद आदेश वर्तमान मूल्य से नीचे रखा गया है (targetProfit/5 दूरी) विक्रय आदेश वर्तमान मूल्य से ऊपर रखा गया है (targetProfit/5 दूरी) यदि लंबित आदेश निष्पादित किया जाता है, तो स्थिति में चरण-दर-चरण वृद्धि की जाएगी: यदि खरीद आदेश निष्पादित हो जाता है, तो अगले खरीद आदेश को कम कीमत पर रखना जारी रखें और मौजूदा स्थिति के लिए बिक्री रोक-लाभ आदेश निर्धारित करें। यदि विक्रय आदेश निष्पादित हो जाता है, तो अगले विक्रय आदेश को उच्चतर मूल्य पर रखना जारी रखें तथा मौजूदा स्थिति के लिए खरीद रोक-लाभ आदेश निर्धारित करें। जोड़े गए पदों की मात्रा को दोगुना या एक निश्चित राशि पर सेट किया जा सकता है। जब स्थिति परिवर्धन की संख्या maxAddCounter तक पहुंच जाती है, तो रणनीति परिसमापन को बाध्य करने का विकल्प चुन सकती है।
  • 1. स्थिति नियंत्रण और पूंजी संरक्षण प्रारंभिक कुल इक्विटी (totalEq) के आधार पर खोली गई प्रत्येक स्थिति की राशि निर्धारित करें। USDT राशि द्वारा अनुबंधों की संख्या का अनुमान लगाने में सहायता (अंतर्निहित मूल्य के आधार पर ऑर्डर मात्रा की स्वचालित रूप से गणना)। सुनिश्चित करें कि खाते में शेष राशि एक निश्चित अनुपात (आरक्षित) से अधिक हो। यदि शेष राशि अपर्याप्त है, तो व्यापार बंद कर दें।
• 1. मुख्य कार्यों और मॉड्यूल का परिचय
  • 1. कुल खाता इक्विटी प्राप्त करें getTotalEquity फ़ंक्शन को बायनेन्स फ्यूचर्स (Futures_Binance) और OKEX V5 (Futures_OKCoin) के लिए एनकैप्सुलेट किया गया है। विभिन्न एक्सचेंजों के API अंतरों के साथ संगत, खाते की वर्तमान कुल परिसंपत्तियों (USDT में नामित) को समान रूप से लौटाता है।
  • 1. ऑर्डर प्लेसमेंट और रद्दीकरण मॉड्यूल व्यापार (दिशा, मूल्य, राशि): एक एकीकृत आदेश इंटरफ़ेस को समाहित करता है। cancelAll(): बहुत अधिक लंबित ऑर्डर के कारण जोखिम संचय को रोकने के लिए सभी लंबित ऑर्डर रद्द करें।
  • 1. लॉन्ग ओपनिंग, शॉर्ट ओपनिंग और क्लोजिंग पोजीशन openLong(मूल्य, राशि): लंबा खोलें. openShort(मूल्य, राशि): एक छोटी स्थिति खोलें। कवरलांग(मूल्य, राशि): लंबे समय के करीब। कवरशॉर्ट(मूल्य, राशि): रिक्त.
  • 1. जोड़े गए पदों की संख्या और स्थिति रिकॉर्ड प्रयोग_G() डिस्कनेक्शन और पुनः आरंभ के बाद स्थिति जोड़ने की स्थिति की हानि से बचने के लिए लगातार स्थिति जोड़ने की संख्या को रिकॉर्ड करता है। वास्तविक समय खाता जानकारी, लंबित ऑर्डर स्थिति और स्थिति जानकारी को गतिशील रूप से प्रदर्शित करने के लिए लॉगस्टेटस का उपयोग करें।
  • 1. चार्ट ड्राइंग दृश्य बैकटेस्टिंग और वास्तविक समय निगरानी में सहायता के लिए खरीद आदेश मूल्य, बिक्री आदेश मूल्य, औसत स्थिति मूल्य आदि जैसी प्रमुख रेखाएं खींचने के लिए KLineChart का उपयोग करें।
• 1. रणनीति फ़्लोचार्ट

  flowchart TD
      开始 --> 初始化参数
      初始化参数 --> 账户余额检查
      账户余额检查 --> 计算EMA
      计算EMA --> 判断是否锁仓
      判断是否锁仓 -->|是| 暂停交易
      判断是否锁仓 -->|否| 正常交易
      正常交易 --> 是否有持仓
      是否有持仓 -->|无| 首次挂单
      是否有持仓 -->|有| 按持仓方向加仓与止盈挂单
      首次挂单 --> 等待成交
      按持仓方向加仓与止盈挂单 --> 等待成交
      等待成交 --> 挂单成交检测
      挂单成交检测 --> 成交后调整
      成交后调整 --> 更新加仓次数
      更新加仓次数 --> 是否超出最大加仓次数
      是否超出最大加仓次数 -->|是| 平仓
      是否超出最大加仓次数 -->|否| 继续交易

• 1. सारांश ईएमए फ़िल्टरिंग पर आधारित यह चरण-दर-चरण स्थिति-वृद्धि रणनीति रिटर्न और जोखिम नियंत्रण दोनों को ध्यान में रखती है, और अस्थिर और कमजोर रूप से अस्थिर बाजार में परिचालन के लिए उपयुक्त है। पदों को जोड़ने और प्रवृत्ति विराम तंत्र के लचीले तरीकों के माध्यम से, परिसमापन की संभावना को प्रभावी ढंग से कम किया जा सकता है और पूंजी उपयोग की दक्षता में सुधार किया जा सकता है। यह बैकटेस्टिंग और वास्तविक ट्रेडिंग दोनों का समर्थन करता है, और इसका मॉड्यूलर डिज़ाइन इसे विस्तारित करना आसान बनाता है। उदाहरण के लिए, यह लक्ष्य लाभ और राशि का गतिशील समायोजन शुरू कर सकता है, या फ़िल्टरिंग प्रभाव को बढ़ाने के लिए अन्य तकनीकी संकेतक जोड़ सकता है।
  • क्या आप चाहते हैं कि मैं आपको कोई उन्नत सुझाव दूं? उदाहरण के लिए: दो-तरफ़ा स्थिति में सुधार कैसे करें (दो-तरफ़ा स्थिति) स्थिति वृद्धि अनुपात को गतिशील रूप से कैसे समायोजित करें जोखिम नियंत्रण स्टॉप-लॉस तर्क को कैसे एम्बेड करें?

स्थानीय प्रश्न/स्पष्टीकरण

जीपीटी प्रश्नों के संबंध में:

निम्नलिखित सामग्री को AI द्वारा समझाया गया है:

इस रणनीति में, प्रवृत्ति फ़िल्टरिंग को इस प्रकार कार्यान्वित किया जाता है:

var ema = TA.EMA(r, 60)
if (Math.abs(ticker.Last - ema[ema.length - 2]) / ema[ema.length - 2] > 0.03) {
    cancelAll()
    isLock = true 
}
if (Math.abs(ticker.Last - ema[ema.length - 2]) / ema[ema.length - 2] < 0.02) {
    isLock = false 
}
if (isLock) {
    LogStatus(_D(), "暂停, 检测阈值：", _N(Math.abs(ticker.Last - ema[ema.length - 2]) / ema[ema.length - 2], 3), logStatusMsgBuff)
    plotRecords(c, null, null, pos)
    Sleep(interval)
    continue 
}

• कोड विश्लेषण ईएमए ट्रेंड फ़िल्टर: TA.EMA(r, 60) का उपयोग पिछले 60 घंटों के लिए घातीय चल औसत (EMA) की गणना करने के लिए किया जाता है। r, exchange.GetRecords द्वारा प्राप्त ऐतिहासिक K-लाइन डेटा है, और प्रत्येक डेटा बिंदु एक घंटे की मूल्य जानकारी का प्रतिनिधित्व करता है। ईएमए सरणी प्रत्येक घंटे के लिए ईएमए मान संग्रहीत करती है।[ema.length - 2] वर्तमान समय बिंदु पर पिछले घंटे के EMA मान का प्रतिनिधित्व करता है।

ट्रेंड लॉक और रिलीज: वर्तमान मूल्य (टिकर.लास्ट) और पिछले घंटे के ईएमए मूल्य के बीच अंतर की तुलना करके, ईएमए से मूल्य के विचलन का प्रतिशत गणना किया जाता है। Math.abs(ticker.Last - ema[ema.length - 2]) / ema[ema.length - 2] पिछले घंटे के ईएमए से वर्तमान मूल्य के प्रतिशत विचलन की गणना करता है। यदि विचलन 3% (> 0.03) से अधिक हो जाता है, तो बाजार की प्रवृत्ति में महत्वपूर्ण परिवर्तन माना जाता है, और सभी लंबित ऑर्डरों को रद्द करने के लिए cancelAll() फ़ंक्शन को कॉल किया जाता है, और isLock को true पर सेट किया जाता है, अर्थात स्थिति लॉक हो जाती है, जिससे आगे व्यापार नहीं हो पाता। यदि मूल्य EMA से 2% से कम (< 0.02) विचलित होता है, तो लॉक स्थिति जारी हो जाती है और isLock को गलत पर सेट कर दिया जाता है।

व्यापार निलंबन: यदि isLock सत्य है (यह दर्शाता है कि स्थिति वर्तमान में लॉक है), तो आगे कोई भी ट्रेडिंग ऑपरेशन नहीं किया जाएगा। प्रोग्राम लॉग रिकॉर्ड आउटपुट करेगा और वर्तमान प्रवृत्ति और स्थिति को दिखाने के लिए चार्ट बनाने हेतु plotRecords() को कॉल करेगा। एक निश्चित समयावधि के लिए रुकने के लिए स्लीप(अंतराल) का उपयोग करें और फिर लूप जारी रखें।

• बैकटेस्टिंग

ऐसा लगता है कि कुछ प्रवृत्तियों को छानकर निकाला जा सकता है। कोड को स्वयं पढ़कर मैंने पाया कि एआई का स्पष्टीकरण बहुत स्पष्ट था, यहां तक ​​कि यदि मैंने स्वयं उसे समझाया होता तो उससे भी अधिक स्पष्ट होता।

संक्षेप

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

मात्रात्मक व्यापार के मार्ग पर, एआई हमारे लिए अत्यंत शक्तिशाली शिक्षण और विकास भागीदार बन सकता है। एक क्लिक से तैयार रणनीति बनाने के लिए AI पर निर्भर रहने के बजाय, AI यह कर सकता है:

• डीप लर्निंग की मौजूदा रणनीतियाँ
• जटिल तर्क को शीघ्रता से समझें
• व्यवस्थित डिजाइन अनुभव
• निरंतर अनुकूलन और नवाचार

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