add equity

rl_agent/env.py

@@ -29,14 +29,15 @@ class Environment:
         
         Zt = self.data.iloc[self.t, :]['Close'] - self.data.iloc[(self.t-1), :]['Close']
         reward = (self.position_value * Zt) - (self.cost_rate * cost_amount)
-        profit = self.position_value * Zt
-        self.profits += profit
+        self.profit = self.position_value * Zt
+        self.profits += self.profit
 
         # set next time
         self.t += 1
         self.position_value = act
         
         self.history.pop(0)
+        
         self.history.append(self.data.iloc[self.t, :]['Close'] - self.data.iloc[(self.t-1), :]['Close']) # the price being traded
         
         self.position_value = self.position_value.item()

rl_agent/test_env.py

@@ -9,18 +9,26 @@ from collections import OrderedDict
 
 import matplotlib.pyplot as plt
 
+from tqdm import tqdm
+from torch.utils.tensorboard import SummaryWriter
+
 if __name__ == "__main__":
+    writer = SummaryWriter('runs/new_data_ex_7')
 
-    data = pd.read_csv('./data/EURUSD_Candlestick_1_M_BID_01.01.2021-04.02.2023.csv')
+    # data = pd.read_csv('./data/EURUSD_Candlestick_1_M_BID_01.01.2021-04.02.2023.csv')
+    data = pd.read_csv('./data/EURUSD_Candlestick_30_M_BID_01.01.2021-04.02.2023.csv')
     # data['Local time'] = pd.to_datetime(data['Local time'])
     data = data.set_index('Local time')
     print(data.index.min(), data.index.max())
 
-    date_split = '19.09.2022 17:55:00.000 GMT-0500'
+    # date_split = '19.09.2022 17:55:00.000 GMT-0500'
+    # date_split = '25.08.2022 04:30:00.000 GMT-0500' # 30 min
+
+    date_split = '03.02.2023 15:30:00.000 GMT-0600' # 30 min
+
     train = data[:date_split]
     test = data[date_split:]
 
-    initial_money = 10.0
 
     learning_rate = 0.001
     first_momentum = 0.0
@@ -28,6 +36,7 @@ if __name__ == "__main__":
     transaction_cost = 0.0001
     adaptation_rate = 0.01
     state_size = 15
+    equity = 1.0
 
     agent = Policy(input_channels=state_size)
     optimizer = myOptimizer(learning_rate, first_momentum, second_momentum, adaptation_rate, transaction_cost)
@@ -50,10 +59,8 @@ if __name__ == "__main__":
         model_gradients_history.update({name: torch.zeros_like(param)})
 
 
-    p = []
-
 
-    for _ in range(state_size, 28800):
+    for i in tqdm(range(state_size, len(train))):
         observation = torch.as_tensor(observation).float()
         action = agent(observation)
         observation, reward, _ = env.step(action.data.to("cpu").numpy())
@@ -69,47 +76,52 @@ if __name__ == "__main__":
             param = param + optimizer.step(grad_n, reward, observation[-1], model_gradients_history[name])
             checkpoint[name] = param
             model_gradients_history.update({name: grad_n})
-        
-        p.append(env.profits)
+
+        if i > 10000:
+            equity += env.profit
+            writer.add_scalar('equity', equity, i)    
+        else:
+            writer.add_scalar('equity', 1.0, i) 
+
         optimizer.after_step(reward)
         agent.load_state_dict(checkpoint)
 
     ###########
     ###########
 
-    history = []
-    for i in range(1, state_size):
-        c = test.iloc[i, :]['Close'] - test.iloc[i-1, :]['Close']
-        history.append(c)
+    # history = []
+    # for i in range(1, state_size):
+    #     c = test.iloc[i, :]['Close'] - test.iloc[i-1, :]['Close']
+    #     history.append(c)
 
-    env = Environment(test, history=history, state_size=state_size)
-    observation = env.reset()
+    # env = Environment(test, history=history, state_size=state_size)
+    # observation = env.reset()
     
 
-    model_gradients_history = dict()
-    checkpoint = OrderedDict()
+    # model_gradients_history = dict()
+    # checkpoint = OrderedDict()
 
-    for name, param in agent.named_parameters():
-        model_gradients_history.update({name: torch.zeros_like(param)})
+    # for name, param in agent.named_parameters():
+    #     model_gradients_history.update({name: torch.zeros_like(param)})
 
-    for _ in range(state_size, 14400):
-        observation = torch.as_tensor(observation).float()
-        action = agent(observation)
-        observation, reward, _ = env.step(action.data.numpy())
+    # for _ in tqdm(range(state_size, len(test))):
+    #     observation = torch.as_tensor(observation).float()
+    #     action = agent(observation)
+    #     observation, reward, _ = env.step(action.data.numpy())
 
 
         
         
-        action.backward()
+    #     action.backward()
 
-        for name, param in agent.named_parameters():
+    #     for name, param in agent.named_parameters():
         
-            grad_n = param.grad
-            param = param + optimizer.step(grad_n, reward, observation[-1], model_gradients_history[name])
-            checkpoint[name] = param
-            model_gradients_history.update({name: grad_n})
+    #         grad_n = param.grad
+    #         param = param + optimizer.step(grad_n, reward, observation[-1], model_gradients_history[name])
+    #         checkpoint[name] = param
+    #         model_gradients_history.update({name: grad_n})
 
-        optimizer.after_step(reward)
-        agent.load_state_dict(checkpoint)
+    #     optimizer.after_step(reward)
+    #     agent.load_state_dict(checkpoint)
 
     print(env.profits)