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