def test_merge_timeframes(self):
tfs = [TimeFrame("2010-01-01", "2011-01-01"),
TimeFrame("2011-01-01", "2011-06-01"),
TimeFrame("2012-01-01", "2013-01-01")]
merged = merge_timeframes(tfs)
correct_answer = [TimeFrame("2010-01-01", "2011-06-01"),
TimeFrame("2012-01-01", "2013-01-01")]
self.assertEqual(merged, correct_answer)
def test_merge_timeframes(self):
tfs = [
TimeFrame("2010-01-01", "2011-01-01"),
TimeFrame("2011-01-01", "2011-06-01"),
TimeFrame("2012-01-01", "2013-01-01")
]
merged = merge_timeframes(tfs)
correct_answer = [
TimeFrame("2010-01-01", "2011-06-01"),
TimeFrame("2012-01-01", "2013-01-01")
]
self.assertEqual(merged, correct_answer)
def _save_metadata_for_disaggregation(
self,
output_datastore,
sample_period,
measurement,
timeframes,
building,
meters=None,
num_meters=None,
supervised=True,
):
"""Add metadata for disaggregated appliance estimates to datastore.
This method returns nothing. It sets the metadata
in `output_datastore`.
Note that `self.MODEL_NAME` needs to be set to a string before
calling this method. For example, we use `self.MODEL_NAME = 'CO'`
for Combinatorial Optimisation.
Parameters
----------
output_datastore : nilmtk.DataStore subclass object
The datastore to write metadata into.
sample_period : int
The sample period, in seconds, used for both the
mains and the disaggregated appliance estimates.
measurement : 2-tuple of strings
In the form (<physical_quantity>, <type>) e.g.
("power", "active")
timeframes : list of nilmtk.TimeFrames or nilmtk.TimeFrameGroup
The TimeFrames over which this data is valid for.
building : int
The building instance number (starting from 1)
supervised : bool, defaults to True
Is this a supervised NILM algorithm?
meters : list of nilmtk.ElecMeters, optional
Required if `supervised=True`
num_meters : int
Required if `supervised=False`
"""
# TODO: `preprocessing_applied` for all meters
# TODO: submeter measurement should probably be the mains
# measurement we used to train on, not the mains measurement.
# DataSet and MeterDevice metadata:
building_path = "/building{}".format(building)
mains_data_location = building_path + "/elec/meter1"
meter_devices = {
self.MODEL_NAME: {
"model": self.MODEL_NAME,
"sample_period": sample_period,
"max_sample_period": sample_period,
"measurements": [{"physical_quantity": measurement[0], "type": measurement[1]}],
},
"mains": {
"model": "mains",
"sample_period": sample_period,
"max_sample_period": sample_period,
"measurements": [{"physical_quantity": measurement[0], "type": measurement[1]}],
},
}
merged_timeframes = merge_timeframes(timeframes, gap=sample_period)
total_timeframe = TimeFrame(merged_timeframes[0].start, merged_timeframes[-1].end)
date_now = datetime.now().isoformat().split(".")[0]
dataset_metadata = {
"name": self.MODEL_NAME,
"date": date_now,
"meter_devices": meter_devices,
"timeframe": total_timeframe.to_dict(),
}
output_datastore.save_metadata("/", dataset_metadata)
# Building metadata
# Mains meter:
elec_meters = {
1: {
"device_model": "mains",
"site_meter": True,
"data_location": mains_data_location,
"preprocessing_applied": {}, # TODO
"statistics": {"timeframe": total_timeframe.to_dict()},
}
}
def update_elec_meters(meter_instance):
elec_meters.update(
{
meter_instance: {
"device_model": self.MODEL_NAME,
"submeter_of": 1,
"data_location": ("{}/elec/meter{}".format(building_path, meter_instance)),
"preprocessing_applied": {}, # TODO
"statistics": {"timeframe": total_timeframe.to_dict()},
}
}
)
# Appliances and submeters:
appliances = []
if supervised:
for meter in meters:
meter_instance = meter.instance()
update_elec_meters(meter_instance)
for app in meter.appliances:
appliance = {
"meters": [meter_instance],
"type": app.identifier.type,
"instance": app.identifier.instance
# TODO this `instance` will only be correct when the
# model is trained on the same house as it is tested on
# https://github.com/nilmtk/nilmtk/issues/194
}
appliances.append(appliance)
# Setting the name if it exists
if meter.name:
if len(meter.name) > 0:
elec_meters[meter_instance]["name"] = meter.name
else: # Unsupervised
# Submeters:
# Starts at 2 because meter 1 is mains.
for chan in range(2, num_meters + 2):
update_elec_meters(meter_instance=chan)
appliance = {
"meters": [chan],
"type": "unknown",
"instance": chan - 1
# TODO this `instance` will only be correct when the
# model is trained on the same house as it is tested on
# https://github.com/nilmtk/nilmtk/issues/194
}
appliances.append(appliance)
building_metadata = {"instance": building, "elec_meters": elec_meters, "appliances": appliances}
output_datastore.save_metadata(building_path, building_metadata)
def add_metadata(self, output_datastore, measurement, timeframes, mains, timezone, load_kwargs):
date_now = datetime.now().isoformat().split('.')[0]
output_name = load_kwargs.pop('output_name', 'NILMTK_CO_' + date_now)
resample_seconds = load_kwargs.pop('resample_seconds', 60)
building_path = '/building{}'.format(mains.building())
mains_data_location = '{}/elec/meter1'.format(building_path)
# DataSet and MeterDevice metadata:
meter_devices = {
'CO': {
'model': 'CO',
'sample_period': resample_seconds,
'max_sample_period': resample_seconds,
'measurements': [{
'physical_quantity': measurement[0],
'type': measurement[1]
}]
},
'mains': {
'model': 'mains',
'sample_period': resample_seconds,
'max_sample_period': resample_seconds,
'measurements': [{
'physical_quantity': measurement[0],
'type': measurement[1]
}]
}
}
merged_timeframes = merge_timeframes(timeframes, gap=resample_seconds)
total_timeframe = TimeFrame(merged_timeframes[0].start,
merged_timeframes[-1].end)
dataset_metadata = {'name': output_name, 'date': date_now,
'meter_devices': meter_devices,
'timeframe': total_timeframe.to_dict(),
'timezone': timezone}
output_datastore.save_metadata('/', dataset_metadata)
# Building metadata
# Mains meter:
elec_meters = {
1: {
'device_model': 'mains',
'site_meter': True,
'data_location': mains_data_location,
'preprocessing_applied': {}, # TODO
'statistics': {
'timeframe': total_timeframe.to_dict(),
'good_sections': list_of_timeframe_dicts(merged_timeframes)
}
}
}
# Appliances and submeters:
appliances = []
for model in self.model:
meter = model['training_metadata']
meter_instance = meter.instance()
for app in meter.appliances:
meters = app.metadata['meters']
appliance = {
'meters': [meter_instance],
'type': app.identifier.type,
'instance': app.identifier.instance
}
appliances.append(appliance)
elec_meters.update({
meter_instance: {
'device_model': 'CO',
'submeter_of': 1,
'data_location': ('{}/elec/meter{}'
.format(building_path, meter_instance)),
'preprocessing_applied': {}, # TODO
'statistics': {
'timeframe': total_timeframe.to_dict(),
'good_sections': list_of_timeframe_dicts(merged_timeframes)
}
}
})
#Setting the name if it exists
if meter.name:
if len(meter.name)>0:
elec_meters[meter_instance]['name'] = meter.name
building_metadata = {
'instance': mains.building(),
'elec_meters': elec_meters,
'appliances': appliances
}
output_datastore.save_metadata(building_path, building_metadata)
def add_metadata(self, output_datastore, measurement, timeframes, mains,
timezone, load_kwargs):
date_now = datetime.now().isoformat().split('.')[0]
output_name = load_kwargs.pop('output_name', 'NILMTK_CO_' + date_now)
resample_seconds = load_kwargs.pop('resample_seconds', 60)
building_path = '/building{}'.format(mains.building())
mains_data_location = '{}/elec/meter1'.format(building_path)
# DataSet and MeterDevice metadata:
meter_devices = {
'CO': {
'model':
'CO',
'sample_period':
resample_seconds,
'max_sample_period':
resample_seconds,
'measurements': [{
'physical_quantity': measurement[0],
'type': measurement[1]
}]
},
'mains': {
'model':
'mains',
'sample_period':
resample_seconds,
'max_sample_period':
resample_seconds,
'measurements': [{
'physical_quantity': measurement[0],
'type': measurement[1]
}]
}
}
merged_timeframes = merge_timeframes(timeframes, gap=resample_seconds)
total_timeframe = TimeFrame(merged_timeframes[0].start,
merged_timeframes[-1].end)
dataset_metadata = {
'name': output_name,
'date': date_now,
'meter_devices': meter_devices,
'timeframe': total_timeframe.to_dict(),
'timezone': timezone
}
output_datastore.save_metadata('/', dataset_metadata)
# Building metadata
# Mains meter:
elec_meters = {
1: {
'device_model': 'mains',
'site_meter': True,
'data_location': mains_data_location,
'preprocessing_applied': {}, # TODO
'statistics': {
'timeframe': total_timeframe.to_dict(),
'good_sections': list_of_timeframe_dicts(merged_timeframes)
}
}
}
# Appliances and submeters:
appliances = []
for model in self.model:
meter = model['training_metadata']
meter_instance = meter.instance()
for app in meter.appliances:
meters = app.metadata['meters']
appliance = {
'meters': [meter_instance],
'type': app.identifier.type,
'instance': app.identifier.instance
}
appliances.append(appliance)
elec_meters.update({
meter_instance: {
'device_model':
'CO',
'submeter_of':
1,
'data_location':
('{}/elec/meter{}'.format(building_path, meter_instance)),
'preprocessing_applied': {}, # TODO
'statistics': {
'timeframe': total_timeframe.to_dict(),
'good_sections':
list_of_timeframe_dicts(merged_timeframes)
}
}
})
#Setting the name if it exists
if meter.name:
if len(meter.name) > 0:
elec_meters[meter_instance]['name'] = meter.name
building_metadata = {
'instance': mains.building(),
'elec_meters': elec_meters,
'appliances': appliances
}
output_datastore.save_metadata(building_path, building_metadata)
def _save_metadata_for_disaggregation(self,
output_datastore,
sample_period,
measurement,
timeframes,
building,
meters=None,
num_meters=None,
supervised=True):
"""Add metadata for disaggregated appliance estimates to datastore.
This method returns nothing. It sets the metadata
in `output_datastore`.
Note that `self.MODEL_NAME` needs to be set to a string before
calling this method. For example, we use `self.MODEL_NAME = 'CO'`
for Combinatorial Optimisation.
Parameters
----------
output_datastore : nilmtk.DataStore subclass object
The datastore to write metadata into.
sample_period : int
The sample period, in seconds, used for both the
mains and the disaggregated appliance estimates.
measurement : 2-tuple of strings
In the form (<physical_quantity>, <type>) e.g.
("power", "active")
timeframes : list of nilmtk.TimeFrames or nilmtk.TimeFrameGroup
The TimeFrames over which this data is valid for.
building : int
The building instance number (starting from 1)
supervised : bool, defaults to True
Is this a supervised NILM algorithm?
meters : list of nilmtk.ElecMeters, optional
Required if `supervised=True`
num_meters : int
Required if `supervised=False`
"""
# TODO: `preprocessing_applied` for all meters
# TODO: submeter measurement should probably be the mains
# measurement we used to train on, not the mains measurement.
# DataSet and MeterDevice metadata:
building_path = '/building{}'.format(building)
mains_data_location = building_path + '/elec/meter1'
meter_devices = {
self.MODEL_NAME: {
'model':
self.MODEL_NAME,
'sample_period':
sample_period,
'max_sample_period':
sample_period,
'measurements': [{
'physical_quantity': measurement[0],
'type': measurement[1]
}]
},
'mains': {
'model':
'mains',
'sample_period':
sample_period,
'max_sample_period':
sample_period,
'measurements': [{
'physical_quantity': measurement[0],
'type': measurement[1]
}]
}
}
merged_timeframes = merge_timeframes(timeframes, gap=sample_period)
total_timeframe = TimeFrame(merged_timeframes[0].start,
merged_timeframes[-1].end)
date_now = datetime.now().isoformat().split('.')[0]
dataset_metadata = {
'name': self.MODEL_NAME,
'date': date_now,
'meter_devices': meter_devices,
'timeframe': total_timeframe.to_dict()
}
output_datastore.save_metadata('/', dataset_metadata)
# Building metadata
# Mains meter:
elec_meters = {
1: {
'device_model': 'mains',
'site_meter': True,
'data_location': mains_data_location,
'preprocessing_applied': {}, # TODO
'statistics': {
'timeframe': total_timeframe.to_dict()
}
}
}
def update_elec_meters(meter_instance):
elec_meters.update({
meter_instance: {
'device_model':
self.MODEL_NAME,
'submeter_of':
1,
'data_location':
('{}/elec/meter{}'.format(building_path, meter_instance)),
'preprocessing_applied': {}, # TODO
'statistics': {
'timeframe': total_timeframe.to_dict()
}
}
})
# Appliances and submeters:
appliances = []
if supervised:
for meter in meters:
meter_instance = meter.instance()
update_elec_meters(meter_instance)
for app in meter.appliances:
appliance = {
'meters': [meter_instance],
'type': app.identifier.type,
'instance': app.identifier.instance
# TODO this `instance` will only be correct when the
# model is trained on the same house as it is tested on
# https://github.com/nilmtk/nilmtk/issues/194
}
appliances.append(appliance)
# Setting the name if it exists
if meter.name:
if len(meter.name) > 0:
elec_meters[meter_instance]['name'] = meter.name
else: # Unsupervised
# Submeters:
# Starts at 2 because meter 1 is mains.
for chan in range(2, num_meters + 2):
update_elec_meters(meter_instance=chan)
appliance = {
'meters': [chan],
'type': 'unknown',
'instance': chan - 1
# TODO this `instance` will only be correct when the
# model is trained on the same house as it is tested on
# https://github.com/nilmtk/nilmtk/issues/194
}
appliances.append(appliance)
building_metadata = {
'instance': building,
'elec_meters': elec_meters,
'appliances': appliances
}
output_datastore.save_metadata(building_path, building_metadata)
