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

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

यहाँ पता हैःhttps://www.fmz.com/digest-topic/4187औरhttps://www.fmz.com/digest-topic/4169 这两篇文章.

अनुसंधान वातावरण के बारे में

इस ट्यूटोरियल को सभी स्तरों के शौकीनों, इंजीनियरों और डेटा वैज्ञानिकों के लिए डिज़ाइन किया गया है, चाहे आप उद्योग के बुल या प्रोग्रामिंग के छोटे व्यक्ति हों, आपको केवल पायथन प्रोग्रामिंग भाषा के बुनियादी ज्ञान और कमांड लाइन संचालन के बारे में पर्याप्त ज्ञान की आवश्यकता है (एक डेटा विज्ञान परियोजना स्थापित करने के लिए)

• इंस्टॉलर क्वांटिफाइड होस्टिंग स्थापित करें और Anaconda सेट करें

发明者量化平台FMZ.COM除了提供优质的各大主流交易所的数据源，还提供一套丰富的API接口以帮助我们在完成数据的分析后进行自动化交易。这套接口包括查询账户信息，查询各个主流交易所的高，开，低，收价格，成交量，各种常用技术分析指标等实用工具，特别是对于实际交易过程中连接各大主流交易所的公共API接口，提供了强大的技术支持。

इन सभी सुविधाओं को एक Docker-like system में पैक किया जाता है, जिसे हम खरीदते हैं या अपने स्वयं के क्लाउड कंप्यूटिंग सेवा को किराए पर लेते हैं और फिर इसे Docker सिस्टम पर तैनात करते हैं।

आविष्कारकों के लिए क्वांटिफाइड प्लेटफॉर्म के आधिकारिक नाम में, इस डॉकर सिस्टम को होस्टिंग सिस्टम कहा जाता है।

यह एक बहुत ही दिलचस्प और उपयोगी लेख है, लेकिन यह एक बहुत ही दिलचस्प लेख है, और यह एक बहुत ही उपयोगी लेख है।https://www.fmz.com/bbs-topic/4140

जो लोग अपने स्वयं के क्लाउड सर्वर परिनियोजन प्रबंधक खरीदना चाहते हैं, वे इस लेख को देख सकते हैंःhttps://www.fmz.com/bbs-topic/2848

एक बार जब हम एक अच्छी क्लाउड सेवा और व्यवस्थापक प्रणाली को सफलतापूर्वक तैनात कर लेते हैं, तो अब हम पायथन के सबसे बड़े मंदिर को स्थापित करते हैं: एनाकोंडा।

सभी संबंधित प्रोग्रामिंग वातावरणों (निर्भरता पुस्तकालय, संस्करण प्रबंधन, आदि) को लागू करने के लिए सबसे आसान तरीका Anaconda का उपयोग करना है; यह एक पैक किया गया पायथन डेटा विज्ञान पारिस्थितिकी तंत्र और निर्भरता पुस्तकालय प्रबंधक है।

चूंकि हम Anaconda को क्लाउड सर्विस पर इंस्टॉल करते हैं, इसलिए हम क्लाउड सर्वर को लिनक्स सिस्टम के लिए Anaconda के कमांड लाइन संस्करण को इंस्टॉल करने की सलाह देते हैं।

Anaconda को स्थापित करने के तरीके के लिए, कृपया Anaconda के आधिकारिक गाइड देखेंःhttps://www.anaconda.com/distribution/

यदि आप एक अनुभवी पायथन प्रोग्रामर हैं और आपको लगता है कि Anaconda का उपयोग करने की आवश्यकता नहीं है, तो यह बिल्कुल ठीक है। मैं मानता हूं कि आपको आवश्यक निर्भरता वातावरण स्थापित करने में मदद की आवश्यकता नहीं है, आप सीधे इस भाग को छोड़ सकते हैं।

व्यापार रणनीति बनाना

ट्रेडिंग रणनीति का अंतिम आउटपुट निम्नलिखित प्रश्नों का उत्तर देना चाहिएः

• दिशाः यह निर्धारित करें कि क्या संपत्ति सस्ती, महंगी या उचित मूल्य है।

• 开仓条件：如果资产价格便宜或者昂贵，你应该做多或者做空.

• समतल लेनदेनः क्या आपको समतल करना चाहिए यदि संपत्ति का मूल्य उचित है और हम उस संपत्ति में एक स्थिति रखते हैं (पिछली खरीद या बिक्री)

• मूल्य सीमाः शुरुआती व्यापार के लिए मूल्य (या सीमा)

• मात्राः लेन-देन की राशि (उदाहरण के लिए डिजिटल मुद्राओं की संख्या या कमोडिटी वायदा की संख्या)

मशीन लर्निंग का उपयोग उपरोक्त सभी प्रश्नों के उत्तर देने के लिए किया जा सकता है, लेकिन इस लेख के शेष भाग के लिए, हम पहले प्रश्न का उत्तर देने पर ध्यान केंद्रित करेंगे, जो कि व्यापार की दिशा है।

रणनीतिक दृष्टिकोण

रणनीति बनाने के लिए, दो प्रकार के तरीके हैं, एक मॉडल आधारित है; दूसरा डेटा आधारित खनन है। ये दोनों मूल रूप से एक दूसरे के विपरीत तरीके हैं।

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

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

यह स्पष्ट है कि मशीन लर्निंग को डेटा खनन के तरीकों के लिए आसानी से लागू किया जा सकता है। आइए देखें कि मशीन लर्निंग का उपयोग डेटा खनन के माध्यम से लेनदेन संकेत बनाने के लिए कैसे किया जा सकता है।

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

pip install -U scikit-learn

मशीन सीखने का उपयोग करके ट्रेडिंग रणनीति संकेत बनाने के लिए

• डेटा खनन

इससे पहले कि हम शुरू करें, एक मानक मशीन सीखने की समस्या प्रणाली निम्न चित्र में दिखाई गई हैः

मशीन लर्निंग समस्या प्रणाली

हमारे द्वारा बनाए जाने वाले गुणों में कुछ पूर्वानुमान क्षमता होनी चाहिए ((X), हम लक्ष्य चर ((Y) की भविष्यवाणी करना चाहते हैं, और ऐतिहासिक डेटा का उपयोग करके एक एमएल मॉडल को प्रशिक्षित करना चाहते हैं जो Y को वास्तविक मूल्य के रूप में निकटतम अनुमान लगा सकता है। अंत में, हम इस मॉडल का उपयोग Y के लिए अज्ञात नए डेटा के लिए भविष्यवाणी करने के लिए करते हैं। यह हमें पहले चरण की ओर ले जाता हैः

पहला कदमः अपनी समस्याएं सेट करें

• आप क्या भविष्यवाणी करना चाहते हैं? क्या एक अच्छा भविष्यवाणी है? आप भविष्यवाणी के परिणामों का मूल्यांकन कैसे करते हैं?

तो, हमारे ऊपर के फ्रेम में, Y क्या है?

आप क्या भविष्यवाणी करना चाहते हैं?

क्या आप भविष्य की कीमतों, भविष्य के रिटर्न / पीएनएल, खरीद / बिक्री संकेतों, पोर्टफोलियो आवंटन का अनुकूलन करना चाहते हैं और व्यापार को कुशलता से निष्पादित करने का प्रयास करना चाहते हैं?

मान लीजिए कि हम अगले समय पर कीमत का अनुमान लगाने की कोशिश कर रहे हैं. इस मामले में, Y ((t) = कीमत ((t + 1) । अब हम अपने फ्रेम को ऐतिहासिक डेटा के साथ पूरा कर सकते हैं।

ध्यान दें कि Y (t) केवल पुनरावृत्ति में जाना जाता है, लेकिन जब हम अपने मॉडल का उपयोग करते हैं, तो हम समय t का मूल्य नहीं जानते हैं ((t + 1) । हम अपने मॉडल का उपयोग Y (t) की भविष्यवाणी करने के लिए करते हैं और केवल समय t + 1 में इसे वास्तविक मूल्य से तुलना करते हैं। इसका मतलब है कि आप Y को भविष्यवाणी मॉडल में एक विशेषता के रूप में उपयोग नहीं कर सकते हैं।

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

एमएल फ्रेमवर्क का उपयोग भविष्य की कीमतों का अनुमान लगाने के लिए किया जाता है

प्रदर्शन के लिए, हम एक पूर्वानुमान मॉडल बनाएंगे जो एक अनुमानित निवेश के लिए भविष्य के अपेक्षित आधार के मूल्य का अनुमान लगाएगा, जिसमेंः

basis = Price of Stock — Price of Future

basis(t)=S(t)−F(t)

Y(t) = future expected value of basis = Average(basis(t+1),basis(t+2),basis(t+3),basis(t+4),basis(t+5))

चूंकि यह एक प्रतिगमन समस्या है, इसलिए हम मॉडल का मूल्यांकन RMSE (समान वर्गमूल त्रुटि) पर करेंगे। हम कुल Pnl का उपयोग भी मूल्यांकन मानदंड के रूप में करेंगे

ध्यान देंः आरएमएसई के बारे में संबंधित गणित ज्ञान के लिए, कृपया संबंधित सामग्री देखें।

• 我们的目标：创建一个模型，使预测值尽可能接近Y.

दूसरा कदमः विश्वसनीय डेटा एकत्र करना

डेटा इकट्ठा करें और साफ करें जो आपके पास मौजूद समस्याओं को हल करने में मदद कर सकता है

यदि हम कीमत का अनुमान लगाते हैं, तो आप निवेश के मूल्य डेटा, निवेश के लेनदेन के आंकड़े, संबंधित निवेश के समान डेटा, निवेश के सूचकांक की इक्विटी के समग्र बाजार संकेतकों, अन्य संबंधित संपत्ति के मूल्य आदि का उपयोग कर सकते हैं।

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

यदि आप एक आविष्कारक क्वांटिफाइंग प्लेटफॉर्म का उपयोग कर रहे हैं।FMZ.COMहम Google, Yahoo, NSE और Quandl से मुफ्त वैश्विक डेटा तक पहुंच सकते हैं; CTP और EOS जैसे घरेलू वस्तु वायदा के गहन डेटा; Binance, OKEX, Huobi और BitMex जैसे प्रमुख डिजिटल मुद्रा एक्सचेंजों से डेटा। आविष्कारक क्वांटिफिकेशन प्लेटफॉर्म भी इन डेटा को पहले से साफ और फ़िल्टर करता है, जैसे कि निवेशकों के लिए स्प्लिट और गहन ट्रेडिंग डेटा, और रणनीतिक डेवलपर्स को एक प्रारूप में प्रस्तुत करता है जिसे क्वांटिफ़िकेशन कार्यकर्ताओं द्वारा आसानी से समझा जा सकता है।

इस लेख के प्रदर्शन के लिए, हम निम्नलिखित डेटा का उपयोग कर रहे हैं, जो कि एक आभासी निवेश सूचक के रूप में Auquan MQK कंक्रीट है, और हम एक बहुत ही सुविधाजनक माप उपकरण का उपयोग कर रहे हैं, जिसे Auquan कंक्रीट टूलबॉक्स कहा जाता है, अधिक जानकारी के लिए यहां देखेंःhttps://github.com/Auquan/auquan-toolbox-python

# Load the data
from backtester.dataSource.quant_quest_data_source import QuantQuestDataSource
cachedFolderName = '/Users/chandinijain/Auquan/qq2solver-data/historicalData/'
dataSetId = 'trainingData1'
instrumentIds = ['MQK']
ds = QuantQuestDataSource(cachedFolderName=cachedFolderName,
                                    dataSetId=dataSetId,
                                    instrumentIds=instrumentIds)
def loadData(ds):
    data = None
    for key in ds.getBookDataByFeature().keys():
        if data is None:
            data = pd.DataFrame(np.nan, index = ds.getBookDataByFeature()[key].index, columns=[])
        data[key] = ds.getBookDataByFeature()[key]
    data['Stock Price'] =  ds.getBookDataByFeature()['stockTopBidPrice'] + ds.getBookDataByFeature()['stockTopAskPrice'] / 2.0
    data['Future Price'] = ds.getBookDataByFeature()['futureTopBidPrice'] + ds.getBookDataByFeature()['futureTopAskPrice'] / 2.0
    data['Y(Target)'] = ds.getBookDataByFeature()['basis'].shift(-5)
    del data['benchmark_score']
    del data['FairValue']
    return data
data = loadData(ds)

उपरोक्त कोड के माध्यम से, Auquan तालिका उपकरण बॉक्स ने डेटा तालिका शब्दकोश में डेटा डाउनलोड और लोड किया है। अब हमें अपने पसंदीदा प्रारूप में डेटा तैयार करने की आवश्यकता है। फ़ंक्शन ds.getBookDataByFeature () डेटा तालिका के शब्दकोश को वापस करता है, प्रत्येक विशेषता के लिए एक डेटा तालिका। हम सभी विशेषताओं वाले स्टॉक के लिए नए डेटा तालिका बनाते हैं।

तीसरा कदमः डेटा को विभाजित करें

• डेटा से प्रशिक्षण सेट बनाएं, क्रॉस-प्रमाणित करें और इन डेटासेट का परीक्षण करें

यह एक बहुत ही महत्वपूर्ण कदम है!इससे पहले कि हम आगे बढ़ें, हमें अपने मॉडल को प्रशिक्षित करने के लिए डेटा को प्रशिक्षण डेटासेट में विभाजित करना चाहिए; मॉडल के प्रदर्शन का आकलन करने के लिए परीक्षण डेटासेट; यह सुझाव दिया जाता है कि इसे विभाजित किया जाएः 60-70% प्रशिक्षण सेट और 30-40% परीक्षण सेट।

डेटा को प्रशिक्षण और परीक्षण सेट में विभाजित करें

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

डेटा को प्रशिक्षण, सत्यापन और परीक्षण सेट में विभाजित करें

इस दृष्टिकोण में समस्याएं हैं. यदि हम प्रशिक्षण डेटा को बार-बार प्रशिक्षित करते हैं, परीक्षण डेटा के प्रदर्शन का मूल्यांकन करते हैं और हमारे मॉडल को तब तक अनुकूलित करते हैं जब तक कि हम प्रदर्शन से संतुष्ट न हों, तो हम परीक्षण डेटा को प्रशिक्षण डेटा का एक हिस्सा मानते हैं. अंत में, हमारा मॉडल प्रशिक्षण और परीक्षण डेटा के इस सेट पर अच्छा प्रदर्शन कर सकता है, लेकिन यह गारंटी नहीं दे सकता है कि यह नए डेटा को अच्छी तरह से भविष्यवाणी करेगा।

इस समस्या को हल करने के लिए, हम एक अलग सत्यापन डेटासेट बना सकते हैं। अब, आप डेटा को प्रशिक्षित कर सकते हैं, सत्यापन डेटा के प्रदर्शन का मूल्यांकन कर सकते हैं, जब तक आप प्रदर्शन से संतुष्ट न हों तब तक अनुकूलित कर सकते हैं, और अंत में परीक्षण डेटा का परीक्षण कर सकते हैं। इस तरह, परीक्षण डेटा दूषित नहीं होता है, और हम अपने मॉडल को बेहतर बनाने के लिए परीक्षण डेटा में से किसी भी जानकारी का उपयोग नहीं करते हैं।

याद रखें कि परीक्षण डेटा के प्रदर्शन की जांच करने के बाद, मॉडल को और अधिक अनुकूलित करने का प्रयास करने के लिए वापस मत देखो। यदि आप पाते हैं कि आपका मॉडल अच्छा परिणाम नहीं दे रहा है, तो मॉडल को पूरी तरह से छोड़ दें और फिर से शुरू करें। यह सुझाव दिया गया है कि प्रशिक्षण डेटा का 60%, सत्यापन डेटा का 20% और परीक्षण डेटा का 20% हो।

हमारे प्रश्न के लिए, हमारे पास तीन उपलब्ध डेटासेट हैं, हम एक को प्रशिक्षण सेट के रूप में उपयोग करेंगे, दूसरा सत्यापन सेट के रूप में, और तीसरा हमारे परीक्षण सेट के रूप में।

# Training Data
dataSetId =  'trainingData1'
ds_training = QuantQuestDataSource(cachedFolderName=cachedFolderName,
                                    dataSetId=dataSetId,
                                    instrumentIds=instrumentIds)
training_data = loadData(ds_training)
# Validation Data
dataSetId =  'trainingData2'
ds_validation = QuantQuestDataSource(cachedFolderName=cachedFolderName,
                                    dataSetId=dataSetId,
                                    instrumentIds=instrumentIds)
validation_data = loadData(ds_validation)
# Test Data
dataSetId =  'trainingData3'
ds_test = QuantQuestDataSource(cachedFolderName=cachedFolderName,
                                    dataSetId=dataSetId,
                                    instrumentIds=instrumentIds)
out_of_sample_test_data = loadData(ds_test)

इनमे से प्रत्येक के लिए, हम लक्ष्य चर Y जोड़ते हैं, जिसे अगले पांच आधार मानों के औसत के रूप में परिभाषित किया गया है।

def prepareData(data, period):
    data['Y(Target)'] = data['basis'].rolling(period).mean().shift(-period)
    if 'FairValue' in data.columns:
        del data['FairValue']
    data.dropna(inplace=True)
period = 5
prepareData(training_data, period)
prepareData(validation_data, period)
prepareData(out_of_sample_test_data, period)

चौथा कदमः विशेषता निर्माण

डेटा के व्यवहार का विश्लेषण करें और भविष्यवाणी करने योग्य विशेषताएं बनाएं

अब असली इंजीनियरिंग का निर्माण शुरू हो गया है. विशेषता चयन का स्वर्ण नियम यह है कि भविष्यवाणी करने की क्षमता मुख्य रूप से विशेषता से आती है, मॉडल से नहीं. आप पाएंगे कि विशेषता चयन का प्रदर्शन पर मॉडल के चयन से बहुत अधिक प्रभाव पड़ता है. विशेषता चयन के लिए कुछ नोट्सः

• जब तक लक्ष्य चर के साथ संबंध का पता नहीं लगाया जाता है, तब तक किसी भी विशेषता के एक बड़े समूह को यादृच्छिक रूप से न चुनें।

• लक्ष्य चर के साथ बहुत कम या कोई संबंध नहीं है जो अत्यधिक अनुकूलन का कारण बन सकता है

• आपके द्वारा चुने गए लक्षण एक दूसरे के साथ अत्यधिक संबंधित हो सकते हैं, और इस मामले में, कम संख्या में लक्षण भी लक्ष्य का वर्णन कर सकते हैं

• मैं आमतौर पर कुछ सहज ज्ञान युक्त विशेषताएं बनाता हूं, और देखता हूं कि लक्ष्य चर उन विशेषताओं से कैसे संबंधित हैं, और उनके बीच क्या संबंध हैं, यह तय करने के लिए कि कौन सा उपयोग करना है।

• आप उम्मीदवारों के लक्षणों को अधिकतम सूचनात्मक गुणांक (MIC), मुख्य घटक विश्लेषण (PCA) और अन्य तरीकों से क्रमबद्ध करने का भी प्रयास कर सकते हैं।

विशेषता रूपांतरण / मानकीकरणः

एमएल मॉडल अक्सर मानकीकरण के मामले में अच्छा प्रदर्शन करते हैं। हालांकि, समय-श्रृंखला डेटा को संभालते समय, मानकीकरण मुश्किल है क्योंकि भविष्य का डेटा दायरा अज्ञात है। आपका डेटा मानकीकरण के दायरे से बाहर हो सकता है, जिससे मॉडल त्रुटि हो सकती है। लेकिन आप अभी भी कुछ हद तक स्थिरता को मजबूर करने का प्रयास कर सकते हैंः

• स्केलिंगः मानक अंतर या चार अंकों के दायरे के अनुसार विशेषताएं

• निवासः वर्तमान मूल्य से ऐतिहासिक औसत घटाएं

• समेकनः उपरोक्त ((x - mean) / stdev के दो पुनरावर्ती अवधि

• सामान्य समापनः रिवर्स अवधि ((x-min) / ((max-min) के भीतर डेटा को -1 से +1 तक के दायरे में मानकीकृत किया जाता है और केंद्र को फिर से परिभाषित किया जाता है

ध्यान दें कि चूंकि हम ऐतिहासिक निरंतर औसत, मानक विचलन, अधिकतम मूल्य या न्यूनतम मूल्य का उपयोग करते हैं, इसलिए विशेषता के लिए एकीकरण मानकीकरण मूल्य अलग-अलग समय के लिए अलग-अलग वास्तविक मानों को दर्शाएगा। उदाहरण के लिए, यदि विशेषता का वर्तमान मूल्य 5 है, तो निरंतर 30 चक्र औसत 4.5 है, जो बाद में 0.5 में परिवर्तित हो जाएगा। इसके बाद, यदि निरंतर 30 चक्र औसत 3 हो जाता है, तो मूल्य 3.5 हो जाएगा। यह मॉडल त्रुटि का कारण हो सकता है। इसलिए, मानकीकरण मुश्किल है, आपको यह पता लगाना होगा कि वास्तव में मॉडल के प्रदर्शन में क्या सुधार हुआ है (यदि कोई है) ।

हमारी समस्या में पहले पुनरावृत्ति के लिए, हमने मिश्रित पैरामीटर का उपयोग करके बहुत सारे गुण बनाए हैं। हम बाद में यह देखने की कोशिश करेंगे कि क्या हम गुणों की संख्या को कम कर सकते हैं।

def difference(dataDf, period):
    return dataDf.sub(dataDf.shift(period), fill_value=0)
def ewm(dataDf, halflife):
    return dataDf.ewm(halflife=halflife, ignore_na=False,
                      min_periods=0, adjust=True).mean()
def rsi(data, period):
    data_upside = data.sub(data.shift(1), fill_value=0)
    data_downside = data_upside.copy()
    data_downside[data_upside > 0] = 0
    data_upside[data_upside < 0] = 0
    avg_upside = data_upside.rolling(period).mean()
    avg_downside = - data_downside.rolling(period).mean()
    rsi = 100 - (100 * avg_downside / (avg_downside + avg_upside))
    rsi[avg_downside == 0] = 100
    rsi[(avg_downside == 0) & (avg_upside == 0)] = 0
return rsi
def create_features(data):
    basis_X = pd.DataFrame(index = data.index, columns =  [])
    
    basis_X['mom3'] = difference(data['basis'],4)
    basis_X['mom5'] = difference(data['basis'],6)
    basis_X['mom10'] = difference(data['basis'],11)
    
    basis_X['rsi15'] = rsi(data['basis'],15)
    basis_X['rsi10'] = rsi(data['basis'],10)
    
    basis_X['emabasis3'] = ewm(data['basis'],3)
    basis_X['emabasis5'] = ewm(data['basis'],5)
    basis_X['emabasis7'] = ewm(data['basis'],7)
    basis_X['emabasis10'] = ewm(data['basis'],10)
    basis_X['basis'] = data['basis']
    basis_X['vwapbasis'] = data['stockVWAP']-data['futureVWAP']
    
    basis_X['swidth'] = data['stockTopAskPrice'] -
                        data['stockTopBidPrice']
    basis_X['fwidth'] = data['futureTopAskPrice'] -
                        data['futureTopBidPrice']
    
    basis_X['btopask'] = data['stockTopAskPrice'] -
                         data['futureTopAskPrice']
    basis_X['btopbid'] = data['stockTopBidPrice'] -
                         data['futureTopBidPrice']

    basis_X['totalaskvol'] = data['stockTotalAskVol'] -
                             data['futureTotalAskVol']
    basis_X['totalbidvol'] = data['stockTotalBidVol'] -
                             data['futureTotalBidVol']
    
    basis_X['emabasisdi7'] = basis_X['emabasis7'] -
                             basis_X['emabasis5'] + 
                             basis_X['emabasis3']
    
    basis_X = basis_X.fillna(0)
    
    basis_y = data['Y(Target)']
    basis_y.dropna(inplace=True)
    
    print("Any null data in y: %s, X: %s"
            %(basis_y.isnull().values.any(), 
             basis_X.isnull().values.any()))
    print("Length y: %s, X: %s"
            %(len(basis_y.index), len(basis_X.index)))
    
    return basis_X, basis_y
basis_X_train, basis_y_train = create_features(training_data)
basis_X_test, basis_y_test = create_features(validation_data)

चरण 5: मॉडल का चयन

चयनित प्रश्नों के आधार पर उपयुक्त सांख्यिकीय/एमएल मॉडल का चयन करें

मॉडल का चयन इस बात पर निर्भर करता है कि समस्या का निर्माण कैसे किया जाता है. क्या आप एक पर्यवेक्षण (विशेषताओं के मैट्रिक्स में प्रत्येक बिंदु X को लक्ष्य चर Y में मैप किया जाता है) या एक गैर-पर्यवेक्षण सीखने की समस्या का समाधान कर रहे हैं (किसी भी दिए गए मैपिंग के बिना, मॉडल अज्ञात पैटर्न सीखने का प्रयास करता है)? क्या आप एक प्रतिगमन (भविष्य में वास्तविक मूल्य का अनुमान लगाना) या एक वर्गीकरण समस्या का समाधान कर रहे हैं (केवल भविष्य में मूल्य की दिशा का अनुमान लगाना) ।

पर्यवेक्षित या अन पर्यवेक्षित सीखना

वापसी or वर्गीकरण

कुछ सामान्य निगरानी सीखने के एल्गोरिदम हैं जो आपको शुरू करने में मदद कर सकते हैंः

• रैखिक पुनरावृत्ति (परामर्श, पुनरावृत्ति)

• लॉजिस्टिक प्रतिगमन (पैरामीटर, वर्गीकरण)

• K निकटतम पड़ोसी (KNN) एल्गोरिथ्म (उदाहरण आधारित, प्रतिगमन)

• एसवीएम, एसवीआर (पैरामीटर, वर्गीकरण और प्रतिगमन)

• निर्णय का पेड़

• निर्णय वन

मेरा सुझाव है कि आप एक सरल मॉडल से शुरू करें, जैसे कि रैखिक या तार्किक प्रतिगमन, और जहां तक आवश्यक हो, वहां से अधिक जटिल मॉडल का निर्माण करें। मेरा सुझाव है कि आप मॉडल के पीछे के गणित को पढ़ें, न कि इसे अंधाधुंध रूप से ब्लैक बॉक्स के रूप में उपयोग करें।

चरण 6: प्रशिक्षण, सत्यापन और अनुकूलन (चरण 4-6 दोहराएं)

प्रशिक्षण और सत्यापन डेटासेट का उपयोग करके अपने मॉडल को प्रशिक्षित और अनुकूलित करें

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

केवल तब जब आपके पास अपना पसंदीदा मॉडल हो, तो अगले चरण पर जाएं।

हमारे प्रदर्शन के लिए, चलो एक सरल रैखिक प्रतिगमन से शुरू करते हैं।

from sklearn import linear_model
from sklearn.metrics import mean_squared_error, r2_score
def linear_regression(basis_X_train, basis_y_train,
                      basis_X_test,basis_y_test):
    
    regr = linear_model.LinearRegression()
    # Train the model using the training sets
    regr.fit(basis_X_train, basis_y_train)
    # Make predictions using the testing set
    basis_y_pred = regr.predict(basis_X_test)
    # The coefficients
    print('Coefficients: \n', regr.coef_)
    
    # The mean squared error
    print("Mean squared error: %.2f"
          % mean_squared_error(basis_y_test, basis_y_pred))
    
    # Explained variance score: 1 is perfect prediction
    print('Variance score: %.2f' % r2_score(basis_y_test,
                                            basis_y_pred))
    # Plot outputs
    plt.scatter(basis_y_pred, basis_y_test,  color='black')
    plt.plot(basis_y_test, basis_y_test, color='blue', linewidth=3)
    plt.xlabel('Y(actual)')
    plt.ylabel('Y(Predicted)')
    plt.show()
    
    return regr, basis_y_pred
_, basis_y_pred = linear_regression(basis_X_train, basis_y_train, 
                                    basis_X_test,basis_y_test)

बिना एकीकरण के रैखिक प्रतिगमन

('Coefficients: \n', array([ -1.0929e+08, 4.1621e+07, 1.4755e+07, 5.6988e+06, -5.656e+01, -6.18e-04, -8.2541e-05,4.3606e-02, -3.0647e-02, 1.8826e+07, 8.3561e-02, 3.723e-03, -6.2637e-03, 1.8826e+07, 1.8826e+07, 6.4277e-02, 5.7254e-02, 3.3435e-03, 1.6376e-02, -7.3588e-03, -8.1531e-04, -3.9095e-02, 3.1418e-02, 3.3321e-03, -1.3262e-06, -1.3433e+07, 3.5821e+07, 2.6764e+07, -8.0394e+06, -2.2388e+06, -1.7096e+07]))
Mean squared error: 0.02
Variance score: 0.96

मॉडल गुणांक देखें. हम वास्तव में उनकी तुलना नहीं कर सकते हैं या यह नहीं कह सकते कि कौन सा महत्वपूर्ण है, क्योंकि वे सभी अलग-अलग पैमाने पर हैं. आइए उन्हें समान अनुपात में लाने के लिए समेकित करने का प्रयास करें और कुछ स्थिरता भी लागू करें.

def normalize(basis_X, basis_y, period):
    basis_X_norm = (basis_X - basis_X.rolling(period).mean())/
                    basis_X.rolling(period).std()
    basis_X_norm.dropna(inplace=True)
    basis_y_norm = (basis_y - 
                    basis_X['basis'].rolling(period).mean())/
                    basis_X['basis'].rolling(period).std()
    basis_y_norm = basis_y_norm[basis_X_norm.index]
    
    return basis_X_norm, basis_y_norm
norm_period = 375
basis_X_norm_test, basis_y_norm_test = normalize(basis_X_test,basis_y_test, norm_period)
basis_X_norm_train, basis_y_norm_train = normalize(basis_X_train, basis_y_train, norm_period)
regr_norm, basis_y_pred = linear_regression(basis_X_norm_train, basis_y_norm_train, basis_X_norm_test, basis_y_norm_test)
basis_y_pred = basis_y_pred * basis_X_test['basis'].rolling(period).std()[basis_y_norm_test.index] + basis_X_test['basis'].rolling(period).mean()[basis_y_norm_test.index]

एकीकरण की रैखिक वापसी

Mean squared error: 0.05
Variance score: 0.90

यह मॉडल पहले के मॉडल में सुधार नहीं करता है, लेकिन न ही बदतर है। अब हम वास्तव में गुणकों की तुलना कर सकते हैं और देख सकते हैं कि कौन से गुणक वास्तव में मायने रखते हैं।

तो चलो गुणांक देखते हैं.

for i in range(len(basis_X_train.columns)):
    print('%.4f, %s'%(regr_norm.coef_[i], basis_X_train.columns[i]))

परिणामः

19.8727, emabasis4
-9.2015, emabasis5
8.8981, emabasis7
-5.5692, emabasis10
-0.0036, rsi15
-0.0146, rsi10
0.0196, mom10
-0.0035, mom5
-7.9138, basis
0.0062, swidth
0.0117, fwidth
2.0883, btopask
2.0311, btopbid
0.0974, bavgask
0.0611, bavgbid
0.0007, topaskvolratio
0.0113, topbidvolratio
-0.0220, totalaskvolratio
0.0231, totalbidvolratio

हम स्पष्ट रूप से देख सकते हैं कि कुछ लक्षणों में अन्य लक्षणों की तुलना में उच्च गुणक होते हैं और संभवतः अधिक भविष्यवाणी करने में सक्षम होते हैं।

एक बार जब हम अपने जीवन के बारे में बात करते हैं, तो हम अपने जीवन के बारे में बात करते हैं।

import seaborn

c = basis_X_train.corr()
plt.figure(figsize=(10,10))
seaborn.heatmap(c, cmap='RdYlGn_r', mask = (np.abs(c) <= 0.8))
plt.show()

लक्षणों के बीच संबंध

गहरा लाल क्षेत्र अत्यधिक संबंधित चर को दर्शाता है. चलो फिर से कुछ विशेषताएं बनाते हैं / संशोधित करते हैं और हमारे मॉडल को बेहतर बनाने का प्रयास करते हैं.

例如，我可以轻松地丢弃像emabasisdi7这样的特征，这些特征只是其他特征的线性组合.

def create_features_again(data):
    basis_X = pd.DataFrame(index = data.index, columns =  [])
    basis_X['mom10'] = difference(data['basis'],11)
    basis_X['emabasis2'] = ewm(data['basis'],2)
    basis_X['emabasis5'] = ewm(data['basis'],5)
    basis_X['emabasis10'] = ewm(data['basis'],10)
    basis_X['basis'] = data['basis']
    basis_X['totalaskvolratio'] = (data['stockTotalAskVol']
                                 - data['futureTotalAskVol'])/
                                   100000
    basis_X['totalbidvolratio'] = (data['stockTotalBidVol']
                                 - data['futureTotalBidVol'])/
                                   100000
    basis_X = basis_X.fillna(0)
    
    basis_y = data['Y(Target)']
    basis_y.dropna(inplace=True)
    return basis_X, basis_y
basis_X_test, basis_y_test = create_features_again(validation_data)
basis_X_train, basis_y_train = create_features_again(training_data)
_, basis_y_pred = linear_regression(basis_X_train, basis_y_train, basis_X_test,basis_y_test)
basis_y_regr = basis_y_pred.copy()

('Coefficients: ', array([ 0.03246139,
0.49780982, -0.22367172,  0.20275786,  0.50758852,
-0.21510795, 0.17153884]))
Mean squared error: 0.02
Variance score: 0.96

देखिए, हमारे मॉडल के प्रदर्शन में कोई बदलाव नहीं हुआ है, हमें केवल कुछ विशेषताओं की आवश्यकता है जो हमारे लक्ष्य चर को समझाते हैं. मैं सुझाव देता हूं कि आप ऊपर दिए गए विशेषताओं को और अधिक प्रयास करें, नए संयोजनों आदि का प्रयास करें, और देखें कि क्या हमारे मॉडल में सुधार किया जा सकता है.

我们还可以尝试更复杂的模型，看看模型的变化是否可以提高性能.

• के एन एन एल्गोरिथ्म

from sklearn import neighbors
n_neighbors = 5
model = neighbors.KNeighborsRegressor(n_neighbors, weights='distance')
model.fit(basis_X_train, basis_y_train)
basis_y_pred = model.predict(basis_X_test)
basis_y_knn = basis_y_pred.copy()

• एसवीआर

from sklearn.svm import SVR
model = SVR(kernel='rbf', C=1e3, gamma=0.1)
model.fit(basis_X_train, basis_y_train)
basis_y_pred = model.predict(basis_X_test)
basis_y_svr = basis_y_pred.copy()

• निर्णय का पेड़

model=ensemble.ExtraTreesRegressor()
model.fit(basis_X_train, basis_y_train)
basis_y_pred = model.predict(basis_X_test)
basis_y_trees = basis_y_pred.copy()

चरण 7: परीक्षण डेटा का पुनः परीक्षण करें

वास्तविक नमूना डेटा के प्रदर्शन की जांच करें

(अभी तक छुआ नहीं गया) परीक्षण डेटासेट पर पुनः परीक्षण प्रदर्शन

यह एक महत्वपूर्ण क्षण है. हम परीक्षण डेटा के अंतिम चरण से हमारे अंतिम अनुकूलन मॉडल को चलाने के लिए शुरू करते हैं, और हम इसे शुरू से ही एक तरफ रख देते हैं, जो अभी तक डेटा तक नहीं पहुंचा है।

यह आपको वास्तविक उम्मीद देता है कि जब आप वास्तविक समय में व्यापार करना शुरू करते हैं तो आपका मॉडल नए और अनदेखे डेटा पर कैसे निष्पादित होगा; इसलिए यह सुनिश्चित करना आवश्यक है कि आपके पास एक साफ डेटासेट है जिसका उपयोग मॉडल को प्रशिक्षित या सत्यापित करने के लिए नहीं किया जाता है।

यदि आप परीक्षण डेटा के पुनर्मूल्यांकन के परिणामों को पसंद नहीं करते हैं, तो मॉडल को छोड़ दें और फिर से शुरू करें. अपने मॉडल को फिर से अनुकूलित करने के लिए वापस न जाएं, यह अति-अनुकूलन का कारण बन जाएगा! (यह भी एक नया परीक्षण डेटासेट बनाने की सलाह दी जाती है, क्योंकि यह डेटासेट अब दूषित हो गया है; मॉडल को छोड़ने पर, हम पहले से ही डेटासेट के बारे में जान चुके हैं) ।

यहाँ पर हम Auquan के टूलबॉक्स का उपयोग करते हैं।

import backtester
from backtester.features.feature import Feature
from backtester.trading_system import TradingSystem
from backtester.sample_scripts.fair_value_params import FairValueTradingParams
class Problem1Solver():
def getTrainingDataSet(self):
        return "trainingData1"
def getSymbolsToTrade(self):
        return ['MQK']
def getCustomFeatures(self):
        return {'my_custom_feature': MyCustomFeature}
def getFeatureConfigDicts(self):
                            
        expma5dic = {'featureKey': 'emabasis5',
                 'featureId': 'exponential_moving_average',
                 'params': {'period': 5,
                              'featureName': 'basis'}}
        expma10dic = {'featureKey': 'emabasis10',
                 'featureId': 'exponential_moving_average',
                 'params': {'period': 10,
                              'featureName': 'basis'}}                     
        expma2dic = {'featureKey': 'emabasis3',
                 'featureId': 'exponential_moving_average',
                 'params': {'period': 3,
                              'featureName': 'basis'}}
        mom10dic = {'featureKey': 'mom10',
                 'featureId': 'difference',
                 'params': {'period': 11,
                              'featureName': 'basis'}}
        
        return [expma5dic,expma2dic,expma10dic,mom10dic]    
    
    def getFairValue(self, updateNum, time, instrumentManager):
        # holder for all the instrument features
        lbInstF = instrumentManager.getlookbackInstrumentFeatures()
        mom10 = lbInstF.getFeatureDf('mom10').iloc[-1]
        emabasis2 = lbInstF.getFeatureDf('emabasis2').iloc[-1]
        emabasis5 = lbInstF.getFeatureDf('emabasis5').iloc[-1]
        emabasis10 = lbInstF.getFeatureDf('emabasis10').iloc[-1] 
        basis = lbInstF.getFeatureDf('basis').iloc[-1]
        totalaskvol = lbInstF.getFeatureDf('stockTotalAskVol').iloc[-1] - lbInstF.getFeatureDf('futureTotalAskVol').iloc[-1]
        totalbidvol = lbInstF.getFeatureDf('stockTotalBidVol').iloc[-1] - lbInstF.getFeatureDf('futureTotalBidVol').iloc[-1]
        
        coeff = [ 0.03249183, 0.49675487, -0.22289464, 0.2025182, 0.5080227, -0.21557005, 0.17128488]
        newdf['MQK'] = coeff[0] * mom10['MQK'] + coeff[1] * emabasis2['MQK'] +\
                      coeff[2] * emabasis5['MQK'] + coeff[3] * emabasis10['MQK'] +\
                      coeff[4] * basis['MQK'] + coeff[5] * totalaskvol['MQK']+\
                      coeff[6] * totalbidvol['MQK']
                    
        newdf.fillna(emabasis5,inplace=True)
        return newdf
problem1Solver = Problem1Solver()
tsParams = FairValueTradingParams(problem1Solver)
tradingSystem = TradingSystem(tsParams)
tradingSystem.startTrading(onlyAnalyze=False, 
                           shouldPlot=True,
                           makeInstrumentCsvs=False)

पुनरीक्षण परिणाम, Pnl डॉलर में गणना की जाती है (Pnl लेनदेन लागत और अन्य शुल्क को शामिल नहीं करता है)

चरण 8: मॉडल को बेहतर बनाने के अन्य तरीके

स्क्रॉल सत्यापन, समूह सीखना, बैगिंग और बूस्टिंग

अधिक डेटा एकत्र करने, बेहतर विशेषताएं बनाने या अधिक मॉडल का प्रयास करने के अलावा, कुछ और चीजें हैं जिन्हें आप सुधारने की कोशिश कर सकते हैं।

1. रोल-आउट सत्यापन

रोलर सत्यापन

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

जनवरी से फरवरी के प्रशिक्षण, मार्च के सत्यापन, अप्रैल से मई के पुनः प्रशिक्षण, जून के सत्यापन आदि के लिए आगे की ओर रोलिंग सत्यापन का प्रयास करना बेहतर हो सकता है।

2. सामूहिक सीखना

सामूहिक शिक्षा

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

बैगिंग

उत्तेजना

एक संक्षिप्त परिचय के लिए, मैं इन तरीकों को छोड़ दूंगा, लेकिन आप अधिक जानकारी के लिए ऑनलाइन खोज सकते हैं।

तो चलिए हम अपनी समस्या के लिए एक सामूहिक विधि का प्रयास करते हैं।

basis_y_pred_ensemble = (basis_y_trees + basis_y_svr +
                         basis_y_knn + basis_y_regr)/4

Mean squared error: 0.02
Variance score: 0.95

अब तक, हमने बहुत सारे ज्ञान और जानकारी एकत्र की है। आइए एक त्वरित समीक्षा करेंः

• अपनी समस्याओं को हल करें

• विश्वसनीय डेटा एकत्र करना और डेटा को साफ करना

• डेटा को प्रशिक्षण, सत्यापन और परीक्षण सेट में विभाजित करें

• लक्षण बनाने और उनके व्यवहार का विश्लेषण करना

• व्यवहार के आधार पर उपयुक्त प्रशिक्षण मॉडल चुनें

• प्रशिक्षण डेटा का उपयोग करके अपने मॉडल को प्रशिक्षित करें और भविष्यवाणियां करें

• सत्यापन सेट पर प्रदर्शन की जांच करें और फिर से अनुकूलित करें

• परीक्षण सेट के अंतिम प्रदर्शन को सत्यापित करें

बहुत ऊपर की ओर है, है ना? लेकिन यह खत्म नहीं हुआ है, अब आपके पास केवल एक विश्वसनीय पूर्वानुमान मॉडल है. याद रखें कि हम वास्तव में हमारी रणनीति में क्या चाहते हैं? तो आपको अभी तक इसकी आवश्यकता नहीं हैः

• ट्रेडिंग दिशाओं की पहचान करने के लिए पूर्वानुमान मॉडल पर आधारित संकेत विकसित करना

• पट्टे की पहचान के लिए विशिष्ट रणनीतियों का विकास

• पदों और कीमतों की पहचान करने के लिए निष्पादन प्रणाली

ये सभी आविष्कारकों के लिए क्वांटिफाइंग प्लेटफॉर्म हैं।FMZ.COMInventors Quantification Platform में, एक उच्च पैकेजिंग और परिष्कृत एपीआई इंटरफ़ेस है, साथ ही वैश्विक रूप से कॉल करने के लिए नीचे के आदेश और लेनदेन के कार्यों के साथ, आपको अलग-अलग एक्सचेंजों को जोड़ने और जोड़ने के लिए एपीआई इंटरफ़ेस की आवश्यकता नहीं है। Inventors Quantification Platform के रणनीति स्क्वायर में, कई परिपक्व और पूर्ण विकल्प रणनीतियाँ हैं, जो इस लेख के साथ मशीन सीखने के तरीकों के साथ हैं, जो आपकी विशिष्ट रणनीतियों को एक बाघ की तरह पंख देंगे। रणनीति स्क्वायर स्थित हैःhttps://www.fmz.com/square

लेनदेन की लागत के बारे में महत्वपूर्ण जानकारी：你的模型会告诉你所选资产何时是做多或做空。然而，它没有考虑费用/交易成本/可用交易量/止损等。交易成本通常会使有利可图的交易成为亏损。例如，预期价格上涨0.05美元的资产是买入，但如果你必须支付0.10美元进行此交易，你将最终获得净亏损$0.05。在你考虑经纪人佣金，交换费和点差后，我们上面看起来很棒的盈利图实际上是这样的：

लेन-देन शुल्क और बिंदु अंतर के बाद पुनर्मूल्यांकन के परिणाम, Pnl डॉलर में

लेनदेन शुल्क और अंतर हमारे पीएनएल का 90% से अधिक है! हम बाद के लेखों में विस्तार से चर्चा करेंगे।

अंत में, आइए कुछ आम खतरों पर एक नज़र डालें।

क्या करें और क्या न करें

• हरसंभव कोशिश करें कि ज्यादा फिट न हों!

• प्रत्येक डेटा बिंदु के बाद पुनः प्रशिक्षण न करेंः यह एक आम गलती है जो लोग मशीन सीखने के विकास में करते हैं। यदि आपके मॉडल को प्रत्येक डेटा बिंदु के बाद पुनः प्रशिक्षण की आवश्यकता होती है, तो यह एक बहुत अच्छा मॉडल नहीं हो सकता है। यानी, इसे नियमित रूप से पुनः प्रशिक्षण की आवश्यकता होती है, केवल उचित आवृत्ति पर प्रशिक्षण दिया जाना चाहिए ((उदाहरण के लिए, यदि दिन के दौरान भविष्यवाणी की जाती है, तो सप्ताह के अंत में पुनः प्रशिक्षण दिया जाता है) ।

• विचलन से बचें, विशेष रूप से पूर्वानुमानात्मक विचलनः यह एक और कारण है कि मॉडल काम नहीं करता है, सुनिश्चित करें कि आप भविष्य की किसी भी जानकारी का उपयोग नहीं करते हैं। ज्यादातर मामलों में, इसका मतलब है कि लक्ष्य चर Y का उपयोग मॉडल में एक विशेषता के रूप में नहीं करना चाहिए। आप इसका उपयोग रेट्रो-टेस्टिंग के दौरान कर सकते हैं, लेकिन यह वास्तव में मॉडल चलाने के दौरान अनुपयोगी होगा, जिससे आपका मॉडल अनुपयोगी हो जाएगा।

• सतर्कता डेटा खनन विचलनः चूंकि हम अपने डेटा के साथ एक श्रृंखला के मॉडलिंग का प्रयास कर रहे हैं, यह निर्धारित करने के लिए कि क्या यह उपयुक्त है, यदि कोई विशेष कारण नहीं है, तो सुनिश्चित करें कि आप यादृच्छिक पैटर्न को वास्तविक पैटर्न से अलग करने के लिए कठोर परीक्षण चलाते हैं जो हो सकता है। उदाहरण के लिए, रैखिक प्रतिगमन ऊपर की ओर बढ़ने वाले पैटर्न को अच्छी तरह से समझाता है, और यह केवल एक छोटा सा हिस्सा हो सकता है जो एक बड़ा यादृच्छिक बहना है!

अत्यधिक फिट होने से बचें

यह बहुत महत्वपूर्ण है, और मुझे लगता है कि इसे दोहराना आवश्यक है।

• बहुत अधिक अनुकूलन व्यापार रणनीति में सबसे खतरनाक जाल है

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

• अपने सिस्टम को यथासंभव सरल बनाएं। यदि आप अपने आप को डेटा की व्याख्या करने के लिए बहुत सारे जटिल कार्यों की आवश्यकता पाते हैं, तो आप बहुत अधिक फिट हो सकते हैं।

• अपने उपलब्ध डेटा को प्रशिक्षण और परीक्षण डेटा में विभाजित करें, और हमेशा मॉडल का उपयोग करके वास्तविक समय में लेनदेन करने से पहले वास्तविक नमूना डेटा के प्रदर्शन का सत्यापन करें।

संबंधित

अधिक