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)
