एसपीवाई और आईडब्ल्यूएम के बीच एक इंट्राडे मीडियन रिवर्सन जोड़े की रणनीति का बैकटेस्टिंग

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

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

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

रणनीति

इस रणनीति को निम्नलिखित चरणों में लागू किया जाता हैः

1. एसपीवाई और आईडब्ल्यूएम के डेटा - 1 मिनट के बार अप्रैल 2007 से फरवरी 2014 तक प्राप्त किए जाते हैं।
2. प्रसंस्करण - डेटा को सही ढंग से संरेखित किया जाता है और लापता सलाखों को पारस्परिक रूप से खारिज कर दिया जाता है।
3. स्प्रेड - दो ईटीएफ के बीच हेज अनुपात की गणना रोलिंग रैखिक प्रतिगमन के द्वारा की जाती है। यह एक लुकबैक विंडो का उपयोग करके β प्रतिगमन गुणांक के रूप में परिभाषित किया जाता है जो 1 बार आगे बढ़ता है और प्रतिगमन गुणांक की पुनः गणना करता है। इस प्रकार, बार बी के लिए हेज अनुपात βi, k बार के लुकबैक के लिए बि−1−k से bi−1 बिंदुओं पर गणना की जाती है।
4. Z- स्कोर - प्रसार का मानक स्कोर सामान्य तरीके से गणना की जाती है। इसका मतलब है कि प्रसार के (नमूना) औसत को घटाकर प्रसार के (नमूना) मानक विचलन से विभाजित करना। इसका तर्क यह है कि z- स्कोर एक आयाम रहित मात्रा है, इसलिए सीमा मापदंडों को व्याख्या करने के लिए अधिक सीधा बनाना है। मैंने जानबूझकर गणना में एक लुकहेड पूर्वाग्रह पेश किया है ताकि यह दिखाया जा सके कि यह कितना सूक्ष्म हो सकता है। कोशिश करें और इसके लिए देखें!
5. ट्रेड - लंबे संकेत तब उत्पन्न होते हैं जब नकारात्मक जेड-स्कोर एक पूर्वनिर्धारित (या पोस्ट-अनुकूलित) सीमा से नीचे गिर जाता है, जबकि छोटे संकेत इसके विपरीत होते हैं। बाहर निकलने के संकेत तब उत्पन्न होते हैं जब पूर्ण जेड-स्कोर एक अतिरिक्त सीमा से नीचे गिर जाता है। इस रणनीति के लिए मैंने (कुछ मनमाने ढंग से) एक पूर्ण प्रवेश सीमा चुन ली है

शायद रणनीति को गहराई से समझने का सबसे अच्छा तरीका वास्तव में इसे लागू करना है। निम्नलिखित अनुभाग इस अर्थ-रिवर्सिंग रणनीति को लागू करने के लिए एक पूर्ण पायथन कोड (एकल फ़ाइल) का वर्णन करता है। मैंने समझने में सहायता के लिए कोड पर उदारता से टिप्पणी की है।

पायथन कार्यान्वयन

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

मेरे द्वारा उपयोग किए जा रहे विशिष्ट पुस्तकालय संस्करण निम्नलिखित हैंः

• पायथन - 2.7.3
• NumPy - 1.8.0
• पांडा - 0.12.0
• matplotlib - 1.1.0 चलिए आगे बढ़ते हैं और पुस्तकालयों का आयात करते हैंः

# mr_spy_iwm.py

import matplotlib.pyplot as plt
import numpy as np
import os, os.path
import pandas as pd

निम्नलिखित फ़ंक्शन create_pairs_dataframe दो प्रतीकों के इंट्राडे बार वाले दो CSV फ़ाइलों को आयात करता है। हमारे मामले में यह SPY और IWM होगा। यह तब एक अलग डेटाफ्रेम जोड़े बनाता है, जो दोनों मूल फ़ाइलों के सूचकांक का उपयोग करता है। चूंकि उनके टाइमस्टैम्प याद किए गए ट्रेडों और त्रुटियों के कारण अलग होने की संभावना है, यह गारंटी देता है कि हमारे पास मिलान डेटा होगा। यह पांडा जैसे डेटा एनालिसिस लाइब्रेरी का उपयोग करने के मुख्य लाभों में से एक है। boilerplate कोड हमारे लिए बहुत कुशल तरीके से संभाला जाता है।

# mr_spy_iwm.py

def create_pairs_dataframe(datadir, symbols):
    """Creates a pandas DataFrame containing the closing price
    of a pair of symbols based on CSV files containing a datetime
    stamp and OHLCV data."""

    # Open the individual CSV files and read into pandas DataFrames
    print "Importing CSV data..."
    sym1 = pd.io.parsers.read_csv(os.path.join(datadir, '%s.csv' % symbols[0]),
                                  header=0, index_col=0, 
                                  names=['datetime','open','high','low','close','volume','na'])
    sym2 = pd.io.parsers.read_csv(os.path.join(datadir, '%s.csv' % symbols[1]),
                                  header=0, index_col=0, 
                                  names=['datetime','open','high','low','close','volume','na'])

    # Create a pandas DataFrame with the close prices of each symbol
    # correctly aligned and dropping missing entries
    print "Constructing dual matrix for %s and %s..." % symbols    
    pairs = pd.DataFrame(index=sym1.index)
    pairs['%s_close' % symbols[0].lower()] = sym1['close']
    pairs['%s_close' % symbols[1].lower()] = sym2['close']
    pairs = pairs.dropna()
    return pairs

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

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

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

# mr_spy_iwm.py

def calculate_spread_zscore(pairs, symbols, lookback=100):
    """Creates a hedge ratio between the two symbols by calculating
    a rolling linear regression with a defined lookback period. This
    is then used to create a z-score of the 'spread' between the two
    symbols based on a linear combination of the two."""
    
    # Use the pandas Ordinary Least Squares method to fit a rolling
    # linear regression between the two closing price time series
    print "Fitting the rolling Linear Regression..."
    model = pd.ols(y=pairs['%s_close' % symbols[0].lower()], 
                   x=pairs['%s_close' % symbols[1].lower()],
                   window=lookback)

    # Construct the hedge ratio and eliminate the first 
    # lookback-length empty/NaN period
    pairs['hedge_ratio'] = model.beta['x']
    pairs = pairs.dropna()

    # Create the spread and then a z-score of the spread
    print "Creating the spread/zscore columns..."
    pairs['spread'] = pairs['spy_close'] - pairs['hedge_ratio']*pairs['iwm_close']
    pairs['zscore'] = (pairs['spread'] - np.mean(pairs['spread']))/np.std(pairs['spread'])
    return pairs

create_long_short_market_signals में ट्रेडिंग सिग्नल बनाए जाते हैं। ये तब गणना किए जाते हैं जब z-स्कोर नकारात्मक z-स्कोर से अधिक हो और जब z-स्कोर सकारात्मक z-स्कोर से अधिक हो तो स्प्रेड को छोटा कर दिया जाता है। exit सिग्नल तब दिया जाता है जब z-स्कोर का पूर्ण मूल्य किसी अन्य (छोटे परिमाण) सीमा से कम या बराबर होता है।

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

एक पांडा डेटाफ्रेम पर पुनरावृत्ति करने के लिए (जो स्वीकार्य रूप से एक आम ऑपरेशन नहीं है) यह iterrows विधि का उपयोग करने के लिए आवश्यक है, जो एक जनरेटर प्रदान करता है जिस पर पुनरावृत्ति करने के लिएः

# mr_spy_iwm.py

def create_long_short_market_signals(pairs, symbols, 
                                     z_entry_threshold=2.0, 
                                     z_exit_threshold=1.0):
    """Create the entry/exit signals based on the exceeding of 
    z_enter_threshold for entering a position and falling below
    z_exit_threshold for exiting a position."""

    # Calculate when to be long, short and when to exit
    pairs['longs'] = (pairs['zscore'] <= -z_entry_threshold)*1.0
    pairs['shorts'] = (pairs['zscore'] >= z_entry_threshold)*1.0
    pairs['exits'] = (np.abs(pairs['zscore']) <= z_exit_threshold)*1.0

    # These signals are needed because we need to propagate a
    # position forward, i.e. we need to stay long if the zscore
    # threshold is less than z_entry_threshold by still greater
    # than z_exit_threshold, and vice versa for shorts.
    pairs['long_market'] = 0.0
    pairs['short_market'] = 0.0

    # These variables track whether to be long or short while
    # iterating through the bars
    long_market = 0
    short_market = 0

    # Calculates when to actually be "in" the market, i.e. to have a
    # long or short position, as well as when not to be.
    # Since this is using iterrows to loop over a dataframe, it will
    # be significantly less efficient than a vectorised operation,
    # i.e. slow!
    print "Calculating when to be in the market (long and short)..."
    for i, b in enumerate(pairs.iterrows()):
        # Calculate longs
        if b[1]['longs'] == 1.0:
            long_market = 1            
        # Calculate shorts
        if b[1]['shorts'] == 1.0:
            short_market = 1
        # Calculate exists
        if b[1]['exits'] == 1.0:
            long_market = 0
            short_market = 0
        # This directly assigns a 1 or 0 to the long_market/short_market
        # columns, such that the strategy knows when to actually stay in!
        pairs.ix[i]['long_market'] = long_market
        pairs.ix[i]['short_market'] = short_market
    return pairs

इस चरण में हमने वास्तविक लंबे / लघु संकेतों को शामिल करने के लिए जोड़े को अपडेट किया है, जो हमें यह निर्धारित करने की अनुमति देता है कि क्या हमें बाजार में होने की आवश्यकता है। अब हमें पदों के बाजार मूल्य का ट्रैक रखने के लिए एक पोर्टफोलियो बनाने की आवश्यकता है। पहला कार्य एक पद कॉलम बनाना है जो लंबे और छोटे संकेतों को जोड़ती है। इसमें (1,0,−1) से तत्वों की सूची होगी, जिसमें 1 एक लंबी / बाजार स्थिति का प्रतिनिधित्व करता है, 0 कोई स्थिति का प्रतिनिधित्व नहीं करता है (बाहर निकलना चाहिए) और -1 एक छोटी / बाजार स्थिति का प्रतिनिधित्व करता है। sym1 और sym2 कॉलम प्रत्येक बार के बंद होने पर SPY और IWM पदों के बाजार मूल्यों का प्रतिनिधित्व करते हैं।

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

# mr_spy_iwm.py

def create_portfolio_returns(pairs, symbols):
    """Creates a portfolio pandas DataFrame which keeps track of
    the account equity and ultimately generates an equity curve.
    This can be used to generate drawdown and risk/reward ratios."""
    
    # Convenience variables for symbols
    sym1 = symbols[0].lower()
    sym2 = symbols[1].lower()

    # Construct the portfolio object with positions information
    # Note that minuses to keep track of shorts!
    print "Constructing a portfolio..."
    portfolio = pd.DataFrame(index=pairs.index)
    portfolio['positions'] = pairs['long_market'] - pairs['short_market']
    portfolio[sym1] = -1.0 * pairs['%s_close' % sym1] * portfolio['positions']
    portfolio[sym2] = pairs['%s_close' % sym2] * portfolio['positions']
    portfolio['total'] = portfolio[sym1] + portfolio[sym2]

    # Construct a percentage returns stream and eliminate all 
    # of the NaN and -inf/+inf cells
    print "Constructing the equity curve..."
    portfolio['returns'] = portfolio['total'].pct_change()
    portfolio['returns'].fillna(0.0, inplace=True)
    portfolio['returns'].replace([np.inf, -np.inf], 0.0, inplace=True)
    portfolio['returns'].replace(-1.0, 0.0, inplace=True)

    # Calculate the full equity curve
    portfolio['returns'] = (portfolio['returns'] + 1.0).cumprod()
    return portfolio

..मुख्यकार्य यह सब एक साथ लाता है. इंट्राडे सीएसवी फ़ाइलें datadir पथ पर स्थित हैं. अपनी विशिष्ट निर्देशिका को इंगित करने के लिए नीचे कोड को संशोधित करना सुनिश्चित करें.

यह निर्धारित करने के लिए कि रणनीति लुकबैक अवधि के प्रति कितनी संवेदनशील है, लुकबैक की सीमा के लिए एक प्रदर्शन मीट्रिक की गणना करना आवश्यक है। मैंने प्रदर्शन उपाय के रूप में पोर्टफोलियो के अंतिम कुल प्रतिशत रिटर्न और लुकबैक रेंज को [50,200] में 10 की वृद्धि के साथ चुना है। आप निम्नलिखित कोड में देख सकते हैं कि पिछले कार्य इस रेंज में एक लूप में लपेटे गए हैं, अन्य सीमाओं को तय किया गया है। अंतिम कार्य लुकबैक बनाम रिटर्न का एक लाइन चार्ट बनाने के लिए मैटप्लोटलिब का उपयोग करना है:

# mr_spy_iwm.py

if __name__ == "__main__":
    datadir = '/your/path/to/data/'  # Change this to reflect your data path!
    symbols = ('SPY', 'IWM')

    lookbacks = range(50, 210, 10)
    returns = []

    # Adjust lookback period from 50 to 200 in increments
    # of 10 in order to produce sensitivities
    for lb in lookbacks: 
        print "Calculating lookback=%s..." % lb
        pairs = create_pairs_dataframe(datadir, symbols)
        pairs = calculate_spread_zscore(pairs, symbols, lookback=lb)
        pairs = create_long_short_market_signals(pairs, symbols, 
                                                z_entry_threshold=2.0, 
                                                z_exit_threshold=1.0)

        portfolio = create_portfolio_returns(pairs, symbols)
        returns.append(portfolio.ix[-1]['returns'])

    print "Plot the lookback-performance scatterchart..."
    plt.plot(lookbacks, returns, '-o')
    plt.show()

लुकबैक अवधि बनाम रिटर्न का चार्ट अब देखा जा सकता है। ध्यान दें कि लुकबैक के आसपास global अधिकतम 110 बार के बराबर है। यदि हमने एक ऐसी स्थिति देखी थी जहां लुकबैक रिटर्न से स्वतंत्र था तो यह चिंता का कारण होगाःएसपीवाई-आईडब्ल्यूएम रैखिक प्रतिगमन हेज-रेशियो लुकबैक अवधि संवेदनशीलता विश्लेषण

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

# mr_spy_iwm.py

    # This is still within the main function
    print "Plotting the performance charts..."
    fig = plt.figure()
    fig.patch.set_facecolor('white')

    ax1 = fig.add_subplot(211,  ylabel='%s growth (%%)' % symbols[0])
    (pairs['%s_close' % symbols[0].lower()].pct_change()+1.0).cumprod().plot(ax=ax1, color='r', lw=2.)

    ax2 = fig.add_subplot(212, ylabel='Portfolio value growth (%%)')
    portfolio['returns'].plot(ax=ax2, lw=2.)

    fig.show()

निम्नलिखित इक्विटी वक्र चार्ट 100 दिनों की पिछली अवधि के लिए है:एसपीवाई-आईडब्ल्यूएम रैखिक प्रतिगमन हेज-रेशियो लुकबैक अवधि संवेदनशीलता विश्लेषण

यह ध्यान दिया जाना चाहिए कि वित्तीय संकट की अवधि के दौरान 2009 में SPY का उपयोग महत्वपूर्ण है। इस चरण में रणनीति में भी अस्थिर अवधि थी। यह भी ध्यान दिया जाना चाहिए कि इस अवधि में SPY की मजबूत प्रवृत्ति की प्रकृति के कारण पिछले वर्ष में प्रदर्शन कुछ हद तक बिगड़ गया है, जो S & P500 सूचकांक को दर्शाता है।

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

बाद के लेखों में हम एक बहुत अधिक परिष्कृत घटना-संचालित बैकटेस्टर बनाएंगे जो इन कारकों को ध्यान में रखेगा और हमें हमारे इक्विटी वक्र और प्रदर्शन मेट्रिक्स में काफी अधिक विश्वास देगा।