def test_weighted():
np.random.seed(1234)
t = np.arange(100)
y0 = (+0.4 * (t >= 5) + 0.9 * (t >= 10) - 0.2 * (t >= 20) + 0.2 *
(t >= 50) + 1.1 * (t >= 70))
y = y0 + 0.05 * np.random.rand(y0.size)
y = y.tolist()
w = [1] * len(y)
y[15] = 2
right, values, dists = solve_potts(y, w=w, gamma=0.1)
assert right == [5, 10, 15, 16, 20, 50, 70, 100]
steps = detect_steps(y, w=w)
steps_pos = [s[0] for s in steps]
assert steps_pos == [0, 5, 10, 15, 16, 20, 50, 70]
w[15] = 0.1
right, values, dists = solve_potts(y, w=w, gamma=0.1)
assert right == [5, 10, 20, 50, 70, 100]
steps = detect_steps(y, w=w)
steps_pos = [s[0] for s in steps]
assert steps_pos == [0, 5, 10, 20, 50, 70]
# Missing weights and data should be handled properly
y[35] = None
w[23] = None
steps = detect_steps(y, w=w)
steps_pos = [s[0] for s in steps]
assert steps_pos == [0, 5, 10, 20, 50, 70]
def test_solve_potts(use_rangemedian):
np.random.seed(1234)
# Easy case, exact solver
y = [1, 1, 1, 2, 2, 2, 3, 3, 3]
right, values, dists = solve_potts(y, w=[1]*len(y), gamma=0.1)
assert right == [3, 6, 9]
assert np.allclose(values, [1, 2, 3], atol=0)
right, values, dists = solve_potts(y, w=[1]*len(y), gamma=8.0)
assert right == [9]
assert np.allclose(values, [2], atol=0)
# l1 norm
right, values, dists = solve_potts(y, w=[1]*len(y), gamma=0.1)
assert right == [3, 6, 9]
assert np.allclose(values, [1, 2, 3], atol=0)
# Bigger case, exact solver
t = np.arange(100)
y0 = (+ 0.4 * (t >= 5)
+ 0.9 * (t >= 10)
- 0.2 * (t >= 20)
+ 0.2 * (t >= 50)
+ 1.1 * (t >= 70))
y = y0 + 0.05 * np.random.rand(y0.size)
right, values, dists = solve_potts(y.tolist(), w=[1]*len(y), gamma=0.1)
assert right == [5, 10, 20, 50, 70, 100]
# Bigger case, approximative solver
right, values, dists = solve_potts_approx(y.tolist(), w=[1]*len(y), gamma=0.1)
assert right == [5, 10, 20, 50, 70, 100]
# Larger case
t = np.arange(3000)
y0 = (+ 0.4 * (t >= 10)
+ 0.9 * (t >= 30)
- 0.2 * (t >= 200)
+ 0.2 * (t >= 600)
+ 1.1 * (t >= 2500)
- 0.5 * (t >= 2990))
# Small amount of noise shouldn't disturb step finding
y = y0 + 0.05 * np.random.randn(y0.size)
right, values, dists, gamma = solve_potts_autogamma(y.tolist(), w=[1]*len(y))
assert right == [10, 30, 200, 600, 2500, 2990, 3000]
# Large noise should prevent finding any steps
y = y0 + 5.0 * np.random.randn(y0.size)
right, values, dists, gamma = solve_potts_autogamma(y.tolist(), w=[1]*len(y))
assert right == [3000]
# The routine shouldn't choke on datasets with 10k points.
# Appending noisy data to weakly noisy data should retain the
# steps in the former
y = y0 + 0.025 * np.random.rand(y.size)
ypad = 0.025 * np.random.randn(10000 - 3000)
right, values, dists, gamma = solve_potts_autogamma(y.tolist() + ypad.tolist(),
w=[1]*(len(y)+len(ypad)))
assert right == [10, 30, 200, 600, 2500, 2990, 3000, 10000]
def test_solve_potts(use_rangemedian):
np.random.seed(1234)
# Easy case, exact solver
y = [1, 1, 1, 2, 2, 2, 3, 3, 3]
right, values, dists = solve_potts(y, w=[1]*len(y), gamma=0.1)
assert right == [3, 6, 9]
assert np.allclose(values, [1, 2, 3], atol=0)
right, values, dists = solve_potts(y, w=[1]*len(y), gamma=8.0)
assert right == [9]
assert np.allclose(values, [2], atol=0)
# l1 norm
right, values, dists = solve_potts(y, w=[1]*len(y), gamma=0.1)
assert right == [3, 6, 9]
assert np.allclose(values, [1, 2, 3], atol=0)
# Bigger case, exact solver
t = np.arange(100)
y0 = (+ 0.4 * (t >= 5)
+ 0.9 * (t >= 10)
- 0.2 * (t >= 20)
+ 0.2 * (t >= 50)
+ 1.1 * (t >= 70))
y = y0 + 0.05 * np.random.rand(y0.size)
right, values, dists = solve_potts(y.tolist(), w=[1]*len(y), gamma=0.1)
assert right == [5, 10, 20, 50, 70, 100]
# Bigger case, approximative solver
right, values, dists = solve_potts_approx(y.tolist(), w=[1]*len(y), gamma=0.1)
assert right == [5, 10, 20, 50, 70, 100]
# Larger case
t = np.arange(3000)
y0 = (+ 0.4 * (t >= 10)
+ 0.9 * (t >= 30)
- 0.2 * (t >= 200)
+ 0.2 * (t >= 600)
+ 1.1 * (t >= 2500)
- 0.5 * (t >= 2990))
# Small amount of noise shouldn't disturb step finding
y = y0 + 0.05 * np.random.randn(y0.size)
right, values, dists, gamma = solve_potts_autogamma(y.tolist(), w=[1]*len(y))
assert right == [10, 30, 200, 600, 2500, 2990, 3000]
# Large noise should prevent finding any steps
y = y0 + 5.0 * np.random.randn(y0.size)
right, values, dists, gamma = solve_potts_autogamma(y.tolist(), w=[1]*len(y))
assert right == [3000]
# The routine shouldn't choke on datasets with 10k points.
# Appending noisy data to weakly noisy data should retain the
# steps in the former
y = y0 + 0.025 * np.random.rand(y.size)
ypad = 0.025 * np.random.randn(10000 - 3000)
right, values, dists, gamma = solve_potts_autogamma(y.tolist() + ypad.tolist(),
w=[1]*(len(y)+len(ypad)))
assert right == [10, 30, 200, 600, 2500, 2990, 3000, 10000]
def test_solve_potts_approx_bug():
y = [2.9, 3.1, 3.1, 3.1, 3.1, 3.1, 3.1, 3.1, 3.1, 3.1, 3.1, 3.1,
3.1, 3.1, 3.1, 3.1, 3.1, 3.1, 3.1, 3.1, 3.1, 3.1, 3.1, 3.1, 3.1,
3.1, 3.1, 3.1, 3.1, 3.1, 3.1, 3.1, 3.1, 3.2, 3.1, 3.1, 3.1, 3.1,
3.1, 3.1, 3.1, 3.1, 2.9, 3.1, 3.1, 3.1, 3.1, 3.1, 3.1, 3.1]
w = [86.1, 1.0, 1.0, 1.0, 0.8, 1.0, 0.8, 1.0, 1.0, 0.9, 0.9, 1.0,
0.8, 1.0, 1.0, 1.0, 1.0, 0.9, 0.6, 0.9, 0.5, 1.0, 1.0, 1.0, 1.0,
1.0, 1.0, 1.0, 1.0, 1.0, 0.9, 1.0, 1.0, 0.7, 1.0, 1.0, 1.0, 1.0,
1.0, 1.0, 0.8, 0.8, 50.0, 0.8, 1.0, 1.0, 0.6, 0.8, 1.0, 1.0]
gamma = 0.3
r0, v0, d0 = solve_potts(y, w, gamma=gamma)
r, v, d = solve_potts_approx(y, w, gamma=gamma)
assert r == r0
def test_weighted():
np.random.seed(1234)
t = np.arange(100)
y0 = (+ 0.4 * (t >= 5)
+ 0.9 * (t >= 10)
- 0.2 * (t >= 20)
+ 0.2 * (t >= 50)
+ 1.1 * (t >= 70))
y = y0 + 0.05 * np.random.rand(y0.size)
y = y.tolist()
w = [1]*len(y)
y[15] = 2
right, values, dists = solve_potts(y, w=w, gamma=0.1)
assert right == [5, 10, 15, 16, 20, 50, 70, 100]
steps = detect_steps(y, w=w)
steps_pos = [s[0] for s in steps]
assert steps_pos == [0, 5, 10, 15, 16, 20, 50, 70]
w[15] = 0.1
right, values, dists = solve_potts(y, w=w, gamma=0.1)
assert right == [5, 10, 20, 50, 70, 100]
steps = detect_steps(y, w=w)
steps_pos = [s[0] for s in steps]
assert steps_pos == [0, 5, 10, 20, 50, 70]
# Missing weights and data should be handled properly
y[35] = None
w[23] = None
steps = detect_steps(y, w=w)
steps_pos = [s[0] for s in steps]
assert steps_pos == [0, 5, 10, 20, 50, 70]
