Esempio n. 1
0
class PingPong:
    __game = False
    i1 = 0
    i2 = 0
    __x = 0.0
    __y = 0.0
    __w = 0.0
    __h = 0.0
    __ball = None
    __gamer1 = None
    __gamer2 = None
    NNCTR = None
    gui = None
    game_gui = None
    win = None
    space = None
    inp = None
    outp = None
    network = None
    test = None
    pp_settings = None

    def __init__(self, x=0.0, y=0.0, w=480, h=768, ball=None, gamer1=None, gamer2=None, interval=0.02):
        self.__x = x
        self.__y = y
        self.__w = w
        self.__h = h
        self.interval = interval

        self.NNCTR = NNCTR()
        self.gui = GUI(self)
        self.game_gui = PingPongGUI()

        self.pp_settings = self.gui.new_window("Ping Pong Settings", 70.0, 100.0, 240, 350)
        self.win = self.gui.new_window("Ping Pong", x, y, w, h)

        self.pp_settings.iconbitmap('./favicon/game.ico')
        self.win.iconbitmap('./favicon/game.ico')

        self.space = self.game_gui.new_gamespace(self.win, x=x, y=y, w=w, h=h)

        self.__ball = self.create_ball(ball)
        self.__gamer1 = self.create_gamer(gamer1, id=1)
        self.__gamer2 = self.create_gamer(gamer2, id=2)

        self.win.bind('<Key>', self.key_press)
        self.win.bind('<KeyRelease>', self.key_release)

        frame = self.gui.frame(self.pp_settings, x=0, y=0, w=240, h=360, bind=None, bg="#77AA77")
        frame_control = self.gui.frame(frame, x=10, y=0, w=220, h=70, bind=None, bg="#669966")
        frame_settings = self.gui.frame(frame, x=10, y=80, w=220, h=270, bind=None, bg="#669966")

        self.gui.text(frame_control, x=60, y=5, w=100, h=20, text=self.NNCTR.localization("game_control_title"),
                      bg="#669966", font='Arial 14')

        self.gui.button(frame_control, x=20, y=30, w=80, h=30, text=self.NNCTR.localization("game_start_button"),
                        bind=("<Button-1>", lambda event:  self.start()))

        self.gui.button(frame_control, x=120, y=30, w=80, h=30, text=self.NNCTR.localization("game_stop_button"),
                        bind=("<Button-1>", lambda event:  self.stop()))

        self.gui.text(frame_settings, x=60, y=0, w=100, h=20, text=self.NNCTR.localization("game_settings_title"),
                      bg="#669966", font='Arial 14')

        self.gui.text(frame_settings, x=10, y=40, w=110, h=20, text=self.NNCTR.localization("game_settings_speed_ball"),
                      bg="#669966")

        x_speed_ball = self.gui.input(frame_settings, x=120, y=40, w=40, h=20)

        self.gui.set_text_input(x_speed_ball, "")

        y_speed_ball = self.gui.input(frame_settings, x=170, y=40, w=40, h=20)

        self.gui.set_text_input(y_speed_ball, "")

        self.gui.text(frame_settings, x=10, y=70, w=110, h=20, text=self.NNCTR.localization("game_settings_speed_of_p1"),
                      bg="#669966")

        x_speed_g1 = self.gui.input(frame_settings, x=170, y=70, w=40, h=20)

        self.gui.set_text_input(x_speed_g1, "")

        self.gui.text(frame_settings, x=10, y=100, w=110, h=20, text=self.NNCTR.localization("game_settings_speed_of_p2"),
                      bg="#669966")

        x_speed_g2 = self.gui.input(frame_settings, x=170, y=100, w=40, h=20)

        self.gui.set_text_input(x_speed_g2, "")

        self.gui.text(frame_settings, x=10, y=130, w=110, h=20, text=self.NNCTR.localization("game_settings_radius"),
                      bg="#669966")

        r_ball = self.gui.input(frame_settings, x=170, y=130, w=40, h=20)

        self.gui.set_text_input(r_ball, "10")

        self.gui.text(frame_settings, x=10, y=160, w=130, h=20, text=self.NNCTR.localization("game_settings_collision"),
                      bg="#669966")

        k_ball = self.gui.input(frame_settings, x=170, y=160, w=40, h=20)

        self.gui.set_text_input(k_ball, "1.2")

        self.gui.text(frame_settings, x=10, y=190, w=110, h=20, text=self.NNCTR.localization("game_settings_cords"),
                      bg="#669966")

        x_ball = self.gui.input(frame_settings, x=120, y=190, w=40, h=20)

        self.gui.set_text_input(x_ball, "")

        y_ball = self.gui.input(frame_settings, x=170, y=190, w=40, h=20)

        self.gui.set_text_input(y_ball, "")

        self.gui.button(frame_settings, x=20, y=230, w=80, h=30, text=self.NNCTR.localization("game_get_button"),
                        bind=("<Button-1>", lambda event: self.get_settings(x_speed_ball, y_speed_ball,
                                                                            x_speed_g1, x_speed_g2, x_ball, y_ball)))

        self.gui.button(frame_settings, x=120, y=230, w=80, h=30, text=self.NNCTR.localization("game_set_button"),
                        bind=("<Button-1>", lambda event:
                        self.update_settings(x_speed_ball.get(),
                                             y_speed_ball.get(), x_speed_g1.get(),
                                             x_speed_g2.get(), r_ball.get(), k_ball.get(),
                                             x_ball.get(), y_ball.get())))

    def __getattr__(self, item):
        if item == "x":
            return self.__x
        elif item == "y":
            return self.__y
        elif item == "w":
            return self.__w
        elif item == "h":
            return self.__h
        elif item == "g1":
            return self.__gamer1
        elif item == "g2":
            return self.__gamer2
        elif item == "g":
            return self.__game

    def update_settings(self, x_speed_ball, y_speed_ball, x_speed_g1, x_speed_g2, r_ball, k_ball, x_ball, y_ball):
        try:
            x_speed_ball = float(x_speed_ball)
            y_speed_ball = float(y_speed_ball)
        except ValueError:
            self.gui.message("warning", "Warning!", self.NNCTR.localization("ii_error")
                             % self.NNCTR.localization("game_settings_speed_ball"))
            return None

        try:
            x_speed_g1 = float(x_speed_g1)
        except ValueError:
            self.gui.message("warning", "Warning!", self.NNCTR.localization("ii_error")
                             % self.NNCTR.localization("game_settings_speed_of_p1"))
            return None

        try:
            x_speed_g2 = float(x_speed_g2)
        except ValueError:
            self.gui.message("warning", "Warning!",self.NNCTR.localization("ii_error")
                             % self.NNCTR.localization("game_settings_speed_of_p2"))
            return None

        try:
            r_ball = float(r_ball)
        except ValueError:
            self.gui.message("warning", "Warning!", self.NNCTR.localization("ii_error")
                             % self.NNCTR.localization("game_settings_radius"))
            return None

        try:
            k_ball = float(k_ball)
        except ValueError:
            self.gui.message("warning", "Warning!", self.NNCTR.localization("ii_error")
                             % self.NNCTR.localization("game_settings_collision"))
            return None

        try:
            x_ball = float(x_ball)
            y_ball = float(y_ball)
        except ValueError:
            self.gui.message("warning", "Warning!", self.NNCTR.localization("ii_error")
                             % self.NNCTR.localization("game_settings_cords"))
            return None

        self.__ball.set_speed(x_speed_ball, y_speed_ball)
        self.__gamer1.set_speed(x_speed_g1)
        self.__gamer2.set_speed(x_speed_g2)
        self.__ball.set_r(float(r_ball), float(k_ball))
        self.__ball.set_cords(x_ball, y_ball)
        self.__game = True
        self.paint()
        self.__game = False

    def get_settings(self, x_speed_ball, y_speed_ball, x_speed_g1, x_speed_g2, x_ball, y_ball):
        x, y = self.__ball.get_speed()
        self.gui.set_text_input(x_speed_ball, round(x, 2))
        self.gui.set_text_input(y_speed_ball, round(y, 2))
        x = self.__gamer1.get_speed()
        self.gui.set_text_input(x_speed_g1, round(x, 2))
        x = self.__gamer2.get_speed()
        self.gui.set_text_input(x_speed_g2, round(x, 2))
        x, y = self.__ball.get_cords()
        self.gui.set_text_input(x_ball, round(x, 2))
        self.gui.set_text_input(y_ball, round(y, 2))

    def create_ball(self, ball):
        pass
        return Ball(self, ball)

    def create_gamer(self, gamer, id):
        pass
        return Gamer(self, gamer, id=id)

    def game_loop(self):
        self.__game = True
        while self.__game:
            self.__ball.move()
            self.__gamer1.move()
            self.__gamer2.move()
            sleep(self.interval)
            self.space.update()

    def stop_all(self):
        self.__game = False
        self.NNCTR.stop_all()

    def stop(self):
        self.__game = False

    def start(self):
        if self.NNCTR.network is None:
            self.gui.message("warning", "Warning!", "Network is not loaded!")
            return None
        if not self.__game:
            self.game_loop()

    def paint(self):
        if self.__game:
            self.__ball.paint()
            self.__gamer1.paint()
            self.__gamer2.paint()

    def key_press(self, event):
        if event.keycode == (65 if os.name == "nt" else 38):
            self.__gamer1.mul_speed(-1)
        elif event.keycode == (68 if os.name == "nt" else 40):
            self.__gamer1.mul_speed(1)
        elif event.keycode == (37 if os.name == "nt" else 113):
            self.__gamer2.mul_speed(-1)
        elif event.keycode == (39 if os.name == "nt" else 114):
            self.__gamer2.mul_speed(1)
        elif event.keycode == (32 if os.name == "nt" else 65):
            self.stop() if self.__game else self.start()

    def key_release(self, event):
        if event.keycode == (65 if os.name == "nt" else 38) or event.keycode == (68 if os.name == "nt" else 40):
            self.__gamer1.mul_speed(0)
        elif event.keycode == (37 if os.name == "nt" else 113) or event.keycode == (39 if os.name == "nt" else 114):
            self.__gamer2.mul_speed(0)
Esempio n. 2
0
class NNConstructor:

    gui = None
    win = None
    winNN = None
    t_stop_train = {"next": False, "_next": False}
    __train = None
    samples = []
    test_samples = []
    p_samples = []
    inp = None
    outp = None
    gui_samples = None
    gui_samples_list = None
    gui_network_graph = None
    gui_graph = None
    frame_neurons_graph = None
    gui_graph_colors = None
    __visible_edit_samples = None
    network = None
    analysis_process = None

    def __init__(self, x=450.0, y=0.0):
        self.gui = GUI(self)
        self.winNN = self.gui.new_window("Constructor of Neural Networks", x, y, 960, h=720)
        self.winNN.iconbitmap('./favicon/constructor.ico')
        try:
            words = json.load(open("./language.json", "r"))
        except IOError:
            words = None
        except ValueError:
            words = None
        self.localization = Localization(words).localization


        frame = self.gui.frame(self.winNN, x=0, y=0, w=1046, h=768, bind=None, bg="#77AA77")

        frame_excel = self.gui.frame(frame, x=10, y=0, w=200, h=350, bind=None, bg="#669966")

        frame_newnet = self.gui.frame(frame, x=10, y=360, w=200, h=170, bind=None, bg="#669966")
        frame_train = self.gui.frame(frame, x=10, y=540, w=200, h=170, bind=None, bg="#669966")
        frame_samples = self.gui.frame(frame, x=220, y=0, w=300, h=370, bind=None, bg="#669966")
        self.frame_neurons_graph = self.gui.frame(frame, x=530, y=0, w=420, h=370, bind=None, bg="#669966")
        frame_neurons_control = self.gui.frame(frame, x=615, y=380, w=335, h=360, bind=None, bg="#669966")
        self.frame_train_graph = self.gui.frame(frame, x=220, y=380, w=385, h=350, bind=None, bg="#669966")

        self.gui_network_graph = self.gui.canvas(self.frame_neurons_graph, x=10, y=10, w=400, h=350, bg="#FFFFFF")
        self.new_graph()
        self.gui.button(self.frame_train_graph, x=10, y=310, w=367, h=25, text=self.localization("graph_button"),
                        bind=("<Button-1>",
                              lambda event:
                              self.new_graph()))

        self.new_network_graph(self.frame_neurons_graph)

        self.gui.text(frame_samples, x=50, y=5, w=200, h=20, text=self.localization("sample_editor_title"),
                      bg="#669966", font='Arial 13')

        self.gui_samples = self.gui.textarea(frame_samples, x=10, y=30, w=280, h=260)
        self.gui_samples_list = self.gui.listbox(frame_samples, x=10, y=30, w=280, h=260, bind=("<<ListboxSelect>>",
                                                                                                lambda event:
                                                                                                self.refresh_st_samples(
                                                                                                )))
        self.gui.button(frame_samples, x=10, y=300, w=280, h=30, text=self.localization("load_test_button"),
                        bind=("<Button-1>",
                              lambda event:
                              self.load_tsamples()))

        self.gui.button(frame_samples, x=10, y=335, w=67, h=30, text=self.localization("edit_samples_button"),
                        bind=("<Button-1>",
                              lambda event:  self.edit_samples()))

        self.gui.button(frame_samples, x=81, y=335, w=67, h=30, text=self.localization("clear_samples_button"),
                        bind=("<Button-1>",
                              lambda event: self.clear_samples()))

        self.gui.button(frame_samples, x=152, y=335, w=67, h=30, text=self.localization("load_samples_button"),
                        bind=("<Button-1>",
                              lambda event:  self.load_samples()))

        self.gui.button(frame_samples, x=223, y=335, w=67, h=30, text=self.localization("save_samples_button"),
                        bind=("<Button-1>",
                              lambda event:  self.save_samples()))

        self.gui.text(frame_newnet, x=10, y=0, w=180, h=20, text=self.localization("menu_net_title"),
                      bg="#669966", font='Arial 13')

        self.gui.text(frame_newnet, x=10, y=30, w=50, h=20, text=self.localization("menu_net_layers"), bg="#669966")
        layers = self.gui.input(frame_newnet, x=80, y=30, w=110, h=20)
        self.gui.set_text_input(layers, "")

        bias = self.gui.Tkinter.IntVar()

        self.gui.checkbox(frame_newnet, x=10, y=60, w=180, h=20, variable=bias,
                          text=self.localization("check_box_bias"))

        self.gui.button(frame_newnet, x=10, y=130, w=85, h=30, text=self.localization("load_network_button"),
                        bind=("<Button-1>",
                              lambda event: self.load_network()))

        self.gui.button(frame_newnet, x=105, y=130, w=85, h=30, text=self.localization("save_network_button"),
                        bind=("<Button-1>", lambda event: self.save_network()))

        self.gui.button(frame_newnet, x=10, y=90, w=180, h=30, text=self.localization("new_network_button"),
                        bind=("<Button-1>", lambda event: self.new_network(layers.get(), bias.get())))

        self.gui.text(frame_train, x=10, y=0, w=180, h=20, text=self.localization("menu_train_title"),
                      bg="#669966", font='Arial 13')

        self.gui.text(frame_train, x=10, y=25, w=110, h=20, text=self.localization("menu_train_speed"), bg="#669966")

        speed = self.gui.input(frame_train, x=120, y=25, w=70, h=20)

        self.gui.set_text_input(speed, "")

        self.gui.text(frame_train, x=10, y=50, w=110, h=20, text=self.localization("menu_train_iterations"),
                      bg="#669966")

        iterations = self.gui.input(frame_train, x=120, y=50, w=70, h=20)

        self.gui.set_text_input(iterations, "")

        checkbox = self.gui.Tkinter.IntVar()
        self.gui.checkbox(frame_train, x=10, y=75, w=180, h=20, variable=checkbox,
                          text=self.localization("check_box_change_speed"))

        self.gui.button(frame_train, x=10, y=100, w=180, h=30, text=self.localization("train_button"),
                        bind=("<Button-1>", lambda event: self.train_network(
                            iterations.get(),
                            speed.get(),
                            checkbox.get()
                        )))

        self.gui.button(frame_train, x=10, y=132, w=180, h=30, text=self.localization("stop_train_button"),
                        bind=("<Button-1>", lambda event: self.stop_train()))

        self.gui.text(frame_neurons_control, x=5, y=20, w=240, h=20, text=self.localization("status_sample_error"),
                      bg="#669966", font='Arial 12')

        self.smErr = self.gui.input(frame_neurons_control, x=250, y=20, w=70, h=20)

        self.gui.text(frame_neurons_control, x=5, y=60, w=240, h=20, text=self.localization("status_max_error"),
                      bg="#669966", font='Arial 12')

        self.mxErr = self.gui.input(frame_neurons_control, x=250, y=60, w=70, h=20)

        self.gui.text(frame_neurons_control, x=5, y=100, w=240, h=20, text=self.localization("status_av_error"),
                      bg="#669966", font='Arial 12')

        self.avErr = self.gui.input(frame_neurons_control, x=250, y=100, w=70, h=20)

        self.gui.text(frame_neurons_control, x=5, y=140, w=240, h=20, text=self.localization("status_max_test_error"),
                      bg="#669966", font='Arial 12')

        self.tmxErr = self.gui.input(frame_neurons_control, x=250, y=140, w=70, h=20)

        self.gui.text(frame_neurons_control, x=5, y=180, w=240, h=20, text=self.localization("status_av_test_error"),
                      bg="#669966", font='Arial 12')

        self.ttErr = self.gui.input(frame_neurons_control, x=250, y=180, w=70, h=20)

        self.gui.button(frame_neurons_control, x=30, y=250, w=80, h=30, text=self.localization("module_1_button"),
                        bind=("<Button-1>", lambda event: self.load_module("_module_1")))

        self.gui.button(frame_neurons_control, x=120, y=250, w=80, h=30, text=self.localization("module_2_button"),
                        bind=("<Button-1>", lambda event: self.load_module("_module_2")))

        self.gui.button(frame_neurons_control, x=210, y=250, w=80, h=30, text=self.localization("module_3_button"),
                        bind=("<Button-1>", lambda event: self.load_module("_module_3")))

        self.gui.text(frame_excel, x=50, y=5, w=100, h=20, text=self.localization("analysis_title"),
                      bg="#669966", font='Arial 13')

        self.gui.text(frame_excel, x=5, y=35, w=120, h=20, text=self.localization("analysis_name_of_file"),
                      bg="#669966")

        book_name = self.gui.input(frame_excel, x=120, y=35, w=70, h=20)

        self.gui.text(frame_excel, x=5, y=70, w=120, h=20, text=self.localization("analysis_layers"), bg="#669966")

        layers_pat = self.gui.input(frame_excel, x=120, y=70, w=70, h=20)

        self.gui.text(frame_excel, x=5, y=100, w=120, h=20, text=self.localization("analysis_ch_speed"), bg="#669966")

        ch_layers = self.gui.input(frame_excel, x=120, y=100, w=70, h=20)

        self.gui.text(frame_excel, x=5, y=135, w=120, h=20, text=self.localization("analysis_iterations"), bg="#669966")

        iter = self.gui.input(frame_excel, x=120, y=135, w=70, h=20)

        self.gui.text(frame_excel, x=5, y=170, w=120, h=20, text=self.localization("analysis_data_size"), bg="#669966")

        data = self.gui.input(frame_excel, x=120, y=170, w=70, h=20)

        self.gui.text(frame_excel, x=5, y=205, w=120, h=20, text=self.localization("analysis_speed"), bg="#669966")

        speed_cof = self.gui.input(frame_excel, x=120, y=205, w=70, h=20)

        checkbox = self.gui.Tkinter.IntVar()
        self.gui.checkbox(frame_excel, x=10, y=240, w=180, h=20, variable=checkbox,
                          text=self.localization("check_box_ch_speed"))

        progressbar = self.gui.progressbar(frame_excel, x=10, y=310, w=180, h=30,
                                           orient='horizontal', mode='indeterminate')

        self.gui.button(frame_excel, x=10, y=270, w=85, h=30, text=self.localization("start_analysis_button"),
                        bind=("<Button-1>", lambda event: self.analysis_start(book_name.get(),
                                                                              layers_pat.get(),
                                                                              ch_layers.get(),
                                                                              iter.get(),
                                                                              data.get(),
                                                                              speed_cof.get(),
                                                                              checkbox.get(),
                                                                              progressbar)))

        self.gui.button(frame_excel, x=105, y=270, w=85, h=30, text=self.localization("stop_analysis_button"),
                        bind=("<Button-1>", lambda event: self.analysis_stop(progressbar)))

    def open(self):
        self.gui.mainloop()

    def close(self):
        self.gui.close()

    def stop_all(self):
        self.stop_train()
        time.sleep(0.5)

    def load_module(self, name):
        try:
            module = __import__(name)
            if "main" in dir(module):
                module.main(self)
            else:
                self.gui.message("warning", "Warning!", self.localization("fminf_error"))
        except ImportError:
            self.gui.message("error", "Error!", self.localization("minf_error") % name)

    def analysis_start(self, fn, layers, ch_layers, iter, data, speed, ch_speed, pb):

        def parse_str(s):
            arr_s = s.replace(" ", "").split(",")
            if arr_s[0] == '':
                arr_s = []
            arr = []
            if len(arr_s) == 1:
                arr_s = arr_s[0].split(":")
            elif len(arr_s) > 1:
                arr = [float(i) for i in arr_s]
                arr_s = []

            if len(arr_s) == 1:
                arr = [float(arr_s[0])]
            elif len(arr_s) == 3:
                i = float(arr_s[0])
                while i <= float(arr_s[1]):
                    arr.append(i)
                    i += float(arr_s[2])

            return arr

        if len(fn) < 1:
            self.gui.message("warning", "Warning!", self.localization("ii_error")
                             % (self.localization("analysis_name_of_file")))
            return None

        for i in ['\\', '/', ':', '*', '.', '?', '"', '<', '>', '|']:
            if i in fn:
                self.gui.message("warning", "Warning!", self.localization("fcncc_error"))
                return None

        layers = layers.replace(" ", "").split(",")
        if layers[0] == '':
            self.gui.message("warning", "Warning!", self.localization("ii_error")
                             % (self.localization("analysis_layers")))
            return None

        try:
            ch_layers = parse_str(ch_layers)
        except ValueError:
            self.gui.message("warning", "Warning!", self.localization("ii_error")
                             % self.localization("analysis_ch_speed"))
            return None

        try:
            iter = parse_str(iter)
        except ValueError:
            self.gui.message("warning", "Warning!", self.localization("ii_error")
                             % (self.localization("analysis_iterations")))
            return None

        try:
            data = parse_str(data)
        except ValueError:
            self.gui.message("warning", "Warning!", self.localization("ii_error")
                             % (self.localization("analysis_data_size")))
            return None

        try:
            speed = parse_str(speed)
        except ValueError:
            self.gui.message("warning", "Warning!", self.localization("ii_error")
                             % (self.localization("analysis_speed")))
            return None

        samples = self.samples[:]
        test_samples = self.test_samples[:] if len(self.test_samples) > 0 else samples

        len_samples = len(samples)
        len_test_samples = len(test_samples)

        if len_samples < 1:
            self.gui.message("warning", "Warning!", self.localization("sinl_error"))
            return None

        def main():

            wb = openpyxl.Workbook()
            test_wb = openpyxl.Workbook() if not (samples == test_samples) else None

            self.analysis_process = True
            pb.start(5)

            column = 1
            for i in ch_layers:
                row = 1
                for j in iter:
                    for k in data:
                        sample = samples[:int(k)] if (int(k) > 0) and (int(k) < len_samples) else samples
                        test_sample = test_samples[:int(k)] \
                            if (int(k) > 0) and (int(k) < len_test_samples) else test_samples

                        for z in speed:
                            if self.analysis_process is not True:
                                return None
                            nn = analysis.NN([int(i) if t == 'x' else int(t) for t in layers])

                            nn.train(sample, int(j), z, z/100 if ch_speed else z)
                            err = nn.get_error(sample, test_sample)
                            del nn
                            sheet = "col_data "+str(int(k))+" speed "+str(z)
                            if not (sheet in wb):
                                wb.create_sheet(1, sheet)
                            wb[sheet].cell(row=row, column=column).value = err[0]
                            if test_wb is not None:
                                if not (sheet in test_wb):
                                    test_wb.create_sheet(1, sheet)
                                test_wb[sheet].cell(row=row, column=column).value = err[1]

                        row += 1
                    column += 1

                pb.stop()

            wb.save("./sheets/%s.xlsx" % fn)
            if test_wb is not None:
                test_wb.save("./sheets/%s_test.xlsx" % fn)

        threading.Thread(target=main).start()

    def analysis_stop(self, pb):
        self.analysis_process = False
        pb.stop()

    def new_network(self, layers, bias=0):
        try:
            arr = layers.split(",")
            if len(arr) < 1:
                raise ValueError
            layers = []
            for i in arr:
                if int(i) > 0:
                    layers.append(int(i))
                else:
                    raise ValueError
        except ValueError:
            self.gui.message("warning", "Warning!", self.localization("ii_error") % (self.localization("menu_net_layers")))
            return None

        funcs = [[f_activation, df_activation]]*len(layers)
        funcs[0] = None

        self.network = Net(layers, funcs, bias)
        self.new_network_graph(self.frame_neurons_graph)
        self.refresh_st_samples()

    def train_network(self, iterations, speed, dspeed):
        if self.__train is not None and self.__train.isAlive():
            self.gui.message("warning", "Warning!", self.localization("ptsb_error"))
            return None

        if self.network is None:
            self.gui.message("warning", "Warning!", self.localization("ninl_error"))
            return None

        if len(self.samples) < 1:
            self.gui.message("warning", "Warning!", self.localization("sinl_error"))
            return None

        if not self.network.check_sample(self.samples):
            self.gui.message("warning", "Warning!", self.localization("sinl_error"))
            return None

        if not self.network.check_sample(self.test_samples) and self.test_samples != [] and self.test_samples != self.samples:
            self.gui.message("warning", "Warning!", self.localization("tsinl_error"))
            return None

        try:
            iterations = int(iterations)
            if iterations < 1:
                raise ValueError
        except ValueError:
            self.gui.message("warning", "Warning!", self.localization("ii_error")
                             % (self.localization("menu_train_iterations")))
            return None

        try:
            speed = float(speed)
        except ValueError:
            self.gui.message("warning", "Warning!", self.localization("ii_error")
                             % (self.localization("menu_train_speed")))
            return None

        self.graph[3] = iterations
        if len(self.gui_graph_colors) == 0:
            self.new_graph()
        color = self.gui_graph_colors.pop()
        start = time.time()

        self.__train = threading.Thread(target=lambda: self.network.train(self.samples, iterations, speed, dspeed,
                                                                          func=lambda i, error, terror:
                                                                          self.picture_graph(
                                                                              i=i,
                                                                              error=error,
                                                                              terror=terror,
                                                                              iterations=iterations,
                                                                              color=color
                                                                          ),
                                                                          test=self.test_samples,
                                                                          stop=self.t_stop_train,
                                                                          callback=lambda: self.new_network_graph(
                                                                              self.frame_neurons_graph
                                                                          ) or self.refresh_st_samples(st=True)))
        self.__train.start()

    def stop_train(self):
        self.t_stop_train["_next"] = True
        self.t_stop_train["next"] = True

    def save_network(self):
        if self.network is None:
            return None
        self.set_samples()
        f = self.gui.save_file(self.winNN, filetypes=[("JSON file", ".json")])
        if not f:
            return None
        try:
            json.dump([self.network.n, self.network.w], f)
        except ValueError:
            self.gui.message("error", "Error!", self.localization("io_error"))
            return None

    def load_network(self):
        f = self.gui.open_file(self.winNN, filetypes=[("JSON file", ".json")])
        if not f:
            return None

        def check_network(ntw):
            if len(ntw) < 2 or type(ntw) is not list or len(ntw[0]) != len(ntw[1])+1:
                return False
            for i in range(len(ntw[0])-1):
                if ntw[0][i] != len(ntw[1][i]):
                    return False
                for j in range(len(ntw[1][i])):
                    if ntw[0][i+1] != len(ntw[1][i][j]):
                        return False

            return True

        try:
            network = json.load(f)
            if not check_network(network):
                raise ValueError
        except ValueError:
            self.gui.message("error", "Error!", self.localization("tinn_error"))
            return None
        funcs = [[f_activation, df_activation]]*len(network[0])
        funcs[0] = None
        self.network = Net(network[0], funcs)
        self.network.w = network[1]
        self.new_network_graph(self.frame_neurons_graph)
        self.refresh_st_samples()

    def new_graph(self):
        if self.gui_graph is not None:
            self.gui_graph.space.destroy()
            del self.gui_graph

        self.gui_graph = self.gui.canvas(self.frame_train_graph, x=10, y=10, w=365, h=300, bg="#99BB99")
        self.graph = [None, (40.0, 270.0, 300.0, 260.0, 0.2), None, 1]
        self.gui_graph.line(int(self.graph[1][0]),
                            int(self.graph[1][1]),
                            int(self.graph[1][0]),
                            int(self.graph[1][1]-self.graph[1][3]),
                            arrow=self.gui.Tkinter.LAST)
        self.gui_graph.line(int(self.graph[1][0]),
                            int(self.graph[1][1]),
                            int(self.graph[1][0]+self.graph[1][2]),
                            int(self.graph[1][1]),
                            arrow=self.gui.Tkinter.LAST)

        self.gui_graph_colors = ["red", "blue", "black", "orange", "purple"]
        text_cords = self.gui_graph.text(x=0, y=0, text="")
        self.gui_graph.space.bind("<B1-Motion>", lambda event: self.gui_graph.space.coords(text_cords, event.x-(
            -40 if event.x < self.graph[1][2]/2 else 40), event.y+7) or self.gui_graph.space.itemconfigure(
            text_cords, text=str(int((event.x-self.graph[1][0])/self.graph[1][2]*self.graph[3]))+" / "+str(
                round((self.graph[1][1]-event.y)/self.graph[1][3]*self.graph[1][4], 2))))

        self.gui_graph.text(x=self.graph[1][0]-20, y=self.graph[1][1]-self.graph[1][3]+10, text="Q")
        self.gui_graph.text(x=self.graph[1][0]+self.graph[1][2]-20, y=self.graph[1][1]+20, text="N")

        self.gui_graph.space.bind("<B1-ButtonRelease>", lambda e: self.gui_graph.space.coords(text_cords, -10, -10))
        cx, cy = 5, 5
        for i in range(1, cy):
            self.gui_graph.line(self.graph[1][0]-5, self.graph[1][1]-self.graph[1][3]/cy*i,
                                self.graph[1][0]+5, self.graph[1][1]-self.graph[1][3]/cy*i,
                                fill="red")
        for i in range(1, cx):
            self.gui_graph.space.create_line(self.graph[1][0]+self.graph[1][2]/cx*i,
                                             self.graph[1][1]+5, self.graph[1][0]+self.graph[1][2]/cx*i,
                                             self.graph[1][1]-5, width=1, fill="red")

    def picture_graph(self, i=0, error=0, terror=0, iterations=0, color=None):

        if not color:
            return None
        if self.graph[0] is None or i < 5:
            self.graph[0] = (i*1.0, error)
            self.graph[2] = (i*1.0, terror)
        else:
            self.gui_graph.space.create_line(
                self.graph[1][0]+i*1.0/iterations*self.graph[1][2],
                self.graph[1][1]-error/self.graph[1][4]*self.graph[1][3],
                self.graph[1][0]+self.graph[0][0]/iterations*self.graph[1][2],
                self.graph[1][1]-self.graph[0][1]/self.graph[1][4]*self.graph[1][3],
                width=2, fill=color
            )
            if terror:
                self.gui_graph.space.create_oval(
                    self.graph[1][0]+i*1.0/iterations*self.graph[1][2]-2,
                    self.graph[1][1]-terror/self.graph[1][4]*self.graph[1][3]-2,
                    self.graph[1][0]+i*1.0/iterations*self.graph[1][2]+2,
                    self.graph[1][1]-terror/self.graph[1][4]*self.graph[1][3]+2,
                    fill=color
                )
            self.graph[0] = (i*1.0, error)
            self.graph[2] = (i*1.0, terror)

    def new_network_graph(self, frame_neurons_graph):
        if not self.network:
            return None
        if self.gui_network_graph is not None:
            self.gui_network_graph.space.destroy()
            del self.gui_network_graph
        self.gui_network_graph = self.gui.canvas(frame_neurons_graph, x=10, y=10, w=400, h=350, bg="#FFFFFF")
        n = self.network.n

        for i in range(len(n)-1):
            for j in range(n[i]):
                for k in range(n[i+1]):
                        self.gui_network_graph.line(400/(len(n)+1)*(i+1), 350/(n[i]+1)*(j+1),
                                                    400/(len(n)+1)*(i+2), 350/(n[i+1]+1)*(k+1),
                                                    fill="#%x%x%x" % (15/(1+math.exp(
                                                        -self.network.w[i][j][k]*5)), 0, 15/(
                                                        1+math.exp(self.network.w[i][j][k]*5))))
        for i in range(len(n)):
            for j in range(n[i]):
                    self.gui_network_graph.circle(400/(len(n)+1)*(i+1), 350/(n[i]+1)*(j+1), 4,
                                                  tags=("neurons", "neuron-%d-%d" % (i, j)), fill="green")

    def refresh_st_samples(self, st=False):
        if self.network is None or (self.__train is not None and self.__train.isAlive() and not st) \
                or len(self.samples) < 1:
            return None

        if not self.network.check_sample(self.samples):
            return None

        if not self.network.check_sample(self.test_samples):
            return None

        smp_cl = int(self.gui_samples_list.curselection()[0]) if len(self.gui_samples_list.curselection()) > 0 else 0
        err = 0.0

        if len(self.samples) > smp_cl:
            sample = self.samples[smp_cl]

            self.network.update(sample[0])

            for k in range(len(sample[1])):
                err += abs(sample[1][k]-self.network.a[-1][k])
            err /= len(sample[1])

            self.gui.set_text_input(self.smErr, str(round(err, 5)))

        averr = 0.0
        mxerr = 0.0
        for p in self.samples:
            self.network.update(p[0])
            _averr = 0.0
            for k in range(len(p[1])):
                _averr += abs(p[1][k]-self.network.a[-1][k])
            _averr /= len(p[1])
            averr += _averr
            if _averr > mxerr:
                mxerr = _averr
        averr /= len(self.samples)

        t_averr = 0.0
        t_mxerr = 0.0

        for p in self.test_samples:
            self.network.update(p[0])
            _averr = 0.0
            for k in range(len(p[1])):
                _averr += abs(p[1][k]-self.network.a[-1][k])
            _averr /= len(p[1])
            t_averr += _averr
            if _averr > t_mxerr:
                t_mxerr = _averr

        t_averr /= len(self.test_samples) or 1

        self.gui.set_text_input(self.avErr, str(round(averr, 5)))
        self.gui.set_text_input(self.mxErr, str(round(mxerr, 5)))
        self.gui.set_text_input(self.ttErr, str(round(t_averr, 5)))
        self.gui.set_text_input(self.tmxErr, str(round(t_mxerr, 5)))

        return (err, averr, mxerr, t_averr, t_mxerr)

    def edit_samples(self):
        if self.__visible_edit_samples is None:
            self.__visible_edit_samples = 30
            self.gui_samples_list.place(y=-500)
        else:
            try:
                if self.set_samples() is not False:
                    self.get_samples()
                    self.gui_samples_list.place(y=self.__visible_edit_samples)
                    self.__visible_edit_samples = None
                    self.gui_samples_list.focus()

            except IndexError:
                self.gui.message("warning", "Warning!", self.localization("tsinc_error"))
                return None

    def clear_samples(self):
        self.samples = []
        self.get_samples()
        self.refresh_st_samples()

    def get_samples(self):
        self.gui.set_text_textarea(self.gui_samples, data_samples(self.samples))
        samples, k = "", 0
        for i in self.samples:
            samples += "%2d:        " % k
            k += 1
            for j in i[0]:
                samples += "% .2f  " % round(j, 2)
            samples += "  ->  "
            for j in i[1]:
                samples += "% .2f  " % round(j, 2)
            samples += "\n"

        self.gui.set_text_listbox(self.gui_samples_list, samples)

    def set_samples(self):
        try:
            self.samples = parse_samples(self.gui.get_text(self.gui_samples))
        except ValueError:
            self.gui.message("warning", "Warning!", self.localization("tsinc_error"))
            return False
        self.refresh_st_samples()

    def load_samples(self):
        f = self.gui.open_file(self.winNN, filetypes=[("JSON file", ".json")])
        if not f:
            return 0
        try:
            self.samples = json.load(f)
            if type(self.samples) is not list:
                raise ValueError
            self.refresh_st_samples()
            self.get_samples()
        except ValueError:
            self.gui.message("warning", "Warning!", self.localization("tins_error"))
            return None
        except TypeError:
            self.gui.message("warning", "Warning!", self.localization("tins_error"))
            return None

    def load_tsamples(self):
        f = self.gui.open_file(self.winNN, filetypes=[("JSON file", ".json")])
        if not f:
            return 0
        try:
            self.test_samples = json.load(f)
            if type(self.test_samples) is not list:
                raise ValueError
            self.refresh_st_samples()
            self.get_samples()
        except ValueError:
            self.gui.message("warning", "Warning!", self.localization("tints_error"))
            return None
        except TypeError:
            self.gui.message("warning", "Warning!", self.localization("tints_error"))
            return None

    def save_samples(self):
        self.set_samples()
        f = self.gui.save_file(self.winNN, filetypes=[("JSON file", ".json")])
        if not f:
            return 0
        try:
            json.dump(self.samples, f)
        except ValueError:
            self.gui.message("error", "Error!", self.localization("io_error"))
            return None