class RightFrame: """ This class is for creating right frame widgets which are used to draw graphics on canvas as well as embedding matplotlib figures in the tkinter. Farhad Kamangar 2018_06_03 """ def __init__(self, root, master, debug_print_flag=False): self.master = master self.root = root ######################################################################### # Set up the constants and default values ######################################################################### self.alpha = 0.1 self.second_weight = 1 self.bias = 0.0 self.error_final=[] self.epoch=[] self.ep=0.0 self.xmin = 0 self.xmax = 10 self.ymin = 0 self.ymax = 1 self.debug_print_flag = debug_print_flag self.input_weight = 1 self.bias = 0.0 self.activation_type = "Hardlim" self.Learning_type = "Smoothing" ######################################################################### # Set up the plotting frame and controls frame ######################################################################### master.rowconfigure(0, weight=10, minsize=200) master.columnconfigure(0, weight=1) self.plot_frame = tk.Frame(self.master, borderwidth=10, relief=tk.SUNKEN) self.plot_frame.grid(row=0, column=0, columnspan=1, sticky=tk.N + tk.E + tk.S + tk.W) self.figure = plt.figure(figsize=(8,5)) self.axes = self.figure.add_axes([0.15, 0.15, 0.6, 0.8]) # self.axes = self.figure.add_axes() self.axes = self.figure.gca() #self.axes.set_xlabel('Input') #self.axes.set_ylabel('Output') # self.axes.margins(0.5) self.axes.set_title("") # plt.xlim(self.xmin, self.xmax) # plt.ylim(self.ymin, self.ymax) # fg=plt.rcParams["figure.figsize"] #fg[0]=2 #fg[1]=40 #plt.rcParams["figure.figsize"] = fg self.canvas = FigureCanvasTkAgg(self.figure, master=self.plot_frame) self.plot_widget = self.canvas.get_tk_widget() self.plot_widget.grid(row=0, column=0, sticky=tk.N + tk.E + tk.S + tk.W) # Create a frame to contain all the controls such as sliders, buttons, ... self.controls_frame = tk.Frame(self.master) self.controls_frame.grid(row=1, column=0, sticky=tk.N + tk.E + tk.S + tk.W) ######################################################################### # Set up the control widgets such as sliders and selection boxes ######################################################################### self.alpha_slider = tk.Scale(self.controls_frame, variable=tk.DoubleVar(), orient=tk.HORIZONTAL, from_=0.001, to_=1.0, resolution=0.01, bg="#DDDDDD", activebackground="#FF0000", highlightcolor="#00FFFF", label="Alpha", command=lambda event: self.alpha_slider_callback()) self.alpha_slider.set(self.alpha) self.alpha_slider.bind("<ButtonRelease-1>", lambda event: self.alpha_slider_callback()) self.alpha_slider.grid(row=0, column=2, sticky=tk.N + tk.E + tk.S + tk.W) ######################################################################### # Set up the frame for drop down selection ######################################################################### self.label_for_activation_function = tk.Label(self.controls_frame, text="Activation Function Type:", justify="center") self.label_for_activation_function.grid(row=3, column=4, sticky=tk.N + tk.E + tk.S + tk.W) self.activation_function_variable = tk.StringVar() self.activation_function_dropdown = tk.OptionMenu(self.controls_frame, self.activation_function_variable, "Hardlim", "Tangent", "Linear", command=lambda event: self.activation_function_dropdown_callback()) self.activation_function_variable.set("Hardlim") self.activation_function_dropdown.grid(row=3, column=5, sticky=tk.N + tk.E + tk.S + tk.W) self.label_for_Learning_method = tk.Label(self.controls_frame, text="learning method:", justify="center") self.label_for_Learning_method.grid(row=4, column=4, sticky=tk.N + tk.E + tk.S + tk.W) self.Learning_method_variable = tk.StringVar() self.Learning_method_dropdown = tk.OptionMenu(self.controls_frame, self.Learning_method_variable, "Smoothing", "Delta-rule", "Unsupervised-Hebb", command=lambda event: self.Learning_method_dropdown_callback()) self.Learning_method_variable.set("Smoothing") self.Learning_method_dropdown.grid(row=4, column=5, sticky=tk.N + tk.E + tk.S + tk.W) ######################################################################### # Set up the frame for botton selection ######################################################################### self.Train_button = tk.Button(self.controls_frame, text="Train", fg="red", width=16, command=self.Training_method_callback) self.Randomize_weight_button = tk.Button(self.controls_frame, text="Randomize weight", fg="red", width=16, command=self.Randomize_callback) self.Confusion_matrix_button = tk.Button(self.controls_frame, text="Confusion_matrix", fg="red", width=16, command=self.Confusion_callback) self.Train_button.grid(row=1, column=4) self.Randomize_weight_button.grid(row=0, column=4) self.Confusion_matrix_button.grid(row=2, column=4) self.canvas.get_tk_widget().bind("<ButtonPress-1>", self.left_mouse_click_callback) self.canvas.get_tk_widget().bind("<ButtonPress-1>", self.left_mouse_click_callback) self.canvas.get_tk_widget().bind("<ButtonRelease-1>", self.left_mouse_release_callback) self.canvas.get_tk_widget().bind("<B1-Motion>", self.left_mouse_down_motion_callback) self.canvas.get_tk_widget().bind("<ButtonPress-3>", self.right_mouse_click_callback) self.canvas.get_tk_widget().bind("<ButtonRelease-3>", self.right_mouse_release_callback) self.canvas.get_tk_widget().bind("<B3-Motion>", self.right_mouse_down_motion_callback) self.canvas.get_tk_widget().bind("<Key>", self.key_pressed_callback) self.canvas.get_tk_widget().bind("<Up>", self.up_arrow_pressed_callback) self.canvas.get_tk_widget().bind("<Down>", self.down_arrow_pressed_callback) self.canvas.get_tk_widget().bind("<Right>", self.right_arrow_pressed_callback) self.canvas.get_tk_widget().bind("<Left>", self.left_arrow_pressed_callback) self.canvas.get_tk_widget().bind("<Shift-Up>", self.shift_up_arrow_pressed_callback) self.canvas.get_tk_widget().bind("<Shift-Down>", self.shift_down_arrow_pressed_callback) self.canvas.get_tk_widget().bind("<Shift-Right>", self.shift_right_arrow_pressed_callback) self.canvas.get_tk_widget().bind("<Shift-Left>", self.shift_left_arrow_pressed_callback) self.canvas.get_tk_widget().bind("f", self.f_key_pressed_callback) self.canvas.get_tk_widget().bind("b", self.b_key_pressed_callback) def read_one_image_and_convert_to_vector(self,infile): img = scipy.misc.imread(infile).astype(np.float32) # read image and convert to float return img.reshape(-1,1) # reshape to column vector and return it def data(self): path = 'Data\\' listing = os.listdir(path) Input_Vector=[] Target_Vector=[] Input_Vector_Train=[] Input_Vector_Test=[] Target_Vector_Train=[] Target_Vector_Test=[] for infile in listing: Target=np.zeros((10,1)) if infile.endswith('.png'): pic1=self.read_one_image_and_convert_to_vector('Data/'+infile) pic1=np.append(pic1,[1]) #index=listing.index(infile) #pic2[index)=3 Input_Vector.append(pic1/127.5-1) out=int(infile[0]) Target[out]=out #print('sdf', Target) Target_Vector.append(Target) X1=random.sample(range(1000), 800) X2=list(range(1000)) #print('sss',X2,len(X2)) for i in X1: if i in X2: X2.remove(i) for i in X1: Input_Vector_Train.append(Input_Vector[i]) Target_Vector_Train.append(Target_Vector[i]) for i in X2: Input_Vector_Test.append(Input_Vector[i]) Target_Vector_Test.append(Target_Vector[i]) self.Input_Vectors_Test=Input_Vector_Test self.Input_Vectors_Train=Input_Vector_Train self.Target_Vectors_Test=Target_Vector_Test self.Target_Vectors_Train=Target_Vector_Train print('ddd',type(self.Target_Vectors_Test[2])) #print(len(Target_Vectors),Input_Vectors[300]) def alpha_slider_callback(self): self.alpha = np.float(self.alpha_slider.get()) #self.display_matplotlib_figure_on_tk_canvas() def activation_function_dropdown_callback(self): self.activation_type = self.activation_function_variable.get() #self.display_activation_function() def Learning_method_dropdown_callback(self): self.Learning_type = self.Learning_method_variable.get() #self.display_activation_function() def Randomize_Weights_bias(self): rr=np.random.random((10,785)) self.Weight=(rr*0.002)-0.001 self.epoch=0 self.epoch=[] print('mahdi',self.Weight) # Train botton comes here def Training(self): self.figure = plt.figure(figsize=(8,5)) self.axes = self.figure.add_axes([0.15, 0.15, 0.6, 0.8]) self.axes = self.figure.gca() self.canvas = FigureCanvasTkAgg(self.figure, master=self.plot_frame) self.plot_widget = self.canvas.get_tk_widget() self.plot_widget.grid(row=0, column=0, sticky=tk.N + tk.E + tk.S + tk.W) j=0 self.data() while (j<10): self.ep=self.ep+1 self.epoch.append(self.ep) j=j+1 if (self.Learning_type=="Smoothing"): for idx, item in enumerate(self.Target_Vectors_Train): ret=self.Input_Vectors_Train[idx] ret = ret.reshape(785,1) # print('faeze',len(ret)) multiply=np.dot(item, np.transpose(ret)) #print ('weigt1',Weight[3,45]) self.Weight=self.Weight*(1-self.alpha)+self.alpha*multiply #print ('weigt2',Weight[3,45]) error_count=0 for k in range(0,200): output=self.Target_Vectors_Test[k] ret=self.Input_Vectors_Test[k] ret = ret.reshape(785,1) actual1=np.dot(self.Weight,ret) actual = Ghaderi_03_02.calculate_activation_function(actual1, self.activation_type) max=actual.argmax() #print ('hello',actual,max) if max!=output.argmax(): error_count=error_count+1 error=error_count/200 print('error_count',error) self.error_final.append(error) print('error_final',self.error_final) elif (self.Learning_type=="Delta-rule"): for idx, item in enumerate(self.Target_Vectors_Train): ret=self.Input_Vectors_Train[idx] ret = ret.reshape(785,1) actual1=np.dot(self.Weight,ret) actual = Ghaderi_03_02.calculate_activation_function(actual1, self.activation_type) print('actual shape',actual.shape) new_item=item-actual multiply=np.dot(new_item, np.transpose(ret)) self.Weight=self.Weight+self.alpha*multiply # print('fas2',Weight.shape) error_count=0 for k in range(0,200): output = self.Target_Vectors_Test[k] ret = self.Input_Vectors_Test[k] ret = ret.reshape(785,1) actual1 = np.dot(self.Weight,ret) actual = Ghaderi_03_02.calculate_activation_function(actual1, self.activation_type) max = actual.argmax() #print ('hello',actual,max) if max!=output.argmax(): error_count=error_count+1 error=error_count/200 print('error_count',error) self.error_final.append(error) print('error_final',self.error_final) elif (self.Learning_type=="Unsupervised-Hebb"): for idx, item in enumerate(self.Target_Vectors_Train): ret=self.Input_Vectors_Train[idx] ret = ret.reshape(785,1) actual1=np.dot(self.Weight,ret) actual = Ghaderi_03_02.calculate_activation_function(actual1, self.activation_type) multiply=np.dot(actual, np.transpose(ret)) self.Weight=self.Weight+self.alpha*multiply #print('fas3',Weight.shape,alpha) error_count=0 for k in range(0,200): output=self.Target_Vectors_Test[k] ret=self.Input_Vectors_Test[k] ret = ret.reshape(785,1) actual1=np.dot(self.Weight,ret) actual = Ghaderi_03_02.calculate_activation_function(actual1, self.activation_type) max=actual.argmax() #print ('hello',actual,max) if max!=output.argmax(): error_count=error_count+1 error=error_count/200 print('error_count',error) self.error_final.append(error) print('error_final',self.error_final) # self.figure = plt.figure(figsize=(8,5)) # self.plot_frame = tk.Frame(self.master, borderwidth=10, relief=tk.SUNKEN) self.display_error_epoch() # ============================================================================= # self.error_final_final.extend(error_final) # # ,self.epoch_counter.extend() # print('error_finalsss',self.error_final_final,self.epoch) # self.Weight_final=Weight # # self.ep=ep # ============================================================================= def display_error_epoch(self): # self.figure = plt.figure(figsize=(18,15)) #input_values = np.linspace(-10, 10, 256, endpoint=True) # self.plot_frame = tk.Frame(self.master, borderwidth=10, relief=tk.SUNKEN) # self.plot_frame.grid(row=0, column=0, columnspan=1, sticky=tk.N + tk.E + tk.S + tk.W) # self.axes = self.figure.add_axes([0.15, 0.15, 0.6, 0.8]) #self.axes = self.figure.add_axes() # self.axes = self.figure.gca() #plt.xlim(self.xmin, self.xmax) #plt.ylim(self.ymin, self.ymax) #self.canvas = FigureCanvasTkAgg(self.figure, master=self.plot_frame) # self.plot_widget = self.canvas.get_tk_widget() # self.plot_widget.grid(row=0, column=0, sticky=tk.N + tk.E + tk.S + tk.W) self.axes.cla() self.axes.set_xlabel('epoch') self.axes.set_ylabel('error') self.axes.scatter(self.epoch,self.error_final) self.axes.xaxis.set_visible(True) plt.xlim(self.xmin, self.ep) plt.ylim(self.ymin, self.ymax) # Get current size #fig_size = plt.rcParams["figure.figsize"] #plt.rcParams["figure.figsize"] = [1,1] # Prints: [8.0, 6.0] #print ("Current size:", fig_size) # Set figure width to 12 and height to 9 #fig_size[0] = 12 #fig_size[1] = 9 #plt.rcParams["figure.figsize"] = fig_size #plt.title(self.activation_type) self.canvas.draw() def Show_Confusion_Matrix(self): actual_max=[] target_max=[] for k in range(0,200): output=self.Target_Vectors_Test[k] ret=self.Input_Vectors_Test[k] ret = ret.reshape(785,1) actual1=np.dot(self.Weight,ret) actual = Ghaderi_03_02.calculate_activation_function(actual1, self.activation_type) max1=actual.argmax() actual_max.append(max1) #print ('hello',max1,type(max1)) max2=output.argmax() target_max.append(max2) #print('actual_max',actual_max) #print('target_max',target_max) confusion = confusion_matrix(target_max,actual_max) #print('confusion:',confusion) self.axes.cla() #fig, ax = plt.subplots() min_val, max_val = 0, 10 # confusion = np.random.randint(0, 10, size=(max_val, max_val)) #ax.matshow(confusion, cmap=plt.cm.Reds) self.axes.matshow(confusion) for i in range(10): for j in range(10): c = confusion[i][j] self.axes.text(i, j, str(c), va='center', ha='center') self.canvas.draw() # ============================================================================= # plt.matshow(confusion, cmap=plt.cm.Blues) # # self.axes.set_xlim(min_val, max_val) # self.axes.set_ylim(min_val, max_val) # self.axes.set_xticks(np.arange(max_val)) # self.axes.set_yticks(np.arange(max_val)) # self.axes.grid() # # # ============================================================================= def key_pressed_callback(self, event): self.root.status_bar.set('%s', 'Key pressed') def up_arrow_pressed_callback(self, event): self.root.status_bar.set('%s', "Up arrow was pressed") def down_arrow_pressed_callback(self, event): self.root.status_bar.set('%s', "Down arrow was pressed") def right_arrow_pressed_callback(self, event): self.root.status_bar.set('%s', "Right arrow was pressed") def left_arrow_pressed_callback(self, event): self.root.status_bar.set('%s', "Left arrow was pressed") def shift_up_arrow_pressed_callback(self, event): self.root.status_bar.set('%s', "Shift up arrow was pressed") def shift_down_arrow_pressed_callback(self, event): self.root.status_bar.set('%s', "Shift down arrow was pressed") def shift_right_arrow_pressed_callback(self, event): self.root.status_bar.set('%s', "Shift right arrow was pressed") def shift_left_arrow_pressed_callback(self, event): self.root.status_bar.set('%s', "Shift left arrow was pressed") def f_key_pressed_callback(self, event): self.root.status_bar.set('%s', "f key was pressed") def b_key_pressed_callback(self, event): self.root.status_bar.set('%s', "b key was pressed") def left_mouse_click_callback(self, event): self.root.status_bar.set('%s', 'Left mouse button was clicked. ' + 'x=' + str(event.x) + ' y=' + str( event.y)) self.x = event.x self.y = event.y self.canvas.focus_set() def left_mouse_release_callback(self, event): self.root.status_bar.set('%s', 'Left mouse button was released. ' + 'x=' + str(event.x) + ' y=' + str(event.y)) self.x = None self.y = None def left_mouse_down_motion_callback(self, event): self.root.status_bar.set('%s', 'Left mouse down motion. ' + 'x=' + str(event.x) + ' y=' + str(event.y)) self.x = event.x self.y = event.y def right_mouse_click_callback(self, event): self.root.status_bar.set('%s', 'Right mouse down motion. ' + 'x=' + str(event.x) + ' y=' + str(event.y)) self.x = event.x self.y = event.y def right_mouse_release_callback(self, event): self.root.status_bar.set('%s', 'Right mouse button was released. ' + 'x=' + str(event.x) + ' y=' + str(event.y)) self.x = None self.y = None def right_mouse_down_motion_callback(self, event): self.root.status_bar.set('%s', 'Right mouse down motion. ' + 'x=' + str(event.x) + ' y=' + str(event.y)) self.x = event.x self.y = event.y def left_mouse_click_callback(self, event): self.root.status_bar.set('%s', 'Left mouse button was clicked. ' + 'x=' + str(event.x) + ' y=' + str( event.y)) self.x = event.x self.y = event.y # self.focus_set() def frame_resized_callback(self, event): print("frame resize callback") def redisplay(self, event): self.create_graphic_objects() def Randomize_callback(self): self.Randomize_Weights_bias() def Confusion_callback(self): self.Show_Confusion_Matrix() def Training_method_callback(self): self.Training()
class LeftFrame: """ This class creates and controls the widgets and figures in the left frame which are used to display the activation functions. Kush Raina 2018_06_03 """ def __init__(self, root, master, debug_print_flag=False): self.master = master self.root = root ######################################################################### # Set up the constants and default values ######################################################################### self.xmin = -10 self.xmax = 10 self.ymin = -2 self.ymax = 2 self.input_weight = 1 self.bias = 0.0 self.activation_type = "Sigmoid" ######################################################################### # Set up the plotting frame and controls frame ######################################################################### master.rowconfigure(0, weight=1) master.columnconfigure(0, weight=1) self.plot_frame = tk.Frame(self.master, borderwidth=10, relief=tk.SUNKEN) self.plot_frame.grid(row=0, column=0, columnspan=1, sticky=tk.N + tk.E + tk.S + tk.W) #self.plot_frame.grid(row=0, column=1, columnspan=1, sticky=tk.N + tk.E + tk.S + tk.W) self.figure = plt.figure(figsize=(20, 9)) #self.axes = self.figure.add_axes([0.9, 0.9, 0.6, 0.8]) self.axes = self.figure.add_axes() self.axes = self.figure.gca() self.axes.set_xlabel('Input') self.axes.set_ylabel('Output') # self.axes.margins(0.5) self.axes.set_title("") plt.xlim(self.xmin, self.xmax) plt.ylim(self.ymin, self.ymax) self.canvas = FigureCanvasTkAgg(self.figure, master=self.plot_frame) self.plot_widget = self.canvas.get_tk_widget() self.plot_widget.grid(row=0, column=1, sticky=tk.N + tk.E + tk.S + tk.W) # Create a frame to contain all the controls such as sliders, buttons, ... self.controls_frame = tk.Frame(self.master) self.controls_frame.grid(row=1, column=0, sticky=tk.N + tk.E + tk.S + tk.W) ######################################################################### # Set up the control widgets such as sliders and selection boxes ######################################################################### self.input_weight_slider = tk.Scale( self.controls_frame, variable=tk.DoubleVar(), orient=tk.HORIZONTAL, from_=-10.0, to_=10.0, resolution=0.01, bg="#DDDDDD", activebackground="#FF0000", highlightcolor="#00FFFF", label="Input Weight", command=lambda event: self.input_weight_slider_callback()) self.input_weight_slider.set(self.input_weight) self.input_weight_slider.bind( "<ButtonRelease-1>", lambda event: self.input_weight_slider_callback()) self.input_weight_slider.grid(row=0, column=0, sticky=tk.N + tk.E + tk.S + tk.W) self.bias_slider = tk.Scale( self.controls_frame, variable=tk.DoubleVar(), orient=tk.HORIZONTAL, from_=-10.0, to_=10.0, resolution=0.01, bg="#DDDDDD", activebackground="#FF0000", highlightcolor="#00FFFF", label="Bias", command=lambda event: self.bias_slider_callback()) self.bias_slider.set(self.bias) self.bias_slider.bind("<ButtonRelease-1>", lambda event: self.bias_slider_callback()) self.bias_slider.grid(row=0, column=1, sticky=tk.N + tk.E + tk.S + tk.W) ######################################################################### # Set up the frame for drop down selection ######################################################################### self.label_for_activation_function = tk.Label( self.controls_frame, text="Activation Function Type:", justify="center") self.label_for_activation_function.grid(row=0, column=2, sticky=tk.N + tk.E + tk.S + tk.W) self.activation_function_variable = tk.StringVar() self.activation_function_dropdown = tk.OptionMenu( self.controls_frame, self.activation_function_variable, "Sigmoid", "Linear", "Hyperbolic Tangent", "RELU", "Hard", command=lambda event: self.activation_function_dropdown_callback()) self.activation_function_variable.set("Sigmoid") self.activation_function_dropdown.grid(row=0, column=3, sticky=tk.N + tk.E + tk.S + tk.W) self.canvas.get_tk_widget().bind("<ButtonPress-1>", self.left_mouse_click_callback) self.canvas.get_tk_widget().bind("<ButtonPress-1>", self.left_mouse_click_callback) self.canvas.get_tk_widget().bind("<ButtonRelease-1>", self.left_mouse_release_callback) self.canvas.get_tk_widget().bind("<B1-Motion>", self.left_mouse_down_motion_callback) self.canvas.get_tk_widget().bind("<ButtonPress-3>", self.right_mouse_click_callback) self.canvas.get_tk_widget().bind("<ButtonRelease-3>", self.right_mouse_release_callback) self.canvas.get_tk_widget().bind("<B3-Motion>", self.right_mouse_down_motion_callback) self.canvas.get_tk_widget().bind("<Key>", self.key_pressed_callback) self.canvas.get_tk_widget().bind("<Up>", self.up_arrow_pressed_callback) self.canvas.get_tk_widget().bind("<Down>", self.down_arrow_pressed_callback) self.canvas.get_tk_widget().bind("<Right>", self.right_arrow_pressed_callback) self.canvas.get_tk_widget().bind("<Left>", self.left_arrow_pressed_callback) self.canvas.get_tk_widget().bind("<Shift-Up>", self.shift_up_arrow_pressed_callback) self.canvas.get_tk_widget().bind( "<Shift-Down>", self.shift_down_arrow_pressed_callback) self.canvas.get_tk_widget().bind( "<Shift-Right>", self.shift_right_arrow_pressed_callback) self.canvas.get_tk_widget().bind( "<Shift-Left>", self.shift_left_arrow_pressed_callback) self.canvas.get_tk_widget().bind("f", self.f_key_pressed_callback) self.canvas.get_tk_widget().bind("b", self.b_key_pressed_callback) def key_pressed_callback(self, event): self.root.status_bar.set('%s', 'Key pressed') def up_arrow_pressed_callback(self, event): self.root.status_bar.set('%s', "Up arrow was pressed") def down_arrow_pressed_callback(self, event): self.root.status_bar.set('%s', "Down arrow was pressed") def right_arrow_pressed_callback(self, event): self.root.status_bar.set('%s', "Right arrow was pressed") def left_arrow_pressed_callback(self, event): self.root.status_bar.set('%s', "Left arrow was pressed") def shift_up_arrow_pressed_callback(self, event): self.root.status_bar.set('%s', "Shift up arrow was pressed") def shift_down_arrow_pressed_callback(self, event): self.root.status_bar.set('%s', "Shift down arrow was pressed") def shift_right_arrow_pressed_callback(self, event): self.root.status_bar.set('%s', "Shift right arrow was pressed") def shift_left_arrow_pressed_callback(self, event): self.root.status_bar.set('%s', "Shift left arrow was pressed") def f_key_pressed_callback(self, event): self.root.status_bar.set('%s', "f key was pressed") def b_key_pressed_callback(self, event): self.root.status_bar.set('%s', "b key was pressed") def left_mouse_click_callback(self, event): self.root.status_bar.set( '%s', 'Left mouse button was clicked. ' + 'x=' + str(event.x) + ' y=' + str(event.y)) self.x = event.x self.y = event.y self.canvas.focus_set() def left_mouse_release_callback(self, event): self.root.status_bar.set( '%s', 'Left mouse button was released. ' + 'x=' + str(event.x) + ' y=' + str(event.y)) self.x = None self.y = None def left_mouse_down_motion_callback(self, event): self.root.status_bar.set( '%s', 'Left mouse down motion. ' + 'x=' + str(event.x) + ' y=' + str(event.y)) self.x = event.x self.y = event.y def right_mouse_click_callback(self, event): self.root.status_bar.set( '%s', 'Right mouse down motion. ' + 'x=' + str(event.x) + ' y=' + str(event.y)) self.x = event.x self.y = event.y def right_mouse_release_callback(self, event): self.root.status_bar.set( '%s', 'Right mouse button was released. ' + 'x=' + str(event.x) + ' y=' + str(event.y)) self.x = None self.y = None def right_mouse_down_motion_callback(self, event): self.root.status_bar.set( '%s', 'Right mouse down motion. ' + 'x=' + str(event.x) + ' y=' + str(event.y)) self.x = event.x self.y = event.y def left_mouse_click_callback(self, event): self.root.status_bar.set( '%s', 'Left mouse button was clicked. ' + 'x=' + str(event.x) + ' y=' + str(event.y)) self.x = event.x self.y = event.y # self.focus_set() def display_activation_function(self): input_values = np.linspace(-10, 10, 256, endpoint=True) activation = Raina_01_02.calculate_activation_function( self.input_weight, self.bias, input_values, self.activation_type) self.axes.cla() self.axes.set_xlabel('Input1') self.axes.set_ylabel('Output') self.axes.plot(input_values, activation) self.axes.xaxis.set_visible(True) plt.xlim(self.xmin, self.xmax) plt.ylim(self.ymin, self.ymax) plt.title(self.activation_type) self.canvas.draw() def input_weight_slider_callback(self): self.input_weight = np.float(self.input_weight_slider.get()) self.display_activation_function() def bias_slider_callback(self): self.bias = np.float(self.bias_slider.get()) self.display_activation_function() def activation_function_dropdown_callback(self): self.activation_type = self.activation_function_variable.get() self.display_activation_function()
class LeftFrame: """ This class creates and controls the widgets and figures in the left frame which are used to display the activation functions. Farhad Kamangar 2018_06_03 """ def __init__(self, root, master, debug_print_flag=False): self.master = master self.root = root ######################################################################### # Set up the constants and default values ######################################################################### self.xmin = -2.0 self.xmax = 2.0 self.ymin = -2.0 self.ymax = 2.0 self.epoch = 100 self.alpha_rate = 0.1 self.lambda_rate = 0.01 self.number_of_class = 4 self.number_of_hidden_layer = 100 self.number_of_samples = 200 self.generated_data_type = "s_curve" self.transfer_function_type = "RELU" self.data, self.original_ = generate_data(self.generated_data_type, self.number_of_samples, self.number_of_class) self.graph_value = np.linspace(self.xmin, self.xmax, 300, endpoint=True) self.mesh = np.vstack( map(np.ravel, np.meshgrid(self.graph_value, self.graph_value))).T ######################################################################### # Set up the tensors for the calculation ######################################################################### self.tf_X = tf.placeholder(dtype=tf.float64, name="X_vector") self.tf_y = tf.placeholder(dtype=tf.int32, name="labels") self.tf_W_hidden = tf.Variable( np.random.uniform(low=-0.1, high=0.1, size=(2, self.number_of_hidden_layer))) self.tf_b_hidden = tf.Variable( np.random.uniform(low=-0.1, high=0.1, size=self.number_of_hidden_layer)) self.tf_p_hidden_relu = tf.nn.relu( tf.add(tf.matmul(self.tf_X, self.tf_W_hidden), self.tf_b_hidden)) self.tf_p_hidden_sigmoid = tf.nn.sigmoid( tf.add(tf.matmul(self.tf_X, self.tf_W_hidden), self.tf_b_hidden)) self.tf_W_output = tf.Variable( np.random.uniform(low=-0.1, high=0.1, size=(self.number_of_hidden_layer, self.number_of_class))) self.tf_b_output = tf.Variable( np.random.uniform(low=-0.1, high=0.1, size=self.number_of_class)) if self.transfer_function_type == "RELU": self.tf_p_hidden = self.tf_p_hidden_relu else: self.tf_p_hidden = self.tf_p_hidden_sigmoid # self.b_output = tf.Variable(np.ones(self.number_of_class)) self.tf_p_output = tf.add( tf.matmul(self.tf_p_hidden, self.tf_W_output), self.tf_b_output) self.tf_p_output_softmax = tf.nn.softmax(self.tf_p_output, axis=1) self.tf_y_ = tf.argmax(input=self.tf_p_output_softmax, axis=1) self.tf_loss = tf.reduce_mean( tf.nn.softmax_cross_entropy_with_logits_v2( logits=self.tf_p_output, labels=tf.one_hot(self.tf_y, self.number_of_class))) self.tf_regularize_weights = tf.nn.l2_loss( self.tf_W_hidden) + tf.nn.l2_loss(self.tf_W_output) self.tf_loss = tf.reduce_mean(self.tf_loss + self.lambda_rate * self.tf_regularize_weights) self.tf_minimization_op = tf.train.GradientDescentOptimizer( learning_rate=self.alpha_rate).minimize(self.tf_loss) self.session = tf.InteractiveSession() self.reset_weights_function() ######################################################################### # Set up the plotting frame and controls frame ######################################################################### master.rowconfigure(0, weight=10, minsize=200) master.columnconfigure(0, weight=1) self.plot_frame = tk.Frame(self.master, borderwidth=10, relief=tk.SUNKEN) self.plot_frame.grid(row=0, column=0, columnspan=1, sticky=tk.N + tk.E + tk.S + tk.W) self.figure = plt.figure("") self.axes = self.figure.add_axes([0.15, 0.15, 0.6, 0.8]) # self.axes = self.figure.add_axes() self.axes = self.figure.gca() # self.axes.set_xlabel('Iteration') # self.axes.set_ylabel('Error') # self.axes.margins(0.5) self.axes.set_title("") plt.xlim(self.xmin, self.xmax) plt.ylim(self.ymin, self.ymax) self.canvas = FigureCanvasTkAgg(self.figure, master=self.plot_frame) self.plot_widget = self.canvas.get_tk_widget() self.plot_widget.grid(row=0, column=0, sticky=tk.N + tk.E + tk.S + tk.W) self.plot_widget.pack(side="top", fill='both', expand=True) # Create a frame to contain all the controls such as sliders, buttons, ... self.controls_frame = tk.Frame(self.master) self.controls_frame.grid(row=1, column=0, sticky=tk.N + tk.E + tk.S + tk.W) ######################################################################### # Set up the control widgets such as sliders and selection boxes ######################################################################### self.lambda_rate_slider = tk.Scale( self.controls_frame, variable=tk.DoubleVar(), orient=tk.HORIZONTAL, from_=0, to_=1, resolution=0.01, bg="#DDDDDD", activebackground="#FF0000", highlightcolor="#00FFFF", label="Lambda", command=lambda event: self.slider_callback()) self.lambda_rate_slider.set(self.lambda_rate) self.lambda_rate_slider.bind("<ButtonRelease-1>", lambda event: self.slider_callback()) self.lambda_rate_slider.grid(row=0, column=0, sticky=tk.N + tk.E + tk.S + tk.W) self.epoch_rate_slider = tk.Scale( self.controls_frame, variable=tk.DoubleVar(), orient=tk.HORIZONTAL, from_=10, to_=1000, resolution=10, bg="#DDDDDD", activebackground="#FF0000", highlightcolor="#00FFFF", label="Epoch", command=lambda event: self.slider_callback()) self.epoch_rate_slider.set(self.epoch) self.epoch_rate_slider.bind("<ButtonRelease-1>", lambda event: self.slider_callback()) self.epoch_rate_slider.grid(row=1, column=0, sticky=tk.N + tk.E + tk.S + tk.W) ######################################################################### # Set up the control widgets such as sliders and selection boxes ######################################################################### self.alpha_rate_slider = tk.Scale( self.controls_frame, variable=tk.DoubleVar(), orient=tk.HORIZONTAL, from_=0.000, to_=1, resolution=0.001, bg="#DDDDDD", activebackground="#FF0000", highlightcolor="#00FFFF", label="Alpha", command=lambda event: self.slider_callback()) self.alpha_rate_slider.set(self.alpha_rate) self.alpha_rate_slider.bind("<ButtonRelease-1>", lambda event: self.slider_callback()) self.alpha_rate_slider.grid(row=0, column=1, sticky=tk.N + tk.E + tk.S + tk.W) ######################################################################### # Set up the control widgets such as sliders and selection boxes ######################################################################### self.number_of_hidden_layer_slider = tk.Scale( self.controls_frame, variable=tk.DoubleVar(), orient=tk.HORIZONTAL, from_=1, to_=500, resolution=1, bg="#DDDDDD", activebackground="#FF0000", highlightcolor="#00FFFF", label="Hidden Layes", command=lambda event: self.slider_callback()) self.number_of_hidden_layer_slider.set(self.number_of_hidden_layer) self.number_of_hidden_layer_slider.bind( "<ButtonRelease-1>", lambda event: self.slider_callback()) self.number_of_hidden_layer_slider.grid(row=0, column=2, sticky=tk.N + tk.E + tk.S + tk.W) ######################################################################### # Set up the control widgets such as sliders and selection boxes ######################################################################### self.number_of_samples_slider = tk.Scale( self.controls_frame, variable=tk.DoubleVar(), orient=tk.HORIZONTAL, from_=4, to_=1000, resolution=1, bg="#DDDDDD", activebackground="#FF0000", highlightcolor="#00FFFF", label="Samples", command=lambda event: self.slider_callback()) self.number_of_samples_slider.set(self.number_of_samples) self.number_of_samples_slider.bind( "<ButtonRelease-1>", lambda event: self.slider_callback()) self.number_of_samples_slider.grid(row=0, column=3, sticky=tk.N + tk.E + tk.S + tk.W) ######################################################################### # Set up the control widgets such as sliders and selection boxes ######################################################################### self.number_of_classes_slider = tk.Scale( self.controls_frame, variable=tk.DoubleVar(), orient=tk.HORIZONTAL, from_=2, to_=10, resolution=1, bg="#DDDDDD", activebackground="#FF0000", highlightcolor="#00FFFF", label="Classes", command=lambda event: self.slider_callback()) self.number_of_classes_slider.set(self.number_of_class) self.number_of_classes_slider.bind( "<ButtonRelease-1>", lambda event: self.slider_callback()) self.number_of_classes_slider.grid(row=0, column=4, sticky=tk.N + tk.E + tk.S + tk.W) ######################################################################### # Set up the frame for drop down selection ######################################################################### self.reset_weights_button = tk.Button( self.controls_frame, text="Reset Weights", fg="blue", command=self.reset_weights_function) self.reset_weights_button.grid(row=0, column=5) self.adjust_weights = tk.Button(self.controls_frame, text="Adjust Wieghts(Training)", fg="blue", command=self.do_training) self.adjust_weights.grid(row=0, column=6) self.transfer_function = tk.StringVar() self.transfer_function_dropdown = tk.OptionMenu( self.controls_frame, self.transfer_function, "Sigmoid", "RELU", command=lambda event: self.activation_function_dropdown_callback()) self.transfer_function.set(self.transfer_function_type) self.transfer_function_dropdown.grid(row=1, column=5, sticky=tk.N + tk.E + tk.S + tk.W) self.generated_data = tk.StringVar() self.generated_data_dropdown = tk.OptionMenu( self.controls_frame, self.generated_data, "s_curve", "blobs", "swiss_roll", "moons", command=lambda event: self.generated_data_dropdown_callback()) self.generated_data.set(self.generated_data_type) self.generated_data_dropdown.grid(row=1, column=6, sticky=tk.N + tk.E + tk.S + tk.W) self.canvas.get_tk_widget().bind("<ButtonPress-1>", self.left_mouse_click_callback) self.canvas.get_tk_widget().bind("<ButtonPress-1>", self.left_mouse_click_callback) self.canvas.get_tk_widget().bind("<ButtonRelease-1>", self.left_mouse_release_callback) self.canvas.get_tk_widget().bind("<B1-Motion>", self.left_mouse_down_motion_callback) self.canvas.get_tk_widget().bind("<ButtonPress-3>", self.right_mouse_click_callback) self.canvas.get_tk_widget().bind("<ButtonRelease-3>", self.right_mouse_release_callback) self.canvas.get_tk_widget().bind("<B3-Motion>", self.right_mouse_down_motion_callback) self.canvas.get_tk_widget().bind("<Key>", self.key_pressed_callback) self.canvas.get_tk_widget().bind("<Up>", self.up_arrow_pressed_callback) self.canvas.get_tk_widget().bind("<Down>", self.down_arrow_pressed_callback) self.canvas.get_tk_widget().bind("<Right>", self.right_arrow_pressed_callback) self.canvas.get_tk_widget().bind("<Left>", self.left_arrow_pressed_callback) self.canvas.get_tk_widget().bind("<Shift-Up>", self.shift_up_arrow_pressed_callback) self.canvas.get_tk_widget().bind( "<Shift-Down>", self.shift_down_arrow_pressed_callback) self.canvas.get_tk_widget().bind( "<Shift-Right>", self.shift_right_arrow_pressed_callback) self.canvas.get_tk_widget().bind( "<Shift-Left>", self.shift_left_arrow_pressed_callback) self.canvas.get_tk_widget().bind("f", self.f_key_pressed_callback) self.canvas.get_tk_widget().bind("b", self.b_key_pressed_callback) def activation_function_dropdown_callback(self): self.transfer_function_type = self.transfer_function.get() if self.transfer_function_type == "RELU": self.tf_p_hidden = self.tf_p_hidden_relu else: self.tf_p_hidden = self.tf_p_hidden_sigmoid def reset_weights_function(self): self.session.run(tf.global_variables_initializer()) def generated_data_dropdown_callback(self): self.generated_data_type = self.generated_data.get() self.data, self.original_ = generate_data(self.generated_data_type, self.number_of_samples, self.number_of_class) def do_training(self): for step in range(self.epoch): self.session.run([self.tf_loss, self.tf_minimization_op], feed_dict={ self.tf_X: self.data, self.tf_y: self.original_ }) self.draw_graph(yy=self.session.run( self.tf_y_, feed_dict={self.tf_X: self.mesh})) def draw_graph(self, yy): self.axes.clear() self.axes.relim() self.axes.autoscale_view() self.axes.pcolormesh(self.graph_value, self.graph_value, np.reshape(yy, (300, 300)), cmap='viridis') #self.axes.scatter(self.mesh[:,0], self.mesh[:,1], c=yy, cmap=plt.cm.Accent) self.axes.scatter(self.data[:, 0], self.data[:, 1], c=self.original_, cmap=plt.cm.PiYG) #self.axes.xaxis.set_visible(True) plt.xlim(self.xmin, self.xmax) plt.ylim(self.ymin, self.ymax) plt.title(self.transfer_function_type + " with " + self.generated_data_type) self.canvas.draw() def slider_callback(self): self.lambda_rate = self.lambda_rate_slider.get() self.epoch = self.epoch_rate_slider.get() self.alpha_rate = self.alpha_rate_slider.get() if (self.number_of_hidden_layer != self.number_of_hidden_layer_slider.get()): self.number_of_hidden_layer = self.number_of_hidden_layer_slider.get( ) self.reset_weights_function() if (self.number_of_samples != self.number_of_samples_slider.get()): self.number_of_samples = self.number_of_samples_slider.get() self.generated_data_dropdown_callback() if (self.number_of_class != self.number_of_classes_slider.get()): self.number_of_class = self.number_of_classes_slider.get() self.generated_data_dropdown_callback() def key_pressed_callback(self, event): self.root.status_bar.set('%s', 'Key pressed') def up_arrow_pressed_callback(self, event): self.root.status_bar.set('%s', "Up arrow was pressed") def down_arrow_pressed_callback(self, event): self.root.status_bar.set('%s', "Down arrow was pressed") def right_arrow_pressed_callback(self, event): self.root.status_bar.set('%s', "Right arrow was pressed") def left_arrow_pressed_callback(self, event): self.root.status_bar.set('%s', "Left arrow was pressed") def shift_up_arrow_pressed_callback(self, event): self.root.status_bar.set('%s', "Shift up arrow was pressed") def shift_down_arrow_pressed_callback(self, event): self.root.status_bar.set('%s', "Shift down arrow was pressed") def shift_right_arrow_pressed_callback(self, event): self.root.status_bar.set('%s', "Shift right arrow was pressed") def shift_left_arrow_pressed_callback(self, event): self.root.status_bar.set('%s', "Shift left arrow was pressed") def f_key_pressed_callback(self, event): self.root.status_bar.set('%s', "f key was pressed") def b_key_pressed_callback(self, event): self.root.status_bar.set('%s', "b key was pressed") def left_mouse_click_callback(self, event): self.root.status_bar.set( '%s', 'Left mouse button was clicked. ' + 'x=' + str(event.x) + ' y=' + str(event.y)) self.x = event.x self.y = event.y self.canvas.focus_set() def left_mouse_release_callback(self, event): self.root.status_bar.set( '%s', 'Left mouse button was released. ' + 'x=' + str(event.x) + ' y=' + str(event.y)) self.x = None self.y = None def left_mouse_down_motion_callback(self, event): self.root.status_bar.set( '%s', 'Left mouse down motion. ' + 'x=' + str(event.x) + ' y=' + str(event.y)) self.x = event.x self.y = event.y def right_mouse_click_callback(self, event): self.root.status_bar.set( '%s', 'Right mouse down motion. ' + 'x=' + str(event.x) + ' y=' + str(event.y)) self.x = event.x self.y = event.y def right_mouse_release_callback(self, event): self.root.status_bar.set( '%s', 'Right mouse button was released. ' + 'x=' + str(event.x) + ' y=' + str(event.y)) self.x = None self.y = None def right_mouse_down_motion_callback(self, event): self.root.status_bar.set( '%s', 'Right mouse down motion. ' + 'x=' + str(event.x) + ' y=' + str(event.y)) self.x = event.x self.y = event.y def left_mouse_click_callback(self, event): self.root.status_bar.set( '%s', 'Left mouse button was clicked. ' + 'x=' + str(event.x) + ' y=' + str(event.y)) self.x = event.x self.y = event.y
class LeftFrame: """ This class creates and controls the widgets and figures in the left frame which are used to display the activation functions.""" def __init__(self, root, master, debug_print_flag=False): self.master = master self.root = root ######################################################################### # Set up the constants and default values ######################################################################### self.xmin = -10 self.xmax = 10 self.ymin = -10 self.ymax = 10 self.sampleFlag = 0 self.input_weight = 1 self.input_weight1 = 1 self.bias = 0.0 self.weight_array = np.array([self.input_weight, self.input_weight1]) self.plotLine = None self.plotFlag = False self.activation_type = "Symmetrical Hardlimit" ######################################################################### # Set up the plotting frame and controls frame ######################################################################### master.rowconfigure(0, weight=10, minsize=200) master.columnconfigure(0, weight=1, minsize=500) self.plot_frame = tk.Frame(self.master, borderwidth=10, relief=tk.SUNKEN) self.plot_frame.grid(row=0, column=0, columnspan=2, sticky=tk.N + tk.E + tk.S + tk.W) self.plot_frame.rowconfigure(0, weight=1, minsize=200) self.plot_frame.columnconfigure(0, weight=1, minsize=500) self.figure = plt.figure("") self.axes = self.figure.add_axes([0.15, 0.15, 0.6, 0.8]) # self.axes = self.figure.add_axes() self.axes = self.figure.gca() self.axes.set_xlabel('INPUT') self.axes.set_ylabel('OUTPUT') self.axes.set_visible(True) # self.axes.margins(0.5) self.axes.set_title("Binary Class Decision Boundary", loc='center') plt.xlim(self.xmin, self.xmax) plt.ylim(self.ymin, self.ymax) self.canvas = FigureCanvasTkAgg(self.figure, master=self.plot_frame) self.plot_widget = self.canvas.get_tk_widget() self.plot_widget.grid(row=0, column=0, sticky=tk.N + tk.E + tk.S + tk.W) # Create a frame to contain all the controls such as sliders, buttons, ... self.controls_frame = tk.Frame(self.master) self.controls_frame.grid(row=1, column=0, sticky=tk.N + tk.E + tk.S + tk.W) ######################################################################### # Set up the control widgets such as sliders and selection boxes ######################################################################### self.input_weight_slider = tk.Scale( self.controls_frame, variable=tk.DoubleVar(), orient=tk.HORIZONTAL, from_=-10.0, to_=10.0, resolution=0.01, bg="#DDDDDD", activebackground="#FF0000", highlightcolor="#00FFFF", label="Input Weight 1", command=lambda event: self.input_weight_slider_callback()) self.input_weight_slider.set(self.input_weight) self.input_weight_slider.bind( "<ButtonRelease-1>", lambda event: self.input_weight_slider_callback()) self.input_weight_slider.grid(row=0, column=0, sticky=tk.N + tk.E + tk.S + tk.W) self.input_weight_slider1 = tk.Scale( self.controls_frame, variable=tk.DoubleVar(), orient=tk.HORIZONTAL, from_=-10.0, to_=10.0, resolution=0.01, bg="#DDDDDD", activebackground="#FF0000", highlightcolor="#00FFFF", label="Input Weight 2", command=lambda event: self.input_weight_slider1_callback()) self.input_weight_slider1.set(self.input_weight1) self.input_weight_slider1.bind( "<ButtonRelease-1>", lambda event: self.input_weight_slider1_callback()) self.input_weight_slider1.grid(row=0, column=1, sticky=tk.N + tk.E + tk.S + tk.W) self.bias_slider = tk.Scale( self.controls_frame, variable=tk.DoubleVar(), orient=tk.HORIZONTAL, from_=-10.0, to_=10.0, resolution=0.01, bg="#DDDDDD", activebackground="#FF0000", highlightcolor="#00FFFF", label="Bias", command=lambda event: self.bias_slider_callback()) self.bias_slider.set(self.bias) self.bias_slider.bind("<ButtonRelease-1>", lambda event: self.bias_slider_callback()) self.bias_slider.grid(row=0, column=2, sticky=tk.N + tk.E + tk.S + tk.W) self.trainButton = tk.Button(self.controls_frame, text="Train", command=self.trainNeuralNetwork) self.trainButton.grid(row=0, column=4, sticky=tk.N + tk.E + tk.S + tk.W) self.randomPoints = tk.Button(self.controls_frame, text="Create Random Data", command=self.randomPointsGenerate) self.randomPoints.grid(row=0, column=5, sticky=tk.N + tk.E + tk.S + tk.W) ######################################################################### # Set up the frame for drop down selection ######################################################################### self.label_for_activation_function = tk.Label( self.controls_frame, text="Activation Function Type:", justify="center") self.label_for_activation_function.grid(row=0, column=3, sticky=tk.N + tk.E + tk.S + tk.W) self.activation_function_variable = tk.StringVar() self.activation_function_dropdown = tk.OptionMenu( self.controls_frame, self.activation_function_variable, "Linear", "Hyperbolic Tangent", "Symmetrical Hardlimit", command=lambda event: self.activation_function_dropdown_callback()) self.activation_function_variable.set("Symmetrical Hardlimit") self.activation_function_dropdown.grid(row=0, column=3, sticky=tk.N + tk.E + tk.S + tk.W) self.canvas.get_tk_widget().bind("<ButtonPress-1>", self.left_mouse_click_callback) self.canvas.get_tk_widget().bind("<ButtonPress-1>", self.left_mouse_click_callback) self.canvas.get_tk_widget().bind("<ButtonRelease-1>", self.left_mouse_release_callback) self.canvas.get_tk_widget().bind("<B1-Motion>", self.left_mouse_down_motion_callback) self.canvas.get_tk_widget().bind("<ButtonPress-3>", self.right_mouse_click_callback) self.canvas.get_tk_widget().bind("<ButtonRelease-3>", self.right_mouse_release_callback) self.canvas.get_tk_widget().bind("<B3-Motion>", self.right_mouse_down_motion_callback) self.canvas.get_tk_widget().bind("<Key>", self.key_pressed_callback) self.canvas.get_tk_widget().bind("<Up>", self.up_arrow_pressed_callback) self.canvas.get_tk_widget().bind("<Down>", self.down_arrow_pressed_callback) self.canvas.get_tk_widget().bind("<Right>", self.right_arrow_pressed_callback) self.canvas.get_tk_widget().bind("<Left>", self.left_arrow_pressed_callback) self.canvas.get_tk_widget().bind("<Shift-Up>", self.shift_up_arrow_pressed_callback) self.canvas.get_tk_widget().bind( "<Shift-Down>", self.shift_down_arrow_pressed_callback) self.canvas.get_tk_widget().bind( "<Shift-Right>", self.shift_right_arrow_pressed_callback) self.canvas.get_tk_widget().bind( "<Shift-Left>", self.shift_left_arrow_pressed_callback) self.canvas.get_tk_widget().bind("f", self.f_key_pressed_callback) self.canvas.get_tk_widget().bind("b", self.b_key_pressed_callback) def key_pressed_callback(self, event): self.root.status_bar.set('%s', 'Key pressed') def up_arrow_pressed_callback(self, event): self.root.status_bar.set('%s', "Up arrow was pressed") def down_arrow_pressed_callback(self, event): self.root.status_bar.set('%s', "Down arrow was pressed") def right_arrow_pressed_callback(self, event): self.root.status_bar.set('%s', "Right arrow was pressed") def left_arrow_pressed_callback(self, event): self.root.status_bar.set('%s', "Left arrow was pressed") def shift_up_arrow_pressed_callback(self, event): self.root.status_bar.set('%s', "Shift up arrow was pressed") def shift_down_arrow_pressed_callback(self, event): self.root.status_bar.set('%s', "Shift down arrow was pressed") def shift_right_arrow_pressed_callback(self, event): self.root.status_bar.set('%s', "Shift right arrow was pressed") def shift_left_arrow_pressed_callback(self, event): self.root.status_bar.set('%s', "Shift left arrow was pressed") def f_key_pressed_callback(self, event): self.root.status_bar.set('%s', "f key was pressed") def b_key_pressed_callback(self, event): self.root.status_bar.set('%s', "b key was pressed") def left_mouse_click_callback(self, event): self.root.status_bar.set( '%s', 'Left mouse button was clicked. ' + 'x=' + str(event.x) + ' y=' + str(event.y)) self.x = event.x self.y = event.y self.canvas.focus_set() def left_mouse_release_callback(self, event): self.root.status_bar.set( '%s', 'Left mouse button was released. ' + 'x=' + str(event.x) + ' y=' + str(event.y)) self.x = None self.y = None def left_mouse_down_motion_callback(self, event): self.root.status_bar.set( '%s', 'Left mouse down motion. ' + 'x=' + str(event.x) + ' y=' + str(event.y)) self.x = event.x self.y = event.y def right_mouse_click_callback(self, event): self.root.status_bar.set( '%s', 'Right mouse down motion. ' + 'x=' + str(event.x) + ' y=' + str(event.y)) self.x = event.x self.y = event.y def right_mouse_release_callback(self, event): self.root.status_bar.set( '%s', 'Right mouse button was released. ' + 'x=' + str(event.x) + ' y=' + str(event.y)) self.x = None self.y = None def right_mouse_down_motion_callback(self, event): self.root.status_bar.set( '%s', 'Right mouse down motion. ' + 'x=' + str(event.x) + ' y=' + str(event.y)) self.x = event.x self.y = event.y def left_mouse_click_callback(self, event): self.root.status_bar.set( '%s', 'Left mouse button was clicked. ' + 'x=' + str(event.x) + ' y=' + str(event.y)) self.x = event.x self.y = event.y def randomPointsGenerate(self): self.axes.cla() self.plotLine = None self.bias = 0 self.bias_slider.set(self.bias) self.input_weight = self.weight_array[0] = 1 self.input_weight_slider.set(self.input_weight) self.input_weight1 = self.weight_array[1] = 1 self.input_weight_slider1.set(self.input_weight1) self.display_activation_function() self.N = 4 self.x = np.random.randint(-10, 10, self.N) self.y = np.random.randint(-10, 10, self.N) self.class1X = self.x[:int(self.N / 2)] self.class1Y = self.y[:int(self.N / 2)] self.class2X = self.x[int(self.N / 2):] self.class2Y = self.y[int(self.N / 2):] plt.xlim(self.xmin, self.xmax) plt.ylim(self.ymin, self.ymax) plt.plot(self.class1X, self.class1Y, 'yo', markersize=6, label='Class 1') plt.plot(self.class2X, self.class2Y, 'bo', markersize=6, label='Class -1') plt.legend(loc='upper left', bbox_to_anchor=(1, 1)) plt.title("Binary Class Decision Boundary", loc='center') self.target = np.array([1, -1]) self.plotFlag = False self.canvas.draw() def trainNeuralNetwork(self, plotFlag=False): self.plotFlag = plotFlag if self.plotLine != None: try: for line in self.plotLine: line.remove() except: pass epochs = 100 inputarr = [] if self.plotFlag == False: for index, element in enumerate(self.x): inputarr.append([element, self.y[index]]) input_array = np.array(inputarr) epochCounter = 0 plotLine1 = None for epoch in range(0, epochs): if plotLine1 != None: for line in plotLine1: line.remove() epochCounter += 1 #errorList = [] for index, inputIter in enumerate(input_array): activation, net_value = Joshi_02_02.calculate_activation_function( self.weight_array, self.bias, inputIter, self.activation_type) np.add(self.weight_array, ((self.target[int(index / 2)]) - activation) * inputIter, out=self.weight_array, casting='unsafe') self.bias += (self.target[int(index / 2)] - activation) self.display_activation_function() self.plotFlag = False def display_activation_function(self): if self.plotLine != None: try: for line in self.plotLine: line.remove() except: pass resolution = 100 xs = np.linspace(-10., 10., resolution) ys = np.linspace(-10., 10., resolution) xx, yy = np.meshgrid(xs, ys) zz = (self.weight_array[0] * xx) + (self.weight_array[1] * yy) + self.bias if self.activation_type == "Linear": gradientNorm = MidpointNormalize() quad = self.axes.pcolormesh(xs, ys, zz, cmap=LinearSegmentedColormap.from_list( 'rg', ["r", "w", "g"], N=256), norm=gradientNorm) elif self.activation_type == "Symmetrical Hardlimit": zz[zz < 0] = -1 zz[zz >= 0] = +1 quad = self.axes.pcolormesh(xs, ys, zz, cmap=LinearSegmentedColormap.from_list( 'rg', ["r", "w", "g"], N=256)) elif self.activation_type == "Hyperbolic Tangent": zz = np.tanh(zz) quad = self.axes.pcolormesh(xs, ys, zz, cmap=LinearSegmentedColormap.from_list( 'rg', ["r", "w", "g"], N=256)) plt.xlim(self.xmin, self.xmax) plt.ylim(self.ymin, self.ymax) ax1 = self.figure.gca() if self.weight_array[1] != 0: self.plotLine = ax1.plot( xx[0], (-self.bias - (self.weight_array[0] * xx[0])) / self.weight_array[1], xx[1], (-self.bias - (self.weight_array[0] * xx[1])) / self.weight_array[1], 'k') elif self.weight_array[1] == 0: if self.weight_array[0] == 0: self.plotLine = ax1.plot(xx[0] * 0 - (self.bias), xx[0], xx[1] * 0 - (self.bias), xx[1], 'k') else: self.plotLine = ax1.plot( xx[0] * 0 - (self.bias / self.weight_array[0]), xx[0], xx[1] * 0 - (self.bias / self.weight_array[0]), xx[1], 'k') self.canvas.draw() def input_weight_slider_callback(self): self.input_weight = np.float(self.input_weight_slider.get()) self.weight_array[0] = self.input_weight self.display_activation_function() #self.trainNeuralNetwork(True) def input_weight_slider1_callback(self): self.input_weight1 = np.float(self.input_weight_slider1.get()) self.weight_array[1] = self.input_weight1 self.display_activation_function() #self.trainNeuralNetwork(True) def bias_slider_callback(self): self.bias = np.float(self.bias_slider.get()) self.display_activation_function() #self.trainNeuralNetwork(True) def activation_function_dropdown_callback(self): self.activation_type = self.activation_function_variable.get() self.display_activation_function()
class MainFrame: """ This class creates and controls the widgets and figures in the left frame which are used to display the activation functions. Gajanan Wadekar 09-06-2018 """ def __init__(self, root, master, debug_print_flag=False): self.master = master self.root = root ######################################################################### # Set up the constants and default values ######################################################################### self.xmin = -10 self.xmax = 10 self.ymin = -10 self.ymax = 10 self.input_weight1 = 1 self.input_weight2 = 1 self.bias = 0.0 self.activation_type = "Symmetrical Hard limit" self.x1 = 0 self.y1 = 0 self.x2 = 0 self.y2 = 0 self.x3 = 0 self.y3 = 0 self.x4 = 0 self.y4 = 0 ######################################################################### # Set up the plotting frame and controls frame ######################################################################### master.rowconfigure(0, weight=10, minsize=500) master.columnconfigure(0, weight=1) self.plot_frame = tk.Frame(self.master, borderwidth=10, relief=tk.SUNKEN) self.plot_frame.grid(row=0, column=0, columnspan=2, sticky=tk.E + tk.W + tk.N + tk.S) self.figure = plt.figure("") self.axes = self.figure.add_axes([0.15, 0.15, 0.6, 0.8]) # self.axes = self.figure.add_axes() self.axes = self.figure.gca() self.axes.set_xlabel('Input') self.axes.set_ylabel('Output') # self.axes.margins(0.5) self.axes.set_title("") plt.xlim(self.xmin, self.xmax) plt.ylim(self.ymin, self.ymax) self.canvas = FigureCanvasTkAgg(self.figure, master=self.plot_frame) self.plot_widget = self.canvas.get_tk_widget().pack(fill=tk.BOTH) # Create a frame to contain all the controls such as sliders, buttons, ... self.controls_frame = tk.Frame(self.master) self.controls_frame.grid(row=1, column=0, sticky=tk.N) ######################################################################### # Set up the control widgets such as sliders and selection boxes ######################################################################### self.input_weight_slider1 = tk.Scale( self.controls_frame, variable=tk.DoubleVar(), orient=tk.HORIZONTAL, from_=-10.0, to_=10.0, width=30, resolution=0.01, bg="#DDDDDD", activebackground="#FF0000", highlightcolor="#00FFFF", label="First Weight(W1)", command=lambda event: self.input_weight_slider_callback1()) self.input_weight_slider1.set(self.input_weight1) self.input_weight_slider1.bind( "<ButtonRelease-1>", lambda event: self.input_weight_slider_callback1()) self.input_weight_slider1.grid(row=0, column=0, sticky=tk.N + tk.E + tk.S + tk.W) self.input_weight_slider2 = tk.Scale( self.controls_frame, variable=tk.DoubleVar(), orient=tk.HORIZONTAL, from_=-10.0, to_=10.0, width=30, resolution=0.01, bg="#DDDDDD", activebackground="#FF0000", highlightcolor="#00FFFF", label="Second Weight(W2)", command=lambda event: self.input_weight_slider_callback2()) self.input_weight_slider2.set(self.input_weight2) self.input_weight_slider2.bind( "<ButtonRelease-1>", lambda event: self.input_weight_slider_callback2()) self.input_weight_slider2.grid(row=0, column=1, sticky=tk.N + tk.S + tk.W) self.bias_slider = tk.Scale( self.controls_frame, variable=tk.DoubleVar(), width=30, orient=tk.HORIZONTAL, from_=-10.0, to_=10.0, resolution=0.01, bg="#DDDDDD", activebackground="#FF0000", highlightcolor="#00FFFF", label="Bias", command=lambda event: self.bias_slider_callback()) self.bias_slider.set(self.bias) self.bias_slider.bind("<ButtonRelease-1>", lambda event: self.bias_slider_callback()) self.bias_slider.grid(row=0, column=2, sticky=tk.N + tk.E + tk.S + tk.W) self.input_generate_button = tk.Button( self.controls_frame, text='Create random data', width=20, command=lambda: self.Generate_random_input_callback) self.input_generate_button.bind( "<ButtonRelease-1>", lambda event: self.Generate_random_input_callback()) self.input_generate_button.grid(row=0, column=3) self.learn_weight_button = tk.Button( self.controls_frame, text='Train', width=20, command=lambda: self.Learn_new_weight_callback()) self.learn_weight_button.bind( "<ButtonRelease-2>", lambda event: self.Learn_new_weight_callback()) self.learn_weight_button.grid(row=0, column=4) #self.input_generate_button.set() ######################################################################### # Set up the frame for drop down selection ######################################################################### self.label_for_activation_function = tk.Label( self.controls_frame, text="Activation Function Type:") self.label_for_activation_function.grid(row=0, column=5, sticky=tk.N + tk.E + tk.S + tk.W) self.activation_function_variable = tk.StringVar() self.activation_function_dropdown = tk.OptionMenu( self.controls_frame, self.activation_function_variable, "Symmetrical Hard limit", "Linear", "Hyperbolic Tangent", command=lambda event: self.activation_function_dropdown_callback()) self.activation_function_variable.set("Symmetrical Hard limit") self.activation_function_dropdown.grid(row=0, column=6, sticky=tk.N + tk.E + tk.S + tk.W) self.canvas.get_tk_widget().bind("<ButtonPress-1>", self.left_mouse_click_callback) self.canvas.get_tk_widget().bind("<ButtonPress-1>", self.left_mouse_click_callback) self.canvas.get_tk_widget().bind("<ButtonRelease-1>", self.left_mouse_release_callback) self.canvas.get_tk_widget().bind("<B1-Motion>", self.left_mouse_down_motion_callback) self.canvas.get_tk_widget().bind("<ButtonPress-3>", self.right_mouse_click_callback) self.canvas.get_tk_widget().bind("<ButtonRelease-3>", self.right_mouse_release_callback) self.canvas.get_tk_widget().bind("<B3-Motion>", self.right_mouse_down_motion_callback) self.canvas.get_tk_widget().bind("<Key>", self.key_pressed_callback) self.canvas.get_tk_widget().bind("<Up>", self.up_arrow_pressed_callback) self.canvas.get_tk_widget().bind("<Down>", self.down_arrow_pressed_callback) self.canvas.get_tk_widget().bind("<Right>", self.right_arrow_pressed_callback) self.canvas.get_tk_widget().bind("<Left>", self.left_arrow_pressed_callback) self.canvas.get_tk_widget().bind("<Shift-Up>", self.shift_up_arrow_pressed_callback) self.canvas.get_tk_widget().bind( "<Shift-Down>", self.shift_down_arrow_pressed_callback) self.canvas.get_tk_widget().bind( "<Shift-Right>", self.shift_right_arrow_pressed_callback) self.canvas.get_tk_widget().bind( "<Shift-Left>", self.shift_left_arrow_pressed_callback) self.canvas.get_tk_widget().bind("f", self.f_key_pressed_callback) self.canvas.get_tk_widget().bind("b", self.b_key_pressed_callback) def key_pressed_callback(self, event): self.root.status_bar.set('%s', 'Key pressed') def up_arrow_pressed_callback(self, event): self.root.status_bar.set('%s', "Up arrow was pressed") def down_arrow_pressed_callback(self, event): self.root.status_bar.set('%s', "Down arrow was pressed") def right_arrow_pressed_callback(self, event): self.root.status_bar.set('%s', "Right arrow was pressed") def left_arrow_pressed_callback(self, event): self.root.status_bar.set('%s', "Left arrow was pressed") def shift_up_arrow_pressed_callback(self, event): self.root.status_bar.set('%s', "Shift up arrow was pressed") def shift_down_arrow_pressed_callback(self, event): self.root.status_bar.set('%s', "Shift down arrow was pressed") def shift_right_arrow_pressed_callback(self, event): self.root.status_bar.set('%s', "Shift right arrow was pressed") def shift_left_arrow_pressed_callback(self, event): self.root.status_bar.set('%s', "Shift left arrow was pressed") def f_key_pressed_callback(self, event): self.root.status_bar.set('%s', "f key was pressed") def b_key_pressed_callback(self, event): self.root.status_bar.set('%s', "b key was pressed") def left_mouse_click_callback(self, event): self.root.status_bar.set( '%s', 'Left mouse button was clicked. ' + 'x=' + str(event.x) + ' y=' + str(event.y)) self.x = event.x self.y = event.y self.canvas.focus_set() def left_mouse_release_callback(self, event): self.root.status_bar.set( '%s', 'Left mouse button was released. ' + 'x=' + str(event.x) + ' y=' + str(event.y)) self.x = None self.y = None def left_mouse_down_motion_callback(self, event): self.root.status_bar.set( '%s', 'Left mouse down motion. ' + 'x=' + str(event.x) + ' y=' + str(event.y)) self.x = event.x self.y = event.y def right_mouse_click_callback(self, event): self.root.status_bar.set( '%s', 'Right mouse down motion. ' + 'x=' + str(event.x) + ' y=' + str(event.y)) self.x = event.x self.y = event.y def right_mouse_release_callback(self, event): self.root.status_bar.set( '%s', 'Right mouse button was released. ' + 'x=' + str(event.x) + ' y=' + str(event.y)) self.x = None self.y = None def right_mouse_down_motion_callback(self, event): self.root.status_bar.set( '%s', 'Right mouse down motion. ' + 'x=' + str(event.x) + ' y=' + str(event.y)) self.x = event.x self.y = event.y def left_mouse_click_callback(self, event): self.root.status_bar.set( '%s', 'Left mouse button was clicked. ' + 'x=' + str(event.x) + ' y=' + str(event.y)) self.x = event.x self.y = event.y def display_activation_function(self): # creating random points between -10 and +10 u1 = random.randint(-10, 10) v1 = random.randint(-10, 10) u2 = random.randint(-10, 10) v2 = random.randint(-10, 10) u3 = random.randint(-10, 10) v3 = random.randint(-10, 10) u4 = random.randint(-10, 10) v4 = random.randint(-10, 10) self.x1 = u1 self.y1 = v1 self.x2 = u2 self.y2 = v2 self.x3 = u3 self.y3 = v3 self.x4 = u4 self.y4 = v4 # plotting the generated points by categorizing them self.axes.cla() self.axes.set_xlabel('Input') self.axes.set_ylabel('Output') self.axes.plot(u1, v1, 'xw') self.axes.plot(u2, v2, 'xw') self.axes.plot(u3, v3, 'yo') self.axes.plot(u4, v4, 'yo') self.axes.xaxis.set_visible(True) self.draw_boundry_line() def learn_new_weight(self): for each in range(1, 100): # for point 1 P1(x1,y1) target is 1 net_value = self.input_weight1 * self.x1 + self.input_weight2 * self.y1 + self.bias activation = self.calculate_activation_function( net_value, self.activation_type) if activation == 1: pass else: self.input_weight1 = self.input_weight1 + ( 1 - activation) * self.x1 self.input_weight2 = self.input_weight2 + ( 1 - activation) * self.y1 self.bias = self.bias + (1 - activation) # for point 1 P1(x2,y2) target is 1 net_value = self.input_weight1 * self.x2 + self.input_weight2 * self.y2 + self.bias activation = self.calculate_activation_function( net_value, self.activation_type) if activation == 1: pass else: self.input_weight1 = self.input_weight1 + ( 1 - activation) * self.x2 self.input_weight2 = self.input_weight2 + ( 1 - activation) * self.y2 self.bias = self.bias + (1 - activation) # for point 1 P1(x3,y3) target is -1 net_value = self.input_weight1 * self.x3 + self.input_weight2 * self.y3 + self.bias activation = self.calculate_activation_function( net_value, self.activation_type) if activation == -1: pass else: self.input_weight1 = self.input_weight1 + ( -1 - activation) * self.x3 self.input_weight2 = self.input_weight2 + ( -1 - activation) * self.y3 self.bias = self.bias + (1 - activation) # for point 1 P1(x4,y4) target is -1 net_value = self.input_weight1 * self.x4 + self.input_weight2 * self.y4 + self.bias activation = self.calculate_activation_function( net_value, self.activation_type) if activation == -1: pass else: self.input_weight1 = self.input_weight1 + ( -1 - activation) * self.x4 self.input_weight2 = self.input_weight2 + ( -1 - activation) * self.y4 self.bias = self.bias + (1 - activation) self.draw_boundry_line() def calculate_activation_function(self, net_value, type='Symmetrical Hard limit'): if type == 'Symmetrical Hard limit': if net_value >= 0: activation = 1 else: activation = -1 elif type == "Linear": activation = net_value elif type == "Hyperbolic Tangent": activation = ((np.exp(net_value) - np.exp(-net_value)) / (np.exp(net_value) + np.exp(-net_value))) return activation def draw_boundry_line(self): #for updating values into graph while training self.input_weight_slider1.set(self.input_weight1) self.input_weight_slider2.set(self.input_weight2) self.bias_slider.set(self.bias) #setting resolution of the plot, as we need resolution of 100x100 resolution = 100 xs = np.linspace(-10., 10., resolution) ys = np.linspace(-10., 10., resolution) xx, yy = np.meshgrid(xs, ys) zz = self.input_weight1 * xx + self.input_weight2 * yy + self.bias #Equation of decision boundary zz[zz > 0] = 1 zz[zz < 0] = -1 self.axes.pcolormesh(xs, ys, zz, cmap='RdYlGn') plt.xlim(self.xmin, self.xmax) plt.ylim(self.ymin, self.ymax) plt.title(self.activation_type) self.canvas.draw() # callback methods for sliders, buttons, and drop downlists def input_weight_slider_callback1(self): self.input_weight1 = np.float(self.input_weight_slider1.get()) self.draw_boundry_line() def input_weight_slider_callback2(self): self.input_weight2 = np.float(self.input_weight_slider2.get()) self.draw_boundry_line() def Generate_random_input_callback(self): self.bias = 0 self.input_weight1 = 1 self.input_weight2 = 1 self.display_activation_function() def Learn_new_weight_callback(self): self.learn_new_weight() def bias_slider_callback(self): self.bias = np.float(self.bias_slider.get()) self.draw_boundry_line() def activation_function_dropdown_callback(self): self.activation_type = self.activation_function_variable.get() self.draw_boundry_line()
class RightFrame: """ This class is for creating right frame widgets which are used to draw graphics on canvas as well as embedding matplotlib figures in the tkinter. Farhad Kamangar 2018_06_03 """ def __init__(self, root, master, debug_print_flag=False): self.master = master self.root = root ######################################################################### # Set up the constants and default values ######################################################################### self.ep = 0.0 self.xmin = 0 self.xmax = 10 self.ymin = 0 self.ymax = 2 self.debug_print_flag = debug_print_flag self.Number_of_Delayed_Elements = 10 self.Learning_Rate = 0.1 self.Training_Sample_Size = 80 self.Stride = 1 self.Number_of_Iterations = 10 ######################################################################### # Set up the plotting frame and controls frame ######################################################################### master.rowconfigure(0, weight=10, minsize=200) master.columnconfigure(0, weight=1) self.plot_frame = tk.Frame(self.master, borderwidth=10, relief=tk.SUNKEN) self.plot_frame.grid(row=0, column=0, columnspan=1, sticky=tk.N + tk.E + tk.S + tk.W) self.figure = plt.figure(figsize=(6, 4)) self.plot_frame1 = tk.Frame(self.master, borderwidth=10, relief=tk.SUNKEN) self.plot_frame1.grid(row=0, column=1, columnspan=2, sticky=tk.N + tk.E + tk.S + tk.W) self.figure1 = plt.figure(figsize=(6, 4)) self.axes = self.figure.add_axes([0.15, 0.15, 0.6, 0.8]) self.axes = self.figure.add_axes() self.axes = self.figure.gca() self.axes1 = self.figure1.add_axes([0.15, 0.15, 0.6, 0.8]) self.axes1 = self.figure1.add_axes() self.axes1 = self.figure1.gca() # self.axes.margins(0.5) self.axes.set_title("MSE") self.axes1.set_title("MAE") self.canvas = FigureCanvasTkAgg(self.figure, master=self.plot_frame) self.canvas1 = FigureCanvasTkAgg(self.figure1, master=self.plot_frame) self.plot_widget = self.canvas.get_tk_widget() self.plot_widget.grid(row=0, column=0, sticky=tk.N + tk.E + tk.S + tk.W) self.plot_widget = self.canvas1.get_tk_widget() self.plot_widget.grid(row=0, column=1, sticky=tk.N + tk.E + tk.S + tk.W) # Create a frame to contain all the controls such as sliders, buttons, ... self.controls_frame = tk.Frame(self.master) self.controls_frame.grid(row=1, column=0, sticky=tk.N + tk.E + tk.S + tk.W) ######################################################################### # Set up the control widgets such as sliders and selection boxes ######################################################################### self.Number_of_Delayed_Elements_slider = tk.Scale( self.controls_frame, variable=tk.DoubleVar(), orient=tk.HORIZONTAL, from_=0.0, to_=100, resolution=1, bg="#DDDDDD", activebackground="#FF0000", highlightcolor="#00FFFF", label="Number of Delayed Elements", command=lambda event: self. Number_of_Delayed_Elements_slider_callback()) self.Number_of_Delayed_Elements_slider.set( self.Number_of_Delayed_Elements) self.Number_of_Delayed_Elements_slider.bind( "<ButtonRelease-1>", lambda event: self.Number_of_Delayed_Elements_slider_callback()) self.Number_of_Delayed_Elements_slider.grid(row=0, column=2, sticky=tk.N + tk.E + tk.S + tk.W) #------------------------------- self.Learning_Rate_slider = tk.Scale( self.controls_frame, variable=tk.DoubleVar(), orient=tk.HORIZONTAL, from_=0.001, to_=1.0, resolution=0.01, bg="#DDDDDD", activebackground="#FF0000", highlightcolor="#00FFFF", label="Learning Rate", command=lambda event: self.Learning_Rate_slider_callback()) self.Learning_Rate_slider.set(self.Learning_Rate) self.Learning_Rate_slider.bind( "<ButtonRelease-1>", lambda event: self.Learning_Rate_slider_callback()) self.Learning_Rate_slider.grid(row=1, column=2, sticky=tk.N + tk.E + tk.S + tk.W) #------------------------------- self.Training_Sample_Size_slider = tk.Scale( self.controls_frame, variable=tk.DoubleVar(), orient=tk.HORIZONTAL, from_=0, to_=100, resolution=1, bg="#DDDDDD", activebackground="#FF0000", highlightcolor="#00FFFF", label="Training Sample Size", command=lambda event: self.Training_Sample_Size_slider_callback()) self.Training_Sample_Size_slider.set(self.Training_Sample_Size) self.Training_Sample_Size_slider.bind( "<ButtonRelease-1>", lambda event: self.Training_Sample_Size_slider_callback()) self.Training_Sample_Size_slider.grid(row=3, column=2, sticky=tk.N + tk.E + tk.S + tk.W) #------------------------------- self.Stride_slider = tk.Scale( self.controls_frame, variable=tk.DoubleVar(), orient=tk.HORIZONTAL, from_=1, to_=100, resolution=1, bg="#DDDDDD", activebackground="#FF0000", highlightcolor="#00FFFF", label="Stride", command=lambda event: self.Stride_slider_callback()) self.Stride_slider.set(self.Stride) self.Stride_slider.bind("<ButtonRelease-1>", lambda event: self.Stride_slider_callback()) self.Stride_slider.grid(row=4, column=2, sticky=tk.N + tk.E + tk.S + tk.W) #------------------------------- self.Number_of_Iterations_slider = tk.Scale( self.controls_frame, variable=tk.DoubleVar(), orient=tk.HORIZONTAL, from_=1, to_=100, resolution=1, bg="#DDDDDD", activebackground="#FF0000", highlightcolor="#00FFFF", label="Number of Iterations", command=lambda event: self.Number_of_Iterations_slider_callback()) self.Number_of_Iterations_slider.set(self.Number_of_Iterations) self.Number_of_Iterations_slider.bind( "<ButtonRelease-1>", lambda event: self.Number_of_Iterations_slider_callback()) self.Number_of_Iterations_slider.grid(row=5, column=2, sticky=tk.N + tk.E + tk.S + tk.W) #------------------------------- ######################################################################### # Set up the frame for botton selection ######################################################################### self.Set_Weights_to_Zero_button = tk.Button( self.controls_frame, text="Set Weights to Zero", fg="red", width=16, command=self.Set_Weights_to_Zero_callback) self.Adjust_Weights_LMS_button = tk.Button( self.controls_frame, text="Adjust Weights (LMS)", fg="red", width=16, command=self.Adjust_Weights_LMS_callback) self.Adjust_Weights_Direct_button = tk.Button( self.controls_frame, text="Adjust Weights(Direct)", fg="red", width=16, command=self.Adjust_Weights_Direct_callback) self.Set_Weights_to_Zero_button.grid(row=0, column=4) self.Adjust_Weights_LMS_button.grid(row=1, column=4) self.Adjust_Weights_Direct_button.grid(row=2, column=4) self.canvas.get_tk_widget().bind("<ButtonPress-1>", self.left_mouse_click_callback) self.canvas.get_tk_widget().bind("<ButtonPress-1>", self.left_mouse_click_callback) self.canvas.get_tk_widget().bind("<ButtonRelease-1>", self.left_mouse_release_callback) self.canvas.get_tk_widget().bind("<B1-Motion>", self.left_mouse_down_motion_callback) self.canvas.get_tk_widget().bind("<ButtonPress-3>", self.right_mouse_click_callback) self.canvas.get_tk_widget().bind("<ButtonRelease-3>", self.right_mouse_release_callback) self.canvas.get_tk_widget().bind("<B3-Motion>", self.right_mouse_down_motion_callback) self.canvas.get_tk_widget().bind("<Key>", self.key_pressed_callback) self.canvas.get_tk_widget().bind("<Up>", self.up_arrow_pressed_callback) self.canvas.get_tk_widget().bind("<Down>", self.down_arrow_pressed_callback) self.canvas.get_tk_widget().bind("<Right>", self.right_arrow_pressed_callback) self.canvas.get_tk_widget().bind("<Left>", self.left_arrow_pressed_callback) self.canvas.get_tk_widget().bind("<Shift-Up>", self.shift_up_arrow_pressed_callback) self.canvas.get_tk_widget().bind( "<Shift-Down>", self.shift_down_arrow_pressed_callback) self.canvas.get_tk_widget().bind( "<Shift-Right>", self.shift_right_arrow_pressed_callback) self.canvas.get_tk_widget().bind( "<Shift-Left>", self.shift_left_arrow_pressed_callback) self.canvas.get_tk_widget().bind("f", self.f_key_pressed_callback) self.canvas.get_tk_widget().bind("b", self.b_key_pressed_callback) def read_csv_as_matrix(self, file_name): # Each row of data in the file becomes a row in the matrix # So the resulting matrix has dimension [num_samples x sample_dimension] data = np.loadtxt(file_name, skiprows=1, delimiter=',', dtype=np.float32) return data def data_price_volume(self): data = self.read_csv_as_matrix('data.csv') self.data_normalize = 2 * ((data - data.min(axis=0)) / (data.max(axis=0) - data.min(axis=0))) - 1 def data(self): self.data_price_volume() #dividing data into training and test parts based on training sample size s = int(self.data_normalize.shape[0] * self.Training_Sample_Size / 100) data_train = np.array_split(self.data_normalize, [s]) self.train = data_train[0] self.test = data_train[1] self.Target_Vectors_Train = [] self.Input_Vectors_Train = [] self.Target_Vectors_Test = [] self.Input_Vectors_Test = [] #creating one sample input for train and test r = int((self.train.shape[0] - self.Number_of_Delayed_Elements - 1) / self.Stride) for k in range(0, r): current = self.Number_of_Delayed_Elements + (k * self.Stride) self.Target_Vectors_Train.append(self.train[current + 1, 0]) input_train = [] for i in range(0, self.Number_of_Delayed_Elements + 1): input_train.append(self.train[current - i, 0]) input_train.append(self.train[current - i, 1]) input_train.append(1) self.Input_Vectors_Train.append(input_train) #----------------------------------- r = (self.test.shape[0] - self.Number_of_Delayed_Elements - 1) for k in range(0, r): current = self.Number_of_Delayed_Elements + k self.Target_Vectors_Test.append(self.test[current + 1, 0]) input_test = [] for i in range(0, self.Number_of_Delayed_Elements + 1): input_test.append(self.test[current - i, 0]) input_test.append(self.test[current - i, 1]) input_test.append(1) self.Input_Vectors_Test.append(input_test) def Number_of_Delayed_Elements_slider_callback(self): self.Number_of_Delayed_Elements = np.int( self.Number_of_Delayed_Elements_slider.get()) def Learning_Rate_slider_callback(self): self.Learning_Rate = np.float(self.Learning_Rate_slider.get()) def Training_Sample_Size_slider_callback(self): self.Training_Sample_Size = np.int( self.Training_Sample_Size_slider.get()) def Stride_slider_callback(self): self.Stride = np.int(self.Stride_slider.get()) def Number_of_Iterations_slider_callback(self): self.Number_of_Iterations = np.int( self.Number_of_Iterations_slider.get()) def Set_Weights_to_Zero_callback(self): self.Set_Weights_to_Zero() def Adjust_Weights_LMS_callback(self): self.Adjust_Weights_LMS() def Adjust_Weights_Direct_callback(self): self.Adjust_Weights_Direct() def Set_Weights_to_Zero(self): #added with biases self.No_of_samples = self.Number_of_Delayed_Elements * 2 + 2 s = (1, self.No_of_samples + 1) self.Weight = np.zeros(s) def Adjust_Weights_LMS(self): self.data() j = 0 self.ep = [] self.error_MSE = [] self.error_MAE = [] while (j < self.Number_of_Iterations): for i in range(0, len(self.Input_Vectors_Train)): a = np.dot(self.Weight, self.Input_Vectors_Train[i]) e = self.Target_Vectors_Train[i] - a self.Weight = self.Weight + 2 * self.Learning_Rate * e * np.transpose( self.Input_Vectors_Train[i]) j = j + 1 self.ep.append(j) #calculating error error_MSE = [] error_MAE = [] for i in range(0, len(self.Input_Vectors_Test)): a = np.dot(self.Weight, self.Input_Vectors_Test[i]) e = self.Target_Vectors_Test[i] - a error_MSE.append(math.pow(e, 2)) error_MAE.append(e) error_MSE = np.mean(error_MSE) error_MAE = np.max(error_MAE) self.error_MSE.append(error_MSE) self.error_MAE.append(error_MAE) self.display_error_epoch() print('self.error_MSE-LMS', self.error_MSE) print('self.error_MAE-LMS', self.error_MAE) def Adjust_Weights_Direct(self): self.data() h_train = [] R_train = [] self.ep = [1] #calculating list of tz and zz for i in range(0, int(len(self.Input_Vectors_Train))): h = self.Target_Vectors_Train[i] * np.transpose( self.Input_Vectors_Train[i]) h_train.append(h) self.Input_Vectors_Train[i] = np.reshape( self.Input_Vectors_Train[i], (self.Number_of_Delayed_Elements * 2 + 3, 1)) R = np.dot(self.Input_Vectors_Train[i], np.transpose(self.Input_Vectors_Train[i])) R_train.append(R) #calculating h=e[tz] mean_tz = [] for k in range(0, self.Number_of_Delayed_Elements * 2 + 3): sum = 0 for e in range(0, int(len(self.Input_Vectors_Train))): s = h_train[e] sum = sum + s[k] mean_tz.append(sum / len(self.Input_Vectors_Train)) mean_tz = np.reshape(mean_tz, (self.Number_of_Delayed_Elements * 2 + 3, 1)) #calculating R=e[zz] mean_zz = np.zeros((self.Number_of_Delayed_Elements * 2 + 3, self.Number_of_Delayed_Elements * 2 + 3)) for k in range(0, self.Number_of_Delayed_Elements * 2 + 3): for o in range(0, self.Number_of_Delayed_Elements * 2 + 3): sum = 0 for g in range(0, int(len(self.Input_Vectors_Train))): sg = R_train[g] sum = sum + sg[k, o] mean_zz[k, o] = (sum / len(self.Input_Vectors_Train)) #calculating W=R(-1).h R_inv = np.linalg.inv(mean_zz) self.Weight = np.transpose(np.dot(R_inv, mean_tz)) #calculating error error_MAE = [] error_MSE = [] for i in range(0, int(len(self.Input_Vectors_Test))): a = np.dot(self.Weight, np.transpose(self.Input_Vectors_Test[i])) e = self.Target_Vectors_Test[i] - a error_MSE.append(math.pow(e, 2)) error_MAE.append(e) error_MSE = np.mean(error_MSE) error_MAE = np.max(error_MAE) self.error_MSE = [error_MSE] self.error_MAE = [error_MAE] self.display_error_epoch() print('self.error_MSE-direct', self.error_MSE) print('self.error_MAE-direct', self.error_MAE) def display_error_epoch(self): self.axes.cla() self.axes.set_title("MSE") self.axes.set_xlabel('epoch') self.axes.set_ylabel('error') self.axes.scatter(self.ep, self.error_MSE) self.axes.xaxis.set_visible(True) self.axes.set_ylim([0, 2]) self.canvas.draw() self.axes1.cla() self.axes1.set_title("MAE") self.axes1.set_xlabel('epoch') self.axes1.set_ylabel('error') self.axes1.scatter(self.ep, self.error_MAE) self.axes1.xaxis.set_visible(True) self.axes1.set_ylim([0, 2]) self.canvas1.draw() def key_pressed_callback(self, event): self.root.status_bar.set('%s', 'Key pressed') def up_arrow_pressed_callback(self, event): self.root.status_bar.set('%s', "Up arrow was pressed") def down_arrow_pressed_callback(self, event): self.root.status_bar.set('%s', "Down arrow was pressed") def right_arrow_pressed_callback(self, event): self.root.status_bar.set('%s', "Right arrow was pressed") def left_arrow_pressed_callback(self, event): self.root.status_bar.set('%s', "Left arrow was pressed") def shift_up_arrow_pressed_callback(self, event): self.root.status_bar.set('%s', "Shift up arrow was pressed") def shift_down_arrow_pressed_callback(self, event): self.root.status_bar.set('%s', "Shift down arrow was pressed") def shift_right_arrow_pressed_callback(self, event): self.root.status_bar.set('%s', "Shift right arrow was pressed") def shift_left_arrow_pressed_callback(self, event): self.root.status_bar.set('%s', "Shift left arrow was pressed") def f_key_pressed_callback(self, event): self.root.status_bar.set('%s', "f key was pressed") def b_key_pressed_callback(self, event): self.root.status_bar.set('%s', "b key was pressed") def left_mouse_click_callback(self, event): self.root.status_bar.set( '%s', 'Left mouse button was clicked. ' + 'x=' + str(event.x) + ' y=' + str(event.y)) self.x = event.x self.y = event.y self.canvas.focus_set() def left_mouse_release_callback(self, event): self.root.status_bar.set( '%s', 'Left mouse button was released. ' + 'x=' + str(event.x) + ' y=' + str(event.y)) self.x = None self.y = None def left_mouse_down_motion_callback(self, event): self.root.status_bar.set( '%s', 'Left mouse down motion. ' + 'x=' + str(event.x) + ' y=' + str(event.y)) self.x = event.x self.y = event.y def right_mouse_click_callback(self, event): self.root.status_bar.set( '%s', 'Right mouse down motion. ' + 'x=' + str(event.x) + ' y=' + str(event.y)) self.x = event.x self.y = event.y def right_mouse_release_callback(self, event): self.root.status_bar.set( '%s', 'Right mouse button was released. ' + 'x=' + str(event.x) + ' y=' + str(event.y)) self.x = None self.y = None def right_mouse_down_motion_callback(self, event): self.root.status_bar.set( '%s', 'Right mouse down motion. ' + 'x=' + str(event.x) + ' y=' + str(event.y)) self.x = event.x self.y = event.y def left_mouse_click_callback(self, event): self.root.status_bar.set( '%s', 'Left mouse button was clicked. ' + 'x=' + str(event.x) + ' y=' + str(event.y)) self.x = event.x self.y = event.y # self.focus_set() def frame_resized_callback(self, event): print("frame resize callback") def redisplay(self, event): self.create_graphic_objects()
class ImageSession: def __init__(self, master, filename, hdu=0): # filename should be a string! self.filename = filename self.hdu = hdu # The master window? self.master = master if not os.path.exists(self.filename): tkMessageBox.showerror("File not found", "File {0} doesn't exist!".format(file)) return self.openFile() self.createWindow() def openFile(self): # Try to open the file and read in the data from HDU try: hdulist = pf.open(self.filename) try: if hdulist[self.hdu].header['XTENSION'] == 'BINTABLE': tkMessageBox.showerror("HDU Error", "The HDU {0} is not an ImageHDU!".format(self.hdu)) raise util.NotAnImageHDUError("The HDU {0} is not an ImageHDU!".format(self.hdu)) # HDU is a table -- throw an error! except KeyError: # HDU is an image, carry on! pass self.rawData = hdulist[self.hdu].data self.rawData.shape except IOError: tkMessageBox.showerror("FITS file error ", "File {0} does not appear to be a valid FITS file!".format(self.filename)) raise util.ImageSessionError("File {0} does not appear to be a valid FITS file!".format(self.filename)) except AttributeError: tkMessageBox.showerror("FITS file error ", "File {0} does not appear to have data in HDU 0.".format(self.filename)) raise util.ImageSessionError("File {0} does not appear to have data in HDU 0.".format(self.filename)) def createWindow(self): # Create the actual window to draw the image and scale controls self.ImageWindow = Tk.Toplevel(self.master) self.ImageWindow.title(self.filename) #self.ImageWindow.protocol("WM_DELETE_WINDOW", self.closeImage) # TODO: THIS SHOULD DETECT SCREEN RESOLUTION screenSize = (1050/1.5, 1680/1.5) if self.rawData.shape[0] > screenSize[0] and self.rawData.shape[1] > screenSize[1]: factor1 = screenSize[0] / self.rawData.shape[0] factor2 = screenSize[1] / self.rawData.shape[1] self.zoomFactor = min([factor1, factor2]) elif self.rawData.shape[1] > screenSize[0]: self.zoomFactor = screenSize[0]/ self.rawData.shape[1] elif self.rawData.shape[0] > screenSize[1]: self.zoomFactor = screenSize[1] / self.rawData.shape[0] else: self.zoomFactor = 1. # Create the image tools scaleTypeLabel = Tk.Label(self.ImageWindow, text="Scaling: ") scaleTypeLabel.grid(row=0, column=0) self.scalingName = Tk.StringVar() self.scalingName.set("arcsinh") self.scalingOption = Tk.OptionMenu(self.ImageWindow, self.scalingName, "arcsinh","linear","sqrt", command=self.setRescaler) self.scalingOption.grid(row=0, column=1) rescaleLabel = Tk.Label(self.ImageWindow, text="Rescale: ") rescaleLabel.grid(row=1, column=0) self.scaleValue = Tk.Scale(self.ImageWindow, from_=-4, to=6, resolution=0.05, orient=Tk.HORIZONTAL, showvalue=1, length=300) self.scaleValue.set(1.0) self.scaleValue.grid(row=1, column=1) minLabel = Tk.Label(self.ImageWindow, text="Min Pixel Value: ") minLabel.grid(row=2, column=0) self.minValue = Tk.Scale(self.ImageWindow, resolution=0.05, orient=Tk.HORIZONTAL, showvalue=1, length=300) self.minValue.set(1.0) self.minValue.grid(row=2, column=1) maxLabel = Tk.Label(self.ImageWindow, text="Max Pixel Value: ") maxLabel.grid(row=3, column=0) self.maxValue = Tk.Scale(self.ImageWindow, resolution=0.05, orient=Tk.HORIZONTAL, showvalue=1, length=300) self.maxValue.set(1.0) self.maxValue.grid(row=3, column=1) # Set the min/max slider boundaries self.minValue.config(from_=self.rawData.min(), to=self.rawData.max()) self.minValue.set(self.rawData.min()) self.maxValue.config(from_=self.rawData.min(), to=self.rawData.max()) self.maxValue.set(self.rawData.max()) # Set the default rescaler self.rescaler = util.arcsinhStretch self.scaleImage() self.drawImage() # Bind the sliders to the scaleImage() method self.scaleValue.bind("<ButtonRelease-1>", self.redraw) self.minValue.bind("<ButtonRelease-1>", self.redraw) self.maxValue.bind("<ButtonRelease-1>", self.redraw) self.scalingOption.bind("<ButtonRelease-1>", self.redraw) def setRescaler(self, event): self.rescaler = scalingTypes[self.scalingName.get()] def redraw(self, event=None): """ This rescales and redraws the image using the current values for scaling """ self.scaleImage() self.drawImage() def updateThumbnail(self, event): """ """ self.lastMousePosition = (event.x, event.y) self.pilThumbnail = self.pilImage.transform(self.pilImage.size, Image.EXTENT, (event.x-25,event.y-25,event.x+25,event.y+25)) self.thumbnailImage = ImageTk.PhotoImage(self.pilThumbnail.resize((200,200))) self.thumbnailImageLabel.configure(image=self.thumbnailImage) def scaleImage(self): """ This method re-scales the image data """ self.scaledData = 255.0*self.rescaler(self.rawData, beta=10.**self.scaleValue.get(), min=self.minValue.get(), max=self.maxValue.get(), clip=True) def plotContour(self, event): """ If the 'c' key is pressed, generate a contour plot of whatever is in the thumbnail zoom box """ self.contourPlot = Tk.Toplevel(self.master) self.contourPlot.title("Contour plot for: {0}".format(self.filename)) rawShape = self.rawData.shape lastx, lasty = self.lastMousePosition lastx = round(lastx/self.zoomFactor) lasty = round(lasty/self.zoomFactor) boxHalfSize = 25/self.zoomFactor x1,y1,x2,y2 = [x for x in map(round, (lastx-boxHalfSize,lasty-boxHalfSize,lastx+boxHalfSize,lasty+boxHalfSize))] if x1 < 0: x1 = 0 x2 = boxHalfSize*2 if x2 > rawShape[1]: x2 = rawShape[1] x1 = x2 - boxHalfSize*2 if y1 < 0: y1 = 0 y2 = boxHalfSize*2 if y2 > rawShape[0]: y2 = rawShape[0] y1 = y2 - boxHalfSize*2 thumbData = self.rawData[y1:y2, x1:x2] shp = thumbData.shape x,y = np.meshgrid(range(shp[0]), range(shp[1])) self.fig = Figure(figsize=(5,5)) ax = self.fig.add_subplot(111) ax.contour(x, y, thumbData) ax.set_ylim(ax.get_ylim()[::-1]) ax.get_xaxis().set_ticks([]) ax.get_yaxis().set_ticks([]) self.canvas = FigureCanvasTkAgg(self.fig, master=self.contourPlot) self.canvas.get_tk_widget().pack(side='top', fill='both', expand=1) def drawImage(self): """ This method will draw the image into a PhotoImage object in the new image window """ self.pilImage = Image.fromarray(self.scaledData.astype(np.uint8)) newSize = (int(self.pilImage.size[0]*self.zoomFactor), int(self.pilImage.size[1]*self.zoomFactor)) self.pilImage = self.pilImage.resize(newSize) self.tkImage = ImageTk.PhotoImage(self.pilImage) self.canvas = Tk.Canvas(self.ImageWindow, width=newSize[0], height=newSize[1], bd=0) self.canvas.create_image(0, 0, image=self.tkImage, anchor="nw") self.canvas.grid(row=0, column=2, rowspan=5, sticky="nswe") self.canvas.bind("<Motion>", self.updateThumbnail) self.canvas.bind("c", self.plotContour) self.canvas.focus_set() """ # Code for source detection: numSigma = 2. labels, num = snd.label(self.rawData > (numSigma*np.std(self.rawData)), np.ones((3,3))) coords = snd.center_of_mass(self.rawData, labels, range(1,num+1)) rad = 5. for coord in coords: y,x = coord x = x*self.zoomFactor y = y*self.zoomFactor circ1 = self.canvas.create_oval(x-rad,y-rad,x+rad,y+rad, outline='red') """ self.pilThumbnail = self.pilImage.transform(self.pilImage.size, Image.EXTENT, (0,0,50,50)) self.pilThumbnail = self.pilThumbnail.resize((200,200)) self.thumbnailImage = ImageTk.PhotoImage(self.pilThumbnail) self.thumbnailImageLabel = Tk.Label(self.ImageWindow, image=self.thumbnailImage, command=None) self.thumbnailImageLabel.grid(row=4, column=0, columnspan=2, rowspan=5)
class LeftFrame: """ This class creates and controls the widgets and figures in the left frame which are used to display the activation functions. Farhad Kamangar 2018_06_03 """ def __init__(self, root, master, debug_print_flag=False): self.master = master self.root = root ######################################################################### # Set up the constants and default values ######################################################################### self.alpha = 0.1 self.xmin = 0 self.xmax = 1000 self.ymin = 0 self.ymax = 100 self.input_weight = np.random.uniform(-0.001, 0.001, size=(785, 10)) # print(self.input_weight) self.input_image_vector = [] self.target_values = [] self.errors = [] self.epochs = [] self.epoch = 0 self.error_rate = 0 self.conf_matrix = [] #self.input_weight_2 = 1.0 #self.bias = 0.0 self.activation_type = "Symmetrical Hard Limit" self.learning_method = "Filtered Learning" # self.input_values = np.random.uniform(-10, 10, size=(2, 4)) # self.bias_input = np.ones(4) # self.input_values = np.vstack((self.input_values, self.bias_input)) ######################################################################### # Set up the plotting frame and controls frame ######################################################################### master.rowconfigure(0, weight=10, minsize=200) master.columnconfigure(0, weight=1) self.plot_frame = tk.Frame(self.master, borderwidth=10, relief=tk.SUNKEN) self.plot_frame.grid(row=0, column=0, columnspan=1, sticky=tk.N + tk.E + tk.S + tk.W) w = self.plot_frame.winfo_screenwidth() h = self.plot_frame.winfo_screenheight() #self.figure = plt.figure(figsize=[w/100,h/100-2.2]) self.figure = plt.figure("") self.axes = self.figure.add_axes([0.15, 0.15, 0.6, 0.8]) # self.axes = self.figure.add_axes() self.axes = self.figure.gca() self.axes.set_xlabel('Epochs') self.axes.set_ylabel('Error Rate') # self.axes.margins(0.5) self.axes.set_title("") plt.xlim(self.xmin, self.xmax) plt.ylim(self.ymin, self.ymax) self.canvas = FigureCanvasTkAgg(self.figure, master=self.plot_frame) self.plot_widget = self.canvas.get_tk_widget() self.plot_widget.grid(row=0, column=0, sticky=tk.N + tk.E + tk.S + tk.W) # Create a frame to contain all the controls such as sliders, buttons, ... self.controls_frame = tk.Frame(self.master) self.controls_frame.grid(row=1, column=0, sticky=tk.N + tk.E + tk.S + tk.W) self.plot_widget .pack(side=tk.TOP, fill=tk.BOTH, expand=1) ######################################################################### # Set up the control widgets such as sliders and selection boxes ######################################################################### self.learning_rate_slider = tk.Scale(self.controls_frame, variable=tk.DoubleVar(), orient=tk.HORIZONTAL, from_=0.001, to_=1.0, resolution=0.01, bg="#DDDDDD", activebackground="#FF0000", highlightcolor="#00FFFF", label="alpha", command=lambda event: self.learning_rate_slider_callback()) self.learning_rate_slider.set(self.alpha) self.learning_rate_slider.bind("<ButtonRelease-1>", lambda event: self.learning_rate_slider_callback()) self.learning_rate_slider.grid(row=0, column=0, sticky=tk.N + tk.E + tk.S + tk.W) self.adjust_weights_button = tk.Button(self.controls_frame, text="Learn (Adjust Weights)", fg="red", command=lambda: self.adjust_weights_button_callback()) self.randomize_weights_button = tk.Button(self.controls_frame, text="Randomize Weights", fg="red", command=lambda: self.randomize_weights_button_callback()) self.display_confusion_matrix_button = tk.Button(self.controls_frame, text="Display Confusion Matrix", fg="red", command=lambda: self.display_confusion_matrix_button_callback()) self.adjust_weights_button.grid(row=0, column=1, sticky=tk.N + tk.E + tk.S + tk.W) self.randomize_weights_button.grid(row=0, column=2, sticky=tk.N + tk.E + tk.S + tk.W) self.display_confusion_matrix_button.grid(row=0, column=3, sticky=tk.N + tk.E + tk.S + tk.W) ######################################################################### # Set up the frame for drop down selection ######################################################################### self.label_for_activation_function = tk.Label(self.controls_frame, text="Activation Function Type:", justify="center") self.label_for_activation_function.grid(row=0, column=4, sticky=tk.N + tk.E + tk.S + tk.W) self.activation_function_variable = tk.StringVar() self.activation_function_dropdown = tk.OptionMenu(self.controls_frame, self.activation_function_variable, "Linear", "Hyperbolic Tangent", "Symmetrical Hard Limit", command=lambda event: self.activation_function_dropdown_callback()) self.activation_function_variable.set("Symmetrical Hard Limit") self.activation_function_dropdown.grid(row=0, column=5, sticky=tk.N + tk.E + tk.S + tk.W) self.label_for_learning_method = tk.Label(self.controls_frame, text="Select Learning Method:", justify="center") self.label_for_learning_method.grid(row=0, column=6, sticky=tk.N + tk.E + tk.S + tk.W) self.learning_method_variable = tk.StringVar() self.learning_method_dropdown = tk.OptionMenu(self.controls_frame, self.learning_method_variable, "Filtered Learning", "Delta Rule", "Unsupervised Hebb", command=lambda event: self.learning_method_dropdown_callback()) self.learning_method_variable.set("Filtered Learning") self.learning_method_dropdown.grid(row=0, column=7, sticky=tk.N + tk.E + tk.S + tk.W) self.canvas.get_tk_widget().bind("<ButtonPress-1>", self.left_mouse_click_callback) self.canvas.get_tk_widget().bind("<ButtonPress-1>", self.left_mouse_click_callback) self.canvas.get_tk_widget().bind("<ButtonRelease-1>", self.left_mouse_release_callback) self.canvas.get_tk_widget().bind("<B1-Motion>", self.left_mouse_down_motion_callback) self.canvas.get_tk_widget().bind("<ButtonPress-3>", self.right_mouse_click_callback) self.canvas.get_tk_widget().bind("<ButtonRelease-3>", self.right_mouse_release_callback) self.canvas.get_tk_widget().bind("<B3-Motion>", self.right_mouse_down_motion_callback) self.canvas.get_tk_widget().bind("<Key>", self.key_pressed_callback) self.canvas.get_tk_widget().bind("<Up>", self.up_arrow_pressed_callback) self.canvas.get_tk_widget().bind("<Down>", self.down_arrow_pressed_callback) self.canvas.get_tk_widget().bind("<Right>", self.right_arrow_pressed_callback) self.canvas.get_tk_widget().bind("<Left>", self.left_arrow_pressed_callback) self.canvas.get_tk_widget().bind("<Shift-Up>", self.shift_up_arrow_pressed_callback) self.canvas.get_tk_widget().bind("<Shift-Down>", self.shift_down_arrow_pressed_callback) self.canvas.get_tk_widget().bind("<Shift-Right>", self.shift_right_arrow_pressed_callback) self.canvas.get_tk_widget().bind("<Shift-Left>", self.shift_left_arrow_pressed_callback) self.canvas.get_tk_widget().bind("f", self.f_key_pressed_callback) self.canvas.get_tk_widget().bind("b", self.b_key_pressed_callback) def key_pressed_callback(self, event): self.root.status_bar.set('%s', 'Key pressed') def up_arrow_pressed_callback(self, event): self.root.status_bar.set('%s', "Up arrow was pressed") def down_arrow_pressed_callback(self, event): self.root.status_bar.set('%s', "Down arrow was pressed") def right_arrow_pressed_callback(self, event): self.root.status_bar.set('%s', "Right arrow was pressed") def left_arrow_pressed_callback(self, event): self.root.status_bar.set('%s', "Left arrow was pressed") def shift_up_arrow_pressed_callback(self, event): self.root.status_bar.set('%s', "Shift up arrow was pressed") def shift_down_arrow_pressed_callback(self, event): self.root.status_bar.set('%s', "Shift down arrow was pressed") def shift_right_arrow_pressed_callback(self, event): self.root.status_bar.set('%s', "Shift right arrow was pressed") def shift_left_arrow_pressed_callback(self, event): self.root.status_bar.set('%s', "Shift left arrow was pressed") def f_key_pressed_callback(self, event): self.root.status_bar.set('%s', "f key was pressed") def b_key_pressed_callback(self, event): self.root.status_bar.set('%s', "b key was pressed") def left_mouse_click_callback(self, event): self.root.status_bar.set('%s', 'Left mouse button was clicked. ' + 'x=' + str(event.x) + ' y=' + str( event.y)) self.x = event.x self.y = event.y self.canvas.focus_set() def left_mouse_release_callback(self, event): self.root.status_bar.set('%s', 'Left mouse button was released. ' + 'x=' + str(event.x) + ' y=' + str(event.y)) self.x = None self.y = None def left_mouse_down_motion_callback(self, event): self.root.status_bar.set('%s', 'Left mouse down motion. ' + 'x=' + str(event.x) + ' y=' + str(event.y)) self.x = event.x self.y = event.y def right_mouse_click_callback(self, event): self.root.status_bar.set('%s', 'Right mouse down motion. ' + 'x=' + str(event.x) + ' y=' + str(event.y)) self.x = event.x self.y = event.y def right_mouse_release_callback(self, event): self.root.status_bar.set('%s', 'Right mouse button was released. ' + 'x=' + str(event.x) + ' y=' + str(event.y)) self.x = None self.y = None def right_mouse_down_motion_callback(self, event): self.root.status_bar.set('%s', 'Right mouse down motion. ' + 'x=' + str(event.x) + ' y=' + str(event.y)) self.x = event.x self.y = event.y def left_mouse_click_callback(self, event): self.root.status_bar.set('%s', 'Left mouse button was clicked. ' + 'x=' + str(event.x) + ' y=' + str( event.y)) self.x = event.x self.y = event.y #################################### def read_one_image_and_convert_to_vector(self, file_name): img = scipy.misc.imread(file_name).astype(np.float32) # read image and convert to float img = img.reshape(-1, 1) # reshape to column vector and return it img = (img / 127.5) - 1.0 img = np.append(img, [1]) img = img.transpose() return img # self.focus_set() def display_activation_function(self): if self.epoch == 0 or self.epoch >= 1000: self.epoch = 0 self.epochs = [] self.errors = [] self.setup_values() shuffle(self.input_image_vector) error_rate, self.input_weight, epoch, epochs, self.conf_matrix = Parikh_03_02.calculate_activation_function(self.input_weight, self.alpha, self.input_image_vector, self.learning_method, self.activation_type, self.epoch) self.epoch += epoch self.errors.extend(error_rate) self.epochs.extend(epochs) self.axes.cla() self.axes.set_xlabel('Epochs') self.axes.set_ylabel('Error Rate') self.axes.plot(self.epochs, self.errors, 'ro') self.axes.xaxis.set_visible(True) plt.xlim(self.xmin, self.xmax) plt.ylim(self.ymin, self.ymax) plt.title(self.activation_type) self.canvas.draw() def learning_rate_slider_callback(self): self.alpha = np.float(self.learning_rate_slider.get()) #self.display_activation_function() def activation_function_dropdown_callback(self): self.activation_type = self.activation_function_variable.get() #self.display_activation_function() def learning_method_dropdown_callback(self): self.learning_method = self.learning_method_variable.get() #self.display_activation_function() def adjust_weights_button_callback(self): self.display_activation_function() def randomize_weights_button_callback(self): self.input_weight = [] self.input_weight = np.random.uniform(-0.001, 0.001, size=(785, 10)) # print(self.input_weight) self.display_activation_function() def display_confusion_matrix_button_callback(self): if len(self.conf_matrix): Parikh_03_03.display_numpy_array_as_table(np.array(self.conf_matrix)) #################### def setup_values(self): for file in glob.glob('./Data/*'): a = file.split('_') self.input_image_vector.append(np.append(self.read_one_image_and_convert_to_vector(file), [int(a[0][-1])]))
class LeftFrame: """ This class creates and controls the widgets and figures in the left frame which are used to display the activation functions. Kush Raina 2018_06_03 """ def __init__(self, root, master, debug_print_flag=False): self.master = master self.root = root self.flagvar = False ######################################################################### # Set up the constants and default values ######################################################################### self.xmin = -10 self.xmax = 10 self.ymin = -10 self.ymax = 10 self.input_weight = 1 self.input_weight1 = 1 self.bias = 0.0 self.activation_type = "Hard Limit" self.x1_samples_new = 0 self.x2_samples_new = 0 ######################################################################### # Set up the plotting frame and controls frame ######################################################################### master.rowconfigure(0, weight=1) master.columnconfigure(0, weight=1) self.plot_frame = tk.Frame(self.master, borderwidth=10, relief=tk.SUNKEN) self.plot_frame.grid(row=0, column=0, columnspan=1, sticky=tk.N + tk.E + tk.S + tk.W) #self.plot_frame.grid(row=0, column=1, columnspan=1, sticky=tk.N + tk.E + tk.S + tk.W) self.figure = plt.figure(figsize=(6, 6)) #self.axes = self.figure.add_axes([0.9, 0.9, 0.6, 0.8]) self.axes = self.figure.add_axes() self.axes = self.figure.gca() self.axes.set_xlabel('Input') self.axes.set_ylabel('Output') # self.axes.margins(0.5) self.axes.set_title("") plt.xlim(self.xmin, self.xmax) plt.ylim(self.ymin, self.ymax) self.canvas = FigureCanvasTkAgg(self.figure, master=self.plot_frame) self.plot_widget = self.canvas.get_tk_widget() self.plot_widget.grid(row=0, column=1, sticky=tk.N + tk.E + tk.S + tk.W) # Create a frame to contain all the controls such as sliders, buttons, ... self.controls_frame = tk.Frame(self.master) self.controls_frame.grid(row=1, column=0, sticky=tk.N + tk.E + tk.S + tk.W) ######################################################################### # Set up the control widgets such as sliders and selection boxes ######################################################################### #Creating 1st weight slider self.input_weight_slider = tk.Scale( self.controls_frame, variable=tk.DoubleVar(), orient=tk.HORIZONTAL, from_=-10.0, to_=10.0, resolution=0.01, bg="#DDDDDD", activebackground="#FF0000", highlightcolor="#00FFFF", label="Input Weight", command=lambda event: self.input_weight_slider_callback()) self.input_weight_slider.set(self.input_weight) self.input_weight_slider.bind( "<ButtonRelease-1>", lambda event: self.input_weight_slider_callback()) self.input_weight_slider.grid(row=0, column=0, sticky=tk.N + tk.E + tk.S + tk.W) #Creating 2nd weight slider self.input_weight_slider1 = tk.Scale( self.controls_frame, variable=tk.DoubleVar(), orient=tk.HORIZONTAL, from_=-10.0, to_=10.0, resolution=0.01, bg="#DDDDDD", activebackground="#FF0000", highlightcolor="#00FFFF", label="Input Weight1", command=lambda event: self.input_weight_slider_callback1()) self.input_weight_slider1.set(self.input_weight1) self.input_weight_slider1.bind( "<ButtonRelease-1>", lambda event: self.input_weight_slider_callback1()) self.input_weight_slider1.grid(row=0, column=1, sticky=tk.N + tk.E + tk.S + tk.W) # bias slider self.bias_slider = tk.Scale( self.controls_frame, variable=tk.DoubleVar(), orient=tk.HORIZONTAL, from_=-10.0, to_=10.0, resolution=0.01, bg="#DDDDDD", activebackground="#FF0000", highlightcolor="#00FFFF", label="Bias", command=lambda event: self.bias_slider_callback()) self.bias_slider.set(self.bias) self.bias_slider.bind("<ButtonRelease-1>", lambda event: self.bias_slider_callback()) self.bias_slider.grid(row=0, column=2, sticky=tk.N + tk.E + tk.S + tk.W) # Randomize weight button self.randomize = tk.Button(self.controls_frame, text="Randomize", fg="red", width=16, command=self.Random_Gen) self.randomize.grid(row=0, column=4) self.randomize = tk.Button(self.controls_frame, text="Train", fg="red", width=16, command=self.train_Data) self.randomize.grid(row=0, column=5) ######################################################################### # Set up the frame for drop down selection ######################################################################### self.label_for_activation_function = tk.Label( self.controls_frame, text="Activation Function Type:", justify="center") self.label_for_activation_function.grid(row=0, column=3, sticky=tk.N + tk.E + tk.S + tk.W) self.activation_function_variable = tk.StringVar() self.activation_function_dropdown = tk.OptionMenu( self.controls_frame, self.activation_function_variable, "Linear", "Hyperbolic Tangent", "Hard Limit", command=lambda event: self.activation_function_dropdown_callback()) self.activation_function_variable.set("Hard Limit") self.activation_function_dropdown.grid(row=0, column=3, sticky=tk.N + tk.E + tk.S + tk.W) self.canvas.get_tk_widget().bind("<ButtonPress-1>", self.left_mouse_click_callback) self.canvas.get_tk_widget().bind("<ButtonPress-1>", self.left_mouse_click_callback) self.canvas.get_tk_widget().bind("<ButtonRelease-1>", self.left_mouse_release_callback) self.canvas.get_tk_widget().bind("<B1-Motion>", self.left_mouse_down_motion_callback) self.canvas.get_tk_widget().bind("<ButtonPress-3>", self.right_mouse_click_callback) self.canvas.get_tk_widget().bind("<ButtonRelease-3>", self.right_mouse_release_callback) self.canvas.get_tk_widget().bind("<B3-Motion>", self.right_mouse_down_motion_callback) self.canvas.get_tk_widget().bind("<Key>", self.key_pressed_callback) self.canvas.get_tk_widget().bind("<Up>", self.up_arrow_pressed_callback) self.canvas.get_tk_widget().bind("<Down>", self.down_arrow_pressed_callback) self.canvas.get_tk_widget().bind("<Right>", self.right_arrow_pressed_callback) self.canvas.get_tk_widget().bind("<Left>", self.left_arrow_pressed_callback) self.canvas.get_tk_widget().bind("<Shift-Up>", self.shift_up_arrow_pressed_callback) self.canvas.get_tk_widget().bind( "<Shift-Down>", self.shift_down_arrow_pressed_callback) self.canvas.get_tk_widget().bind( "<Shift-Right>", self.shift_right_arrow_pressed_callback) self.canvas.get_tk_widget().bind( "<Shift-Left>", self.shift_left_arrow_pressed_callback) self.canvas.get_tk_widget().bind("f", self.f_key_pressed_callback) self.canvas.get_tk_widget().bind("b", self.b_key_pressed_callback) def key_pressed_callback(self, event): self.root.status_bar.set('%s', 'Key pressed') def g1(self): print('kush') def Random_Gen(self): self.input_weight = 1 self.input_weight1 = 1 self.bias = 0 print('kush') self.x1_samples_old = np.random.uniform(-10, 10, 4) self.x1_samples_old = np.reshape(self.x1_samples_old, (2, 2)) #x1_samples=np.insert(x1_samples, [2], [[1],[1]], axis=1) # mu_vec1 = np.array([10,9]) # cov_mat1 = np.array([[2,0],[0,2]]) # x1_samples = np.random.multivariate_normal(mu_vec1, cov_mat1, 2) # mu_vec1 = np.array([-10,-9]) # cov_mat1 = np.array([[2,0],[0,2]]) # x2_samples = np.random.multivariate_normal(mu_vec1, cov_mat1, 2) self.x2_samples_old = np.random.uniform(-10, 10, 4) self.x2_samples_old = np.reshape(self.x2_samples_old, (2, 2)) self.axes.cla() self.axes.set_xlabel('Input1') self.axes.set_ylabel('Output') fig = plt.figure() print() plt.scatter(self.x1_samples_old[:, 0], self.x1_samples_old[:, 1], marker='+') plt.scatter(self.x2_samples_old[:, 0], self.x2_samples_old[:, 1], c='black', marker='o') plt.show() self.axes.scatter(self.x1_samples_old[:, 0], self.x1_samples_old[:, 1], marker='+') self.axes.scatter(self.x2_samples_old[:, 0], self.x2_samples_old[:, 1], c='black', marker='o') self.x1_samples = np.insert(self.x1_samples_old, [2], [[-1], [-1]], axis=1) self.x2_samples = np.insert(self.x2_samples_old, [2], [[1], [1]], axis=1) self.x1_samples_new = np.concatenate( (self.x1_samples, self.x2_samples), axis=0) #self.x1_samples_new=np.array([[ 8.53654607,-3.16339858,-1],[-2.54230638,5.49458051,-1],[-5.76855298 ,6.89591834,1],[-2.94826308 ,0.82912687,1]]) print('combined ', self.x1_samples_new) # add labels to the data generated self.axes.set_xlim(self.xmin, self.xmax) self.axes.set_ylim(self.ymin, self.ymax) self.axes.xaxis.set_visible(True) plt.xlim(self.xmin, self.xmax) plt.ylim(self.ymin, self.ymax) plt.title(self.activation_type) self.canvas.draw() self.input_weight = 1 self.input_weight1 = 1 self.bias = 0 self.input_weight_slider.set(self.input_weight) self.input_weight_slider1.set(self.input_weight1) self.bias_slider.set(self.bias) self.flagvar = False def train_Data(self): for x in range(100): self.input_weight, self.input_weight1, self.bias = Raina_01_02.calculate_activation_function( self.input_weight, self.input_weight1, self.bias, self.x1_samples_new, self.activation_type) print('w0', self.input_weight) print('w1', self.input_weight1) print('bias', self.bias) self.axes.cla() self.axes.set_xlabel('Input') self.axes.set_ylabel('Output') fig = plt.figure() ax = fig.gca() resolution = 100 xs = np.linspace(-10., 10., resolution) ys = np.linspace(-10., 10., resolution) xx, yy = np.meshgrid(xs, ys) zz = self.input_weight * xx + self.input_weight1 * yy + self.bias zz[zz < 0] = -1 zz[zz > 0] = +1 quad = ax.pcolormesh(xs, ys, zz) c = ListedColormap(['r', 'g']) plt.scatter(self.x1_samples_old[:, 0], self.x1_samples_old[:, 1], marker='+') plt.scatter(self.x2_samples_old[:, 0], self.x2_samples_old[:, 1], c='black', marker='o') #self.axes.plot(quad) self.axes.pcolormesh(xs, ys, zz, cmap=c) #self.axes.pcolormesh() self.axes.scatter(self.x1_samples_old[:, 0], self.x1_samples_old[:, 1], marker='+') self.axes.scatter(self.x2_samples_old[:, 0], self.x2_samples_old[:, 1], c='black', marker='o') plt.show() self.axes.xaxis.set_visible(True) plt.xlim(self.xmin, self.xmax) plt.ylim(self.ymin, self.ymax) plt.title(self.activation_type) self.canvas.draw() print('activation type', self.activation_type) if self.activation_type == 'Linear': self.input_weight_slider_callback() self.input_weight_slider_callback1() self.bias_slider_callback() self.flagvar = True def redrawline(self): self.axes.cla() self.axes.set_xlabel('Input') self.axes.set_ylabel('Output') fig = plt.figure() ax = fig.gca() resolution = 500 xs = np.linspace(-10., 10., resolution) ys = np.linspace(-10., 10., resolution) xx, yy = np.meshgrid(xs, ys) zz = self.input_weight * xx + self.input_weight1 * yy + self.bias zz[zz < 0] = -1 zz[zz > 0] = +1 quad = ax.pcolormesh(xs, ys, zz) c = ListedColormap(['r', 'g']) plt.scatter(self.x1_samples_old[:, 0], self.x1_samples_old[:, 1], marker='+') plt.scatter(self.x2_samples_old[:, 0], self.x2_samples_old[:, 1], c='black', marker='o') #self.axes.plot(quad) self.axes.pcolormesh(xs, ys, zz, cmap=c) #self.axes.pcolormesh() self.axes.scatter(self.x1_samples_old[:, 0], self.x1_samples_old[:, 1], marker='+') self.axes.scatter(self.x2_samples_old[:, 0], self.x2_samples_old[:, 1], c='black', marker='o') plt.show() self.axes.xaxis.set_visible(True) plt.xlim(self.xmin, self.xmax) plt.ylim(self.ymin, self.ymax) plt.title(self.activation_type) self.canvas.draw() def up_arrow_pressed_callback(self, event): self.root.status_bar.set('%s', "Up arrow was pressed") def down_arrow_pressed_callback(self, event): self.root.status_bar.set('%s', "Down arrow was pressed") def right_arrow_pressed_callback(self, event): self.root.status_bar.set('%s', "Right arrow was pressed") def left_arrow_pressed_callback(self, event): self.root.status_bar.set('%s', "Left arrow was pressed") def shift_up_arrow_pressed_callback(self, event): self.root.status_bar.set('%s', "Shift up arrow was pressed") def shift_down_arrow_pressed_callback(self, event): self.root.status_bar.set('%s', "Shift down arrow was pressed") def shift_right_arrow_pressed_callback(self, event): self.root.status_bar.set('%s', "Shift right arrow was pressed") def shift_left_arrow_pressed_callback(self, event): self.root.status_bar.set('%s', "Shift left arrow was pressed") def f_key_pressed_callback(self, event): self.root.status_bar.set('%s', "f key was pressed") def b_key_pressed_callback(self, event): self.root.status_bar.set('%s', "b key was pressed") def left_mouse_click_callback(self, event): self.root.status_bar.set( '%s', 'Left mouse button was clicked. ' + 'x=' + str(event.x) + ' y=' + str(event.y)) self.x = event.x self.y = event.y self.canvas.focus_set() def left_mouse_release_callback(self, event): self.root.status_bar.set( '%s', 'Left mouse button was released. ' + 'x=' + str(event.x) + ' y=' + str(event.y)) self.x = None self.y = None def left_mouse_down_motion_callback(self, event): self.root.status_bar.set( '%s', 'Left mouse down motion. ' + 'x=' + str(event.x) + ' y=' + str(event.y)) self.x = event.x self.y = event.y def right_mouse_click_callback(self, event): self.root.status_bar.set( '%s', 'Right mouse down motion. ' + 'x=' + str(event.x) + ' y=' + str(event.y)) self.x = event.x self.y = event.y def right_mouse_release_callback(self, event): self.root.status_bar.set( '%s', 'Right mouse button was released. ' + 'x=' + str(event.x) + ' y=' + str(event.y)) self.x = None self.y = None def right_mouse_down_motion_callback(self, event): self.root.status_bar.set( '%s', 'Right mouse down motion. ' + 'x=' + str(event.x) + ' y=' + str(event.y)) self.x = event.x self.y = event.y def left_mouse_click_callback(self, event): self.root.status_bar.set( '%s', 'Left mouse button was clicked. ' + 'x=' + str(event.x) + ' y=' + str(event.y)) self.x = event.x self.y = event.y # self.focus_set() def display_activation_function(self): input_values = np.linspace(-10, 10, 256, endpoint=True) print('values ', input_values) print('weights ', self.input_weight) activation = Raina_01_02.calculate_activation_function( self.input_weight, self.input_weight1, self.bias, self.x1_samples_new, self.x2_samples_new, self.activation_type) self.axes.cla() self.axes.set_xlabel('Input1') self.axes.set_ylabel('Output') # x1_samples=self.Random_Gen(10,9) # x2_samples=self.Random_Gen(-10,-9) # fig = plt.figure() # print() # # # plt.scatter(x1_samples[:,0],x1_samples[:,1], marker='+') # plt.scatter(x2_samples[:,0],x2_samples[:,1], c= 'green', marker='o') # plt.show() # self.axes.scatter(x1_samples[:,0],x1_samples[:,1], marker='+') # self.axes.scatter(x2_samples[:,0],x2_samples[:,1], c= 'green', marker='o') #self.axes.plot(input_values, activation) self.axes.xaxis.set_visible(True) plt.xlim(self.xmin, self.xmax) plt.ylim(self.ymin, self.ymax) plt.title(self.activation_type) self.canvas.draw() def input_weight_slider_callback(self): self.input_weight = np.float(self.input_weight_slider.get()) if self.flagvar: self.redrawline() def input_weight_slider_callback1(self): self.input_weight1 = np.float(self.input_weight_slider1.get()) if self.flagvar: self.redrawline() def bias_slider_callback(self): self.bias = np.float(self.bias_slider.get()) if self.flagvar: self.redrawline() def activation_function_dropdown_callback(self): self.activation_type = self.activation_function_variable.get() print(self.activation_type)
class LeftFrame: """ This class creates and controls the widgets and figures in the left frame which are used to display the activation functions. Farhad Kamangar 2018_06_03 """ def __init__(self, root, master, debug_print_flag=False): self.master = master self.root = root ######################################################################### # Set up the constants and default values ######################################################################### self.number_of_delayed_elements = 10 self.input_file = 'data_set_1.csv' self.alpha = 0.1 self.training_sample_size = 80 self.stride = 1 self.number_of_iterations = 10 self.xmin = 0 self.xmax = 100 self.ymin = 0 self.ymax = 1 self.input_weight = None self.input_values = [] self.target_values = [] self.error = 0 # self.input_file = '' # self.input_values = np.random.uniform(-10, 10, size=(2, 4)) # self.bias_input = np.ones(4) # self.input_values = np.vstack((self.input_values, self.bias_input)) ######################################################################### # Set up the plotting frame and controls frame ######################################################################### master.rowconfigure(0, weight=10, minsize=200) master.columnconfigure(0, weight=1) self.plot_frame = tk.Frame(self.master, borderwidth=10, relief=tk.SUNKEN) self.plot_frame.grid(row=0, column=0, columnspan=1, sticky=tk.N + tk.E + tk.S + tk.W) w = self.plot_frame.winfo_screenwidth() h = self.plot_frame.winfo_screenheight() #self.figure = plt.figure(figsize=[w/100,h/100-2.2]) self.figure = plt.figure("") self.axes = self.figure.add_axes([0.15, 0.15, 0.6, 0.8]) # self.axes = self.figure.add_axes() self.axes = self.figure.gca() self.axes.set_xlabel('Iterations') self.axes.set_ylabel('Error') # self.axes.margins(0.5) self.axes.set_title("") plt.xlim(self.xmin, self.xmax) plt.ylim(self.ymin, self.ymax) self.canvas = FigureCanvasTkAgg(self.figure, master=self.plot_frame) self.plot_widget = self.canvas.get_tk_widget() self.plot_widget.grid(row=0, column=0, sticky=tk.N + tk.E + tk.S + tk.W) # Create a frame to contain all the controls such as sliders, buttons, ... self.controls_frame = tk.Frame(self.master) self.controls_frame.grid(row=1, column=0, sticky=tk.N + tk.E + tk.S + tk.W) self.plot_widget.pack(side=tk.TOP, fill=tk.BOTH, expand=1) ######################################################################### # Set up the control widgets such as sliders and selection boxes ######################################################################### self.number_of_delayed_elements_slider = tk.Scale( self.controls_frame, variable=tk.DoubleVar(), orient=tk.HORIZONTAL, from_=0, to_=100, resolution=1, bg="#DDDDDD", activebackground="#FF0000", highlightcolor="#00FFFF", label="Delayed Ele", command=lambda event: self. number_of_delayed_elements_slider_callback()) self.number_of_delayed_elements_slider.set( self.number_of_delayed_elements) self.number_of_delayed_elements_slider.bind( "<ButtonRelease-1>", lambda event: self.number_of_delayed_elements_slider_callback()) self.number_of_delayed_elements_slider.grid(row=0, column=0, sticky=tk.N + tk.E + tk.S + tk.W) self.learning_rate_slider = tk.Scale( self.controls_frame, variable=tk.DoubleVar(), orient=tk.HORIZONTAL, from_=0.001, to_=1.0, resolution=0.001, bg="#DDDDDD", activebackground="#FF0000", highlightcolor="#00FFFF", label="Alpha", command=lambda event: self.learning_rate_slider_callback()) self.learning_rate_slider.set(self.alpha) self.learning_rate_slider.bind( "<ButtonRelease-1>", lambda event: self.learning_rate_slider_callback()) self.learning_rate_slider.grid(row=0, column=1, sticky=tk.N + tk.E + tk.S + tk.W) self.training_sample_size_slider = tk.Scale( self.controls_frame, variable=tk.DoubleVar(), orient=tk.HORIZONTAL, from_=0, to_=100, resolution=10, bg="#DDDDDD", activebackground="#FF0000", highlightcolor="#00FFFF", label="TrainSample %", command=lambda event: self.training_sample_size_slider_callback()) self.training_sample_size_slider.set(self.training_sample_size) self.training_sample_size_slider.bind( "<ButtonRelease-1>", lambda event: self.training_sample_size_slider_callback()) self.training_sample_size_slider.grid(row=0, column=2, sticky=tk.N + tk.E + tk.S + tk.W) self.stride_slider = tk.Scale( self.controls_frame, variable=tk.DoubleVar(), orient=tk.HORIZONTAL, from_=1, to_=100, resolution=1, bg="#DDDDDD", activebackground="#FF0000", highlightcolor="#00FFFF", label="Stride(s)", command=lambda event: self.set_stride_callback()) self.stride_slider.set(self.stride) self.stride_slider.bind("<ButtonRelease-1>", lambda event: self.set_stride_callback()) self.stride_slider.grid(row=0, column=3, sticky=tk.N + tk.E + tk.S + tk.W) self.number_of_iterations_slider = tk.Scale( self.controls_frame, variable=tk.DoubleVar(), orient=tk.HORIZONTAL, from_=1, to_=100, resolution=1, bg="#DDDDDD", activebackground="#FF0000", highlightcolor="#00FFFF", label="Iterations", command=lambda event: self.number_of_iterations_slider_callback()) self.number_of_iterations_slider.set(self.number_of_iterations) self.number_of_iterations_slider.bind( "<ButtonRelease-1>", lambda event: self.number_of_iterations_slider_callback()) self.number_of_iterations_slider.grid(row=0, column=4, sticky=tk.N + tk.E + tk.S + tk.W) self.label_for_data_file = tk.Label(self.controls_frame, text="Data File:", justify="center") self.label_for_data_file.grid(row=0, column=5, sticky=tk.N + tk.E + tk.S + tk.W) self.data_file_variable = tk.StringVar() self.data_file_dropdown = tk.OptionMenu( self.controls_frame, self.data_file_variable, "data_set_1.csv", "data_set_2.csv", command=lambda event: self.data_file_dropdown_callback()) self.data_file_variable.set(self.input_file) self.data_file_dropdown.grid(row=0, column=6, sticky=tk.N + tk.E + tk.S + tk.W) self.adjust_weights_button = tk.Button( self.controls_frame, text="Adjust Weights(LMS)", fg="red", command=lambda: self.adjust_weights_button_callback()) self.adjust_weights_direct_button = tk.Button( self.controls_frame, text="Adjust Weights(Direct)", fg="red", command=lambda: self.adjust_weights_direct_button_callback()) self.set_weights_to_zero_button = tk.Button( self.controls_frame, text="Set Weights to Zero", fg="red", command=lambda: self.set_weights_to_zero_button_callback()) self.adjust_weights_button.grid(row=0, column=7, sticky=tk.N + tk.E + tk.S + tk.W) self.adjust_weights_direct_button.grid(row=0, column=8, sticky=tk.N + tk.E + tk.S + tk.W) self.set_weights_to_zero_button.grid(row=0, column=9, sticky=tk.N + tk.E + tk.S + tk.W) self.canvas.get_tk_widget().bind("<ButtonPress-1>", self.left_mouse_click_callback) self.canvas.get_tk_widget().bind("<ButtonPress-1>", self.left_mouse_click_callback) self.canvas.get_tk_widget().bind("<ButtonRelease-1>", self.left_mouse_release_callback) self.canvas.get_tk_widget().bind("<B1-Motion>", self.left_mouse_down_motion_callback) self.canvas.get_tk_widget().bind("<ButtonPress-3>", self.right_mouse_click_callback) self.canvas.get_tk_widget().bind("<ButtonRelease-3>", self.right_mouse_release_callback) self.canvas.get_tk_widget().bind("<B3-Motion>", self.right_mouse_down_motion_callback) self.canvas.get_tk_widget().bind("<Key>", self.key_pressed_callback) self.canvas.get_tk_widget().bind("<Up>", self.up_arrow_pressed_callback) self.canvas.get_tk_widget().bind("<Down>", self.down_arrow_pressed_callback) self.canvas.get_tk_widget().bind("<Right>", self.right_arrow_pressed_callback) self.canvas.get_tk_widget().bind("<Left>", self.left_arrow_pressed_callback) self.canvas.get_tk_widget().bind("<Shift-Up>", self.shift_up_arrow_pressed_callback) self.canvas.get_tk_widget().bind( "<Shift-Down>", self.shift_down_arrow_pressed_callback) self.canvas.get_tk_widget().bind( "<Shift-Right>", self.shift_right_arrow_pressed_callback) self.canvas.get_tk_widget().bind( "<Shift-Left>", self.shift_left_arrow_pressed_callback) self.canvas.get_tk_widget().bind("f", self.f_key_pressed_callback) self.canvas.get_tk_widget().bind("b", self.b_key_pressed_callback) def key_pressed_callback(self, event): self.root.status_bar.set('%s', 'Key pressed') def up_arrow_pressed_callback(self, event): self.root.status_bar.set('%s', "Up arrow was pressed") def down_arrow_pressed_callback(self, event): self.root.status_bar.set('%s', "Down arrow was pressed") def right_arrow_pressed_callback(self, event): self.root.status_bar.set('%s', "Right arrow was pressed") def left_arrow_pressed_callback(self, event): self.root.status_bar.set('%s', "Left arrow was pressed") def shift_up_arrow_pressed_callback(self, event): self.root.status_bar.set('%s', "Shift up arrow was pressed") def shift_down_arrow_pressed_callback(self, event): self.root.status_bar.set('%s', "Shift down arrow was pressed") def shift_right_arrow_pressed_callback(self, event): self.root.status_bar.set('%s', "Shift right arrow was pressed") def shift_left_arrow_pressed_callback(self, event): self.root.status_bar.set('%s', "Shift left arrow was pressed") def f_key_pressed_callback(self, event): self.root.status_bar.set('%s', "f key was pressed") def b_key_pressed_callback(self, event): self.root.status_bar.set('%s', "b key was pressed") def left_mouse_click_callback(self, event): self.root.status_bar.set( '%s', 'Left mouse button was clicked. ' + 'x=' + str(event.x) + ' y=' + str(event.y)) self.x = event.x self.y = event.y self.canvas.focus_set() def left_mouse_release_callback(self, event): self.root.status_bar.set( '%s', 'Left mouse button was released. ' + 'x=' + str(event.x) + ' y=' + str(event.y)) self.x = None self.y = None def left_mouse_down_motion_callback(self, event): self.root.status_bar.set( '%s', 'Left mouse down motion. ' + 'x=' + str(event.x) + ' y=' + str(event.y)) self.x = event.x self.y = event.y def right_mouse_click_callback(self, event): self.root.status_bar.set( '%s', 'Right mouse down motion. ' + 'x=' + str(event.x) + ' y=' + str(event.y)) self.x = event.x self.y = event.y def right_mouse_release_callback(self, event): self.root.status_bar.set( '%s', 'Right mouse button was released. ' + 'x=' + str(event.x) + ' y=' + str(event.y)) self.x = None self.y = None def right_mouse_down_motion_callback(self, event): self.root.status_bar.set( '%s', 'Right mouse down motion. ' + 'x=' + str(event.x) + ' y=' + str(event.y)) self.x = event.x self.y = event.y def left_mouse_click_callback(self, event): self.root.status_bar.set( '%s', 'Left mouse button was clicked. ' + 'x=' + str(event.x) + ' y=' + str(event.y)) self.x = event.x self.y = event.y #################### def get_data(self): self.input_weight = np.zeros( shape=((2 * (self.number_of_delayed_elements + 1)) + 1, )) self.input_values = [] self.target_values = [] price_change, volume_change = Parikh_04_03.read_csv_as_matrix( self.input_file) start_index = 0 current_index = self.number_of_delayed_elements target_index = current_index + 1 bias = 1 while current_index < len(price_change) - 1: data = list(price_change[start_index:current_index + 1]) data.extend(list(volume_change[start_index:current_index + 1])) data.extend([ bias, ]) self.input_values.append(data) self.target_values.append(price_change[target_index]) current_index += self.stride target_index += self.stride start_index += self.stride # print(np.array(self.target_values).shape) # print(np.array(self.input_values).shape) # self.focus_set() def display_activation_function(self): # self.get_data() self.mse, self.mae = Parikh_04_02.calculate_activation_function( self.input_weight, self.alpha, self.input_values, self.target_values, self.training_sample_size, self.number_of_iterations, self.learn_type) self.axes.cla() self.axes.set_xlabel('Iterations') self.axes.set_ylabel('Error') self.axes.plot(range(1, self.number_of_iterations + 1), self.mse, 'r-', label='MSE') self.axes.plot(range(1, self.number_of_iterations + 1), self.mae, 'y-', label='MAE') self.axes.xaxis.set_visible(True) # plt.xlim(self.xmin, self.xmax) # plt.ylim(self.ymin, self.ymax) self.axes.legend() plt.title("Mean Squared Error and Max Absolute Error") self.canvas.draw() def learning_rate_slider_callback(self): self.alpha = np.float(self.learning_rate_slider.get()) def adjust_weights_button_callback(self): self.learn_type = 0 self.display_activation_function() def data_file_dropdown_callback(self): self.input_file = self.data_file_variable.get() self.get_data() def set_weights_to_zero_button_callback(self): self.input_weight = np.zeros( shape=((2 * (self.number_of_delayed_elements + 1)) + 1, )) def adjust_weights_direct_button_callback(self): self.learn_type = 1 self.display_activation_function() def number_of_delayed_elements_slider_callback(self): self.number_of_delayed_elements = self.number_of_delayed_elements_slider.get( ) self.get_data() def training_sample_size_slider_callback(self): self.training_sample_size = self.training_sample_size_slider.get() def set_stride_callback(self): self.stride = self.stride_slider.get() def number_of_iterations_slider_callback(self): self.number_of_iterations = self.number_of_iterations_slider.get()
class LeftFrame: """ This class creates and controls the widgets and figures in the left frame which are used to display the activation functions. Farhad Kamangar 2018_06_03 """ def __init__(self, root, master, debug_print_flag=False): self.master = master self.root = root ######################################################################### # Set up the constants and default values ######################################################################### self.xmin = 0 self.xmax = 10 self.ymin = 0 self.ymax = 2 self.alpha_rate = 0.1 self.delay_element = 11 self.train_size = 0.8 self.stride = 2 self.iterations = 10 self.weights = np.zeros((1, (2 * (self.delay_element)) + 1)) self.test_data = [] self.train_data = [] self.data = [] self.mae = [] self.mse = [] self.current_epoch = 0 ######################################################################### # Set up the plotting frame and controls frame ######################################################################### master.rowconfigure(0, weight=10, minsize=200) master.columnconfigure(0, weight=1) self.plot_frame = tk.Frame(self.master, borderwidth=10, relief=tk.SUNKEN) self.plot_frame.grid(row=0, column=0, columnspan=1, sticky=tk.N + tk.E + tk.S + tk.W) self.figure = plt.figure("") self.axes = self.figure.add_axes([0.15, 0.15, 0.6, 0.8]) # self.axes = self.figure.add_axes() self.axes = self.figure.gca() self.axes.set_xlabel('Iteration') self.axes.set_ylabel('Error') # self.axes.margins(0.5) self.axes.set_title("") plt.xlim(self.xmin, self.xmax) plt.ylim(self.ymin, self.ymax) self.canvas = FigureCanvasTkAgg(self.figure, master=self.plot_frame) self.plot_widget = self.canvas.get_tk_widget() self.plot_widget.grid(row=0, column=0, sticky=tk.N + tk.E + tk.S + tk.W) self.plot_widget.pack(side="top", fill='both', expand=True) # Create a frame to contain all the controls such as sliders, buttons, ... self.controls_frame = tk.Frame(self.master) self.controls_frame.grid(row=1, column=0, sticky=tk.N + tk.E + tk.S + tk.W) ######################################################################### # Set up the control widgets such as sliders and selection boxes ######################################################################### self.data = self.read_csv_as_matrix("data1.csv") # read data self.train_test_split() # split data self.number_of_delay_slider = tk.Scale( self.controls_frame, variable=tk.DoubleVar(), orient=tk.HORIZONTAL, from_=0, to_=100, resolution=10, bg="#DDDDDD", activebackground="#FF0000", highlightcolor="#00FFFF", label="Delay Element", command=lambda event: self.slider_callback()) self.number_of_delay_slider.set(self.delay_element - 1) self.number_of_delay_slider.bind("<ButtonRelease-1>", lambda event: self.slider_callback()) self.number_of_delay_slider.grid(row=0, column=0, sticky=tk.N + tk.E + tk.S + tk.W) ######################################################################### # Set up the control widgets such as sliders and selection boxes ######################################################################### self.alpha_rate_slider = tk.Scale( self.controls_frame, variable=tk.DoubleVar(), orient=tk.HORIZONTAL, from_=0.001, to_=1, resolution=0.001, bg="#DDDDDD", activebackground="#FF0000", highlightcolor="#00FFFF", label="Alpha Rate", command=lambda event: self.slider_callback()) self.alpha_rate_slider.set(self.alpha_rate) self.alpha_rate_slider.bind("<ButtonRelease-1>", lambda event: self.slider_callback()) self.alpha_rate_slider.grid(row=0, column=1, sticky=tk.N + tk.E + tk.S + tk.W) ######################################################################### # Set up the control widgets such as sliders and selection boxes ######################################################################### self.training_sample_slider = tk.Scale( self.controls_frame, variable=tk.DoubleVar(), orient=tk.HORIZONTAL, from_=0, to_=100, resolution=10, bg="#DDDDDD", activebackground="#FF0000", highlightcolor="#00FFFF", label="Train Size", command=lambda event: self.slider_callback()) self.training_sample_slider.set(int(self.train_size * 100)) self.training_sample_slider.bind("<ButtonRelease-1>", lambda event: self.slider_callback()) self.training_sample_slider.grid(row=0, column=2, sticky=tk.N + tk.E + tk.S + tk.W) ######################################################################### # Set up the control widgets such as sliders and selection boxes ######################################################################### self.stride_slider = tk.Scale( self.controls_frame, variable=tk.DoubleVar(), orient=tk.HORIZONTAL, from_=0, to_=100, resolution=1, bg="#DDDDDD", activebackground="#FF0000", highlightcolor="#00FFFF", label="Stride", command=lambda event: self.slider_callback()) self.stride_slider.set(self.stride // 2) self.stride_slider.bind("<ButtonRelease-1>", lambda event: self.slider_callback()) self.stride_slider.grid(row=0, column=3, sticky=tk.N + tk.E + tk.S + tk.W) ######################################################################### # Set up the control widgets such as sliders and selection boxes ######################################################################### self.number_of_iteration_slider = tk.Scale( self.controls_frame, variable=tk.DoubleVar(), orient=tk.HORIZONTAL, from_=0, to_=100, resolution=10, bg="#DDDDDD", activebackground="#FF0000", highlightcolor="#00FFFF", label="Iterations", command=lambda event: self.slider_callback()) self.number_of_iteration_slider.set(self.iterations) self.number_of_iteration_slider.bind( "<ButtonRelease-1>", lambda event: self.slider_callback()) self.number_of_iteration_slider.grid(row=0, column=4, sticky=tk.N + tk.E + tk.S + tk.W) ######################################################################### # Set up the frame for drop down selection ######################################################################### self.reset_weights_button = tk.Button( self.controls_frame, text="Reset Weights", fg="blue", command=self.reset_weights_function) self.reset_weights_button.grid(row=0, column=5) self.adjust_weights_LMS_button = tk.Button( self.controls_frame, text="LMS", fg="blue", command=self.do_lms_algo_training) self.adjust_weights_LMS_button.grid(row=0, column=6) self.adjust_weights_direct_button = tk.Button( self.controls_frame, text="Direct", fg="blue", command=self.do_direct_algorithm) self.adjust_weights_direct_button.grid(row=0, column=7) self.canvas.get_tk_widget().bind("<ButtonPress-1>", self.left_mouse_click_callback) self.canvas.get_tk_widget().bind("<ButtonPress-1>", self.left_mouse_click_callback) self.canvas.get_tk_widget().bind("<ButtonRelease-1>", self.left_mouse_release_callback) self.canvas.get_tk_widget().bind("<B1-Motion>", self.left_mouse_down_motion_callback) self.canvas.get_tk_widget().bind("<ButtonPress-3>", self.right_mouse_click_callback) self.canvas.get_tk_widget().bind("<ButtonRelease-3>", self.right_mouse_release_callback) self.canvas.get_tk_widget().bind("<B3-Motion>", self.right_mouse_down_motion_callback) self.canvas.get_tk_widget().bind("<Key>", self.key_pressed_callback) self.canvas.get_tk_widget().bind("<Up>", self.up_arrow_pressed_callback) self.canvas.get_tk_widget().bind("<Down>", self.down_arrow_pressed_callback) self.canvas.get_tk_widget().bind("<Right>", self.right_arrow_pressed_callback) self.canvas.get_tk_widget().bind("<Left>", self.left_arrow_pressed_callback) self.canvas.get_tk_widget().bind("<Shift-Up>", self.shift_up_arrow_pressed_callback) self.canvas.get_tk_widget().bind( "<Shift-Down>", self.shift_down_arrow_pressed_callback) self.canvas.get_tk_widget().bind( "<Shift-Right>", self.shift_right_arrow_pressed_callback) self.canvas.get_tk_widget().bind( "<Shift-Left>", self.shift_left_arrow_pressed_callback) self.canvas.get_tk_widget().bind("f", self.f_key_pressed_callback) self.canvas.get_tk_widget().bind("b", self.b_key_pressed_callback) def key_pressed_callback(self, event): self.root.status_bar.set('%s', 'Key pressed') def up_arrow_pressed_callback(self, event): self.root.status_bar.set('%s', "Up arrow was pressed") def down_arrow_pressed_callback(self, event): self.root.status_bar.set('%s', "Down arrow was pressed") def right_arrow_pressed_callback(self, event): self.root.status_bar.set('%s', "Right arrow was pressed") def left_arrow_pressed_callback(self, event): self.root.status_bar.set('%s', "Left arrow was pressed") def shift_up_arrow_pressed_callback(self, event): self.root.status_bar.set('%s', "Shift up arrow was pressed") def shift_down_arrow_pressed_callback(self, event): self.root.status_bar.set('%s', "Shift down arrow was pressed") def shift_right_arrow_pressed_callback(self, event): self.root.status_bar.set('%s', "Shift right arrow was pressed") def shift_left_arrow_pressed_callback(self, event): self.root.status_bar.set('%s', "Shift left arrow was pressed") def f_key_pressed_callback(self, event): self.root.status_bar.set('%s', "f key was pressed") def b_key_pressed_callback(self, event): self.root.status_bar.set('%s', "b key was pressed") def left_mouse_click_callback(self, event): self.root.status_bar.set( '%s', 'Left mouse button was clicked. ' + 'x=' + str(event.x) + ' y=' + str(event.y)) self.x = event.x self.y = event.y self.canvas.focus_set() def left_mouse_release_callback(self, event): self.root.status_bar.set( '%s', 'Left mouse button was released. ' + 'x=' + str(event.x) + ' y=' + str(event.y)) self.x = None self.y = None def left_mouse_down_motion_callback(self, event): self.root.status_bar.set( '%s', 'Left mouse down motion. ' + 'x=' + str(event.x) + ' y=' + str(event.y)) self.x = event.x self.y = event.y def right_mouse_click_callback(self, event): self.root.status_bar.set( '%s', 'Right mouse down motion. ' + 'x=' + str(event.x) + ' y=' + str(event.y)) self.x = event.x self.y = event.y def right_mouse_release_callback(self, event): self.root.status_bar.set( '%s', 'Right mouse button was released. ' + 'x=' + str(event.x) + ' y=' + str(event.y)) self.x = None self.y = None def right_mouse_down_motion_callback(self, event): self.root.status_bar.set( '%s', 'Right mouse down motion. ' + 'x=' + str(event.x) + ' y=' + str(event.y)) self.x = event.x self.y = event.y def left_mouse_click_callback(self, event): self.root.status_bar.set( '%s', 'Left mouse button was clicked. ' + 'x=' + str(event.x) + ' y=' + str(event.y)) self.x = event.x self.y = event.y def slider_callback(self): self.iterations = int(self.number_of_iteration_slider.get()) self.stride = int(self.stride_slider.get()) * 2 self.train_size = np.float(self.training_sample_slider.get()) / 100 self.alpha_rate = np.float(self.alpha_rate_slider.get()) if self.delay_element != int(self.number_of_delay_slider.get()) + 1: self.delay_element = int(self.number_of_delay_slider.get()) + 1 self.reset_weights_function() def read_csv_as_matrix(self, file_name): # Each row of data in the file becomes a row in the matrix # So the resulting matrix has dimension [num_samples x sample_dimension] data = np.loadtxt(file_name, skiprows=1, delimiter=',', dtype=np.float32) std = lambda x: 2 * ((x - np.amin(x)) / (np.amax(x) - np.amin(x))) - 1 return np.apply_along_axis(std, 0, data) # self.focus_set() def display_activation_function(self, x_val, y_val, y_val_2, sttring): self.axes.relim() self.axes.autoscale_view() self.axes.cla() self.axes.set_xlabel('Iterations') self.axes.set_ylabel('Errors') self.axes.plot(x_val, y_val, "k--", color="blue", label="Mean Square Error") self.axes.plot(x_val, y_val_2, "k:", color="green", label="Maximum Absolute Error") self.axes.set_ylim([self.ymin, self.ymax]) self.axes.xaxis.set_visible(True) self.axes.legend(loc='upper right', shadow=True) plt.title(sttring) self.canvas.draw() def input_weight_slider_callback(self): self.alpha_rate = np.float(self.alpha_learning_rate_slider.get()) def train_test_split(self): split_row = int(self.train_size * len(self.data)) self.train_data = self.data[:split_row] self.test_data = self.data[split_row:] def do_lms_algo_training(self): for k in range(self.current_epoch, self.current_epoch + self.iterations): #Training Part len_1 = len(self.train_data) for i in range(0, len_1 - self.delay_element, self.stride): delay = min(self.delay_element, len_1 - i - 1) if delay != self.delay_element: diff = (self.delay_element) - delay dd = np.hstack( (np.flipud(self.train_data[i:i + delay, 1]), [0] * diff, np.flipud(self.train_data[i:i + delay, 0]), [0] * diff, [1])) else: dd = np.hstack((np.flipud(self.train_data[i:i + delay, 1]), np.flipud(self.train_data[i:i + delay, 0]), [1])) error = self.train_data[i + delay, 0] - np.dot( self.weights, dd) self.weights += np.multiply(2 * self.alpha_rate * error, dd) #Testing Part len_1 = len(self.test_data) predic = [] true = [] for i in range(0, len_1 - self.delay_element, self.stride): delay = min(self.delay_element, len_1 - i - 1) if delay != self.delay_element: diff = (self.delay_element) - delay dd = np.hstack( (np.flipud(self.test_data[i:i + delay, 1]), [0] * diff, np.flipud(self.test_data[i:i + delay, 0]), [0] * diff, [1])) else: dd = np.hstack((np.flipud(self.data[i:i + delay, 1]), np.flipud(self.test_data[i:i + delay, 0]), [1])) predic.append(np.dot(self.weights, dd)[0]) true.append(self.test_data[i + delay, 0]) #plot them on the graph self.mse.append(mean_squared_error(true, predic)) self.mae.append(max(np.absolute(np.subtract(true, predic)))) self.display_activation_function(range(len(self.mse)), self.mse, self.mae, "LMS") def do_direct_algorithm(self): for k in range(self.current_epoch, self.current_epoch + self.iterations): len_1 = len(self.train_data) h = np.zeros((1, (2 * (self.delay_element)) + 1)) R = np.zeros((((2 * (self.delay_element)) + 1), (2 * (self.delay_element)) + 1)) total = 0 for i in range(0, len_1 - self.delay_element, self.stride): total += 1 delay = min(self.delay_element, len_1 - i - 1) if delay != self.delay_element: diff = (self.delay_element) - delay dd = np.hstack( (np.flipud(self.train_data[i:i + delay, 1]), [0] * diff, np.flipud(self.train_data[i:i + delay, 0]), [0] * diff, [1])) else: dd = np.hstack((np.flipud(self.train_data[i:i + delay, 1]), np.flipud(self.train_data[i:i + delay, 0]), [1])) target = self.train_data[i + delay, 0] h += np.multiply(target, dd) R += np.outer(dd, dd) R /= total h /= total self.weights = np.dot(h, np.linalg.inv(R)) len_1 = len(self.test_data) predic = [] true = [] for i in range(0, len_1 - self.delay_element, self.stride): delay = min(self.delay_element, len_1 - i - 1) if delay != self.delay_element: diff = (self.delay_element) - delay dd = np.hstack( (np.flipud(self.test_data[i:i + delay, 1]), [0] * diff, np.flipud(self.test_data[i:i + delay, 0]), [0] * diff, [1])) else: dd = np.hstack((np.flipud(self.data[i:i + delay, 1]), np.flipud(self.test_data[i:i + delay, 0]), [1])) predic.append(np.dot(self.weights, dd)[0]) true.append(self.test_data[i + delay, 0]) #plot them on the graph self.mse.append(mean_squared_error(true, predic)) self.mae.append(max(np.absolute(np.subtract(true, predic)))) self.display_activation_function(range(len(self.mse)), self.mse, self.mae, "LMS Direct") def reset_weights_function(self): self.weights = np.zeros((1, (2 * (self.delay_element)) + 1))
class RightFrame: """ This class is for creating right frame widgets which are used to draw graphics on canvas as well as embedding matplotlib figures in the tkinter. Farhad Kamangar 2018_06_03 """ def __init__(self, root, master, debug_print_flag=False): self.master = master self.root = root ######################################################################### # Set up the constants and default values ######################################################################### self.ep=0.0 self.xmin = 0 self.xmax = 10 self.ymin = 0 self.ymax = 2 self.debug_print_flag = debug_print_flag self.Alpha = 1 self.Learning_Rate=0.1 self.Number_of_Nodes_in_Hidden_Layer = 100 self.Number_of_Samples=20 self.Numbe_of_Classes=4 self.Lambda=0.01 self.activation_type = "Relu" self.Type_of_generated_data= "s_curve" ######################################################################### # Set up the plotting frame and controls frame ######################################################################### master.rowconfigure(0, weight=10, minsize=200) master.columnconfigure(0, weight=1) self.plot_frame = tk.Frame(self.master, borderwidth=10, relief=tk.SUNKEN) self.plot_frame.grid(row=0, column=0, columnspan=1, sticky=tk.N + tk.E + tk.S + tk.W) self.figure = plt.figure(figsize=(9.5,5)) self.axes = self.figure.add_axes([0.15, 0.15, 0.6, 0.8]) #self.axes = self.figure.add_axes() self.axes = self.figure.gca() # self.axes.margins(0.5) #self.axes.set_title("MSE") self.canvas = FigureCanvasTkAgg(self.figure, master=self.plot_frame) self.plot_widget = self.canvas.get_tk_widget() self.plot_widget.grid(row=0, column=0, sticky=tk.N + tk.E + tk.S + tk.W) # Create a frame to contain all the controls such as sliders, buttons, ... self.controls_frame = tk.Frame(self.master) self.controls_frame.grid(row=1, column=0, sticky=tk.N + tk.E + tk.S + tk.W) ######################################################################### # Set up the control widgets such as sliders and selection boxes ######################################################################### self.Alpha_slider = tk.Scale(self.controls_frame, variable=tk.DoubleVar(), orient=tk.HORIZONTAL, from_=0.1, to_=1.0, resolution=.001, bg="#DDDDDD", activebackground="#FF0000", highlightcolor="#00FFFF", label="Alpha", command=lambda event: self.Alpha_slider_callback()) self.Alpha_slider.set(self.Alpha) self.Alpha_slider.bind("<ButtonRelease-1>", lambda event: self.Alpha_slider_callback()) self.Alpha_slider.grid(row=0, column=2, sticky=tk.N + tk.E + tk.S + tk.W) #------------------------------- self.Lambda = tk.Scale(self.controls_frame, variable=tk.DoubleVar(), orient=tk.HORIZONTAL, from_=0.0, to_=1.0, resolution=0.01, bg="#DDDDDD", activebackground="#FF0000", highlightcolor="#00FFFF", label="Lambda", command=lambda event: self.Lambda_callback()) self.Lambda.set(self.Learning_Rate) self.Lambda.bind("<ButtonRelease-1>", lambda event: self.Lambda_callback()) self.Lambda.grid(row=1, column=2, sticky=tk.N + tk.E + tk.S + tk.W) #------------------------------- self.Number_of_Nodes_in_Hidden_Layer_slider = tk.Scale(self.controls_frame, variable=tk.DoubleVar(), orient=tk.HORIZONTAL, from_=1, to_=500, resolution=1, bg="#DDDDDD", activebackground="#FF0000", highlightcolor="#00FFFF", label="Num. of Nodes in Hidden Layer", command=lambda event: self.Number_of_Nodes_in_Hidden_Layer_slider_callback()) self.Number_of_Nodes_in_Hidden_Layer_slider.set(self.Number_of_Nodes_in_Hidden_Layer) self.Number_of_Nodes_in_Hidden_Layer_slider.bind("<ButtonRelease-1>", lambda event: self.Number_of_Nodes_in_Hidden_Layer_slider_callback()) self.Number_of_Nodes_in_Hidden_Layer_slider.grid(row=3, column=2, sticky=tk.N + tk.E + tk.S + tk.W) #------------------------------- self.Number_of_Samples_slider = tk.Scale(self.controls_frame, variable=tk.DoubleVar(), orient=tk.HORIZONTAL, from_=4, to_=1000, resolution=1, bg="#DDDDDD", activebackground="#FF0000", highlightcolor="#00FFFF", label="Number of Samples", command=lambda event: self.Number_of_Samples_slider_callback()) self.Number_of_Samples_slider.set(self.Number_of_Samples) self.Number_of_Samples_slider.bind("<ButtonRelease-1>", lambda event: self.Number_of_Samples_slider_callback()) self.Number_of_Samples_slider.grid(row=4, column=2, sticky=tk.N + tk.E + tk.S + tk.W) #------------------------------- self.Numbe_of_Classes_slider = tk.Scale(self.controls_frame, variable=tk.DoubleVar(), orient=tk.HORIZONTAL, from_=2, to_=10, resolution=1, bg="#DDDDDD", activebackground="#FF0000", highlightcolor="#00FFFF", label="Number of Classes", command=lambda event: self.Numbe_of_Classes_slider_callback()) self.Numbe_of_Classes_slider.set(self.Numbe_of_Classes) self.Numbe_of_Classes_slider.bind("<ButtonRelease-1>", lambda event: self.Numbe_of_Classes_slider_callback()) self.Numbe_of_Classes_slider.grid(row=5, column=2, sticky=tk.N + tk.E + tk.S + tk.W) #------------------------------- ######################################################################### # Set up the frame for botton selection ######################################################################### self.Adjust_Weights_button = tk.Button(self.controls_frame, text="Adjust Weights", fg="red", width=16, command=self.Adjust_Weights_callback) self.Reset_Weights_button = tk.Button(self.controls_frame, text="Reset Weights", fg="red", width=16, command=self.Reset_Weights_callback) self.Adjust_Weights_button.grid(row=0, column=4) self.Reset_Weights_button.grid(row=1, column=4) ######################################################################### # Set up the frame for drop down selection ######################################################################### self.label_for_activation_function = tk.Label(self.controls_frame, text="Activation Function Type:", justify="center") self.label_for_activation_function.grid(row=3, column=4, sticky=tk.N + tk.E + tk.S + tk.W) self.activation_function_variable = tk.StringVar() self.activation_function_dropdown = tk.OptionMenu(self.controls_frame, self.activation_function_variable, "Relu", "Sigmoid", command=lambda event: self.activation_function_dropdown_callback()) self.activation_function_variable.set("Relu") self.activation_function_dropdown.grid(row=3, column=5, sticky=tk.N + tk.E + tk.S + tk.W) self.label_for_Type_of_generated_data = tk.Label(self.controls_frame, text="Type of generated data:", justify="center") self.label_for_Type_of_generated_data.grid(row=4, column=4, sticky=tk.N + tk.E + tk.S + tk.W) self.Type_of_generated_data_variable = tk.StringVar() self.Type_of_generated_data_dropdown = tk.OptionMenu(self.controls_frame, self.Type_of_generated_data_variable, "s_curve", "blobs", "swiss_roll", "moons", command=lambda event: self.Type_of_generated_data_dropdown_callback()) self.Type_of_generated_data_variable.set("s_curve") self.Type_of_generated_data_dropdown.grid(row=4, column=5, sticky=tk.N + tk.E + tk.S + tk.W) self.canvas.get_tk_widget().bind("<ButtonPress-1>", self.left_mouse_click_callback) self.canvas.get_tk_widget().bind("<ButtonPress-1>", self.left_mouse_click_callback) self.canvas.get_tk_widget().bind("<ButtonRelease-1>", self.left_mouse_release_callback) self.canvas.get_tk_widget().bind("<B1-Motion>", self.left_mouse_down_motion_callback) self.canvas.get_tk_widget().bind("<ButtonPress-3>", self.right_mouse_click_callback) self.canvas.get_tk_widget().bind("<ButtonRelease-3>", self.right_mouse_release_callback) self.canvas.get_tk_widget().bind("<B3-Motion>", self.right_mouse_down_motion_callback) self.canvas.get_tk_widget().bind("<Key>", self.key_pressed_callback) self.canvas.get_tk_widget().bind("<Up>", self.up_arrow_pressed_callback) self.canvas.get_tk_widget().bind("<Down>", self.down_arrow_pressed_callback) self.canvas.get_tk_widget().bind("<Right>", self.right_arrow_pressed_callback) self.canvas.get_tk_widget().bind("<Left>", self.left_arrow_pressed_callback) self.canvas.get_tk_widget().bind("<Shift-Up>", self.shift_up_arrow_pressed_callback) self.canvas.get_tk_widget().bind("<Shift-Down>", self.shift_down_arrow_pressed_callback) self.canvas.get_tk_widget().bind("<Shift-Right>", self.shift_right_arrow_pressed_callback) self.canvas.get_tk_widget().bind("<Shift-Left>", self.shift_left_arrow_pressed_callback) self.canvas.get_tk_widget().bind("f", self.f_key_pressed_callback) self.canvas.get_tk_widget().bind("b", self.b_key_pressed_callback) self.initial_data() def Alpha_slider_callback(self): self.Alpha = np.int(self.Alpha_slider.get()) def Lambda_callback(self): self.Learning_Rate = np.float(self.Lambda.get()) def Number_of_Nodes_in_Hidden_Layer_slider_callback(self): self.Number_of_Nodes_in_Hidden_Layer = np.int(self.Number_of_Nodes_in_Hidden_Layer_slider.get()) def Number_of_Samples_slider_callback(self): self.Number_of_Samples = np.int(self.Number_of_Samples_slider.get()) def Numbe_of_Classes_slider_callback(self): self.Numbe_of_Classes = np.int(self.Numbe_of_Classes_slider.get()) def Adjust_Weights_callback(self): self.Adjust_Weights() def Reset_Weights_callback(self): self.Reset_Weights() def Adjust_Weights_Direct_callback(self): self.Adjust_Weights_Direct() def activation_function_dropdown_callback(self): self.activation_type = self.activation_function_variable.get() def Type_of_generated_data_dropdown_callback(self): self.Type_of_generated_data = self.Type_of_generated_data_variable.get() def generate_data(self,dataset_name, n_samples, n_classes): if dataset_name == 'swiss_roll': data = sklearn.datasets.make_swiss_roll(n_samples, noise=1.5, random_state=99)[0] data = data[:, [0, 2]] if dataset_name == 'moons': data = sklearn.datasets.make_moons(n_samples=n_samples, noise=0.15)[0] if dataset_name == 'blobs': data = sklearn.datasets.make_blobs(n_samples=n_samples, centers=n_classes*2, n_features=2, cluster_std=0.85*np.sqrt(n_classes), random_state=100) return data[0]/10., [i % n_classes for i in data[1]] if dataset_name == 's_curve': data = sklearn.datasets.make_s_curve(n_samples=n_samples, noise=0.15, random_state=100)[0] data = data[:, [0,2]]/3.0 ward = AgglomerativeClustering(n_clusters=n_classes*2, linkage='ward').fit(data) return data[:]+np.random.randn(*data.shape)*0.03, [i % n_classes for i in ward.labels_] def initial_data(self): self.X, self.y = self.generate_data(self.Type_of_generated_data, self.Number_of_Samples, self.Numbe_of_Classes ) min_x=np.amin(self.X, axis=0) max_x=np.amax(self.X, axis=0) self.min_x = min_x[0] self.max_x = max_x[0] self.min_y = min_x[1] self.max_y = max_x[1] self.display_error_epoch() def Reset_Weights(self): self.axes.cla() self.initial_data() self.Weight1 =self.init1 self.Weight2 = self.init2 self.bias1 = self.init_bias1 self.bias2 = self.init_bias2 def Adjust_Weights(self): self.axes.cla() #### initialize weights and biases tf.reset_default_graph() init1=np.random.uniform(size=2*self.Number_of_Nodes_in_Hidden_Layer) self.init1=np.reshape(init1,(self.Number_of_Nodes_in_Hidden_Layer,2)) init2=np.random.uniform(size=self.Number_of_Nodes_in_Hidden_Layer*self.Numbe_of_Classes) self.init2=np.reshape(init2,(self.Numbe_of_Classes,self.Number_of_Nodes_in_Hidden_Layer)) init_bias1=np.random.uniform(size=self.Number_of_Nodes_in_Hidden_Layer) self.init_bias1=np.reshape(init_bias1,(self.Number_of_Nodes_in_Hidden_Layer,1)) init_bias2=np.random.uniform(size=self.Numbe_of_Classes) self.init_bias2=np.reshape(init_bias2,(self.Numbe_of_Classes,1)) ###### Declaring placeholders and variables Train_input = tf.placeholder(dtype=tf.float64) Train_target = tf.placeholder(tf.int64) self.Weight1 = tf.Variable(self.init1, dtype=np.float64) self.Weight2 = tf.Variable(self.init2, dtype=np.float64) self.bias1 = tf.Variable(self.init_bias1, dtype=np.float64) self.bias2 = tf.Variable(self.init_bias2, dtype=np.float64) Alpha = tf.placeholder(dtype=np.float64) lamda= tf.placeholder(dtype=np.float64) ###### Calculations for training output1 = tf.matmul(self.Weight1, Train_input) + self.bias1 actual = Ghaderi_05_02.calculate_activation_function(output1,self.activation_type) output2 = tf.matmul(self.Weight2, actual) + self.bias2 loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(labels=Train_target,logits=output2)) regularizer= tf.nn.l2_loss(self.Weight2) + tf.nn.l2_loss(self.Weight1) loss=tf.reduce_mean(loss + lamda*regularizer) optimizer=tf.train.GradientDescentOptimizer(Alpha).minimize(loss) train_prediction = tf.nn.softmax(output2) final_answer = tf.argmax(train_prediction) ###### meshgrid coordinates for testing the network res = 100; telorance_x = (self.max_x - self.min_x ) /20 telorance_y = (self.max_y - self.min_y ) /20 yy=np.linspace( self.min_y - telorance_y, self.max_y + telorance_y, res) xx=np.linspace( self.min_x - telorance_x, self.max_x + telorance_x, res) self.xx,self.yy= np.meshgrid(xx, yy) xx1=np.reshape(self.xx,(1,res*res)) yy1=np.reshape(self.yy,(1,res*res)) input_test=np.concatenate((xx1, yy1)) ###### Testing and obtain the colors output_test1 = tf.matmul(self.Weight1, input_test) + self.bias1 actual_test = Ghaderi_05_02.calculate_activation_function(output_test1,self.activation_type) output_test2 = tf.matmul(self.Weight2, actual_test) + self.bias2 test_prediction = tf.nn.softmax(output_test2) final_answer_test = tf.argmax(test_prediction) sess=tf.Session() # Run the initializer sess.run(tf.global_variables_initializer()) with sess.as_default(): input=np.transpose(self.X) ##### Running for i in range(40): opt,final=sess.run([optimizer,final_answer_test], feed_dict={Train_input: input, Train_target: self.y ,lamda : self.Learning_Rate, Alpha:self.Alpha}) self.final_color=np.reshape(final,(res,res)) print('yyyyyyyyyyyyyyy123',final) print('final_color',self.final_color) self.display_error_epoch1() self.display_error_epoch() sess.close() def display_error_epoch1(self): self.axes.cla() cmap = plt.get_cmap('PiYG') self.axes.pcolormesh(self.xx, self.yy, self.final_color, cmap=cmap) self.canvas.draw() def display_error_epoch(self): X=self.X y=self.y self.axes.scatter(X[:, 0], X[:, 1], c=y, cmap=plt.cm.Accent) plt.suptitle(self.Type_of_generated_data,fontsize=20) self.canvas.draw() def key_pressed_callback(self, event): self.root.status_bar.set('%s', 'Key pressed') def up_arrow_pressed_callback(self, event): self.root.status_bar.set('%s', "Up arrow was pressed") def down_arrow_pressed_callback(self, event): self.root.status_bar.set('%s', "Down arrow was pressed") def right_arrow_pressed_callback(self, event): self.root.status_bar.set('%s', "Right arrow was pressed") def left_arrow_pressed_callback(self, event): self.root.status_bar.set('%s', "Left arrow was pressed") def shift_up_arrow_pressed_callback(self, event): self.root.status_bar.set('%s', "Shift up arrow was pressed") def shift_down_arrow_pressed_callback(self, event): self.root.status_bar.set('%s', "Shift down arrow was pressed") def shift_right_arrow_pressed_callback(self, event): self.root.status_bar.set('%s', "Shift right arrow was pressed") def shift_left_arrow_pressed_callback(self, event): self.root.status_bar.set('%s', "Shift left arrow was pressed") def f_key_pressed_callback(self, event): self.root.status_bar.set('%s', "f key was pressed") def b_key_pressed_callback(self, event): self.root.status_bar.set('%s', "b key was pressed") def left_mouse_click_callback(self, event): self.root.status_bar.set('%s', 'Left mouse button was clicked. ' + 'x=' + str(event.x) + ' y=' + str( event.y)) self.x = event.x self.y = event.y self.canvas.focus_set() def left_mouse_release_callback(self, event): self.root.status_bar.set('%s', 'Left mouse button was released. ' + 'x=' + str(event.x) + ' y=' + str(event.y)) self.x = None self.y = None def left_mouse_down_motion_callback(self, event): self.root.status_bar.set('%s', 'Left mouse down motion. ' + 'x=' + str(event.x) + ' y=' + str(event.y)) self.x = event.x self.y = event.y def right_mouse_click_callback(self, event): self.root.status_bar.set('%s', 'Right mouse down motion. ' + 'x=' + str(event.x) + ' y=' + str(event.y)) self.x = event.x self.y = event.y def right_mouse_release_callback(self, event): self.root.status_bar.set('%s', 'Right mouse button was released. ' + 'x=' + str(event.x) + ' y=' + str(event.y)) self.x = None self.y = None def right_mouse_down_motion_callback(self, event): self.root.status_bar.set('%s', 'Right mouse down motion. ' + 'x=' + str(event.x) + ' y=' + str(event.y)) self.x = event.x self.y = event.y def left_mouse_click_callback(self, event): self.root.status_bar.set('%s', 'Left mouse button was clicked. ' + 'x=' + str(event.x) + ' y=' + str( event.y)) self.x = event.x self.y = event.y # self.focus_set() def frame_resized_callback(self, event): print("frame resize callback") def redisplay(self, event): self.create_graphic_objects()
class LeftFrame: """ This class creates and controls the widgets and figures in the left frame which are used to display the activation functions. Farhad Kamangar 2018_06_03 """ def __init__(self, root, master, debug_print_flag=False): self.master = master self.root = root ######################################################################### # Set up the constants and default values ######################################################################### self.xmin = -10 self.xmax = 10 self.ymin = -10 self.ymax = 10 self.input_weight = 1.0 self.input_weight_2 = 1.0 self.bias = 0.0 self.activation_type = "Symmetrical Hard Limit" self.input_values = np.random.uniform(-10, 10, size=(2, 4)) self.bias_input = np.ones(4) self.input_values = np.vstack((self.input_values, self.bias_input)) ######################################################################### # Set up the plotting frame and controls frame ######################################################################### master.rowconfigure(0, weight=10, minsize=200) master.columnconfigure(0, weight=1) self.plot_frame = tk.Frame(self.master, borderwidth=10, relief=tk.SUNKEN) self.plot_frame.grid(row=0, column=0, columnspan=1, sticky=tk.N + tk.E + tk.S + tk.W) w = self.plot_frame.winfo_screenwidth() h = self.plot_frame.winfo_screenheight() #self.figure = plt.figure(figsize=[w/100,h/100-2.2]) self.figure = plt.figure("") self.axes = self.figure.add_axes([0.15, 0.15, 0.6, 0.8]) # self.axes = self.figure.add_axes() self.axes = self.figure.gca() self.axes.set_xlabel('Input') self.axes.set_ylabel('Output') # self.axes.margins(0.5) self.axes.set_title("") plt.xlim(self.xmin, self.xmax) plt.ylim(self.ymin, self.ymax) self.canvas = FigureCanvasTkAgg(self.figure, master=self.plot_frame) self.plot_widget = self.canvas.get_tk_widget() self.plot_widget.grid(row=0, column=0, sticky=tk.N + tk.E + tk.S + tk.W) # Create a frame to contain all the controls such as sliders, buttons, ... self.controls_frame = tk.Frame(self.master) self.controls_frame.grid(row=1, column=0, sticky=tk.N + tk.E + tk.S + tk.W) self.plot_widget.pack(side=tk.TOP, fill=tk.BOTH, expand=1) ######################################################################### # Set up the control widgets such as sliders and selection boxes ######################################################################### self.input_weight_slider = tk.Scale( self.controls_frame, variable=tk.DoubleVar(), orient=tk.HORIZONTAL, from_=-10.0, to_=10.0, resolution=0.01, bg="#DDDDDD", activebackground="#FF0000", highlightcolor="#00FFFF", label="Input Weight", command=lambda event: self.input_weight_slider_callback()) self.input_weight_slider.set(self.input_weight) self.input_weight_slider.bind( "<ButtonRelease-1>", lambda event: self.input_weight_slider_callback()) self.input_weight_slider.grid(row=0, column=0, sticky=tk.N + tk.E + tk.S + tk.W) self.input_weight_2_slider = tk.Scale( self.controls_frame, variable=tk.DoubleVar(), orient=tk.HORIZONTAL, from_=-10.0, to_=10.0, resolution=0.01, bg="#DDDDDD", activebackground="#FF0000", highlightcolor="#00FFFF", label="Input Weight 2", command=lambda event: self.input_weight_2_slider_callback()) self.input_weight_2_slider.set(self.input_weight_2) self.input_weight_2_slider.bind( "<ButtonRelease-1>", lambda event: self.input_weight_2_slider_callback()) self.input_weight_2_slider.grid(row=0, column=1, sticky=tk.N + tk.E + tk.S + tk.W) self.bias_slider = tk.Scale( self.controls_frame, variable=tk.DoubleVar(), orient=tk.HORIZONTAL, from_=-10.0, to_=10.0, resolution=0.01, bg="#DDDDDD", activebackground="#FF0000", highlightcolor="#00FFFF", label="Bias", command=lambda event: self.bias_slider_callback()) self.bias_slider.set(self.bias) self.bias_slider.bind("<ButtonRelease-1>", lambda event: self.bias_slider_callback()) self.bias_slider.grid(row=0, column=2, sticky=tk.N + tk.E + tk.S + tk.W) self.adjust_weights_button = tk.Button( self.controls_frame, text="Learn (Adjust Weights)", fg="red", command=lambda: self.adjust_weights_button_callback()) self.create_random_data_button = tk.Button( self.controls_frame, text="Create Random Data", fg="red", command=lambda: self.create_random_data_button_callback()) self.adjust_weights_button.grid(row=0, column=3, sticky=tk.N + tk.E + tk.S + tk.W) self.create_random_data_button.grid(row=0, column=4, sticky=tk.N + tk.E + tk.S + tk.W) ######################################################################### # Set up the frame for drop down selection ######################################################################### self.label_for_activation_function = tk.Label( self.controls_frame, text="Activation Function Type:", justify="center") self.label_for_activation_function.grid(row=0, column=5, sticky=tk.N + tk.E + tk.S + tk.W) self.activation_function_variable = tk.StringVar() self.activation_function_dropdown = tk.OptionMenu( self.controls_frame, self.activation_function_variable, "Linear", "Hyperbolic Tangent", "Symmetrical Hard Limit", command=lambda event: self.activation_function_dropdown_callback()) self.activation_function_variable.set("Symmetrical Hard Limit") self.activation_function_dropdown.grid(row=0, column=6, sticky=tk.N + tk.E + tk.S + tk.W) self.canvas.get_tk_widget().bind("<ButtonPress-1>", self.left_mouse_click_callback) self.canvas.get_tk_widget().bind("<ButtonPress-1>", self.left_mouse_click_callback) self.canvas.get_tk_widget().bind("<ButtonRelease-1>", self.left_mouse_release_callback) self.canvas.get_tk_widget().bind("<B1-Motion>", self.left_mouse_down_motion_callback) self.canvas.get_tk_widget().bind("<ButtonPress-3>", self.right_mouse_click_callback) self.canvas.get_tk_widget().bind("<ButtonRelease-3>", self.right_mouse_release_callback) self.canvas.get_tk_widget().bind("<B3-Motion>", self.right_mouse_down_motion_callback) self.canvas.get_tk_widget().bind("<Key>", self.key_pressed_callback) self.canvas.get_tk_widget().bind("<Up>", self.up_arrow_pressed_callback) self.canvas.get_tk_widget().bind("<Down>", self.down_arrow_pressed_callback) self.canvas.get_tk_widget().bind("<Right>", self.right_arrow_pressed_callback) self.canvas.get_tk_widget().bind("<Left>", self.left_arrow_pressed_callback) self.canvas.get_tk_widget().bind("<Shift-Up>", self.shift_up_arrow_pressed_callback) self.canvas.get_tk_widget().bind( "<Shift-Down>", self.shift_down_arrow_pressed_callback) self.canvas.get_tk_widget().bind( "<Shift-Right>", self.shift_right_arrow_pressed_callback) self.canvas.get_tk_widget().bind( "<Shift-Left>", self.shift_left_arrow_pressed_callback) self.canvas.get_tk_widget().bind("f", self.f_key_pressed_callback) self.canvas.get_tk_widget().bind("b", self.b_key_pressed_callback) def key_pressed_callback(self, event): self.root.status_bar.set('%s', 'Key pressed') def up_arrow_pressed_callback(self, event): self.root.status_bar.set('%s', "Up arrow was pressed") def down_arrow_pressed_callback(self, event): self.root.status_bar.set('%s', "Down arrow was pressed") def right_arrow_pressed_callback(self, event): self.root.status_bar.set('%s', "Right arrow was pressed") def left_arrow_pressed_callback(self, event): self.root.status_bar.set('%s', "Left arrow was pressed") def shift_up_arrow_pressed_callback(self, event): self.root.status_bar.set('%s', "Shift up arrow was pressed") def shift_down_arrow_pressed_callback(self, event): self.root.status_bar.set('%s', "Shift down arrow was pressed") def shift_right_arrow_pressed_callback(self, event): self.root.status_bar.set('%s', "Shift right arrow was pressed") def shift_left_arrow_pressed_callback(self, event): self.root.status_bar.set('%s', "Shift left arrow was pressed") def f_key_pressed_callback(self, event): self.root.status_bar.set('%s', "f key was pressed") def b_key_pressed_callback(self, event): self.root.status_bar.set('%s', "b key was pressed") def left_mouse_click_callback(self, event): self.root.status_bar.set( '%s', 'Left mouse button was clicked. ' + 'x=' + str(event.x) + ' y=' + str(event.y)) self.x = event.x self.y = event.y self.canvas.focus_set() def left_mouse_release_callback(self, event): self.root.status_bar.set( '%s', 'Left mouse button was released. ' + 'x=' + str(event.x) + ' y=' + str(event.y)) self.x = None self.y = None def left_mouse_down_motion_callback(self, event): self.root.status_bar.set( '%s', 'Left mouse down motion. ' + 'x=' + str(event.x) + ' y=' + str(event.y)) self.x = event.x self.y = event.y def right_mouse_click_callback(self, event): self.root.status_bar.set( '%s', 'Right mouse down motion. ' + 'x=' + str(event.x) + ' y=' + str(event.y)) self.x = event.x self.y = event.y def right_mouse_release_callback(self, event): self.root.status_bar.set( '%s', 'Right mouse button was released. ' + 'x=' + str(event.x) + ' y=' + str(event.y)) self.x = None self.y = None def right_mouse_down_motion_callback(self, event): self.root.status_bar.set( '%s', 'Right mouse down motion. ' + 'x=' + str(event.x) + ' y=' + str(event.y)) self.x = event.x self.y = event.y def left_mouse_click_callback(self, event): self.root.status_bar.set( '%s', 'Left mouse button was clicked. ' + 'x=' + str(event.x) + ' y=' + str(event.y)) self.x = event.x self.y = event.y # self.focus_set() def display_activation_function(self): # #input_values = np.linspace(-10, 10, 256, endpoint=True) # input_values = np.random.uniform(-10, 10, size=(2, 4)) # #print(input_values) # bias_input = np.ones(4) # input_values = np.vstack((input_values, bias_input)) self.input_weight, self.input_weight_2, self.bias = Parikh_02_02.calculate_activation_function( self.input_weight, self.input_weight_2, self.bias, self.input_values, self.activation_type) self.axes.cla() self.axes.set_xlabel('Input') self.axes.set_ylabel('Output') # self.axes.plot(self.input_values[0], self.input_values[1], 'bo') self.axes.plot(self.input_values[0][0], self.input_values[1][0], 'bo') self.axes.plot(self.input_values[0][1], self.input_values[1][1], 'bo') self.axes.plot(self.input_values[0][2], self.input_values[1][2], 'yv') self.axes.plot(self.input_values[0][3], self.input_values[1][3], 'yv') resolution = 100 xs = np.linspace(-10., 10., resolution) ys = np.linspace(-10., 10., resolution) xx, yy = np.meshgrid(xs, ys) zz = self.input_weight * xx + self.input_weight_2 * yy + self.bias zz[zz < 0] = -1 zz[zz > 0] = +1 self.axes.pcolormesh(xs, ys, zz, cmap=matplotlib.colors.ListedColormap(['r', 'g'])) self.axes.xaxis.set_visible(True) plt.xlim(self.xmin, self.xmax) plt.ylim(self.ymin, self.ymax) plt.title(self.activation_type) self.canvas.draw() def input_weight_slider_callback(self): self.input_weight = np.float(self.input_weight_slider.get()) self.display_activation_function() def input_weight_2_slider_callback(self): self.input_weight_2 = np.float(self.input_weight_2_slider.get()) self.display_activation_function() def bias_slider_callback(self): self.bias = np.float(self.bias_slider.get()) self.display_activation_function() def activation_function_dropdown_callback(self): self.activation_type = self.activation_function_variable.get() self.display_activation_function() def adjust_weights_button_callback(self): self.display_activation_function() def create_random_data_button_callback(self): self.input_values = np.random.uniform(-10, 10, size=(2, 4)) self.bias_input = np.ones(4) self.input_values = np.vstack((self.input_values, self.bias_input)) self.display_activation_function()