Offer models that are not dependent on Modelx

[MatthewCaseres]

When developing a modelx model in a plain Python file (without using the modelx plugin for Spyder), static analysis tools will raise errors due to some of the syntax.

I'm interested in if you would take contributions that are not dependent on Modelx, or maybe have Modelx offer a syntax that is compatible with static analysis tools.

The VSCode Jupyter notebook plugin provides some features of the modelx plugin, like the data viewer. But it does not feel like writing normal Python to write the modelx model in Jupyter.

This is an attempt at a decorator that has a joint cache and aggregates results.

# %%
import pandas as pd
import numpy as np
from typing import Callable
from collections import defaultdict

# this is a decorator for memoizing functions. The 'Cash' class is really a cache.
class Cash:
    def __init__(self):
        self.reset()
    def reset(self):
        self.caches = defaultdict(dict)
    def __call__(self, f: Callable[[int], np.array]) -> Callable[[int], np.array]:
        def g(t):
            if t not in self.caches[f.__name__]:
                self.caches[f.__name__][t] = f(t)
            return self.caches[f.__name__][t]
        return g
cash = Cash()

# %%
mp = pd.read_csv("src/model_point_table.csv")
class Mortality:
    def __init__(self, issue_age: pd.Series):
        self.mort_np = pd.read_csv("src/mort_table.csv").drop(columns=["Age"]).to_numpy()
        self.issue_age = issue_age
    def get_annual_rate(self, duration: int):
        return self.mort_np[self.issue_age + duration - 18, min(duration, 5)]
    def get_monthly_rate(self, duration: int):
        return 1 - (1 - self.get_annual_rate(duration))**(1/12)
mortality = Mortality(mp["age_at_entry"])

# %%
def duration(t: int):
    return t // 12
@cash
def pols_death(t: int):
    return pols_inforce(t) * mortality.get_monthly_rate(duration(t))
@cash
def pols_inforce(t: int):
    if t == 0:
        return np.ones(len(mp))
    return pols_inforce(t - 1) - pols_lapse(t - 1) - pols_death(t - 1) - pols_maturity(t)
def lapse_rate(t: int):
    return max(0.1 - 0.02 * duration(t), 0.02)
@cash
def pols_lapse(t: int):
    return (pols_inforce(t) - pols_death(t)) * (1 - (1 - lapse_rate(t))**(1/12))
@cash
def pols_maturity(t: int):
    return (t == 12 * mp["policy_term"]) * (pols_inforce(t - 1) - pols_lapse(t - 1) - pols_death(t - 1))

# %%
def summarize_results(cash: Cash) -> pd.DataFrame:
    res = []
    for function_name, cache in cash.caches.items():
        s = pd.Series({k: sum(v) for k, v in cache.items()}, name=function_name)
        res.append(s)
    return pd.concat(res, axis=1)

# %%
cash.reset()
pols_lapse(20 * 12)

# %%
results = summarize_results(cash)
results["duration"] = results.index // 12

# %%
results

[fumitoh]

To remove static syntax error, you can use variable annotation without initial values:

import modelx as mx

m = mx.new_model()

bar: int

@mx.defcells
def foo():
    return bar

m.bar = 3

I guess your attempt looks similar to acturtle/cashflower?

[MatthewCaseres]

I want cashflower to feel more like the @cache/@lru_cache decorator. I could add lifelib models to the CI/CD thing here - https://github.com/actuarialopensource/benchmarks and then that can be a place where varying implementations of lifelib models can be run/viewed.

[fumitoh]

If the code above is your entire work, then I'd suggest you make it as a Jupyter notebook and put it in an existing library. If your final work consits of multiple files with more contents, then that should deserve a new separate library, in which case complete documentation is needed. In the latter case, I suggest you first prepare the contents in your own repositry first then ask for review/comments before PR to lifelib.