poliosim.analysis module

Additional analysis functions.

class Analyzer(label=None)

Bases: sciris.sc_utils.prettyobj

Base class for analyzers. Based on the Intervention class. Analyzers are used to provide more detailed information about a simulation than is available by default – for example, pulling states out of sim.people on a particular timestep before it gets updated in the next timestep.

To retrieve a particular analyzer from a sim, use sim.get_analyzer().

Parameters

label (str) – a label for the Analyzer (used for ease of identification)

initialize(sim=None)

Initialize the analyzer, e.g. convert date strings to integers.

finalize(sim=None)

Finalize analyzer

This method is run once as part of sim.finalize() enabling the analyzer to perform any final operations after the simulation is complete (e.g. rescaling)

apply(sim)

Apply analyzer at each time point. The analyzer has full access to the sim object, and typically stores data/results in itself. This is the core method which each analyzer object needs to implement.

Parameters

sim – the Sim instance

shrink(in_place=False)

Remove any excess stored data from the intervention; for use with sim.shrink().

Parameters

in_place (bool) – whether to shrink the intervention (else shrink a copy)

to_json()

Return JSON-compatible representation

Custom classes can’t be directly represented in JSON. This method is a one-way export to produce a JSON-compatible representation of the intervention. This method will attempt to JSONify each attribute of the intervention, skipping any that fail.

Returns

JSON-serializable representation

class snapshot(days, *args, **kwargs)

Bases: poliosim.analysis.Analyzer

Analyzer that takes a “snapshot” of the sim.people array at specified points in time, and saves them to itself. To retrieve them, you can either access the dictionary directly, or use the get() method.

Parameters

• days (list) – list of ints/strings/date objects, the days on which to take the snapshot

• kwargs (dict) – passed to Intervention()

Example:

sim = ps.Sim(analyzers=ps.snapshot('2020-04-04', '2020-04-14'))
sim.run()
snapshot = sim['analyzers'][0]
people = snapshot.snapshots[0]            # Option 1
people = snapshot.snapshots['2020-04-04'] # Option 2
people = snapshot.get('2020-04-14')       # Option 3
people = snapshot.get(34)                 # Option 4
people = snapshot.get()                   # Option 5

initialize(sim)

apply(sim)

get(key=None)

Retrieve a snapshot from the given key (int, str, or date)

class save_states(states=None, full=False, sort_inds=None, **kwargs)

Bases: poliosim.analysis.Analyzer

Save the states of the people into a big array for polio.

Parameters

• states (list) the list of states to save (default, just shedding) –

• full (bool) – whether to save the complete list of states

initialize(sim)

apply(sim)

to_dfdict()

plot(sort_inds=None, log_viral_shed=True, nonzero_only=False, filter_states=None, rows=None, **kwargs)

coplot(people_inds=None, filter_states=None, transform_state=None, **kwargs)

Co-plot selected states of selected people, one plot per person.

Parameters

• people_inds – The indices of the people to create plots for.

• filter_states – If specified, only these states will be shown. The states you want also need to be

• object (specified when creating the analyzer) –

• didn't (or else be one of the defaults if you) –

• explicitly. (specify any) –

• transform_state – An optional dictionary, keyed on state names. The dictionary value is a function

• plotted. (to pass the state values through. The transformed value will be) –

• **kwargs –

Returns

Nothing.

Example of using transform_state:

# This function returns log10(x) when x > 0, otherwise np.nan:
def snoop_loggy_log10(x):
    return np.log10(x, where=0 < x, out=np.nan * x)

# Apply the special log function just to the state 'viral_shed'.
my_analyzer.plot(people_inds=inds, transform_state={'viral_shed': snoop_loggy_log10})

class track_events(states=None, full=True, curr_imm=False, **kwargs)

Bases: poliosim.analysis.Analyzer

Store a list of events for everyone.

Parameters

• states (list) the list of states to save (default, just shedding) –

• full (bool) – whether to save the complete list of states

• curr_imm (bool) – whether to store current immunity, which is updated on every timestep (default: false)

Data are stored in self.events for the events, and self.init_state for the initial state.

initialize(sim)

finalize(sim=None)

Convert from list-of-dicts to dataframe

apply(sim)

class track_shedders(**kwargs)

Bases: poliosim.analysis.Analyzer

Keep a record of people who shed

initialize(sim)

apply(sim)

Record data throughout the sim

plot(font_family=None)

class infection_report(naive_immunity=8.0, age_breakpoints=None, **kwargs)

Bases: poliosim.analysis.Analyzer

Keep a record of who infects who.

Parameters

• naive_immunity (float) – immunity threshold for categorization as naive (units = Nab). Default is 8.0.

• age_breakpoints (array of float) – age breakpoints for making categories.

• [5 (Default is) –

• u5' ('non-naive) –

• u5' –

• '5-15' –

• 'o15'. –

• variants. (All categories with lower bound <5 will have naive and non-naive) –

• raised. (The first age breakpoint must be >0 or an exception will be) –

make_infection_report_categories(age_breakpoints)

initialize(sim)

get_infection_report_category(age, immunity)

apply(sim)

Record data throughout the sim

plot(font_family=None)

class Fit(sim, weights=None, keys=None, method=None, custom=None, compute=True, verbose=False, **kwargs)

Bases: sciris.sc_utils.prettyobj

A class for calculating the fit between the model and the data. Note the following terminology is used here:

• fit: nonspecific term for how well the model matches the data

• difference: the absolute numerical differences between the model and the data (one time series per result)

• goodness-of-fit: the result of passing the difference through a statistical function, such as mean squared error

• loss: the goodness-of-fit for each result multiplied by user-specified weights (one time series per result)

• mismatch: the sum of all the loses (a single scalar value) – this is the value to be minimized during calibration

Parameters

• sim (Sim) – the sim object

• weights (dict) – the relative weight to place on each result

• keys (list) – the keys to use in the calculation

• method (str) – the method to be used to calculate the goodness-of-fit

• custom (dict) – a custom dictionary of additional data to fit; format is e.g. {‘<label>’:{‘data’:[1,2,3], ‘sim’:[1,2,4], ‘weights’:2.0}}

• compute (bool) – whether to compute the mismatch immediately

• verbose (bool) – detail to print

• kwargs (dict) – passed to compute_gof()

Example:

sim = ps.Sim() # Needs data to work
sim.run()
fit = sim.compute_fit()
fit.plot()

compute()

Perform all required computations

reconcile_inputs()

Find matching keys and indices between the model and the data

compute_diffs(absolute=False)

Find the differences between the sim and the data

compute_gofs(**kwargs)

Compute the goodness-of-fit

compute_losses()

Compute the weighted goodness-of-fit

compute_mismatch(use_median=False)

Compute the final mismatch

plot(keys=None, width=0.8, font_size=18, fig_args=None, axis_args=None, plot_args=None)

Plot the fit of the model to the data. For each result, plot the data and the model; the difference; and the loss (weighted difference). Also plots the loss as a function of time.

Parameters

• keys (list) – which keys to plot (default, all)

• width (float) – bar width

• font_size (float) – size of font

• fig_args (dict) – passed to pl.figure()

• axis_args (dict) – passed to pl.subplots_adjust()

• plot_args (dict) – passed to pl.plot()

class TransTree(sim, to_networkx=False)

Bases: sciris.sc_utils.prettyobj

A class for holding a transmission tree. There are several different representations of the transmission tree: “infection_log” is copied from the people object and is the simplest representation. “detailed h” includes additional attributes about the source and target. If NetworkX is installed (required for most methods), “graph” includes an NX representation of the transmission tree.

Parameters

• sim (Sim) – the sim object

• to_networkx (bool) – whether to convert the graph to a NetworkX object

property transmissions

Iterable over edges corresponding to transmission events

This excludes edges corresponding to seeded infections without a source

day(day=None, which=None)

Convenience function for converting an input to an integer day

count_targets(start_day=None, end_day=None)

Count the number of targets each infected person has. If start and/or end days are given, it will only count the targets of people who got infected between those dates (it does not, however, filter on the date the target got infected).

Parameters

• start_day (int/str) – the day on which to start counting people who got infected

• end_day (int/str) – the day on which to stop counting people who got infected

make_detailed(people, reset=False)

Construct a detailed transmission tree, with additional information for each person

plot(*args, **kwargs)

Plot the transmission tree

plot_histograms(start_day=None, end_day=None, bins=None, width=0.8, fig_args=None, font_size=18)

Plots a histogram of the number of transmissions.

Parameters

• start_day (int/str) – the day on which to start counting people who got infected

• end_day (int/str) – the day on which to stop counting people who got infected

• bins (list) – bin edges to use for the histogram

• width (float) – width of bars

• fig_args (dict) – passed to pl.figure()

• font_size (float) – size of font

plot_intervals()

Plot serial interval distribution

class calculate_contacts_infected(ignore_last_n_days=None, **kwargs)

Bases: poliosim.analysis.Analyzer

Calculate the contacts infected

apply(sim)

calculate_contact_counts(sim)

calculate_contacts_infected(sim)

clear()

plot()

save(folder=None)