def __init__(self, black_stone_img, white_stone_img): #初始化棋盘 self.chessboard = Chessboard() #初始化神经网络 #TODO:神经网络还要改 self.neural = Neural(19, 19) #初始化先手棋子 self.player = BLACK_PLAYER #黑白棋棋子图片 self.black_stone_img = black_stone_img self.white_stone_img = white_stone_img #初始化赢家 self.winner = None #初始化胜利后的标题 self.win_text_surface = None
def build_sigle_neural_output_layer(self): previous_layer_output = [] for neural in self.hidden_layers[self.hidden_layer_num - 1]: previous_layer_output.append(neural.Y) self.output_layer.append( Neural(0, previous_layer_output, self.learning_rate, True, self.D[0], None))
def __run_network_(self, thorough=False): try: score = Neural(self, thorough).run_network() except: return 0 return score
def __init__(self, black_stone_img, white_stone_img): self.chessboard = Chessboard() self.neural = Neural(19, 19) self.player = BLACK_PLAYER self.black_stone_img = black_stone_img self.white_stone_img = white_stone_img self.winner = None self.win_text_surface = None
def make_cubes(self): cubes = [] neural = [] for i in range(0, self.cube_number): cubes.append(Cube()) cubes[].read_cube("scrambled_cube1.txt") neural.append(Neural(cube[i].array(), i)) self.cube_array = cubes self.neural_array = neural
def training(training_set, training_time): a_list = [] neural_1 = Neural() for i in range(training_time): ri = numpy.random.randint(len(training_set)) a_train_set = training_set[ri] training_sub(a_train_set, neural_1) a_list.append(abs((neural_1.output / 1000000) - 1 - a_train_set[4])) sum = 0 for j in a_list: sum = sum + j avg = sum / len(a_list) print('avg_error = ' + str(avg)) return [neural_1, a_list]
def build_hidden_layer(self): next_layer = [] hidden_layer = [] previous_layer_output = self.X[0] for i in range(self.hidden_layer_num): current_layer_output = [] for j in range(self.hidden_layer_neural_num): hidden_layer.append( Neural(j, previous_layer_output, self.learning_rate, False, None, next_layer)) current_layer_output.append(hidden_layer[j].calculate_Y()) previous_layer_output = current_layer_output self.hidden_layers.append(hidden_layer) hidden_layer = next_layer next_layer = [] for neural in self.hidden_layers[self.hidden_layer_num - 1]: neural.next_layer = self.output_layer
# Main driver program import numpy as np from mnist_loader import load_data_wrapper from neural import Neural training_data, validation_data, test_data = load_data_wrapper() nn = Neural([784, 50, 10]) input = np.ones((784, 1)) nn.feedforward(input) nn.SGD(training_data, test_data, 3, 25, 50) import pdb pdb.set_trace()
def run(self): filename = self.file_path_label["text"] if (filename == ""): print("未選取檔案") tk.messagebox.showinfo("Error", "未選取資料集") return df = pd.read_table(filename, sep=" ", header=None) # 檢查是否二類問題 df_label = np.split(df, [len(df.columns) - 1], axis=1)[1] if (len(df_label.groupby(len(df.columns) - 1).groups) != 2): print("非二類問題") tk.messagebox.showinfo("Error", "資料集非二類問題") return # 非二類問題 # label非0/1組合 改變label-> 0~1 if (0 not in df_label.groupby(len(df.columns) - 1).groups) or ( 1 not in df_label.groupby(len(df.columns) - 1).groups): df[len(df.columns) - 1] = df[len(df.columns) - 1] % 2 # split traning data and testing data train_df = df.sample(frac=0.666666) test_df = df.drop(train_df.index) train_dfs = np.split(train_df, [len(train_df.columns) - 1], axis=1) train_X_df = train_dfs[0] train_y_df = train_dfs[1] train_X = train_X_df.values.tolist() train_y = train_y_df.values.reshape(-1, ).tolist() test_dfs = np.split(test_df, [len(test_df.columns) - 1], axis=1) test_X_df = test_dfs[0] test_y_df = test_dfs[1] test_X = test_X_df.values.tolist() test_y = test_y_df.values.reshape(-1, ).tolist() #learning_rate = 0.8 learning_rate = self.learning_rate.get() # run training and show result n = Neural(train_X, train_y, learning_rate) train_result_list = [] print("### training start ###") for i in range(int(self.epoch_spinbox.get())): self.training_epoch_text_label["text"] = i + 1 train_result = n.train() train_result_list.append(train_result) if train_result["acc"] > float(self.early_stop_spinbox.get()): break print("### training end ###") self.draw_training_acc_figure(train_result_list) self.training_acc_text_label["text"] = train_result_list[ len(train_result_list) - 1]["acc"] self.bias_text_label["text"] = train_result_list[len(train_result_list) - 1]["bias"] self.weight_text.delete(1.0, END) self.weight_text.insert( 1.0, train_result_list[len(train_result_list) - 1]["weight"]) # run testing and show result print("### predict start ###") test_result = n.test(test_X, test_y) print("### predict end ###") self.testing_acc_text_label["text"] = test_result["acc"] # draw training data and predict line self.draw_training_data_figure( df, test_df, train_result_list[len(train_result_list) - 1])
class GameFlow(object): """description of class""" def __init__(self, black_stone_img, white_stone_img): #初始化棋盘 self.chessboard = Chessboard() #初始化神经网络 #TODO:神经网络还要改 self.neural = Neural(19, 19) #初始化先手棋子 self.player = BLACK_PLAYER #黑白棋棋子图片 self.black_stone_img = black_stone_img self.white_stone_img = white_stone_img #初始化赢家 self.winner = None #初始化胜利后的标题 self.win_text_surface = None #重置 def reset(self): self.chessboard.reset() self.neural.reset() self.player = BLACK_PLAYER self.winner = None self.win_text_surface = None #换手 def _change_player(self): if self.player == BLACK_PLAYER: self.player = WHITE_PLAYER elif self.player == WHITE_PLAYER: self.player = BLACK_PLAYER else: assert (False) self.player = BLACK_PLAYER #获取当前执手玩家姓名 #TODO:当前用black和white代替 def get_player_name(self): if self.player == BLACK_PLAYER: return 'Black' elif self.player == WHITE_PLAYER: return 'White' else: return 'Unknown' #判断是否赢了 def _is_win(self, x, y): for dir in range(1, 5): if self.neural.get_connected_count(x, y, dir) >= 5: return True return False def update(self, pos): px, py = pos # update button if self.chessboard.in_range_reset_btn(px, py): # reset self.reset() return # update go if self.winner: return ix, iy = self.chessboard.get_stone_index(px, py) if ix is None or iy is None: return if self.neural.set_value(ix, iy, self.player): if self._is_win(ix, iy): self.winner = self.player msg = u'%s is winner!' % self.get_player_name() self.win_text_surface = self.chessboard.font.render( msg, True, (0, 0, 0), (255, 255, 255)) self._change_player() def play_move(self, ix, iy): if ix is None or iy is None: return if self.neural.set_value(ix, iy, self.player): if self._is_win(ix, iy): self.winner = self.player msg = u'%s is winner!' % self.get_player_name() self.win_text_surface = self.chessboard.font.render( msg, True, (0, 0, 0), (255, 255, 255)) self._change_player() #获取当前执手方图片 def _get_img(self, player): if player == BLACK_PLAYER: return self.black_stone_img elif player == WHITE_PLAYER: return self.white_stone_img else: assert (False) return None #当前鼠标控制方图片 def get_mouse_cursor(self): return self._get_img(self.player) #在棋盘上画上棋子 def draw(self, screen): for w in range(self.neural.width): for h in range(self.neural.height): value = self.neural.get_value(w, h) if not value: continue play_img = self._get_img(value) x, y = self.chessboard.get_pos(w, h) if x is None or y is None: continue x -= play_img.get_width() / 2 y -= play_img.get_height() / 2 #计算光标的左上角位置 screen.blit(play_img, (x, y)) #每次都需要重新绘制reset按钮 self.chessboard.draw(screen)
from neural import Neural from sklearn.datasets import load_iris net = Neural() data = load_iris() x, y = data.data, data.target net.setparam(n_input=4, n_hidden=41, n_output=1, lr=0.000001) net.init_weight() net.train(x, y.reshape(y.shape[0], 1), 20000) net.accuracy()
parser.add_argument('-l', '--logfile', action='store', help="save stats to file") parser.add_argument('-w', '--wristband', action='store_true', help="enable bluetooth wristband") args = parser.parse_args() if args.wristband: wrist = Wristband() wrist.start() if args.camera: neural = Neural(parameters) camera = Camera(parameters, neural) camera.start() print("* Camera loop started") _socketHandler = (r"/websocket", SocketHandler, {'camera': camera}) _statusHandler = (r"/status", StatusHandler, { 'io': hardware, 'wristband': wrist }) _staticHandler = (r"/(.*)", tornado.web.StaticFileHandler, { 'path': os.path.dirname(os.path.realpath(__file__)) + '/web/', 'default_filename': 'index.html' })
for i in range(1, len(args)): if (args[i] == param): argValue = args[i + 1] if (argValue == False): raise Exception("Param " + str(param) + " couldn't be found") return argValue except Exception as e: print( "Exec format: python main.py [args] | python main.py -h for help.\nError: " + str(e)) exit() dbName = getArgs(sys.argv, '-i') neural = Neural(dbName) # print(neural.inputs) # print(neural.outputs) ages = 200 # Learning rate lr = 0.1 neural.trainning(ages, lr) neural.testDatabase('database/test/dificil_teste.csv') # print(neural.inputsTest) neural.compareTest() # neural.plot_all() # neural.plot_all() # print('weights: ' + str(neural.weights)) # print('bias: ' + str(neural.bias)) # rights, wrongs = compare(inputs, outputs, weights, bias)
import os from flask import Flask, request, redirect, url_for, flash, render_template, send_from_directory from werkzeug.utils import secure_filename #from classification import neural from imageProces import * from neural import Neural from regresion import Regresion #Directory folder temp UPLOAD_FOLDER = '/home/adhan/Projek/sisdas-API/backend/temp' ALLOWED_EXTENSIONS = set(['png', 'jpg', 'jpeg']) app = Flask(__name__) app.config['UPLOAD_FOLDER'] = UPLOAD_FOLDER neural = Neural() regresion = Regresion() def allowed_file(filename): return '.' in filename and \ filename.rsplit('.', 1)[1].lower() in ALLOWED_EXTENSIONS @app.route('/', methods=['GET', 'POST']) def upload_file(): if request.method == 'POST': # check if the post request has the file part if 'file' not in request.files: flash('No file part') return redirect(request.url)
def __init__(self): self.image = None self.state = 1 self.neural = Neural()
# Main driver program import numpy as np from mnist_loader import load_data_wrapper from neural import Neural training_data, validation_data, test_data = load_data_wrapper() nn = Neural([784, 50, 10]) input = np.ones((784, 1)) nn.feedforward(input) nn.SGD(training_data, test_data, 3, 25, 50) import pdb; pdb.set_trace()
SPEED = 0.01 DROP_INPUT = 0.2 DROP_HIDDEN = 0.6 PRINT_FROM = 10 PRINT_TO = 50 STEP_SHOW = 3 RHO = 0.9 EPSILON = 1e-4 STEP = 50 print "test" trX, teX = load.loadMel("afterLDA100.db") # trY, teY = load.loadRes() trZ, teZ = load.loadLeter() print "loaded" neur = Neural() # neur.load_from_file(WEIGHTS_FILE) neur.init_model(ARR_SHAPE) neur.train(trX, teX, trZ, teZ, epochs=TIMES) neur.save_to_file(WEIGHTS_FILE) # trT = neur.result(trX) # teT = neur.result(teX) # print "start train" # neur2 = Neural() # neur2.init_model([(55, 300), (300, 28)]) # neur2.train(trT, teT, trZ, teZ, epochs=TIMES) # neur = Neural()
[21.4, 16.8, 0, 21.3, -0.131]] def training_ann(training_set, my_neural): my_neural.set_i1(training_set[0]) my_neural.set_i2(training_set[1]) my_neural.set_i3(training_set[2]) my_neural.set_i4(training_set[3]) my_neural.set_target((training_set[4] + 1) * 100000) my_neural.learn_w1() my_neural.learn_w2() my_neural.learn_w3() my_neural.learn_w4() my_neural.learn_b() return my_neural a_list = [] neural_1 = Neural() for i in range(50000): ri = numpy.random.randint(len(my_trainset)) train_set = my_trainset[ri] training_ann(train_set, neural_1) print(neural_1.output / 100000) a_list.append(abs(neural_1.output / 100000 - (train_set[4] + 1))) sum = 0 for j in a_list: sum = sum + j avg = sum / len(a_list) print(avg)
class GUI: top = Tk() selected_file_path = NONE select_file_label_textvariable = IntVar() splitdata_spinbox_textvariable = IntVar() optimalizers_str_var = StringVar() padding_val = 7 input_columns = IntVar() output_columns = IntVar() verbose = BooleanVar() shuffle_data = BooleanVar() epochs = IntVar() validate = BooleanVar() plot = BooleanVar() mu = StringVar() mu_update = StringVar() test_string = StringVar() file_info = StringVar() optimalizers = ['LevenbergMarquardt', 'GradientDescent', 'Adam', 'QuasiNewton', 'Quickprop', 'MinibatchGradientDescent', 'ConjugateGradient', 'Hessian', 'HessianDiagonal', 'Momentum', 'RPROP', 'IRPROPPlus', 'Adadelta', 'Adagrad', 'RMSProp', 'Adamax'] activation_function_list = ('Linear', 'Sigmoid', 'HardSigmoid', 'Step', 'Tanh', 'Relu', 'Softplus', 'Softmax', 'Elu', 'PRelu', 'LeakyRelu') layers_count = 0 layers_continous_count = 0 raw_model = [] network_frame = None layers_frame = None optimalizers_combobox = None optimalizer_opt_frame = None neural = Neural() def __init__(self): self.test_entry = None self.select_file_label_textvariable.set("Nie wybrano pliku") self.selected_optimalizer = self.optimalizers[0] self.input_columns.set(4) self.output_columns.set(1) self.verbose.set(1) self.shuffle_data.set(1) self.epochs.set(0) self.validate.set(1) self.plot.set(0) self.test_string.set('') self.mu.set(0.1) self.mu_update.set(1.2) self.file_info.set('Brak informacji o pliku') def add_layer_callback(self): layer_frame = LabelFrame(self.layers_frame.interior, relief=FLAT) layer_frame.pack(fill="both", expand="no", side=TOP) Label(layer_frame, text='Ilość neuronów: ').pack(side=LEFT) neuron_count_var = IntVar() neuron_count_spinbox = Spinbox(layer_frame, from_=1, to=10000, width=6, textvariable=neuron_count_var) neuron_count_spinbox.pack(side=LEFT, pady=self.padding_val, padx=self.padding_val) neuron_count_var.set(self.output_columns.get()) activation_fuction = StringVar() activation_function_combobox = ttk.Combobox(layer_frame, values=self.activation_function_list, textvariable=activation_fuction, state="readonly", width=12) activation_fuction.set(self.activation_function_list[0]) activation_function_combobox.pack(pady=self.padding_val, padx=self.padding_val, side=LEFT) index = self.layers_continous_count Button(layer_frame, text="Usuń warstwę", command=lambda: remove_layer(index)).pack(side=LEFT, pady=self.padding_val, padx=self.padding_val) neuron_count_var.set(self.validate_val(self.output_columns.get(), 1, 10000, neuron_count_var)[0]) layer_data = [self.layers_continous_count, neuron_count_var, activation_fuction] self.raw_model.append(layer_data) self.layers_continous_count += 1 self.layers_count += 1 def remove_layer(layer_id): ind = 0 for layer in self.raw_model: if int(layer[0]) == int(layer_id): print("USUWAM index:{0} ID={1}, Neurons={2}, Activation={3}".format(str(ind), str(layer[0]), str(layer[1]), str(layer[2].get()))) self.raw_model.pop(ind) layer_frame.destroy() self.layers_count -= 1 break else: ind += 1 print('Warstwy: ' + str(self.layers_count)) def selectFileCallback(self): self.selected_file_path = filedialog.askopenfilename(title='Wybierz plik z danymi', filetypes=[("All files", "*.dat"), ("All files", "*.csv")]) if self.selected_file_path: msg_box.showinfo("Informacja", "Otwarto plik: " + self.selected_file_path) self.neural.labels = [] file_name_tokens = self.selected_file_path.split("/") rel_file_name = file_name_tokens[len(file_name_tokens) - 1] self.select_file_label_textvariable.set("Wybrano: " + rel_file_name) print("Wybrano plik: " + rel_file_name) self.neural.read_file(path=self.selected_file_path) self.file_info.set( 'Załadowano rekordów: ' + str(len(self.neural.df)) + ', kolumn: ' + str(len(self.neural.df.columns))) self.input_columns.set(len(self.neural.df.columns) - 1) def optimalizer_callback(self): self.selected_optimalizer = self.optimalizers_combobox.get() if self.selected_optimalizer == 'LevenbergMarquardt': self.optimalizer_opt_frame.pack(side=TOP, pady=self.padding_val, padx=self.padding_val) else: self.optimalizer_opt_frame.pack_forget() print("Optymalizer: " + self.selected_optimalizer) def reset_layer_callback(self): self.layers_count = 0 for widget in self.layers_frame.interior.winfo_children(): widget.destroy() self.raw_model.clear() msg_box.showinfo("Informacja", "Zresetowano model sieci") def start_learn_callback(self): if self.neural.is_file_loaded(): result = self.validate_val(default=80, min_=1, max_=100, var=self.splitdata_spinbox_textvariable) if result[1]: # invalid value msg_box.showinfo("Informacja", "Niewłaściwa wartość podziału danych, ustawiam: " + str(result[0])) self.epochs.set(result[0]) result = self.validate_val(default=10, min_=1, max_=100000, var=self.epochs) if result[1]: # invalid value msg_box.showinfo("Informacja", "Niewłaściwa wartość liczby epok, ustawiam: " + str(result[0])) self.epochs.set(result[0]) result = self.is_digit(self.mu.get()) if not result: msg_box.showinfo("Informacja", "Niewłaściwa wartość współczynnika µ, przerywam i ustawiam: 0.1") self.mu.set("0.1") return result = self.is_digit(self.mu_update.get()) if not result: msg_box.showinfo("Informacja", "Niewłaściwa wartość współczynnika β, przerywam i ustawiam: 1.2") self.mu_update.set("1.2") return self.neural.set_columns_split(self.input_columns.get(), self.output_columns.get()) print(str("Inputs: " + str(self.input_columns.get()) + ", Outputs: " + str(self.output_columns.get()))) try: self.neural.prepare_data(verbose=False) except IOError: msg_box.showerror("Informacja", "Nie wybrano pliku z danymi") return self.neural.split_data(self.splitdata_spinbox_textvariable.get()) try: options_ = [float(self.mu.get()), float(self.mu_update.get())] self.neural.model_network(algorithm=self.selected_optimalizer, model=self.raw_model, opt=options_) except ValueError: msg_box.showerror(title="Błąd", message="Nie udało się nauczyć sieci!") return try: self.neural.train_network(verbose=True, shuffle=self.shuffle_data.get(), validate=self.validate.get(), epo=self.epochs.get()) except ValueError as e: msg_box.showerror("Błąd uczenia sieci", "Przerwano uczenie sieci" + str(e)) return if self.plot.get(): try: self.neural.show_plow() except AttributeError: msg_box.showerror("Błąd", "Nie udało się zaprezentowac wykresu precesu uczenia ") if self.verbose.get(): top = Toplevel() def callback(): top.destroy() close_window = Button(top, text="Zamknij okno", command=callback) close_window.pack(side=BOTTOM, pady=self.padding_val, padx=self.padding_val) top.protocol("WM_DELETE_WINDOW", callback) var = StringVar() Label(top, textvariable=var, relief=FLAT).pack(side=TOP) var.set("Wynik uczenia sieci:") text = Text(top) text.pack(side=TOP, pady=self.padding_val, padx=self.padding_val, fill="both", expand="no") text.insert(END, 'Plik: ' + str(self.selected_file_path) + '\n') text.insert(END, 'Załadowano rekordów: ' + str(len(self.neural.df)) + ', kolumn: ' + str( len(self.neural.df.columns)) + '\n') text.insert(END, str("Wejścia: " + str(self.input_columns.get()) + ", Wyjścia: " + str( self.output_columns.get())) + '\n') text.insert(END, 'Model warstw: ' + str(self.neural.layers) + '\n') text.insert(END, 'Liczba epok: ' + str(self.epochs.get()) + '\n') text.insert(END, 'Algorytm: ' + str(self.selected_optimalizer) + '\n\n') text.insert(END, 'Proces uczenia:\n') try: for epoch in range(self.neural.network.last_epoch): if self.validate.get(): text.insert(END, 'Epoka:{:>5}, błąd uczenia:{:>11}, błąd walidacji: {:>11} \n'.format(epoch + 1, "%.5f" % self.neural.network.errors[epoch], "%.5f" % self.neural.network.validation_errors[epoch])) else: text.insert(END, 'Epoka {:>5}, błąd uczenia: {:>11},\n'.format(epoch + 1, "%.5f" % self.neural.network.errors[epoch])) except Exception: msg_box.showerror("Błąd", "Błąd przy logowaniu danych uczenia sieci") top.minsize(500, 400) top.title = 'Wyniki uczenia sieci' top.mainloop() else: msg_box.showinfo("Informacja", "Zakończono uczenie sieci !") print("Nauczono sieć") else: msg_box.showinfo("Informacja", "Nie załadowano pliku!") def start_classification_callback(self): if self.neural.network is not None: data = self.test_string.get() data_list = [] predicted_val = None test_val = self.neural.output_test stacked = [] if data != '': print("a: " + data) try: data_list = self.csv_line_to_list(data) except IndexError: msg_box.showerror("Błąd dekompozycji danych", "Niepoprawne dane") return print("b: " + str(data_list)) input_selected = np.array([data_list]) # input_selected = data_list else: input_selected = self.neural.input_test try: predicted_val = self.neural.predict(data=input_selected) # stacked = np.hstack((test_val, np.asarray(predicted_val))) except Exception: msg_box.showerror("Błąd podczas klasyfikacji danych", "Niepoprawne dane wejściowe") return print("Zakończono klasyfikację") top = Toplevel() def callback(): top.destroy() close_window = Button(top, text="Zamknij okno", command=callback) close_window.pack(side=BOTTOM, pady=self.padding_val, padx=self.padding_val) top.protocol("WM_DELETE_WINDOW", callback) var = StringVar() Label(top, textvariable=var, relief=FLAT).pack(side=TOP) text = Text(top) text.pack(side=TOP, pady=self.padding_val, padx=self.padding_val, fill="both", expand="yes") text.tag_configure('good', background='green') text.tag_configure('bad', background='red') labels = self.neural.labels for lab in labels[-1]: text.insert(END, ' {:>12},'.format(str(lab))) text.insert(END, ' Klasa wyjściowa\n') element_index = 0 well_classed = 0 for element in predicted_val: var.set("Wynik klasyfikacji dla danych testowych") label_predicted = 'Błąd' label_real = 'Błąd' if data == '': test_hightest_index = 0 predicted_hightest_index = 0 for i in range(len(test_val[element_index])): if test_val[element_index][i] > test_hightest_index: test_hightest_index = i for index in range(len(predicted_val[element_index])): if predicted_val[element_index][index] >= predicted_val[element_index][predicted_hightest_index]: predicted_hightest_index = index for name, dict_ in labels[-1].items(): if predicted_hightest_index + 1 == dict_: label_predicted = name for name, dict_ in labels[-1].items(): if test_hightest_index + 1 == dict_: label_real = name color = 'bad' if predicted_hightest_index == test_hightest_index: color = 'good' well_classed += 1 for list_element in range(len(element)): text.insert(END, ' {:>12},'.format("%.3f" % element[list_element]), color) text.insert(END, ' Sklasyfikowano jako: {:>12}, wartość rzecz. {:>12} \n' .format(str(label_predicted), str(label_real)), color) element_index += 1 else: var.set("Wynik klasyfikacji dla zadanej próbki" + str(data)) print(predicted_val[0]) for list_element in range(len(predicted_val[0])): text.insert(END, ' {:>12},'.format("%.5f" % predicted_val[0][list_element])) predicted_hightest_index = 0 for index in range(len(predicted_val[0])): if predicted_val[0][index] >= predicted_val[0][predicted_hightest_index]: predicted_hightest_index = index for name, dict_ in labels[-1].items(): if predicted_hightest_index + 1 == dict_: label_predicted = name text.insert(END, ' Sklasyfikowano jako: {:>12}\n'.format(str(label_predicted))) if len(predicted_val) > 1: percent = (well_classed / len(predicted_val)) * 100 Label(top, text="Poprawnie klasyfikowano {} ({}%) z {} ".format(str(well_classed), str("%.2f" % percent), str(len(predicted_val))), relief=FLAT).pack(side=RIGHT) top.minsize(800, 600) top.title = 'Wyniki klasyfikacji' top.mainloop() else: msg_box.showerror("Błąd", "Nie nauczono sieci!") def csv_line_to_list(self, line): try: from StringIO import StringIO except ImportError: from io import StringIO output = [] f = StringIO(line) reader = csv.reader(f, delimiter=',', skipinitialspace=True) for idy, row in enumerate(reader): labels = self.neural.labels converted = [] for idx, val in enumerate(row): if labels[idx] is not None: for name, dict_ in labels[idx].items(): if str(name) == val: converted.append(dict_) break else: converted.append(val) output = list(converted) return output def update_input_spinbox(self): if self.neural.is_file_loaded(): if self.input_columns.get() == len(self.neural.df.columns): self.input_columns.set(len(self.neural.df.columns) - 1) def is_digit(self, x): try: float(x) return True except ValueError: return False def validate_val(self, default, min_, max_, var): # return false if ALL OKAY try: var = var.get() if self.is_digit(var): if (var < min_) or (var > max_): print('Wartość poza zakresem') var.set(default) return [var, True] else: return [var, False] else: print('Wartość nie jest cyfrą, zwracam: ' + default.__str__()) var.set(default) return [var, True] except Exception: try: var = default print('Wyjątek niewłaściwa wartość, zwracam: ' + default.__str__()) var.set(default) return [var, True] except AttributeError: print('Wyjątek niewłaściwa wartość, zwracam: ' + var.__str__()) return [var, True] def create_gui(self): data_frame = LabelFrame(self.top, text="Wybór danych") data_frame.pack(fill="both", expand="no", pady=self.padding_val, padx=self.padding_val) select_file_btn = Button(data_frame, text="Wybierz plik", command=self.selectFileCallback) select_file_btn.pack(side=LEFT, pady=self.padding_val, padx=self.padding_val) Label(data_frame, textvariable=self.select_file_label_textvariable, relief=FLAT).pack( side=LEFT, pady=self.padding_val, padx=self.padding_val) splitdata_spinbox = Spinbox(data_frame, from_=0, to=100, width=4, textvariable=self.splitdata_spinbox_textvariable) splitdata_spinbox.pack(side=RIGHT, pady=self.padding_val, padx=self.padding_val) self.splitdata_spinbox_textvariable.set("80") Label(data_frame, text='Procent danych uczących', relief=FLAT).pack(side=RIGHT) Label(data_frame, text="Ilość wejść", relief=FLAT).pack(side=BOTTOM) input_columns_spinbox = Spinbox(data_frame, from_=1, to=10000, width=10, textvariable=self.input_columns, state='readonly', command=self.update_input_spinbox) input_columns_spinbox.pack(side=BOTTOM, pady=self.padding_val, padx=self.padding_val) Label(data_frame, textvariable=self.file_info, relief=FLAT).pack(side=TOP) # === MODEL FRAME === model_frame = LabelFrame(self.top, text="Modelowanie sieci") model_frame.pack(fill="both", expand="no", pady=self.padding_val, padx=self.padding_val) optimalizer_frame = LabelFrame(model_frame, text="Wybór optymalizatora") optimalizer_frame.pack(expand="no", fill='y', pady=self.padding_val, padx=self.padding_val, side=LEFT) # optimalizer_frame.place(relwidth = 0.5) self.optimalizers_combobox = ttk.Combobox(optimalizer_frame, values=self.optimalizers, textvariable=self.optimalizers_str_var, state="readonly") self.optimalizers_str_var.set(self.optimalizers[0]) self.optimalizers_combobox.pack(pady=self.padding_val, padx=self.padding_val) self.optimalizers_combobox.bind("<<ComboboxSelected>>", lambda x: self.optimalizer_callback()) self.optimalizer_opt_frame = LabelFrame(optimalizer_frame) self.optimalizer_opt_frame.pack(expand="yes", fill='both', pady=self.padding_val, padx=self.padding_val, side=LEFT) Label(self.optimalizer_opt_frame, text="Czynnik - µ", relief=FLAT).pack(side=TOP) mu_entry = ttk.Entry(self.optimalizer_opt_frame, textvariable=self.mu) mu_entry.pack(side=TOP, pady=self.padding_val, padx=self.padding_val) Label(self.optimalizer_opt_frame, text="Czynnik regularyzacyjny - β", relief=FLAT).pack(side=TOP) mu_update_entry = ttk.Entry(self.optimalizer_opt_frame, textvariable=self.mu_update) mu_update_entry.pack(side=TOP, pady=self.padding_val, padx=self.padding_val) options_frame = LabelFrame(model_frame, text="Opcje uczenia") options_frame.pack(expand="no", fill='y', pady=self.padding_val, padx=self.padding_val, side=LEFT) Label(options_frame, text="Liczba epok:", relief=FLAT).pack() self.epochs.set(10) Spinbox(options_frame, from_=1, to=10000, width=6, textvariable=self.epochs).pack( pady=self.padding_val, padx=self.padding_val) shuffle_data_checkbox = Checkbutton(options_frame, text="Mieszanie danych", variable=self.shuffle_data, onvalue=1, offvalue=0) shuffle_data_checkbox.pack(pady=self.padding_val, padx=self.padding_val) Checkbutton(options_frame, text="Pokaż szczegóły", variable=self.verbose, onvalue=1, offvalue=0).pack(pady=self.padding_val, padx=self.padding_val) # === Network FRAME === self.network_frame = LabelFrame(model_frame, text="Sieć") self.network_frame.pack(fill="both", expand="no", pady=self.padding_val, padx=self.padding_val, side=TOP) self.layers_frame = VerticalScrolledFrame(self.network_frame, relief=FLAT) # warstwy self.layers_frame.pack(fill="both", expand="no", side=TOP) reset_layer_button = Button(self.network_frame, text="Resetuj sieć", command=self.reset_layer_callback) reset_layer_button.pack(side=RIGHT, pady=self.padding_val, padx=self.padding_val) add_layer_button = Button(self.network_frame, text="Dodaj warstwę sieci", command=self.add_layer_callback) add_layer_button.pack(side=RIGHT, pady=self.padding_val, padx=self.padding_val) # === Simulation FRAME === simulation_frame = LabelFrame(self.top, text="Uczenie sieci") simulation_frame.pack(fill="both", expand="no", pady=self.padding_val, padx=self.padding_val) Checkbutton(simulation_frame, text="Ucz. z danymi walidującymi", variable=self.validate, onvalue=1, offvalue=0).pack(pady=self.padding_val, padx=self.padding_val, side=LEFT) Checkbutton(simulation_frame, text="Pokaż wykres [OSTROŻNIE!!!]", variable=self.plot, onvalue=1, offvalue=0).pack(pady=self.padding_val, padx=self.padding_val, side=LEFT) start_learn_button = Button(simulation_frame, text="Rozpocznij uczenie sieci", command=self.start_learn_callback) start_learn_button.pack(side=RIGHT, pady=self.padding_val, padx=self.padding_val) # === test FRAME === test_frame = LabelFrame(self.top, text="Testowanie sieci") test_frame.pack(fill="both", expand="no", pady=self.padding_val, padx=self.padding_val) # L1 = Label(test_frame, text="hjkhjk").pack() Label(test_frame, text="Podaj dane do klasyfikacji", relief=FLAT).pack(side=LEFT) self.test_entry = ttk.Entry(test_frame, textvariable=self.test_string).pack(side=LEFT) start_test_button = Button(test_frame, text="Rozpocznij klasyfikację", command=self.start_classification_callback) start_test_button.pack(side=LEFT, pady=self.padding_val, padx=self.padding_val) def start_gui(self): self.add_layer_callback() self.top.title("Klasyfikator") self.top.minsize(950, 600) self.top.maxsize(800, 400) self.top.mainloop()
class Ui_MainWindow(object): def __init__(self): self.image = None self.state = 1 self.neural = Neural() def setupUi(self, MainWindow): MainWindow.setObjectName("MainWindow") MainWindow.resize(640, 480) self.centralwidget = QtWidgets.QWidget(MainWindow) self.centralwidget.setObjectName("centralwidget") self.pushButton = QtWidgets.QPushButton(self.centralwidget) self.pushButton.setGeometry(QtCore.QRect(24, 380, 81, 31)) self.pushButton.setMouseTracking(False) self.pushButton.setObjectName("pushButton") self.frame = QtWidgets.QFrame(self.centralwidget) self.frame.setGeometry(QtCore.QRect(20, 10, 471, 361)) self.frame.setFrameShape(QtWidgets.QFrame.StyledPanel) self.frame.setFrameShadow(QtWidgets.QFrame.Raised) self.frame.setObjectName("frame") self.graphicsView = QtWidgets.QGraphicsView(self.frame) self.graphicsView.setGeometry(QtCore.QRect(10, 10, 451, 341)) self.graphicsView.setObjectName("graphicsView") self.textEdit = QtWidgets.QTextEdit(self.centralwidget) self.textEdit.setGeometry(QtCore.QRect(220, 380, 161, 31)) self.textEdit.setObjectName("textEdit") # print(dir(self.textEdit)) self.pushButton_3 = QtWidgets.QPushButton(self.centralwidget) self.pushButton_3.setGeometry(QtCore.QRect(390, 380, 91, 31)) self.pushButton_3.setObjectName("pushButton_3") self.pushButton.clicked.connect(self.actualizar) self.pushButton_3.clicked.connect(self.save_person) MainWindow.setCentralWidget(self.centralwidget) self.menubar = QtWidgets.QMenuBar(MainWindow) self.menubar.setGeometry(QtCore.QRect(0, 0, 643, 20)) self.menubar.setObjectName("menubar") MainWindow.setMenuBar(self.menubar) self.statusbar = QtWidgets.QStatusBar(MainWindow) self.statusbar.setObjectName("statusbar") MainWindow.setStatusBar(self.statusbar) self.retranslateUi(MainWindow) QtCore.QMetaObject.connectSlotsByName(MainWindow) def retranslateUi(self, MainWindow): _translate = QtCore.QCoreApplication.translate MainWindow.setWindowTitle(_translate("MainWindow", "FaceDetector")) self.pushButton.setText(_translate("MainWindow", "Detener")) self.textEdit.setPlaceholderText( _translate("MainWindow", "Ingrese el nombre")) self.pushButton_3.setText(_translate("MainWindow", "Guardar")) def actualizar(self): self.state = not (self.state) name = "Detener" if (self.state) else "Iniciar" _translate = QtCore.QCoreApplication.translate self.pushButton.setText(_translate("MainWindow", name)) print("cambiando estado: " + str(self.state)) QtCore.QMetaObject.connectSlotsByName(MainWindow) def run_neural(self): while (True): if (self.state): try: frame = self.neural.neural_detector() cv2.imshow('Video', frame[0]) if cv2.waitKey(1) & 0xFF == ord('q'): break except IndexError as identifier: print('an error ocurred', identifier) # Release handle to the webcam self.neural.videoCapture.release() cv2.destroyAllWindows() def save_person(self): self.name = self.textEdit.toPlainText() self.frame = self.neural.frame hilo2 = threading.Thread(target=self.runRecognition) hilo2.daemon = True hilo2.start() def runRecognition(self): self.neural.neural_recognition(self.name, self.frame)
def test_neural_dcost_db(self): test_neural = Neural() test_neural.set_w1(2) test_neural.set_w2(3) test_neural.set_w3(4) test_neural.set_w4(5) test_neural.set_b(10) test_neural.set_i1(2) test_neural.set_i2(3) test_neural.set_i3(4) test_neural.set_i4(5) test_neural.set_target(100) result = -72 self.assertEqual(test_neural.dcost_db(), result)
def main(): input = [(1, 2), (-1, 1)] output = [(0.3, 0.6), (0.6, 0.8)] n = Neural((1, 2), (3, 5), 2, 1, 3, 2) print("w_h:", n.w_h) print("w_o:", n.w_o) for i in range(10): # print("*****"+str(i)+"*****") n.forword() n.errorFunc() n.sigma() n.updateWeight() print("ERR:", n.errorFunc()) if (n.errorFunc() < 8.455): print("iteration " + str(i) + " times") break print("updated w_h", n.w_h) print("updated w_o", n.w_o) # print ("updated w_ih",n.w_ih) # print ("updated w_h",n.w_h) # print ("updated w_ho",n.w_ho) # print ("updated w_o",n.w_o) print("output", n.output)
def test_neural_learn_b(self): test_neural = Neural() test_neural.set_w1(2) test_neural.set_w2(3) test_neural.set_w3(4) test_neural.set_w4(5) test_neural.set_b(10) test_neural.set_i1(2) test_neural.set_i2(3) test_neural.set_i3(4) test_neural.set_i4(5) test_neural.set_target(100) result = 10.00072 self.assertEqual(test_neural.learn_b(), result)
class GameFlow(object): """description of class""" def __init__(self, black_stone_img, white_stone_img): self.chessboard = Chessboard() self.neural = Neural(19, 19) self.player = BLACK_PLAYER self.black_stone_img = black_stone_img self.white_stone_img = white_stone_img self.winner = None self.win_text_surface = None def reset(self): self.chessboard.reset() self.neural.reset() self.player = BLACK_PLAYER self.winner = None self.win_text_surface = None def _change_player(self): if self.player == BLACK_PLAYER: self.player = WHITE_PLAYER elif self.player == WHITE_PLAYER: self.player = BLACK_PLAYER else: assert(false) self.player = BLACK_PLAYER def get_player_name(self): if self.player == BLACK_PLAYER: return 'Black' elif self.player == WHITE_PLAYER: return 'White' else: return 'Unknown' def _is_win(self, x, y): for dir in range(1,5): if self.neural.get_connected_count(x,y,dir) >= 5: return True return False def update(self, pos): px, py = pos # update button if self.chessboard.in_range_reset_btn(px, py): # reset self.reset() return # update go if self.winner: return ix, iy = self.chessboard.get_stone_index(px, py) if ix is None or iy is None: return if self.neural.set_value(ix, iy, self.player): if self._is_win(ix, iy): self.winner = self.player msg = u'%s is winner!' % self.get_player_name() self.win_text_surface = self.chessboard.font.render(msg, True, (0,0,0), (255, 255, 255)) self._change_player() def _get_img(self, player): if player == BLACK_PLAYER: return self.black_stone_img elif player == WHITE_PLAYER: return self.white_stone_img else: assert(False) return None def get_mouse_cursor(self): return self._get_img(self.player) def draw(self, screen): for w in range(self.neural.width): for h in range(self.neural.height): value = self.neural.get_value(w,h) if not value: continue play_img = self._get_img(value) x, y = self.chessboard.get_pos(w,h) if x is None or y is None: continue x-= play_img.get_width() / 2 y-= play_img.get_height() / 2 #计算光标的左上角位置 screen.blit(play_img, (x, y)) self.chessboard.draw(screen)
def test_neural_cal_new_i(self): test_neural = Neural() test_neural.set_w1(2) test_neural.set_w2(3) test_neural.set_w3(4) test_neural.set_w4(5) test_neural.set_b(10) test_neural.set_i1(2) test_neural.set_i2(3) test_neural.set_i3(4) test_neural.set_i4(5) result = 64 self.assertEqual(test_neural.cal_new_i(), result)
from neural import Neural from sklearn.datasets import load_iris import numpy as np import matplotlib.pyplot as plt import sys server = None net = Neural() x = np.linspace(0, 4, 1000) y = np.sin(x) x_test = np.linspace(4, 8, 100) x_test = y.reshape(y.shape[0], 1) x = y.reshape(y.shape[0], 1) y = x.reshape(x.shape[0], 1) net.setparam(n_input=1, n_hidden=10, n_output=1, lr=0.00001) net.init_weight() net.train(x, y, 200) net.accuracy() cmd = sys.argv[1:] if cmd: if cmd[0] == 'server' or 'serve': plt.plot(y) plt.plot([net.predict(i) for i in x_test])
def test_neural_cal_cost(self): test_neural = Neural() test_neural.set_w1(2) test_neural.set_w2(3) test_neural.set_w3(4) test_neural.set_w4(5) test_neural.set_b(10) test_neural.set_i1(2) test_neural.set_i2(3) test_neural.set_i3(4) test_neural.set_i4(5) test_neural.set_target(100) result = 1296 self.assertEqual(test_neural.cal_cost(), result)