def applyKalmanFilter(self):
        """
        Apply KalmanFilter for each 2nd level grid cell
        Note: If Kalman filter is NOT applied, the naive approach is already applied for 2nd time instances.
        :return:
        """

        # init Kalman filter
        kf = KalmanFilterPID(self.param)

        for x1 in range(len(self.root.children)):
            for y1 in range(len(self.root.children)):
                child_l1 = self.root.children[x1][y1]
                if child_l1.n_isLeaf or child_l1.children is None:
                    seq_l1 = child_l1.a_count
                    if self.sampling:
                        seq_l1_filtered = kf.kalmanFilter(seq_l1, self.budgetKF, self.param.samplingRate)
                    else:
                        seq_l1_filtered = kf.kalmanFilter(seq_l1, self.budgetKF)
                    child_l1.l_count = seq_l1_filtered

                else:
                    for x2 in range(len(child_l1.children)):
                        for y2 in range(len(child_l1.children)):
                            seq_l2 = self.root.children[x1][y1].children[x2][y2].a_count
                            if self.sampling:
                                seq_l2_filtered = kf.kalmanFilter(seq_l2, self.budgetKF, self.param.samplingRate)
                            else:
                                seq_l2_filtered = kf.kalmanFilter(seq_l2, self.budgetKF)
                            self.root.children[x1][y1].children[x2][y2].l_count = seq_l2_filtered
    def applyKalmanFilter(self):
        """
        Apply KalmanFilter for each 2nd level grid cell
        Note: If Kalman filter is NOT applied, the naive approach is already applied for 2nd time instances.
        :return:
        """

        # init Kalman filter
        kf = KalmanFilterPID(self.param)

        for x1 in range(len(self.AGs[0].root.children)):
            for y1 in range(len(self.AGs[0].root.children)):
                child_l1 = self.AGs[0].root.children[x1][y1]
                if child_l1.n_isLeaf or child_l1.children is None:
                    seq_l1 = [self.getCountAt(True, i, x1, y1) for i in range(self.instances)]
                    if self.sampling:
                        seq_l1_filtered = kf.kalmanFilter(seq_l1, self.budgetKF, self.param.samplingRate)
                    else:
                        seq_l1_filtered = kf.kalmanFilter(seq_l1, self.budgetKF)
                    [self.updateCountAt(seq_l1_filtered[i], i, x1, y1) for i in range(self.instances)]
                    del seq_l1
                    del seq_l1_filtered

                else:
                    for x2 in range(len(child_l1.children)):
                        for y2 in range(len(child_l1.children)):
                            # child_l2 = child_l1.children[x2][y2]
                            seq_l2 = [self.getCountAt(True, i, x1, y1, x2, y2) for i in range(self.instances)]
                            if self.sampling:
                                seq_l2_filtered = kf.kalmanFilter(seq_l2, self.budgetKF, self.param.samplingRate)
                            else:
                                seq_l2_filtered = kf.kalmanFilter(seq_l2, self.budgetKF)
                            [self.updateCountAt(seq_l2_filtered[i], i, x1, y1, x2, y2) for i in range(self.instances)]

                            del seq_l2
                            del seq_l2_filtered

        del kf
    def applyKalmanFilter(self):
        """
        Apply KalmanFilter for each 2nd level grid cell
        Note: If Kalman filter is NOT applied, the naive approach is already applied for 2nd time instances.
        :return:
        """

        # init Kalman filter
        kf = KalmanFilterPID(self.param)

        for x1 in range(len(self.AGs[0].root.children)):
            for y1 in range(len(self.AGs[0].root.children)):
                child_l1 = self.AGs[0].root.children[x1][y1]
                if child_l1.n_isLeaf or child_l1.children is None:
                    seq_l1 = [
                        self.getCountAt(True, i, x1, y1)
                        for i in range(self.instances)
                    ]
                    if self.sampling:
                        seq_l1_filtered = kf.kalmanFilter(
                            seq_l1, self.budgetKF, self.param.samplingRate)
                    else:
                        seq_l1_filtered = kf.kalmanFilter(
                            seq_l1, self.budgetKF)
                    [
                        self.updateCountAt(seq_l1_filtered[i], i, x1, y1)
                        for i in range(self.instances)
                    ]
                    del seq_l1
                    del seq_l1_filtered

                else:
                    for x2 in range(len(child_l1.children)):
                        for y2 in range(len(child_l1.children)):
                            # child_l2 = child_l1.children[x2][y2]
                            seq_l2 = [
                                self.getCountAt(True, i, x1, y1, x2, y2)
                                for i in range(self.instances)
                            ]
                            if self.sampling:
                                seq_l2_filtered = kf.kalmanFilter(
                                    seq_l2, self.budgetKF,
                                    self.param.samplingRate)
                            else:
                                seq_l2_filtered = kf.kalmanFilter(
                                    seq_l2, self.budgetKF)
                            [
                                self.updateCountAt(seq_l2_filtered[i], i, x1,
                                                   y1, x2, y2)
                                for i in range(self.instances)
                            ]

                            del seq_l2
                            del seq_l2_filtered

        del kf
Esempio n. 4
0
    def applyKalmanFilter(self):
        """
        Apply KalmanFilter for each 2nd level grid cell
        Note: If Kalman filter is NOT applied, the naive approach is already applied for 2nd time instances.
        :return:
        """

        # init Kalman filter
        kf = KalmanFilterPID(self.param)

        for x1 in range(len(self.root.children)):
            for y1 in range(len(self.root.children)):
                child_l1 = self.root.children[x1][y1]
                if child_l1.n_isLeaf or child_l1.children is None:
                    seq_l1 = child_l1.a_count
                    if self.sampling:
                        seq_l1_filtered = kf.kalmanFilter(
                            seq_l1, self.budgetKF, self.param.samplingRate)
                    else:
                        seq_l1_filtered = kf.kalmanFilter(
                            seq_l1, self.budgetKF)
                    child_l1.l_count = seq_l1_filtered

                else:
                    for x2 in range(len(child_l1.children)):
                        for y2 in range(len(child_l1.children)):
                            seq_l2 = self.root.children[x1][y1].children[x2][
                                y2].a_count
                            if self.sampling:
                                seq_l2_filtered = kf.kalmanFilter(
                                    seq_l2, self.budgetKF,
                                    self.param.samplingRate)
                            else:
                                seq_l2_filtered = kf.kalmanFilter(
                                    seq_l2, self.budgetKF)
                            self.root.children[x1][y1].children[x2][
                                y2].l_count = seq_l2_filtered
    error = 0
    for i in range(len(publish)):
        if orig[i] < 0:
            error += distance(publish[i], orig[i])
        elif orig[i] == 0:
            error += distance(publish[i], 1)
        else:
            error += distance(max(publish[i], 0), orig[i])
    return error / len(publish)


for q in q_list:
    for i in range(len(eps_list)):
        with open("../log/foursquare/true_count_KF_" + str(eps_list[i]) + ".log") as f:
            rel_errs = []
            for line in f.readlines():
                orig = map(float, line.strip().split("\t"))
                p = Params(1000)
                p.Eps = eps_list[i]

                kf = KalmanFilterPID(p)
                kf.setQ(q)
                budgetKF = budgetKF = eps_list[i] / 2
                # filter = kf.kalmanFilter(seq, budgetKF, p.samplingRate)
                publish = kf.kalmanFilter(orig, budgetKF)

                rel_err = getRelError(publish, orig)
                rel_errs.append(rel_err)

            print q, "\t", eps_list[i], "\t", sum(rel_errs) / len(rel_errs)