पायथन के साथ घटना-संचालित बैकटेस्टिंग - भाग III

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

एक इवेंट-ड्राइव ट्रेडिंग सिस्टम के साथ हमारे लक्ष्यों में से एक बैकटेस्टिंग तत्व और लाइव निष्पादन तत्व के बीच कोड की डुप्लिकेट को कम करना है। आदर्श रूप से ऐतिहासिक परीक्षण और लाइव ट्रेडिंग दोनों के लिए एक ही सिग्नल जनरेशन पद्धति और पोर्टफोलियो प्रबंधन घटकों का उपयोग करना इष्टतम होगा। इसके लिए काम करने के लिए सिग्नल उत्पन्न करने वाली रणनीति ऑब्जेक्ट और उन पर आधारित ऑर्डर प्रदान करने वाली पोर्टफोलियो ऑब्जेक्ट को ऐतिहासिक और लाइव दोनों के लिए बाजार फीड के लिए एक समान इंटरफ़ेस का उपयोग करना चाहिए।

यह एक DataHandler ऑब्जेक्ट पर आधारित एक वर्ग पदानुक्रम की अवधारणा को प्रेरित करता है, जो सभी उपवर्गों को प्रणाली के भीतर शेष घटकों को बाजार डेटा प्रदान करने के लिए एक इंटरफ़ेस देता है। इस तरह से किसी भी उपवर्ग डेटा हैंडलर को रणनीति या पोर्टफोलियो गणना को प्रभावित किए बिना स्वैप किया जा सकता है।

विशिष्ट उदाहरण उपवर्गों में HistoricCSVDataHandler, QuandlDataHandler, SecuritiesMasterDataHandler, InteractiveBrokersMarketFeedDataHandler आदि शामिल हो सकते हैं। इस ट्यूटोरियल में हम केवल एक ऐतिहासिक CSV डेटा हैंडलर के निर्माण पर विचार करने जा रहे हैं, जो एक ओपन-लो-हाई-क्लोज-वॉल्यूम-ओपन-इंटरस्ट सेट में इक्विटी के लिए इंट्राडे सीएसवी डेटा लोड करेगा। इसका उपयोग बार-दर-बार आधार पर डेटा को स्ट्रैटेजी और पोर्टफोलियो कक्षाओं में करने के लिए किया जा सकता है।

पहला कार्य आवश्यक पुस्तकालयों आयात करने के लिए है. विशेष रूप से हम आयात करने के लिए जा रहे हैं पांडा और अमूर्त आधार वर्ग उपकरण. के बाद से DataHandler उत्पन्न MarketEvents हम भी आयात करने की जरूरत हैevent.pyजैसा कि पिछले ट्यूटोरियल में वर्णित हैः

# data.py

import datetime
import os, os.path
import pandas as pd

abc आयात ABCMeta, सार पद्धति से

घटना आयात से MarketEvent DataHandler एक अमूर्त आधार वर्ग (ABC) है, जिसका अर्थ है कि एक उदाहरण को सीधे उदाहरण देना असंभव है। केवल उपवर्गों को ही उदाहरण दिया जा सकता है। इसका तर्क यह है कि ABC एक इंटरफ़ेस प्रदान करता है जिसे सभी बाद के DataHandler उपवर्गों को पालन करना चाहिए, जिससे अन्य वर्गों के साथ संगतता सुनिश्चित होती है जो उनके साथ संवाद करते हैं।

हम उपयोग करते हैंमेटाक्लासproperty to let Python know that this is an ABC. इसके अतिरिक्त हम @abstractmethod decorator का उपयोग करते हैं ताकि पायथन को पता चल सके कि विधि को उपवर्गों में ओवरराइड किया जाएगा (यह C++ में एक शुद्ध आभासी विधि के समान है).

ब्याज के दो तरीके get_latest_bars और update_bars हैं। पूर्ववर्ती वर्तमान दिल की धड़कन टाइमस्टैम्प से अंतिम N बार लौटाता है, जो रणनीति वर्गों में आवश्यक रोलिंग गणनाओं के लिए उपयोगी है। उत्तरार्द्ध विधि एक नई डेटा संरचना पर पट्टी की जानकारी रखने के लिए ड्रिप फीड तंत्र प्रदान करती है जो लुकहेड पूर्वाग्रह को सख्ती से प्रतिबंधित करती है। ध्यान दें कि यदि वर्ग के उदाहरण का प्रयास होता है तो अपवाद उठाए जाएंगेः

# data.py

class DataHandler(object):
    """
    DataHandler is an abstract base class providing an interface for
    all subsequent (inherited) data handlers (both live and historic).

    The goal of a (derived) DataHandler object is to output a generated
    set of bars (OLHCVI) for each symbol requested. 

    This will replicate how a live strategy would function as current
    market data would be sent "down the pipe". Thus a historic and live
    system will be treated identically by the rest of the backtesting suite.
    """

    __metaclass__ = ABCMeta

    @abstractmethod
    def get_latest_bars(self, symbol, N=1):
        """
        Returns the last N bars from the latest_symbol list,
        or fewer if less bars are available.
        """
        raise NotImplementedError("Should implement get_latest_bars()")

    @abstractmethod
    def update_bars(self):
        """
        Pushes the latest bar to the latest symbol structure
        for all symbols in the symbol list.
        """
        raise NotImplementedError("Should implement update_bars()")

DataHandler ABC निर्दिष्ट के साथ अगला कदम ऐतिहासिक CSV फ़ाइलों के लिए एक हैंडलर बनाना है। विशेष रूप से HistoricCSVDataHandler कई CSV फ़ाइलें लेगा, प्रत्येक प्रतीक के लिए एक, और इन्हें पांडा डेटाफ्रेम की शब्दकोश में परिवर्तित करेगा।

डेटा हैंडलर को कुछ पैरामीटरों की आवश्यकता होती है, अर्थात् एक इवेंट कतार जिस पर MarketEvent जानकारी को पुश करना है, CSV फ़ाइलों का पूर्ण पथ और प्रतीकों की सूची। यहाँ वर्ग का आरंभ हैः

# data.py

class HistoricCSVDataHandler(DataHandler):
    """
    HistoricCSVDataHandler is designed to read CSV files for
    each requested symbol from disk and provide an interface
    to obtain the "latest" bar in a manner identical to a live
    trading interface. 
    """

    def __init__(self, events, csv_dir, symbol_list):
        """
        Initialises the historic data handler by requesting
        the location of the CSV files and a list of symbols.

        It will be assumed that all files are of the form
        'symbol.csv', where symbol is a string in the list.

        Parameters:
        events - The Event Queue.
        csv_dir - Absolute directory path to the CSV files.
        symbol_list - A list of symbol strings.
        """
        self.events = events
        self.csv_dir = csv_dir
        self.symbol_list = symbol_list

        self.symbol_data = {}
        self.latest_symbol_data = {}
        self.continue_backtest = True       

        self._open_convert_csv_files()

यह निहित रूप से SYMBOL.csv के प्रारूप के साथ फ़ाइलों को खोलने का प्रयास करेगा जहां प्रतीक टिकर प्रतीक है। फ़ाइलों का प्रारूप डीटीएन आईक्यूफीड विक्रेता द्वारा प्रदान किए गए से मेल खाता है, लेकिन अतिरिक्त डेटा प्रारूपों को संभालने के लिए आसानी से संशोधित किया जा सकता है। फ़ाइलों का उद्घाटन नीचे दी गई _open_convert_csv_files विधि द्वारा संभाला जाता है।

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

# data.py

    def _open_convert_csv_files(self):
        """
        Opens the CSV files from the data directory, converting
        them into pandas DataFrames within a symbol dictionary.

        For this handler it will be assumed that the data is
        taken from DTN IQFeed. Thus its format will be respected.
        """
        comb_index = None
        for s in self.symbol_list:
            # Load the CSV file with no header information, indexed on date
            self.symbol_data[s] = pd.io.parsers.read_csv(
                                      os.path.join(self.csv_dir, '%s.csv' % s),
                                      header=0, index_col=0, 
                                      names=['datetime','open','low','high','close','volume','oi']
                                  )

            # Combine the index to pad forward values
            if comb_index is None:
                comb_index = self.symbol_data[s].index
            else:
                comb_index.union(self.symbol_data[s].index)

            # Set the latest symbol_data to None
            self.latest_symbol_data[s] = []

        # Reindex the dataframes
        for s in self.symbol_list:
            self.symbol_data[s] = self.symbol_data[s].reindex(index=comb_index, method='pad').iterrows()

_get_new_bar विधि बार डेटा का एक स्वरूपित संस्करण प्रदान करने के लिए एक जनरेटर बनाता है। इसका मतलब है कि विधि के लिए बाद के कॉल एक नया बार उत्पन्न करेंगे जब तक कि प्रतीक डेटा के अंत तक नहीं पहुंच जाता हैः

# data.py

    def _get_new_bar(self, symbol):
        """
        Returns the latest bar from the data feed as a tuple of 
        (sybmbol, datetime, open, low, high, close, volume).
        """
        for b in self.symbol_data[symbol]:
            yield tuple([symbol, datetime.datetime.strptime(b[0], '%Y-%m-%d %H:%M:%S'), 
                        b[1][0], b[1][1], b[1][2], b[1][3], b[1][4]])

डेटा हैंडलर से लागू होने वाली पहली अमूर्त विधि get_latest_bars है। यह विधि केवल नवीनतम_प्रतीक_डेटा संरचना से अंतिम N बारों की सूची प्रदान करती है। N=1 सेट करने से वर्तमान बार (सूची में लिपटे हुए) को पुनर्प्राप्त करने की अनुमति मिलती हैः

# data.py

    def get_latest_bars(self, symbol, N=1):
        """
        Returns the last N bars from the latest_symbol list,
        or N-k if less available.
        """
        try:
            bars_list = self.latest_symbol_data[symbol]
        except KeyError:
            print "That symbol is not available in the historical data set."
        else:
            return bars_list[-N:]

अंतिम विधि, update_bars DataHandler से दूसरी अमूर्त विधि है. यह केवल एक MarketEvent उत्पन्न करता है जो नवीनतम_symbol_data के लिए नवीनतम सलाखों को जोड़ने के रूप में कतार में जोड़ा जाता हैः

# data.py

    def update_bars(self):
        """
        Pushes the latest bar to the latest_symbol_data structure
        for all symbols in the symbol list.
        """
        for s in self.symbol_list:
            try:
                bar = self._get_new_bar(s).next()
            except StopIteration:
                self.continue_backtest = False
            else:
                if bar is not None:
                    self.latest_symbol_data[s].append(bar)
        self.events.put(MarketEvent())

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

अगले लेख में हम रणनीति वर्ग पदानुक्रम पर विचार करेंगे और वर्णन करेंगे कि कैसे एक रणनीति को कई प्रतीकों को संभालने के लिए डिज़ाइन किया जा सकता है, इस प्रकार पोर्टफोलियो ऑब्जेक्ट के लिए कई सिग्नल इवेंट उत्पन्न करते हैं।