Modelo de fatores de moeda digital

[TOC]

Estrutura do Modelo de Fatores

O estudo do modelo multifatorial do mercado de ações é repleto de teorias e práticas. O mercado de moedas digitais, seja qual for o número de moedas, o valor total do mercado, o volume de transações, o mercado de derivativos, etc., é suficiente para satisfazer o estudo fatorial. Este artigo é voltado principalmente para iniciantes em estratégias de quantificação, não envolve princípios matemáticos complexos e análise estatística.

O fator pode ser visto como um indicador, pode ser escrito como uma expressão, o fator está sempre mudando, refletindo informações de ganhos futuros, geralmente o fator representa uma lógica de investimento.

Por exemplo: o fator de fechamento do preço de fechamento, que é o fato de que o preço do estoque pode prever o retorno futuro, e o preço do estoque mais alto, o retorno futuro mais alto (ou talvez mais baixo), é um modelo de investimento / estratégia para comprar ações de alto preço em turnos regulares. Em geral, os fatores que podem gerar retorno excessivo de forma contínua são muitas vezes chamados de alfa.

Tanto o mercado de ações como o mercado de moeda digital são sistemas complexos, não há fatores que possam prever completamente os rendimentos futuros, mas ainda assim têm uma certa previsibilidade. Um alfa eficaz (modelo de investimento) e, gradualmente, falha com a entrada de mais fundos. Mas esse processo irá gerar outros padrões no mercado, gerando novos alfa. O fator de valor foi uma estratégia muito eficaz no mercado de ações A. Simplesmente comprar 10 ações de menor valor de mercado, ajustando uma vez por dia, obtém mais de 400 vezes o retorno, superando o recorde desde 2007, mas o grande fator de valor das ações de 2017 reflete o fracasso do fator de pequeno mercado, o fator de valor, em vez disso, se popularizou.

Os fatores procurados são a base para a construção de uma estratégia, e uma estratégia melhor pode ser construída através da combinação de vários fatores eficazes não relacionados.

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

Fonte de dados

Os dados da linha K da hora do início de 2022 até hoje, até o momento, são mais de 150 moedas. Como dito anteriormente, o modelo de fator é um modelo de moeda opcional voltado para todas as moedas, e não para uma moeda específica. Os dados da linha K contêm dados sobre preços de alta e baixa, transações, transações, compras ativas e outros dados, que, obviamente, não são a fonte de todos os fatores, como o índice de ações dos EUA, expectativas de aumento de juros, dados de rentabilidade na cadeia, calor da mídia social, etc. As fontes de dados fechadas também podem descobrir um alfa eficaz, mas os dados de preços básicos também são suficientes.

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

Fora:

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

Fora:

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)

Fora:

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

---

Inicialmente, extraímos os dados de nosso interesse a partir dos dados da linha K: preço de fechamento, preço de abertura, volume de transações, número de transações, proporção de compras ativas e, com base nesses dados, processamos os fatores necessários.

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

O índice de mercado, que caiu 60% desde o início do ano, é um pouco mais sombrio.

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

Determinação da eficácia do fator

• Regressão O período seguinte é o de rendimento como variável causada, o fator a ser testado como variável autônomo, o fator de retorno é o fator de retorno. Após a construção da equação de retorno, geralmente se refere ao valor absoluto médio do fator t, a proporção da seqüência de valores absolutos do fator t maior que 2, o fator de retorno anual, a taxa de flutuação do fator de retorno anual, o fator de retorno Sharpe do fator de retorno, entre outros parâmetros para ver a eficácia e a volatilidade do fator.

• Indicadores como IC, IR O chamado IC é o coeficiente de correlação entre o fator e o rendimento do próximo período, agora geralmente usado como Rank_IC, ou seja, o coeficiente de correlação entre o ranking do fator e o rendimento do próximo período de ações. IR é geralmente o valor médio da sequência de IC / o diferencial padrão da sequência de IC.

• Regresso por camadas Este artigo usará esse método, que consiste em dividir as moedas em N grupos de acordo com a ordem dos fatores a serem testados, para fazer um regrupo e usar um ciclo fixo para fazer a troca. Se o caso for ideal, os rendimentos das moedas N grupos apresentarão uma melhor monotonia, aumentando ou diminuindo monotonicamente e com um maior diferencial de rendimentos em cada grupo. Esse fator se traduz em uma melhor distinção.

Operações reais de retrospecção

De acordo com os fatores, classificar as moedas pendentes em 3 grupos de acordo com o ordenamento, de pequeno a grande, com cada grupo de moedas representando cerca de 1/3, o menor de cada componente geralmente tem um maior rendimento se um fator for eficaz, mas também significa que o capital distribuído para cada moeda é relativamente maior. Se o espaço for duplicado, o primeiro e o último grupo de 10 moedas, respectivamente, uma proporção é de 10%, se um tipo de moeda estiver vazio aumenta duas vezes, retira 20%; se o grupo de divisões for 50, retira. 4% de moedas dispersas podem reduzir o risco de catástrofes negras.

Geralmente, a capacidade de previsão de fatores é avaliada de forma aproximada com base no rendimento final da retrospecção e na proporção de Sharpe. Além disso, é necessário referir se a expressão de fatores é simples, insensível ao tamanho do agrupamento, insensível ao intervalo de modulação, insensível ao tempo inicial da retrospecção, etc.

No que diz respeito à frequência de reajustes, os mercados de ações tendem a ser de 5, 10 dias e um mês em ciclos, mas para o mercado de moeda digital, esses ciclos são sem dúvida muito longos e os mercados em campo real são monitorados em tempo real. Não é necessário reajustar os mercados em um ciclo específico, portanto, em campo real somos reais ou de curto prazo.

No que diz respeito ao equilíbrio, segundo o método tradicional, a próxima classificação pode ser feita fora do grupo; no entanto, no caso de negociação em tempo real, algumas moedas podem estar bem no limite da divisão e haverá uma situação de equilíbrio de volta. Portanto, esta estratégia usa o modo de equilíbrio de espera para mudanças no grupo e para fazer o equilíbrio novamente quando a posição de direção inversa for necessária.

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

Testes de fatores simples

Fator de troca: simplesmente fazer moedas com baixo volume de troca e fazer moedas com alto volume de troca, o que mostra que as moedas populares tendem a cair.

Os fatores de preço de transação: fazer moeda mais barata e moeda mais barata, efeito geral.

Fator de transação: o desempenho e o volume de transações são muito semelhantes. É óbvio que a correlação entre o fator de transação e o fator de transação é muito alta, o que é verdade, com uma correlação média de 0,97 entre as diferentes moedas, o que indica que os dois fatores são muito próximos, o que deve ser considerado quando se sintetiza um fator múltiplo.

3h fator de movimento: ((df_close - df_close.shift)) 3)) /df_close.shift ((3)); isto é, o aumento de 3 horas do fator, os resultados da retrospecção mostram que o aumento de 3 horas tem uma característica de regressão evidente, ou seja, o aumento é mais fácil de cair em seguida. O desempenho geral é bom, mas também há um período de retração e oscilação mais longo.

O resultado do ciclo de negociação de 24h é bom, com ganhos próximos ao de 3h e recuo menor.

O fator de mudança de volume de negociação:df_volume.rolling ((24).mean (() /df_volume.rolling ((96).mean ((), ou seja, a relação entre o volume de negociação de um dia recente e o valor do volume de negociação de três dias recentes, ajustando os negócios a cada 8 horas. Os resultados de retrospecção apresentam um desempenho melhor e o recuo é menor, o que indica que os negócios estão ativos e tendem a cair.

Fator de variação do número de transações:df_count.rolling ((24).mean (() /df_count.rolling ((96).mean ((), ou seja, a relação entre o número de transações no último dia 1 e o número de transações nos últimos 3 dias, ajustando a posição uma vez a cada 8h. Os resultados de retrospecção apresentam um desempenho melhor, o recuo também é menor, o que indica que o número de transações aumenta ativamente e tende a cair.

Os fatores de variação no valor de uma transação: - ((df_volume.rolling(24).mean()/df_count.rolling(24.mean())/(df_volume.rolling(24.mean()/df_count.rolling ((96).mean()) O valor de transação no último dia é a proporção do valor de transação nos últimos 3 dias, uma vez a cada 8 horas. Este fator também está altamente relacionado ao fator de volume de transações.

Fator de variação da taxa de transação ativa:df_buy_ratio.rolling ((24).mean (() /df_buy_ratio.rolling ((96).mean ((), ou seja, a relação entre o volume de compra ativa no último dia e o total de transações realizadas no último dia e a relação entre o valor das transações realizadas nos últimos 3 dias, uma vez a cada 8 horas.

O fator de volatilidade: (df_close/df_open).rolling ((24).std ((), fazendo moedas com pouca volatilidade, tem um certo efeito.

Fator de correlação entre o volume de transações e o preço de fechamento:df_close.rolling ((96).corr ((df_volume), o preço de fechamento dos últimos 4 dias tem um fator de correlação entre o volume de transações e o desempenho geral é bom.

Estes são apenas alguns fatores baseados no preço da quantidade, mas a verdade é que as combinações de fórmulas podem ser muito complexas e não podem ter uma lógica óbvia.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);

Síntese de múltiplos factores

A busca constante de novos fatores eficazes é a parte mais importante do processo de construção da estratégia, mas sem um bom método de síntese de fatores, um bom alfa individual não pode desempenhar o seu papel máximo.

Lei da equivalência: todos os pesos de todos os fatores de síntese são adicionados para obter um novo fator de síntese.

O método de ponderação do rendimento dos fatores históricos: todos os fatores a serem sintetizados são somados como um peso de média aritmética do rendimento dos fatores históricos durante o período mais recente para obter um novo fator pós-síntese.

Maximizar o IC_IR em função da ponderação: usando o valor médio do IC do fator composto de um período histórico como estimativa do valor do IC do próximo período do fator composto, usando a matriz de diferença de correlação do valor do IC histórico como estimativa da volatilidade do fator composto do próximo período, pode-se obter a reformulação privilegiada do factor composto máximo IC_IR com base no valor esperado do IC dividido pelo diferencial padrão do IC.

Análise de componentes principais (PCA): PCA é um método comum de diminuição de dados, e a correlação entre os fatores pode ser relativamente alta, usando os componentes principais após a diminuição como fatores após a síntese.

Este artigo é sobre a habilitação manual da eficácia dos fatores de referência. Os métodos descritos acima podem ser usados:ae933a8c-5a94-4d92-8f33-d92b70c36119.pdf

O ordenamento é fixo quando testado com um único fator, mas a síntese multifatorial requer a combinação de dados completamente diferentes e, portanto, o tratamento padronizado de todos os fatores, geralmente eliminando o valor máximo e o tratamento de valores perdidos. Aqui usamos a síntesedf_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);

Resumo

Este artigo apresenta o método de teste de um único fator e testa o fator comum, introduz o método de síntese do fator, mas o estudo do fator é muito rico. O artigo menciona que cada ponto pode ser desenvolvido em profundidade. Transformar o estudo de uma variedade de estratégias para a descoberta do fator alfa é um caminho viável.

O endereço do local:https://www.fmz.com/robot/486605

Relacionados

Mais.