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
