phenom

evodm/dpsolve.py

@@ -20,7 +20,7 @@ class dp_env:
     """
     def __init__(self, N, sigma, 
                  correl = np.linspace(-1.0,1.0,51), 
-                 num_drugs = 4, drugs = None, noinit = False):
+                 num_drugs = 4, drugs = None, noinit = False, phenom = 0):
         #define the drugs if there aren't any
         if drugs is None:
             ## Generate landscapes - use whatever parameters were set in main()
@@ -35,8 +35,11 @@ def __init__(self, N, sigma,
         #define the landscapes
         landscapes = [Landscape(ls = i, N=N, sigma = sigma, dense = False) for i in drugs]
         #get the transition matrix for each landscape
-        self.tm = [i.get_TM() for i in landscapes]
-
+        #if phenom > 0:
+         #   self.tm = [i.get_TM_phenom(phenom) for i in landscapes]
+        #else: 
+         #   self.tm = [i.get_TM() for i in landscapes]
+        self.tm = [i.get_TM_phenom(phenom) for i in landscapes]
         #get number of states
         self.nS = pow(2,N)
         self.nA = num_drugs

evodm/evol_game.py

@@ -71,10 +71,10 @@ def __init__(self,  drugs = None, N = 5, sigma = 0.5, correl = np.linspace(-1.0,
         self.DENSE= dense
         self.CS = cs
         self.num_drugs = num_drugs
+        self.PHENOM = phenom
 
         #Defining these in case self.reset is called
         self.correl = correl
-        self.phenom = phenom
 
         #define victory counters
         self.player_wcount = 0
@@ -145,8 +145,11 @@ def define_landscapes(self, drugs, normalize_drugs):
             self.drugs = normalize_landscapes(self.drugs)
             self.landscapes = [Landscape(ls = i, N=self.N, sigma = self.sigma,
                                          dense = self.DENSE) for i in self.drugs]
-
-        [i.get_TM() for i in self.landscapes] #pre-compute TM
+        #if self.PHENOM > 0:
+        #    [i.get_TM_phenom(phenom = self.PHENOM) for i in self.landscapes]
+        #else:
+        #    [i.get_TM() for i in self.landscapes] #pre-compute TM
+        [i.get_TM_phenom(phenom = self.PHENOM) for i in self.landscapes]
 
         return 
 

evodm/exp.py

@@ -25,7 +25,7 @@ def evol_deepmind(savepath = None, num_evols = 1, N = 5, episodes = 50,
                   starting_genotype = 0, train_freq = 100, 
                   compute_implied_policy_bool = False,
                   dense = False, master_memory = True,
-                  delay = 0):
+                  delay = 0, phenom = 0):
     """
     evol_deepmind is the main function that initializes and trains a learner to switch between n drugs
     to try and minimize the fitness of a population evolving on a landscape.
@@ -115,6 +115,7 @@ def evol_deepmind(savepath = None, num_evols = 1, N = 5, episodes = 50,
     hp.DENSE = dense
     hp.MASTER_MEMORY = master_memory
     hp.DELAY= int(delay)
+    hp.PHENOM = phenom
 
     #gotta modulate epsilon decay based on the number of episodes defined
     #0.005 = epsilon_decay^episodes

evodm/landscapes.py

@@ -149,7 +149,7 @@ def define_adjMut(self, mut, i):
         return adjMut
 
 
-    def get_TM_phenom(self, phenom, store=False):
+    def get_TM_phenom(self, phenom, store=True):
         """
         Returns the transition matrix for this landscape, with phenomenological stepping (see Tan and Gore 2012). If store=True, it will
         be saved in a field of this object (TM) for later use. If a stored copy already

evodm/learner.py

@@ -91,6 +91,7 @@ def __init__(self):
         self.NUM_DRUGS = 4
         self.MIRA = True
         self.TOTAL_RESISTANCE = False
+        self.PHENOM = 0
         #wright-fisher controls
         self.WF = False
         self.POP_SIZE = 10000
@@ -154,7 +155,8 @@ def __init__(self, hp, drugs= None):
                                 starting_genotype = self.hp.STARTING_GENOTYPE,
                                 total_resistance= self.hp.TOTAL_RESISTANCE,
                                 dense=self.hp.DENSE,
-                                delay=self.hp.DELAY)
+                                delay=self.hp.DELAY, 
+                                phenom=self.hp.PHENOM)
 
         # main model  # gets trained every step
         self.model = self.create_model()
@@ -229,7 +231,7 @@ def train(self):
 
         # Now we need to enumerate our batches
         X,y = self.enumerate_batch(minibatch = minibatch, future_qs_list = future_qs_list, 
-                                   current_qs_list= current_qs_list)
+                                   current_qs_list = current_qs_list)
 
         self.model.fit(X, y, batch_size=self.hp.MINIBATCH_SIZE, 
                        verbose=0, shuffle=False, callbacks=None)
@@ -381,7 +383,8 @@ def compute_optimal_policy(agent, discount_rate = 0.99, num_steps = 20):
     '''
 
     env = dp_env(N = agent.env.N, sigma = agent.env.sigma, 
-                 drugs = agent.env.drugs, num_drugs= len(agent.env.drugs))
+                 drugs = agent.env.drugs, num_drugs= len(agent.env.drugs),
+                 phenom = agent.env.PHENOM)
 
     policy, V = backwards_induction(env = env, discount_rate= discount_rate, num_steps=num_steps)
 

evodm/test/test_exp.py

@@ -18,6 +18,11 @@ def test_mdp_mira_sweep():
     bools_list = list(chain.from_iterable(bools_list))
     assert any(bools_list)
 
+def test_evol_deepmind_phenom():
+    #make sure the phenom landscapes don't crash everything
+    out = evol_deepmind(train_input = 'fitness', episodes=5, num_drugs=15, N=4, 
+                        mira=True, normalize_drugs=False, phenom=20)
+
 def test_evol_deepmind_wf():
     #just make sure it runs quietly at a minimum
     out = evol_deepmind(wf = True, train_input='fitness', episodes=5,