def test_method_access_default_call(self):
oscN = 3
nH = 1
params = self.generate_params(oscN, nH)
t = np.linspace(0, 1, 200)
model = ModelWrapper(KurSL(params))
kursl = KurSL()
s_kursl = np.array(kursl(t, params))
s_model = np.array(model(t, params))
self.assertTrue(np.all(s_kursl == s_model),
"Both calls should return the same")
def test_lnlikelihood(self):
t = np.arange(0, 1, 0.01)
S = np.random.random(t.size)
theta = self.random_theta(3, 2)
kursl = KurSL(theta)
model = ModelWrapper(kursl)
lnlikelihood = KurslMCMC.lnlikelihood(theta, t, S[:-1], model)
self.assertTrue(lnlikelihood < 0, "Any negative value is good")
def test_lnprob(self):
t = np.arange(0, 1, 0.01)
S = np.random.random(t.size)
theta = self.random_theta(4, 3)
kursl = KurSL(theta)
model = ModelWrapper(kursl)
self.assertTrue(
KurslMCMC.lnprob(theta, t, S[:-1], model) < 0,
"Any good theta should return negative value")
def test_initiation_with_model(self):
oscN = 3
nH = 1
params = self.generate_params(oscN, nH)
kursl = KurSL(params)
model = ModelWrapper(kursl)
self.assertEqual(model.model, kursl)
self.assertEqual(model.oscN, oscN)
self.assertEqual(model.nH, nH)
def test_lnprob_theta_outside_range(self):
t = np.arange(0, 1, 0.01)
S = np.random.random(t.size)
theta = self.random_theta(4, 3)
kursl = KurSL(theta)
model = ModelWrapper(kursl)
theta[0, 0] = model.MIN_W - 1
self.assertEqual(KurslMCMC.lnprob(theta, t, S[:-1], model), -np.inf,
"Inherit behaviour of lnprob and lnlikelihood")
def test_lnprior(self):
t = np.arange(0, 1, 0.01)
theta = self.random_theta(3, 2)
kursl = KurSL(theta)
model = ModelWrapper(kursl)
lnprob = KurslMCMC.lnprior(theta, model)
# Given default uniform probablities it's either 0 or -np.inf
self.assertEqual(np.round(lnprob, 10), 0,
"Theta within max ranges results in 0")
def test_set_model_after_initiation(self):
model = ModelWrapper()
oscN = 3
nH = 1
params = np.random.random(oscN * (3 + (oscN - 1) * nH)) + 1
params = params.reshape((oscN, -1))
kursl = KurSL(params)
model.set_model(kursl)
self.assertEqual(model.model, kursl)
self.assertEqual(model.oscN, oscN)
self.assertEqual(model.nH, nH)
def test_lnlikelihood_zero(self):
t = np.arange(0, 1, 0.01)
S = 2 * np.cos(10 * t + 0) + 6 * np.cos(20 * t + 4)
theta = np.array([
[10, 0, 2, 0],
[20, 4, 6, 0],
])
kursl = KurSL(theta)
model = ModelWrapper(kursl)
lnlikelihood = KurslMCMC.lnlikelihood(theta, t, S[:-1], model)
self.assertEqual(np.round(lnlikelihood, 10), 0,
"Exact reconstruction should return 0")
self.assertTrue(model.THRESHOLD_OBTAINED, "0 is below any threshold")
def test_correct_parameter_initiation(self):
oscN = 3
nH = 2
# W Ph A| K1 | K2
P = [
[11, 0, 1, 1, -1, 0.1, 2.3],
[20, 0.2, 2, 1, 2, 0.5, 3.1],
[29, 1.5, 2.5, 0.1, -1.7, -10, 0],
]
P = np.array(P)
kursl = KurSL(P)
self.assertEqual(kursl.oscN, oscN, "Number of oscillators")
self.assertEqual(kursl.nH, nH, "Order of model")
def test_lnprior_theta_outside_ranges(self):
t = np.arange(0, 1, 0.01)
S = np.random.random(t.size)
theta = self.random_theta(3, 2)
kursl = KurSL(theta)
model = ModelWrapper(kursl)
new_theta = theta.copy()
new_theta[0, 2] = model.MIN_R - 1
self.assertEqual(KurslMCMC.lnprior(new_theta, model), -np.inf)
new_theta[0, 2] = model.MAX_R + 1
self.assertEqual(KurslMCMC.lnprior(new_theta, model), -np.inf)
new_theta = theta.copy()
new_theta[1, 0] = model.MIN_W - 1
self.assertEqual(KurslMCMC.lnprior(new_theta, model), -np.inf)
new_theta[1, 0] = model.MAX_W + 1
self.assertEqual(KurslMCMC.lnprior(new_theta, model), -np.inf)
# Check for W_i < sum_j (|k_ij|)
new_theta = theta.copy()
new_theta[2, 0] = np.sum(new_theta[2, 3:]) * 0.6
self.assertEqual(KurslMCMC.lnprior(new_theta, model), -np.inf)
#oscN = 3
#nH = 2
F = [3., 5, 10]
W = np.array([f * 2 * np.pi for f in F])
R = np.array([1, 2, 1])
Y = np.array([0, 0.5, np.pi])
K = np.array([
[2.1, 3.2, -2.5, 1.2],
[-1.2, 0.3, -6.1, -5.2],
[7.9, 3.4, 0.1, 4.2],
])
params = np.column_stack((W, Y, R, K))
kursl = KurSL(params)
phase, amp, signals = kursl.generate(t)
# Precalculate Fourier transform parameters
freq = np.fft.fftfreq(len(t) - 1, dt)
idx = np.r_[freq >= 0] & np.r_[freq < 20]
f, axes = plt.subplots(3, 2, figsize=(8, 8))
for osc in range(len(W)):
ax = axes[osc, 0]
ax.plot(t[:-1], signals[osc], 'b')
ax.plot(t[:-1], amp[osc], 'r')
ax.plot(t[:-1], -amp[osc], 'r')
if osc == 0:
ax.set_title("Time series")
R_MIN, R_MAX = 0, 5
K_MIN, K_MAX = -5, 5
# Making sure that there's W_MIN_DIFF between all W
while True:
W = np.random.random(oscN) * W_MAX + W_MIN
if np.all(np.diff(W) > W_MIN_DIFF): break
R = np.random.random(oscN) * R_MAX + R_MIN
Y0 = np.random.random(oscN) * Y_MAX + Y_MIN
K = np.random.random((oscN, nH * (oscN - 1))) * K_MAX + K_MIN
K[:] = 0.8 * W[:, None] * K / np.sum(K, axis=1)[:, None]
theta = np.column_stack((W, Y0, R, K))
kursl = KurSL(theta)
_, _, s_gen = kursl.generate(t)
s_gen = np.sum(s_gen, axis=0)
t = t[:-1]
####################################################
## Estimate peaks present in signal
preprocess = Preprocessor(max_osc=oscN, nH=nH)
theta_init = preprocess.compute_prior(t, s_gen)
peaks = theta_init[:, 0] * 0.5 / np.pi
####################################################
## Plot extracted frequencies in spectrum
plt.figure()
freq = np.fft.fftfreq(len(t), dt)