O recurso está a ser carregado... Carregamento...

2021 Revisão do TAQ da criptomoeda e estratégia simples perdida de aumento de 10 vezes

Autora:Ninabadass, Criado: 2022-04-07 11:36:32, Atualizado: 2022-04-13 09:25:23

2021 Revisão do TAQ da criptomoeda e estratégia simples perdida de aumento de 10 vezes

Conclusão de 2021 e futura estratégia.ipynb

2021 está chegando ao fim, e pontos quentes do DEFI ao GAMEFI estão emergindo um após o outro, e o mercado geral ainda está em um mercado de alta. Olhando para trás agora, quanto você ganhou em 2021? Que oportunidade você perdeu? Há investimentos bem sucedidos? Recentemente, eu puxei as cotações do mercado histórico do ano passado e encontrei uma estratégia de lucro inesperadamente simples, mas é um índice multi-moeda.

Há muitos símbolos de moeda listados em plataformas, e muitos estão destinados a ser desconhecidos e podem até ser retirados da negociação. Aqui escolhemos os símbolos de moeda que foram listados no Binance Perpetual Swap. Eles foram geralmente testados e são reconhecidos como moedas convencionais, que são relativamente seguras. Após uma simples triagem, algumas moedas do índice foram removidas e 134 moedas finalmente sobreviveram.

Em [1]: Pedidos de importação a partir da data-hora data de importação, data-hora Tempo de importação importar pandas como pd importar numpy como np importar matplotlib.pyplot como plt % matplotlib em linha

Em [144]: ##pares de negociação atuais Informações = pedidos.obtenção"https://fapi.binance.com/fapi/v1/exchangeInfo’) símbolos = [s[symbol] para s em Info.json() [symbols]]

Em [154]: símbolos_f = list(set(filter(lambda x: x[-4:] == USDT, [s.split(_) [0] para s em símbolos]))- O valor da taxa de câmbio é calculado em função da taxa de câmbio da taxa de câmbio. Impressão (symbols_f)

Em [155]: Impressão (symbols)

Mercado no ano passado

Então, obtemos seus preços de fechamento diários no ano passado, e notamos que alguns símbolos de moeda estavam no mercado apenas por um curto período de tempo, então os dados precisam de processamento de unitização.

O lucro final do índice é de cerca de 12 vezes, ou seja, se você comprar esses 134 símbolos de moeda em média em 1o de janeiro de 2021, o lucro final de não fazer nada é de 12 vezes, e estima-se que mais de 90% das pessoas não superam o índice médio. Entre eles, os símbolos de moeda com o maior declínio: ICP caiu 93%, DODO caiu 85% e LINA caiu 75%. O aumento de quase cem vezes: SOL, FTM, LUNA, MATIC, SAND, AXS. Entre eles, o AXS aumentou 168 vezes e é o maior cavalo negro. A mediana aumentou 3 vezes. Pode-se dizer que o índice é impulsionado principalmente pelas cadeias públicas e jogos.

Este é um rácio de lucro desesperado. Eu trabalhei duro e tentei todos os tipos de estratégias, e eu não fiz tanto lucro como um ano em que eu não fiz nenhum esforço extra. No entanto, deve-se notar que vários dos aumentos do rácio são muito grandes, e obviamente se desviam do índice. Se esses símbolos de moeda não forem selecionados no início do ano, o lucro será próximo da mediana, que é muito menos proeminente.

Em [157]: # função para obter a linha K em qualquer período def GetKlines ((símbolo=BTCUSDT,start=2020-8-10,end=2021-8-10,periodo=1h,base=fapi,v = v1): Cravos = [] start_time = int(time.mktime(datetime.strptime(start, %Y-%m-%d).timetuple()))1000 + 860601000 end_time = int(time.mktime(datetime.strptime(end, %Y-%m-%d).timetuple()))1000 + 860601000 Interval_map = {m:601000,h:60601000,d:2460601000) enquanto start_time < end_time: tempo médio = min(tempo de início+1000*int(período[:-1])intervalo_map[período[-1], final_tempo] url = https://+base+.binance.com/+base+/+v+/klines?simbolo=%s&interval=%s&startTime=%s&endTime=%s&limit=1000%(simbolo,período,start_time,mid_time) res = solicitações.get ((url)) res_list = res.json() se tipo ((res_list) == lista e len ((res_list) > 0: start_time = res_list[-1][0] Klines += res_list elif tipo ((res_list) == lista: tempo de início = tempo de início+1000int(período[:-1])*intervalo_mapa[período[-1]] Outros: interrupção

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

Em [164]: df_all_s = pd.DataFrame ((index=pd.date_range ((start=2021-1-1, end=2021-12-28, freq=1d), colunas=simbolos_s) para i no intervalo ((len ((simbolos_f)): #print ((simbolos_s[i]) símbolo_s = símbolos_f[i] df_s = GetKlines ((simbolo=simbolo_s,start=2021-1-1,end=2021-12-28,período=1d,base=api,v=v3) df_all_s[simbolo_s] = df_s[~df_s.index.duplicated(keep=first)].close

Em [165]: df_all_s.tail() #estrutura de dados Fora[165]:

Em [174]: df_all = df_all_s.fillna ((método=bfill) # preencher dados df_norm = df_all/df_all.iloc[0] #unitization df_norm.mean ((eixo=1).plot(figsize=(12,4),grid=True); # gráfico do lucro final do índice Fora [1]:img

Em [175]: #aumento médio df_norm.median ((eixo=1).plot ((figsize=(12,4), grelha=true); Fora [1]:img

Em [168]: #aumento e queda de classificação print ((df_norm.iloc[-1].round ((2).sort_values().to_dict())

Em [317]: #maximo retiro do preço actual em comparação com o preço mais elevado do ano passado print ((((1-df_norm.iloc[-1]/df_norm.max()) redondo(2).sort_values().to_dict())

Em [177]: df_all_f = pd.DataFrame ((index=pd.date_range ((start=2021-1-1, end=2021-12-28, freq=1d), colunas=simbolos_s) para i no intervalo ((len ((simbolos_f)): #print ((simbolos_s[i]) símbolo_f = símbolos_f[i] df_f = GetKlines ((simbolo=simbolo_f,start=2021-1-1,end=2021-12-28,período=1d,base=fapi,v=v1) df_all_f[simbolo_f] = df_f[~df_f.index.duplicated(keep=first)].close

Em [208]: Não incluem novos símbolos. df = df_all_s[df_all_s.columns[~df_all_f.iloc[0].isnull() ] df = df.fillna ((método=bfill) df = df/df.iloc[0] df.mean ((axis=1).plot ((figsize=(12,4), grid=True); Fora[208]:img

Em [212]: #comparado com o BTC (df.mean(axis=1)/df.BTCUSDT).plot(figsize=(12,4), grelha=Verdadeiro); Fora[212]:img

Em [213]: # Use o velho motor de backtest classe Intercâmbio:

def __init__(self, trade_symbols, fee=0.0004, initial_balance=10000):
    self.initial_balance = initial_balance #initial asset  
    self.fee = fee
    self.trade_symbols = trade_symbols
    self.account = {'USDT':{'realised_profit':0, 'unrealised_profit':0, 'total':initial_balance, 'fee':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 #deduct service fee
    self.account['USDT']['fee'] += price*amount*self.fee
    self.account[symbol]['fee'] += price*amount*self.fee

    if cover_amount > 0: #close first 
        self.account['USDT']['realised_profit'] += -direction*(price - self.account[symbol]['hold_price'])*cover_amount  #profit
        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): #update asset
    self.account['USDT']['unrealised_profit'] = 0
    for symbol in self.trade_symbols:
        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']
    self.account['USDT']['total'] = round(self.account['USDT']['realised_profit'] + self.initial_balance + self.account['USDT']['unrealised_profit'],6)

Em [418]: # Para um backtest mais preciso, rastrear 1 hora k-line df_all_s = pd.DataFrame ((index=pd.date_range ((start=2021-1-1, end=2021-12-28, freq=1h), colunas=simbolos_s) para i no intervalo ((len ((simbolos_f)): #print ((simbolos_s[i]) símbolo_s = símbolos_f[i] df_s = GetKlines ((simbolo=simbolo_s,start=2021-1-1,end=2021-12-28,período=1h,base=api,v=v3) df_all_s[simbolo_s] = df_s[~df_s.index.duplicated(keep=first) ].close

Em [419]: df = df_all_s[df_all_s.columns[~df_all_f.iloc[0].isnull() ] df = df.fillna ((método=bfill) df = df/df.iloc[0] df.mean ((axis=1).plot ((figsize=(12,4), grid=True); Fora[419]:img

Desempenho equilibrado da estratégia

O backtest selecionou todos os símbolos de moeda listados nos contratos Binance Perpetual em 1 de janeiro de 2021. O período de linha K é de 1h, e o parâmetro é que comece a comprar quando o valor da posição é inferior a 5% da média e comece a vender quando superior a 5%. Quando o backtest é de todos os símbolos de moeda, o lucro final da estratégia é de 7,7 vezes. Significativamente pior do que o lucro médio de 13 vezes. Isso também está na minha expectativa. Afinal, aqueles símbolos de moeda que aumentaram cem vezes são muito especiais, e a estratégia equilibrada os venderá todos.

Se o backtest optar por remover os 10 símbolos de moeda com o maior aumento e examinar apenas os símbolos de moeda relativamente medíocres, o lucro final é de 4,8 vezes, muito superior ao desempenho médio de 3,4 vezes.

Se apenas os 3 símbolos de moeda com o maior aumento forem rotados, o lucro final é de 373 vezes, superando em muito o desempenho médio de 160 vezes.

Em [494]: # backtest de todos os símbolos símbolos = list(df.iloc[-1].sort_values()[:].index) e = intercâmbio ((símbolos, taxa=0,001, saldo inicial=10000) res_list = [] Avg_pct = 1/len (simbolos) para a linha de df[simbolos].iterrows(): preços = linha [1] Total = e.conta[USDT][total] e.Atualização dos preços Para símbolos em símbolos: pct = e.conta[símbolo][valor]/total se pct < 0,95*avg_pct: e.Comprar (símbolo,preços)Total/preços[símbolo]) se pct > 1,05Avg_pct: e.Vender (símbolo,preços (símbolo), (pct-avg_pct) *total/preços (símbolo)) res_list.append (([e.account[simbolo][value] para símbolo em símbolos] + [e.account[USDT][total]]) res = pd.DataFrame ((data=res_list, colunas=símbolos+[total],index = df.index)

Em [495]: e.conta[USDT] Fora[495]:

Em [496]: # backtest desempenho de todos os símbolos (res.total/10000).plot(figsize=(12,4), grelha = True); df[símbolos].média ((eixo=1).plot(figsize=(12,4), grelha=Verdade); Fora[496]:img

Em [498]: #reduzir símbolos com enorme aumento símbolos = list ((df.iloc[-1].sort_values()[:-10].index) e = intercâmbio (simbolos, taxa=0,001, saldo inicial=10000) res_list = [] Avg_pct = 1/len (símbolos) para a linha de df[simbolos].iterrows(): preços = linha [1] Total = e.conta[USDT][total] e.Atualização dos preços Para símbolos em símbolos: pct = e.conta[símbolo][valor]/total se pct < 0,95*avg_pct: e.Comprar (símbolo,preços (símbolo),avg_pct-pct)Total/preços[símbolo]) se pct > 1,05Avg_pct: e.Vender (símbolo,preços (símbolo), (pct-avg_pct) *total/preços (símbolo)) res_list.append (([e.account[simbolo][value] para símbolo em símbolos] + [e.account[USDT][total]]) res = pd.DataFrame ((data=res_list, colunas=símbolos+[total],index = df.index)

Em [501]: e.conta[USDT] Fora[501]:

Em [499]: (res.total/10000).plot(figsize=(12,4), grelha = True); df[símbolos].média ((eixo=1).plot(figsize=(12,4), grelha=Verdade); Fora[499]:img

Em [503]: # só testar os símbolos com o maior aumento símbolos = list(df.iloc[-1].sort_values()[-3:].index) e = intercâmbio (simbolos, taxa=0,001, saldo inicial=10000) res_list = [] Avg_pct = 1/len (símbolos) para a linha de df[simbolos].iterrows(): preços = linha [1] Total = e.conta[USDT][total] e.Atualização dos preços Para símbolos em símbolos: pct = e.conta[símbolo][valor]/total se pct < 0,95*avg_pct: e.Comprar (símbolo,preços (símbolo),avg_pct-pct)Total/preços[símbolo]) se pct > 1,05Avg_pct: e.Vender (símbolo,preços (símbolo), (pct-avg_pct) *total/preços (símbolo)) res_list.append (([e.account[simbolo][value] para símbolo em símbolos] + [e.account[USDT][total]]) res = pd.DataFrame ((data=res_list, colunas=símbolos+[total],index = df.index)

Em [504]: e.conta[USDT] Fora[504]:

Em [505]: (res.total/10000).plot(figsize=(12,4), grelha = True); df[símbolos].média(eixo=1).plot(figsize=(12,4),grid=True); Fora[505]:img

Conclusão

Em geral, 2021 foi um grande mercado alcista para moedas cópias e um ano desolador para o BTC. O valor de mercado do BTC caiu de 70% no início do ano para 40% agora, o que já é o nível mais baixo da história. Portanto, o lucro médio de comprar símbolos de moeda cópia e mantê-los no ano passado foi muito maior do que o de manter o BTC. Olhando para frente para 2022, se você acha que ainda existem várias centenas de vezes de moedas nascidas no mercado atual no futuro, você pode diversificar ousadamente os símbolos de moeda que está segurando e esperar pacientemente. Se você é particularmente otimista sobre alguns símbolos de moeda ou o mercado médio, pode usar a estratégia de rotação para obter lucros excessivos sem pensar. Se você concordar que as coisas se desenvolverão na direção oposta quando se tornam extremas, você pode pescar fundo para obter melhores lucros e segurança do BTC.


Mais.