एक बिटकॉइन ट्रेडिंग रोबोट बनाने के लिए जो पैसे नहीं खोता है

आइए एक डिजिटल मुद्रा ट्रेडिंग रोबोट बनाने के लिए एआई में प्रबलित सीखने का उपयोग करें।

इस पाठ में, हम एक बिटकॉइन ट्रेडिंग रोबोट बनाने के तरीके के बारे में सीखने के लिए एक प्रबलित सीखने की संख्या बनाने और लागू करने जा रहे हैं। इस पाठ में, हम ओपनएआई के जिम और ओपनएआई के बेसलाइन के एक शाखा, स्थिर-बेसलाइन रिपॉजिटरी से पीपीओ रोबोट का उपयोग करेंगे।

OpenAI और DeepMind के लिए बहुत बहुत धन्यवाद, जो पिछले कुछ वर्षों में Deep Learning के शोधकर्ताओं के लिए उपलब्ध कराए गए ओपन सोर्स सॉफ्टवेयर के लिए। यदि आपने अभी तक AlphaGo, OpenAI Five और AlphaStar जैसी प्रौद्योगिकियों के साथ उनके आश्चर्यजनक उपलब्धियों को नहीं देखा है, तो आप पिछले साल से पृथकवास के बाहर रह सकते हैं, लेकिन आपको उन्हें देखना चाहिए।

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

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

यह बहुत आसान है, और यह कुछ भी मूल्य नहीं रखता है।

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

योजना

1.为我们的机器人创建gym环境以供其进行机器学习

2.渲染一个简单而优雅的可视化环境

3.训练我们的机器人，使其学习一个可获利的交易策略

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

प्रवेश

在本教程中，我们将使用Zielak生成的Kaggle数据集。如果您想下载源代码，我的Github仓库中会提供，同时也有.csv数据文件。好的，让我们开始吧。

सबसे पहले, हम सभी आवश्यक पुस्तकालयों को आयात करते हैं.

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

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

हम डेटा को 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)

हमारे action_space को यहाँ 3 विकल्पों के एक समूह (खरीद, बेच या धारण) और 10 राशि (१/१०, २/१०, ३/१० आदि) के एक समूह के रूप में दर्शाया गया है। जब हम खरीद कार्रवाई का चयन करते हैं, तो हम buy amount * self.balance worth of BTC को चुनते हैं। बिक्री क्रिया के लिए, हम sell amount * self.btc_held value of BTC को चुनते हैं। बेशक, धारण क्रिया राशि को अनदेखा करती है और कुछ नहीं करती है।

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

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

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 के समय-चरण के बाद, हमारे रोबोट हमेशा डेटासेट में एक साथ चलेंगे, और प्रत्येक समय-चरण के बाद तीन विकल्प होंगेः खरीदें, बेचें या पकड़ें। इन तीनों विकल्पों में से प्रत्येक के लिए एक अन्य विकल्प की आवश्यकता होती हैः 10%, 20%,... या 100% विशिष्ट व्यवहार्यता। इसका मतलब है कि हमारे रोबोट को 103 में से किसी भी 10 में से एक स्थिति का सामना करना पड़ सकता है, कुल मिलाकर 1030 स्थितियां।

अब हमारे यादृच्छिक टुकड़े के वातावरण में लौटते हैं। समय पैदल 10 पर, हमारा रोबोट किसी भी len (df) समय पैदल में हो सकता है। प्रत्येक समय पैदल के बाद एक ही विकल्प बनाने की धारणा का मतलब है कि रोबोट एक ही 10 समय पैदल में किसी भी len (df) के 30 सेकंड में एक ही स्थिति का अनुभव कर सकता है।

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

रोबोट की आंखों से देखा गया

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

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

छवि में प्रत्येक पंक्ति हमारे observation_space में एक पंक्ति का प्रतिनिधित्व करती है; पहले 4 पंक्तियों में समान आवृत्ति वाली लाल पंक्ति OHCL डेटा का प्रतिनिधित्व करती है, और नीचे दिए गए नारंगी और पीले बिंदु लेनदेन का प्रतिनिधित्व करते हैं; नीचे की उतार-चढ़ाव वाली नीली पट्टी रोबोट का शुद्ध मूल्य है, और नीचे की हल्की पट्टी रोबोट के लेनदेन का प्रतिनिधित्व करती है।

यदि आप बारीकी से देखते हैं, तो आप अपने आप को एक स्क्रैप भी बना सकते हैं. लेनदेन मात्रा पट्टी के नीचे एक मोर्स कोड जैसा इंटरफ़ेस है जो लेनदेन इतिहास दिखाता है. ऐसा लगता है कि हमारे रोबोट को हमारे observation_space में डेटा से पूरी तरह से सीखने में सक्षम होना चाहिए, इसलिए चलो जारी रखें. यहाँ हम _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 को कॉल करते हैं। अन्यथा, हम रिवार्ड को वर्तमान नेटवर्थ पर सेट करते हैं, और यदि हमारे फंड समाप्त हो जाते हैं, तो इसे True पर सेट करते हैं।

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, {}

ट्रेडिंग एक्शन लेना उतना ही सरल है जितना कि वर्तमान_मूल्य प्राप्त करना, कार्य करने के लिए आवश्यक कार्यों को निर्धारित करना, और खरीदने या बेचने के लिए संख्याएं। चलो जल्दी से एक_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中的代码，并重新设计它以适应比特币环境。你可以从我的Github中获取代码。

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

from datetime import datetime

सबसे पहले, हम datetime library को import करते हैं, फिर हम utcfromtimestampmethod का उपयोग करके प्रत्येक timeframe और strftime से UTC स्ट्रिंग प्राप्त करते हैं, ताकि इसे Y-m-d H:M प्रारूप में स्ट्रिंग के रूप में स्वरूपित किया जा सके।

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

अंत में, हम अपने डेटासेट से मेल खाने के लिए self.df[Volume] को 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-fold प्रूफिंग कहा जाता है, जिसमें आप डेटा को k समकक्ष समूहों में विभाजित करते हैं, प्रत्येक समूह को अलग से एक परीक्षण समूह के रूप में लेते हैं, और शेष डेटा को प्रशिक्षण समूह के रूप में उपयोग करते हैं। हालांकि, समय अनुक्रम डेटा अत्यधिक समय-निर्भर है, जिसका अर्थ है कि बाद के डेटा पहले के डेटा पर अत्यधिक निर्भर हैं। इसलिए k-fold काम नहीं करेगा, क्योंकि हमारे रोबोट लेनदेन से पहले भविष्य के डेटा से सीखेंगे, जो एक अनुचित लाभ है।

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

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 चरणों के दौरान 1000x संतुलन प्राप्त कर सकते हैं, बाकी औसत कम से कम 30 गुना बढ़ जाती है!

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

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

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

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

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

reward = self.net_worth - prev_net_worth

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

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

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

निष्कर्ष

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

1.使用OpenAI的gym从零开始创建比特币交易环境。

2.使用Matplotlib构建该环境的可视化。

3.使用简单的交叉验证对我们的机器人进行训练和测试。

4.略微调整我们的机器人以实现盈利

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

संबंधित

अधिक