def test_default_initial_conditions_are_zero(self):
n1 = 5
n2 = 8
usage_seq = np.hstack((np.ones(n2, dtype=int), np.zeros(n1,
dtype=int)))
seqs = []
for i in range(2):
if i == 0:
ic = ([0.0], [0.0, 0.0])
else:
ic = None
arma1 = Arma(
[0.9],
[0.1, -0.2],
default_source=sources.GaussianNoise(),
)
arma2 = Arma(
[0.1, -0.2],
[0.3, 0.4, 0.5],
default_source=sources.GaussianNoise(),
)
seq = sample_switching_models([arma1, arma2],
usage_seq,
initial_conditions=ic)
seqs.append(seq)
np.testing.assert_allclose(seqs[0], seqs[1])
def test_second_model_history_is_not_default(self):
n1 = 13
n2 = 23
# these will get overridden
seq = [0]
seq1_exp = [1]
seq2_exp = [2]
for i in range(2):
arma1 = Arma([0.9], [0.1, -0.2],
default_source=sources.GaussianNoise())
arma2 = Arma([0.1, -0.2], [0.3],
default_source=sources.GaussianNoise())
if i == 0:
seq1_exp = arma1.transform(n1)
seq2_exp = arma2.transform(n2)
else:
seq = sample_switching_models(
[arma1, arma2],
np.hstack((np.zeros(n1, dtype=int), np.ones(n2,
dtype=int))),
)
np.testing.assert_allclose(seq[:n1], seq1_exp)
self.assertGreater(np.max(np.abs(seq[n1:] - seq2_exp)), 0)
def test_model_histories_do_not_matter(self):
n1 = 5
n2 = 8
usage_seq = np.hstack((np.ones(n2, dtype=int), np.zeros(n1,
dtype=int)))
seqs = []
for i in range(2):
if i == 0:
ic1 = ([0.3], [-0.2, 0.2])
ic2 = ([0.2, 0.1], [-0.1, 0.2, 0.0])
else:
ic1 = None
ic2 = None
arma1 = Arma(
[0.9],
[0.1, -0.2],
default_source=sources.GaussianNoise(),
initial_conditions=ic1,
)
arma2 = Arma(
[0.1, -0.2],
[0.3, 0.4, 0.5],
default_source=sources.GaussianNoise(),
initial_conditions=ic2,
)
seq = sample_switching_models([arma1, arma2], usage_seq)
seqs.append(seq)
np.testing.assert_allclose(seqs[0], seqs[1])
def test_default_seed_is_zero(self):
src1 = sources.GaussianNoise()
src2 = sources.GaussianNoise(0)
n = 13
y1 = src1(size=n)
y2 = src2(size=n)
np.testing.assert_allclose(y1, y2)
def test_default_scale_is_one(self):
seed = 1
src1 = sources.GaussianNoise(seed)
src2 = sources.GaussianNoise(seed, scale=1)
n = 12
y1 = src1(size=n)
y2 = src2(size=n)
np.testing.assert_allclose(y1, y2)
def test_default_loc_is_zero(self):
seed = 123
src1 = sources.GaussianNoise(seed)
src2 = sources.GaussianNoise(seed, loc=0)
n = 13
y1 = src1(size=n)
y2 = src2(size=n)
np.testing.assert_allclose(y1, y2)
def test_scale_matters(self):
seed = 123
src1 = sources.GaussianNoise(seed, scale=1)
src2 = sources.GaussianNoise(seed, scale=2)
n = 13
y1 = src1(size=n)
y2 = src2(size=n)
self.assertGreater(np.max(np.abs(y1 - y2)), 1e-3)
def test_init_can_take_default_rng_seed_or_rng(self):
seed = 123
src1 = sources.GaussianNoise(seed)
src2 = sources.GaussianNoise(np.random.default_rng(seed))
n = 13
y1 = src1(size=n)
y2 = src2(size=n)
np.testing.assert_allclose(y1, y2)
def test_single_model(self):
n = 20
a = [0.9]
b = [0.1, -0.2]
arma1 = Arma(a, b, default_source=sources.GaussianNoise())
seq_exp = arma1.transform(n)
arma2 = Arma(a, b, default_source=sources.GaussianNoise())
seq = sample_switching_models([arma2], np.zeros(n, dtype=int))
np.testing.assert_allclose(seq, seq_exp)
def test_using_different_source_constructor(self):
loc = 1.0
seed = 3
scale = sources.fix_transformer_scale(
self.arma,
source_constructor=lambda **kwargs: sources.GaussianNoise(
loc=loc, rng=seed, **kwargs),
)
self.arma_alt.default_source = sources.GaussianNoise(loc=loc, rng=seed)
scale_alt = sources.fix_source_scale(self.arma_alt)
self.assertAlmostEqual(scale, scale_alt)
def test_transform_only_one_retval_by_default(self):
arma_hsmm = ArmaHSMM(self.armas)
n = 16
y_exp, _, _ = arma_hsmm.transform(n,
return_input=True,
return_usage_seq=True)
arma1 = Arma([0.9], [], default_source=sources.GaussianNoise())
arma2 = Arma([0.2, -0.1], [0.3],
default_source=sources.GaussianNoise())
arma_hsmm2 = ArmaHSMM([arma1, arma2])
y = arma_hsmm2.transform(n)
np.testing.assert_allclose(y, y_exp)
def setUp(self):
self.rng = np.random.default_rng(1)
self.loc = -0.5
self.scale = 2.3
self.src = sources.GaussianNoise(self.rng,
loc=self.loc,
scale=self.scale)
def test_when_scale_is_zero_all_values_equal_loc(self):
loc = 0.35
src = sources.GaussianNoise(1, loc=loc, scale=0)
n = 10
y = src(size=n)
np.testing.assert_allclose(y, loc)
def test_scale_matches_that_from_fix_source_scale_with_gaussian_by_default(
self):
scale = sources.fix_transformer_scale(self.arma)
self.arma_alt.default_source = sources.GaussianNoise()
scale_alt = sources.fix_source_scale(self.arma_alt)
self.assertAlmostEqual(scale, scale_alt)
def test_returned_samples_are_random(self):
src = sources.GaussianNoise(1)
n = 10
y1 = src(size=n)
y2 = src(size=n)
self.assertGreater(np.max(np.abs(y1 - y2)), 1e-3)
def test_fix_source_scale_does_not_affect_sources_rng_by_default(self):
seed = 123
src1 = sources.GaussianNoise(seed)
n = 12
u1 = src1(size=n)
rng = np.random.default_rng(30)
src2 = sources.GaussianNoise(seed)
arma = make_random_arma(3, 2, rng, default_source=src2)
sources.fix_source_scale(arma)
# reset scale
src2.scale = 1
u2 = src2(size=n)
np.testing.assert_allclose(u1, u2)
def test_fix_source_scale_affects_sources_rng_when_use_copy_is_false(self):
seed = 123
src1 = sources.GaussianNoise(seed)
n = 12
u1 = src1(size=n)
rng = np.random.default_rng(30)
src2 = sources.GaussianNoise(seed)
arma = make_random_arma(3, 2, rng, default_source=src2)
sources.fix_source_scale(arma, use_copy=False)
# reset scale
src2.scale = 1
u2 = src2(size=n)
self.assertGreater(np.max(np.abs(u1 - u2)), 1e-3)
def test_arguments_forwarded_to_fix_source_scale(self):
kwargs = {"output_std": 3.5, "n_samples": 500}
scale = sources.fix_transformer_scale(self.arma, **kwargs)
self.arma_alt.default_source = sources.GaussianNoise()
scale_alt = sources.fix_source_scale(self.arma_alt, **kwargs)
self.assertAlmostEqual(scale, scale_alt)
def test_multiple_models_callable_source(self):
n1 = 13
n2 = 23
seed = 12
src = sources.GaussianNoise(seed)
X_exp = src(size=n1 + n2)
arma1 = Arma([0.9], [0.1, -0.2])
arma2 = Arma([0.1, -0.2], [0.3])
_, X_ret = sample_switching_models(
[arma1, arma2],
np.hstack((np.zeros(n1, dtype=int), np.ones(n2, dtype=int))),
X=sources.GaussianNoise(seed),
return_input=True,
)
np.testing.assert_allclose(X_exp, X_ret)
def test_fix_source_scale_returns_final_scale(self):
seed = 10
src = sources.GaussianNoise(seed)
rng = np.random.default_rng(30)
arma = make_random_arma(2, 0, rng, default_source=src)
scale = sources.fix_source_scale(arma)
self.assertAlmostEqual(scale, src.scale)
def test_initial_conditions_parameter_is_obeyed(self):
a = [0.8]
b = [0.1, 0.2]
n = 32
ic = ([-0.5], [-0.5, 0.3])
arma = Arma(a,
b,
default_source=sources.GaussianNoise(),
initial_conditions=ic)
seq_exp = arma.transform(n)
arma = Arma(a, b, default_source=sources.GaussianNoise())
seq = sample_switching_models([arma],
np.zeros(n, dtype=int),
initial_conditions=ic)
np.testing.assert_allclose(seq, seq_exp)
def test_source_is_copied_before_using(self):
dataset = RandomArmaDataset(1,
23, [(1, 2), (3, 0)],
source=sources.GaussianNoise())
sig1 = dataset[0]
sig2 = dataset[0]
np.testing.assert_equal(sig1.y, sig2.y)
np.testing.assert_equal(sig1.u, sig2.u)
np.testing.assert_equal(sig1.usage_seq, sig2.usage_seq)
def test_ar1_output_variance_is_fixed_to_one_by_default(self):
seed = 10
src = sources.GaussianNoise(seed)
rng = np.random.default_rng(30)
arma = make_random_arma(1, 0, rng, default_source=src)
sources.fix_source_scale(arma, n_samples=5000)
ma_var = src.scale**2
arma_var = ma_var / (1 - arma.a[0]**2)
self.assertAlmostEqual(arma_var, 1, places=2)
def test_correct_history_used_at_switch_point(self):
n1 = 13
n2 = 5
arma1 = Arma([0.9], [0.1, -0.2],
default_source=sources.GaussianNoise())
a2 = [0.1, -0.2]
b2 = [0.3]
arma2 = Arma(a2, b2, default_source=sources.GaussianNoise())
seq, X = sample_switching_models(
[arma1, arma2],
np.hstack((np.zeros(n1, dtype=int), np.ones(n2, dtype=int))),
return_input=True,
)
exp_ar = np.dot(np.flip(a2), seq[n1 - len(a2):n1])
exp_ma = np.dot(np.flip(b2), X[n1 - len(b2):n1]) + X[n1]
self.assertAlmostEqual(exp_ar + exp_ma, seq[n1])
def test_ar2_output_variance_is_fixed_to_one_by_default(self):
seed = 10
src = sources.GaussianNoise(seed)
rng = np.random.default_rng(30)
arma = make_random_arma(2, 0, rng, default_source=src)
sources.fix_source_scale(arma, n_samples=10000)
ma_var = src.scale**2
a_diff = 1 - arma.a[1]
a_sum = 1 + arma.a[1]
arma_var = a_diff * ma_var / (a_sum * (a_diff**2 - arma.a[0]**2))
self.assertAlmostEqual(arma_var, 1, places=2)
def test_scale_varies_in_proportion_to_output_variance(self):
seed = 10
src = sources.GaussianNoise(seed)
rng = np.random.default_rng(30)
arma = make_random_arma(2, 0, rng, default_source=src)
var1 = 0.5
sources.fix_source_scale(arma, output_std=var1)
scale1 = src.scale
var2 = 1.5
sources.fix_source_scale(arma, output_std=var2)
scale2 = src.scale
self.assertAlmostEqual(var1 / var2, scale1 / scale2, places=2)
def __getitem__(self, idx: int) -> SwitchingArmaSignal:
""" Generate a signal.
Parameters
----------
idx
The index of the signal to generate.
Returns a `SwitchingArmaSignal` instance. Note that the signal is generated anew
every time it is accessed, making this a potentially time-consuming operation.
"""
if idx < 0:
idx = self.n_signals + idx
if idx < 0 or idx >= self.n_signals:
raise IndexError("index out of range")
# create an ArmaHSMM instance
seed = self.signal_seeds[idx]
rng = np.random.default_rng(seed)
crt_armas = self.armas[idx]
arma_hsmm = ArmaHSMM(crt_armas, rng=rng, **self.arma_hsmm_kws)
if self.source is not None:
source = copy.deepcopy(self.source)
else:
source_seed = rng.integers(0, sys.maxsize)
source_rng = np.random.default_rng(source_seed)
source = sources.GaussianNoise(rng=source_rng)
y, u, usage_seq = arma_hsmm.transform(
self.n_samples,
X=source,
initial_conditions=self.initial_conditions,
return_input=True,
return_usage_seq=True,
)
if self.normalize:
scale = 1.0 / np.std(y)
y *= scale
else:
scale = 1.0
return SwitchingArmaSignal(y, u, usage_seq, list(crt_armas), scale)
def setUp(self):
self.arma1 = Arma([0.9], [], default_source=sources.GaussianNoise())
self.arma2 = Arma([0.2, -0.1], [0.3],
default_source=sources.GaussianNoise())
self.armas = [self.arma1, self.arma2]
ax2.set_ylim(0.5, 1)
ax2.set_ylabel("accuracy score")
# fig.savefig(os.path.join(fig_path, "cepstral_results_vs_xcorr_and_biowta_with_streak.pdf"), transparent=True)
# %% [markdown]
# ## Temporal correlations explanation
# %%
rng = np.random.default_rng(4)
# scales chosen so the outputs of both processes have aproximately unit variance
two_ar_short = SimpleNamespace(
arma1=Arma([-0.474], [],
default_source=sources.GaussianNoise(scale=0.879, rng=rng)),
arma2=Arma([0.6], [],
default_source=sources.GaussianNoise(scale=0.802, rng=rng)),
)
two_ar_short.armas = [two_ar_short.arma1, two_ar_short.arma2]
crt_samples1 = two_ar_short.arma1.transform(100000)
crt_samples2 = two_ar_short.arma2.transform(100000)
print("should be almost zero:",
np.std(crt_samples1) - 1,
np.std(crt_samples2) - 1)
two_ar_short.n_samples = 500
two_ar_short.usage_seq = np.zeros(two_ar_short.n_samples, dtype=int)
two_ar_short.usage_seq[150:390] = 1
def setUp(self):
self.arma1 = Arma([0.9], [], default_source=sources.GaussianNoise())
self.arma2 = Arma([0.2, -0.1], [0.3],
default_source=sources.GaussianNoise())
self.armas = [self.arma1, self.arma2]
self.arma_hsmm = ArmaHSMM(self.armas, min_dwell=3, dwell_times=5)
