def __init__(self, should_generate_regime_classifier=True):
self.MH = ModelHelper.get_instance() # type: ModelHelper
if should_generate_regime_classifier:
self.regime_classifier = RegimeClassifier()
self.model_dict = {}
for regime in self.MH.regime_indices:
for header in self.MH.output_headers:
self.model_dict[header + str(regime)] = Regressor(
header, regime)
def __init__(self):
self.it = InterModel()
self.fw = self.it.fwd_model
self.MH = ModelHelper.get_instance() # type: ModelHelper
self.ranges_dict = self.MH.ranges_dict
self.input_headers = self.MH.input_headers
self.output_headers = self.MH.output_headers
def __init__(self):
self.MH = ModelHelper.get_instance() # type: ModelHelper
self.neuralnet = NeuralNetModel_regime()
print("regime classifier")
if load_model:
print("Loading classifier")
self.neuralnet.load_model()
else:
print("Training classifier")
print("Data points: " + str(len(self.MH.train_features_dat_wholenorm)))
self.neuralnet.train_model(self.MH.train_features_dat_wholenorm, self.MH.train_regime_dat)
train_features = np.stack(self.MH.train_features_dat_wholenorm)
train_labels = np.stack(self.MH.train_regime_dat)
print("Train accuracy: " + str(sklearn.metrics.accuracy_score(train_labels-1,self.neuralnet.classifier_model.predict_classes(train_features))))
print()
def __init__(self, output_name, regime):
self.MH = ModelHelper.get_instance() # type: ModelHelper
self.regime = regime
regime_indices = self.MH.regime_indices[regime]
regime_feature_data = [self.MH.train_features_dat_regnorm[x] for x in regime_indices]
regime_label_data = [self.MH.train_labels_dat[output_name][x] for x in regime_indices]
print("Regression model " + output_name + str(regime))
if output_name == "generation_rate":
if regime == 1:
self.regression_model = NeuralNetModel_rate1()
elif regime == 2:
self.regression_model = NeuralNetModel_rate2()
elif output_name == "droplet_size":
if regime == 1:
self.regression_model = NeuralNetModel_size1()
elif regime == 2:
self.regression_model = NeuralNetModel_size2()
if load_model:
print("Loading Regressor")
self.regression_model.load_model(output_name, regime)
else:
print("Training Regressor")
print("All data points: " + str(len(self.MH.train_features_dat_regnorm)))
print("Train points: " + str(len(regime_indices)))
self.regression_model.train_model(output_name, regime, regime_feature_data, regime_label_data)
train_features = np.stack(regime_feature_data)
train_labels = np.stack(regime_label_data)
#print(",".join(self.MH.input_headers) + ",label,prediction")
#for i,label in enumerate(list(train_labels)):
# print(",".join(list(map(str,list(train_features[i])))) + "," + str(label) + "," + str(self.regression_model.regression_model.predict(train_features)[i][0]))
#print(train_labels)
#print()
#print(train_features)
print("R square (R^2) for Train: %f" % sklearn.metrics.r2_score(train_labels, self.regression_model.regression_model.predict(train_features)))
print()
def __init__(self):
"""Initialize the GUI components"""
self.root = tkinter.Tk()
self.root.title("DAFD")
#Attach the interpolation model to the GUI
self.di = DAFD_Interface()
self.MH = ModelHelper.get_instance() # type: ModelHelper
# DAFD Logo
img = Image.open(self.MH.resource_path("DAFD_logo.png"))
img = ImageTk.PhotoImage(
img.resize((int(0.1 * img.size[0]), int(0.1 * img.size[1])),
Image.ANTIALIAS))
panel = tkinter.Label(self.root, image=img)
panel.pack(side="top", fill="both")
panel.configure(background="white")
self.root.configure(background="white")
# Pack all input constraint elements together
inputs_frame = tkinter.Frame(self.root)
inputs_frame.pack(side="top")
inputs_frame.configure(background="white")
inputs_header = tkinter.Label(inputs_frame)
inputs_header.pack(side="top")
inputs_header["text"] = "Constraints"
inputs_header.config(font=("Times", 20))
inputs_header.configure(background="white")
self.entries_dict = {}
self.tol_var = 0
for param_name in self.di.input_headers:
param_frame = tkinter.Frame(inputs_frame)
param_frame.pack(side="top")
param_frame.configure(background="white")
param_label = tkinter.Label(param_frame, width=40, anchor="e")
param_label.pack(side="left")
param_label["text"] = param_name + " (" + str(
round(self.di.ranges_dict[param_name][0], 2)) + "-" + str(
round(self.di.ranges_dict[param_name][1], 2)) + ") : "
param_label.configure(background="white")
param_entry = tkinter.Entry(param_frame)
param_entry.pack(side="left")
param_entry.configure(background="white")
self.entries_dict[param_name] = param_entry
regime_frame = tkinter.Frame(inputs_frame)
regime_frame.pack(side="top")
regime_frame.configure(background="white")
regime_label = tkinter.Label(regime_frame, width=40, anchor="e")
regime_label.pack(side="left")
regime_label["text"] = "regime (1-2) : "
regime_label.configure(background="white")
regime_entry = tkinter.Entry(regime_frame)
regime_entry.pack(side="left")
regime_entry.configure(background="white")
self.entries_dict["regime"] = regime_entry
# Pack the desired output elements together
outputs_frame = tkinter.Frame(self.root, pady=20)
outputs_frame.pack(side="top")
outputs_frame.configure(background="white")
outputs_header = tkinter.Label(outputs_frame)
outputs_header.pack(side="top")
outputs_header["text"] = "Desired Values"
outputs_header.config(font=("Times", 20))
outputs_header.configure(background="white")
for param_name in self.di.output_headers:
param_frame = tkinter.Frame(outputs_frame)
param_frame.pack(side="top")
param_frame.configure(background="white")
param_label = tkinter.Label(param_frame, width=40, anchor="e")
param_label.pack(side="left")
param_label["text"] = param_name + " (" + str(
round(self.di.ranges_dict[param_name][0], 2)) + "-" + str(
round(self.di.ranges_dict[param_name][1], 2)) + ") : "
param_label.configure(background="white")
param_entry = tkinter.Entry(param_frame)
param_entry.pack(side="left")
param_entry.configure(background="white")
self.entries_dict[param_name] = param_entry
# Pack Tolerance Study Together
tolerance_frame = tkinter.Frame(self.root, pady=20)
tolerance_frame.pack(side="top")
tolerance_frame.configure(background="white")
tolerance_header = tkinter.Label(tolerance_frame)
tolerance_header.pack(side="top")
tolerance_header["text"] = "Tolerance Options"
tolerance_header.config(font=("Times", 20))
tolerance_header.configure(background="white")
tol_frame = tkinter.Frame(tolerance_frame)
tol_frame.pack(side="top")
tol_frame.configure(background="white")
tol_label = tkinter.Label(tol_frame, width=40, anchor="e")
tol_label.pack(side="left")
tol_label["text"] = "Perform Tolerance Study? "
tol_label.configure(background="white")
check_var = tkinter.IntVar(value=0)
tol_entry = tkinter.Checkbutton(tol_frame, variable=check_var)
tol_entry.pack(side="left")
tol_entry.configure(background="white")
self.entries_dict["tolerance_test"] = tol_entry
tol_frame = tkinter.Frame(tolerance_frame)
tol_frame.pack(side="top")
tol_frame.configure(background="white")
tol_label = tkinter.Label(tol_frame, width=40, anchor="e")
tol_label.pack(side="left")
tol_label["text"] = "Tolerance (1-50, default 10) : "
tol_label.configure(background="white")
tol_entry = tkinter.Entry(tol_frame)
tol_entry.pack(side="left")
tol_entry.configure(background="white")
self.entries_dict["tolerance"] = tol_entry
# Pack the results together
results_frame = tkinter.Frame(self.root, pady=20)
results_frame.pack(side="top")
results_frame.configure(background="white")
submit_dafd_button = ttk.Button(results_frame,
text='Run DAFD',
command=self.runInterp)
submit_dafd_button.pack(side="top")
submit_fwd_button = ttk.Button(results_frame,
text='Run Forward Model',
command=self.runForward)
submit_fwd_button.pack(side="top")
self.results_label = tkinter.Label(results_frame)
self.results_label.pack(side="top")
self.results_label.configure(background="white")
# Start GUI
self.root.mainloop()
def __init__(self):
"""Make and save the interpolation models"""
self.MH = ModelHelper.get_instance() # type: ModelHelper
self.fwd_model = ForwardModel()
def __init__(self):
self.MH = ModelHelper.get_instance() # type: ModelHelper