بٹ کوائن ٹریڈنگ روبوٹ بنانا جو پیسہ نہیں کھوئے گا

آئیے اے آئی میں تقویت یافتہ سیکھنے کا استعمال کرتے ہوئے ایک ڈیجیٹل کرنسی ٹریڈنگ روبوٹ بنائیں

اس سبق میں ، ہم اوپن اے آئی کے جم اور اسٹیبل بیس لائنز ریکوری سے پی پی او روبوٹ کا استعمال کریں گے ، جو اوپن اے آئی بیس ریکوری کا ایک شاخ ہے۔

اوپن اے آئی اور ڈیپ مائنڈ کا شکریہ کہ انہوں نے گذشتہ چند سالوں میں ڈیپ لرننگ کے محققین کے لئے اوپن سورس سافٹ ویئر مہیا کیا ہے۔ اگر آپ نے ابھی تک ان کی حیرت انگیز کامیابیوں کو نہیں دیکھا ہے جو انہوں نے الفاگو ، اوپن اے آئی فائیو اور الفا اسٹار جیسی ٹیکنالوجیز کے ساتھ حاصل کیں ، تو آپ گذشتہ سال قرنطینہ سے باہر رہ سکتے تھے ، لیکن آپ کو بھی ان کو دیکھنا چاہئے۔

الفا اسٹار ٹریننگhttps://deepmind.com/blog/alphastar-mastering-real-time-strategy-game-starcraft-ii/

اگرچہ ہم کچھ بھی متاثر کن نہیں بنائیں گے ، لیکن بٹ کوائن روبوٹ کے ساتھ روزمرہ کی تجارت میں تجارت کرنا ابھی بھی آسان کام نہیں ہے۔ تاہم ، جیسا کہ ٹیڈی روزفر نے کہا تھا ، "ہمیں اس کے بارے میں بہت کچھ جاننے کی ضرورت ہے۔"

اس کے علاوہ ، آپ کو یہ بھی معلوم ہونا چاہئے کہ آپ کے پاس کیا ہے اور آپ کو کیا کرنا چاہئے۔

لہذا ، نہ صرف خود سے تجارت کرنا سیکھیں... بلکہ روبوٹ کو ہمارے لئے تجارت کرنے دیں۔

منصوبہ بندی

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

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

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

اگر آپ ابھی تک جم ماحول بنانے کے بارے میں نہیں جانتے ہیں ، یا ان کے ماحول کو آسانی سے پیش کرنے کے بارے میں نہیں جانتے ہیں۔ آگے بڑھنے سے پہلے ، براہ کرم اس طرح کا ایک مضمون گوگل کریں۔ یہ دونوں اقدامات ابتدائی پروگرامر کے طور پر بھی مشکل نہیں ہوں گے۔

داخلہ

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

سب سے پہلے ، آئیے تمام ضروری لائبریریاں درآمد کریں۔ اس بات کو یقینی بنائیں کہ آپ جو بھی لائبریریاں کھو رہے ہیں اسے پائپ کے ساتھ انسٹال کریں۔

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

اگلا، ہم ماحول کے لئے اپنی کلاس بنائیں گے۔ ہمیں ایک پانڈا کے اعداد و شمار کے ٹن کو منتقل کرنے کی ضرورت ہے، اور ایک اختیاری ابتدائی_توازن اور ایک lookback_window_size، جو روبوٹ کو ہر مرحلے میں مشاہدہ کرنے والے ماضی کے وقت کے اقدامات کو بتائے گا۔ ہم ہر ٹرانزیکشن کی کمیشن کو 0.075٪، یعنی Bitmex کی موجودہ شرح تبادلہ کے طور پر ڈیفالٹ کرتے ہیں، اور اس سلسلے کے پیرامیٹرز کو غلط کے طور پر ڈیفالٹ کرتے ہیں، جس کا مطلب یہ ہے کہ ڈیفالٹ کے تحت ہمارے اعداد و شمار کے ٹن کو بے ترتیب ٹکڑے ٹکڑے میں منتقل کیا جائے گا۔

ہم ڈیٹا کو 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 رقم (۱/۱۰، ۲/۱۰، ۳/۱۰ وغیرہ) ہیں۔ جب ہم خریدنے کا انتخاب کرتے ہیں تو ہم خریدنے کی رقم * self.balance worth of BTC استعمال کرتے ہیں۔ جب ہم فروخت کرتے ہیں تو ہم sell amount * self.btc_held worth of BTC استعمال کرتے ہیں۔ یقیناً، ہولڈ کرنے کی کارروائی رقم کو نظر انداز کرتی ہے اور کچھ نہیں کرتی ہے۔

ہماری مشاہدہ_اسپیس کو 0 سے 1 کے درمیان ایک مسلسل فلوٹ سیٹ کے طور پر بیان کیا گیا ہے ، جس کی شکل ہے ((10,lookback_window_size + 1) ؛ + 1 موجودہ وقت کی لمبائی کا حساب لگانے کے لئے استعمال کیا جاتا ہے۔ ونڈو میں ہر وقت کی لمبائی کے ل we ، ہم OHCLV کی قدر کا مشاہدہ کریں گے۔ ہماری خالص رقم بی ٹی سی کی تعداد کے برابر ہے جو ہم نے خریدی یا فروخت کی ہے ، اور ڈالر کی کل رقم جو ہم نے ان بی ٹی سی پر خرچ کی ہے یا وصول کی ہے۔

اگلا، ہمیں ماحول کو شروع کرنے کے لئے دوبارہ ترتیب دینے کا طریقہ لکھنا ہوگا.

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 طریقہ کار میں، ہم پہلے موجودہ_step کو 0 پر ری سیٹ کرتے ہیں۔ اگلا، ہم steps_left کو 1 سے MAX_TRADING_SESSION تک کسی بھی نمبر پر سیٹ کریں گے، جس کا حصہ ہم پروگرام کے سب سے اوپر کی وضاحت کریں گے۔

MAX_TRADING_SESSION = 100000 ＃ ~2个月

اگلا، اگر ہم مسلسل ٹرنسفر کرنا چاہتے ہیں، تو ہمیں پورے ٹرنسفر پر سیٹ کرنا ہوگا، ورنہ ہم فریم_اسٹارٹ کو خود.df میں ایک بے ترتیب نقطہ کے طور پر سیٹ کریں گے اور ایک نیا ڈیٹا ٹرنسفر بناتے ہیں جسے فعال_df کہا جاتا ہے، جو صرف ایک ٹکڑا ہے self.df اور فریم_اسٹارٹ سے فریم_اسٹارٹ + اقدامات_بائیں تک ہے۔

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 رینڈرنگ کا استعمال کرتے ہوئے قابل مشاہدہ جگہ کی نمائش ہے۔

اوپن سی وی کے منظر نامے کا مشاہدہ

تصویر میں ہر سطر ہمارے مشاہدے کی جگہ میں ایک سطر کی نمائندگی کرتی ہے۔ پہلی چار سطروں میں اسی طرح کی فریکوئنسی والی سرخ لائنیں 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

کارروائی

ہم نے اپنی مشاہداتی جگہ بنائی ہے ، اب وقت آگیا ہے کہ ہم اپنی سیڑھی کی تقریب لکھیں اور پھر روبوٹ کے لئے طے شدہ اقدامات کریں۔ ہر بار جب ہم اپنے موجودہ ٹریڈنگ ٹائم میں خود.steps_left == 0 ہوں گے تو ہم اپنے پاس موجود بی ٹی سی کو فروخت کریں گے اور _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, {}

تجارتی کارروائی کرنا اتنا ہی آسان ہے جتنا کہ موجودہ قیمت حاصل کرنا ، انجام دینے کے لئے ضروری کارروائی کا تعین کرنا ، اور خریدنے یا فروخت کرنے کی تعداد۔ آئیے جلدی سے_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)

ہمارے روبوٹ اب نئے ماحول کو شروع کر سکتے ہیں، اس ماحول کو آہستہ آہستہ مکمل کر سکتے ہیں، اور ماحول کو متاثر کرنے والے اقدامات کر سکتے ہیں۔ اب وقت آگیا ہے کہ ان کی تجارت کی جائے۔

ہماری روبوٹ تجارت دیکھیں

ہمارے رنگنے کا طریقہ اتنا ہی آسان ہوسکتا ہے جتنا پرنٹ ((self.net_worth) کو کال کرنا ، لیکن یہ کافی دلچسپ نہیں ہے۔ اس کے بجائے ، ہم ایک سادہ ٹائپ گراف تیار کریں گے جس میں ٹرانزیکشن حجم کی چوٹی اور ہماری خالص قیمت کا ایک الگ چارٹ شامل ہے۔

我们将从我上一篇文章中获取StockTradingGraph.py中的代码，并重新设计它以适应比特币环境。你可以从我的Github中获取代码。

پہلی تبدیلی جو ہم کریں گے وہ یہ ہے کہ ہم self.df [Date tag] کو self.df [Timestamp tag] میں اپ ڈیٹ کریں گے اور date2num پر تمام کالز کو ہٹا دیں گے کیونکہ ہماری تاریخ پہلے سے ہی یونیکس ٹائم ٹیگ فارمیٹ ہے۔ اگلا ، ہمارے رنگنے کے طریقہ کار میں ، ہم تاریخ کے ٹیگ کو اپ ڈیٹ کریں گے تاکہ اعداد کے بجائے انسانی پڑھنے کے قابل تاریخوں کو پرنٹ کیا جاسکے۔

from datetime import datetime

سب سے پہلے ، ہم ڈیٹا ٹائم لائبریری کو درآمد کرتے ہیں ، پھر ہم ہر ٹائم اسٹیمپ اور strftime سے UTC سٹرنگ حاصل کرنے کے لئے utcfromtimestampmethod کا استعمال کرتے ہیں ، تاکہ اس کی شکل: 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 مساوی گروپس میں تقسیم کرتے ہیں ، ہر ایک گروپ کو الگ الگ ٹیسٹ گروپ کے طور پر استعمال کرتے ہیں ، اور باقی ڈیٹا کو ٹریننگ گروپ کے طور پر استعمال کرتے ہیں۔ تاہم ، ٹائم سیریز کا ڈیٹا بہت زیادہ وقت پر منحصر ہے ، جس کا مطلب ہے کہ بعد کا ڈیٹا بہت زیادہ پچھلے ڈیٹا پر منحصر ہے۔ لہذا ، کے فولڈ کام نہیں کرے گا ، کیونکہ ہمارے روبوٹ تجارت سے پہلے مستقبل کے اعداد و شمار سے سیکھیں گے ، جو ایک غیر منصفانہ فائدہ ہے۔

جب وقت کے سلسلے کے اعداد و شمار پر لاگو کیا جاتا ہے تو ، اسی طرح کے نقائص زیادہ تر دیگر کراس ویلیڈیشن کی حکمت عملیوں پر لاگو ہوتے ہیں۔ لہذا ، ہمیں صرف مکمل اعداد و شمار کے ایک حصے کو ایک ٹریننگ سیٹ کے طور پر استعمال کرنے کی ضرورت ہے ، جس میں کسی بھی انڈیکس کے لئے کسی بھی انڈیکس سے شروع ہوتا ہے ، اور باقی ڈیٹا کو ٹیسٹ سیٹ کے طور پر استعمال کیا جاتا ہے۔

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 روبوٹ کے بجائے مستحکم بیس لائن پر A2C استعمال کرنے کے لئے تبدیل کردیں گے۔ اور آخر میں ، شین اوگورمین کی تجویز کے مطابق ، ہم اپنی انعامات کی خصوصیت کو تھوڑا سا اپ ڈیٹ کرسکتے ہیں تاکہ ہم خالص میں انعامات میں اضافہ کریں ، نہ کہ صرف اعلی خالص حاصل کریں اور وہاں رہیں۔

reward = self.net_worth - prev_net_worth

صرف یہ دو تبدیلیاں ٹیسٹ ڈیٹا سیٹ کی کارکردگی کو بہت بہتر بناسکتی ہیں ، اور جیسا کہ آپ ذیل میں دیکھیں گے ، ہم آخر کار نئے اعداد و شمار پر فائدہ اٹھانے کے قابل ہو گئے ہیں جو ٹریننگ سیٹ میں موجود نہیں تھے۔

لیکن ہم بہتر کام کر سکتے ہیں۔ ان نتائج کو بہتر بنانے کے لیے ہمیں اپنے سپر پیرامیٹرز کو بہتر بنانے اور اپنے روبوٹ کو زیادہ دیر تک تربیت دینے کی ضرورت ہے۔ اب وقت آگیا ہے کہ جی پی یو کو کام کرنے دیں اور اسے مکمل طور پر چلائیں!

اب تک ، یہ مضمون تھوڑا سا لمبا ہے ، اور ہمارے پاس بہت ساری تفصیلات ہیں جن پر غور کرنے کی ضرورت ہے ، لہذا ہم یہاں آرام کرنے کا ارادہ رکھتے ہیں۔ اگلے مضمون میں ، ہم بائیز کی اصلاح کا استعمال کرتے ہوئے اپنے مسئلے کی جگہ کے لئے بہترین سپر پیرامیٹرز کا تعین کریں گے اور CUDA کا استعمال کرتے ہوئے GPU پر تربیت / جانچ کے لئے تیار ہوں گے۔

اختتام

اس مضمون میں ہم نے ایک منافع بخش بٹ کوائن ٹریڈنگ روبوٹ بنانے کے لئے مضبوط سیکھنے کا استعمال کرتے ہوئے شروع کیا۔ ہم مندرجہ ذیل کاموں کو انجام دینے کے قابل تھے:

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

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

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

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

اگرچہ ہمارے ٹریڈنگ روبوٹ اتنے منافع بخش نہیں تھے جتنا ہم چاہتے تھے ، لیکن ہم صحیح سمت میں آگے بڑھ رہے ہیں۔ اگلی بار ، ہم اس بات کو یقینی بنائیں گے کہ ہمارے روبوٹ ہمیشہ مارکیٹوں کو شکست دیتے رہیں ، اور ہم دیکھیں گے کہ ہمارے ٹریڈنگ روبوٹ حقیقی وقت کے اعداد و شمار کو کس طرح سنبھالتے ہیں۔ براہ کرم میرے اگلے مضمون پر نظر رکھیں ، اور بٹ کوائن کی زندگی!

متعلقہ

مزید