def partial_fit(self, train_main, train_appliances, **load_kwargs):
train_main = pd.concat(train_main, axis=0)
train_app_tmp = []
for app_name, df_list in train_appliances:
df_list = pd.concat(df_list, axis=0)
train_app_tmp.append((app_name,df_list))
train_appliances = train_app_tmp
print("...............CO partial_fit running.............")
num_on_states=None
if len(train_appliances)>12:
max_num_clusters=2
else:
max_num_clusters=3
appliance_in_model=[d['appliance_name'] for d in self.model]
for appliance,readings in train_appliances:
#print(appliance," ",readings)
if appliance in appliance_in_model:
# raise RuntimeError(
# "Appliance {} is already in model!"
# " Can't train twice on the same meter!",appliance)
print("Trained on " + appliance + " before.")
else:
states = cluster(readings, max_num_clusters, num_on_states)
self.model.append({
'states': states,
'appliance_name': appliance})
def train_centroid(self,
metergroup,
max_num_clusters=3,
resample_seconds=60,
centroids=None):
self.model = []
if centroids is None:
load_kwargs = {}
load_kwargs.setdefault('resample', True)
load_kwargs.setdefault('sample_period', resample_seconds)
for i, meter in enumerate(metergroup.submeters().meters):
print("Training model for submeter '{}'".format(meter))
for chunk in meter.power_series(**load_kwargs):
states = cluster(chunk, max_num_clusters)
self.model.append({
'states': states,
'training_metadata': meter
})
break
else:
for i, meter in enumerate(metergroup.submeters().meters):
print("Setting model for submeter '{}'".format(meter))
states = centroids[meter.instance()]
self.model.append({
'states': states,
'training_metadata': meter
})
print("Done training!")
def train_on_chunk(self, chunk, meter, max_num_clusters, num_on_states):
# Check if we've already trained on this meter
meters_in_model = [d["training_metadata"] for d in self.model]
if meter in meters_in_model:
raise RuntimeError("Meter {} is already in model!" " Can't train twice on the same meter!".format(meter))
states = cluster(chunk, max_num_clusters, num_on_states)
self.model.append({"states": states, "training_metadata": meter})
def train_on_chunk(self, chunk, meter, max_num_clusters, num_on_states):
# Check if we've already trained on this meter
meters_in_model = [d['training_metadata'] for d in self.model]
if meter in meters_in_model:
raise RuntimeError(
"Meter {} is already in model!"
" Can't train twice on the same meter!".format(meter))
states = cluster(chunk, max_num_clusters, num_on_states)
self.model.append({'states': states, 'training_metadata': meter})
def partial_fit(self, train_main, train_appliances, **load_kwargs):
train_main = pd.concat(train_main, axis=0)
train_app_tmp = []
for app_name, df_list in train_appliances:
df_list = pd.concat(df_list, axis=0)
train_app_tmp.append((app_name, df_list))
self.app_names.append(app_name)
train_appliances = train_app_tmp
learnt_model = OrderedDict()
num_meters = len(train_appliances)
if num_meters > 12:
max_num_clusters = 2
else:
max_num_clusters = 3
for appliance, meter in train_appliances:
meter_data = meter.dropna()
X = meter_data.values.reshape((-1, 1))
assert X.ndim == 2
self.X = X
if self.num_of_states > 0:
num_total_states = self.num_of_states
else:
states = cluster(meter_data, max_num_clusters)
num_total_states = len(states)
learnt_model[appliance] = hmm.GaussianHMM(num_total_states, "full")
learnt_model[appliance].fit(X)
self.meters = []
new_learnt_models = OrderedDict()
for meter in learnt_model:
startprob, means, covars, transmat = sort_learnt_parameters(
learnt_model[meter].startprob_, learnt_model[meter].means_,
learnt_model[meter].covars_, learnt_model[meter].transmat_)
new_learnt_models[meter] = hmm.GaussianHMM(startprob.size, "full")
new_learnt_models[meter].startprob_ = startprob
new_learnt_models[meter].transmat_ = transmat
new_learnt_models[meter].means_ = means
new_learnt_models[meter].covars_ = covars
self.meters.append(meter)
learnt_model_combined = create_combined_hmm(new_learnt_models)
self.individual = new_learnt_models
self.model = learnt_model_combined
def train_on_chunk(self, chunk, meter, max_num_clusters, num_on_states):
'''
Parameters
----------
chunk : The powerline
meter: The meter object
max_num_clusters : The amount of clusters to check for
num_on_states : The amount of states which are considered for a single appliance
'''
# Check if we've already trained on this meter
meters_in_model = [d['training_metadata'] for d in self.model]
if meter in meters_in_model:
raise RuntimeError(
"Meter {} is already in model!"
" Can't train twice on the same meter!".format(meter))
# Build the states, which are available for this appliance
states = cluster(chunk, max_num_clusters, num_on_states)
self.model.append({'states': states, 'training_metadata': meter})
def train(self, metergroup, max_num_clusters = 3, resample_seconds=60, centroids=None):
self.model = []
if centroids is None:
load_kwargs={}
load_kwargs.setdefault('resample', True)
load_kwargs.setdefault('sample_period', resample_seconds)
for i, meter in enumerate(metergroup.submeters().meters):
print("Training model for submeter '{}'".format(meter))
for chunk in meter.power_series(**load_kwargs):
states = cluster(chunk, max_num_clusters)
self.model.append({
'states': states,
'training_metadata': meter})
break
else:
for i, meter in enumerate(metergroup.submeters().meters):
print("Setting model for submeter '{}'".format(meter))
states = centroids[meter.instance()]
self.model.append({
'states': states,
'training_metadata': meter})
print("Done training!")
def train(self, metergroup, num_states_dict={}, **load_kwargs):
"""Train using 1d FHMM.
Places the learnt model in `model` attribute
The current version performs training ONLY on the first chunk.
Online HMMs are welcome if someone can contribute :)
Assumes all pre-processing has been done.
"""
learnt_model = OrderedDict()
num_meters = len(metergroup.meters)
if num_meters > 12:
max_num_clusters = 2
else:
max_num_clusters = 3
_check_memory(len((metergroup.submeters().meters)))
for i, meter in enumerate(metergroup.submeters().meters):
power_series = meter.power_series(**load_kwargs)
meter_data = next(power_series).dropna()
X = meter_data.values.reshape((-1, 1))
if not len(X):
print(
"Submeter '{}' has no samples, skipping...".format(meter))
continue
assert X.ndim == 2
self.X = X
num_total_states = None
# Check if the user has specific the number of states for this meter
num_total_states = num_states_dict.get(meter)
# If not, check if the number of states for the appliances was specified
if num_total_states is None:
num_apps_states = []
for appliance in meter.appliances:
num_app_state = num_states_dict.get(appliance)
if num_app_state is None:
num_app_state = num_states_dict.get(
appliance.identifier.type)
if num_app_state is not None:
num_apps_states.append(num_app_state)
if num_apps_states:
num_total_states = sum(num_apps_states)
if num_states_dict.get(meter) is not None or num_states_dict.get(
meter) is not None:
# User has specified the number of states for this appliance
num_total_states = num_states_dict.get(meter)
# Otherwise, find the optimum number of states via clustering
if num_total_states is None:
states = cluster(meter_data, max_num_clusters)
num_total_states = len(states)
print("Training model for submeter '{}' with {} states".format(
meter, num_total_states))
learnt_model[meter] = hmm.GaussianHMM(num_total_states, "full")
# Fit
learnt_model[meter].fit(X)
# Check to see if there are any more chunks.
# TODO handle multiple chunks per appliance.
try:
next(power_series)
except StopIteration:
pass
else:
warn("The current implementation of FHMM"
" can only handle a single chunk. But there are multiple"
" chunks available. So have only trained on the"
" first chunk!")
# Combining to make a AFHMM
self.meters = []
new_learnt_models = OrderedDict()
for meter in learnt_model:
startprob, means, covars, transmat = sort_learnt_parameters(
learnt_model[meter].startprob_, learnt_model[meter].means_,
learnt_model[meter].covars_, learnt_model[meter].transmat_)
new_learnt_models[meter] = hmm.GaussianHMM(startprob.size, "full")
new_learnt_models[meter].startprob_ = startprob
new_learnt_models[meter].transmat_ = transmat
new_learnt_models[meter].means_ = means
new_learnt_models[meter].covars_ = covars
# UGLY! But works.
self.meters.append(meter)
learnt_model_combined = create_combined_hmm(new_learnt_models)
self.individual = new_learnt_models
self.model = learnt_model_combined
def train(self, metergroup, num_states_dict={}, **load_kwargs):
"""Train using 1d FHMM.
Places the learnt model in `model` attribute
The current version performs training ONLY on the first chunk.
Online HMMs are welcome if someone can contribute :)
Assumes all pre-processing has been done.
"""
learnt_model = OrderedDict()
num_meters = len(metergroup.meters)
if num_meters > 12:
max_num_clusters = 2
else:
max_num_clusters = 3
for i, meter in enumerate(metergroup.submeters().meters):
power_series = meter.power_series(**load_kwargs)
meter_data = power_series.next().dropna()
X = meter_data.values.reshape((-1, 1))
assert X.ndim == 2
self.X = X
if num_states_dict.get(meter) is not None:
# User has specified the number of states for this appliance
num_total_states = num_states_dict.get(meter)
else:
# Find the optimum number of states
states = cluster(meter_data, max_num_clusters)
num_total_states = len(states)
print("Training model for submeter '{}'".format(meter))
learnt_model[meter] = hmm.GaussianHMM(num_total_states, "full")
# Fit
learnt_model[meter].fit([X])
# Check to see if there are any more chunks.
# TODO handle multiple chunks per appliance.
try:
power_series.next()
except StopIteration:
pass
else:
warn("The current implementation of FHMM"
" can only handle a single chunk. But there are multiple"
" chunks available. So have only trained on the"
" first chunk!")
# Combining to make a AFHMM
self.meters = []
new_learnt_models = OrderedDict()
for meter in learnt_model:
startprob, means, covars, transmat = sort_learnt_parameters(
learnt_model[meter].startprob_, learnt_model[meter].means_,
learnt_model[meter].covars_, learnt_model[meter].transmat_)
new_learnt_models[meter] = hmm.GaussianHMM(
startprob.size, "full", startprob, transmat)
new_learnt_models[meter].means_ = means
new_learnt_models[meter].covars_ = covars
# UGLY! But works.
self.meters.append(meter)
learnt_model_combined = create_combined_hmm(new_learnt_models)
self.individual = new_learnt_models
self.model = learnt_model_combined
def partial_fit(self, train_main, train_appliances, **load_kwargs):
"""Train using 1d FHMM.
"""
print(".........................FHMM partial_fit.................")
train_main = pd.concat(train_main, axis=0)
train_app_tmp = []
for app_name, df_list in train_appliances:
df_list = pd.concat(df_list, axis=0)
train_app_tmp.append((app_name, df_list))
self.app_names.append(app_name)
train_appliances = train_app_tmp
learnt_model = OrderedDict()
num_meters = len(train_appliances)
if num_meters > 12:
max_num_clusters = 2
else:
max_num_clusters = 3
for appliance, meter in train_appliances:
meter_data = meter.dropna()
X = meter_data.values.reshape((-1, 1))
if not len(X):
print(
"Submeter '{}' has no samples, skipping...".format(meter))
continue
assert X.ndim == 2
self.X = X
if self.num_of_states > 0:
# User has specified the number of states for this appliance
num_total_states = self.num_of_states
else:
# Find the optimum number of states
states = cluster(meter_data, max_num_clusters)
num_total_states = len(states)
print("Training model for submeter '{}'".format(appliance))
learnt_model[appliance] = hmm.GaussianHMM(num_total_states, "full")
# Fit
learnt_model[appliance].fit(X)
print("Learnt model for : " + appliance)
# Check to see if there are any more chunks.
# TODO handle multiple chunks per appliance.
# Combining to make a AFHMM
self.meters = []
new_learnt_models = OrderedDict()
for meter in learnt_model:
startprob, means, covars, transmat = sort_learnt_parameters(
learnt_model[meter].startprob_, learnt_model[meter].means_,
learnt_model[meter].covars_, learnt_model[meter].transmat_)
new_learnt_models[meter] = hmm.GaussianHMM(startprob.size, "full")
new_learnt_models[meter].startprob_ = startprob
new_learnt_models[meter].transmat_ = transmat
new_learnt_models[meter].means_ = means
new_learnt_models[meter].covars_ = covars
# UGLY! But works.
self.meters.append(meter)
learnt_model_combined = create_combined_hmm(new_learnt_models)
self.individual = new_learnt_models
self.model = learnt_model_combined
print("FHMM partial_fit end.................")
def partial_fit(self, train_main, train_appliances, **load_kwargs):
"""Train using 1d FHMM.
"""
print("FHMM partial_fit.................")
learnt_model = OrderedDict()
num_meters = len(train_appliances)
if num_meters > 12:
max_num_clusters = 2
else:
max_num_clusters = 3
appliance_in_model=[d['appliance_name'] for d in self.model]
for appliance, meter in train_appliances:
meter_data = meter.dropna()
X = meter_data.values.reshape((-1, 1))
if not len(X):
print("Submeter '{}' has no samples, skipping...".format(meter))
continue
assert X.ndim == 2
self.X = X
# num_states_dict={}
# if num_states_dict.get(meter) is not None:
# # User has specified the number of states for this appliance
# num_total_states = num_states_dict.get(meter)
# else:
# # Find the optimum number of states
states = cluster(meter_data, max_num_clusters)
num_total_states = len(states)
print("Training model for submeter '{}'".format(meter.head()))
learnt_model[appliance] = hmm.GaussianHMM(num_total_states, "full")
# Fit
learnt_model[appliance].fit(X)
print("Learnt model for : "+appliance)
# Check to see if there are any more chunks.
# TODO handle multiple chunks per appliance.
# Combining to make a AFHMM
self.meters = []
new_learnt_models = OrderedDict()
for meter in learnt_model:
print(meter)
startprob, means, covars, transmat = sort_learnt_parameters(
learnt_model[meter].startprob_, learnt_model[meter].means_,
learnt_model[meter].covars_, learnt_model[meter].transmat_)
new_learnt_models[meter] = hmm.GaussianHMM(startprob.size, "full")
new_learnt_models[meter].startprob_ = startprob
new_learnt_models[meter].transmat_ = transmat
new_learnt_models[meter].means_ = means
new_learnt_models[meter].covars_ = covars
# UGLY! But works.
self.meters.append(meter)
learnt_model_combined = create_combined_hmm(new_learnt_models)
self.individual = new_learnt_models
self.model = learnt_model_combined
print("End FHMM.................")
def train(self, metergroup, num_states_dict={}, **load_kwargs):
"""Train using 1d FHMM.
Places the learnt model in `model` attribute
The current version performs training ONLY on the first chunk.
Online HMMs are welcome if someone can contribute :)
Assumes all pre-processing has been done.
"""
learnt_model = OrderedDict()
num_meters = len(metergroup.meters)
if num_meters > 12:
max_num_clusters = 2
else:
max_num_clusters = 3
for i, meter in enumerate(metergroup.submeters().meters):
power_series = meter.power_series(**load_kwargs)
meter_data = next(power_series).dropna()
X = meter_data.values.reshape((-1, 1))
assert X.ndim == 2
self.X = X
if num_states_dict.get(meter) is not None:
# User has specified the number of states for this appliance
num_total_states = num_states_dict.get(meter)
else:
# Find the optimum number of states
states = cluster(meter_data, max_num_clusters)
num_total_states = len(states)
print("Training model for submeter '{}'".format(meter))
learnt_model[meter] = hmm.GaussianHMM(num_total_states, "full")
# Fit
learnt_model[meter].fit([X]) # learnt_model[meter].fit([x for x in X])
# Original: learnt_model[meter].fit([X])
# Check to see if there are any more chunks.
# TODO handle multiple chunks per appliance.
try:
next(power_series)
except StopIteration:
pass
else:
warn("The current implementation of FHMM"
" can only handle a single chunk. But there are multiple"
" chunks available. So have only trained on the"
" first chunk!")
# Combining to make a AFHMM
self.meters = []
new_learnt_models = OrderedDict()
for meter in learnt_model:
startprob, means, covars, transmat = sort_learnt_parameters(
learnt_model[meter].startprob_, learnt_model[meter].means_,
learnt_model[meter].covars_, learnt_model[meter].transmat_)
new_learnt_models[meter] = hmm.GaussianHMM(
startprob.size, "full", startprob, transmat)
new_learnt_models[meter].means_ = means
new_learnt_models[meter].covars_ = covars
# UGLY! But works.
self.meters.append(meter)
learnt_model_combined = create_combined_hmm(new_learnt_models)
self.individual = new_learnt_models
self.model = learnt_model_combined
