Investigación sobre la estrategia de cobertura de divisas de futuros de Binance Parte 1

El autor:La bondad, Creado: 2020-05-09 11:14:50, Actualizado: 2023-11-04 19:49:01

Haga clic en el botón de búsqueda en la página del panel de control, y luego haga clic en la flecha para ingresar. Abra el archivo de sufijo.pynb cargado y presione shift + enter para ejecutar línea por línea. Hay tutoriales básicos en la ayuda de uso del entorno de investigación.

Razones estratégicas

Binance ha listado muchas altcoins en el lugar. Aunque las fluctuaciones a corto plazo son inciertas, si miras la línea diaria durante mucho tiempo, encontrarás que básicamente han caído más del 90%, y algunas incluso solo tienen fracciones de la fracción de precio más alta. Sin embargo, no existe un método universal de venta corta para el lugar, y no hay una recomendación especial excepto no tocar la altcoin. En los últimos dos meses, Binance Futures ha lanzado más de 20 contratos perpetuos, la mayoría de los cuales son monedas convencionales, y algunos son desconocidos. Esto nos da los medios para resumir estas combinaciones de altcoins.

Principios de la estrategia

La primera estrategia: Vender a corto la cesta seleccionada de altcoins en un equivalente descentralizado, y al mismo tiempo comprar a largo la misma cantidad de posición BTC para cubrir, con el fin de reducir los riesgos y la volatilidad.

La segunda estrategia: cortocircuitar monedas con un precio superior al índice de precios altcoin-bitcoin, y anhelar con monedas inferiores al índice, cuanto mayor sea la desviación, mayor será la posición.

# Libraries to import
import pandas as pd
import requests
import matplotlib.pyplot as plt
import seaborn as sns
import numpy as np
%matplotlib inline

Mostrar la moneda requerida

El contrato perpetuo de Binance actualmente incluye monedas, que se pueden obtener utilizando su interfaz API, son un número total de 23 (excluyendo BTC).

#Info = requests.get('https://fapi.binance.com/fapi/v1/exchangeInfo')
#symbols = [symbol_info['baseAsset'] for symbol_info in Info.json()['symbols']]
symbols = ['ETH', 'BCH', 'XRP', 'EOS', 'LTC', 'TRX', 'ETC', 'LINK', 'XLM', 'ADA', 'XMR', 'DASH', 'ZEC', 'XTZ', 'BNB', 'ATOM', 'ONT', 'IOTA', 'BAT', 'VET', 'NEO', 'QTUM', 'IOST']

Primero, estudiemos el movimiento de precios de altcoins a Bitcoin en el último año. He descargado los datos por adelantado y los he publicado en el foro, que se pueden citar directamente en el entorno de investigación.

price_btc = pd.read_csv('https://www.fmz.com/upload/asset/1ef1af8ec28a75a2dcb.csv', index_col = 0)
price_btc.index = pd.to_datetime(price_btc.index,unit='ms') #Index date

price_btc.tail()

Resultados:

5 filas × 23 columnas

Primero dibujar los precios de estas monedas para ver la tendencia, los datos deben ser normalizados.

price_btc_norm = price_btc/price_btc.fillna(method='bfill').iloc[0,]
price_btc_norm.plot(figsize=(16,6),grid = True,legend=False);

Al ordenar los últimos cambios de precios, puede encontrar varias monedas que son obviamente diferentes, a saber, LINK, XTZ, BCH, ETH. Explica que a menudo pueden ejecutar su propia tendencia, y que hacerlos a corto tiene un mayor riesgo y debe excluirse de la estrategia.

Dibuje un mapa de calor del coeficiente de correlación de las monedas restantes y descubra que la tendencia de ETC y ATOM también es relativamente especial y puede excluirse.

price_btc_norm.iloc[-1,].sort_values()[-5:]

Resultados:

ETH     0.600417
ETC     0.661616
BCH     1.141961
XTZ     2.512195
LINK    2.764495
Name: 2020-03-25 00:00:00, dtype: float64

trade_symbols = list(set(symbols)-set(['LINK','XTZ','BCH', 'ETH'])) # Remaining currencies

plt.subplots(figsize=(12, 12)) # Set the screen size
sns.heatmap(price_btc[trade_symbols].corr(), annot=True, vmax=1, square=True, cmap="Blues");

La última moneda restante cayó en un promedio de 66% al año, obviamente hay un amplio margen para el cortocircuito. Sintetizando la tendencia de estas monedas en el índice de precios de altcoin, se encontró que básicamente cayó todo el camino, fue más estable en la segunda mitad del año pasado, y comenzó a caer todo el camino este año.

Debe tenerse en cuenta que el índice actual de altcoin está en el punto más bajo del año pasado. Tal vez no es una oportunidad corta, sino una oportunidad de compra larga. usted tiene que decidirlo por sí mismo.

trade_symbols = list(set(symbols)-set(['LINK','XTZ','BCH', 'ETH', 'ETC','ATOM','BNB','EOS','LTC'])) # You can set the remaining currencies, which you want to subtract.
1-price_btc_norm[trade_symbols].iloc[-1,].mean()

Resultados:

0.6714306758250285

price_btc_norm[trade_symbols].mean(axis=1).plot(figsize=(16,6),grid = True,legend=False);

Datos de sostenibilidad de Binance

Del mismo modo, los datos sobre la Sostenibilidad de Binance se han recopilado, también puede citarlos directamente en su cuaderno, los datos son la línea K del mercado de 1h del 28 de enero al 31 de marzo de 2020, porque la mayoría de los contratos perpetuos de Binance se han almuerzado solo dos meses, por lo que los datos son suficientes para backtest.

price_usdt = pd.read_csv('https://www.fmz.com/upload/asset/20227de6c1d10cb9dd1.csv ', index_col = 0)
price_usdt.index = pd.to_datetime(price_usdt.index)

price_usdt.tail()

Resultados:

En la actualidad, la tendencia de los precios de los automóviles en el mercado se ha convertido en un descenso de los precios de los automóviles en los últimos años, lo que demuestra que el riesgo de un contrato perpetuo también es muy alto.

price_usdt_norm = price_usdt/price_usdt.fillna(method='bfill').iloc[0,]
price_usdt_norm.plot(figsize=(16,6),grid = True,legend=False);

Dibujar el precio del índice de la moneda que queremos vender contra Bitcoin, el principio de la estrategia es corto esta curva, y el retorno es básicamente el inverso de esta curva.

price_usdt_btc = price_usdt.divide(price_usdt['BTC'],axis=0)
price_usdt_btc_norm = price_usdt_btc/price_usdt_btc.fillna(method='bfill').iloc[0,]
price_usdt_btc_norm[trade_symbols].mean(axis=1).plot(figsize=(16,6),grid = True);
#price_usdt_btc_norm.mean(axis=1).plot(figsize=(16,6),grid = True,legend=False);

Motor de prueba posterior

Debido a que el backtest local de FMZ no tiene datos para todas las monedas y no admite backtest multi-moneda, es necesario volver a implementar un motor de backtest. Así que escribí un nuevo motor de backtest, es relativamente simple, pero básicamente suficiente. Teniendo en cuenta la tarifa de transacción, pero básicamente ignoró la tasa de capital, no consideró la situación de mantener el capital de margen. Se registraron el capital total, el margen ocupado y el apalancamiento. Dado que esta estrategia tiene el atributo de que la posición larga es igual a la posición corta, por lo que el impacto de las tasas de capital no es significativo.

La prueba de retroceso no tiene en cuenta la situación de deslizamiento de precios, puede aumentar la simulación de la tarifa de transacción por sí mismo, teniendo en cuenta la baja tarifa de transacción del creador de Binance, incluso la diferencia de diferencia de precios en el mercado de divisas impopular es muy pequeña, puede usar el método de comisión de iceberg en el mercado real al realizar un pedido, el impacto no debería ser significativo.

Cuando se crea un objeto de intercambio, se debe especificar la moneda a negociar. Comprar es largo y Vender es corto. Debido a la limitación del contrato perpetuo, al abrir la posición, las posiciones largas y cortas se cierran automáticamente juntas. Al vender la posición corta y el número de monedas son negativos. Los parámetros son los siguientes:

trade_symbols: lista de las monedas que se negociarán
apalancamiento: apalancamiento, margen de efecto,
Comisión: tasa de transacción, por defecto 0,00005
balance inicial: activo inicial, valoración en USDT
registro: si se imprimen los registros de transacciones

class Exchange:
    
    def __init__(self, trade_symbols, leverage=20, commission=0.00005,  initial_balance=10000, log=False):
        self.initial_balance = initial_balance # Initial asset
        self.commission = commission
        self.leverage = leverage
        self.trade_symbols = trade_symbols
        self.date = ''
        self.log = log
        self.df = pd.DataFrame(columns=['margin','total','leverage','realised_profit','unrealised_profit'])
        self.account = {'USDT':{'realised_profit':0, 'margin':0, 'unrealised_profit':0, 'total':initial_balance, 'leverage':0}}
        for symbol in trade_symbols:
            self.account[symbol] = {'amount':0, 'hold_price':0, 'value':0, 'price':0, 'realised_profit':0, 'margin':0, 'unrealised_profit':0}
            
    def Trade(self, symbol, direction, price, amount, msg=''):
        if self.date and self.log:
            print('%-20s%-5s%-5s%-10.8s%-8.6s %s'%(str(self.date), symbol, 'buy' if direction == 1 else 'sell', price, amount, msg))
            
        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.commission # Minus transaction fee
        
        if cover_amount > 0: # close position first
            self.account['USDT']['realised_profit'] += -direction*(price - self.account[symbol]['hold_price'])*cover_amount  # profit
            self.account['USDT']['margin'] -= cover_amount*self.account[symbol]['hold_price']/self.leverage # Free the margin
            
            self.account[symbol]['realised_profit'] += -direction*(price - self.account[symbol]['hold_price'])*cover_amount
            self.account[symbol]['amount'] -= -direction*cover_amount
            self.account[symbol]['margin'] -=  cover_amount*self.account[symbol]['hold_price']/self.leverage
            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['USDT']['margin'] +=  open_amount*price/self.leverage            
            self.account[symbol]['hold_price'] = total_cost/total_amount
            self.account[symbol]['amount'] += direction*open_amount
            self.account[symbol]['margin'] +=  open_amount*price/self.leverage
            
        self.account[symbol]['unrealised_profit'] = (price - self.account[symbol]['hold_price'])*self.account[symbol]['amount']
        self.account[symbol]['price'] = price
        self.account[symbol]['value'] = abs(self.account[symbol]['amount'])*price
        
        return True
    
    def Buy(self, symbol, price, amount, msg=''):
        self.Trade(symbol, 1, price, amount, msg)
        
    def Sell(self, symbol, price, amount, msg=''):
        self.Trade(symbol, -1, price, amount, msg)
        
    def Update(self, date, close_price): # Update assets
        self.date = date
        self.close = close_price
        self.account['USDT']['unrealised_profit'] = 0
        for symbol in self.trade_symbols:
            if np.isnan(close_price[symbol]):
                continue
            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']['unrealised_profit'] += self.account[symbol]['unrealised_profit']
            if self.date.hour in [0,8,16]:
                pass
                self.account['USDT']['realised_profit'] += -self.account[symbol]['amount']*close_price[symbol]*0.01/100
        
        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']['margin']/self.account['USDT']['total'],4)*self.leverage
        self.df.loc[self.date] = [self.account['USDT']['margin'],self.account['USDT']['total'],self.account['USDT']['leverage'],self.account['USDT']['realised_profit'],self.account['USDT']['unrealised_profit']]

# First test the backtest engine
e = Exchange(['BTC','XRP'],initial_balance=10000,commission=0,log=True)

e.Buy('BTC',100, 5)
e.Sell('XRP',10, 50)

e.Sell('BTC',105,e.account['BTC']['amount'])
e.Buy('XRP',9,-e.account['XRP']['amount'])

round(e.account['USDT']['realised_profit'],4)

75.0

El primer código de estrategia

La lógica de la estrategia:

Compruebe el precio de la moneda, si no es nan, puede comerciar
Compruebe el valor del contrato de altcoin. Si es menor que el valor objetivo trade_value, la diferencia correspondiente se venderá en corto, y si es mayor, se comprará la cantidad correspondiente para cerrar la posición.
Agregue el valor corto de todas las altcoins y ajuste la posición de BTC para cubrirse contra ella.

La posición corta trade_value determina el tamaño de la posición.

# Need to hedge with BTC
trade_symbols = list(set(symbols)-set(['LINK','XTZ','BCH', 'ETH', 'ETC','ATOM','BNB','EOS','LTC'])) # Remaining currencies
e = Exchange(trade_symbols+['BTC'],initial_balance=10000,commission=0.0005,log=False)
trade_value = 2000
for row in price_usdt.iloc[:].iterrows():
    e.Update(row[0], row[1])
    empty_value = 0
    for symbol in trade_symbols:
        price = row[1][symbol]
        if np.isnan(price):
            continue
        if e.account[symbol]['value'] - trade_value  < -20 :
            e.Sell(symbol, price, round((trade_value-e.account[symbol]['value'])/price, 6),round(e.account[symbol]['realised_profit']+e.account[symbol]['unrealised_profit'],2))
        if e.account[symbol]['value'] - trade_value > 20 :
            e.Buy(symbol, price, round((e.account[symbol]['value']-trade_value)/price, 6),round(e.account[symbol]['realised_profit']+e.account[symbol]['unrealised_profit'],2))
        empty_value += e.account[symbol]['value']
    price = row[1]['BTC']
    if e.account['BTC']['value'] - empty_value < -20:
        e.Buy('BTC', price, round((empty_value-e.account['BTC']['value'])/price,6),round(e.account['BTC']['realised_profit']+e.account['BTC']['unrealised_profit'],2))
    if e.account['BTC']['value'] - empty_value > 20:
        e.Sell('BTC', price, round((e.account['BTC']['value']-empty_value)/price,6),round(e.account['BTC']['realised_profit']+e.account['BTC']['unrealised_profit'],2))
stragey_1 = e

El beneficio final de cada moneda es el siguiente:

pd.DataFrame(stragey_1.account).T.apply(lambda x:round(x,3))

Los dos gráficos a continuación son la curva de patrimonio neto y el apalancamiento utilizado.

El amarillo en la curva de patrimonio neto es el efecto del apalancamiento de 1x que corta el índice altcoin. Se puede ver que la estrategia amplifica básicamente la fluctuación del índice, que está en línea con las expectativas. El rendimiento final de dos meses es del 60%, el retracement máximo es del 20%, y el apalancamiento máximo es de aproximadamente 8 veces. La mayoría de las veces, es menos de 6 veces. Todavía es seguro. Lo más importante, la cobertura completa ha hecho que la estrategia pierda poco en la caída del 12 de marzo.

Cuando el precio de la moneda de venta corta aumenta y el valor del contrato aumenta, la posición se reduce, por otro lado, cuando se obtiene ganancia, la posición se incrementa.

Pero los riesgos también se mencionaron anteriormente, las altcoins son muy propensas a ejecutar su propia tendencia, y pueden subir mucho desde el fondo. Depende de cómo lo uses. Si eres optimista sobre el altcoin y crees que ha alcanzado el fondo, puedes operar en la dirección y comprar largo este índice. O si eres optimista sobre ciertas monedas, puedes cubrir con ellos.

(stragey_1.df['total']/stragey_1.initial_balance).plot(figsize=(18,6),grid = True); # Net worth curve
#(2-price_usdt_btc_norm[trade_symbols].mean(axis=1)).plot(figsize=(18,6),grid = True);

# Strategy leverage
stragey_1.df['leverage'].plot(figsize=(18,6),grid = True);

Además, dado que el precio de la altcoin contra el USDT también cayó, el plan extremo no está cubierto, vendiendo directamente en corto, pero la fluctuación es muy grande y el retroceso es alto.

trade_symbols = list(set(symbols)-set(['LINK','XTZ','BCH', 'ETH', 'ETC','ATOM','BNB','EOS','LTC'])) # Remaining currencies
e = Exchange(trade_symbols+['BTC'],initial_balance=10000,commission=0.0005,log=False)
trade_value = 2000
for row in price_usdt.iloc[:].iterrows():
    e.Update(row[0], row[1])
    empty_value = 0
    for symbol in trade_symbols:
        price = row[1][symbol]
        if np.isnan(price):
            continue
        if e.account[symbol]['value'] - trade_value  < -20 :
            e.Sell(symbol, price, round((trade_value-e.account[symbol]['value'])/price, 6),round(e.account[symbol]['realised_profit']+e.account[symbol]['unrealised_profit'],2))
        if e.account[symbol]['value'] - trade_value > 20 :
            pass
            #e.Buy(symbol, price, round((e.account[symbol]['value']-trade_value)/price, 6),round(e.account[symbol]['realised_profit']+e.account[symbol]['unrealised_profit'],2))
        empty_value += e.account[symbol]['value']
stragey_1b = e

(stragey_1b.df['total']/stragey_1.initial_balance).plot(figsize=(18,6),grid = True); # Net worth curve
(2-price_usdt_btc_norm[trade_symbols].mean(axis=1)).plot(figsize=(18,6),grid = True);

El segundo código de estrategia

La lógica de la estrategia:

Compruebe si hay un precio o si hay un precio para el comercio
Compruebe la desviación del precio de la moneda respecto al índice
Ir largo y corto basado en el juicio de la desviación, y juzgar la posición de acuerdo con el tamaño de la desviación
Calcular las posiciones no cubiertas y cubrirlas con BTC

Trade_value también controla el tamaño de las posiciones abiertas. También puede modificar el factor de conversión de diff/0.001

trade_symbols = list(set(symbols)-set(['LINK','XTZ','BCH', 'ETH'])) # Remaining currencies
price_usdt_btc_norm_mean = price_usdt_btc_norm[trade_symbols].mean(axis=1)
e = Exchange(trade_symbols+['BTC'],initial_balance=10000,commission=0.0005,log=False)
trade_value = 300
for row in price_usdt.iloc[:].iterrows():
    e.Update(row[0], row[1])
    empty_value = 0
    for symbol in trade_symbols:
        price = row[1][symbol]
        if np.isnan(price):
            continue
        diff = price_usdt_btc_norm.loc[row[0],symbol] - price_usdt_btc_norm_mean[row[0]]
        aim_value = -trade_value*round(diff/0.01,0)
        now_value = e.account[symbol]['value']*np.sign(e.account[symbol]['amount'])
        empty_value += now_value
        if aim_value - now_value > 50:
            e.Buy(symbol, price, round((aim_value - now_value)/price, 6),round(e.account[symbol]['realised_profit']+e.account[symbol]['unrealised_profit'],2))
        if aim_value - now_value < -50:
            e.Sell(symbol, price, -round((aim_value - now_value)/price, 6),round(e.account[symbol]['realised_profit']+e.account[symbol]['unrealised_profit'],2))
    price = row[1]['BTC']
    aim_value = -empty_value
    now_value = e.account['BTC']['value']*np.sign(e.account['BTC']['amount'])
    if aim_value - now_value > 50:
        e.Buy('BTC', price, round((aim_value - now_value)/price, 6),round(e.account['BTC']['realised_profit']+e.account['BTC']['unrealised_profit'],2))
    if aim_value - now_value < -50:
        e.Sell('BTC', price, -round((aim_value - now_value)/price, 6),round(e.account['BTC']['realised_profit']+e.account['BTC']['unrealised_profit'],2))
stragey_2 = e

El rendimiento de la segunda estrategia es mucho mejor que el de la primera. En los últimos dos meses, tiene un rendimiento del 100%, pero todavía tiene un retracement del 20%. En la última semana, debido a las pequeñas fluctuaciones del mercado, el rendimiento no es obvio. El apalancamiento general no es mucho. Esta estrategia vale la pena intentarla. Dependiendo del grado de desviación, se abrieron más de 7800 posiciones USDT como máximo.

Tenga en cuenta que si una moneda ejecuta una tendencia independiente, por ejemplo, ha aumentado varias veces en relación con el índice, acumulará un gran número de posiciones cortas en la moneda, y la misma fuerte disminución también hará que la estrategia de compra sea larga, lo que puede limitar la posición máxima de apertura.

(stragey_2.df['total']/stragey_2.initial_balance).plot(figsize=(18,6),grid = True);

# Summary results by currency
pd.DataFrame(e.account).T.apply(lambda x:round(x,3))

e.df['leverage'].plot(figsize=(18,6),grid = True);

Si el resultado de no cubrir es el siguiente, la diferencia en realidad no es mucho, porque las posiciones largas y cortas son básicamente equilibrados.

trade_symbols = list(set(symbols)-set(['LINK','XTZ','BCH', 'ETH'])) # Remaining currencies
price_usdt_btc_norm_mean = price_usdt_btc_norm[trade_symbols].mean(axis=1)
e = Exchange(trade_symbols,initial_balance=10000,commission=0.0005,log=False)
trade_value = 300
for row in price_usdt.iloc[:].iterrows():
    e.Update(row[0], row[1])
    empty_value = 0
    for symbol in trade_symbols:
        price = row[1][symbol]
        if np.isnan(price):
            continue
        diff = price_usdt_btc_norm.loc[row[0],symbol] - price_usdt_btc_norm_mean[row[0]]
        aim_value = -trade_value*round(diff/0.01,1)
        now_value = e.account[symbol]['value']*np.sign(e.account[symbol]['amount'])
        empty_value += now_value
        if aim_value - now_value > 20:
            e.Buy(symbol, price, round((aim_value - now_value)/price, 6),round(e.account[symbol]['realised_profit']+e.account[symbol]['unrealised_profit'],2))
        if aim_value - now_value < -20:
            e.Sell(symbol, price, -round((aim_value - now_value)/price, 6),round(e.account[symbol]['realised_profit']+e.account[symbol]['unrealised_profit'],2))
stragey_2b = e

(stragey_2b.df['total']/stragey_2.initial_balance).plot(figsize=(18,6),grid = True);
#(stragey_2.df['total']/stragey_2.initial_balance).plot(figsize=(18,6),grid = True); # Can be stacked together

Si usted se refiere a la regresión de precios USDT, el efecto será mucho peor

trade_symbols = list(set(symbols)-set(['LINK','XTZ','BCH', 'ETH']))+['BTC'] #Remaining currencies
price_usdt_norm_mean = price_usdt_norm[trade_symbols].mean(axis=1)
e = Exchange(trade_symbols,initial_balance=10000,commission=0.0005,log=False)
trade_value = 300
for row in price_usdt.iloc[:].iterrows():
    e.Update(row[0], row[1])
    empty_value = 0
    for symbol in trade_symbols+['BTC']:
        price = row[1][symbol]
        if np.isnan(price):
            continue
        diff = price_usdt_norm.loc[row[0],symbol] - price_usdt_norm_mean[row[0]]
        aim_value = -trade_value*round(diff/0.01,1)
        now_value = e.account[symbol]['value']*np.sign(e.account[symbol]['amount'])
        empty_value += now_value
        if aim_value - now_value > 20:
            e.Buy(symbol, price, round((aim_value - now_value)/price, 6),round(e.account[symbol]['realised_profit']+e.account[symbol]['unrealised_profit'],2))
        if aim_value - now_value < -20:
            e.Sell(symbol, price, -round((aim_value - now_value)/price, 6),round(e.account[symbol]['realised_profit']+e.account[symbol]['unrealised_profit'],2))
stragey_2c = e

(stragey_2c.df['total']/stragey_2.initial_balance).plot(figsize=(18,6),grid = True);
(stragey_2b.df['total']/stragey_2.initial_balance).plot(figsize=(18,6),grid = True);

Si se limita el valor de posición máxima, el rendimiento será peor

trade_symbols = list(set(symbols)-set(['LINK','XTZ','BCH', 'ETH'])) #Remaining currencies
price_usdt_btc_norm_mean = price_usdt_btc_norm[trade_symbols].mean(axis=1)
e = Exchange(trade_symbols+['BTC'],initial_balance=10000,commission=0.0005,log=False)
trade_value = 300
for row in price_usdt.iloc[:].iterrows():
    e.Update(row[0], row[1])
    empty_value = 0
    for symbol in trade_symbols:
        price = row[1][symbol]
        if np.isnan(price):
            continue
        diff = price_usdt_btc_norm.loc[row[0],symbol] - price_usdt_btc_norm_mean[row[0]]
        aim_value = -trade_value*round(diff/0.01,1)
        now_value = e.account[symbol]['value']*np.sign(e.account[symbol]['amount'])
        empty_value += now_value
        if aim_value - now_value > 20 and abs(aim_value)<3000:
            e.Buy(symbol, price, round((aim_value - now_value)/price, 6),round(e.account[symbol]['realised_profit']+e.account[symbol]['unrealised_profit'],2))
        if aim_value - now_value < -20 and abs(aim_value)<3000:
            e.Sell(symbol, price, -round((aim_value - now_value)/price, 6),round(e.account[symbol]['realised_profit']+e.account[symbol]['unrealised_profit'],2))
    price = row[1]['BTC']
    aim_value = -empty_value
    now_value = e.account['BTC']['value']*np.sign(e.account['BTC']['amount'])
    if aim_value - now_value > 20:
        e.Buy('BTC', price, round((aim_value - now_value)/price, 6),round(e.account['BTC']['realised_profit']+e.account['BTC']['unrealised_profit'],2))
    if aim_value - now_value < -20:
        e.Sell('BTC', price, -round((aim_value - now_value)/price, 6),round(e.account['BTC']['realised_profit']+e.account['BTC']['unrealised_profit'],2))
stragey_2d = e

(stragey_2d.df['total']/stragey_2.initial_balance).plot(figsize=(17,6),grid = True);

Resumen y riesgo

La primera estrategia aprovecha el hecho de que el valor general de las altcoins no es tan bueno como el bitcoin. Si usted compra bitcoins largos, es posible que desee seguir esta estrategia durante mucho tiempo. Debido a la equivalencia de posiciones largas y cortas, básicamente no tiene miedo de la tasa de financiación de 8h. A largo plazo, la tasa de ganancia es relativamente alta. Pero también me preocupa que la altcoin esté actualmente en el fondo, y que pueda salir de una tendencia ascendente y causar una pérdida de esta estrategia.

La segunda estrategia utiliza la característica de regresión de precios de la altcoin, que sube más que el índice y tiene una alta probabilidad de retroceder. Sin embargo, puede acumular demasiadas posiciones en una sola moneda.

Debido a los diferentes tiempos de inicio de la estrategia y los parámetros específicos, el impacto de las personas que utilizan esta estrategia durante mucho tiempo no debería ser grande.

En resumen, no existe una estrategia perfecta, sólo una actitud correcta hacia la estrategia, que en última instancia depende de la comprensión del usuario de los riesgos y el juicio del futuro.

Relacionados

Más.