def _find_sections_with_no_target(self): """Finds the intersections of the mains good sections with the gaps between target appliance activations. """ self.sections_with_no_target = {} seq_length_secs = self.seq_length * self.sample_period for fold, sects_per_building in self.mains_good_sections.items(): for building, good_sections in sects_per_building.items(): activations = ( self.activations[fold][self.target_appliance][building]) mains = self.mains[fold][building] mains_good_sections = self.mains_good_sections[fold][building] gaps_between_activations = TimeFrameGroup() prev_end = mains.index[0] for activation in activations: gap = TimeFrame(prev_end, activation.index[0]) gaps_between_activations.append(gap) prev_end = activation.index[-1] gap = TimeFrame(prev_end, mains.index[-1]) gaps_between_activations.append(gap) intersection = ( gaps_between_activations.intersection(mains_good_sections)) intersection = intersection.remove_shorter_than( seq_length_secs) self.sections_with_no_target.setdefault( fold, {})[building] = (intersection) logger.info( "Found {} sections without target for {} {}.".format( len(intersection), fold, building))
def _find_sections_with_no_target(self): """Finds the intersections of the mains good sections with the gaps between target appliance activations. """ self.sections_with_no_target = {} seq_length_secs = self.seq_length * self.sample_period for fold, sects_per_building in self.data_good_sections.items(): for building, good_sections in sects_per_building.items(): if building not in self.all_activations[fold][self.target_appliance]: continue activations = ( self.all_activations[fold][self.target_appliance][building]) data = self.data[fold][building] data_good_sections = good_sections gaps_between_activations = TimeFrameGroup() prev_end = data.index[0] for activation in activations: activation_start = activation.start if prev_end < activation_start: gap = TimeFrame(prev_end, activation_start) gaps_between_activations.append(gap) prev_end = activation.end data_end = data.index[-1] if prev_end < data_end: gap = TimeFrame(prev_end, data_end) gaps_between_activations.append(gap) intersection = ( gaps_between_activations.intersection(data_good_sections)) intersection = intersection.remove_shorter_than( seq_length_secs) self.sections_with_no_target.setdefault(fold, {})[building] = ( intersection) logger.info("Found {} sections without target for {} {}." .format(len(intersection), fold, building))
def _delete_phony_sections(self): filtered_data = {} for fold, data_per_building in self.data.items(): for building, data in data_per_building.items(): if building not in self.phony_active_timeframes[fold][self.target_appliance]: continue activations = ( self.phony_active_timeframes[fold][self.target_appliance][building]) data_between_phony_activations = TimeFrameGroup() prev_end = data.index[0] for activation in activations: activation_start = activation.start if prev_end < activation_start: gap = TimeFrame(prev_end, activation_start) data_between_phony_activations.append(gap) prev_end = activation.end data_end = data.index[-1] + pd.Timedelta(seconds=self.sample_period) if prev_end < data_end: gap = TimeFrame(prev_end, data_end) data_between_phony_activations.append(gap) dfs = [] for section in data_between_phony_activations: dfs.append(section.slice(data)) data = pd.concat(dfs) filtered_data.setdefault(fold, {})[building] = ( data) logger.info("Found {} good sections for {} {}." .format(len(data_between_phony_activations), fold, building)) self.data = filtered_data
def _find_sections_with_no_target(self): """Finds the intersections of the mains good sections with the gaps between target appliance activations. """ self.sections_with_no_target = {} seq_length_secs = self.seq_length * self.sample_period for fold, sects_per_building in self.mains_good_sections.iteritems(): for building, good_sections in sects_per_building.iteritems(): activations = ( self.activations[fold][self.target_appliance][building]) mains = self.mains[fold][building] mains_good_sections = self.mains_good_sections[fold][building] gaps_between_activations = TimeFrameGroup() prev_end = mains.index[0] for activation in activations: gap = TimeFrame(prev_end, activation.index[0]) gaps_between_activations.append(gap) prev_end = activation.index[-1] gap = TimeFrame(prev_end, mains.index[-1]) gaps_between_activations.append(gap) intersection = ( gaps_between_activations.intersection(mains_good_sections)) intersection = intersection.remove_shorter_than( seq_length_secs) self.sections_with_no_target.setdefault(fold, {})[building] = ( intersection) logger.info("Found {} sections without target for {} {}." .format(len(intersection), fold, building))
def _classify_activation_quality(self, nilmtk_activations): def get_stale_seconds(act): actdiff = act.resample("{:d}S".format(self.sample_period)).mean().ffill().diff() return (actdiff == 0.0).sum() * self.sample_period def activation_filter(tf, building_data): start_time = tf.start end_time = tf.end df = building_data[start_time:end_time] if df.empty: return False else: act_stale_seconds = get_stale_seconds(df['target']) act_duration = (end_time - start_time).total_seconds() act_stale_pct = act_stale_seconds / act_duration mains_stale_seconds = get_stale_seconds(df['mains']) mains_stale_pct = get_stale_seconds(df['mains']) / act_duration if (act_stale_pct < self.activation_max_stale_pct) & (mains_stale_pct < self.mains_max_stale_pct): return True else: return False good_timeframes = {} bad_timeframes = {} all_timeframes = {} for fold, buildings_per_appliances in nilmtk_activations.items(): good_timeframes[fold] = {} bad_timeframes[fold] = {} all_timeframes[fold] = {} for appliance, activations_per_building in buildings_per_appliances.items(): good_timeframes[fold][appliance] = {} bad_timeframes[fold][appliance] = {} all_timeframes[fold][appliance] = {} for building, activations in activations_per_building.items(): building_data = self.data[fold][building] good_timeframes_per_building = TimeFrameGroup() bad_timeframes_per_building = TimeFrameGroup() all_timeframes_per_building = TimeFrameGroup() for i, activation in enumerate(activations): tf = TimeFrame( start=activation.index[0], end=activation.index[-1] + pd.Timedelta(seconds=self.sample_period)) all_timeframes_per_building.append(tf) if activation_filter(tf, building_data): good_timeframes_per_building.append(tf) else: bad_timeframes_per_building.append(tf) good_timeframes[fold][appliance][building] = good_timeframes_per_building bad_timeframes[fold][appliance][building] = bad_timeframes_per_building all_timeframes[fold][appliance][building] = all_timeframes_per_building # self.clean_active_timeframes = good_timeframes self.all_active_timeframes = all_timeframes self.phony_active_timeframes = bad_timeframes
def __init__(self, **config): if 'filename' not in config.keys(): self.dataSet = nilmtk.DataSet("ukdale.h5") else: self.dataSet = nilmtk.DataSet(config['fileName']) if 'startTime' not in config.keys() or 'endTime' not in config.keys(): self.dataSet.set_window("2012-11-01", "2015-01-31") else: self.dataSet.set_window(config['startTime'], config['endTime']) if 'trainBuildings' not in config.keys(): self.trainBuildings = [1, 3, 4, 5] else: self.trainBuildings = config['trainBuildings'] if 'testBuildings' not in config.keys(): self.testBuildings = [2] else: self.testBuildings = config['testBuildings'] if 'applications' not in config.keys(): raise KeyError("please input applications") self.applications = config['applications'] if 'targetapplication' not in config.keys(): raise KeyError("please input targetapplication") self.targetApplication = config['targetapplication'] if 'randSeed' not in config.keys(): randSeed = 0 else: randSeed = config['randSeed'] self.otherApplications = [ i for i in self.applications if i not in [self.targetApplication] ] self.allBuildings = set(self.trainBuildings + self.testBuildings) self.window = 599 self.inputSeqs = [] self.targetSeqs = [] self.rng = np.random.RandomState(randSeed) activationConfig = { 'fridge': { 'min_off_duration': 18, # 12 in paper here 'min_on_duration': 60, 'on_power_threshold': 50, 'sample_period': 6, }, 'kettle': { 'min_off_duration': 18, # 0 in paper here 'min_on_duration': 12, 'on_power_threshold': 2000, 'sample_period': 6, }, 'washing machine': { 'min_off_duration': 160, 'min_on_duration': 1800, 'on_power_threshold': 20, 'sample_period': 6, }, 'microwave': { 'min_off_duration': 30, 'min_on_duration': 12, 'on_power_threshold': 200, 'sample_period': 6, }, 'dish washer': { 'min_off_duration': 1800, 'min_on_duration': 1800, 'on_power_threshold': 10, 'sample_period': 6, } } self.elecMains = {} self.goodSections = {} for building in self.allBuildings: self.goodSections[building] = self.dataSet.buildings[ building].elec.mains().good_sections() self.elecMains[building] = self.dataSet.buildings[ building].elec.mains().power_series_all_data( sample_period=6, sections=self.goodSections[building]).dropna() self.numApp = {} self.elecApp = {} self.activationsApp = {} self.activationAppSections = {} for app in self.applications: self.elecApp[app] = {} self.activationsApp[app] = {} self.numApp[app] = 0 self.activationAppSections[app] = {} for building in self.allBuildings: try: self.elecApp[app][building] = self.dataSet.buildings[ building].elec[app].power_series_all_data( sample_period=6).dropna() self.activationsApp[app][ building] = self.dataSet.buildings[building].elec[ app].get_activations(**activationConfig[app]) self.activationsApp[app][building] = [ activation.astype(np.float32) for activation in self.activationsApp[app][building] ] self.numApp[app] += len(self.activationsApp[app][building]) self.activationAppSections[app][building] = TimeFrameGroup( ) for activation in self.activationsApp[app][building]: self.activationAppSections[app][building].append( TimeFrame(activation.index[0], activation.index[-1])) except KeyError as exception: logger.info( str(building) + " has no " + app + ". Full exception: {}".format(exception)) continue logger.info("Done loading NILMTK data.") for building in self.allBuildings: activationsToRemove = [] try: activations = self.activationsApp[ self.targetApplication][building] mains = self.elecMains[building] for i, activation in enumerate(activations): activationDuration = (activation.index[-1] - activation.index[0]) start = (activation.index[0] - activationDuration) end = (activation.index[-1] + activationDuration) if start < mains.index[0] or end > mains.index[-1]: activationsToRemove.append(i) else: mainsForAct = mains[start:end] if not self._hasSufficientSamples( start, end, mainsForAct): activationsToRemove.append(i) activationsToRemove.reverse() for i in activationsToRemove: activations.pop(i) self.activationsApp[ self.targetApplication][building] = activations except KeyError as exception: continue self.sectionsWithNoTarget = {} for building in self.allBuildings: try: activationsTarget = self.activationsApp[ self.targetApplication][building] mainGoodSections = self.goodSections[building] mains = self.elecMains[building] gapsBetweenActivations = TimeFrameGroup() prev = mains.index[0] for activation in activationsTarget: try: p2 = prev gapsBetweenActivations.append( TimeFrame(prev, activation.index[0])) prev = activation.index[-1] p1 = activation.index[0] except ValueError: logger.debug("----------------------") logger.debug(p1) logger.debug(p2) logger.debug(activation.index[0]) logger.debug(activation.index[-1]) gapsBetweenActivations.append(TimeFrame(prev, mains.index[-1])) intersection = gapsBetweenActivations.intersection( mainGoodSections) intersection = intersection.remove_shorter_than(6 * self.window) self.sectionsWithNoTarget[building] = intersection except KeyError: continue