Faktormodell für digitale Währungen

[TOC]

Faktormodellrahmen

Die Studie über die Multifaktormodelle der Aktienmärkte ist reich an Theorien und Praktiken. Der Markt für digitale Währungen ist ausreichend, um eine Faktorstudie durchzuführen, unabhängig von der Anzahl der Münzen, dem Gesamtmarktwert, dem Handelsvolumen, dem Derivatemarkt usw. Dieser Artikel richtet sich hauptsächlich an Anfänger in der Quantitativstrategie und bezieht sich nicht auf komplexe mathematische Prinzipien und statistische Analysen.

Ein Faktor kann als Indikator betrachtet werden, kann in einer Ausdrucksform geschrieben werden, der sich ständig ändert und zukünftige Ertragsinformationen widerspiegelt, und stellt in der Regel eine Investitionslogik dar.

Zum Beispiel: der Faktor, der den Schlusskurs schließt, ist die Annahme, dass der Aktienpreis die zukünftige Rendite prognostizieren kann, und je höher der Aktienpreis, desto höher (oder möglicherweise niedriger) ist die zukünftige Rendite.

Sowohl der Aktienmarkt als auch der digitale Währungsmarkt sind ein komplexes System, in dem es keine Faktoren gibt, die die zukünftige Rendite vollständig vorhersagen können, aber trotzdem eine gewisse Vorhersagbarkeit haben. Effektive Alpha (Investmentmodelle) und schrittweise versagen, wenn mehr Geld eingesetzt wird. Aber dieser Prozess wird andere Modelle in den Markt erzeugen, wodurch neue Alphas entstehen. Der Marktwertfaktor war einmal eine sehr effektive Strategie auf dem A-Aktienmarkt.

Die Suche nach Faktoren bildet die Grundlage für die Strategie, und eine bessere Strategie kann durch die Kombination mehrerer unabhängiger Wirksamkeitsfaktoren aufgebaut werden.

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

Datenquelle

Die K-Linien-Daten für die Stunde Anfang 2022 bis heute liegen bei mehr als 150 Währungen. Wie bereits erwähnt, ist das Faktormodell ein Optionsmodell, das sich an alle Währungen und nicht an eine bestimmte Währung orientiert. Die K-Linien-Daten enthalten Daten über Preise, Transaktionen, Transaktionen, aktive Käufe und andere Faktoren, die natürlich nicht alle Faktoren wie US-Aktienindex, Zinserhöhungen, Profitabilitätsdaten an der Kette, Social Media-Hitze usw. ausmachen.

## 当前交易对
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)

Ausgeschaltet:

['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))

Ausgeschaltet:

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)

Ausgeschaltet:

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

Zunächst werden aus den Daten der K-Linie die Daten extrahiert, die uns interessieren: Schlusskurs, Eröffnungskurs, Transaktionsvolumen, Transaktionszahl, Anteil der aktiven Käufe, und auf der Grundlage dieser Daten werden die Faktoren, die benötigt werden, verarbeitet.

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')

Der Markt verzeichnete eine relativ schlechte Entwicklung, mit einem Rückgang von 60% seit Jahresbeginn.

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

Faktorische Wirksamkeit bestimmt

• Regressionsrecht In der folgenden Phase werden die Ertragsraten als Faktorvariablen, die zu prüfenden Faktoren als Eigenvariablen, die zurückgegebenen Koeffizienten oder die Ertragsquote der Faktoren verwendet. Nach der Konstruktion der Regressionsgleichung wird im Allgemeinen auf die absolute Mittelwerte der Koeffizienten t-Werte, den Anteil der Absolute-Werte der Koeffizienten t-Werte, die größer als 2 sind, die jährliche Ertragsquote, die jährliche Ertragsquote, die Ertragsfluktuationsrate, die Schärfe der Faktoren gewinnen, um die Effektivität und Volatilität der Faktoren zu bestimmen.

• Indikatoren wie IC, IR Der so genannte IC ist der Koeffizient zwischen der Faktor- und der nächsten Periodenrendite, der jetzt auch allgemein mit RANK_IC verwendet wird.

• Schichtungsregression In diesem Artikel wird mit dieser Methode, die N-Gruppen nach der Sortierung der zu testenden Faktoren zu unterteilen und zu gruppieren, um die Operationen der Positionierung mit einer festen Periode durchzuführen. Idealerweise zeigt die Rendite der N-Gruppen eine bessere Einheitlichkeit, einheitliche Zunahme oder Abnahme, und die Ertragsdifferenz in jeder Gruppe ist groß.

Wirkliche Rückmessung

Nach der Reihenfolge der Faktoren von klein bis groß wird die ausgesuchte Währung in 3 Gruppen aufgeteilt, wobei jede Gruppe etwa 1/3 beträgt. Weniger von jeder Komponente ist oft höher, wenn ein Faktor wirksam ist, aber es bedeutet auch, dass für jede Währung ein relativ hohes Kapital zugeteilt wird. Wenn mehrere Leerstände doppelt so hoch sind, beträgt ein Anteil von 10%, wenn eine leere Währung doppelt so hoch ist, 20%; wenn die entsprechende Komponentezahl 50 beträgt, zurückgezogen.

Die Fähigkeit zur Faktorprognose kann in der Regel anhand der endgültigen Retest-Erträge und des Sharpe-Ratums grob beurteilt werden. Außerdem ist darauf zu achten, ob die Faktorenerklärungen einfach sind, unempfindlich gegenüber der Gruppengröße, unempfindlich gegenüber dem Standortintervall, unempfindlich gegenüber der Anfangszeit der Retestung usw.

In Bezug auf die Frequenz der Anpassung sind die Aktienmärkte häufig fünf-, zehn- und monatlich, aber für den digitalen Währungsmarkt sind solche Zyklen zweifellos zu lang, und der Markt wird in Echtzeit überwacht, so dass es nicht notwendig ist, einen bestimmten Zyklus zu halten.

Wie man einbricht, kann nach der traditionellen Methode beim nächsten Sortieren nicht in der Gruppe ausgeglichen werden. Aber bei einem Echtzeit-Sortierungsszenario können einige Währungen genau an der Grenze liegen und es kann zu einem Rück- und Rück-Plazing kommen. Daher wird die Strategie mit einer Wartezeit für die Veränderung der Gruppe angewendet, wenn die Position in der Umkehrung der Richtung erforderlich ist, um wieder ausgeglichen zu werden, z. B. wenn die erste Gruppe mehr ist, wenn die Währungen in mehreren Zuständen in die dritte Gruppe eingeteilt werden.

#回测引擎
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)

Einfache Faktorentests

Handelsauswirkung: Einfach mehr als weniger gehandelte Währungen und weniger als viel gehandelte Währungen, die sehr gut abschneiden. Dies zeigt, dass beliebte Währungen eher nach unten neigen.

Die Transaktionspreisfaktoren sind: Mehrpreis niedrige Währung, Mehrpreis hohe Währung, Effekt allgemein.

Transaktionsfaktor: Die Performance und die Transaktionsmenge sind sehr ähnlich. Es ist deutlich zu bemerken, dass die Korrelation zwischen Transaktionsfaktor und Transaktionsfaktor sehr hoch ist, was in der Praxis auch der Fall ist. Die durchschnittliche Korrelation zwischen ihren verschiedenen Währungen beträgt 0,97, was zeigt, dass die beiden Faktoren sehr nahe beieinander liegen und bei der Synthese von Multifaktoren berücksichtigt werden muss.

3h-Motionsfaktor: ((df_close - df_close.shift)) 3)) /df_close.shift ((3)); d. h. ein 3-stündiger Anstieg des Faktors. Die Rücktests zeigen, dass ein 3-stündiger Anstieg eine deutliche Regressionscharakteristik aufweist, d. h. der Aufstieg ist in der Folge leichter zu fallen.

24h-Motionalitätsfaktor: Die Ergebnisse der 24-h-Anpassungszyklen sind gut, die Gewinne sind nahe der 3-h-Motionalität und der Rückzug kleiner.

Der Wechselkursfaktor:df_volume.rolling ((24).mean (() /df_volume.rolling ((96).mean ((), d.h. das Verhältnis zwischen den letzten 1 Tage und den letzten 3 Tagen. Alle 8 Stunden wird ein Wechselkurs angepasst.

Die Anzahl der Transaktionen verändert sich mit dem Faktor:df_count.rolling ((24).mean (() /df_count.rolling ((96).mean ((), d.h. das Verhältnis der Anzahl der Transaktionen in den letzten 1 Tagen zu der Anzahl der Transaktionen in den letzten 3 Tagen, die alle 8 Stunden angepasst werden.

Die Veränderungsfaktoren für den Wert der Transaktionen: - ((df_volume.rolling(24).mean() /df_count.rolling(24.mean())/(df_volume.rolling(24.mean() /df_count.rolling ((96).mean()) Der Wert der Transaktionen in den letzten 3 Tagen ist das Verhältnis zwischen dem Wert der Transaktionen in den letzten 1 Tag und dem Wert der Transaktionen in den letzten 3 Tagen. Dieser Faktor ist ebenfalls stark mit dem Faktor der Transaktionen verbunden.

Der Wechselfaktor der aktiven Transaktionsquote:df_buy_ratio.rolling ((24).mean (() /df_buy_ratio.rolling ((96).mean ((), also das Verhältnis der aktiven Einkaufsmenge zum Gesamttransaktionsvolumen des letzten Tages zum Verhältnis des Transaktionswerts der letzten 3 Tage, wird alle 8 Stunden angepasst.

Der Faktor für die Volatilität: ((df_close/df_open).rolling ((24)).std (()) hat eine gewisse Wirkung.

Der Handel ist in den letzten vier Tagen sehr gut gelaufen. Der Handel ist in den letzten vier Tagen sehr gut gelaufen.

Hier sind nur einige Faktoren auf Basis von Quantität und Preis aufgeführt, in der Tat können Kombinationen von Faktorenformeln sehr komplex sein, ohne dass eine offensichtliche Logik besteht.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);

Multifaktor-Synthese

Die ständige Erforschung neuer Wirksamkeitsfaktoren ist zwar der wichtigste Teil des Strategiebauprozesses, aber ohne eine gute Faktor-Synthese kann auch ein hervorragender einzelner Alpha-Faktor nicht seine maximale Rolle spielen.

Gleichgewichtsgesetz: Alle Gewichte der zu synthetisierenden Faktoren werden addiert, um einen neuen synthetischen Nachfaktor zu erhalten.

Historische Faktorrendite Gewichtung: Alle zu synthetisierenden Faktoren werden nach dem arithmetischen Durchschnitt der historischen Faktorrendite in der jüngsten Periode als Gewichtung addiert, um einen neuen synthetischen Nachfaktor zu erhalten.

Maximierung der IC_IR-Wertung: Die maximale Überschreitung der IC_IR-Wertung wird mit dem durchschnittlichen IC-Wert des Komplexfaktors in einem historischen Zeitraum als Schätzung des IC-Wertes des Komplexfaktors in der nächsten Periode, mit der korrelativen Differenzmatrix des historischen IC-Wertes als Schätzung der Komplexfaktor-Wochrate in der nächsten Periode ermittelt.

PCA-Methode: PCA ist eine häufig verwendete Methode zur Datenreduktion, bei der die Korrelation zwischen den Faktoren möglicherweise relativ hoch ist und die Hauptkomponente nach der Reduktion als Faktor nach der Synthese verwendet wird.

In diesem Artikel werden die Effektivitätsbefugnisse der Faktoren manuell verwiesen.ae933a8c-5a94-4d92-8f33-d92b70c36119.pdf

Bei Tests mit einzelnen Faktoren ist die Reihenfolge festgesetzt, aber bei Multifaktor-Synthese müssen völlig verschiedene Daten zusammengeführt werden, sodass alle Faktoren standardisiert behandelt werden müssen.

#标准化函数，去除缺失值和极值，并且进行标准化处理
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);

Zusammenfassung

Dieser Artikel stellt die Testmethode des Einfachters vor und prüft die üblichen Einfachter, gibt eine anfängliche Einführung in die Methode der Multifaktor-Synthese, aber die Multifaktor-Studie ist sehr reichhaltig.

Die Adresse des Platzes:https://www.fmz.com/robot/486605