डिजिटल मुद्रा कारक मॉडल

[TOC]

कारक मॉडल ढांचा

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

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

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

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

खोजे गए कारक रणनीति बनाने के लिए आधार हैं, और कई असंबद्ध प्रभावी कारकों के संयोजन से बेहतर रणनीति बनाई जा सकती है।

import requests
from datetime import date,datetime
import time
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import requests, zipfile, io
%matplotlib inline

डेटा स्रोत

विनय USDT टिकाऊ वायदा 2022 की शुरुआत से अब तक के घंटे के लिए K-लाइन डेटा, अब तक, 150 से अधिक मुद्राओं से अधिक है। जैसा कि पहले कहा गया है, कारक मॉडल एक विकल्प मुद्रा मॉडल है, जो सभी मुद्राओं के लिए है, न कि किसी एक मुद्रा के लिए। K-लाइन डेटा में उच्च और निम्न प्राप्ति मूल्य, लेनदेन की मात्रा, लेनदेन की संख्या, सक्रिय खरीद आदि शामिल हैं, जो निश्चित रूप से सभी कारकों का स्रोत नहीं हैं, जैसे कि अमेरिकी शेयर सूचकांक, ब्याज वृद्धि की उम्मीद, लाभप्रदता श्रृंखला पर डेटा, सोशल मीडिया की गर्मी आदि। ठंडे डेटा स्रोत भी प्रभावी अल्फा का पता लगा सकते हैं, लेकिन बुनियादी मूल्य डेटा पूरी तरह से पर्याप्त है।

## 当前交易对
Info = requests.get('https://fapi.binance.com/fapi/v1/exchangeInfo')
symbols = [s['symbol'] for s in Info.json()['symbols']]
symbols = list(filter(lambda x: x[-4:] == 'USDT', [s.split('_')[0] for s in symbols]))
print(symbols)

बाहरः

['BTCUSDT', 'ETHUSDT', 'BCHUSDT', 'XRPUSDT', 'EOSUSDT', 'LTCUSDT', 'TRXUSDT', 'ETCUSDT', 'LINKUSDT',
'XLMUSDT', 'ADAUSDT', 'XMRUSDT', 'DASHUSDT', 'ZECUSDT', 'XTZUSDT', 'BNBUSDT', 'ATOMUSDT', 'ONTUSDT',
'IOTAUSDT', 'BATUSDT', 'VETUSDT', 'NEOUSDT', 'QTUMUSDT', 'IOSTUSDT', 'THETAUSDT', 'ALGOUSDT', 'ZILUSDT',
'KNCUSDT', 'ZRXUSDT', 'COMPUSDT', 'OMGUSDT', 'DOGEUSDT', 'SXPUSDT', 'KAVAUSDT', 'BANDUSDT', 'RLCUSDT',
'WAVESUSDT', 'MKRUSDT', 'SNXUSDT', 'DOTUSDT', 'DEFIUSDT', 'YFIUSDT', 'BALUSDT', 'CRVUSDT', 'TRBUSDT',
'RUNEUSDT', 'SUSHIUSDT', 'SRMUSDT', 'EGLDUSDT', 'SOLUSDT', 'ICXUSDT', 'STORJUSDT', 'BLZUSDT', 'UNIUSDT',
'AVAXUSDT', 'FTMUSDT', 'HNTUSDT', 'ENJUSDT', 'FLMUSDT', 'TOMOUSDT', 'RENUSDT', 'KSMUSDT', 'NEARUSDT',
'AAVEUSDT', 'FILUSDT', 'RSRUSDT', 'LRCUSDT', 'MATICUSDT', 'OCEANUSDT', 'CVCUSDT', 'BELUSDT', 'CTKUSDT',
'AXSUSDT', 'ALPHAUSDT', 'ZENUSDT', 'SKLUSDT', 'GRTUSDT', '1INCHUSDT', 'CHZUSDT', 'SANDUSDT', 'ANKRUSDT',
'BTSUSDT', 'LITUSDT', 'UNFIUSDT', 'REEFUSDT', 'RVNUSDT', 'SFPUSDT', 'XEMUSDT', 'BTCSTUSDT', 'COTIUSDT',
'CHRUSDT', 'MANAUSDT', 'ALICEUSDT', 'HBARUSDT', 'ONEUSDT', 'LINAUSDT', 'STMXUSDT', 'DENTUSDT', 'CELRUSDT',
'HOTUSDT', 'MTLUSDT', 'OGNUSDT', 'NKNUSDT', 'SCUSDT', 'DGBUSDT', '1000SHIBUSDT', 'ICPUSDT', 'BAKEUSDT',
'GTCUSDT', 'BTCDOMUSDT', 'TLMUSDT', 'IOTXUSDT', 'AUDIOUSDT', 'RAYUSDT', 'C98USDT', 'MASKUSDT', 'ATAUSDT',
'DYDXUSDT', '1000XECUSDT', 'GALAUSDT', 'CELOUSDT', 'ARUSDT', 'KLAYUSDT', 'ARPAUSDT', 'CTSIUSDT', 'LPTUSDT',
'ENSUSDT', 'PEOPLEUSDT', 'ANTUSDT', 'ROSEUSDT', 'DUSKUSDT', 'FLOWUSDT', 'IMXUSDT', 'API3USDT', 'GMTUSDT',
'APEUSDT', 'BNXUSDT', 'WOOUSDT', 'FTTUSDT', 'JASMYUSDT', 'DARUSDT', 'GALUSDT', 'OPUSDT', 'BTCUSDT',
'ETHUSDT', 'INJUSDT', 'STGUSDT', 'FOOTBALLUSDT', 'SPELLUSDT', '1000LUNCUSDT', 'LUNA2USDT', 'LDOUSDT',
'CVXUSDT']

---

print(len(symbols))

बाहरः

153

---

#获取任意周期K线的函数
def GetKlines(symbol='BTCUSDT',start='2020-8-10',end='2021-8-10',period='1h',base='fapi',v = 'v1'):
    Klines = []
    start_time = int(time.mktime(datetime.strptime(start, "%Y-%m-%d").timetuple()))*1000 + 8*60*60*1000
    end_time =  min(int(time.mktime(datetime.strptime(end, "%Y-%m-%d").timetuple()))*1000 + 8*60*60*1000,time.time()*1000)
    intervel_map = {'m':60*1000,'h':60*60*1000,'d':24*60*60*1000}
    while start_time < end_time:
        mid_time = start_time+1000*int(period[:-1])*intervel_map[period[-1]]
        url = 'https://'+base+'.binance.com/'+base+'/'+v+'/klines?symbol=%s&interval=%s&startTime=%s&endTime=%s&limit=1000'%(symbol,period,start_time,mid_time)
        res = requests.get(url)
        res_list = res.json()
        if type(res_list) == list and len(res_list) > 0:
            start_time = res_list[-1][0]+int(period[:-1])*intervel_map[period[-1]]
            Klines += res_list
        if type(res_list) == list and len(res_list) == 0:
            start_time = start_time+1000*int(period[:-1])*intervel_map[period[-1]]
        if mid_time >= end_time:
            break
    df = pd.DataFrame(Klines,columns=['time','open','high','low','close','amount','end_time','volume','count','buy_amount','buy_volume','null']).astype('float')
    df.index = pd.to_datetime(df.time,unit='ms')
    return df

start_date = '2022-1-1'
end_date = '2022-09-14'
period = '1h'
df_dict = {}
for symbol in symbols:
    df_s = GetKlines(symbol=symbol,start=start_date,end=end_date,period=period,base='fapi',v='v1')
    if not df_s.empty:
        df_dict[symbol] = df_s

symbols = list(df_dict.keys())
print(df_s.columns)

बाहरः

Index(['time', 'open', 'high', 'low', 'close', 'amount', 'end_time', 'volume',
       'count', 'buy_amount', 'buy_volume', 'null'],
      dtype='object')

---

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

df_close = pd.DataFrame(index=pd.date_range(start=start_date, end=end_date, freq=period),columns=df_dict.keys())
df_open = pd.DataFrame(index=pd.date_range(start=start_date, end=end_date, freq=period),columns=df_dict.keys())
df_volume = pd.DataFrame(index=pd.date_range(start=start_date, end=end_date, freq=period),columns=df_dict.keys())
df_buy_ratio = pd.DataFrame(index=pd.date_range(start=start_date, end=end_date, freq=period),columns=df_dict.keys())
df_count = pd.DataFrame(index=pd.date_range(start=start_date, end=end_date, freq=period),columns=df_dict.keys())
for symbol in df_dict.keys():
    df_s = df_dict[symbol]
    df_close[symbol] = df_s.close
    df_open[symbol] = df_s.open
    df_volume[symbol] = df_s.volume
    df_count[symbol] = df_s['count']
    df_buy_ratio[symbol] = df_s.buy_amount/df_s.amount
df_close = df_close.dropna(how='all')
df_open = df_open.dropna(how='all')
df_volume = df_volume.dropna(how='all')
df_count = df_count.dropna(how='all')
df_buy_ratio = df_buy_ratio.dropna(how='all')

इस साल की शुरुआत में बाजार सूचकांक में 60 प्रतिशत की गिरावट आई है।

df_norm = df_close/df_close.fillna(method='bfill').iloc[0] #归一化
df_norm.mean(axis=1).plot(figsize=(15,6),grid=True);
#最终指数收益图

कारक प्रभावकारिता

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

• आईसी, आईआर आदि आईसी का अर्थ है कारक और अगले आवर्तन की आय का अनुपात, और अब यह सामान्य रूप से RANK_IC के साथ भी उपयोग किया जाता है। आईआर सामान्य रूप से आईसी क्रम के औसत मूल्य / आईसी क्रम के मानक अंतर हैं।

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

वास्तविक रीसेट ऑपरेशन

कारक के आधार पर चयनित सिक्कों को छोटे से बड़े क्रम में क्रम के आधार पर 3 समूहों में विभाजित किया जाता है, प्रत्येक समूह के सिक्कों का लगभग 1/3 हिस्सा होता है, यदि एक कारक प्रभावी है, तो प्रत्येक घटक का कम से कम अक्सर उच्चतम रिटर्न होता है, लेकिन इसका मतलब यह भी है कि प्रत्येक सिक्के के लिए आवंटित धनराशि अपेक्षाकृत अधिक होती है, यदि अधिक रिक्तता को दोगुना लाभ मिलता है, तो पहले और अंतिम समूह में 10 सिक्के होते हैं, तो एक अनुपात 10% होता है, यदि एक खाली सिक्का बढ़ता है तो 2 गुना होता है, तो 20% वापस ले जाता है; यदि संबंधित गुणक सेट 50 है, तो वापस ले लिया जाता है। 4% बिखरे हुए सिक्के ब्लैकवैलो के जोखिम को कम कर सकते हैं। पहला बहुमूल्य (बहुमूल्यपूर्ण) समूह (कम से कम कारक) कर सकते हैं, खाली तीसरा समूह। यदि कारक अधिक है, तो उच्च रिटर्न हो सकता है, या यदि अधिक रिक्तता है, तो सरल कारक को एक या नकारात्मक संख्या में बदल दें।

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

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

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

#回测引擎
class Exchange:
    
    def __init__(self, trade_symbols, fee=0.0004, initial_balance=10000):
        self.initial_balance = initial_balance #初始的资产
        self.fee = fee
        self.trade_symbols = trade_symbols
        self.account = {'USDT':{'realised_profit':0, 'unrealised_profit':0, 'total':initial_balance, 'fee':0, 'leverage':0, 'hold':0}}
        for symbol in trade_symbols:
            self.account[symbol] = {'amount':0, 'hold_price':0, 'value':0, 'price':0, 'realised_profit':0,'unrealised_profit':0,'fee':0}
            
    def Trade(self, symbol, direction, price, amount):
        
        cover_amount = 0 if direction*self.account[symbol]['amount'] >=0 else min(abs(self.account[symbol]['amount']), amount)
        open_amount = amount - cover_amount
        self.account['USDT']['realised_profit'] -= price*amount*self.fee #扣除手续费
        self.account['USDT']['fee'] += price*amount*self.fee
        self.account[symbol]['fee'] += price*amount*self.fee

        if cover_amount > 0: #先平仓
            self.account['USDT']['realised_profit'] += -direction*(price - self.account[symbol]['hold_price'])*cover_amount  #利润
            self.account[symbol]['realised_profit'] += -direction*(price - self.account[symbol]['hold_price'])*cover_amount
            
            self.account[symbol]['amount'] -= -direction*cover_amount
            self.account[symbol]['hold_price'] = 0 if self.account[symbol]['amount'] == 0 else self.account[symbol]['hold_price']
            
        if open_amount > 0:
            total_cost = self.account[symbol]['hold_price']*direction*self.account[symbol]['amount'] + price*open_amount
            total_amount = direction*self.account[symbol]['amount']+open_amount
            
            self.account[symbol]['hold_price'] = total_cost/total_amount
            self.account[symbol]['amount'] += direction*open_amount
                    
    
    def Buy(self, symbol, price, amount):
        self.Trade(symbol, 1, price, amount)
        
    def Sell(self, symbol, price, amount):
        self.Trade(symbol, -1, price, amount)
        
    def Update(self, close_price): #对资产进行更新
        self.account['USDT']['unrealised_profit'] = 0
        self.account['USDT']['hold'] = 0
        for symbol in self.trade_symbols:
            if not np.isnan(close_price[symbol]):
                self.account[symbol]['unrealised_profit'] = (close_price[symbol] - self.account[symbol]['hold_price'])*self.account[symbol]['amount']
                self.account[symbol]['price'] = close_price[symbol]
                self.account[symbol]['value'] = abs(self.account[symbol]['amount'])*close_price[symbol]
                self.account['USDT']['hold'] += self.account[symbol]['value']
                self.account['USDT']['unrealised_profit'] += self.account[symbol]['unrealised_profit']
        self.account['USDT']['total'] = round(self.account['USDT']['realised_profit'] + self.initial_balance + self.account['USDT']['unrealised_profit'],6)
        self.account['USDT']['leverage'] = round(self.account['USDT']['hold']/self.account['USDT']['total'],3)

#测试因子的函数
def Test(factor, symbols, period=1, N=40, value=300):
    e = Exchange(symbols, fee=0.0002, initial_balance=10000)
    res_list = []
    index_list = []
    factor = factor.dropna(how='all')
    for idx, row in factor.iterrows():
        if idx.hour % period == 0:
            buy_symbols =  row.sort_values().dropna()[0:N].index
            sell_symbols = row.sort_values().dropna()[-N:].index
            prices = df_close.loc[idx,]
            index_list.append(idx)
            for symbol in symbols:
                if symbol in buy_symbols and e.account[symbol]['amount'] <= 0:
                    e.Buy(symbol,prices[symbol],value/prices[symbol]-e.account[symbol]['amount'])
                if symbol in sell_symbols and e.account[symbol]['amount'] >= 0:
                    e.Sell(symbol,prices[symbol], value/prices[symbol]+e.account[symbol]['amount'])
            e.Update(prices)
            res_list.append([e.account['USDT']['total'],e.account['USDT']['hold']])
    return pd.DataFrame(data=res_list, columns=['total','hold'],index = index_list)

सरल कारक परीक्षण

लेन-देन कारकः बहुत कम लेनदेन वाले सिक्कों को सरल बनाने के लिए, उच्च लेनदेन वाले सिक्कों को खाली करने के लिए, बहुत अच्छा प्रदर्शन किया, जो कि लोकप्रिय सिक्कों के लिए अधिक गिरावट का संकेत देता है।

लेन-देन मूल्य कारकः अधिक मूल्य कम मुद्राओं के साथ, उच्च मूल्य वाले मुद्राओं के साथ, प्रभाव आम तौर पर।

लेन-देन संख्या कारकः प्रदर्शन और लेन-देन की मात्रा बहुत समान हैं; यह स्पष्ट रूप से ध्यान दिया जा सकता है कि लेन-देन कारक और लेन-देन संख्या कारक का संबंध बहुत अधिक है, और वास्तव में, उनकी विभिन्न मुद्राओं के बीच औसत संबंध 0.97 तक पहुंच गया है, जो बताता है कि ये दोनों कारक बहुत करीब हैं, और यह कारक बहु-कारक के संश्लेषण में ध्यान में रखा जाना चाहिए।

3h गति कारकः ((df_close - df_close.shift)) 3)) /df_close.shift ((3)); यानी कारक में 3 घंटे की वृद्धि, पुनरीक्षण के परिणामों से पता चलता है कि 3 घंटे की वृद्धि में स्पष्ट प्रतिगामी विशेषताएं हैं, यानी ऊपर की ओर बढ़ने के बाद नीचे जाना आसान है। समग्र प्रदर्शन ठीक है, लेकिन लंबे समय तक वापसी और दोलन अवधि भी है।

24 घंटे की गति का कारकः 24 घंटे के समायोजन चक्र का परिणाम अच्छा है, लाभ 3 घंटे की गति के करीब है, और वापसी छोटी है।

लेन-देन की मात्रा में परिवर्तन का कारकःdf_volume.rolling ((24).mean (() /df_volume.rolling ((96).mean ((), यानी हाल के 1 दिन में लेन-देन की मात्रा और हाल के 3 दिनों में लेन-देन की मात्रा का अनुपात, हर 8 घंटे में एक बार।

लेन-देन की संख्या में परिवर्तन कारकःdf_count.rolling ((24) ।mean (() /df_count.rolling ((96) ।mean ((), यानी हाल के 1 दिन में लेन-देन की संख्या और हाल के 3 दिनों में लेन-देन की संख्या का अनुपात, हर 8 घंटे में एक बार।

एकल लेनदेन के मूल्य में परिवर्तन के कारकः - ((df_volume.rolling(24).mean() /df_count.rolling(24.mean()) /df_volume.rolling(24.mean() /df_count.rolling(96).mean()) एक दिन के कारोबार के मूल्य का पिछले तीन दिनों के कारोबार के मूल्य का अनुपात, हर 8 घंटे में एक बार। यह कारक भी कारोबार के कारक से अत्यधिक संबंधित है।

सक्रिय लेनदेन अनुपात परिवर्तन कारकःdf_buy_ratio.rolling ((24) ।mean (() /df_buy_ratio.rolling ((96).mean ((), यानी हाल के एक दिन में सक्रिय खरीद मात्रा और कुल लेनदेन का अनुपात हाल के 3 दिनों में लेनदेन मूल्य का अनुपात है, हर 8 घंटे में एक बार। यह कारक अभी भी प्रदर्शन करता है, और लेनदेन कारक के साथ बहुत कम संबंध है।

अस्थिरता कारकः ((df_close/df_open).rolling ((24)).std ((), एक निश्चित प्रभाव है।

कारोबार मात्रा और समापन मूल्य संबंध कारकःdf_close.rolling ((96).corr ((df_volume), हाल के 4 दिनों के समापन मूल्य के साथ कारोबार मात्रा संबंध कारक, समग्र प्रदर्शन अच्छा है।

यहां सूचीबद्ध केवल कुछ कारक हैं जो मात्रा-मूल्य के आधार पर हैं, वास्तव में कारक सूत्रों का संयोजन बहुत जटिल हो सकता है और कोई स्पष्ट तर्क नहीं हो सकता है। प्रसिद्ध ALPHA101 के कारक निर्माण का संदर्भ दिया जा सकता हैःhttps://github.com/STHSF/alpha101 。

#成交量
factor_volume = df_volume
factor_volume_res = Test(factor_volume, symbols, period=4)
factor_volume_res.total.plot(figsize=(15,6),grid=True);

#成交价
factor_close = df_close
factor_close_res = Test(factor_close, symbols, period=8)
factor_close_res.total.plot(figsize=(15,6),grid=True);

#成交笔数
factor_count = df_count
factor_count_res = Test(factor_count, symbols, period=8)
factor_count_res.total.plot(figsize=(15,6),grid=True);

print(df_count.corrwith(df_volume).mean())

0.9671246744996017

#3小时动量因子
factor_1 =  (df_close - df_close.shift(3))/df_close.shift(3)
factor_1_res = Test(factor_1,symbols,period=1)
factor_1_res.total.plot(figsize=(15,6),grid=True);

#24小时动量因子
factor_2 =  (df_close - df_close.shift(24))/df_close.shift(24)
factor_2_res = Test(factor_2,symbols,period=24)
tamenxuanfactor_2_res.total.plot(figsize=(15,6),grid=True);

#成交量因子
factor_3 = df_volume.rolling(24).mean()/df_volume.rolling(96).mean()
factor_3_res = Test(factor_3, symbols, period=8)
factor_3_res.total.plot(figsize=(15,6),grid=True);

#成交笔数因子
factor_4 = df_count.rolling(24).mean()/df_count.rolling(96).mean()
factor_4_res = Test(factor_4, symbols, period=8)
factor_4_res.total.plot(figsize=(15,6),grid=True);

#因子相关性
print(factor_4.corrwith(factor_3).mean())

0.9707239580854841

#单笔成交价值因子
factor_5 = -(df_volume.rolling(24).mean()/df_count.rolling(24).mean())/(df_volume.rolling(24).mean()/df_count.rolling(96).mean())
factor_5_res = Test(factor_5, symbols, period=8)
factor_5_res.total.plot(figsize=(15,6),grid=True);

print(factor_4.corrwith(factor_5).mean())

0.861206620552479

#主动成交比例因子
factor_6 = df_buy_ratio.rolling(24).mean()/df_buy_ratio.rolling(96).mean()
factor_6_res = Test(factor_6, symbols, period=4)
factor_6_res.total.plot(figsize=(15,6),grid=True);

print(factor_3.corrwith(factor_6).mean())

0.1534572192503726

#波动率因子
factor_7 = (df_close/df_open).rolling(24).std()
factor_7_res = Test(factor_7, symbols, period=2)
factor_7_res.total.plot(figsize=(15,6),grid=True);

#成交量和收盘价相关性因子
factor_8 = df_close.rolling(96).corr(df_volume)
factor_8_res = Test(factor_8, symbols, period=4)
factor_8_res.total.plot(figsize=(15,6),grid=True);

बहु-कारक संश्लेषण

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

समतुल्य नियम: सभी संश्लेषण कारक के लिए सभी भारों को जोड़कर, एक नया संश्लेषण उप-कारक प्राप्त होता है।

ऐतिहासिक कारक उपज के लिए भारः सभी संश्लेषण के लिए सभी कारकों को हाल की अवधि में ऐतिहासिक कारक उपज के लिए एक अंकगणितीय औसत के रूप में वजन के रूप में जोड़ा जाता है, जिससे नए संश्लेषण के बाद के कारकों को प्राप्त किया जाता है। इस विधि का प्रदर्शन करने वाले कारकों का वजन अधिक होता है।

अधिकतम आईसी_आईआर गुणांक विधिः एक ऐतिहासिक अवधि के लिए समग्र कारक औसत आईसी मूल्य को समग्र कारक के अगले चरण के आईसी मूल्य के अनुमान के रूप में, ऐतिहासिक आईसी मूल्य के संगत अंतर मैट्रिक्स को समग्र कारक के अगले चरण के उतार-चढ़ाव के अनुमान के रूप में, अधिकतम समग्र कारक आईसी_आईआर के सर्वोत्तम अधिकार पुनर्विक्रय को प्राप्त करने के लिए।

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

इस लेख में कारकों की प्रभावशीलता को मैन्युअल रूप से संदर्भित किया गया है।ae933a8c-5a94-4d92-8f33-d92b70c36119.pdf

सिंगल फैक्टर के परीक्षण के दौरान क्रम निश्चित होता है, लेकिन बहु-कारक संश्लेषण में पूरी तरह से अलग-अलग डेटा को एक साथ संयोजित करने की आवश्यकता होती है, इसलिए सभी कारकों को मानकीकृत करने की आवश्यकता होती है, आमतौर पर चरम और लापता मानों को हटाने की आवश्यकता होती है। यहाँ हमdf_volume\factor_1\factor_7\factor_6\factor_8 संश्लेषण का उपयोग करते हैं।

#标准化函数，去除缺失值和极值，并且进行标准化处理
def norm_factor(factor):
    factor = factor.dropna(how='all')
    factor_clip = factor.apply(lambda x:x.clip(x.quantile(0.2), x.quantile(0.8)),axis=1)
    factor_norm = factor_clip.add(-factor_clip.mean(axis=1),axis ='index').div(factor_clip.std(axis=1),axis ='index')
    return factor_norm


df_volume_norm = norm_factor(df_volume)
factor_1_norm = norm_factor(factor_1)
factor_6_norm = norm_factor(factor_6)
factor_7_norm = norm_factor(factor_7)
factor_8_norm = norm_factor(factor_8)

factor_total = 0.6*df_volume_norm + 0.4*factor_1_norm + 0.2*factor_6_norm + 0.3*factor_7_norm + 0.4*factor_8_norm
factor_total_res = Test(factor_total, symbols, period=8)
factor_total_res.total.plot(figsize=(15,6),grid=True);

सारांश

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

वास्तविक पताःhttps://www.fmz.com/robot/486605

संबंधित

अधिक