आइए क्रिप्टोकरेंसी ट्रेडिंग रोबोट बनाने के लिए आर्टिफिशियल इंटेलिजेंस में सुदृढीकरण सीखने का उपयोग करें

इस लेख में, हम बिटकॉइन ट्रेडिंग बॉट बनाने का तरीका सीखने के लिए एक सुदृढीकरण सीखने का ढांचा बनाएंगे और लागू करेंगे। इस ट्यूटोरियल में, हम OpenAI के जिम और स्थिर-बेसलाइन लाइब्रेरी से PPO रोबोट का उपयोग करेंगे, जो OpenAI बेसलाइन लाइब्रेरी का एक भाग है।

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

अल्फास्टार प्रशिक्षण https://deepmind.com/blog/alphastar-mastering-real-time-strategy-game-starcraft-ii/

हालांकि हम कुछ भी प्रभावशाली नहीं बनाएंगे, लेकिन बिटकॉइन रोबोट ट्रेडिंग अभी भी रोजमर्रा के व्यापार में एक आसान काम नहीं है। हालाँकि, जैसा कि टेड्डी रूजवेल्ट ने एक बार कहा था,

जो चीजें आसानी से मिल जाती हैं उनका कोई मूल्य नहीं होता।

इसलिए, न केवल अपने लिए व्यापार करना सीखें... बल्कि रोबोटों को हमारे लिए व्यापार करने दें।

योजना

1. हमारे रोबोट के लिए मशीन लर्निंग करने हेतु जिम का माहौल बनाएं

2. एक सरल और सुंदर विज़ुअलाइज़ेशन वातावरण प्रदान करें

3. हमारे रोबोट को लाभदायक ट्रेडिंग रणनीति सीखने के लिए प्रशिक्षित करें

यदि आप अभी तक इस बात से परिचित नहीं हैं कि जिम का वातावरण कैसे तैयार किया जाए, या इन वातावरणों का दृश्यावलोकन कैसे किया जाए। आगे बढ़ने से पहले कृपया इस तरह के लेख को गूगल पर अवश्य खोजें। ये दोनों कार्य सबसे शुरुआती प्रोग्रामर के लिए भी मुश्किल नहीं होंगे।

शुरू करना

इस ट्यूटोरियल में, हम Zielak द्वारा उत्पन्न Kaggle डेटासेट का उपयोग करेंगे। यदि आप स्रोत कोड डाउनलोड करना चाहते हैं, तो यह मेरे गिटहब रिपोजिटरी में .csv डेटा फ़ाइल के साथ उपलब्ध है। ठीक है, चलिए शुरू करते हैं।

सबसे पहले, आइए सभी आवश्यक लाइब्रेरीज़ को आयात करें। सुनिश्चित करें कि pip का उपयोग करके आप जो भी लाइब्रेरीज़ भूल गए हैं उन्हें स्थापित करें।

            
            
            
import gym
import pandas as pd
import numpy as np
from gym import spaces
from sklearn import preprocessing

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

हम डेटा पर dropna() और reset_index() भी कॉल करते हैं, पहले NaN मान वाली पंक्तियों को हटाने के लिए और फिर फ्रेम नंबर के लिए इंडेक्स को रीसेट करने के लिए क्योंकि हमने डेटा गिरा दिया है।

            
            
            
class BitcoinTradingEnv(gym.Env):
  """A Bitcoin trading environment for OpenAI gym"""
  metadata = {'render.modes': ['live', 'file', 'none']}
  scaler = preprocessing.MinMaxScaler()
  viewer = None
def __init__(self, df, lookback_window_size=50, 
                         commission=0.00075,  
                         initial_balance=10000
                         serial=False):
    super(BitcoinTradingEnv, self).__init__()
self.df = df.dropna().reset_index()
    self.lookback_window_size = lookback_window_size
    self.initial_balance = initial_balance
    self.commission = commission
    self.serial = serial
# Actions of the format Buy 1/10, Sell 3/10, Hold, etc.
    self.action_space = spaces.MultiDiscrete([3, 10])
# Observes the OHCLV values, net worth, and trade history
    self.observation_space = spaces.Box(low=0, high=1, shape=(10, lookback_window_size + 1), dtype=np.float16)

हमारा एक्शन_स्पेस यहां 3 विकल्पों (खरीदें, बेचें या होल्ड करें) और 10 राशियों (1/10, 2/10, 3/10 आदि) के एक सेट के रूप में दर्शाया गया है। खरीद कार्रवाई चुनते समय, हम BTC की राशि * self.balance मूल्य खरीदेंगे। बेचने के लिए, हम * self.btc_held मूल्य के BTC बेचेंगे। बेशक, होल्ड कार्रवाई राशि को नजरअंदाज करती है और कुछ नहीं करती।

हमारा अवलोकन_स्थान 0 और 1 के बीच निरंतर फ़्लोट के एक सेट के रूप में परिभाषित किया गया है, जिसका आकार (10, lookback_window_size + 1) है। + 1 का उपयोग वर्तमान समय चरण की गणना करने के लिए किया जाता है। विंडो में प्रत्येक समय चरण के लिए, हम OHCLV मान का निरीक्षण करेंगे। हमारी कुल संपत्ति खरीदी या बेची गई BTC की मात्रा, तथा उन BTC पर हमारे द्वारा खर्च की गई या प्राप्त की गई कुल USD राशि के बराबर है।

इसके बाद, हमें पर्यावरण को आरंभ करने के लिए रीसेट विधि लिखने की आवश्यकता है।

            
            
            
def reset(self):
  self.balance = self.initial_balance
  self.net_worth = self.initial_balance
  self.btc_held = 0
self._reset_session()
self.account_history = np.repeat([
    [self.net_worth],
    [0],
    [0],
    [0],
    [0]
  ], self.lookback_window_size + 1, axis=1)
self.trades = []
return self._next_observation()

यहां हम self का प्रयोग करते हैं।_reset_session और self._next_observation, हमने उन्हें अभी तक परिभाषित नहीं किया है। आइये पहले इन्हें परिभाषित करें।

ट्रेडिंग सत्र

हमारे पर्यावरण का एक महत्वपूर्ण हिस्सा ट्रेडिंग सत्र की अवधारणा है। यदि हम इस बॉट को बाजार के बाहर तैनात करते, तो संभवतः हम इसे कुछ महीनों से अधिक समय तक नहीं चला पाते। इस कारण से, हम self.df में लगातार फ़्रेमों की संख्या को सीमित कर देंगे, अर्थात, हमारे रोबोट द्वारा एक समय में देखे जा सकने वाले फ़्रेमों की संख्या।

हमारी _reset_session विधि में, हम सबसे पहले current_step को 0 पर रीसेट करते हैं। इसके बाद, हम steps_left को 1 और MAX_TRADING_SESSION के बीच एक यादृच्छिक संख्या पर सेट करेंगे, जिसे हम प्रोग्राम के शीर्ष पर परिभाषित करेंगे।

            
            
            
MAX_TRADING_SESSION = 100000 ＃ ~2个月

इसके बाद, यदि हम लगातार फ़्रेम पर पुनरावृति करना चाहते हैं, तो हमें इसे पूरे फ़्रेम पर पुनरावृति करने के लिए सेट करना होगा, अन्यथा हम frame_start को self.df में एक यादृच्छिक बिंदु पर सेट करते हैं और active_df नामक एक नया डेटा फ़्रेम बनाते हैं जो कि बस self है। एक स्लाइस df का frame_start से frame_start + steps_left तक।

            
            
            
def _reset_session(self):
  self.current_step = 0
if self.serial:
    self.steps_left = len(self.df) - self.lookback_window_size - 1
    self.frame_start = self.lookback_window_size
  else:
    self.steps_left = np.random.randint(1, MAX_TRADING_SESSION)
    self.frame_start = np.random.randint(self.lookback_window_size, len(self.df) - self.steps_left)
self.active_df = self.df[self.frame_start - self.lookback_window_size:self.frame_start + self.steps_left]

रैंडम स्लाइसिंग में डेटा फ़्रेमों की संख्या पर पुनरावृत्ति का एक महत्वपूर्ण दुष्प्रभाव यह है कि लंबे समय तक प्रशिक्षण के दौरान हमारे रोबोट के पास उपयोग करने के लिए अधिक विशिष्ट डेटा होगा। उदाहरण के लिए, यदि हम केवल डेटाफ्रेम की संख्या को क्रमिक तरीके से (अर्थात 0 से len(df) तक क्रम में) दोहराते हैं, तो हमारे पास केवल उतने ही अद्वितीय डेटा बिंदु होंगे, जितने डेटाफ्रेम की संख्या में हैं। हमारा प्रेक्षण स्थान प्रत्येक समय चरण पर केवल असतत संख्या में अवस्थाओं को ही अपना सकता है।

हालांकि, डेटासेट के स्लाइस पर बेतरतीब ढंग से पुनरावृत्ति करके, हम प्रारंभिक डेटासेट में प्रत्येक समय चरण के लिए व्यापार परिणामों का एक अधिक सार्थक सेट बना सकते हैं, यानी, अधिक अद्वितीय डेटासेट बनाने के लिए व्यापार क्रियाओं और पहले देखी गई मूल्य कार्रवाई का संयोजन। मैं इसे एक उदाहरण से समझाता हूं।

सीरियल वातावरण को रीसेट करने के बाद 10 के समय चरण पर, हमारा रोबोट हमेशा डेटासेट के भीतर एक साथ चलेगा और प्रत्येक समय चरण के बाद उसके पास 3 विकल्प होंगे: खरीदें, बेचें या रखें। इन तीनों विकल्पों में से प्रत्येक के लिए एक अन्य विकल्प है: विशिष्ट कार्यान्वयन राशि का 10%, 20%, ... या 100%। इसका अर्थ यह है कि हमारा रोबोट 103 की घात 10 में से किसी भी स्थिति का सामना कर सकता है, अर्थात् कुल 1030 स्थितियों का सामना कर सकता है।

अब वापस अपने रैंडम स्लाइसिंग वातावरण पर आते हैं। 10 के टाइमस्टेप पर, हमारा रोबोट डेटा फ़्रेम की संख्या के भीतर किसी भी len(df) टाइमस्टेप पर हो सकता है। यह मानते हुए कि प्रत्येक समय चरण के बाद एक ही विकल्प चुना जाता है, इसका मतलब है कि रोबोट समान 10 समय चरणों में len(df)30 की किसी भी अद्वितीय स्थिति का अनुभव कर सकता है।

हालांकि इससे बड़े डेटासेट में काफी शोर उत्पन्न हो सकता है, लेकिन मेरा मानना ​​है कि इससे रोबोट को हमारे पास उपलब्ध सीमित मात्रा के डेटा से अधिक सीखने में मदद मिलेगी। एल्गोरिथ्म की प्रभावशीलता की अधिक सटीक समझ हासिल करने के लिए हम अभी भी अपने परीक्षण डेटा को सिलसिलेवार तरीके से दोहराएंगे ताकि सबसे ताज़ा, 'वास्तविक समय' डेटा प्राप्त किया जा सके।

रोबोट की नज़र से

यह अक्सर उपयोगी होता है कि हमारे रोबोट द्वारा उपयोग किए जाने वाले कार्यों के प्रकारों को समझने के लिए पर्यावरण का एक अच्छा दृश्य अवलोकन किया जाए। उदाहरण के लिए, यहां OpenCV का उपयोग करके प्रस्तुत अवलोकनीय स्थान का एक दृश्य है।

ओपनसीवी विज़ुअलाइज़ेशन वातावरण का अवलोकन

छवि में प्रत्येक पंक्ति हमारे अवलोकन_स्थान में एक पंक्ति का प्रतिनिधित्व करती है। समान आवृत्ति की पहली 4 लाल रेखाएं OHCL डेटा को दर्शाती हैं, तथा ठीक नीचे नारंगी और पीले बिंदु आयतन को दर्शाते हैं। नीचे की उतार-चढ़ाव वाली नीली पट्टी बॉट की इक्विटी है, जबकि नीचे की हल्की पट्टियाँ बॉट के ट्रेडों को दर्शाती हैं।

यदि आप बारीकी से देखें तो आप अपना स्वयं का कैंडलस्टिक चार्ट भी बना सकते हैं। वॉल्यूम बार के नीचे मोर्स कोड जैसा इंटरफ़ेस है जो ट्रेडिंग इतिहास दिखाता है। ऐसा लगता है कि हमारा बॉट हमारे अवलोकन_स्थान में मौजूद डेटा से पर्याप्त रूप से सीखने में सक्षम होना चाहिए, तो चलिए जारी रखते हैं। यहां हम _next_observation विधि को परिभाषित करेंगे, जहां हम अवलोकित डेटा को 0 से 1 तक स्केल करेंगे।

• भविष्य में भविष्य में पूर्वाग्रह को रोकने के लिए यह महत्वपूर्ण है कि केवल उसी डेटा को आगे बढ़ाया जाए जिसे रोबोट ने अब तक देखा है।

            
            
            
def _next_observation(self):
  end = self.current_step + self.lookback_window_size + 1
obs = np.array([
    self.active_df['Open'].values[self.current_step:end],  
    self.active_df['High'].values[self.current_step:end],
    self.active_df['Low'].values[self.current_step:end],
    self.active_df['Close'].values[self.current_step:end],
    self.active_df['Volume_(BTC)'].values[self.current_step:end],])
scaled_history = self.scaler.fit_transform(self.account_history)
obs = np.append(obs, scaled_history[:, -(self.lookback_window_size + 1):], axis=0)
return obs

कार्यवाही करना

अब जबकि हमने अपना अवलोकन स्थान स्थापित कर लिया है, तो अब समय है कि हम अपना चरण फ़ंक्शन लिखें और फिर वे क्रियाएं करें जो रोबोट करना चाहता है। जब भी हमारे वर्तमान ट्रेडिंग सत्र के लिए self.steps_left == 0 होगा, हम अपनी BTC होल्डिंग्स बेच देंगे और reset session() कॉल करेंगे। अन्यथा, हम रिवॉर्ड को वर्तमान इक्विटी पर सेट करते हैं, या यदि हमारे पास फंड नहीं है तो उसे ट्रू पर सेट करते हैं।

            
            
            
def step(self, action):
  current_price = self._get_current_price() + 0.01
  self._take_action(action, current_price)
  self.steps_left -= 1
  self.current_step += 1
if self.steps_left == 0:
    self.balance += self.btc_held * current_price
    self.btc_held = 0
    self._reset_session()
obs = self._next_observation()
  reward = self.net_worth
  done = self.net_worth <= 0
return obs, reward, done, {}

व्यापारिक कार्यवाही करना उतना ही सरल है जितना कि current_price प्राप्त करना, की जाने वाली कार्यवाही का निर्धारण करना, तथा खरीदने या बेचने की राशि का निर्धारण करना। आइए जल्दी से _take_action लिखें ताकि हम अपने वातावरण का परीक्षण कर सकें।

            
            
            
def _take_action(self, action, current_price):
  action_type = action[0]
  amount = action[1] / 10
btc_bought = 0
  btc_sold = 0
  cost = 0
  sales = 0
if action_type < 1:
    btc_bought = self.balance / current_price * amount
    cost = btc_bought * current_price * (1 + self.commission)
    self.btc_held += btc_bought
    self.balance -= cost
elif action_type < 2:
    btc_sold = self.btc_held * amount
    sales = btc_sold * current_price  * (1 - self.commission)
    self.btc_held -= btc_sold
    self.balance += sales

अंत में, उसी विधि से, हम ट्रेड को self.trades में जोड़ देंगे और अपनी इक्विटी और खाता इतिहास को अपडेट करेंगे।

            
            
            
if btc_sold > 0 or btc_bought > 0:
    self.trades.append({
      'step': self.frame_start+self.current_step,
      'amount': btc_sold if btc_sold > 0 else btc_bought,
      'total': sales if btc_sold > 0 else cost,
      'type': "sell" if btc_sold > 0 else "buy"
    })
self.net_worth = self.balance + self.btc_held * current_price
  self.account_history = np.append(self.account_history, [
    [self.net_worth],
    [btc_bought],
    [cost],
    [btc_sold],
    [sales]
  ], axis=1)

हमारा रोबोट अब एक नया वातावरण शुरू कर सकता है, उस वातावरण में कदम रख सकता है, तथा ऐसे कार्य कर सकता है जो उस वातावरण को प्रभावित करते हैं। अब उन्हें व्यापार करते हुए देखने का समय आ गया है।

हमारे रोबोट को व्यापार करते हुए देखें

हमारी रेंडर विधि print(self.net_worth) को कॉल करने जितनी सरल हो सकती है, लेकिन वह पर्याप्त दिलचस्प नहीं होगी। इसके बजाय, हम वॉल्यूम बार के साथ एक सरल कैंडलस्टिक चार्ट और अपनी इक्विटी के लिए एक अलग चार्ट तैयार करेंगे।

हम मेरे पिछले लेख से StockTradingGraph.py का कोड लेंगे और उसे बिटकॉइन परिवेश के अनुरूप ढालेंगे। आप मेरे गिटहब से कोड प्राप्त कर सकते हैं।

पहला परिवर्तन जो हम करने जा रहे हैं वह है self.df में परिवर्तन[ 'दिनांक'] self.df में अपडेट करें['टाइमस्टैम्प'] और date2num के सभी कॉल्स को हटा दें क्योंकि हमारी तिथियां पहले से ही यूनिक्स टाइमस्टैम्प प्रारूप में हैं। इसके बाद, हमारी रेंडर विधि में, हम दिनांक लेबल को अपडेट करेंगे ताकि संख्या के बजाय मानव-पठनीय दिनांक प्रिंट हो सके।

            
            
            
from datetime import datetime

सबसे पहले, हम datetime लाइब्रेरी को आयात करेंगे, फिर हम प्रत्येक टाइमस्टैम्प से UTC स्ट्रिंग प्राप्त करने के लिए utcfromtimestampmethod का उपयोग करेंगे और इसे Y-m-d H:M प्रारूप में स्ट्रिंग में बदलने के लिए strftime का उपयोग करेंगे।

            
            
            
date_labels = np.array([datetime.utcfromtimestamp(x).strftime('%Y-%m-%d %H:%M') for x in self.df['Timestamp'].values[step_range]])

अंत में, हम self.df का उपयोग करेंगे['वॉल्यूम'] को self.df में बदल दिया गया है['Volume_(BTC)'] को हमारे डेटासेट से मिलान करने के लिए सेट करें, और ऐसा करने के साथ, हम जाने के लिए तैयार हैं। अपने BitcoinTradingEnv पर वापस आकर, अब हम ग्राफ प्रदर्शित करने के लिए रेंडर विधि लिख सकते हैं।

            
            
            
def render(self, mode='human', **kwargs):
  if mode == 'human':
    if self.viewer == None:
      self.viewer = BitcoinTradingGraph(self.df,
                                        kwargs.get('title', None))
self.viewer.render(self.frame_start + self.current_step,
                       self.net_worth,
                       self.trades,
                       window_size=self.lookback_window_size)

देखना! अब हम अपने रोबोट को बिटकॉइन का व्यापार करते हुए देख सकते हैं।

Matplotlib के साथ हमारे रोबोट के ट्रेडों को विज़ुअलाइज़ करना

हरे रंग के फैंटम लेबल बीटीसी की खरीद को दर्शाते हैं, और लाल रंग के फैंटम लेबल बिक्री को दर्शाते हैं। ऊपरी दाएं कोने में सफेद लेबल रोबोट की वर्तमान निवल संपत्ति है, और निचले दाएं कोने में लेबल बिटकॉइन की वर्तमान कीमत है। सरल एवं सुरुचिपूर्ण. अब, हमारे बॉट को प्रशिक्षित करने और यह देखने का समय है कि हम कितना पैसा कमा सकते हैं!

प्रशिक्षण समय

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

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

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

            
            
            
slice_point = int(len(df) - 100000)
train_df = df[:slice_point]
test_df = df[slice_point:]

इसके बाद, चूंकि हमारा वातावरण केवल डेटा के एक ही फ्रेम को संभालने के लिए सेट किया गया है, इसलिए हम दो वातावरण बनाएंगे, एक प्रशिक्षण डेटा के लिए और दूसरा परीक्षण डेटा के लिए।

            
            
            
train_env = DummyVecEnv([lambda: BitcoinTradingEnv(train_df, commission=0, serial=False)])
test_env = DummyVecEnv([lambda: BitcoinTradingEnv(test_df, commission=0, serial=True)])

अब, हमारे मॉडल को प्रशिक्षित करना हमारे पर्यावरण के साथ एक रोबोट बनाने और model.learn को कॉल करने जितना सरल है।

            
            
            
model = PPO2(MlpPolicy,
             train_env,
             verbose=1, 
             tensorboard_log="./tensorboard/")
model.learn(total_timesteps=50000)

यहां, हम टेंसरबोर्ड का उपयोग करते हैं ताकि हम आसानी से अपने टेंसरफ्लो ग्राफ को देख सकें और अपने रोबोट के बारे में कुछ मात्रात्मक मेट्रिक्स देख सकें। उदाहरण के लिए, यहां 200,000 समय चरणों में कई रोबोटों के लिए छूट वाले पुरस्कारों का एक प्लॉट है:

वाह, ऐसा लगता है कि हमारा बॉट काफी लाभदायक है! हमारा सबसे अच्छा रोबोट 200,000 कदमों के दौरान 1000 गुना बेहतर संतुलन हासिल करने में सक्षम था, और बाकी का औसत कम से कम 30 गुना बेहतर था!

इस बिंदु पर मुझे एहसास हुआ कि पर्यावरण में एक बग था... इसे ठीक करने के बाद, यहां नया पुरस्कार मानचित्र है:

जैसा कि आप देख सकते हैं, हमारे कुछ रोबोटों ने बहुत अच्छा काम किया, और बाकी अपने आप दिवालिया हो गए। हालाँकि, एक अच्छा प्रदर्शन करने वाला बॉट प्रारंभिक शेष राशि का 10 गुना या 60 गुना तक प्राप्त कर सकता है। मुझे यह स्वीकार करना होगा कि सभी लाभदायक बॉट्स को बिना कमीशन के प्रशिक्षित और परीक्षण किया जाता है, इसलिए हमारे बॉट्स के लिए कोई वास्तविक पैसा कमाना अवास्तविक है। लेकिन कम से कम हमें दिशा तो मिल गयी!

आइए अपने बॉट्स को परीक्षण वातावरण में परखें (नए डेटा के साथ जिसे उन्होंने पहले कभी नहीं देखा है) और देखें कि वे कैसा प्रदर्शन करते हैं।

हमारा प्रशिक्षित बॉट नए परीक्षण डेटा का व्यापार करते समय दिवालिया हो जाता है

स्पष्टतः, हमें अभी भी बहुत काम करना है। वर्तमान PPO2 रोबोट के बजाय, मॉडल को स्थिर बेसलाइन A2C का उपयोग करने के लिए स्विच करके, हम इस डेटासेट पर अपने प्रदर्शन में काफी सुधार कर सकते हैं। अंत में, सीन ओ'गोर्मन के सुझाव का पालन करते हुए, हम अपने पुरस्कार फ़ंक्शन को थोड़ा अपडेट कर सकते हैं ताकि हम उच्च निवल मूल्य प्राप्त करने और उसे वहीं छोड़ने के बजाय निवल मूल्य में पुरस्कार जोड़ सकें।

            
            
            
reward = self.net_worth - prev_net_worth

ये दो परिवर्तन अकेले ही परीक्षण डेटासेट पर प्रदर्शन में महत्वपूर्ण सुधार करते हैं, और जैसा कि आप नीचे देख सकते हैं, हम अंततः नए डेटा पर लाभप्रदता प्राप्त करने में सक्षम हैं जो प्रशिक्षण सेट में नहीं था।

लेकिन हम और बेहतर कर सकते हैं। इन परिणामों को बेहतर बनाने के लिए, हमें अपने हाइपरपैरामीटर्स को अनुकूलित करने और अपने बॉट को लंबे समय तक प्रशिक्षित करने की आवश्यकता है। अब समय आ गया है कि आप अपने GPU को पूरी क्षमता से काम करने दें!

यह पोस्ट अब थोड़ी लंबी हो गई है, और हमें अभी भी बहुत सारे विवरणों पर विचार करना है, इसलिए हम यहां एक विराम ले रहे हैं। अगली पोस्ट में, हम अपने समस्या स्थान के लिए सर्वोत्तम हाइपरपैरामीटर्स को विभाजित करने के लिए बायेसियन ऑप्टिमाइज़ेशन का उपयोग करेंगे और CUDA का उपयोग करके GPU पर प्रशिक्षण/परीक्षण के लिए तैयारी करेंगे।

निष्कर्ष के तौर पर

इस लेख में, हमने सुदृढीकरण सीखने का उपयोग करके स्क्रैच से एक लाभदायक बिटकॉइन ट्रेडिंग बॉट बनाने का लक्ष्य रखा है। हम निम्नलिखित कार्य पूरा कर सकते हैं:

1. OpenAI के जिम का उपयोग करके स्क्रैच से बिटकॉइन ट्रेडिंग वातावरण बनाएं।

2. पर्यावरण का दृश्यावलोकन बनाने के लिए Matplotlib का उपयोग करें।

3. सरल क्रॉस सत्यापन का उपयोग करके हमारे बॉट को प्रशिक्षित और परीक्षण करें।

4. लाभप्रदता प्राप्त करने के लिए अपने रोबोट में थोड़ा बदलाव करें

यद्यपि हमारा ट्रेडिंग रोबोट उतना लाभदायक नहीं है जितना हम चाहते हैं, फिर भी हम सही दिशा में आगे बढ़ रहे हैं। अगली बार, हम यह सुनिश्चित करेंगे कि हमारा बॉट लगातार बाजार को मात दे सके और हम देखेंगे कि हमारा ट्रेडिंग बॉट लाइव डेटा पर कैसा प्रदर्शन करता है। मेरे अगले लेख के लिए बने रहें, और बिटकॉइन अमर रहे!