def test_block_entropy_base_4(self):
        self.assertAlmostEqual(2.500000,
                               block_entropy([3, 3, 3, 2, 1, 0, 0, 0, 1], 2),
                               places=6)

        self.assertAlmostEqual(2.405639,
                               block_entropy([2, 2, 3, 3, 3, 3, 2, 1, 0], 2),
                               places=6)
    def test_block_entropy_base_2_ensemble(self):
        xs = [[1, 1, 0, 0, 1, 0, 0, 1], [0, 0, 0, 1, 0, 0, 0, 1]]
        self.assertAlmostEqual(1.788450, block_entropy(xs, 2), places=6)

        xs = [[1, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 1, 1, 1, 1, 0, 0, 0],
              [1, 0, 0, 0, 0, 0, 0, 1, 1], [1, 0, 0, 0, 0, 0, 0, 1, 1],
              [0, 0, 0, 0, 0, 1, 1, 0, 0], [0, 0, 0, 0, 1, 1, 0, 0, 0],
              [1, 1, 1, 0, 0, 0, 0, 1, 1], [0, 0, 0, 1, 1, 1, 1, 0, 0],
              [0, 0, 0, 0, 0, 0, 1, 1, 0]]
        self.assertAlmostEqual(1.649204, block_entropy(xs, 2), places=6)
    def test_block_entropy_base_2(self):
        self.assertAlmostEqual(1.950212,
                               block_entropy([1, 1, 0, 0, 1, 0, 0, 1],
                                             2,
                                             local=True).mean(),
                               places=6)

        self.assertAlmostEqual(0.543564,
                               block_entropy([1, 0, 0, 0, 0, 0, 0, 0, 0],
                                             2,
                                             local=True).mean(),
                               places=6)

        self.assertAlmostEqual(1.811278,
                               block_entropy([0, 0, 1, 1, 1, 1, 0, 0, 0],
                                             2,
                                             local=True).mean(),
                               places=6)

        self.assertAlmostEqual(1.548795,
                               block_entropy([1, 0, 0, 0, 0, 0, 0, 1, 1],
                                             2,
                                             local=True).mean(),
                               places=6)

        self.assertAlmostEqual(1.548795,
                               block_entropy([0, 0, 0, 0, 0, 1, 1, 0, 0],
                                             2,
                                             local=True).mean(),
                               places=6)

        self.assertAlmostEqual(1.548795,
                               block_entropy([0, 0, 0, 0, 1, 1, 0, 0, 0],
                                             2,
                                             local=True).mean(),
                               places=6)

        self.assertAlmostEqual(1.811278,
                               block_entropy([1, 1, 1, 0, 0, 0, 0, 1, 1],
                                             2,
                                             local=True).mean(),
                               places=6)

        self.assertAlmostEqual(1.811278,
                               block_entropy([0, 0, 0, 1, 1, 1, 1, 0, 0],
                                             2,
                                             local=True).mean(),
                               places=6)

        self.assertAlmostEqual(1.548795,
                               block_entropy([0, 0, 0, 0, 0, 0, 1, 1, 0],
                                             2,
                                             local=True).mean(),
                               places=6)
Beispiel #4
0
def changepoint_detection(ts, percent=0.05, plot=True, num_c=4):
    length = len(ts)
    bar = int(percent * length)
    ts = np.array(ts)[bar:-bar]
    min_val, model = length, "l1"
    algo = rpt.Dynp(model="normal").fit(np.array(ts))
    dic = {"best": [0, length]}
    try:
        for i in range(num_c):
            my_bkps = algo.predict(n_bkps=i)
            if plot:
                rpt.show.display(np.array(ts), my_bkps, figsize=(10, 6))
                plt.show()
            start_borne, full_entro = 0, 0
            for end_borne in my_bkps:
                val = block_entropy(ts[start_borne:end_borne], k=1)
                full_entro = val + full_entro
                start_borne = end_borne
            if full_entro == 0: break
            elif full_entro < min_val:
                min_val = full_entro
                dic["best"] = [0] + my_bkps
            else:
                pass
    except Exception as e:
        print(e)
        print("Not enough point")
        return {"best": [0, length]}
    return dic
 def test_block_entropy_base_4_ensemble(self):
     xs = [[3, 3, 3, 2, 1, 0, 0, 0, 1], [2, 2, 3, 3, 3, 3, 2, 1, 0],
           [0, 0, 0, 0, 1, 1, 0, 0, 0], [1, 1, 0, 0, 0, 1, 1, 2, 2]]
     self.assertAlmostEqual(3.010977, block_entropy(xs, 2), places=6)
 def test_block_entropy_empty(self):
     with self.assertRaises(ValueError):
         block_entropy([], 1)
 def test_block_entropy_negative_states(self):
     with self.assertRaises(InformError):
         block_entropy([-1, 0, 0], k=3)
    def test_block_entropy_long_history(self):
        with self.assertRaises(InformError):
            block_entropy([1, 2], k=2)

        with self.assertRaises(InformError):
            block_entropy([1, 2], k=3)
 def test_block_entropy_zero_history(self):
     with self.assertRaises(InformError):
         block_entropy([1, 2], k=0)
 def test_block_entropy_short_series(self):
     with self.assertRaises(InformError):
         block_entropy([1], k=1)
 def test_block_entropy_dimensions(self):
     with self.assertRaises(ValueError):
         block_entropy([[[1]]], 1)