def test_get_convolve_empty_data(self):
     data = []
     pattern_index = []
     window_size = 2
     window_size_zero = 0
     av_model = []
     result = []
     self.assertEqual(utils.get_convolve(pattern_index, av_model, data, window_size), result)
     self.assertEqual(utils.get_convolve(pattern_index, av_model, data, window_size_zero), result)
Beispiel #2
0
 def test_get_convolve_wrong_index(self):
     data = [1.0, 5.0, 2.0, 1.0, 6.0, 2.0]
     data = pd.Series(data)
     segemnts = [1, 11]
     av_model = [0.0, 4.0, 0.0]
     window_size = 1
     try:
         utils.get_convolve(segemnts, av_model, data, window_size)
     except ValueError:
         self.fail('Method get_convolve raised unexpectedly')
    def do_fit(
        self,
        dataframe: pd.DataFrame,
        labeled_segments: List[AnalyticSegment],
        deleted_segments: List[AnalyticSegment],
        learning_info: LearningInfo
    ) -> None:
        data = utils.cut_dataframe(dataframe)
        data = data['value']
        self.state.pattern_center = list(set(self.state.pattern_center + learning_info.segment_center_list))
        self.state.pattern_model = utils.get_av_model(learning_info.patterns_list)
        convolve_list = utils.get_convolve(self.state.pattern_center, self.state.pattern_model, data, self.state.window_size)
        correlation_list = utils.get_correlation(self.state.pattern_center, self.state.pattern_model, data, self.state.window_size)
        height_list = learning_info.patterns_value

        del_conv_list = []
        delete_pattern_width = []
        delete_pattern_height = []
        delete_pattern_timestamp = []
        for segment in deleted_segments:
            delete_pattern_timestamp.append(segment.pattern_timestamp)
            deleted = utils.get_interval(data, segment.center_index, self.state.window_size)
            deleted = utils.subtract_min_without_nan(deleted)
            del_conv = scipy.signal.fftconvolve(deleted, self.state.pattern_model)
            if len(del_conv):
                del_conv_list.append(max(del_conv))
            delete_pattern_height.append(utils.find_confidence(deleted)[1])

        self._update_fiting_result(self.state, learning_info.confidence, convolve_list, del_conv_list, height_list)
Beispiel #4
0
    def do_fit(self, dataframe: pd.DataFrame, labeled_segments: list,
               deleted_segments: list, learning_info: dict) -> None:
        data = utils.cut_dataframe(dataframe)
        data = data['value']
        window_size = self.state['WINDOW_SIZE']
        last_pattern_center = self.state.get('pattern_center', [])
        self.state['pattern_center'] = list(
            set(last_pattern_center + learning_info['segment_center_list']))
        self.state['pattern_model'] = utils.get_av_model(
            learning_info['patterns_list'])
        convolve_list = utils.get_convolve(self.state['pattern_center'],
                                           self.state['pattern_model'], data,
                                           window_size)
        correlation_list = utils.get_correlation(self.state['pattern_center'],
                                                 self.state['pattern_model'],
                                                 data, window_size)
        height_list = learning_info['patterns_value']

        del_conv_list = []
        delete_pattern_width = []
        delete_pattern_height = []
        delete_pattern_timestamp = []
        for segment in deleted_segments:
            del_min_index = segment.center_index
            delete_pattern_timestamp.append(segment.pattern_timestamp)
            deleted = utils.get_interval(data, del_min_index, window_size)
            deleted = utils.subtract_min_without_nan(deleted)
            del_conv = scipy.signal.fftconvolve(deleted,
                                                self.state['pattern_model'])
            if len(del_conv): del_conv_list.append(max(del_conv))
            delete_pattern_height.append(utils.find_confidence(deleted)[1])
            delete_pattern_width.append(utils.find_width(deleted, False))

        self._update_fiting_result(self.state, learning_info['confidence'],
                                   convolve_list, del_conv_list, height_list)
Beispiel #5
0
    def do_fit(self, dataframe: pd.DataFrame,
               labeled_segments: List[AnalyticSegment],
               deleted_segments: List[AnalyticSegment],
               learning_info: LearningInfo) -> None:
        data = utils.cut_dataframe(dataframe)
        data = data['value']
        last_pattern_center = self.state.pattern_center
        self.state.pattern_center = utils.remove_duplicates_and_sort(
            last_pattern_center + learning_info.segment_center_list)
        self.state.pattern_model = utils.get_av_model(
            learning_info.patterns_list)
        convolve_list = utils.get_convolve(self.state.pattern_center,
                                           self.state.pattern_model, data,
                                           self.state.window_size)
        correlation_list = utils.get_correlation(self.state.pattern_center,
                                                 self.state.pattern_model,
                                                 data, self.state.window_size)

        del_conv_list = []
        delete_pattern_timestamp = []
        for segment in deleted_segments:
            del_mid_index = segment.center_index
            delete_pattern_timestamp.append(segment.pattern_timestamp)
            deleted_pat = utils.get_interval(data, del_mid_index,
                                             self.state.window_size)
            deleted_pat = utils.subtract_min_without_nan(deleted_pat)
            del_conv_pat = scipy.signal.fftconvolve(deleted_pat,
                                                    self.state.pattern_model)
            if len(del_conv_pat): del_conv_list.append(max(del_conv_pat))

        self.state.convolve_min, self.state.convolve_max = utils.get_min_max(
            convolve_list, self.state.window_size / 3)
        self.state.conv_del_min, self.state.conv_del_max = utils.get_min_max(
            del_conv_list, self.state.window_size)
 def test_get_convolve(self):
     data = [1, 2, 3, 2, 2, 0, 2, 3, 4, 3, 2, 1, 1, 2, 3, 4, 3, 2, 0]
     data = pd.Series(data)
     pattern_index = [2, 8, 15]
     window_size = 2
     av_model = [1, 2, 3, 2, 1]
     result = []
     self.assertNotEqual(utils.get_convolve(pattern_index, av_model, data, window_size), result)
 def test_get_convolve_with_nan(self):
     data = [1, 2, 3, 2, np.NaN, 0, 2, 3, 4, np.NaN, 2, 1, 1, 2, 3, 4, 3, np.NaN, 0]
     data = pd.Series(data)
     pattern_index = [2, 8, 15]
     window_size = 2
     av_model = [1, 2, 3, 2, 1]
     result = utils.get_convolve(pattern_index, av_model, data, window_size)
     for val in result:
         self.assertFalse(np.isnan(val))
    def do_fit(self, dataframe: pd.DataFrame, labeled_segments: list, deleted_segments: list, learning_info: dict) -> None:
        data = utils.cut_dataframe(dataframe)
        data = data['value']
        last_pattern_center = self.state.get('pattern_center', [])
        self.state['pattern_center'] = list(set(last_pattern_center + learning_info['segment_center_list']))
        self.state['pattern_model'] = utils.get_av_model(learning_info['patterns_list'])
        convolve_list = utils.get_convolve(self.state['pattern_center'], self.state['pattern_model'], data, self.state['WINDOW_SIZE'])
        correlation_list = utils.get_correlation(self.state['pattern_center'], self.state['pattern_model'], data, self.state['WINDOW_SIZE'])

        del_conv_list = []
        delete_pattern_timestamp = []
        for segment in deleted_segments:
            del_mid_index = segment.center_index
            delete_pattern_timestamp.append(segment.pattern_timestamp)
            deleted_pat = utils.get_interval(data, del_mid_index, self.state['WINDOW_SIZE'])
            deleted_pat = utils.subtract_min_without_nan(deleted_pat)
            del_conv_pat = scipy.signal.fftconvolve(deleted_pat, self.state['pattern_model'])
            if len(del_conv_pat): del_conv_list.append(max(del_conv_pat))

        self.state['convolve_min'], self.state['convolve_max'] = utils.get_min_max(convolve_list, self.state['WINDOW_SIZE'] / 3)
        self.state['conv_del_min'], self.state['conv_del_max'] = utils.get_min_max(del_conv_list, self.state['WINDOW_SIZE'])
Beispiel #9
0
    def do_fit(self, dataframe: pd.DataFrame,
               labeled_segments: List[AnalyticSegment],
               deleted_segments: List[AnalyticSegment],
               learning_info: LearningInfo) -> None:
        data = utils.cut_dataframe(dataframe)
        data = data['value']
        window_size = self.state.window_size
        last_pattern_center = self.state.pattern_center
        self.state.pattern_center = utils.remove_duplicates_and_sort(
            last_pattern_center + learning_info.segment_center_list)
        self.state.pattern_model = utils.get_av_model(
            learning_info.patterns_list)
        convolve_list = utils.get_convolve(self.state.pattern_center,
                                           self.state.pattern_model, data,
                                           window_size)
        correlation_list = utils.get_correlation(self.state.pattern_center,
                                                 self.state.pattern_model,
                                                 data, window_size)
        height_list = learning_info.patterns_value

        del_conv_list = []
        delete_pattern_timestamp = []
        for segment in deleted_segments:
            segment_cent_index = segment.center_index
            delete_pattern_timestamp.append(segment.pattern_timestamp)
            deleted_stair = utils.get_interval(data, segment_cent_index,
                                               window_size)
            deleted_stair = utils.subtract_min_without_nan(deleted_stair)
            del_conv_stair = scipy.signal.fftconvolve(deleted_stair,
                                                      self.state.pattern_model)
            if len(del_conv_stair) > 0:
                del_conv_list.append(max(del_conv_stair))

        self._update_fitting_result(self.state, learning_info.confidence,
                                    convolve_list, del_conv_list)
        self.state.stair_height = int(
            min(learning_info.pattern_height, default=1))
        self.state.stair_length = int(
            max(learning_info.pattern_width, default=1))