Python DataCollector.add_table_row方法代码示例

# 需要导入模块: from mesa.datacollection import DataCollector [as 别名]
# 或者: from mesa.datacollection.DataCollector import add_table_row [as 别名]
class CrisisWorld(MetaModel):
    '''
    Basic MetaModel for running multiple iterations with a fixed population.

    By default, creates agents with random military strength, assets and
    bloc membership. Fixed agent parameters (e.g. learning rates) 
    can be passed as a dictionary. To generate more complex behaviors, override
    the make_agents method.

    By default, the log is a list of run qualities. Override assess_run method
    as needed to change that.
    '''
    model_class = CrisisModel
    agent_class = CrisisAgent
    agent_count = 10
    agent_args = {}

    def __init__(self, agent_class, agent_count, agent_args={}, seed=None):
        '''
        Instantiate a new CrisisWorld model.

        Args:
            agent_class: Class to instantiate the agents 
            agent_count: How many agents to instantiate with.
            agent_args: Dictionary of arguments to pass to all agents.
            seed: Random seed to launch the model with.
        '''
        self.agent_class = agent_class
        self.agent_count = agent_count
        self.agent_args = agent_args
        super().__init__(self.model_class, agents_per_model=2, seed=seed)
        
        # Instantiate data collector
        self.dc = DataCollector(tables={
                    "Interactions": 
                        ["Step", "A", "B", "Outcome", "SPE", "quality"],
                    "Agents": ["Name", "Assets", "Capability", "Bloc"] })

        for agent in self.agents:
            row = {"Name": agent.name, 
                   "Assets": agent.assets,
                   "Capability": agent.mil_strength,
                   "Bloc": agent.bloc}
            self.dc.add_table_row("Agents", row)

    def make_agents(self):
        '''
        Create self.agent_count agents.
        '''
        self.agents = []
        for i in range(self.agent_count):
            m = random.randrange(1, 100) # Mil strength
            a = random.randrange(1,100) # Assets
            b = random.randrange(2) # Bloc
            agent_args = dict(learning_rate=0.1,
                              discount_factor=0.9,
                              assets=a,
                              mil_strength=m,
                              bloc=b,
                              name=i)
            for arg, val in self.agent_args.items():
                agent_args[arg] = val
            a = self.agent_class(**agent_args)
            self.agents.append(a)

    def step(self):
        '''
        Pair up all agents at random and have them interact.
        '''
        random.shuffle(self.agents)
        for agent in self.agents:
            alters = [a for a in self.agents if a is not agent]
            random.shuffle(alters)
            for alter in alters:
                model = self.model_class([agent, alter])
                model.run()
                self.assess_run(model)
        self.steps += 1

    def assess_run(self, model):
        '''
        Log the model outcome and equilibrium outcome, and compute similarity.
        '''
        spe_model = model.find_equilibrium()
        a, b = model.agents
        q = model.log.tversky_index(spe_model.log)
        row = {"Step": self.steps, "A": a.name, "B": b.name, 
               "Outcome": model.current_node, "SPE": spe_model.current_node,
               "quality": q}
        self.dc.add_table_row("Interactions", row)