Initial integration

app.py

@@ -3,14 +3,74 @@ import pandas as pd
 import plotly.graph_objects as go
 from plotly.subplots import make_subplots
 
+from env import Environment
+from policy import Policy
+from utils import myOptimizer
+
+import torch
+from collections import OrderedDict
+from tqdm import tqdm
+
 
 import datetime
 def get_time():
     return datetime.datetime.now().time()
 
 
+def init_rl_agent(train, test):
+    date_split = '01.09.2022 00:00:00.000 GMT-0500'
+
+    learning_rate = 0.001
+    first_momentum = 0.0
+    second_momentum = 0.0001
+    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)
+
+    history = []
+    for i in range(1, state_size):
+        c = train.iloc[i, :]['Close'] - train.iloc[i - 1, :]['Close']
+        history.append(c)
+
+    env = Environment(train, history=history, state_size=state_size)
+    observation = env.reset()
+
+    return env, agent, optimizer, state_size, observation, date_split, equity
+
+
+def make_prediction(env, agent, optimizer, state_size, observation, data, date_split, equity):
+    model_gradients_history = dict()
+    checkpoint = OrderedDict()
+
+    for name, param in agent.named_parameters():
+        model_gradients_history.update({name: torch.zeros_like(param)})
+
+    for i in tqdm(range(state_size, len(data[:date_split]))):
+        observation = torch.as_tensor(observation).float()
+        action = agent(observation)
+        observation, reward, _ = env.step(action.data.to("cpu").numpy())
+
+        action.backward()
+
+        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})
+
+        if i > 10000:
+            equity += env.profit
+
+        optimizer.after_step(reward)
+        agent.load_state_dict(checkpoint)
+
+
 counter = 0
-start_year, test_year = 2018, 2023
+start_year, test_year = 2021, 2023
 datetime_column = "Date"
 df_data = pd.read_csv(f"./data/EURUSD_Candlestick_1_M_BID_01.01.{start_year}-04.02.2023_processed.csv")
 df_data[datetime_column] = pd.to_datetime(df_data[datetime_column], format="%Y-%m-%d")    # %d.%m.%Y %H:%M:%S.000 GMT%z

rl_agent/test_env.py

@@ -12,6 +12,7 @@ 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')
 
@@ -21,14 +22,13 @@ if __name__ == "__main__":
     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 = '01.09.2022 00:00: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:]
 
-
     learning_rate = 0.001
     first_momentum = 0.0
     second_momentum = 0.0001
@@ -40,8 +40,6 @@ if __name__ == "__main__":
     agent = Policy(input_channels=state_size)
     optimizer = myOptimizer(learning_rate, first_momentum, second_momentum, adaptation_rate, transaction_cost)
 
-    
-
     history = []
     for i in range(1, state_size):
         c = train.iloc[i, :]['Close'] - train.iloc[i-1, :]['Close']
@@ -49,7 +47,6 @@ if __name__ == "__main__":
 
     env = Environment(train, history=history, state_size=state_size)
     observation = env.reset()
-    
 
     model_gradients_history = dict()
     checkpoint = OrderedDict()
@@ -57,20 +54,14 @@ if __name__ == "__main__":
     for name, param in agent.named_parameters():
         model_gradients_history.update({name: torch.zeros_like(param)})
 
-
-
     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())
-
-
-        
         
         action.backward()
 
         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
@@ -95,7 +86,6 @@ if __name__ == "__main__":
 
     # env = Environment(test, history=history, state_size=state_size)
     # observation = env.reset()
-    
 
     # model_gradients_history = dict()
     # checkpoint = OrderedDict()
@@ -107,14 +97,9 @@ if __name__ == "__main__":
     #     observation = torch.as_tensor(observation).float()
     #     action = agent(observation)
     #     observation, reward, _ = env.step(action.data.numpy())
-
-
-        
-        
     #     action.backward()
 
     #     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
@@ -123,4 +108,5 @@ if __name__ == "__main__":
     #     optimizer.after_step(reward)
     #     agent.load_state_dict(checkpoint)
 
-    print(env.profits)
+    print(env.profits)
+