def run(
self,
package_name=None,
network_layout=None,
hidden_layer_function=None,
output_layer_function=None,
max_epochs=None,
stop_function=None,
training_goal=None,
trains_per_validation_run=None,
max_worse_validations=None,
verbose_settings=None,
):
if package_name is not None:
self.package_name = package_name
if network_layout is not None:
self.network_layout = [int(i) for i in network_layout.split(",")]
if hidden_layer_function is not None:
self.hidden_layer_function = output_layer_function
if output_layer_function is not None:
self.output_layer_function = output_layer_function
if max_epochs is not None:
self.max_epochs = max_epochs
if stop_function is not None:
self.stop_function = stop_function
if training_goal is not None:
self.training_goal = training_goal
if trains_per_validation_run is not None:
self.trains_per_validation_run = trains_per_validation_run
if max_worse_validations is not None:
self.max_worse_validations = max_worse_validations
if verbose_settings is not None:
self.verbose_settings = verbose_settings
# Create network with 2 layers and random initialized
self.ann = nl.net.newff(self.min_max_list[0], self.network_layout, [nl.trans.TanSig(), nl.trans.PureLin()])
self.ann.trainf = nl.train.train_cg
# self.ann.trainf = nl.train.train_gdm
# self.network.trainf = nl.train.train_ncg
self.ann.errorf = SSE()
self.best_network = [copy.deepcopy(self.ann), 9999, 9999]
self.inbuilt_errors = []
self.training_errors = OrderedDict()
self.validation_errors = OrderedDict()
for i in self.error_metrics:
self.training_errors[i] = []
self.validation_errors[i] = []
# Get initial training and validations errors
training_predictions = self.ann.sim(self.training_input)
calc_error(self.training_errors, training_predictions, self.training_target)
validation_predictions = self.ann.sim(self.validation_input)
calc_error(self.validation_errors, validation_predictions, self.validation_target)
worse_validations_count = 0
inbuilt_error_check = 0
for train_validate_cycle in range(int(self.max_epochs / self.trains_per_validation_run)):
# Train network
print("Training...")
self.inbuilt_errors.extend(
self.ann.train(
self.training_input,
self.training_target,
epochs=self.trains_per_validation_run,
show=self.verbose_settings,
goal=self.training_goal,
)
)
print("Run count: {} of Max {}".format(str(len(self.inbuilt_errors)), self.max_epochs))
if len(self.inbuilt_errors) == 0:
return (
1,
"Error Break, not actually training! Run count: {}, Network Layout: {}".format(
str(len(self.inbuilt_errors)), str(self.network_layout)
),
)
elif inbuilt_error_check == len(self.inbuilt_errors):
return (
0,
"Break, not training anymore! Run count: {}, Network Layout: {}".format(
str(len(self.inbuilt_errors)), str(self.network_layout)
),
)
else:
inbuilt_error_check = len(self.inbuilt_errors)
# Get training and validations errors
training_predictions = self.ann.sim(self.training_input)
calc_error(self.training_errors, training_predictions, self.training_target)
print("Training Errors: {}".format(get_last_errors(self.training_errors)))
validation_predictions = self.ann.sim(self.validation_input)
calc_error(self.validation_errors, validation_predictions, self.validation_target)
print("Validation Errors: {}".format(get_last_errors(self.validation_errors)))
# If validation error is smaller than best network error, then that becomes new best network
if self.validation_errors["wRSEpdnaive"][-1] < self.best_network[2]:
self.best_network = [
copy.deepcopy(self.ann),
self.training_errors["wRSEpdnaive"][-1],
self.validation_errors["wRSEpdnaive"][-1],
train_validate_cycle + 1,
]
worse_validations_count = 0
print(
"New Best Network! Training Error: {}, Validation Error: {}".format(
self.training_errors["wRSEpdnaive"][-1], self.validation_errors["wRSEpdnaive"][-1]
)
)
else:
worse_validations_count += self.trains_per_validation_run
print("Runs until validation break: {}".format(self.max_worse_validations - worse_validations_count))
if worse_validations_count >= self.max_worse_validations:
return 0, "Validation Break! Run count: " + str(len(self.inbuilt_errors))
return 0, "Finished without a Break"
def run_main():
# load in data settings about a data set from a ini file, ini file must be in same directory as this file
data_settings = DataSetSettings(os.path.join(os.path.dirname(os.getcwd()), ini_file))
data_set_files = data_settings.get_data_set_files()
meter_groups = []
for meter_file in data_set_files:
# create meter groups from csv data
meter_groups.append(MeterGroup(meter_file[0], meter_file[1], meter_file[2]))
# set meter group settings
meter_groups[-1].set_meter_group_settings(data_settings.meter_groups())
# create data packer and add meter groups
data_packer1 = DataPacker(meter_groups)
for time_horizon in range(1, 2):
# package data for machine learning
data_package1 = data_packer1.package_data(data_settings.packer_input(), data_settings.packer_target(),
forecast_horizon_override=time_horizon)
print('Data Packaged')
if False:
data = data_package1.training_input.T
# data = data_package1.validation_input.T
meta = data_package1.training_input_meta[0]
embedding_search_fnn(data, meta, go_to=15, threshold=50, ratio=0.001)
if False:
for ann_count in range(10):
with open(os.path.join(os.path.dirname(os.getcwd()), log_file), 'a') as f:
f.write('Forecast Horizon: {} ANN Count: {}\n'.format(time_horizon, ann_count))
while True:
# create machine learning obj to run ANN
ann1 = MachineLearning('ANN', data_package1, data_settings.ann())
print('Machine Learning Obj Initialized')
# run: ml_type, package_name, network_layout, layer_func, max_epochs, trains_per_validation_run,
# max_worse_validations stop_function, training_goal, verbose_settings
#code, msg = ann1.run(network_layout='{}, 1'.format(time_horizon))
code, msg = ann1.run()
if code == 1: # Failed to learn
print(msg)
with open(os.path.join(os.path.dirname(os.getcwd()), log_file), 'a') as f:
f.write(msg + '\n')
else:
print(msg)
with open(os.path.join(os.path.dirname(os.getcwd()), log_file), 'a') as f:
f.write(msg + '\n')
print('Machine Learning Obj Finished Run')
data_collector1 = DataCollector(ann1, data_package1, data_settings)
pickle_file = 'data\\Hillersdon\\hill-exp{}_p{}-h50-t{}-r{}.pickle'.format(
experiment_id, process_id, time_horizon, ann_count)
with open(pickle_file, 'wb') as pf:
pickle.dump(data_collector1, pf, pickle.HIGHEST_PROTOCOL)
print('Data Collector Pickled')
with open(os.path.join(os.path.dirname(os.getcwd()), log_file), 'a') as f:
f.write('Run Count: {}, Pickled: {}\n'.format(str(len(data_collector1.ml_obj.inbuilt_errors)), pickle_file))
f.write('Training Errors: {}\n'.format(get_last_errors(ann1.training_errors)))
f.write('Validation Errors: {}\n'.format(get_last_errors(ann1.validation_errors)))
predictions = data_collector1.ml_obj.best_network[0].sim(data_collector1.ml_obj.training_input)
observations = data_collector1.ml_obj.training_target
train_errors_str = get_all_error_metrics(observations, predictions, data_collector1.data_package)
predictions = data_collector1.ml_obj.best_network[0].sim(data_collector1.ml_obj.validation_input)
observations = data_collector1.ml_obj.validation_target
val_errors_str = get_all_error_metrics(observations, predictions, data_collector1.data_package)
with open(os.path.join(os.path.dirname(os.getcwd()), results_file), 'a') as f:
f.write('Run Count: {}, Pickled: {}\n'.format(str(len(data_collector1.ml_obj.inbuilt_errors)), pickle_file))
f.write('Training Errors, {}\n'.format(train_errors_str))
f.write('Validation Errors, {}\n'.format(val_errors_str))
#data_collector1.plot_all()
break
print('Done!')
