def __init__(self, num_agents=7, num_nodes=10, num_steps=1000, server=True): self.server = server self.num_steps = num_steps self.num_agents = num_agents self.num_nodes = num_nodes if num_nodes >= self.num_agents else self.num_agents self.G = nx.erdos_renyi_graph(n=self.num_nodes, p=0.5) self.grid = NetworkGrid(self.G) self.schedule = RandomActivation(self) self.datacollector = DataCollector( model_reporters={"Gini": compute_gini}, agent_reporters={"Wealth": lambda _: _.wealth}) list_of_random_nodes = self.random.sample(self.G.nodes(), self.num_agents) # Create agents for i in range(self.num_agents): a = MoneyAgent(i, self) self.schedule.add(a) # Add the agent to a random node self.grid.place_agent(a, list_of_random_nodes[i]) self.running = True self.datacollector.collect(self)
def __init__(self, **params): super().__init__() config = configparser.ConfigParser() config.read('conf/config.ini') self.sqlite_db = config['SQLITEDB']['file'] self.height = 20 self.width = 20 self.is_init_db = False if params.get( 'write_db') is None else params.get('write_db') self.is_write_db = False if params.get( 'write_db') is None else params.get('write_db') self.max_steps = params['max_steps'] self.initial_saver = params['initial_saver'] self.initial_loan = params['initial_loan'] self.initial_bank = params['initial_bank'] self.rfree = params['rfree'] self.reserve_rates = params[ 'rfree'] / 2.0 # set reserve rates one half of risk free rate self.libor_rate = params['rfree'] self.bankrupt_liquidation = 1 # 1: it is fire sale of assets, 0: bank liquidates loans at face value self.car = params['car'] self.min_reserves_ratio = params['min_reserves_ratio'] self.initial_equity = params['initial_equity'] self.G = nx.empty_graph(self.initial_bank) self.grid = NetworkGrid(self.G) self.schedule = RandomActivation(self) self.datacollector = DataCollector({"BankAsset": get_sum_totasset})
def __init__(self, size, net_type): self.num_agents = size self.num_nodes = self.num_agents self.type = net_type if self.type == 1: self.G, self.avg_degree, self.big_nodes, self.connectivity, self.clustering = netgen_ba( 100, 4) if self.type == 2: self.G, self.avg_degree, self.big_nodes, self.connectivity, self.clustering = netgen_er( 100, .078) if self.type == 3: self.G, self.avg_degree, self.big_nodes, self.connectivity, self.clustering = netgen_rr( 100, 4) self.grid = NetworkGrid(self.G) self.schedule = SimultaneousActivation(self) self.running = True self.step_counter = 1 for i, node in enumerate(self.G.nodes()): a = NormAgent(i, self) self.schedule.add(a) self.grid.place_agent(a, node) self.datacollector = DataCollector( model_reporters={ "PerHate": percent_haters, "AverageSens": average_sensitivity, }, agent_reporters={"Hate": "behavior"})
class COVID_model(Model): def __init__(self): super().__init__(Model) self.susceptible = 0 self.dead = 0 self.recovered = 0 self.infected = 0 interactions = model_params.parameters['interactions'] self.population = model_params.parameters['population'] self.SIR_instance = SIR.Infection( self, ptrans=model_params.parameters['ptrans'], reinfection_rate=model_params.parameters['reinfection_rate'], I0=model_params.parameters["I0"], severe=model_params.parameters["severe"], progression_period=model_params.parameters["progression_period"], progression_sd=model_params.parameters["progression_sd"], death_rate=model_params.parameters["death_rate"], recovery_days=model_params.parameters["recovery_days"], recovery_sd=model_params.parameters["recovery_sd"]) G = SIR.build_network(interactions, self.population) self.grid = NetworkGrid(G) self.schedule = RandomActivation(self) self.dead_agents = [] self.running = True for node in range(self.population): new_agent = agent.human(node, self) #what was self.next_id() self.grid.place_agent(new_agent, node) self.schedule.add(new_agent) #self.meme = 0 self.datacollector = DataCollector( model_reporters={ "infected": lambda m: c_p.compute(m, 'infected'), "recovered": lambda m: c_p.compute(m, 'recovered'), "susceptible": lambda m: c_p.compute(m, "susceptible"), "dead": lambda m: c_p.compute(m, "dead"), "R0": lambda m: c_p.compute(m, "R0"), "severe_cases": lambda m: c_p.compute(m, "severe") }) self.datacollector.collect(self) def step(self): self.schedule.step() self.datacollector.collect(self) ''' for a in self.schedule.agents: if a.alive == False: self.schedule.remove(a) self.dead_agents.append(a.unique_id) ''' if self.dead == self.schedule.get_agent_count(): self.running = False else: self.running = True
def __init__(self, N, limit_time, infected_init, neighbors): self.num_agents = N prob = neighbors / self.num_agents self.G = nx.erdos_renyi_graph(n=self.num_agents, p=prob) self.grid = NetworkGrid(self.G) self.schedule = RandomActivation(self) self.datacollector = DataCollector( { "Infected": number_infected, "Susceptible": number_susceptible, "Resistant": number_resistant, } ) # Create agents for i, node in enumerate(self.G.nodes()): a = PeopleAgent(i,limit_time, self) self.schedule.add(a) # Add the agent to the node self.grid.place_agent(a, node) # Infect some nodes infected_nodes = self.random.sample(self.G.nodes(), infected_init) for a in self.grid.get_cell_list_contents(infected_nodes): a.status = State.ACTIVE self.datacollector.collect(self)
class BoltzmannWealthModelNetwork(Model): """A model with some number of agents.""" def __init__(self, num_agents=7, num_nodes=10): self.num_agents = num_agents self.num_nodes = num_nodes if num_nodes >= self.num_agents else self.num_agents self.G = nx.erdos_renyi_graph(n=self.num_nodes, p=0.5) self.grid = NetworkGrid(self.G) self.schedule = RandomActivation(self) self.datacollector = DataCollector( model_reporters={"Gini": compute_gini}, agent_reporters={"Wealth": lambda _: _.wealth} ) list_of_random_nodes = self.random.sample(self.G.nodes(), self.num_agents) # Create agents for i in range(self.num_agents): a = MoneyAgent(i, self) self.schedule.add(a) # Add the agent to a random node self.grid.place_agent(a, list_of_random_nodes[i]) self.running = True self.datacollector.collect(self) def step(self): self.schedule.step() # collect data self.datacollector.collect(self) def run_model(self, n): for i in range(n): self.step()
def __init__(self, num_nodes, avg_node_degree, initial_outbreak_size, virus_spread_chance, virus_check_frequency, recovery_chance, gain_resistance_chance): self.num_nodes = num_nodes prob = avg_node_degree / self.num_nodes self.G = nx.erdos_renyi_graph(n=self.num_nodes, p=prob) self.grid = NetworkGrid(self.G) self.schedule = RandomActivation(self) self.initial_outbreak_size = initial_outbreak_size if initial_outbreak_size <= num_nodes else num_nodes self.virus_spread_chance = virus_spread_chance self.virus_check_frequency = virus_check_frequency self.recovery_chance = recovery_chance self.gain_resistance_chance = gain_resistance_chance self.running = True self.datacollector = DataCollector({"Infected": number_infected, "Susceptible": number_susceptible, "Resistant": number_resistant}) # Create agents for i, node in enumerate(self.G.nodes()): a = VirusAgent(i, self, State.SUSCEPTIBLE, self.virus_spread_chance, self.virus_check_frequency, self.recovery_chance, self.gain_resistance_chance) self.schedule.add(a) # Add the agent to the node self.grid.place_agent(a, node) # Infect some nodes infected_nodes = random.sample(self.G.nodes(), self.initial_outbreak_size) for a in self.grid.get_cell_list_contents(infected_nodes): a.state = State.INFECTED
def __init__(self, N, initInfected, percInfect, percRecover, intervention): self.running = True self.num_agents = N self.initInfected = initInfected self.percInfect = percInfect self.percRecover = percRecover self.intervention = intervention #self.grid = nx.ErdosRenyiGraph(self.num_agents,) self.G = nx.complete_graph(self.num_agents) self.grid = NetworkGrid(self.G) self.schedule = RandomSingleActivation(self) # create and initialise agents for i, node in enumerate(self.G.nodes): a = DiseaseAgent(i, self) self.schedule.add(a) self.grid.place_agent(a, node) # make some agents initially infected for a in filter( lambda a: a.unique_id in initInfected, self.schedule.agents ): #random.sample(self.schedule.agents, self.initInfected): a.infect() # set up data collection self.datacollector = DataCollector(agent_reporters={ "State": "state", "Event": "event", "Cause": "cause" })
def __init__(self): super().__init__(Model) print("Starting Model") density = model_params.parameters['density'] nodes = model_params.parameters['network_size'] neg_bias = model_params.parameters['neg_bias'] meme_density = model_params.parameters['meme_density'] self.num_agents = nodes self.meme = 0 #G = model_functions.build_network(density, nodes) #nx.write_gpickle(G, "population.gpickle") #END G = nx.read_gpickle("population.gpickle") self.grid = NetworkGrid(G) self.schedule = RandomActivation(self) print("Network Created") self.running = True for node in range(nodes): new_agent = agent.tweeter(self.next_id(), node, self, neg_bias, meme_density) self.grid.place_agent(new_agent, node) self.schedule.add(new_agent) #self.meme = 0 self.datacollector = DataCollector( model_reporters={ "meme_density": model_functions.compute_meme_density }) self.datacollector.collect(self)
def __init__(self): super().__init__(Model) self.susceptible = 0 self.dead = 0 self.recovered = 0 self.infected = 0 interactions = model_params.parameters['interactions'] population = model_params.parameters['population'] self.num_agents = population G = model_functions.build_network(interactions, population) self.grid = NetworkGrid(G) self.schedule = RandomActivation(self) self.running = True for node in range(population): new_agent = agent.human(self.next_id(), node, self) self.grid.place_agent(new_agent, node) self.schedule.add(new_agent) #self.meme = 0 self.datacollector = DataCollector(model_reporters={"infected": model_functions.compute_infected, "recovered": model_functions.compute_recovered, "susceptible": model_functions.compute_susceptible, "dead": model_functions.compute_dead, "R0": model_functions.compute_R0, "severe_cases":model_functions.compute_severe}) self.datacollector.collect(self)
def __init__(self, size, set_no): self.num_agents = size self.num_nodes = self.num_agents self.set = set_no self.I = networks_for_use[self.set][0] self.net_deg = networks_for_use[self.set][ 1] # 1st parameter - average node degree self.big_nodes = networks_for_use[self.set][ 2] # 2nd parameter - huge networks allowed? self.culling = networks_for_use[self.set][ 3] # 3rd parameter - maximum node degree allowed. only use if # big_nodes = True! self.grid = NetworkGrid(self.I) self.schedule = SimultaneousActivation(self) self.running = True for i, node in enumerate(self.I.nodes()): a = NormAgent(i, self) self.schedule.add(a) self.grid.place_agent(a, node) self.datacollector = DataCollector( model_reporters={ "PerHate": percent_haters, "AveKnowing": percent_hate_knowing, "AveHate": average_hate, "MeanDeg": net_avg_deg, "Culling": net_culling, "MaxDeg": max_deg, }, agent_reporters={"Hate": "behavior"})
def __init__( self, num_counties, preferences, network_type, \ climate_threshold, limited_radius=True, init_time=0): super().__init__() global TICK TICK = init_time self.num_agents = 0 self.agent_index = 0 self.preferences = preferences self.limited_radius = limited_radius self.upper_network_size = 3 self.network_type = network_type self.climate_threshold = climate_threshold self.schedule = SimultaneousActivation(self) self.G = create_graph() self.num_counties = num_counties self.nodes = self.G.nodes() self.grid = NetworkGrid(self.G) self.county_climate_ranking = [] self.county_population_list = [0] * self.num_counties self.county_flux = [0] * self.num_counties self.deaths = [] self.births = [] self.county_income = {} self.datacollector = DataCollector(model_reporters={"County Population": lambda m1: list(m1.county_population_list), "County Influx": lambda m2: list(m2.county_flux), "Deaths": lambda m3: m3.deaths, "Births": lambda m4: m4.births, "Total Population": lambda m5: m5.num_agents})
class propagation_model(Model): def __init__(self): super().__init__(Model) density = model_params.parameters['density'] nodes = model_params.parameters['network_size'] neg_bias = model_params.parameters['neg_bias'] meme_density = model_params.parameters['meme_density'] self.num_agents = nodes self.meme = 0 G = model_functions.build_network(density, nodes) self.grid = NetworkGrid(G) self.schedule = RandomActivation(self) self.running = True for node in range(nodes): new_agent = agent.tweeter(self.next_id(), node, self, neg_bias, meme_density) self.grid.place_agent(new_agent, node) self.schedule.add(new_agent) #self.meme = 0 self.datacollector = DataCollector(model_reporters={"meme_density": model_functions.compute_meme_density}) self.datacollector.collect(self) def step(self): self.schedule.step() self.datacollector.collect(self) if self.meme == self.schedule.get_agent_count(): self.running = False
def __init__(self, num_nodes=1000, avg_node_degree=3, initial_outbreak_size=10, race="black"): self.num_nodes = num_nodes self.race = race self.months = 0 prob = avg_node_degree / self.num_nodes self.G = nx.erdos_renyi_graph(n=self.num_nodes, p=prob) self.sentence = generate_sentence(race) self.grid = NetworkGrid(self.G) self.schedule = RandomActivation(self) self.initial_outbreak_size = initial_outbreak_size if initial_outbreak_size <= num_nodes else num_nodes self.datacollector = DataCollector({ "Incarcerated": number_incarcerated, "Susceptible": number_susceptible, "Released": number_released }) for i, node in enumerate(self.G.nodes()): a = Person(i, self, State.SUSCEPTIBLE, self.sentence) self.schedule.add(a) self.grid.place_agent(a, node) # Begin with some portion of the population in prison infected_nodes = self.random.sample(self.G.nodes(), self.initial_outbreak_size) for a in self.grid.get_cell_list_contents(infected_nodes): a.state = State.INCARCERATED self.running = True self.datacollector.collect(self)
class BoltzmannWealthModelNetwork(Model): """A model with some number of agents.""" def __init__(self, num_agents=7, num_nodes=10): self.num_agents = num_agents self.num_nodes = num_nodes if num_nodes >= self.num_agents else self.num_agents self.G = nx.erdos_renyi_graph(n=self.num_nodes, p=0.5) self.grid = NetworkGrid(self.G) self.schedule = RandomActivation(self) self.datacollector = DataCollector( model_reporters={"Gini": compute_gini}, agent_reporters={"Wealth": lambda _: _.wealth} ) list_of_random_nodes = random.sample(self.G.nodes(), self.num_agents) # Create agents for i in range(self.num_agents): a = MoneyAgent(i, self) self.schedule.add(a) # Add the agent to a random node self.grid.place_agent(a, list_of_random_nodes[i]) self.running = True self.datacollector.collect(self) def step(self): self.schedule.step() # collect data self.datacollector.collect(self) def run_model(self, n): for i in range(n): self.step()
def __init__(self, N, avg_node_degree, rule='CMR', zero_prob=0.5): self.num_agents = N self.rule = rule self.schedule = RandomActivation(self) prob = avg_node_degree / self.num_agents self.G = nx.erdos_renyi_graph(n=self.num_agents, p=prob) self.grid = NetworkGrid(self.G) #create the agents for i, node in enumerate(self.G.nodes()): a = OpinionAgent( i, self, initial_opinion=self.random.choices( [0, 1], weights=[zero_prob, 1 - zero_prob], k=1)[0]) #we can seed w/a non-equal probability self.schedule.add(a) self.grid.place_agent(a, node) self.datacollector = DataCollector(model_reporters={ 'opinion_0': opinion_0_ct, 'opinion_1': opinion_1_ct }) self.running = True #we could check to see if we've reached a steady state self.datacollector.collect(self)
def __init__(self, population_size, initial_outbreak_size, spread_chance): print("Beginning model setup...\n") self.population_size = population_size print("Creating graph...") self.graph = nx.powerlaw_cluster_graph(population_size, 100, 0.5) #self.graph = nx.complete_graph(population_size) print(len(self.graph.edges)) print("Initializing grid...") self.grid = NetworkGrid(self.graph) self.schedule = SimultaneousActivation(self) self.initial_outbreak_size = initial_outbreak_size self.spread_chance = spread_chance print("Initializing data collector...") self.datacollector = DataCollector({ "Infected:": count_infected, "Susceptible:": count_susceptible, "Removed:": count_removed }) for i, node in enumerate(self.graph.nodes()): a = Person(i, self, State.SUSCEPTIBLE, spread_chance) self.schedule.add(a) self.grid.place_agent(a, i) if i % 100 == 0: print("Finished with agent ", i) infected_nodes = self.random.sample(self.graph.nodes(), self.initial_outbreak_size) for a in self.grid.get_cell_list_contents(infected_nodes): a.status = State.INFECTED self.datacollector.collect(self) print("Model initialized...\n")
def __init__(self, graph, model_parameters): # Model initialization self.population_size = model_parameters['population_size'] self.initial_outbreak_size = model_parameters['initial_outbreak_size'] self.graph = graph self.grid = NetworkGrid(self.graph) self.schedule = SimultaneousActivation(self) self.datacollector = DataCollector({ "Exposed": count_exposed, "Susceptible": count_susceptible, "Removed": count_removed, "Asymptomatic": count_asymptomatic, "Symptomatic": count_symptomatic }) self.model_parameters = model_parameters for i, node in enumerate(self.graph.nodes()): a = Person(i, self, State.SUSCEPTIBLE, model_parameters) self.schedule.add(a) self.grid.place_agent(a, i) if i % 100 == 0: logger.info("Finished with agent " + str(i)) infected_nodes = self.random.sample(self.graph.nodes(), self.initial_outbreak_size) for a in self.grid.get_cell_list_contents(infected_nodes): a.status = State.EXPOSED self.datacollector.collect(self) print("Model initialized...\n", str(self.model_parameters))
class NormModel(Model): def __init__(self, size): self.num_agents = size self.num_nodes = self.num_agents # self.G = the_network[0] self.G = another_network self.grid = NetworkGrid(self.G) self.schedule = SimultaneousActivation(self) self.running = True for i, node in enumerate(self.G.nodes()): a = NormAgent(i, self) self.schedule.add(a) self.grid.place_agent(a, node) self.datacollector = DataCollector( model_reporters={ "PerHate": percent_haters, "AverageSens": average_sensitivity, }, agent_reporters={"Hate": "behavior"}) def step(self): self.datacollector.collect(self) self.schedule.step() if percent_haters( self ) > 0.8: # When the percentage of haters in the model exceeds 80, self.running = False # the simulation is stopped, data collected, and next one is started.
def __init__(self, num_nodes=10, avg_node_degree=3, rewire_prob=.1, initial_outbreak_size=1, threshold_fake = 2, threshold_real = -2): self.num_nodes = num_nodes self.G = nx.watts_strogatz_graph(n=self.num_nodes, k= avg_node_degree, p=rewire_prob) #G generate graph structure self.grid = NetworkGrid(self.G) #grid is the Masa native defintion of space: a coorindate with specified topology on which agents sits and interact self.schedule = SimultaneousActivation(self) self.initial_outbreak_size = ( initial_outbreak_size if initial_outbreak_size <= num_nodes else num_nodes ) self.datacollector = DataCollector( { "Infected_fake": number_infected_fake, "Infected_real": number_infected_real, } ) # Create agents for i, node in enumerate(self.G.nodes()): a = User( i, self, 0, #make the state a int threshold_fake, threshold_real ) self.schedule.add(a) # Add the agent to the node self.grid.place_agent(a, node) # Infect some nodes, initial infection bug free infected_nodes_fake = self.random.sample(self.G.nodes(), self.initial_outbreak_size) infected_nodes_real = self.random.sample(self.G.nodes(), self.initial_outbreak_size) for a in self.grid.get_cell_list_contents(infected_nodes_fake): a.state = 1 neighbors_nodes = self.grid.get_neighbors(a.pos) for n in self.grid.get_cell_list_contents(neighbors_nodes): n.state = 1 for a in self.grid.get_cell_list_contents(infected_nodes_real): a.state = -1 neighbors_nodes = self.grid.get_neighbors(a.pos) for n in self.grid.get_cell_list_contents(neighbors_nodes): n.state = -1 """ state measures fake score!! the more negative the less likely to spread fake news also this model assumes that 1 one piece of real news can cancel out one piece of fake news This model can be modulated by changing the value of fake and real 2 the inital braeakout size of fake and real news are the same This can be chaged by introducing a different initial breaksize for real and fake news however this score is kepet the same intentionally because too uch complexity is not good for modeling """ self.running = True self.datacollector.collect(self)
class WasteNet(Model): """Waste collection network model""" def __init__(self, mode, nb_nodes=10, nb_episodes=1): # Network self.G = generate_graph(nb_nodes) self.grid = NetworkGrid(self.G) # Gym Environment env_config = dict(graph=self.G) self.env = WasteNetEnv(env_config) # RL Agent if mode == WasteNetMode.PPO.name: rl_agent = PPOAgent("WasteNet", WasteNetEnv, env_config, best_config) rl_agent.load("./checkpoints/checkpoint-best") else: rl_agent = None # Scheduler self.schedule = WasteNetActivation(self, mode, rl_agent) # Data Collector self.datacollector = DataCollector( model_reporters={ "Empty": nb_empty, "Medium": nb_medium, "Full": nb_full, "Overflow": nb_overflow, }, agent_reporters={ "Fill level (%)": fill_level, "": lambda a: 100 }, ) # Mesa Agents for i, node in enumerate(self.G.nodes()): if i in (0, self.G.number_of_nodes() - 1): a = BaseAgent(i, self) else: a = DumpsterAgent(i, self, self.env.fill_levels[i - 1]) self.schedule.add(a) self.grid.place_agent(a, node) self.remaining_episodes = nb_episodes self.running = True self.datacollector.collect(self) def step(self): done = self.schedule.step() self.datacollector.collect(self) if done: self.env.reset() self.remaining_episodes -= 1 if self.remaining_episodes == 0: self.running = False
class VirusModel(Model): """A virus model with some number of agents""" def __init__(self, num_nodes, avg_node_degree, initial_outbreak_size, virus_spread_chance, virus_check_frequency, recovery_chance, gain_resistance_chance): self.num_nodes = num_nodes prob = avg_node_degree / self.num_nodes self.G = nx.erdos_renyi_graph(n=self.num_nodes, p=prob) self.grid = NetworkGrid(self.G) self.schedule = RandomActivation(self) self.initial_outbreak_size = initial_outbreak_size if initial_outbreak_size <= num_nodes else num_nodes self.virus_spread_chance = virus_spread_chance self.virus_check_frequency = virus_check_frequency self.recovery_chance = recovery_chance self.gain_resistance_chance = gain_resistance_chance self.datacollector = DataCollector({ "Infected": number_infected, "Susceptible": number_susceptible, "Resistant": number_resistant }) # Create agents for i, node in enumerate(self.G.nodes()): a = VirusAgent(i, self, State.SUSCEPTIBLE, self.virus_spread_chance, self.virus_check_frequency, self.recovery_chance, self.gain_resistance_chance) self.schedule.add(a) # Add the agent to the node self.grid.place_agent(a, node) # Infect some nodes infected_nodes = random.sample(self.G.nodes(), self.initial_outbreak_size) for a in self.grid.get_cell_list_contents(infected_nodes): a.state = State.INFECTED self.running = True self.datacollector.collect(self) def resistant_susceptible_ratio(self): try: return number_state(self, State.RESISTANT) / number_state( self, State.SUSCEPTIBLE) except ZeroDivisionError: return math.inf def step(self): self.schedule.step() # collect data self.datacollector.collect(self) def run_model(self, n): for i in range(n): self.step()
class VirusModel(Model): """A virus model with some number of agents""" def __init__(self, num_nodes, avg_node_degree, initial_outbreak_size, alpha, beta, gamma, k, n): self.num_nodes = num_nodes self.avg_node_degree = avg_node_degree self.G = nx.barabasi_albert_graph(n=self.num_nodes, m=avg_node_degree) # _graph(n=self.num_nodes, p=prob) self.grid = NetworkGrid(self.G) self.schedule = RandomActivation(self) self.initial_outbreak_size = initial_outbreak_size if initial_outbreak_size <= num_nodes else num_nodes self.alpha = alpha self.beta = beta self.gamma = gamma self.k = k self.n = n self.datacollector = DataCollector({ "Infected": number_active, "Susceptible": number_susceptible, "Carrier": number_inactive, "Removed": number_removed }) # Create agents for i, node in enumerate(self.G.nodes()): a = VirusAgent(i, self, State.SUSCEPTIBLE, self.alpha, self.beta, self.gamma, self.k, self.n) self.schedule.add(a) # Add the agent to the node self.grid.place_agent(a, node) # Infect some nodes active_nodes = random.sample(self.G.nodes(), self.initial_outbreak_size) for a in self.grid.get_cell_list_contents(active_nodes): a.state = State.ACTIVE self.running = True self.datacollector.collect(self) def removed_susceptible_ratio(self): try: return number_state(self, State.REMOVED) / number_state( self, State.SUSCEPTIBLE) except ZeroDivisionError: return math.inf def step(self): self.schedule.step() # collect data self.datacollector.collect(self) def run_model(self, n): for i in range(n): self.step()
class VirusModel(Model): def __init__(self, num_nodes, avg_node_degree, initial_outbreak_size, alpha, beta): self.num_nodes = num_nodes prob = avg_node_degree / self.num_nodes self.initial_outbreak_size = initial_outbreak_size if initial_outbreak_size <= num_nodes else num_nodes self.alpha = alpha self.beta = beta self.G = nx.barabasi_albert_graph(n=self.num_nodes, m=3) # self.G = nx.erdos_renyi_graph(n=self.num_nodes, p=prob) self.grid = NetworkGrid(self.G) self.schedule = RandomActivation(self) self.datacollector = DataCollector({ "Susceptible": number_susceptible, "Infected": number_infected, "Removed": number_removed }) # Create agents for i, node in enumerate(self.G.nodes()): a = VirusAgent( i, self, State.SUSCEPTIBLE, self.alpha, self.beta, ) self.schedule.add(a) self.grid.place_agent(a, node) # Infect some nodes infected_nodes = random.sample(self.G.nodes(), self.initial_outbreak_size) for a in self.grid.get_cell_list_contents(infected_nodes): a.state = State.INFECTED self.running = True self.datacollector.collect(self) def removed_susceptible_ratio(self): try: return number_state(self, State.REMOVED) / number_state( self, State.SUSCEPTIBLE) except ZeroDivisionError: return math.inf def step(self): self.schedule.step() self.datacollector.collect(self) def run_model(self, n): for i in range(n): self.step()
def __init__(self, N=10, pcontact=0.4, ptrans=0.5, avg_node_degree=3, progression_period=3, progression_sd=2, recovery_rate=0.0193, recovery_days=1/0.0193, recovery_sd=7, incubation_time = 6 , incubation_time_sd = 2, rate_infected = 1/6): #My shit here: self.num_nodes = N self.pcontact=pcontact n = 100 self.A_prob = np.random.rand(N,N) self.A = (self.A_prob<pcontact).astype('int') #----------------------------# # Myshit # #----------------------------# #self.num_nodes = N #self.pcontact=pcontact """All parameters""" prob = avg_node_degree / self.num_nodes self.initial_outbreak_size = 1 self.incubation_time = incubation_time self.incubation_time_sd = incubation_time_sd self.rate_infected = rate_infected self.recovery_sd = recovery_sd self.ptrans = ptrans self.recovery_rate = recovery_rate self.recovery_days = recovery_days self.G = nx.Graph(self.A) self.grid = NetworkGrid(self.G) self.schedule = RandomActivation(self) #activate the step of Agents in random orders self.running = True #self.dead_agents = [] """2 types of agents: intra-agent and out-agent""" # Create out_agents: # Create intra-agents for i, node in enumerate(self.G.nodes()): a = CovidAgent(i+1, self) self.G.add_node(a) #add agent self.grid.place_agent(a, node) self.A_prob = np.random.rand(N+i,N+i) self.A = (self.A_prob<pcontact).astype('int') #make some agents infected at start infected = np.random.choice([0,1], p=[0.99,0.01]) if infected == 1: a.state = State.INFECTED a.recovery_time = self.get_recovery_time() self.datacollector = DataCollector( agent_reporters={"State": 'state'})
def __init__(self, agents=agents, dt=0.1, attention_delta=0.1, persuasion=1, a_min=-0.5, r_min=0.05, sd_opinion=0.15, sd_info=0.005, network_params=None): super().__init__() self.dt = dt self.attention_delta = attention_delta self.persuasion = persuasion self.a_min = a_min self.r_min = r_min self.sd_opinion = sd_opinion self.sd_info = sd_info # initialize a scheduler self.schedule = BaseScheduler(self) # create the population self.population = 0 if network_params is None: network_params = {"method": "er", "p": 0.1} self.init_population(agents, network_params) # self.G = nx.Graph() # generates network topology # not used right now, but can be used for mesa visualization self.grid = NetworkGrid(self.G) # create agents self.create_agents(agents) # agent who will interact this turn self.active_agent = None # add datacollector # collects opinion, information and attention each step self.data_collector = DataCollector({ "Opinion": lambda m: self.collect_opinions(), "Attention": lambda m: self.collect_attentions(), "Information": lambda m: self.collect_informations() }) # this is required for the data_collector to work self.running = True self.data_collector.collect(self)
class Population(Model): """Population Adapted from https://www.medrxiv.org/content/10.1101/2020.03.18.20037994v1.full.pdf Model Parameters: spread_chance: probability of infection based on contact gamma: mean incubation period alpha: probability of become asymptomatic vs symptomatic gamma_AR: infectious period for asymptomatic people gamma_YR: infectious period for symptomatic people delta: death rate due to disease """ def __init__(self, graph, model_parameters): # Model initialization self.population_size = model_parameters['population_size'] self.initial_outbreak_size = model_parameters['initial_outbreak_size'] self.graph = graph self.grid = NetworkGrid(self.graph) self.schedule = SimultaneousActivation(self) self.datacollector = DataCollector({ "Exposed": count_exposed, "Susceptible": count_susceptible, "Removed": count_removed, "Asymptomatic": count_asymptomatic, "Symptomatic": count_symptomatic }) self.model_parameters = model_parameters for i, node in enumerate(self.graph.nodes()): a = Person(i, self, State.SUSCEPTIBLE, model_parameters) self.schedule.add(a) self.grid.place_agent(a, i) if i % 100 == 0: logger.info("Finished with agent " + str(i)) infected_nodes = self.random.sample(self.graph.nodes(), self.initial_outbreak_size) for a in self.grid.get_cell_list_contents(infected_nodes): a.status = State.EXPOSED self.datacollector.collect(self) print("Model initialized...\n", str(self.model_parameters)) def step(self): self.datacollector.collect(self) self.schedule.step() def run(self, n): for i in range(n): #logger.info("Steps Completed: " + str(i)) #print("Steps completed: ", i) self.step()
def __init__(self, nodes, initial_RefinedKitten = 100, initial_ImperialKitten = 100, initial_CharmingKitten = 100, initial_HelixKitten = 100, initial_StaticKitten = 100, initial_RemixKitten = 100): super().__init__() self.initial_RefinedKitten = initial_RefinedKitten self.initial_ImperialKitten = initial_ImperialKitten self.initial_CharmingKitten = initial_CharmingKitten self.initial_HelixKitten = initial_HelixKitten self.initial_StaticKitten = initial_StaticKitten self.initial_RemixKitten = initial_RemixKitten self.grid = NetworkGrid(G) self.schedule = RandomActivationByOrg(self) for i in range(self.initial_RefinedKitten): refinedkitten = RefinedKitten(self.next_id(), 'RFK', self) self.grid.place_agent(refinedkitten, 'RFK') self.schedule.add(refinedkitten) for i in range(self.initial_ImperialKitten): imperialkitten = ImperialKitten(self.next_id(), 'IK', self) self.grid.place_agent(imperialkitten, 'IK') self.schedule.add(imperialkitten) for i in range(self.initial_CharmingKitten): charmingkitten = CharmingKitten(self.next_id(), 'CK', self) self.grid.place_agent(charmingkitten, 'CK') self.schedule.add(charmingkitten) for i in range(self.initial_HelixKitten): helixkitten = HelixKitten(self.next_id(), 'HK', self) self.grid.place_agent(helixkitten, 'HK') self.schedule.add(helixkitten) for i in range(self.initial_StaticKitten): statickitten = StaticKitten(self.next_id(), 'SK', self) self.grid.place_agent(statickitten, 'SK') self.schedule.add(statickitten) for i in range(self.initial_RemixKitten): remixkitten = RemixKitten(self.next_id(), 'RMK', self) self.grid.place_agent(remixkitten, 'RMK') self.schedule.add(remixkitten) self.running = True self.datacollector = DataCollector( agent_reporters = {"Organization": "org", "Spear Phishing": "phish", "Zero Day": "zeroday", "Tool Sophistication": "tools", "Attribution Obfuscation": "attrib", "Stealth": "stealth", "Information Weaponization": "iwo","DDoS": "ddos", "Data Destruction": "destruct", "Critical Infrastructure Disruption": "infra"})
def setUp(self): ''' Create a test network grid and populate with Mock Agents. ''' G = nx.complete_graph(TestMultipleNetworkGrid.GRAPH_SIZE) self.space = NetworkGrid(G) self.agents = [] for i, pos in enumerate(TEST_AGENTS_NETWORK_MULTIPLE): a = MockAgent(i, None) self.agents.append(a) self.space.place_agent(a, pos)
def __init__( self, num_nodes=1740, avg_node_degree=3, initial_with_clean=174, change_clean_chance=0.03, check_frequency=1.0, switch_back_chance=0.02, gain_resistance_chance=0.0, ): self.num_nodes = num_nodes prob = avg_node_degree / self.num_nodes self.G = nx.erdos_renyi_graph(n=self.num_nodes, p=prob) self.grid = NetworkGrid(self.G) self.schedule = RandomActivation(self) self.initial_with_clean = ( initial_with_clean if initial_with_clean <= num_nodes else num_nodes ) self.change_clean_chance = change_clean_chance self.check_frequency = check_frequency self.switch_back_chance = switch_back_chance self.gain_resistance_chance = gain_resistance_chance self.datacollector = DataCollector( { "has_clean": number_has_clean, "not_clean": number_not_clean, "refuses_clean": number_refuses_clean, } ) # Create agents for i, node in enumerate(self.G.nodes()): a = VirusAgent( i, self, State.not_clean, self.change_clean_chance, self.check_frequency, self.switch_back_chance, self.gain_resistance_chance, ) self.schedule.add(a) # Add the agent to the node self.grid.place_agent(a, node) # Infect some nodes has_clean_nodes = self.random.sample(self.G.nodes(), self.initial_with_clean) for a in self.grid.get_cell_list_contents(has_clean_nodes): a.state = State.has_clean self.running = True self.datacollector.collect(self)
class PopuNetwork(Model): """ The population network which initializes: - the number of agents - the number of incarcerated agents at start - the race of the simulated community - the average number of relationships per individual """ def __init__(self, num_nodes=1000, avg_node_degree=3, initial_outbreak_size=10, race="black"): self.num_nodes = num_nodes self.race = race self.months = 0 prob = avg_node_degree / self.num_nodes self.G = nx.erdos_renyi_graph(n=self.num_nodes, p=prob) self.sentence = generate_sentence(race) self.grid = NetworkGrid(self.G) self.schedule = RandomActivation(self) self.initial_outbreak_size = initial_outbreak_size if initial_outbreak_size <= num_nodes else num_nodes self.datacollector = DataCollector({ "Incarcerated": number_incarcerated, "Susceptible": number_susceptible, "Released": number_released }) for i, node in enumerate(self.G.nodes()): a = Person(i, self, State.SUSCEPTIBLE, self.sentence) self.schedule.add(a) self.grid.place_agent(a, node) # Begin with some portion of the population in prison infected_nodes = self.random.sample(self.G.nodes(), self.initial_outbreak_size) for a in self.grid.get_cell_list_contents(infected_nodes): a.state = State.INCARCERATED self.running = True self.datacollector.collect(self) def step(self): self.schedule.step() self.months += 1 # collect data self.datacollector.collect(self) def run_model(self, n): for i in range(n): self.step()
class VirusOnNetwork(Model): """A virus model with some number of agents""" def __init__(self, num_nodes=10, avg_node_degree=3, initial_outbreak_size=1, virus_spread_chance=0.4, virus_check_frequency=0.4, recovery_chance=0.3, gain_resistance_chance=0.5): self.num_nodes = num_nodes prob = avg_node_degree / self.num_nodes self.G = nx.erdos_renyi_graph(n=self.num_nodes, p=prob) self.grid = NetworkGrid(self.G) self.schedule = RandomActivation(self) self.initial_outbreak_size = initial_outbreak_size if initial_outbreak_size <= num_nodes else num_nodes self.virus_spread_chance = virus_spread_chance self.virus_check_frequency = virus_check_frequency self.recovery_chance = recovery_chance self.gain_resistance_chance = gain_resistance_chance self.datacollector = DataCollector({"Infected": number_infected, "Susceptible": number_susceptible, "Resistant": number_resistant}) # Create agents for i, node in enumerate(self.G.nodes()): a = VirusAgent(i, self, State.SUSCEPTIBLE, self.virus_spread_chance, self.virus_check_frequency, self.recovery_chance, self.gain_resistance_chance) self.schedule.add(a) # Add the agent to the node self.grid.place_agent(a, node) # Infect some nodes infected_nodes = self.random.sample(self.G.nodes(), self.initial_outbreak_size) for a in self.grid.get_cell_list_contents(infected_nodes): a.state = State.INFECTED self.running = True self.datacollector.collect(self) def resistant_susceptible_ratio(self): try: return number_state(self, State.RESISTANT) / number_state(self, State.SUSCEPTIBLE) except ZeroDivisionError: return math.inf def step(self): self.schedule.step() # collect data self.datacollector.collect(self) def run_model(self, n): for i in range(n): self.step()
def __init__(self, num_nodes=10, avg_node_degree=3, initial_outbreak_size=1, virus_spread_chance=0.4, virus_check_frequency=0.4, recovery_chance=0.3, gain_resistance_chance=0.5): self.num_nodes = num_nodes prob = avg_node_degree / self.num_nodes self.G = nx.erdos_renyi_graph(n=self.num_nodes, p=prob) self.grid = NetworkGrid(self.G) self.schedule = RandomActivation(self) self.initial_outbreak_size = initial_outbreak_size if initial_outbreak_size <= num_nodes else num_nodes self.virus_spread_chance = virus_spread_chance self.virus_check_frequency = virus_check_frequency self.recovery_chance = recovery_chance self.gain_resistance_chance = gain_resistance_chance self.datacollector = DataCollector({"Infected": number_infected, "Susceptible": number_susceptible, "Resistant": number_resistant}) # Create agents for i, node in enumerate(self.G.nodes()): a = VirusAgent(i, self, State.SUSCEPTIBLE, self.virus_spread_chance, self.virus_check_frequency, self.recovery_chance, self.gain_resistance_chance) self.schedule.add(a) # Add the agent to the node self.grid.place_agent(a, node) # Infect some nodes infected_nodes = self.random.sample(self.G.nodes(), self.initial_outbreak_size) for a in self.grid.get_cell_list_contents(infected_nodes): a.state = State.INFECTED self.running = True self.datacollector.collect(self)
def setUp(self): ''' Create a test network grid and populate with Mock Agents. ''' G = nx.complete_graph(TestMultipleNetworkGrid.GRAPH_SIZE) self.space = NetworkGrid(G) self.agents = [] for i, pos in enumerate(TEST_AGENTS_NETWORK_MULTIPLE): a = MockAgent(i, None) self.agents.append(a) self.space.place_agent(a, pos)
class TestMultipleNetworkGrid(unittest.TestCase): GRAPH_SIZE = 3 def setUp(self): ''' Create a test network grid and populate with Mock Agents. ''' G = nx.complete_graph(TestMultipleNetworkGrid.GRAPH_SIZE) self.space = NetworkGrid(G) self.agents = [] for i, pos in enumerate(TEST_AGENTS_NETWORK_MULTIPLE): a = MockAgent(i, None) self.agents.append(a) self.space.place_agent(a, pos) def test_agent_positions(self): ''' Ensure that the agents are all placed properly. ''' for i, pos in enumerate(TEST_AGENTS_NETWORK_MULTIPLE): a = self.agents[i] assert a.pos == pos def test_get_neighbors(self): assert len(self.space.get_neighbors(0, include_center=True)) == TestMultipleNetworkGrid.GRAPH_SIZE assert len(self.space.get_neighbors(0, include_center=False)) == TestMultipleNetworkGrid.GRAPH_SIZE - 1 def test_move_agent(self): initial_pos = 1 agent_number = 1 final_pos = 0 _agent = self.agents[agent_number] assert _agent.pos == initial_pos assert _agent in self.space.G.node[initial_pos]['agent'] assert _agent not in self.space.G.node[final_pos]['agent'] assert len(self.space.G.node[initial_pos]['agent']) == 2 assert len(self.space.G.node[final_pos]['agent']) == 1 self.space.move_agent(_agent, final_pos) assert _agent.pos == final_pos assert _agent not in self.space.G.node[initial_pos]['agent'] assert _agent in self.space.G.node[final_pos]['agent'] assert len(self.space.G.node[initial_pos]['agent']) == 1 assert len(self.space.G.node[final_pos]['agent']) == 2 def test_is_cell_empty(self): assert not self.space.is_cell_empty(0) assert not self.space.is_cell_empty(1) assert self.space.is_cell_empty(2) def test_get_cell_list_contents(self): assert self.space.get_cell_list_contents([0]) == [self.agents[0]] assert self.space.get_cell_list_contents([1]) == [self.agents[1], self.agents[2]] assert self.space.get_cell_list_contents(list(range(TestMultipleNetworkGrid.GRAPH_SIZE))) == [self.agents[0], self.agents[1], self.agents[2]] def test_get_all_cell_contents(self): assert self.space.get_all_cell_contents() == [self.agents[0], self.agents[1], self.agents[2]]