def main(force_name, start_year, start_month, end_year, end_month): # construct and run the model microsim = model.CrimeMicrosim(force_name, (start_year, start_month), (end_year, end_month)) no.run(microsim) plt = visualisation.density_map(microsim.crimes, force_name) plt.show()
def test_linear_timeline() -> None: # 40 years annual steps m = _TestModel2(2011, 2051, 40) assert m.timeline.time() == 2011 assert m.timeline.dt() == 1.0 assert m.timeline.index() == 0 assert m.timeline.end() == 2051 no.run(m) assert m.timeline.index() == 40 assert m.timeline.time() == 2051
def test_resume() -> None: t0 = 0.1 n = 10 m = _TestResume(t0, n) # unit timesteps t = t0 while not m.timeline.at_end(): no.run(m) t += 1 assert m.timeline.time() == t assert m.timeline.time() == t0 + n
def get_crimes(loading): global model no.log("Setting loading factor to %f" % loading) no.log("Sampling crimes in %s for month beginning %s" % (model.force_area(), model.timeline().time())) model.set_loading(loading) no.run(model) buf = StringIO() model.crimes.to_csv(buf) return buf.getvalue()
def test_null_timeline() -> None: t0 = no.NoTimeline() assert t0.nsteps() == 1 assert t0.dt() == 0.0 assert not t0.at_end() assert t0.index() == 0 assert no.time.isnever(t0.time()) assert no.time.isnever(t0.end()) m = _TestModel2(0, 1, 1) no.run(m) assert m.timeline.at_end() assert m.timeline.index() == 1 assert m.timeline.time() == 1.0
def test_halt_finalise() -> None: class HCModel(no.Model): def __init__(self, timeline: no.Timeline, halt: bool = False) -> None: super().__init__(timeline, no.MonteCarlo.deterministic_identical_stream) self.do_halt = halt self.finalise_called = False def step(self) -> None: if self.do_halt: self.halt() def finalise(self) -> None: self.finalise_called = True m = HCModel(no.LinearTimeline(0, 3, 3)) no.run(m) assert m.finalise_called m = HCModel(no.LinearTimeline(0, 3, 3), True) no.run(m) assert not m.finalise_called assert not m.timeline.at_end() assert m.timeline.index() == 1 no.run(m) assert not m.finalise_called assert not m.timeline.at_end() assert m.timeline.index() == 2 no.run(m) assert m.finalise_called assert m.timeline.at_end() assert m.timeline.index() == 3
def main(force_name, start_year, start_month, end_year, end_month): from crims import model #from crims import geography #from crims import utils from crims import visualisation # construct and run the model microsim = model.CrimeMicrosim(force_name, (start_year, start_month), (end_year, end_month)) no.run(microsim) plt = visualisation.density_map(microsim.crimes, force_name) plt.show()
def pop_crimes(): global model, time, timestep # TODO this is inefficient if time >= model.crimes.time.max(): no.log("Sampling crimes in %s for month beginning %s" % (model.force_area(), model.timeline().time())) no.run(model) end = time + timestep buf = StringIO() model.crimes[(model.crimes.time >= time) & (model.crimes.time < end)].to_csv(buf) time = end return buf.getvalue()
def get_crimes(start, end): global model, timestep ts = datetime.strptime(start, TIME_FORMAT) te = datetime.strptime(end, TIME_FORMAT) # NB model time is the start of the *next* (as yet unsampled) timestep if ts >= model.timeline().time(): no.log("%s Sampling crimes in %s for month beginning %s..." % (datetime.now(), model.force_area(), model.timeline().time())) no.run(model) no.log("%s sampling complete" % datetime.now()) #no.log("%s -> %s: %d" % (ts, te, len(model.crimes[(model.crimes.time >= ts) & (model.crimes.time < te)]))) buf = StringIO() model.crimes[(model.crimes.time >= ts) & (model.crimes.time < te)].to_csv(buf) return buf.getvalue()
def test_check_flag() -> None: class FailingModel(no.Model): def __init__(self) -> None: super().__init__(no.NoTimeline(), no.MonteCarlo.deterministic_identical_stream) def step(self) -> None: pass def check(self) -> bool: return False # fails assert not no.run(FailingModel()) no.checked(False) # succeeds assert no.run(FailingModel())
def test_numeric_timeline() -> None: class NumericTimelineModel(no.Model): def __init__(self, numerictimeline: no.Timeline) -> None: super().__init__(numerictimeline, no.MonteCarlo.deterministic_identical_stream) def step(self) -> None: assert self.timeline.dt() == 1 / 16 assert self.timeline.time() == self.timeline.index() / 16 def finalise(self) -> None: assert self.timeline.time() == 1.0 assert self.timeline.time() == self.timeline.end() assert self.timeline.index() == 16 # 16 steps to avoid rounding errors m = NumericTimelineModel(no.NumericTimeline(np.linspace(0.0, 1.0, 17))) assert m.timeline.time() == 0.0 assert m.timeline.index() == 0 no.run(m)
def test_open_ended_timeline() -> None: class OpenEndedModel(no.Model): def __init__(self, timeline: no.Timeline) -> None: super().__init__(timeline, no.MonteCarlo.deterministic_identical_stream) self.i = 0 def step(self) -> None: assert self.i == self.timeline.index() self.i += 1 if self.i > 10: self.halt() m = OpenEndedModel(no.LinearTimeline(0, 1)) assert m.timeline.end() == no.time.far_future() assert m.timeline.nsteps() == -1 assert m.timeline.dt() == 1.0 no.run(m) assert m.i == 11 m = OpenEndedModel(no.CalendarTimeline(date(2020, 12, 17), 1, "d")) assert m.timeline.end() == no.time.far_future() assert m.timeline.nsteps() == -1 assert np.fabs(m.timeline.dt() - 1.0 / 365.2475) < 1e-8 no.run(m) assert m.i == 11 m = OpenEndedModel(no.CalendarTimeline(date(2020, 12, 17), 1, "m")) assert m.timeline.end() == no.time.far_future() assert m.timeline.nsteps() == -1 assert np.fabs(m.timeline.dt() - 31.0 / 365.2475) < 1e-8 no.run(m) assert m.i == 11
def test_dummy_model() -> None: class DummyModel(no.Model): def __init__(self) -> None: super().__init__(no.NoTimeline(), no.MonteCarlo.deterministic_identical_stream) def step(self) -> None: pass def finalise(self) -> None: pass assert no.run(DummyModel())
def test_calendar_timeline() -> None: # monthly timesteps checking we don't overshoot in shorter months dim = [31, 29, 31, 30, 31, 30] class CalendarModel(no.Model): def __init__(self, calendartimeline: no.Timeline) -> None: super().__init__(calendartimeline, no.MonteCarlo.deterministic_identical_stream) def step(self) -> None: assert self.timeline.time().day == min(dim[self.timeline.index()], d) def finalise(self) -> None: assert self.timeline.dt() == 0.0 assert self.timeline.time() == self.timeline.end() assert self.timeline.index() == 6 for d in range(1, 32): t = no.CalendarTimeline(date(2020, 1, d), date(2020, 7, d), 1, "m") m = CalendarModel(t) no.run(m)
def init_model(run_no, force_area, year, month, initial_loading, burn_in): global model # this adjustment needs to happen on netlogo side to keep dates in sync # assert burn_in > 0 # # adjust year/month so that the supplied values correspond to the *end* of the burn-in period # month -= burn_in # while month < 1: # year -= 1 # month += 12 # use canned data if requested if force_area == "TEST": model = CannedCrimeData((year, month)) return # monthly open-ended timeline (run_no is used to seed the mc) model = CrimeMicrosim(run_no, force_area, (year, month), burn_in=burn_in) no.log("Initialised crime model in %s at %s" % (force_area, model.timeline().time())) no.log("MC seed=%d" % model.mc().seed()) # simulate the first month model.set_loading(initial_loading) no.run(model)
def test_multimodel() -> None: class TestModel(no.Model): def __init__(self) -> None: super().__init__(no.LinearTimeline(0, 10, 10), no.MonteCarlo.deterministic_identical_stream) self.x = 0.0 def step(self) -> None: #no.log(self.mc.ustream(1)) self.x += self.mc.ustream(1) def finalise(self) -> None: no.log(self.x) models = [TestModel(), TestModel()] [no.run(m) for m in models] assert models[0].x == models[1].x
def test_consistency() -> None: # need to wrap timeline in a model to do the stepping, which isnt directly accessible from python class ConsistencyTest(no.Model): def __init__(self, timeline: no.Timeline) -> None: super().__init__(timeline, no.MonteCarlo.deterministic_identical_stream) def step(self) -> None: pass m = ConsistencyTest(no.NoTimeline()) assert m.timeline.nsteps() == 1 no.run(m) assert m.timeline.index() == 1 m = ConsistencyTest(no.LinearTimeline(2020, 2021, 12)) assert m.timeline.nsteps() == 12 no.run(m) assert m.timeline.index() == 12 assert m.timeline.time() == 2021 m = ConsistencyTest(no.NumericTimeline([2020 + i / 12 for i in range(13)])) assert m.timeline.nsteps() == 12 no.run(m) assert m.timeline.index() == 12 assert m.timeline.time() == 2021 s = date(2019, 10, 31) e = date(2020, 10, 31) m = ConsistencyTest(no.CalendarTimeline(s, e, 1, "m")) assert m.timeline.time().date() == s assert m.timeline.nsteps() == 12 no.run(m) assert m.timeline.time().date() == e assert m.timeline.index() == 12
""" Competing risks - fertility & mortality """ import neworder # model implementation from people import People # separate visualisation code from visualise import plot # neworder.verbose() # create model # data are for white British women in a London Borough at 1 year time resolution dt = 1.0 # years fertility_hazard_file = "examples/competing/fertility-wbi.csv" mortality_hazard_file = "examples/competing/mortality-wbi.csv" population_size = 100000 pop = People(dt, fertility_hazard_file, mortality_hazard_file, population_size) # run model neworder.run(pop) # visualise results plot(pop)
# m = RedisDemoModel("West Yorkshire", 2020, 1, 2021, 1) # no.run(m) #def run_model(force, start_year, start_month, duration_months): # list for model requests for m in pubsub.listen(): no.log(m) if m["type"] == "message" and m["channel"] == b"crime_model_init": params = json.loads(m["data"]) m = RedisDemoModel(params["force"], params["start_year"], params["start_month"], params["end_year"], params["end_month"]) no.run(m) # # # or json? "unpickling can execute code" # # cache.set("crimes", pickle.dumps(df)) # for m in range(3): # print(m) # # send crime data # cache.publish("crime_data", pickle.dumps(df)) # # wait for response # m = next(pubsub.listen()) # if m["type"] == "message": # print(m["data"]) # else: # print(m)
# neworder.verbose() # checks disabled to emphasise performance differences neworder.checked(False) # the max value in the timeline max_age = 100.0 # The mortality rate data mortality_hazard_file = "examples/mortality/mortality-wbi.csv" population_size = 100000 neworder.log("Population = %d" % population_size) # run the discrete model mortality_discrete = PeopleDiscrete(mortality_hazard_file, population_size, max_age) start = time.perf_counter() neworder.run(mortality_discrete) end = time.perf_counter() neworder.log("Discrete model life expectancy = %f, exec time = %f" % (mortality_discrete.life_expectancy, end - start)) # run the continuous model mortality_continuous = PeopleContinuous(mortality_hazard_file, population_size, 1.0) start = time.perf_counter() neworder.run(mortality_continuous) end = time.perf_counter() neworder.log("Continuous model life expectancy = %f, exec time = %f" % (mortality_continuous.life_expectancy, end - start)) # visualise some results # hist_file = "docs/examples/img/mortality_%dk.png" % (population_size//1000) # anim_file = "docs/examples/img/mortality_hist_%dk.gif" % (population_size//1000) plot(mortality_discrete.population, mortality_continuous.population)
""" Chapter 1 This is a direct neworder cover version of the Basic Cohort Model from the Belanger & Sabourin book See https://www.microsimulationandpopulationdynamics.com/ """ import numpy as np import neworder from person import People # neworder.verbose() # uncomment for detailed output # "An arbitrarily selected value, chosen to produce a life expectancy of about 70 years." # (see the "mortality" example for a more realistic model) mortality_hazard = 0.014 population_size = 100000 model = People(mortality_hazard, population_size) neworder.run(model) # now we can sample the population generated by the model to see the proportion of deaths at (arbitrarily) 10 year intervals for age in np.linspace(10.0, 100.0, 10): neworder.log("Age %.0f survival rate = %.1f%%" % (age, model.alive(age) * 100.0))
def test_model() -> None: model = _TestModel() no.run(model) assert model.step_count == 10
import numpy as np import neworder from schelling import Schelling #neworder.verbose() # category 0 is empty gridsize = (480, 360) categories = np.array([0.36, 0.12, 0.12, 0.4]) # normalise if necessary # categories = categories / sum(categories) similarity = 0.6 # open-ended timeline with arbitrary timestep # the model halts when all agents are satisfied, rather than at a specific time timeline = neworder.LinearTimeline(0, 1.0) schelling = Schelling(timeline, gridsize, categories, similarity) neworder.run(schelling)
for i, r in self.population.iterrows(): if r.talkative: neworder.log("Hello from %d" % i) # !finalise! # def check(self) -> bool: # """ # Custom checks can be made after every timestep during the simulation. # This method is optional # Arguments: self # Returns: bool # """ # return True # !script! # uncomment for verbose output # neworder.verbose() # uncomment to disable checks entirely # neworder.checked(False) # construct the model with the population size and the probability of becoming talkative hello_world = HelloWorld(10, 0.5) # run the model and check it worked ok = neworder.run(hello_world) if not ok: neworder.log("model failed!") # !script!
# infection rate amongst those previously uninfected neworder.log("effective infection rate %.2f%% new : %d" % (100.0 * len(new_infections) / len(uninfected), len(new_infections))) self.infection_rate[self.timeline().index()] = len(new_infections) / len(uninfected) self.mortality_rate[self.timeline().index()] = len(new_deaths) / len(self.pop[self.pop.State != State.DECEASED]) def finalise(self): deaths = sum(~neworder.time.isnever(self.pop.tDeceased.values)) # simple measure of test coverage 100% or severe and above, 25% of mild observed_cases = sum(~neworder.time.isnever(self.pop.tSevere.values)) + 0.25 * sum(~neworder.time.isnever(self.pop.tMild.values)) neworder.log("Mortality: observed = %.2f%%, actual = %.f%%" % (100.0 * deaths / observed_cases, 100.0 * deaths / self.npeople)) self.summary = self.summary.fillna(0) self.summary.index = range(1,len(self.summary)+1) # use the string representations of thobserved_casese int enums self.summary.rename(columns={s: State(s).name for s in self.summary.columns.values}, inplace=True) Graphics().plot(self) # initialise the model days = 180 dt = 1 npeople = 10000 disease_model = DiseaseModel(days, dt, npeople) neworder.run(disease_model)
if m["type"] == "message" and m["channel"] == b"crime_model_stop": self.halt() def checkpoint(self): # send done signal (NB (int)0 gets serialised as b"0" i.e. a string (?)) cache.publish("crime_model_result", json.dumps({"status": 0})) pubsub.unsubscribe("crime_rate") cache = redis.StrictRedis(host='localhost', port=6379) pubsub = cache.pubsub() pubsub.subscribe("crime_model_init") # m = RedisDemoModel("West Yorkshire", 2020, 1, 2021, 1) # no.run(m) #def run_model(force, start_year, start_month, duration_months): while True: # list for model init requests no.log("waiting for init request") for msg in pubsub.listen(): no.log(msg) if msg["type"] == "message" and msg["channel"] == b"crime_model_init": params = json.loads(msg["data"]) model = RedisDemoModel(params["force"], params["start_year"], params["start_month"], params["end_year"], params["end_month"]) no.run(model)
import time from datetime import date import neworder from population import Population #neworder.verbose() # input data initial_population = "examples/people/E08000021_MSOA11_2011.csv" # age, gender and ethnicity-specific rates fertility_rate_data = "examples/people/fertility.csv" mortality_rate_data = "examples/people/mortality.csv" in_migration_rate_data = "examples/people/migration-in.csv" out_migration_rate_data = "examples/people/migration-out.csv" # define the evolution timeline timeline = neworder.CalendarTimeline(date(2011, 1, 1), date(2051, 1, 1), 1, "y") # create the model population = Population(timeline, initial_population, fertility_rate_data, mortality_rate_data, in_migration_rate_data, out_migration_rate_data) # run the model start = time.time() ok = neworder.run(population) neworder.log("run time = %.2fs" % (time.time() - start)) assert ok
See: https://www.statcan.gc.ca/eng/microsimulation/modgen/new/chap3/chap3 https://www.statcan.gc.ca/eng/microsimulation/modgen/new/chap4/chap4 'RiskPaths is a simple, competing risk, case-based continuous time microsimulation model. Its main use is as a teaching tool, introducing microsimulation to social scientists and demonstrating how dynamic microsimulation models can be efficiently programmed using the language Modgen. Modgen is a generic microsimulation programming language developed and maintained at Statistics Canada. RiskPaths as well as the Modgen programming language and other related documents are available at www.statcan.gc.ca/microsimulation/modgen/modgen-eng.htm' """ import neworder from data import max_age from riskpaths import RiskPaths from visualisation import plot # serial mode #neworder.verbose() population_size = 100000 # single step (continuous model) riskpaths = RiskPaths(population_size) neworder.run(riskpaths) plot(riskpaths)
# neworder.checked(False) # uncomment to disable checks # requires 4 identical sims with perturbations to compute market sensitivities # (a.k.a. Greeks) assert neworder.mpi.size() == 4, "This example requires 4 processes" # initialisation # market data market = { "spot": 100.0, # underlying spot price "rate": 0.02, # risk-free interest rate "divy": 0.01, # (continuous) dividend yield "vol": 0.2 # stock volatility } # (European) option instrument data option = { "callput": "CALL", "strike": 100.0, "expiry": 0.75 # years } # model parameters nsims = 1000000 # number of underlyings to simulate # instantiate model bs_mc = BlackScholes(option, market, nsims) # run model neworder.run(bs_mc)