Multiple model runs /batchrunner runs not independent

[yannickoswald]

Hello,

I have constructed the following model and file. If I run the script one time, or many times from scratch again, the model runs fine and as I expect it to. However if I loop through multiple runs, using a simple loop or the batchrunner (doesn't matter same behaviour), the runs are not independent anymore but information is passed on to subsequent runs. I suspect it has something to do with how the class "model" is instantiated or how I set up some specific code within the classes "model" or "agent". It is like there is some memory from run to run or certain variables are not correctly passed on.

However I am 2 days on it and cannot find my mistake. As said, a single model run is exactly as i expect it to work. I tried several things including carefully passing variables and objects with deepcopy() and deleteting instances of classes after all their data is used. Nothing has worked so far. I am quite new to OOP so my mistake might be more trivial than it seems to me and not sure it is MESA specific. I did not encounter the same problem with the example model from the tutorials.

You can try exactly what I mean by going to the 2nd code cell and either set no_of_iterations to 1 and running the whole script multiple times, then the output variable of interest will be following mostly values between 100 and 200 sometimes maybe stuck at lower values but clearly following a different distribution as when you set numer of iteratios to 10 and there you can see in "result_array" that the output has stored monotonically increasing values (which is non-sense and shows the dependence of the results). There is a variable in the agent class "minimum difference" to which all of this is related, so much I have found out, but I don't know exactly why this is caused by my code.

I know some of the code pieces e.g. the compute_distance() function is horribly long but any help appreciated.

import mesa
import mesa.time
import mesa.space
import matplotlib.pyplot as plt
import numpy as np
import math as math
import mesa.batchrunner
import pandas as pd
import copy as copy


def count_lockdowns(model):
    agent_lockdown_states = [agent.state for agent in model.schedule.agents]
    sum_lockdowns = sum(agent_lockdown_states)
    return sum_lockdowns




class CountryAgent(mesa.Agent):
    """Represents a single ALIVE or DEAD cell in the simulation."""
    
    
    NO_LOCKDOWN = 0
    LOCKDOWN = 1
    ### trying this based on this code 
    ### https://stackoverflow.com/questions/328851/printing-all-instances-of-a-class
    instances = []

        
    "initialize agent with income and democracy index only and drawn from a random distribution"
        
    def __init__(self, unique_id, model, init_state=NO_LOCKDOWN):
       super().__init__(unique_id, model)
       self.income = np.random.exponential(20000)
       self.politicalregime = np.random.normal(5.43, 2)
       self.covidcases = np.random.gamma(0.3,1)
       self.adoption_threshold = np.random.normal (0.15, 0.15 * 0.2)
       self.minimum_difference = 1
       self.state = init_state
       self.__class__.instances.append(self)
       if self.adoption_threshold <= 0.001:
              self.adoption_threshold  = 0.01 


    def compute_distance(self):
        
       if self.state == 0:
           
           ### find all countries that have implemented lockdown already
           ### and store in list
           ### also compute ranges of agent properties
            
           max_income = 20000 ## ~ mean of the distr. as initial seed
           min_income = 0 
           
           max_politicalregime = 5.43  ## ~ mean of the distr. as initial seed
           min_politicalregime = 0 
           
           max_covidcases = 0.4 ## ~ mean of the distr. as initial seed
           min_covidcases = 0
           

           list_of_lockdown_countries = []
           for i in range(0, len(CountryAgent.instances)):     
               if CountryAgent.instances[i].state == 1:
                   list_of_lockdown_countries.append(CountryAgent.instances[i])
               
                
               ## find min and max income
               if CountryAgent.instances[i].income > max_income:
                       max_income = copy.deepcopy(CountryAgent.instances[i].income)
               if CountryAgent.instances[i].income < min_income:
                       min_income = copy.deepcopy(CountryAgent.instances[i].income)
                       
               ## find min and max politicalregime        
               if CountryAgent.instances[i].politicalregime > max_politicalregime:
                      max_politicalregime = copy.deepcopy(CountryAgent.instances[i].politicalregime)
               if CountryAgent.instances[i].income < min_politicalregime:
                      min_politicalregime = copy.deepcopy(CountryAgent.instances[i].politicalregime)
                        
               ## find min and max covidcases       
               if CountryAgent.instances[i].covidcases > max_covidcases:
                      max_covidcases = copy.deepcopy(CountryAgent.instances[i].covidcases)
               if CountryAgent.instances[i].covidcases < min_covidcases:
                      min_covidcases = copy.deepcopy(CountryAgent.instances[i].covidcases)
                       
           range_income = max_income - min_income
           range_politicalregime = max_politicalregime - min_politicalregime
           range_covidcases = max_covidcases - min_covidcases
               
           #  compute distance function to all other countries that have lockdown
           
           income_differences_array = np.zeros((len(list_of_lockdown_countries), 1))
           politicalregime_differences_array = np.zeros((len(list_of_lockdown_countries), 1))
           covidcases_differences_array = np.zeros((len(list_of_lockdown_countries), 1))
           geo_differences_array = np.zeros((len(list_of_lockdown_countries), 1))
           total_differences_array  = np.zeros((len(list_of_lockdown_countries), 1))
    
           for i in range(0,len(list_of_lockdown_countries)):
                       
                 income_differences_array[i,0] = self.income - list_of_lockdown_countries[i].income
                 politicalregime_differences_array[i,0] = self.politicalregime - list_of_lockdown_countries[i].politicalregime
                 covidcases_differences_array[i,0] = self.covidcases - list_of_lockdown_countries[i].covidcases
                 geo_differences_array[i,0] = np.sqrt((self.pos[0] - list_of_lockdown_countries[i].pos[0]) ** 2 + (self.pos[1] - list_of_lockdown_countries[i].pos[1]) ** 2)
        
           total_differences_array  = ((abs(income_differences_array)) / range_income
                                              + (abs(politicalregime_differences_array)) / range_politicalregime
                                              + (abs(covidcases_differences_array)) / range_covidcases
                                              + (abs(geo_differences_array)) / np.sqrt( 20 * 20 + 10 * 10 ))
                                              
           #total_differences_array = np.delete(total_differences_array, np.where(total_differences_array == 0)[0][0])
                   
                   
           self.minimum_difference = ((min(total_differences_array, default=0)
                                               + np.random.normal(0,0.05)) 
                                              / (max(total_differences_array, default = 0) + 0.15))
                   
           ### the division by max is a normalization on the interval [0,1]
           ### + 0.15 because the random-noise needs to be factored in the maximum range of possible values
           ### 0.15 is roughly calculated here as upper limited (3 std) to np.random.normal 0, 0.05 
           ### https://onlinestatbook.com/2/calculators/normal_dist.html
           
           list_of_lockdown_countries.clear()
           
       else:
             pass 
                  
           
    def update_state(self):
        
           self.covidcases = self.covidcases + np.random.normal (0, 0.02)
           if self.minimum_difference < self.adoption_threshold:
               self.state = 1
               #self.minimum_difference = 0
               
                
    def step(self):
       self.compute_distance()
       self.update_state()

       # print('\n'.join(A.instances)) #this line was suggested by @anvelascos
       
       
       
      
        
      
                
class CountryModel(mesa.Model):
    """A model with some number of agents."""

    def __init__(self, N, density, width, height):
        self.num_agents = N
        self.density = density
        self.width = width
        self.height = height
        self.grid = mesa.space.MultiGrid(width, height, True)
        self.schedule = mesa.time.RandomActivation(self)
        self.running = True

        # Create agents
        for i in range(self.num_agents):
            a = CountryAgent(i, self)
            self.schedule.add(a)
            if self.random.random() < density:
                a.state = 1

            # Add the agent to a non-random grid cell, 
            # this is for 200 agents on a 20x10 grid
            x = i % 20
            y = math.floor(i/20)
            self.grid.place_agent(a, (x, y))
                        


        self.datacollector = mesa.DataCollector(
            model_reporters={"Number_of_lockdowns": count_lockdowns},
            agent_reporters={"minimum_difference": "minimum_difference", 
                             "Lockdown": "state"}
        )
        
    def reset_randomizer(self, seed):
        """Reset the model random number generator.

        Args:
            seed: A new seed for the RNG; if None, reset using the current seed
        """

        if seed is None:
            seed = self._seed
        self.random.seed(seed)
        self._seed = seed
        


    def step(self):
        self.datacollector.collect(self)
        self.schedule.step()




#%%
no_of_iterations = 10
results_array = np.zeros((no_of_iterations,1))
#from country_model_2 import *
for j in range(no_of_iterations):
        model = CountryModel(200, 0.05, 20, 10)
        for i in range(31):
            model.step()
        
        
        data = copy.deepcopy(model.datacollector.get_agent_vars_dataframe())
        data2 = model.datacollector.get_model_vars_dataframe()

        results_array[j] = data2.iloc[-1][0]
        print("iteration is " + str(j))
        
        
data2.plot()
print(data2.iloc[30])

[rht]

Doing that class instances is not recommended, and is most likely the cause of the unexpected behavior you observed. If you want to access all the initialized agents, you do it this way:

# Inside the compute_distance method
for agent in self.model.schedule.agents:
    # do something with the agent object

[yannickoswald]

Ok thanks but that would need to be a method in the model class then right, this code will not work in the agent class or will it? if i set model to CountryModel (my model class).

[yannickoswald]

I solved my issue. The following way for now. In the future I'll think about how to avoid this issue from scratch.

I just added a reset method to my agent class:

    def reset(cls):
        CountryAgent.instances = []

and call it after every model iteration this way

      CountryAgent.reset(CountryAgent)

not sure though how to use batchrunner with this

[rht]

Once again, it's highly not recommended to put things in class attribute. But if you want to still use it, you can put the reset in the model __init__, so that it automatically gets called during the model initialization.