Modelo de factores de la moneda digital

[TOC] ¿Qué quieres decir?

Marco de modelos por factores

El informe de investigación del modelo multifactor de las bolsas de valores está repleto de teorías y prácticas. El mercado de monedas digitales, independientemente del número de monedas, el valor total de mercado, el volumen de transacciones, el mercado de derivados, etc., es suficiente para realizar un estudio factorial. Este artículo está dirigido principalmente a los principiantes en estrategias cuantitativas y no involucrará principios matemáticos y análisis estadísticos complejos.

Los factores pueden ser considerados como un indicador, pueden ser escritos como expresiones, los factores cambian constantemente y reflejan información de rendimiento futuro, y generalmente los factores representan una lógica de inversión.

Por ejemplo: el factor de cierre del precio de cierre, que se basa en la hipótesis de que el precio de las acciones puede predecir el rendimiento futuro, el precio de las acciones más alto, el rendimiento futuro más alto (o también puede ser menor), la construcción de un portafolio con este factor es en realidad un modelo de inversión / estrategia de compra de acciones de alto precio en turnos regulares. En términos generales, los factores que pueden generar rendimientos excedentes permanentes a menudo se llaman alfa. Por ejemplo, los factores de valor de mercado, los factores de movimiento y otros han sido verificados por el mundo académico y el mundo de los inversionistas como factores que han sido eficaces.

Tanto el mercado de valores como el mercado de monedas digitales son sistemas complejos, sin factores que puedan predecir completamente los rendimientos futuros, pero que aún tienen una cierta previsibilidad. Los alfa efectivos (modelos de inversión) y que se desmoronan gradualmente a medida que se invierten más fondos. Pero este proceso generará otros modelos en el mercado, dando lugar a nuevos alfa. Los factores de valor de mercado fueron una estrategia muy efectiva en el mercado de valores A. Fue una estrategia muy efectiva, simplemente comprar 10 acciones de valor mínimo de mercado, ajustarlas una vez al día, y obtener rendimientos de más de 400 veces más desde 2007, ganando mucho más que el disco.

Los factores que se buscan son la base para construir una estrategia, y se puede construir una mejor estrategia mediante la combinación de varios factores efectivos no 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

Fuentes de datos

Los datos de la línea K de principios de 2022 hasta la fecha, hasta la fecha, son más de 150 monedas. Como se dijo anteriormente, el modelo de factores es un modelo de monedas de opción, orientado a todas las monedas y no a una sola moneda. Los datos de la línea K incluyen precios de alta y baja entrada, transacciones, transacciones, compras activas, etc. Estos datos, por supuesto, no son la fuente de todos los factores, como el índice de acciones estadounidenses, las expectativas de aumento de los tipos de interés, los datos de rentabilidad en la cadena, el calor de los medios sociales, etc. Las fuentes de datos sin filtro también pueden descubrir un alfa efectivo, pero los datos de precios básicos son 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)

- ¿ Qué?

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

- ¿ Qué?

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)

- ¿ Qué?

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

Para comenzar, extraemos los datos que nos interesan de los datos de la línea K: precio de cierre, precio de apertura, volumen de transacciones, número de transacciones, porcentaje de compras activas, y procesamos los factores necesarios sobre la base de estos datos.

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

En general, el desempeño del índice de mercado es más sombrío, con un descenso del 60% desde el comienzo del año.

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

Determinación de la eficacia de los factores

• Ley de regresión En el siguiente período, la rentabilidad como variable causante, el factor a probar como variable de sí mismo, el coeficiente regresado es la rentabilidad del factor. Después de construir la ecuación de regresión, generalmente se hace referencia a la media del valor absoluto del valor del factor t, la proporción de la serie de valores absolutos del valor del factor t que es mayor que 2, la rentabilidad del factor anualizado, la volatilidad del factor anualizado, la Sharp de la ganancia del factor, entre otros parámetros para ver la eficacia y la volatilidad del factor. Se puede regresar a varios factores a la vez, con referencia a la documentación Barra.

• Indicadores como IC, IR y otros El IC es el coeficiente de correlación entre el factor y el rendimiento del próximo período, y ahora se usa generalmente el RANK_IC, que es el coeficiente de correlación entre el factor y el rendimiento del próximo período.

• Regresión por capas Este artículo utilizará este método, es decir, dividir las monedas en N grupos de acuerdo con el orden de los factores a probar, para realizar una recomposición de grupos y realizar operaciones de posicionamiento con ciclos fijos. Si es ideal, las ganancias de N grupos de monedas presentan una mejor monotonía, aumentan o disminuyen de forma monotonía, y cada grupo tiene una mayor brecha de ganancias. Estos factores se reflejan en una mejor diferenciación. Si el primer grupo obtiene el mayor rendimiento, el último grupo obtiene el menor rendimiento, se hace la primera combinación y se hace más vacía la última combinación, lo que se obtiene es la tasa de rendimiento, el indicador de referencia del índice de Sharpe.

Operaciones reales de retroevaluación

Se clasifican las monedas en espera en 3 grupos de acuerdo con el orden de los factores, de pequeño a grande, y cada grupo de monedas representa aproximadamente 1/3, si un factor es efectivo, la menor cantidad de cada componente suele tener una mayor rentabilidad, pero también significa que el capital asignado a cada moneda es relativamente mayor. Si el espacio es doblado por el doble de apalancamiento, el primer y el último grupo son 10 monedas, respectivamente, una proporción de peso es del 10%, si una moneda vacía sube el doble, el retiro es del 20%; si el grupo de puntuación correspondiente es de 50, el retiro.

La capacidad de predicción de los factores se puede evaluar generalmente en función de la rentabilidad final de la retrospección y de la proporción de Sharpe. También se requiere una referencia a la simplicidad de las expresiones de los factores, insensitivos al tamaño del grupo, insensitivos al intervalo de ajuste, insensitivos al tiempo inicial de la retrospección, etc.

En cuanto a la frecuencia de los cambios, los mercados de valores suelen tener ciclos de 5 días, 10 días y un mes, pero para los mercados de monedas digitales, estos ciclos son sin duda demasiado largos, y los mercados en el mercado real se monitorean en tiempo real, no es necesario volver a cambiar los cambios en un ciclo específico, por lo que en el mercado real somos cambios en tiempo real o de corto plazo.

En cuanto a cómo equilibrar, según el método tradicional, la próxima orden puede equilibrarse fuera del grupo; pero en el caso de la operación en tiempo real, algunas monedas pueden estar justo en el límite de la división y se producirá una situación de equilibración de regreso. Por lo tanto, esta estrategia adopta la forma de espera de cambios en el grupo, y se puede equilibrar de nuevo cuando se requiere un cambio de posición de dirección, como el primer grupo, cuando las monedas en estado de multifunción se dividen en un tercer grupo.

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

Pruebas de factores simples

Factor de transacción: las monedas con un bajo volumen de transacción y las monedas con un alto volumen de transacción funcionan muy bien, lo que indica que las monedas populares tienden a caer.

Los factores de precio de transacción: hacer monedas más baratas y monedas más baratas, el efecto general.

Factor del número de transacciones: El rendimiento y el número de transacciones son muy similares. Es evidente que la correlación entre el factor de transacción y el factor de transacción es muy alta, y en realidad es así, la correlación promedio de sus diferentes monedas es de 0.97, lo que indica que los dos factores son muy cercanos, lo que debe tenerse en cuenta cuando se componen múltiples factores.

3 h factor de movimiento: ((df_close - df_close.shift)) 3)) /df_close.shift ((3)); es decir, el aumento de 3 horas del factor, los resultados de la retrospección muestran que el aumento de 3 horas tiene una característica de regresión notable, es decir, que las subidas son más fáciles de bajar después. El rendimiento general es bueno, pero también hay un período de retroceso y oscilación más largo.

24h factor de movilidad: 24h de cambio de ciclo de posicionamiento de resultados buenos, ganancias cercanas a 3h de movilidad, retiro más pequeño.

Factor de cambio de volumen de transacción:df_volume.rolling ((24).mean (() /df_volume.rolling ((96).mean ((), es decir, la relación entre el volumen de transacción de un día reciente y el volumen de transacción de los últimos 3 días, una vez cada 8 horas.

Factor de cambio del número de transacciones:df_count.rolling ((24).mean (() /df_count.rolling ((96).mean ((), es decir, la relación entre el número de transacciones en el último día y el número de transacciones en los últimos 3 días, una vez cada 8 horas. Los resultados de retrospección funcionan mejor y el retraso es más bajo, lo que indica que el número de transacciones está más activo y tiende a caer.

Los factores de cambio en el valor de las transacciones: - ((df_volume.rolling(24).mean() /df_count.rolling(24.mean())/(df_volume.rolling(24.mean() /df_count.rolling(96).mean()) El valor de las transacciones en el último día es la relación entre el valor de las transacciones en el último día y el valor de las transacciones en los últimos 3 días, una vez cada 8 horas. Este factor también está altamente relacionado con el factor de volumen de transacciones.

Fator de cambio de la proporción de transacciones activas:df_buy_ratio.rolling ((24).mean (() /df_buy_ratio.rolling ((96).mean ((), es decir, la proporción de la cantidad de compras activas en el último día con la cantidad total de transacciones en el último día con la proporción del valor de las transacciones en los últimos 3 días, una vez cada 8 horas.

El factor de volatilidad: (df_close/df_open).rolling ((24).std ((), que hace que las monedas sean más o menos volátiles, tiene cierto efecto.

Fator de correlación entre el volumen de transacciones y el precio de cierre:df_close.rolling ((96).corr ((df_volume), el precio de cierre de los últimos 4 días tiene un factor de correlación entre el volumen de transacciones, el desempeño general es bueno.

Estos son sólo algunos de los factores que se basan en el precio de la cantidad, en realidad, las combinaciones de fórmulas de factores pueden ser muy complejas y no pueden tener una lógica obvia.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);

La síntesis de múltiples factores

La búsqueda constante de nuevos factores eficaces es la parte más importante del proceso de construcción de la estrategia, pero sin un buen método de síntesis de factores, los excelentes factores alfa individuales no pueden desempeñar su papel máximo.

Ley de la equivalencia: todos los factores de la síntesis se suman y se obtienen nuevos factores de la síntesis.

Ley de ponderación de la rentabilidad de los factores históricos: todos los factores a sintetizar se suman según el promedio aritmético de la rentabilidad de los factores históricos en el período más reciente y se obtienen nuevos factores post-síntesis.

Maximizar el valor de IC_IR: el valor de IC de la media del factor compuesto de un período histórico como una estimación del valor de IC del siguiente período del factor compuesto, la matriz de diferencia de coeficiente del valor de IC histórico como una estimación de la volatilidad del factor compuesto de la siguiente período, según el valor esperado de IC dividido por el error estándar de IC, se obtiene una reinterpretación óptima del factor compuesto maximizado IC_IR.

Análisis de componentes principales (PCA) método: PCA es un método común de reducción de dimensión de los datos, la correlación entre los factores puede ser relativamente alta, utilizando los componentes principales después de la reducción de dimensión como factor después de la síntesis.

En este artículo, se empodera manualmente el factor de referencia de eficacia.ae933a8c-5a94-4d92-8f33-d92b70c36119.pdf

El orden es fijo cuando se prueba un solo factor, pero la síntesis de múltiples factores requiere la combinación de datos completamente diferentes, por lo que se requiere un tratamiento estandarizado de todos los factores, generalmente eliminando los valores máximos y los valores perdidos. Aquí usamos la síntesis dedf_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);

Resumen

Este artículo presenta métodos de prueba de un solo factor y prueba de un solo factor común, presenta un principio de la síntesis de un solo factor, pero el contenido de la investigación de un factor es muy rico. El artículo menciona que cada punto puede desarrollarse en profundidad, que convertir la investigación de una variedad de estrategias en la búsqueda de un factor alfa es una vía viable, que utiliza la metodología de factores, que puede acelerar enormemente la verificación de las ideas de negociación y que tiene muchas referencias.

La dirección del lugar:https://www.fmz.com/robot/486605