Random seeding

marketsim/MM/simMM.py

@@ -36,8 +36,12 @@ def __init__(self,
                  p=2,
                  k_min=5,
                  k_max=20,
-                 max_position=100
+                 max_position=100, 
+                 random_seed: int = None
                  ):
+
+        random.seed(random_seed)
+        torch.seed(random.randint(1, 4096))
 
         if shade is None:
             shade = [250, 500]
@@ -71,8 +75,8 @@ def __init__(self,
 
         self.markets = []
         for _ in range(num_assets):
-            fundamental = LazyGaussianMeanReverting(mean=mean, final_time=sim_time+1, r=r, shock_var=shock_var)
-            self.markets.append(Market(fundamental=fundamental, time_steps=sim_time))
+            fundamental = LazyGaussianMeanReverting(mean=mean, final_time=sim_time+1, r=r, shock_var=shock_var, random_seed=random.randint(1, 4096))
+            self.markets.append(Market(fundamental=fundamental, time_steps=sim_time, random_seed=random.randint(1, 4096)))
 
         self.agents = {}
         for agent_id in range(num_background_agents):
@@ -85,8 +89,10 @@ def __init__(self,
                     market=self.markets[0],
                     q_max=q_max,
                     shade=shade,
-                    pv_var=pv_var
-                ))
+                    pv_var=pv_var,
+                    random_seed=random.randint(1,4096)
+                )
+            )
 
         self.arrivals_MM[self.arrival_times_MM[self.arrival_index_MM].item()].append(self.num_background_agents)
         self.arrival_index_MM += 1
@@ -106,15 +112,17 @@ def __init__(self,
                 p=p,
                 k_min=k_min,
                 k_max=k_max,
-                max_position=max_position
+                max_position=max_position,
+                random_seed=random.randint(1,4096)
             )
         else: # ladder policy
             self.MM = MMAgent(
                 agent_id=self.num_background_agents,
                 market=self.markets[0],
                 K=K,
                 xi=xi,
-                omega=omega
+                omega=omega,
+                random_seed=random.randint(1,4096)
             )
         self.agents[self.num_background_agents] = self.MM
 

marketsim/agent/extented_zi_agent.py

@@ -8,10 +8,13 @@
 
 
 class ZIAgent(Agent):
-    def __init__(self, agent_id: int, market: Market, q_max: int, offset: float, eta: float, shade: List):
+    def __init__(self, agent_id: int, market: Market, q_max: int, pv_var: int, offset: float, eta: float, shade: List, random_seed: int = None):
+
+        random.seed(random_seed)
+
         self.agent_id = agent_id
         self.market = market
-        self.pv = PrivateValues(q_max)
+        self.pv = PrivateValues(q_max, pv_var, random_seed=random.randint(1,4096))
         self.position = 0
         self.offset = offset
         self.eta = eta

marketsim/agent/hbl_agent.py

@@ -15,10 +15,14 @@
 
 class HBLAgent(Agent):
     def __init__(self, agent_id: int, market: Market, q_max: int, shade: List, L: int, pv_var: float,
-                 arrival_rate: float):
+                 arrival_rate: float, random_seed: int = None):
+
+        random.seed(random_seed)
+        np.random.seed(random.randint(1,4096))
+
         self.agent_id = agent_id
         self.market = market
-        self.pv = PrivateValues(q_max, pv_var)
+        self.pv = PrivateValues(q_max, pv_var, random_seed=random.randint(1,4096))
         self.position = 0
         self.shade = shade
         self.cash = 0

marketsim/agent/market_maker.py

@@ -8,7 +8,10 @@
 
 
 class MMAgent(Agent):
-    def __init__(self, agent_id: int, market: Market, xi: float, K: int, omega: float):
+    def __init__(self, agent_id: int, market: Market, xi: float, K: int, omega: float, random_seed: int = None):
+
+        random.seed(random_seed)
+
         self.agent_id = agent_id
         self.market = market
 

marketsim/agent/market_maker_beta.py

@@ -65,7 +65,11 @@ def __init__(self,
                  p=2,
                  k_min=5,
                  k_max=20,
-                 max_position=15):
+                 max_position=15,
+                 random_seed: int = None):
+
+        random.seed(random_seed)
+        np.random.seed(random.randint(1,4096))
 
         self.agent_id = agent_id
         self.market = market

marketsim/agent/spoofer.py

@@ -7,10 +7,13 @@
 
 
 class SpoofingAgent(Agent):
-    def __init__(self, agent_id: int, market: Market, q_max: int, pv_var: float, order_size:int, spoofing_size: int, normalizers: dict):
+    def __init__(self, agent_id: int, market: Market, q_max: int, pv_var: float, order_size:int, spoofing_size: int, normalizers: dict, random_seed: int = None):
+
+        random.seed(random_seed)
+
         self.agent_id = agent_id
         self.market = market
-        self.pv = PrivateValues(q_max, pv_var)
+        self.pv = PrivateValues(q_max, pv_var, random_seed=random.randint(1,4096))
         self.position = 0
         self.spoofing_size = spoofing_size
         self.order_size = order_size
@@ -75,7 +78,7 @@ def get_pos_value(self) -> float:
         return self.pv.value_at_position(self.position)
 
     def reset(self):
-        self.pv = PrivateValues(self.q_max, self.pv_var)
+        self.pv = PrivateValues(self.q_max, self.pv_var, random_seed=random.randint(1,4096))
         self.position = 0
         self.cash = 0
         self.last_value = 0

marketsim/agent/zero_intelligence_agent.py

@@ -9,12 +9,16 @@
 
 
 class ZIAgent(Agent):
-    def __init__(self, agent_id: int, market: Market, q_max: int, shade: List, pv_var: float, eta: float = 1.0):
+    def __init__(self, agent_id: int, market: Market, q_max: int, shade: List, pv_var: float, eta: float = 1.0, random_seed: int = None):
+
+        random.seed(random_seed)
+        np.random.seed(random.randint(1, 4096))
+
         self.agent_id = agent_id
         self.market = market
         self.q_max = q_max
         self.pv_var = pv_var
-        self.pv = PrivateValues(q_max, pv_var)
+        self.pv = PrivateValues(q_max, pv_var, random_seed=random.randint(1, 4096))
         self.position = 0
         self.shade = shade
         self.cash = 0
@@ -86,5 +90,5 @@ def get_pos_value(self) -> float:
     def reset(self):
         self.position = 0
         self.cash = 0
-        self.pv = PrivateValues(self.q_max, self.pv_var)
+        self.pv = PrivateValues(self.q_max, self.pv_var, random_seed=random.randint(1, 4096))
 

marketsim/event/event_queue.py

@@ -6,8 +6,10 @@
 
 
 class EventQueue:
-    def __init__(self, rand_seed: int = None):
-        self.rand = random.Random(rand_seed)
+    def __init__(self, random_seed: int = None):
+
+        random.seed(random_seed)
+
         self.scheduled_activities = defaultdict(list)
         self.current_time = 0
 
@@ -27,3 +29,4 @@ def get_current_time(self):
 
     def set_time(self, t):
         self.current_time = t
+

marketsim/fundamental/constant.py

@@ -1,10 +1,15 @@
+import random
 import torch
 
 from fundamental_abc import Fundamental
 
 
 class Constant(Fundamental):
-    def __init__(self, final_time: int, value: float):
+    def __init__(self, final_time: int, value: float, random_seed: int = None):
+
+        random.seed(random_seed)
+        torch.manual_seed(random.randint(1, 4096))
+
         self.fundamental_values = torch.ones(final_time, dtype=torch.float32)*value
 
     def get_value_at(self, time: int) -> float:

marketsim/fundamental/lazy_mean_reverting.py

@@ -1,3 +1,4 @@
+import random
 import torch
 from marketsim.fundamental.fundamental_abc import Fundamental
 
@@ -13,7 +14,11 @@ class LazyGaussianMeanReverting(Fundamental):
         shock_var (float): The variance of the Gaussian shocks.
         shock_mean (float, optional): The mean of the Gaussian shocks. Default is 0.
     """
-    def __init__(self, final_time: int, mean: float, r: float, shock_var: float, shock_mean: float = 0):
+    def __init__(self, final_time: int, mean: float, r: float, shock_var: float, shock_mean: float = 0, random_seed: int = None):
+
+        random.seed(random_seed)
+        torch.manual_seed(random.randint(1, 4096))
+
         self.final_time = final_time
         self.mean = torch.tensor(mean, dtype=torch.float32)
         self.r = torch.tensor(r, dtype=torch.float32)

marketsim/fundamental/mean_reverting.py

@@ -1,9 +1,14 @@
+import random
 import torch
 from .fundamental_abc import Fundamental
 
 
 class GaussianMeanReverting(Fundamental):
-    def __init__(self, final_time: int, mean: float, r: float, shock_var: float, shock_mean: float = 0):
+    def __init__(self, final_time: int, mean: float, r: float, shock_var: float, shock_mean: float = 0, random_seed: int = None):
+
+        random.seed(random_seed)
+        torch.manual_seed(random.randint(1, 4096))
+
         self.final_time = final_time
         self.mean = torch.tensor(mean, dtype=torch.float32)
         self.r = torch.tensor(r, dtype=torch.float32)