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()
