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

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

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

रणनीति पदानुक्रम अपेक्षाकृत सरल है क्योंकि इसमें सिग्नल इवेंट ऑब्जेक्ट उत्पन्न करने के लिए एक एकल शुद्ध आभासी विधि के साथ एक अमूर्त आधार वर्ग होता है। रणनीति पदानुक्रम बनाने के लिए NumPy, pandas, Queue ऑब्जेक्ट, अमूर्त आधार वर्ग उपकरण और SignalEvent आयात करना आवश्यक हैः

# strategy.py

import datetime
import numpy as np
import pandas as pd
import Queue

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

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

# strategy.py

class Strategy(object):
    """
    Strategy is an abstract base class providing an interface for
    all subsequent (inherited) strategy handling objects.

    The goal of a (derived) Strategy object is to generate Signal
    objects for particular symbols based on the inputs of Bars 
    (OLHCVI) generated by a DataHandler object.

    This is designed to work both with historic and live data as
    the Strategy object is agnostic to the data source,
    since it obtains the bar tuples from a queue object.
    """

    __metaclass__ = ABCMeta

    @abstractmethod
    def calculate_signals(self):
        """
        Provides the mechanisms to calculate the list of signals.
        """
        raise NotImplementedError("Should implement calculate_signals()")

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

निर्माता (आरंभ करना) की आवश्यकता होती है सलाखों बाजार डेटा हैंडलर और घटना घटना कतार ऑब्जेक्टः

# strategy.py

class BuyAndHoldStrategy(Strategy):
    """
    This is an extremely simple strategy that goes LONG all of the 
    symbols as soon as a bar is received. It will never exit a position.

    It is primarily used as a testing mechanism for the Strategy class
    as well as a benchmark upon which to compare other strategies.
    """

    def __init__(self, bars, events):
        """
        Initialises the buy and hold strategy.

        Parameters:
        bars - The DataHandler object that provides bar information
        events - The Event Queue object.
        """
        self.bars = bars
        self.symbol_list = self.bars.symbol_list
        self.events = events

        # Once buy & hold signal is given, these are set to True
        self.bought = self._calculate_initial_bought()

BuyAndHoldStrategy को प्रारंभ करने पर खरीदे गए शब्दकोश सदस्य के पास प्रत्येक प्रतीक के लिए कुंजी का एक सेट होता है जो सभी गलत पर सेट होते हैं। एक बार जब संपत्ति longed हो जाती है तो यह सही पर सेट होती है। अनिवार्य रूप से यह रणनीति को यह जानने की अनुमति देता है कि यह बाजार में है या नहींः

# strategy.py

    def _calculate_initial_bought(self):
        """
        Adds keys to the bought dictionary for all symbols
        and sets them to False.
        """
        bought = {}
        for s in self.symbol_list:
            bought[s] = False
        return bought

calculate_signals शुद्ध आभासी विधि को इस वर्ग में ठोस रूप से लागू किया गया है। विधि प्रतीक सूची में सभी प्रतीकों पर लूप करती है और बार डेटा हैंडलर से नवीनतम बार प्राप्त करती है। फिर यह जांचती है कि क्या उस प्रतीक को bought किया गया है (यानी हम इस प्रतीक के लिए बाजार में हैं या नहीं) और यदि नहीं तो एक एकल SignalEvent ऑब्जेक्ट बनाता है। यह तब घटनाओं की कतार में रखा जाता है और खरीदी गई शब्दकोश को सही ढंग से इस विशेष प्रतीक कुंजी के लिए सच में अपडेट किया जाता हैः

# strategy.py

    def calculate_signals(self, event):
        """
        For "Buy and Hold" we generate a single signal per symbol
        and then no additional signals. This means we are 
        constantly long the market from the date of strategy
        initialisation.

        Parameters
        event - A MarketEvent object. 
        """
        if event.type == 'MARKET':
            for s in self.symbol_list:
                bars = self.bars.get_latest_bars(s, N=1)
                if bars is not None and bars != []:
                    if self.bought[s] == False:
                        # (Symbol, Datetime, Type = LONG, SHORT or EXIT)
                        signal = SignalEvent(bars[0][0], bars[0][1], 'LONG')
                        self.events.put(signal)
                        self.bought[s] = True

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