def __init__(self, *, cvar, dvar, dlscale, pvar, plscale):
self._kern = (ks.kernel.Constant(var=cvar) + ks.kernel.Exponential(
var=dvar, lscale=(dlscale * YEAR)) + ks.kernel.PeriodicExponential(
var=pvar, lscale=(plscale * YEAR), period=YEAR))
ks_model = ks.BinaryModel(obs_type="probit")
fit_params = {"method": "ep", "max_iter": 100, "lr": 1.0}
super().__init__(ks_model, fit_params)
def test_add_item_twice():
"""Item with same name cannot be added again."""
kernel = ks.kernel.Constant(1.0)
model = ks.BinaryModel()
model.add_item("x", kernel)
with pytest.raises(ValueError):
model.add_item("x", kernel)
def __init__(self,
dataset,
obs_type="probit",
method="ep",
max_iter=100,
lr=1.0):
self.ks_model = ks.BinaryModel(obs_type=obs_type)
self.fit_params = {"method": method, "max_iter": max_iter, "lr": lr}
self.dataset = dataset
def __init__(self,
kernel,
obs_type="probit",
method="ep",
max_iter=100,
lr=1.0):
ks_model = ks.BinaryModel(obs_type=obs_type)
fit_params = {"method": method, "max_iter": max_iter, "lr": lr}
self._kern = kernel
super().__init__(ks_model, fit_params)
def test_damping():
"""Damping should work on a simple example."""
kernel = ks.kernel.Constant(1.0)
model = ks.BinaryModel()
for x in ["A", "B", "C", "D"]:
model.add_item(x, kernel=kernel)
model.observe(winners=["C", "D"], losers=["A", "B"], t=0.0)
model.observe(winners=["A", "B"], losers=["C", "D"], t=0.0)
model.observe(winners=["A", "B"], losers=["C", "D"], t=0.0)
# Without damping, this simple example diverges.
assert not model.fit(max_iter=20)
# However, a little bit of damping is enough to make it converge.
assert model.fit(max_iter=20, lr=0.8)
def test_saving():
"""Serializing a large(-ish) model with pickle should work."""
random.seed(0)
kernel = ks.kernel.Constant(1.0)
model = ks.BinaryModel()
for i in range(100):
model.add_item(f"team{i}", kernel)
for _ in range(500):
i, j = random.sample(model.item.keys(), 2)
model.observe(winners=[i], losers=[j], t=0.0)
# Serialize & unserialize.
data = pickle.dumps(model)
model2 = pickle.loads(data)
assert model2.item.keys() == model.item.keys()
for obs, obs2 in zip(model.observations, model2.observations):
assert obs.t == obs2.t
def __init__(self, *, cvar, wvar):
ks_model = ks.BinaryModel(obs_type="probit")
TTTModel.init_items(ks_model, cvar, wvar)
fit_params = {"method": "ep", "max_iter": 100, "lr": 1.0}
super().__init__(ks_model, fit_params)
def __init__(self, *, ovar, svar, wvar, method="ep"):
ks_model = ks.BinaryModel(obs_type="probit")
AffineWienerModel.init_items(ks_model, ovar, svar, wvar)
fit_params = {"method": method, "max_iter": 100, "lr": 1.0}
super().__init__(ks_model, fit_params)
def __init__(self, *, ovar, svar, dvar, lscale):
ks_model = ks.BinaryModel(obs_type="probit")
AffineDynamicModel.init_items(ks_model, ovar, svar, dvar, lscale)
fit_params = {"method": "ep", "max_iter": 100, "lr": 1.0}
super().__init__(ks_model, fit_params)
model = model_class(**data.get("model_args", {}))
for item in data["items"]:
kernel_class = getattr(ks.kernel, item["kernel_class"])
kernel = kernel_class(**item["kernel_args"])
model.add_item(item["name"], kernel=kernel)
for obs in data["observations"]:
model.observe(**obs)
model.fit(**data.get("fit_args", {}))
for name, scores in data["scores"].items():
_, mean, var = model.item[name].scores
assert np.allclose(scores["mean"], mean, rtol=1e-3)
assert np.allclose(scores["var"], var, rtol=1e-3)
assert np.allclose(model.log_likelihood, data["log_likelihood"], rtol=1e-3)
@pytest.mark.parametrize("model", [ks.BinaryModel(), ks.TernaryModel()])
def test_chronological_order(model):
"""Observations can only be added in chronological order."""
model.add_item("x", kernel=ks.kernel.Constant(1.0))
model.observe(winners=["x"], losers=[], t=1.0)
with pytest.raises(ValueError):
model.observe(winners=["x"], losers=[], t=0.0)
def test_damping():
"""Damping should work on a simple example."""
kernel = ks.kernel.Constant(1.0)
model = ks.BinaryModel()
for x in ["A", "B", "C", "D"]:
model.add_item(x, kernel=kernel)
model.observe(winners=["C", "D"], losers=["A", "B"], t=0.0)
