2021 में डिजिटल मुद्रा बाजार की समीक्षा और सबसे सरल 10 गुना रणनीति चूक गई

2021 के लिए सारांश और भविष्य की रणनीतियाँ

2021 खत्म हो रहा है, और डीईएफआई से गेमफी तक हॉटस्पॉट एक अंतहीन धारा में उभर रहे हैं, और समग्र बाजार अभी भी एक बुल मार्केट है। अब पीछे मुड़कर देखें और सारांशित करें, आपने 2021 में कितना कमाया? आपने क्या अवसर खो दिए? कुछ सफल निवेश क्या थे? हाल ही में, मैंने पिछले वर्ष के ऐतिहासिक बाजार पर एक नज़र डाली और एक अप्रत्याशित सरल मुनाफे की रणनीति पाई, जो एक बहु-मुद्रा सूचकांक है।

एक्सचेंज पर बहुत सारी मुद्राएं हैं, जिनमें से कई अज्ञात होने के लिए नियत हैं और यहां तक कि व्यापार से भी वापस ले लिए जा सकते हैं। यहां हम बाइनेंस की मुद्रा का चयन करते हैं जो बाजार में उपयोग की गई हैं। वे आम तौर पर मुख्यधारा की मुद्राओं के रूप में परीक्षण और मान्यता प्राप्त हैं, जो अपेक्षाकृत सुरक्षित हैं। सरल स्क्रीनिंग के बाद, कुछ सूचकांक मुद्राओं को हटा दिया गया और 134 मुद्राएं अंततः प्राप्त की गईं।

में [1]:

import requests
from datetime import date,datetime
import time
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
%matplotlib inline

[144] मेंः

## Current trading pairs
Info = requests.get('https://fapi.binance.com/fapi/v1/exchangeInfo')
symbols = [s['symbol'] for s in Info.json()['symbols']]

[154] मेंः

symbols_f = list(set(filter(lambda x: x[-4:] == 'USDT', [s.split('_')[0] for s in symbols]))-
                 set(['1000SHIBUSDT','1000XECUSDT','BTCDOMUSDT','DEFIUSDT','BTCSTUSDT'])) + ['SHIBUSDT','XECUSDT']
print(symbols_f)

[१५५] मेंः

print(len(symbols_f))

पिछले वर्ष में बाजार

फिर हम पिछले वर्ष के लिए उनके दैनिक समापन मूल्य प्राप्त करते हैं, यह देखते हुए कि कुछ मुद्राओं को शेल्फ पर थोड़े समय के लिए रखा गया है, इसलिए हमें डेटा भरने की आवश्यकता है। सूचकांक की गणना डेटा को सामान्य करके की जा सकती है।

अंतिम सूचकांक रिटर्न लगभग 12 गुना है, अर्थात, यदि आप 1 जनवरी, 2021 को औसतन 134 सिक्के खरीदते हैं, तो कुछ भी नहीं करने का अंतिम रिटर्न 12 गुना होगा। यह अनुमान लगाया गया है कि 90% से अधिक व्यापारी औसत सूचकांक से बेहतर प्रदर्शन नहीं करते हैं। उनमें से, सबसे बड़ी गिरावट वाली मुद्राएं हैंः आईसीपी 93%, डोडो 85% गिर गया, और लीन 75% गिर गया। जबकि एसओएल, एफटीएम, लुना, मैटिक, सैंड और एएक्सएस में लगभग 100 गुना वृद्धि हुई है। उनमें से, एएक्सएस में 168 गुना वृद्धि हुई, जिससे यह सबसे बड़ा डार्क हॉर्स बन गया। मध्यवर्ती 3 गुना बढ़ गया, जो मुख्य रूप से सार्वजनिक श्रृंखला और खेलों से प्रेरित था। अस्तित्व पूर्वाग्रह को दूर करने के लिए, हमने अवधि के दौरान स्थायी नई मुद्रा को बाहर कर दिया, और हमने लाभ का लगभग 11 गुना भी हासिल किया। यह बीटीसी के लिए लाभ का 7 गुना है।

यह एक निराशाजनक रिटर्न दर है। मैंने सभी प्रकार की रणनीतियों को बनाने के लिए कड़ी मेहनत की है, लेकिन यह एक वर्ष में कुछ भी नहीं करने के लाभ से बहुत दूर था। हालांकि, यह ध्यान दिया जाना चाहिए कि कुछ विशिष्ट वृद्धि बहुत बड़ी है और यह सूचकांक से स्पष्ट रूप से विचलित हो गया था। यदि इन मुद्राओं को वर्ष की शुरुआत में चयनित नहीं किया जाता है, तो लाभ मध्य के करीब होगा, जो बहुत कम लाभदायक है।

[157] मेंः

#Obtain the function of K-line in any period
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 = int(time.mktime(datetime.strptime(end, "%Y-%m-%d").timetuple()))*1000 + 8*60*60*1000
    intervel_map = {'m':60*1000,'h':60*60*1000,'d':24*60*60*1000}
    while start_time < end_time:
        mid_time = min(start_time+1000*int(period[:-1])*intervel_map[period[-1]],end_time)
        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]
            Klines += res_list
        elif type(res_list) == list:
            start_time = start_time+1000*int(period[:-1])*intervel_map[period[-1]]
        else:
            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

[164] मेंः

df_all_s = pd.DataFrame(index=pd.date_range(start='2021-1-1', end='2021-12-28', freq='1d'),columns=symbols_s)
for i in range(len(symbols_f)):
    #print(symbols_s[i])
    symbol_s = symbols_f[i]
    df_s = GetKlines(symbol=symbol_s,start='2021-1-1',end='2021-12-28',period='1d',base='api',v='v3')
    df_all_s[symbol_s] = df_s[~df_s.index.duplicated(keep='first')].close

[165] मेंः

df_all_s.tail() #data structure

बाहर[165]:

[174] मेंः

df_all = df_all_s.fillna(method='bfill')#filled data
df_norm = df_all/df_all.iloc[0] #normalization
df_norm.mean(axis=1).plot(figsize=(12,4),grid=True);
#The final index return chart

बाहर[1]:

[175] मेंः

#The median increase
df_norm.median(axis=1).plot(figsize=(12,4),grid=True);

बाहर[175]:

[168] मेंः

#Ranking for increase/decrease
print(df_norm.iloc[-1].round(2).sort_values().to_dict())

[317] मेंः

#Maximum rollback of current price compared with the highest point in the year
print((1-df_norm.iloc[-1]/df_norm.max()).round(2).sort_values().to_dict())

[177] मेंः

df_all_f = pd.DataFrame(index=pd.date_range(start='2021-1-1', end='2021-12-28', freq='1d'),columns=symbols_s)
for i in range(len(symbols_f)):
    #print(symbols_s[i])
    symbol_f = symbols_f[i]
    df_f = GetKlines(symbol=symbol_f,start='2021-1-1',end='2021-12-28',period='1d',base='fapi',v='v1')
    df_all_f[symbol_f] = df_f[~df_f.index.duplicated(keep='first')].close

[208] मेंः

#Excluding new currency
df = df_all_s[df_all_s.columns[~df_all_f.iloc[0].isnull()]]
df = df.fillna(method='bfill')
df = df/df.iloc[0]
df.mean(axis=1).plot(figsize=(12,4),grid=True);

बाहर[208]:

[212] मेंः

#Compared with Bitcoin
(df.mean(axis=1)/df.BTCUSDT).plot(figsize=(12,4),grid=True);

बाहर[1]:

[213] मेंः

#Use the original backtest engine
class Exchange:
    
    def __init__(self, trade_symbols, fee=0.0004, initial_balance=10000):
        self.initial_balance = initial_balance #Initial assets
        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 the handling fee
        self.account['USDT']['fee'] += price*amount*self.fee
        self.account[symbol]['fee'] += price*amount*self.fee

        if cover_amount > 0: #Close the position first
            self.account['USDT']['realised_profit'] += -direction*(price - self.account[symbol]['hold_price'])*cover_amount  #Profits
            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 the assets
        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)

[418] मेंः

#The hourly K-line was taken to make the backtest more accurate
df_all_s = pd.DataFrame(index=pd.date_range(start='2021-1-1', end='2021-12-28', freq='1h'),columns=symbols_s)
for i in range(len(symbols_f)):
    #print(symbols_s[i])
    symbol_s = symbols_f[i]
    df_s = GetKlines(symbol=symbol_s,start='2021-1-1',end='2021-12-28',period='1h',base='api',v='v3')
    df_all_s[symbol_s] = df_s[~df_s.index.duplicated(keep='first')].close

[419] मेंः

df = df_all_s[df_all_s.columns[~df_all_f.iloc[0].isnull()]]
df = df.fillna(method='bfill')
df = df/df.iloc[0]
df.mean(axis=1).plot(figsize=(12,4),grid=True);

बाहर[419]:

संतुलित रणनीतियों का प्रदर्शन

बैकटेस्ट में, 1 जनवरी, 2021 को ऑनलाइन बाइनेंस स्थायी अनुबंध की सभी मुद्राओं का चयन किया गया था। K-लाइन अवधि 1h थी। पैरामीटर ने पदों में स्केलिंग शुरू की जब स्थिति औसत से 5% कम थी, और स्थिति 5% से अधिक थी। जब बैकटेस्ट सभी मुद्राओं है, तो अंतिम रणनीतिक रिटर्न 7.7 गुना है। यह स्पष्ट रूप से 13 गुना के औसत रिटर्न के रूप में अच्छा नहीं है। यह भी उम्मीद की जाती है। आखिरकार, कई मुद्राएं जो सौ गुना बढ़ी हैं, बहुत विशेष हैं, और संतुलन रणनीति उन्हें सभी बेच देगी।

यदि सबसे अधिक वृद्धि के साथ 10 मुद्राओं को बैकटेस्ट से हटा दिया जाता है, तो केवल अपेक्षाकृत मध्यम मुद्राओं पर विचार किया जाएगा, और अंतिम आय 4.8 गुना होगी, जो 3.4 गुना के औसत प्रदर्शन से बहुत अधिक होगी।

यदि केवल 3 मुद्राओं में सबसे अधिक वृद्धि होती है, तो अंतिम लाभ 373 गुना होगा, जो 160 गुना के औसत प्रदर्शन से बहुत अधिक है। इससे पता चलता है कि यदि चयनित घूमती हुई मुद्रा का रुझान और वृद्धि सुसंगत होती है, तो घूमती हुई मुद्रा का परिणाम कुछ नहीं करने की तुलना में बहुत बेहतर होगा।

[494] मेंः

#Full currency backtest
symbols = list(df.iloc[-1].sort_values()[:].index)
e = Exchange(symbols, fee=0.001, initial_balance=10000)
res_list = []
avg_pct = 1/len(symbols)
for row in df[symbols].iterrows():
    prices = row[1]
    total = e.account['USDT']['total']
    e.Update(prices)
    for symbol in symbols:
        pct = e.account[symbol]['value']/total
        if pct < 0.95*avg_pct:
            e.Buy(symbol,prices[symbol],(avg_pct-pct)*total/prices[symbol])
        if pct > 1.05*avg_pct:
            e.Sell(symbol,prices[symbol],(pct-avg_pct)*total/prices[symbol])
    res_list.append([e.account[symbol]['value'] for symbol in symbols] + [e.account['USDT']['total']])
res = pd.DataFrame(data=res_list, columns=symbols+['total'],index = df.index)

[495] मेंः

e.account['USDT']

बाहर[495]:

[496] मेंः

# Backtest performance of full currencies
(res.total/10000).plot(figsize=(12,4),grid = True); 
df[symbols].mean(axis=1).plot(figsize=(12,4),grid=True);

बाहर[1]:

[498] मेंः

#Remove currencies with huge growth
symbols = list(df.iloc[-1].sort_values()[:-10].index)
e = Exchange(symbols, fee=0.001, initial_balance=10000)
res_list = []
avg_pct = 1/len(symbols)
for row in df[symbols].iterrows():
    prices = row[1]
    total = e.account['USDT']['total']
    e.Update(prices)
    for symbol in symbols:
        pct = e.account[symbol]['value']/total
        if pct < 0.95*avg_pct:
            e.Buy(symbol,prices[symbol],(avg_pct-pct)*total/prices[symbol])
        if pct > 1.05*avg_pct:
            e.Sell(symbol,prices[symbol],(pct-avg_pct)*total/prices[symbol])
    res_list.append([e.account[symbol]['value'] for symbol in symbols] + [e.account['USDT']['total']])
res = pd.DataFrame(data=res_list, columns=symbols+['total'],index = df.index)

[501] मेंः

e.account['USDT']

बाहर[501]:

[499 में]:

(res.total/10000).plot(figsize=(12,4),grid = True); 
df[symbols].mean(axis=1).plot(figsize=(12,4),grid=True);

बाहर [499]:

[503] मेंः

#Only the currency with the highest increase is tested
symbols = list(df.iloc[-1].sort_values()[-3:].index)
e = Exchange(symbols, fee=0.001, initial_balance=10000)
res_list = []
avg_pct = 1/len(symbols)
for row in df[symbols].iterrows():
    prices = row[1]
    total = e.account['USDT']['total']
    e.Update(prices)
    for symbol in symbols:
        pct = e.account[symbol]['value']/total
        if pct < 0.95*avg_pct:
            e.Buy(symbol,prices[symbol],(avg_pct-pct)*total/prices[symbol])
        if pct > 1.05*avg_pct:
            e.Sell(symbol,prices[symbol],(pct-avg_pct)*total/prices[symbol])
    res_list.append([e.account[symbol]['value'] for symbol in symbols] + [e.account['USDT']['total']])
res = pd.DataFrame(data=res_list, columns=symbols+['total'],index = df.index)

[504] मेंः

e.account['USDT']

बाहर[504]:

[505] मेंः

(res.total/10000).plot(figsize=(12,4),grid = True); 
df[symbols].mean(axis=1).plot(figsize=(12,4),grid=True);

बाहर[505]:

सारांश

सामान्य तौर पर, 2021 नकली सिक्कों के लिए एक बुल बाजार और बिटकॉइन के लिए एक गिरावट वाला वर्ष होगा। बिटकॉइन का बाजार मूल्य वर्ष की शुरुआत में 70% से अब 40% तक गिर गया है, जो इतिहास में सबसे कम स्तर है। इसलिए, पिछले वर्ष में नकली सामान खरीदने और रखने से औसत लाभ बिटकॉइन रखने से कहीं अधिक है। 2022 की ओर देखते हुए, यदि आप मानते हैं कि भविष्य में वर्तमान बाजार में अभी भी कई सौ गुना मुद्राएं होंगी, तो आप अपनी स्थिति को साहसपूर्वक विविधता दे सकते हैं और धैर्यपूर्वक इंतजार कर सकते हैं। यदि आप कुछ मुद्राओं या औसत बाजार के बारे में विशेष रूप से आशावादी हैं, तो आप बिना सोचे-समझे अतिरिक्त रिटर्न प्राप्त करने के लिए घूर्णन रणनीति का उपयोग कर सकते हैं। यदि आपको लगता है कि चीजें चरम पर लौटने पर एक-दूसरे के खिलाफ पहुंचेंगी, तो आप बेहतर रिटर्न और सुरक्षा प्राप्त करने के लिए बिटकॉइन का सौदा-शिकार कर सकते हैं।