def solve_sequence(self): logging.info( '--------------------Solving one sequence---------------------------------' ) self.set_sequence = SetSequence(self.data) self.set_sequence.exec_() sequence = self.set_sequence.set_sequence() sequence.print_sequence() self.one_time_model = Solver(self.data) self.one_time_model.current_data_set = self.current_data_set_number self.one_time_model.load_data_set() self.one_time_model.set_sequence(sequence) while not self.one_time_model.finish: self.one_time_model.next_step() total_error = 0 for truck in itertools.chain( self.one_time_model.outbound_trucks.values(), self.one_time_model.compound_trucks.values()): truck.calculate_error() logging.info("Truck {0}, error {1}\n".format( truck.truck_name, truck.error)) total_error += abs(truck.error) logging.info("Error: {0}\n".format(total_error))
def run_calculator_in_command_line(): print( '--------- ** Run A Scientific Calculator Using Command Line ** ---------' ) print( '** Enter the command "-h" or "help" to show available calculator functions...\n' ) problem = Solver() global valid_answer_previous while True: infix = input('---> ') if infix in ['exit', 'quit']: break elif infix == 'ans': print(valid_answer_previous) elif infix in ["help", "-h"]: helper() else: try: temp_ans = problem.solve(infix) if temp_ans in errors: print(temp_ans) else: if isFloat(temp_ans): temp_ans = float(temp_ans) else: temp_ans = integer_modification(temp_ans) valid_answer_previous = temp_ans print(temp_ans) except: print('Wrong Input')
def generate_data_set(self): # ask if sure self.data.arrival_times = [] self.data.boundaries = [] self.model = Solver(self.data) for i in range(len(self.data.data_set_list)): self.model.current_data_set = i self.model.set_data()
def main(): error_detected = False """ Reading sudoku file """ try: with open("static/sudoku.txt") as file: file_sudoku = [line.split() for line in file] except: bcolors.printError('\nFile sudoku.txt does not exist or is corrupted.') error_detected = True """ Validation and conversion of sudoku file into 2D integer array """ if not error_detected: if len(file_sudoku) == 9: for yy in range(9): row_lenght = 0 for xx in range(9): row_lenght += 1 file_sudoku[yy][xx] = int(file_sudoku[yy][xx]) if row_lenght != 9: error_detected = True else: error_detected = True """ Execution of program logic: Solving sudoku """ if not error_detected: bcolors.printOK_BOLD('\nInput sudoku:\n') write_it_down(file_sudoku) bcolors.printOK_BOLD('\nSolved sudoku:\n') write_it_down(Solver.solve_sudoku(file_sudoku)) else: bcolors.printError(error_msg)
def solve_sequence(self): logging.info("--------------------Solving one sequence---------------------------------") self.set_sequence = SetSequence(self.data) self.set_sequence.exec_() sequence = self.set_sequence.set_sequence() sequence.print_sequence() self.one_time_model = Solver(self.data) self.one_time_model.current_data_set = self.current_data_set_number self.one_time_model.load_data_set() self.one_time_model.set_sequence(sequence) while not self.one_time_model.finish: self.one_time_model.next_step() total_error = 0 for truck in itertools.chain( self.one_time_model.outbound_trucks.values(), self.one_time_model.compound_trucks.values() ): truck.calculate_error() logging.info("Truck {0}, error {1}\n".format(truck.truck_name, truck.error)) total_error += abs(truck.error) logging.info("Error: {0}\n".format(total_error))
def get_answer(expression): problem = Solver() try: temp_ans = problem.solve(expression) if temp_ans in errors: return str(temp_ans) else: global valid_answer_previous if isFloat(temp_ans): temp_ans = float(temp_ans) else: temp_ans = integer_modification(temp_ans) valid_answer_previous = temp_ans return str(temp_ans) except: return 'Wrong Input'
def test_run() -> None: assert Solver.run("1/2 + 3/4") == "1_1/4" assert Solver.run("1 + 0") == "1" assert Solver.run("3_1/2 * 3") == "10_1/2" assert Solver.run("2_4/5 - 11/10") == "1_7/10" assert Solver.run("10 / 2") == "5" assert Solver.run("13/2 / 3/2") == "4_1/3" assert Solver.run("-1_1/3 - 1/3") == "-1_2/3" assert Solver.run("-1/2 * 2") == "-1"
def evaluate(self, prob_id, tune=False, plot=True): assert prob_id in [1, 2, 3, 4], "Only support evaluation for problems1~4" self.prob_id = prob_id self.base_dir = osp.join(cfg.EVALUATION.ROOT_DIR, "prob" + str(prob_id)) if not osp.exists(self.base_dir): os.makedirs(self.base_dir) self.strategy_path = osp.join(cfg.PROB.PROBLEM_LIST[prob_id - 1], "strategies.pkl") self.csv_path = self.strategy_path[:-3] + "csv" self.hub_path = osp.join(osp.dirname(self.strategy_path), "hubs.pkl") if not tune and not osp.exists(self.strategy_path): key = input( "It seems that you have not run solver for this problem yet. Run Now?(y or n)" ) if key == 'Y' or key == 'y': solver = Solver() solver.solve(problem_id=prob_id) else: print("exit") return if osp.exists(self.strategy_path): self._pkl2csv() avg_amount_cost, avg_time_cost = self.get_avg_cost() print( "For problem {}:\nAverage amount cost:{:.2f} | Average time cost: {:.2f}min" .format(prob_id, avg_amount_cost, avg_time_cost)) # whether we are tuning the parameters if tune: if prob_id == 1: # for problem1 we tune the weight_amount and weight_cost # self.weight_tune() self.weight_plot() elif prob_id == 2: # self.hub_cost_test() self.hub_cost_plot() elif prob_id == 3: # self.hub_cap_test() self.hub_cap_plot() # plot the distribution or not if plot: self.plot_distribution()
def main(): # Initiaise the solver solver = Solver(n=3, NUM_TERMS=5, epsilon=1e-4) env = simpy.Environment() env.process(example1(env, solver)) # Run the simulation until all events in the queue are processed. # Make it some number to halt simulation after sometime. env.run()
def next_iteration(self): print("next") try: self.solver = Solver(self.data_set_number, self.data) self.solver.done_signal.connect(self.iteration_end) self.solver.value_signal.connect(self.time_saver) print(self.iteration_number) if self.iteration_number == 0: self.sequence = copy.deepcopy(self.algorithm.start1()) self.iteration_number += 1 self.solver.set_sequence(self.sequence) self.solver.solve() elif self.iteration_number < self.number_of_iterations + 1: if self.algorithm_name == "annealing": new_sequence = self.algorithm.next_iteration(self.sequence, self.iteration_number) if self.slow_solution: self.current_result_data.sequence = copy.deepcopy(self.sequence) self.iteration_number += 1 self.sequence = new_sequence self.solver.set_sequence(self.sequence) self.solver.solve() elif self.algorithm_name == "tabu": print("tabu") if self.algorithm.generated_neighbour_number == self.algorithm.number_of_neighbours: print("if") self.algorithm.generated_neighbour_number = 0 decision_list = self.algorithm.choose_sequence() # if self.slow_solution: for i, decision in enumerate(decision_list): self.results[self.solution_name][-len(decision_list) + i].sequence.values[ "decision" ] = decision self.iteration_number += 1 self.next_iteration() else: new_sequence = self.algorithm.next_iteration(self.iteration_number) self.sequence = new_sequence self.algorithm.generated_neighbour_number += 1 if self.algorithm.check_tabu(self.sequence): self.save_tabu_results() self.next_iteration() else: self.solver.set_sequence(self.sequence) self.solver.solve() elif self.iteration_number == self.number_of_iterations + 1: self.end_time = time.time() self.solution_time = self.end_time - self.start_time self.solution_time_label.setText(str(int(self.solution_time))) self.stop() except: pass
def hub_cap_test(self): hub_cap_path = osp.join(self.base_dir, "cap.csv") index = np.where( cfg.EVALUATION.HUB_CAPACITY_FIELD == cfg.PARAM.HUB_CAPACITY)[0] hub_capacity_field = np.insert(cfg.EVALUATION.HUB_CAPACITY_FIELD, index, 0.95 * cfg.PARAM.HUB_CAPACITY) hub_capacity_field = np.insert(hub_capacity_field, index + 2, 1.05 * cfg.PARAM.HUB_CAPACITY) new_dict = edict() num_hubs_list, amount_cost_list, time_cost_list = [], [], [] mask = np.ones_like(hub_capacity_field) for idx, cap in enumerate(hub_capacity_field): new_dict["HUB_CAPACITY"] = cap merge_a_into_b(new_dict, cfg) solver = Solver() solver.solve(problem_id=3, tune_mode=True) with open(self.hub_path, "rb") as f: data = pkl.load(f) num_hubs = len(data["hubs"]) if num_hubs == 0: print("When capacity is :{}. No hubs were built...Continue...". format(cap)) mask[idx] = 0 continue self._pkl2csv() avg_amount_cost, avg_time_cost = self.get_avg_cost() amount_cost_list.append(avg_amount_cost) time_cost_list.append(avg_time_cost) num_hubs_list.append(num_hubs) print( "Hub capacity: {:.0f} | Hubs: {:.0f} | Average amount cost: {:.3f}$ | Average time cost: {:.2f}m." .format(cap, num_hubs, avg_amount_cost, avg_time_cost)) df = pd.DataFrame( data=list( zip(hub_capacity_field[np.nonzero(mask)], num_hubs_list, amount_cost_list, time_cost_list)), columns=["HubCapacity", "NumHubs", "AmountCost", "TimeCost"]) df["Products"] = df["AmountCost"] * df["TimeCost"] df["Values"] = cfg.PARAM.WEIGHT_AMOUNT * df[ "AmountCost"] + cfg.PARAM.WEIGHT_TIME * df["TimeCost"] df.to_csv(hub_cap_path, index=False, float_format="%.2f")
def setup_data_set(self): # setup for one data set self.model = Solver(self.data) self.model.current_data_set = self.current_data_set_number self.model.load_data_set() self.algorithm = self.algorithm_list[self.algorithm_name]( self.number_of_iterations, self.current_data_set_number, self.model, self.data) logging.info("Solving using {0} data set {1}".format( self.algorithm_name, self.current_data_set_number + 1)) logging.info("Nuber of iterations {0}".format( self.number_of_iterations)) self.solve_step_button.setEnabled(True) self.solve_iteration_button.setEnabled(True) self.solve_data_set_button.setEnabled(True) self.solve_sequence_button.setEnabled(True) self.show_solution_button.setEnabled(True) self.show_sequences_button.setEnabled(True)
def main(): # Initiaise the solver solver = Solver(epsilon=1e-6) # For higher precision, default is 5 env = simpy.Environment() env.process(example1(env, solver)) # Run the simulation until all events in the queue are processed. # Make it some number to halt simulation after sometime. env.run(until=10.0) print('total steps: ', step)
def data_set_ready(self): #enable solve buttons self.algorithms = Algorithms() self.model = Solver(self.data) self.model.current_data_set = self.current_data_set self.model.load_data_set() self.algorithms.set_algorithms(self.model) self.current_iteration = 1 self.iteration_limit = 100 self.simulation.init_image(self.model) self.simulation.show()
def main(): # make a string that describes the current running setup num = 0 run_setup_str = f"{args.source}2{args.target}_k_{args.num_k}_kq_{args.num_kq}_lamb_{args.lamb_marg_loss}" while os.path.exists(f"record/{run_setup_str}_run_{num}.txt"): num += 1 run_setup_str = f"{run_setup_str}_run_{num}" # eg, svhn2mnist_k_4_kq_4_lamb_10.0_run_5 # set file names for records (storing training stats) record_train = f"record/{run_setup_str}.txt" record_test = f"record/{run_setup_str}_test.txt" if not os.path.exists('record'): os.mkdir('record') # create a folder for records if not exist # set the checkpoint dir name (storing model params) checkpoint_dir = f'checkpoint/{run_setup_str}' if not os.path.exists('checkpoint'): os.mkdir('checkpoint') # create a folder if not exist if not os.path.exists(checkpoint_dir): os.mkdir(checkpoint_dir) # create a folder if not exist #### # create a solver: load data, create models (or load existing models), # and create optimizers solver = Solver(args, source=args.source, target=args.target, nsamps_q=args.nsamps_q, lamb_marg_loss=args.lamb_marg_loss, learning_rate=args.lr, batch_size=args.batch_size, optimizer=args.optimizer, num_k=args.num_k, num_kq=args.num_kq, all_use=args.all_use, checkpoint_dir=checkpoint_dir, save_epoch=args.save_epoch) # run it (test or training) if args.eval_only: solver.test(0) else: # training count = 0 for t in range(args.max_epoch): num = solver.train(t, record_file=record_train) count += num if t % 1 == 0: # run it on test data every epoch (and save models) solver.test(t, record_file=record_test, save_model=args.save_model) if count >= 20000 * 10: break
def weight_tune(self): """ tuning the weight of time and weight of cost """ new_dict = edict() weight_data_path = osp.join(self.base_dir, "weight.csv") weight_time_list, weight_amount_list = [], [] amount_cost_list, time_cost_list = [], [] for weight_amount in cfg.EVALUATION.WEIGHT_AMOUNT_FIELD: for weight_time in cfg.EVALUATION.WEIGHT_TIME_FIELD: new_dict["WEIGHT_AMOUNT"] = round(weight_amount, 2) new_dict["WEIGHT_TIME"] = round(weight_time, 2) # merge the config merge_a_into_b(new_dict, cfg) # solve the problem and get the output solver = Solver() solver.solve(problem_id=1, tune_mode=True) # don't forget transform into csv file self._pkl2csv() avg_amount_cost, avg_time_cost = self.get_avg_cost() weight_amount_list.append(round(weight_amount, 2)) weight_time_list.append(round(weight_time, 2)) amount_cost_list.append(avg_amount_cost) time_cost_list.append(avg_time_cost) print( "When weight of amount is {:.2f} and weight of time is:{:.2f}" .format(weight_amount, weight_time)) print( "Average amount cost is: {:.1f}. Average time cost is:{:.1f}" .format(avg_amount_cost, avg_time_cost)) df = pd.DataFrame(data=list( zip(weight_amount_list, weight_time_list, amount_cost_list, time_cost_list)), columns=[ "WeightOfAmount", "WeightOfTime", "AmountCost", "TimeCost" ]) # multiply the two columns to get the products df["Products"] = df["AmountCost"] * df["TimeCost"] df.to_csv(weight_data_path, index=False, float_format="%.2f")
def main(): # Initiaise the solver solver = Solver(n=5, epsilon=1e-6) env = simpy.Environment() env.process(lorenz(env, solver)) # Run the simulation until all events in the queue are processed. # Make it some number to halt simulation after sometime. env.run(until=STOP_TIME) # Plot the output plt.plot(data['t'], data['x']) plt.show()
def main(_): os.environ['CUDA_VISIBLE_DEVICES'] = FLAGS.gpu_index solver = Solver(FLAGS) if FLAGS.is_train: solver.train() else: solver.test()
def calculator() -> None: click.echo( click.style( ("Welcome, please enter an operation.\n" "E.g. 1 + 2, 1/2 - 3/4, 2_2/3 / -8_1/5\n" "Press Ctrl+C to exit."), fg="magenta", )) while True: input = click.prompt(click.style("?", fg="green")) try: click.echo( click.style("= ", fg="blue") + click.style(Solver.run(input), fg="yellow")) except ValueError as excinfo: click.echo(click.style(str(excinfo), fg="red"))
def setup_data_set(self): # setup for one data set self.model = Solver(self.data) self.model.current_data_set = self.current_data_set_number self.model.load_data_set() self.algorithm = self.algorithm_list[self.algorithm_name]( self.number_of_iterations, self.current_data_set_number, self.model, self.data ) logging.info("Solving using {0} data set {1}".format(self.algorithm_name, self.current_data_set_number + 1)) logging.info("Nuber of iterations {0}".format(self.number_of_iterations)) self.solve_step_button.setEnabled(True) self.solve_iteration_button.setEnabled(True) self.solve_data_set_button.setEnabled(True) self.solve_sequence_button.setEnabled(True) self.show_solution_button.setEnabled(True) self.show_sequences_button.setEnabled(True)
def solve_multi_solve(self, data_set, function, sequence): print("multi solve") self.function_type = function self.data_set_number = data_set self.solution_name = self.result_names_combo_box.currentText() + '_solvefor_{0}'.format(function) self.results[self.solution_name] = [] self.result_names_combo_box.addItem(self.solution_name) self.setup_truck_names() self.solver = Solver(self.data_set_number, self.data) self.solver.time_signal.connect(self.time.display) self.solver.value_signal.connect(self.solver_truck_signal) self.solver.value_signal.connect(self.time_saver) self.time_constant.textChanged.connect(self.solver.time_step_change) self.solver.done_signal.connect(self.finished) self.sequence = sequence self.solver.set_sequence(self.sequence) self.solver.solve()
def main(config): os.environ["CUDA_VISIBLE_DEVICES"] = str(config["gpu_no"]) save_path = Path(config["training"]["save_path"]) save_path.mkdir(parents=True, exist_ok=True) mode = config["mode"] solver = Solver(config) if mode == "train": solver.train() if mode == "test": solver.test()
def init_solution(self, data=DataStore()): """ Starts solution for a data set :param data: data store :return: """ self.play_button.setDisabled(False) self.stop_button.setDisabled(False) self.pause_button.setDisabled(False) self.solution_type_combo.setDisabled(False) self.data = data self.model = Solver(self.data) self.simulation.init_image(self.model) self.print_start_data() numbers = {'inbound': self.data.number_of_inbound_trucks, 'outbound': self.data.number_of_outbound_trucks, 'compound': self.data.number_of_compound_trucks, 'receive': self.data.number_of_receiving_doors, 'shipping': self.data.number_of_shipping_doors} self.algorithms.set_algorithms(self.model) self.model.set_data(0)
def __init__(self): super(MainWindow, self).__init__() self.setupUi(self) self.data = DataStore() self.solver_data = SolverData() self.solver = Solver(self.data, self.solver_data) self.update_data_table() self.setup_data() self.value_connections() self.connections() self.combobox_coming_sequence = [] self.combobox_going_sequence = [] self.statusBar().showMessage('Ready') self.load_generated_data() self.results = OrderedDict() self.shoved_solution_name = "" self.shoved_iteration = IterationResults() self.shoved_solution = ModelResult() self.shoved_iteration_number = 0 self.continue_solution = True self.showing_result = [] self.result_times = {} self.function_type = "normal" self.solution_name = "" self.solution_number = 0 self.sequence_solver = SequenceSolver() self.solution_results = dict() self.enter_sequence_widget = EnterSequenceWidget(self.data) self.current_sequence = Sequence() self.load_data() self.simulationStartButton.setEnabled(False) self.simulationStepForwardButton.setEnabled(False) self.result_show_best_solution_button.setEnabled(False) self.result_show_errors_button.setEnabled(False) self.result_show_sequences_button.setEnabled(False) self.result_show_trucktimes_button.setEnabled(False) self.result_show_truckgoods_button.setEnabled(False) self.run_simulation_button.setEnabled(False)
def main(config): os.environ["CUDA_VISIBLE_DEVICES"] = str(config["gpu_no"]) mode = config["mode"] save_path = Path(config["training"]["save_path"]) / config["version"] save_path.mkdir(parents=True, exist_ok=True) config["save_path"] = save_path datasets = DataLoader(mode, **config["dataset"]) solver = Solver(config, datasets) if mode == "train": solver.train() if mode == "test": solver.test()
def solve_one_sequence(self): self.data_set_number = self.data_set_spin_box.value() - 1 self.solution_name = "data_set{0}_simulation_{1}".format(self.data_set_number + 1, len(self.results) + 1) self.results[self.solution_name] = [] self.result_names_combo_box.addItem(self.solution_name) self.data_set_number = self.data_set_spin_box.value() - 1 self.setup_truck_names() self.solver = Solver(self.data_set_number, self.data) self.solver.time_signal.connect(self.time.display) self.solver.value_signal.connect(self.solver_truck_signal) self.solver.value_signal.connect(self.time_saver) self.time_constant.textChanged.connect(self.solver.time_step_change) self.solver.done_signal.connect(self.finished) self.solver.time_step = True self.sequence = Sequence() for box in self.combobox_coming_sequence: self.sequence.coming_sequence.append(box.currentText()) for box in self.combobox_going_sequence: self.sequence.going_sequence.append(box.currentText()) self.graphicsView.reset() self.graphicsView.update_scene() self.solver.set_sequence(self.sequence) self.solver.solve()
parser.add_argument('--raw_data_path', type=str, default='', help="rewrite the data path in config file") paras = parser.parse_args() setattr(paras,'gpu',not paras.cpu) setattr(paras,'verbose',not paras.no_msg) config = yaml.load(open(paras.config,'r')) if paras.data_path != '': config['solver']['data_path'] = paras.data_path if paras.raw_data_path != '': config['solver']['raw_data_path'] = paras.raw_data_path random.seed(paras.seed) np.random.seed(paras.seed) torch.manual_seed(paras.seed) if torch.cuda.is_available(): torch.cuda.manual_seed_all(paras.seed) if not paras.rnnlm: if not paras.test: # Train ASR from src.solver import Trainer as Solver else: # Test ASR from src.solver import Tester as Solver else: # Train RNNLM from src.solver import RNNLM_Trainer as Solver solver = Solver(config,paras) solver.load_data() solver.set_model() solver.exec()
help="the number of orders to parse", type=int, default=2400) parser.add_argument("--process_num", dest="NUM_PROCESSES", help="the number of processes", type=int, default=16) parser.add_argument("--weight_amount", dest="WEIGHT_AMOUNT", help="the weight of the amountCost in the objective function", type=float, default=15) parser.add_argument("--weight_time", dest="WEIGHT_TIME", help="the weight of the timeCost in the objective function", type=float, default=1) parser.add_argument("--hub_cost_const", dest="HUB_BUILT_COST_CONST", help="the constant part of cost of building a hub", type=int, default=3000) parser.add_argument("--hub_cost_vary", dest="HUB_BUILT_COST_VARY", help="the variable part cost of building a hub", type=float, default=2.0) parser.add_argument("--hub_ratio", dest="HUB_UNIT_COST_RATIO", help="the cutoff of unit price of a hub", type=float, default=0.7) parser.add_argument("--hub_capacity", dest="HUB_CAPACITY", help="the capacity of the hub(in prob3)", type=int, default=500) args = parser.parse_args() arg_dict = edict(vars(args)) merge_a_into_b(arg_dict, cfg) print("Using the config:") print(cfg) solver = Solver() evaluator = Evaluator() solver.solve(problem_id=args.PROBLEM_ID) # disable the tune mode but plot the distribution, see the outputs for more detail evaluator.evaluate(prob_id=args.PROBLEM_ID, tune=False, plot=True)
class MainWindow(QWidget): """ Main window with control buttons logger and running output """ def __init__(self): QWidget.__init__(self) self.setWindowTitle("Cross Docking Project") self.data = DataStore() self.set_buttons() self.set_logger() self.set_layout() self.algorithm_list = {"annealing1": Annealing1} self.algorithm_name = "annealing1" self.current_data_set_number = 0 # add these to gui self.number_of_iterations = 200 def set_buttons(self): """ set buttons for the main gui :return: """ self.new_data_set_button = QPushButton("New Data Set") self.new_data_set_button.clicked.connect(self.new_data_set) self.load_data_set_button = QPushButton("Load Data Set") self.load_data_set_button.clicked.connect(self.load_data) self.save_data_set_button = QPushButton("Save Data Set") self.save_data_set_button.clicked.connect(self.save_data) self.truck_data_button = QPushButton("Truck Data") self.truck_data_button.clicked.connect(self.show_truck_data_window) self.system_data_button = QPushButton("System Data") self.system_data_button.clicked.connect(self.show_data_set_window) self.algorithm_data_button = QPushButton("Algorithm Data") self.generate_data_set_button = QPushButton("Generate Data Set") self.generate_data_set_button.clicked.connect(self.generate_data_set) self.show_data_button = QPushButton("Show Data Set") self.show_data_button.clicked.connect(self.show_data_window) self.print_gams_button = QPushButton("Print gams output") self.print_gams_button.clicked.connect(self.print_gams) self.data_set_ready_button = QPushButton("Setup Data Set") self.data_set_ready_button.clicked.connect(self.setup_data_set) self.solve_step_button = QPushButton("Solve Next Step") self.solve_step_button.clicked.connect(self.solve_step) self.solve_step_button.setEnabled(False) self.solve_iteration_button = QPushButton("Solve Next Iteration") self.solve_iteration_button.clicked.connect(self.solve_iteration) self.solve_iteration_button.setEnabled(False) self.solve_data_set_button = QPushButton("Solve Data Set") self.solve_data_set_button.setEnabled(False) self.solve_data_set_button.clicked.connect(self.solve_data_set) self.solve_sequence_button = QPushButton("Solve a given sequence") self.solve_data_set_button.setEnabled(True) self.solve_sequence_button.clicked.connect(self.solve_sequence) self.show_solution_button = QPushButton("Show Best Solution") self.show_solution_button.setEnabled(False) self.show_solution_button.clicked.connect(self.show_solution) self.show_sequences_button = QPushButton("Show Sequences") self.show_sequences_button.setEnabled(False) self.show_sequences_button.clicked.connect(self.show_sequences) self.show_logger_button = QPushButton("Show Logger") self.show_simulation_button = QPushButton("Show Simulation") self.show_data_table = QPushButton("Show Run Time Data Table") self.debug_check = QCheckBox("Debug Mode") self.debug_check.stateChanged.connect(self.set_logger_output) self.data_set_number = QSpinBox() self.data_set_number.setMinimum(1) self.data_set_number.valueChanged.connect(self.set_data_set_number) def set_logger(self): """ setup logger with info output and a channel forward to screen output :return: """ self.logger = LogData() self.logger_root = logging.getLogger() self.logger_root.setLevel(logging.INFO) self.logger_ch = logging.StreamHandler(self.logger) self.logger_ch.setLevel(logging.INFO) self.logger_root.addHandler(self.logger_ch) def set_layout(self): """ set layout of the main screen :return: """ self.data_set_layout = QGridLayout() self.data_set_layout.addWidget(self.new_data_set_button, 1, 1) self.data_set_layout.addWidget(self.load_data_set_button, 1, 2) self.data_set_layout.addWidget(self.save_data_set_button, 1, 3) self.data_set_layout.addWidget(self.debug_check, 1, 4) self.data_set_layout.addWidget(self.truck_data_button, 2, 1) self.data_set_layout.addWidget(self.system_data_button, 2, 2) self.data_set_layout.addWidget(self.algorithm_data_button, 2, 3) self.data_set_layout.addWidget(self.generate_data_set_button, 3, 1) self.data_set_layout.addWidget(self.show_data_button, 3, 2) self.data_set_layout.addWidget(self.print_gams_button, 3, 3) self.data_set_layout.addWidget(self.data_set_ready_button, 4, 1) self.data_set_layout.addWidget(self.data_set_number, 4, 2) self.solver_layout = QGridLayout() self.solver_layout.addWidget(self.solve_step_button, 1, 1) self.solver_layout.addWidget(self.solve_iteration_button, 1, 2) self.solver_layout.addWidget(self.solve_data_set_button, 1, 3) self.solver_layout.addWidget(self.solve_sequence_button, 1, 4) self.solver_layout.addWidget(self.show_solution_button, 2, 1) self.interaction_layout = QGridLayout() self.interaction_layout.addWidget(self.show_logger_button, 1, 1) self.interaction_layout.addWidget(self.show_simulation_button, 1, 3) self.interaction_layout.addWidget(self.show_data_table, 1, 4) self.button_layout = QVBoxLayout() self.button_layout.addLayout(self.data_set_layout) self.button_layout.addLayout(self.solver_layout) # self.button_layout.addLayout(self.interaction_layout) self.layout = QGridLayout() self.layout.addLayout(self.button_layout, 1, 1) self.layout.addWidget(self.logger, 1, 2) self.setLayout(self.layout) def set_logger_output(self, state): """ setup logger output between info and debug depending on the check box on main screen :param state: :return: """ if state == Qt.Checked: self.logger_root.setLevel(logging.DEBUG) self.logger_ch.setLevel(logging.DEBUG) logging.info("Debug Mode") else: self.logger_root.setLevel(logging.INFO) self.logger_ch.setLevel(logging.INFO) logging.info("Normal Mode") def new_data_set(self): """ new data set """ self.data = DataStore() logging.debug("New Data Set") def load_data(self): """ loads prev saved data :return: """ file_name, _ = QFileDialog.getOpenFileName(self, "Open file", "/home") try: self.data = pickle.load(open(file_name, "rb")) logging.info("Loaded file: {0}".format(file_name)) except Exception as e: logging.info(e) def save_data(self): """ saves current data :return: """ file_name, _ = QFileDialog.getSaveFileName(self, "Save file", "/home") try: pickle.dump(self.data, open(file_name, "wb")) logging.info("Saved to file: {0}".format(file_name)) except Exception as e: logging.info(e) def show_truck_data_window(self): self.truck_data_window = TruckDataWindow(self.data) self.truck_data_window.exec_() def show_data_set_window(self): self.data_set_window = DataSetWindow(self.data) self.data_set_window.exec_() def show_data_window(self): self.data_window = ShowData(self.data) self.data_window.exec_() def generate_data_set(self): # ask if sure self.data.arrival_times = [] self.data.boundaries = [] self.model = Solver(self.data) for i in range(len(self.data.data_set_list)): self.model.current_data_set = i self.model.set_data() def print_gams(self): file_name, _ = QFileDialog.getSaveFileName(self, "Open file", "/home") for i in range(len(self.data.data_set_list)): gams_writer(file_name + str(i), i, self.data) def set_data_set_number(self): self.current_data_set_number = self.data_set_number.value() - 1 def setup_data_set(self): # setup for one data set self.model = Solver(self.data) self.model.current_data_set = self.current_data_set_number self.model.load_data_set() self.algorithm = self.algorithm_list[self.algorithm_name]( self.number_of_iterations, self.current_data_set_number, self.model, self.data ) logging.info("Solving using {0} data set {1}".format(self.algorithm_name, self.current_data_set_number + 1)) logging.info("Nuber of iterations {0}".format(self.number_of_iterations)) self.solve_step_button.setEnabled(True) self.solve_iteration_button.setEnabled(True) self.solve_data_set_button.setEnabled(True) self.solve_sequence_button.setEnabled(True) self.show_solution_button.setEnabled(True) self.show_sequences_button.setEnabled(True) def solve_step(self): self.algorithm.step_mode = True self.algorithm.solve() def solve_iteration(self): self.algorithm.step_mode = False self.algorithm.solve() def solve_data_set(self): self.algorithm.solve_data_set() def solve_sequence(self): logging.info("--------------------Solving one sequence---------------------------------") self.set_sequence = SetSequence(self.data) self.set_sequence.exec_() sequence = self.set_sequence.set_sequence() sequence.print_sequence() self.one_time_model = Solver(self.data) self.one_time_model.current_data_set = self.current_data_set_number self.one_time_model.load_data_set() self.one_time_model.set_sequence(sequence) while not self.one_time_model.finish: self.one_time_model.next_step() total_error = 0 for truck in itertools.chain( self.one_time_model.outbound_trucks.values(), self.one_time_model.compound_trucks.values() ): truck.calculate_error() logging.info("Truck {0}, error {1}\n".format(truck.truck_name, truck.error)) total_error += abs(truck.error) logging.info("Error: {0}\n".format(total_error)) def show_solution(self): pass def show_sequences(self): pass
import sys from src.solver import Solver from src.parsing import parse lines = [] for line in sys.stdin: lines.append(line.rstrip('\n')) matrix = parse() solver = Solver(matrix) # print(matrix) # print(solver.is_solved(matrix)) # print(solver.manhattan_distance(matrix)) print(solver.solve(matrix))
from src.solver import Solver for i in range(2, 42): runner = Solver() print("========================================================") print(i.__str__() + "begin :: ") runner.run("../dataset/raw_datas/g" + i.__str__())
for net in range(1000): # counter printer print "iteration: ", net # train net1 model1 = FullyConnectedNet([100, 100], weight_scale=0.003, use_batchnorm=False, reg=0.6) solver1 = Solver( model1, data1, print_every=data1['X_train'].shape[0], num_epochs=50, batch_size=100, update_rule='sgd', optim_config={ 'learning_rate': 0.03, }, verbose=False, lr_decay=0.9, ) solver1.train() pass #train net2 model2 = FullyConnectedNet([100, 100], weight_scale=0.003, use_batchnorm=False, reg=0.6) solver2 = Solver( model2,
class MainWindow(QWidget): """ Main window class for capraz_sevkiyat project """ def __init__(self): QWidget.__init__(self) self.model = None self.setWindowTitle("Capraz Sevkiyat Projesi") self.setGeometry(400,400,400,400) self.set_buttons() self.set_layout() self.truck_image_list = {} self.truckDataWindow = None self.data = DataStore() self.model = None self.current_iteration = 1 self.iteration_limit = 100 self.current_data_set = 0 self.algorithms = None self.solution_choice = None self.scn = QGraphicsScene() self.simulation = GraphView(self.scn) def set_buttons(self): self.new_data_set_button = QPushButton('New Data Set') self.load_data_set_button = QPushButton('Load Data Set') self.save_data_set_button = QPushButton('Save Data Set') self.truck_data_button = QPushButton('Truck Data') self.system_data_button = QPushButton('System Data') self.algorithm_data_button = QPushButton('Algorithm Data') self.generate_data_set_button = QPushButton('Generate Data Set') self.show_data_button = QPushButton('Show Data Set') self.print_gams_button = QPushButton('Print gams output') self.data_set_ready_button = QPushButton('Data Set Ready') self.solve_step_button = QPushButton('Solve Next Step') self.solve_iteration_button = QPushButton('Solve Next Iteration') self.solve_next_data_set_button = QPushButton('Solve Next Data Set') self.show_debug_logger_button = QPushButton('Show Debug Logger') self.show_logger_button = QPushButton('Show Logger') self.show_simulation_button = QPushButton('Show Simulation') self.show_data_table = QPushButton('Show Run Time Data Table') self.data_set_number = QSpinBox() self.data_set_number.setMinimum(0) self.new_data_set_button.clicked.connect(self.new_data_set) self.load_data_set_button.clicked.connect(self.load_data) self.save_data_set_button.clicked.connect(self.save_data) self.truck_data_button.clicked.connect(self.show_truck_data) self.system_data_button.clicked.connect(self.show_system_data) self.algorithm_data_button.clicked.connect(self.show_algorithm_data) self.generate_data_set_button.clicked.connect(self.generate_data_set) self.show_data_button.clicked.connect(self.show_data) self.print_gams_button.clicked.connect(self.print_gams) self.data_set_ready_button.clicked.connect(self.data_set_ready) self.show_logger_button.clicked.connect(self.show_logger) self.show_data_table.clicked.connect(self.show_runtime_table) self.solve_next_data_set_button.clicked.connect(self.data_set_button) self.solve_iteration_button.clicked.connect(self.iteration_button) self.solve_step_button.clicked.connect(self.step_button) self.data_set_number.valueChanged.connect(self.set_data_set_number) def set_layout(self): self.data_set_layout = QGridLayout() self.data_set_layout.addWidget(self.new_data_set_button, 1 ,1) self.data_set_layout.addWidget(self.load_data_set_button, 1 ,2) self.data_set_layout.addWidget(self.save_data_set_button, 1 ,3) self.data_set_layout.addWidget(self.truck_data_button, 2 ,1) self.data_set_layout.addWidget(self.system_data_button, 2 ,2) self.data_set_layout.addWidget(self.algorithm_data_button, 2 ,3) self.data_set_layout.addWidget(self.generate_data_set_button, 3, 1) self.data_set_layout.addWidget(self.show_data_button, 3, 2) self.data_set_layout.addWidget(self.print_gams_button, 3, 3) self.data_set_layout.addWidget(self.data_set_ready_button, 4, 1) self.solver_layout = QGridLayout() self.solver_layout.addWidget(self.solve_step_button, 1, 1) self.solver_layout.addWidget(self.solve_iteration_button, 1, 2) self.solver_layout.addWidget(self.solve_next_data_set_button, 1, 3) self.solver_layout.addWidget(self.data_set_number, 1, 4) self.interaction_layout = QGridLayout() self.interaction_layout.addWidget(self.show_logger_button, 1, 1) self.interaction_layout.addWidget(self.show_debug_logger_button, 1, 2) self.interaction_layout.addWidget(self.show_simulation_button, 1, 3) self.interaction_layout.addWidget(self.show_data_table, 1, 4) self.layout = QVBoxLayout() self.layout.addLayout(self.data_set_layout) self.layout.addLayout(self.solver_layout) self.layout.addLayout(self.interaction_layout) self.setLayout(self.layout) self.pause_bool = False def new_data_set(self): """ :return: """ self.data = DataStore() def load_data(self): """ loads prev saved data :return: """ file_name, _ = QFileDialog.getOpenFileName(self, 'Open file', '/home') self.data = pickle.load(open(file_name, 'rb')) def save_data(self): """ saves current data :return: """ file_name, _ = QFileDialog.getSaveFileName(self, 'Save file', '/home') pickle.dump(self.data, open(file_name, 'wb')) def generate_data_set(self): # ask if sure self.data.arrival_times = [] self.data.boundaries = [] self.model = Solver(self.data) for i in range(len(self.data.data_set_list)): self.model.current_data_set = i self.model.set_data() def show_data(self): self.data_show = ShowData(self.data) self.data_show.exec_() def print_gams(self): file_name, _ = QFileDialog.getSaveFileName(self, 'Open file', '/home') for i in range(len(self.data.data_set_list)): gams_writer(file_name + str(i), i, self.data ) def show_truck_data(self): """ shows data about the trucks :return: """ self.truckDataWindow = TruckDataWindow(self.data) self.truckDataWindow.exec_() def show_system_data(self): """ shows data set :return: """ self.dataWindow = DataSetWindow(self.data) self.dataWindow.exec_() def show_algorithm_data(self): pass def data_set_ready(self): #enable solve buttons self.algorithms = Algorithms() self.model = Solver(self.data) self.model.current_data_set = self.current_data_set self.model.load_data_set() self.algorithms.set_algorithms(self.model) self.current_iteration = 1 self.iteration_limit = 100 self.simulation.init_image(self.model) self.simulation.show() def show_logger(self): self.logger = LogData() root = logging.getLogger() root.setLevel(logging.INFO) ch = logging.StreamHandler(self.logger) ch.setLevel(logging.INFO) formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s') ch.setFormatter(formatter) root.addHandler(ch) self.logger.show() logging.info('Logger Started') def data_set_button(self): self.solution_choice = 'data_set' self.solution_type_choice() self.solve_dataset() def iteration_button(self): self.solution_choice = 'iteration' self.solution_type_choice() self.solve_dataset() def step_button(self): self.solution_choice = 'step' self.solution_type_choice() self.solve_dataset() def set_data_set_number(self): self.current_data_set = self.data_set_number.value() def solve_dataset(self): """ solves one data set :return: """ logging.info('Data Set Number: {0}'.format(self.current_data_set)) self.model.current_data_set = self.current_data_set if self.data_set_bool: #print('one_set')1 if self.current_iteration == 1 and self.model.current_time == 0: self.model.load_data_set() self.solve_iteration() if self.current_data_set == len(self.data.data_set_list): # print('finish') self.current_iteration = 1 self.current_data_set = 0 self.trial_time = 0 else: while self.current_data_set < len(self.data.data_set_list): if self.pause_bool: break self.model.load_data_set() self.solve_iteration() # print(self.current_data_set) self.current_data_set = 0 def show_runtime_table(self): """ shows data table of the :return: """ self.runtime_table = TruckDataTable(self.algorithms, self.model) self.runtime_table.show() def solve_iteration(self): """ solves one iteration :return: """ if self.iteration_bool: if self.model.current_time == 0: if self.current_iteration == 1: self.algorithms.start() self.model.set_sequence(self.algorithms.solution_sequence) self.solve_whole_step() self.model.reset() self.algorithms.next() self.model.set_sequence(self.algorithms.solution_sequence) else: self.algorithms.next() self.model.set_sequence(self.algorithms.solution_sequence) self.solve_step() if self.current_iteration == self.iteration_limit: self.log_results() self.current_iteration = 1 else: while self.current_iteration < self.iteration_limit: if self.pause_bool: break if self.model.current_time == 0: if self.current_iteration == 1: self.algorithms.start() else: self.algorithms.next() self.model.set_sequence(self.algorithms.solution_sequence) # next sequence self.solve_step() self.current_iteration = 1 self.log_results() def solve_step(self): if self.step_bool: self.solve_one_step() else: self.solve_whole_step() def solve_whole_step(self): """ solves one iterations :return: """ while not self.model.finish: # if self.model.current_time > 800: # # break if self.pause_bool: break self.model.next_step() #finished for truck in itertools.chain(self.model.outbound_trucks.values(), self.model.compound_trucks.values()): truck.calculate_error() if self.runtime_table: self.runtime_table.update_tables() self.runtime_table.activateWindow() #add reset self.model.finish = False self.algorithms.solution_sequence['error'] = self.add_errors() self.model.reset() if self.current_iteration > 1: self.algorithms.calculate() self.current_iteration += 1 def solve_one_step(self): """ goes one time step forward :return: """ self.model.next_step() self.simulation.update_image() if self.runtime_table: self.runtime_table.update_tables() self.runtime_table.activateWindow() if self.model.finish: #finished for truck in self.model.outbound_trucks.values(): truck.calculate_error() self.model.reset() # add reset self.add_errors() self.current_iteration += 1 self.model.finish = False self.algorithms.solution_sequence['error'] = self.add_errors() self.algorithms.calculate() def add_errors(self): """ adds absolute values of the errors :return: """ total_error = 0 for truck in itertools.chain(self.model.outbound_trucks.values(), self.model.compound_trucks.values()): total_error += abs(truck.error) logging.info("Error: {0}\n".format(total_error)) return total_error def simulation_cycle(self): i = 0 for inbound_trucks in self.model.inbound_trucks.values(): truck_name = inbound_trucks.truck_name self.truck_image_list[truck_name] = self.scn.addPixmap(self.truckPixmap) self.truck_image_list[truck_name].scale(0.2,0.2) self.truck_image_list[truck_name].setPos(-600,i*100) i = i +1 self.simulation.show() def solution_type_choice(self): """ update bools for the choosen solution type :return: """ if self.solution_choice == 'solve': self.solve_bool = True self.data_set_bool = False self.iteration_bool = False self.step_bool = False elif self.solution_choice == 'data_set': self.solve_bool = True self.data_set_bool = True self.iteration_bool = False self.step_bool = False self.data_set_ready() elif self.solution_choice == 'iteration': self.solve_bool = True self.data_set_bool = True self.iteration_bool = True self.step_bool = False elif self.solution_choice == 'step': self.solve_bool = True self.data_set_bool = True self.iteration_bool = True self.step_bool = True def print_simulation_data(self): logging.info("Iteration Number: {0}\n".format(self.current_iteration)) logging.info("Inbound Sequence: {0}\n".format(self.algorithms.solution_sequence['inbound'])) logging.info("Outbound Sequence: {0}\n".format(self.algorithms.solution_sequence['outbound'])) logging.info("Error value: {0}\n".format(self.algorithms.solution_sequence['error'])) def log_results(self): logging.info("Best result:") logging.info("Inbound Sequence: {0}\n".format(self.algorithms.best_sequence['inbound'])) logging.info("Outbound Sequence: {0}\n".format(self.algorithms.best_sequence['outbound'])) logging.info("Error value: {0}\n".format(self.algorithms.best_sequence['error']))
class GeneralInfo(QWidget): """ General information screen in main gui """ def __init__(self, status_bar): """ init text screen for info :return: """ QWidget.__init__(self) self.data = None self.infoText = QTextEdit() self.infoText.setReadOnly(True) self.scn = QGraphicsScene() self.simulation = GraphView(self.scn) self.status_bar = status_bar # solution types self.solution_list = {} self.solution_list['iteration'] = self.solve_iteration self.solution_list['step'] = self.solve_step self.solution_list['data_set'] = self.solve_dataset self.solution_list['solve'] = self.solve self.solution_type = 'iteration' # cycle booleans self.solve_bool = False self.step_bool = False self.iteration_bool = False self.data_set_bool = False self.pause_bool = False # buttons self.play_button = QPushButton("Play") self.play_button.setIcon(self.style().standardIcon(QStyle.SP_MediaPlay)) self.stop_button = QPushButton("Stop") self.stop_button.setIcon(self.style().standardIcon(QStyle.SP_MediaStop)) self.pause_button = QPushButton("Pause") self.pause_button.setIcon(self.style().standardIcon(QStyle.SP_MediaPause)) self.solution_type_combo = QComboBox() self.solution_type_combo.addItems(self.solution_list.keys()) self.new_data_set_button = QPushButton("New Data Set") self.play_button.setDisabled(True) self.stop_button.setDisabled(True) self.pause_button.setDisabled(True) self.solution_type_combo.setDisabled(True) self.play_button.clicked.connect(self.solve) self.pause_button.clicked.connect(self.pause) # setup layout self.layout = QGridLayout() self.data_set_layout = QGridLayout() self.data_set_layout.addWidget(self.new_data_set_button) self.layout.addLayout(self.data_set_layout, 1,1) # self.layout.addWidget(self.infoText, 1, 1, 1) # self.layout.addWidget(self.simulation, 1, 2) self.h_layout = QHBoxLayout() self.h_layout.addWidget(self.play_button) self.h_layout.addWidget(self.stop_button) self.h_layout.addWidget(self.pause_button) self.h_layout.addWidget(self.solution_type_combo) self.layout.addLayout(self.h_layout, 2, 1) # self.layout.addWidget(self.simulation, 1, 2) self.setLayout(self.layout) self.model = None self.data = DataStore() self.current_iteration = 1 self.iteration_limit = 100 self.current_data_set = 0 self.data_string = '' self.algorithms = Algorithms() self.algo_screen = ChooseAlgo() self.trial_time = 0 def init_solution(self, data=DataStore()): """ Starts solution for a data set :param data: data store :return: """ self.play_button.setDisabled(False) self.stop_button.setDisabled(False) self.pause_button.setDisabled(False) self.solution_type_combo.setDisabled(False) self.data = data self.model = Solver(self.data) self.simulation.init_image(self.model) self.print_start_data() numbers = {'inbound': self.data.number_of_inbound_trucks, 'outbound': self.data.number_of_outbound_trucks, 'compound': self.data.number_of_compound_trucks, 'receive': self.data.number_of_receiving_doors, 'shipping': self.data.number_of_shipping_doors} self.algorithms.set_algorithms(self.model) self.model.set_data(0) def solution_type_choice(self): """ update bools for the choosen solution type :return: """ choice = self.solution_type_combo.currentText() if choice == 'solve': self.solve_bool = True self.data_set_bool = False self.iteration_bool = False self.step_bool = False elif choice == 'data_set': self.solve_bool = True self.data_set_bool = True self.iteration_bool = False self.step_bool = False elif choice == 'iteration': self.solve_bool = True self.data_set_bool = True self.iteration_bool = True self.step_bool = False elif choice == 'step': self.solve_bool = True self.data_set_bool = True self.iteration_bool = True self.step_bool = True def choose_algorithm(self): """ choose and algorithm :return: """ self.algo_screen.exec_() self.iteration_limit = self.algo_screen.iteration_number #get algorithm def pause(self): self.pause_bool = True def solve(self): """ solves all of the data sets :return: """ self.pause_bool = False self.solution_type_choice() # print('solve') self.solve_dataset() def solve_dataset(self): """ solves one data set :return: """ if self.data_set_bool: #print('one_set')1 if self.current_iteration == 1 and self.model.current_time == 0: self.model.set_data(self.current_data_set) self.solve_iteration() if self.current_data_set == len(self.data.data_set_list): # print('finish') self.current_iteration = 1 self.current_data_set = 0 self.trial_time = 0 else: while self.current_data_set < len(self.data.data_set_list): if self.pause_bool: break self.model.set_data(self.current_data_set) self.solve_iteration() self.current_data_set += 1 # print(self.current_data_set) self.current_data_set = 0 def solve_iteration(self): """ solves one iteration :return: """ if self.iteration_bool: #print('one_iteration') if self.model.current_time == 0: if self.current_iteration == 1: print('start') self.algorithms.start() self.model.set_sequence(self.algorithms.solution_sequence) self.solve_whole_step() self.algorithms.next() self.model.set_sequence(self.algorithms.solution_sequence) else: self.algorithms.next() self.model.set_sequence(self.algorithms.solution_sequence) self.print_simulation_data() self.solve_step() if self.current_iteration == self.iteration_limit: self.current_data_set += 1 self.current_iteration = 1 else: while self.current_iteration < self.iteration_limit: if self.pause_bool: break self.print_simulation_data() if self.model.current_time == 0: if self.current_iteration == 1: self.algorithms.start() else: self.algorithms.next_sequence() self.model.set_sequence(self.algorithms.solution_sequence) # next sequence self.solve_step() self.current_iteration += 1 #print(self.current_iteration) self.current_iteration = 1 #print('whole_iteration') def solve_step(self): if self.step_bool: self.solve_one_step() else: self.solve_whole_step() def solve_whole_step(self): """ solves one iterations :return: """ while not self.model.finish: if self.model.current_time > 800: print('time limit') break if self.pause_bool: break self.model.next_step() #finished for truck in itertools.chain(self.model.outbound_trucks.values(), self.model.compound_trucks.values()): truck.calculate_error() #add reset self.model.finish = False self.algorithms.solution_sequence['error'] = self.add_errors() self.model.reset_trucks() if self.current_iteration > 1: self.algorithms.calculate() self.current_iteration += 1 #self.print_results() def solve_one_step(self): """ goes one time step forward :return: """ self.model.next_step() self.simulation.update_image() if self.model.finish: #finished for truck in self.model.outbound_trucks.values(): truck.calculate_error() self.model.reset_trucks() # add reset self.add_errors() #self.print_results() self.current_iteration += 1 self.model.finish = False self.algorithms.current_sequence['error'] = self.add_errors() self.algorithms.calculate() def add_errors(self): """ adds absolute values of the errors :return: """ total_error = 0 for truck in itertools.chain(self.model.outbound_trucks.values(), self.model.compound_trucks.values()): total_error += abs(truck.error) print('total error', total_error) return total_error def print_start_data(self): """ prints the configuration info one time :return: """ self.infoText.clear() self.data_string = '' self.data_string += "Number of inbound Trucks: {0}\n".format(self.data.number_of_inbound_trucks) self.data_string += "Number of outbound Trucks: {0}\n".format(self.data.number_of_outbound_trucks) self.data_string += "Number of compound Trucks: {0}\n".format(self.data.number_of_compound_trucks) self.data_string += "Number of receiving doors: {0}\n".format(self.data.number_of_receiving_doors) self.data_string += "Number of shipping doors: {0}\n".format(self.data.number_of_shipping_doors) # # data set self.infoText.setText(self.data_string) def step_time(self): pass def next_iteration(self): """ increase iteration if limit not reached :return: """ if self.current_iteration < self.iteration_limit: self.current_iteration += 1 else: self.current_iteration = 0 self.next_data_set() def next_data_set(self): pass def print_simulation_data(self): self.infoText.clear() self.data_string = '' self.data_string += "Iteration Number: {0}\n".format(self.current_iteration) self.data_string += "Inbound Sequence: {0}\n".format(self.algorithms.solution_sequence['inbound']) self.data_string += "Outbound Sequence: {0}\n".format(self.algorithms.solution_sequence['outbound']) # time # data set number # error value # sequence self.infoText.setText(self.data_string) def print_results(self): self.infoText.clear() for truck in self.model.outbound_trucks.values(): print('bounds', truck.bounds) print('error', truck.error) print('finish', truck.finish_time)
class MainWindow(QMainWindow, Ui_MainWindow): def __init__(self): super(MainWindow, self).__init__() self.setupUi(self) self.data = DataStore() self.truck_states = {} self.update_data_table() self.number_of_iterations = 100 self.setup_data() self.connections() self.results = {} self.combobox_coming_sequence = [] self.combobox_going_sequence = [] self.statusBar().showMessage("Ready") self.setup_sequence_solver() self.load_generated_data() self.graphicsView.data = self.data self.setup_simulator() self.graphicsView.parent = self self.showing_result = [] self.result_times = {} self.function_type = "normal" def setup_data(self): self.data_set_model = DataSetModel(self.data) self.datasettable.setModel(self.data_set_model) self.inbound_table_model = GoodTableModel( self.data.number_of_inbound_trucks, self.data.number_of_goods, self.data.inbound_goods, "inbound" ) self.inbound_good_table.setModel(self.inbound_table_model) self.outbound_table_model = GoodTableModel( self.data.number_of_outbound_trucks, self.data.number_of_goods, self.data.outbound_goods, "outbound" ) self.outbound_good_table.setModel(self.outbound_table_model) self.compound_coming_table_model = GoodTableModel( self.data.number_of_compound_trucks, self.data.number_of_goods, self.data.compound_coming_goods, "compound_coming", ) self.compound_coming_good_table.setModel(self.compound_coming_table_model) self.compound_going_table_model = GoodTableModel( self.data.number_of_compound_trucks, self.data.number_of_goods, self.data.compound_going_goods, "compound_going", ) self.compound_going_good_table.setModel(self.compound_going_table_model) self.numberOfIterationsLineEdit.setText(str(self.number_of_iterations)) def generate_times(self): self.data.arrival_times = [] self.data.lower_boundaries = [] self.data.upper_boundaries = [] for k, data_set in enumerate(self.data.data_sets): self.data.arrival_times.append({}) self.data.lower_boundaries.append({}) self.data.upper_boundaries.append({}) self.data.calculate_truck_related_data() for i in range(self.data.number_of_inbound_trucks): name = "inbound" + str(i) two_gdj = self.calculate_2dgj(data_set[2], self.data.coming_mu, self.data.product_per_coming_truck) self.data.arrival_times[k][name] = int(uniform(self.data.inbound_arrival_time, two_gdj)) for i in range(self.data.number_of_outbound_trucks): name = "outbound" + str(i) two_gdj = self.calculate_2dgj(data_set[2], self.data.going_mu, self.data.product_per_going_truck) gdj = int(uniform(self.data.outbound_arrival_time, two_gdj)) self.data.arrival_times[k][name] = gdj A = ( gdj + (self.data.going_mu - 1) * self.data.changeover_time + self.data.going_mu * self.data.product_per_going_truck * self.data.loading_time ) self.data.lower_boundaries[k][name] = int(A * data_set[0]) self.data.upper_boundaries[k][name] = int(A * data_set[1]) for i in range(self.data.number_of_compound_trucks): name = "compound" + str(i) two_gdj = self.calculate_2dgj(data_set[2], self.data.coming_mu, self.data.product_per_coming_truck) gdj = int(uniform(self.data.outbound_arrival_time, two_gdj)) self.data.arrival_times[k][name] = gdj # A = gdj + (self.data.going_mu - 1) * self.data.changeover_time + self.data.going_mu * self.data.product_per_going_truck * self.data.loading_time A = ( gdj + (self.data.coming_mu - 1) * self.data.changeover_time + self.data.coming_mu * self.data.product_per_coming_truck * self.data.loading_time + self.data.changeover_time + self.data.truck_transfer_time + (self.data.going_mu - 1) * self.data.changeover_time + self.data.going_mu * self.data.product_per_going_truck * self.data.loading_time ) self.data.lower_boundaries[k][name] = int(A * data_set[0]) self.data.upper_boundaries[k][name] = int(A * data_set[1]) self.load_generated_data() def new_generate_times(self): self.data.arrival_times = [] self.data.lower_boundaries = [] self.data.upper_boundaries = [] for k, data_set in enumerate(self.data.data_sets): self.data.arrival_times.append({}) self.data.lower_boundaries.append({}) self.data.upper_boundaries.append({}) self.data.calculate_truck_related_data() for i in range(self.data.number_of_inbound_trucks): name = "inbound" + str(i) two_gdj = self.calculate_2dgj(data_set[2], self.data.coming_mu, self.data.product_per_coming_truck) self.data.arrival_times[k][name] = int(uniform(self.data.inbound_arrival_time, two_gdj)) for i in range(self.data.number_of_outbound_trucks): name = "outbound" + str(i) two_gdj = self.calculate_2dgj(data_set[2], self.data.going_mu, self.data.product_per_going_truck) gdj = int(uniform(self.data.outbound_arrival_time, two_gdj)) self.data.arrival_times[k][name] = gdj A = ( self.data.product_per_coming_truck * self.data.unloading_time + gdj + self.data.product_per_going_truck * self.data.loading_time ) self.data.lower_boundaries[k][name] = int(A * data_set[0]) self.data.upper_boundaries[k][name] = int(A * data_set[1]) for i in range(self.data.number_of_compound_trucks): name = "compound" + str(i) two_gdj = self.calculate_2dgj(data_set[2], self.data.coming_mu, self.data.product_per_coming_truck) gdj = int(uniform(self.data.outbound_arrival_time, two_gdj)) self.data.arrival_times[k][name] = gdj A = ( self.data.product_per_coming_truck * self.data.unloading_time + gdj + self.data.product_per_going_truck * self.data.loading_time ) self.data.lower_boundaries[k][name] = int(A * data_set[0]) self.data.upper_boundaries[k][name] = int(A * data_set[1]) self.load_generated_data() def load_generated_data(self): self.arrival_time_table_model = TimeTableModel(self.data.arrival_times) self.arrival_time_table.setModel(self.arrival_time_table_model) self.leaving_lower_table_model = TimeTableModel(self.data.lower_boundaries) self.leaving_lower_table.setModel(self.leaving_lower_table_model) self.leaving_upper_table_model = TimeTableModel(self.data.upper_boundaries) self.leaving_upper_table.setModel(self.leaving_upper_table_model) def calculate_2dgj(self, tightness_factor, mu, product_per_truck): return (2 * mu * tightness_factor * product_per_truck) / (2 - tightness_factor * mu * self.data.makespan_factor) def connections(self): """ create connections from buttons to functions :return: """ self.value_connections() self.numberOfInboundTrucksSpinBox.valueChanged.connect(self.set_inbound_truck_number) self.numberOfOutboundTrucksSpinBox.valueChanged.connect(self.set_outbound_truck_number) self.numberOfCompoundTrucksSpinBox.valueChanged.connect(self.set_compound_truck_number) self.numberOfCompoundTrucksSpinBox.valueChanged.connect(self.set_compound_truck_number) self.numberOfShippingDoorsSpinBox.valueChanged.connect(self.set_shipping_door_number) self.numberOfReceivingDoorsSpinBox.valueChanged.connect(self.set_receiving_door_number) self.numberOfGoodsSpinBox.valueChanged.connect(self.update_number_of_goods) self.print_gams.clicked.connect(self.gams_output) self.stop_data_set_solve_button.clicked.connect(self.stop) self.solve_data_set_button.clicked.connect(self.solve_data_set) self.solve_one_sequence_button.clicked.connect(self.solve_one_sequence) self.actionNew_Data.triggered.connect(self.new_data) self.actionSave_Data.triggered.connect(self.save_data) self.actionLoad_Data.triggered.connect(self.load_data) self.pause_button.clicked.connect(self.pause) self.resume_button.clicked.connect(self.resume) self.generate_times_button.clicked.connect(self.generate_times) self.generate_new_boundaries_button.clicked.connect(self.new_generate_times) self.stop_button.clicked.connect(self.finished) self.result_names_combo_box.currentTextChanged.connect(self.change_result_name) self.show_results_button.clicked.connect(self.show_results) def new_data(self): self.data = DataStore() self.update_data_table() self.value_connections() self.setup_data() def value_connections(self): self.numberOfDataSetsSpinBox.valueChanged.connect(self.set_data_set_table) self.loadingTumeLineEdit.textChanged.connect(self.data.set_loading_time) self.unloading_time_edit.textChanged.connect(self.data.set_unloading_time) self.truckChangeoverTimeLineEdit.textChanged.connect(self.data.set_changeover_time) self.effectOfTheArrivalTimesOnMakespanLineEdit.textChanged.connect(self.data.set_makespan_factor) self.truckTransferTimeLineEdit.textChanged.connect(self.data.set_truck_transfer_time) self.inboundArrivalTimeLineEdit.textChanged.connect(self.data.set_inbound_arrival_time) self.outboundArrivalTimeLineEdit.textChanged.connect(self.data.set_outbound_arrival_time) self.goodTransferTimeLineEdit.textChanged.connect(self.data.set_good_transfer_time) def set_inbound_truck_number(self, value): self.inbound_table_model.truck_number(value) self.data.number_of_inbound_trucks = value self.data.update_truck_numbers() self.setup_sequence_solver() def set_outbound_truck_number(self, value): self.outbound_table_model.truck_number(value) self.data.number_of_outbound_trucks = value self.data.update_truck_numbers() self.setup_sequence_solver() def set_compound_truck_number(self, value): self.compound_coming_table_model.truck_number(value) self.compound_going_table_model.truck_number(value) self.data.number_of_compound_trucks = value self.data.update_truck_numbers() self.setup_sequence_solver() def set_receiving_door_number(self, value): self.data.set_receiving_door_number(value) self.setup_sequence_solver() self.setup_simulator() def set_shipping_door_number(self, value): self.data.set_shipping_door_number(value) self.setup_sequence_solver() self.setup_simulator() def update_data_table(self): """ update table values :return: """ self.loadingTumeLineEdit.setText(str(self.data.loading_time)) try: self.unloading_time_edit.setText(str(self.data.unloading_time)) except: self.unloading_time_edit.setText(str(0)) self.data.unloading_time = 0 self.truckChangeoverTimeLineEdit.setText(str(self.data.changeover_time)) self.effectOfTheArrivalTimesOnMakespanLineEdit.setText(str(self.data.makespan_factor)) self.truckTransferTimeLineEdit.setText(str(self.data.truck_transfer_time)) self.inboundArrivalTimeLineEdit.setText(str(self.data.inbound_arrival_time)) self.outboundArrivalTimeLineEdit.setText(str(self.data.outbound_arrival_time)) self.goodTransferTimeLineEdit.setText(str(self.data.good_transfer_time)) self.numberOfInboundTrucksSpinBox.setValue(self.data.number_of_inbound_trucks) self.numberOfOutboundTrucksSpinBox.setValue(self.data.number_of_outbound_trucks) self.numberOfCompoundTrucksSpinBox.setValue(self.data.number_of_compound_trucks) self.numberOfReceivingDoorsSpinBox.setValue(self.data.number_of_receiving_doors) self.numberOfShippingDoorsSpinBox.setValue(self.data.number_of_shipping_doors) self.numberOfGoodsSpinBox.setValue(self.data.number_of_goods) self.numberOfDataSetsSpinBox.setValue(self.data.number_of_data_sets) def update_number_of_goods(self, amount): self.inbound_table_model.change_good_number(amount) self.outbound_table_model.change_good_number(amount) self.compound_coming_table_model.change_good_number(amount) self.compound_going_table_model.change_good_number(amount) self.data.number_of_goods = amount def set_data_set_table(self): self.data.number_of_data_sets = self.numberOfDataSetsSpinBox.value() if self.numberOfDataSetsSpinBox.value() > len(self.data_set_model.data): self.data_set_model.insertRows(len(self.data_set_model.data), self.numberOfDataSetsSpinBox.value()) elif self.numberOfDataSetsSpinBox.value() < len(self.data_set_model.data): self.data_set_model.removeRows(len(self.data_set_model.data), self.numberOfDataSetsSpinBox.value()) def load_data(self): """ loads prev saved data :return: """ file_name, _ = QFileDialog.getOpenFileName(self, "Open file", "/home") try: self.data = pickle.load(open(file_name, "rb")) except Exception as e: pass self.graphicsView.data = self.data self.setup_data() self.update_data_table() self.load_generated_data() self.value_connections() def save_data(self): """ saves current data :return: """ self.graphicsView.data = self.data self.setup_data() file_name, _ = QFileDialog.getSaveFileName(self, "Save file", "/home") try: pickle.dump(self.data, open(file_name, "wb")) except Exception as e: pass def setup_sequence_solver(self): self.combobox_coming_sequence = [] self.combobox_going_sequence = [] self.setup_truck_names() self.coming_truck_list = self.data.coming_truck_name_list + ["0"] * (self.data.number_of_receiving_doors - 1) self.going_truck_list = self.data.going_truck_name_list + ["0"] * (self.data.number_of_shipping_doors - 1) for i in range(self.data.number_of_coming_trucks + self.data.number_of_receiving_doors - 1): newbox = QComboBox() newbox.addItems(self.coming_truck_list) self.combobox_coming_sequence.append(newbox) for i in range(self.data.number_of_going_trucks + self.data.number_of_shipping_doors - 1): newbox = QComboBox() newbox.addItems(self.going_truck_list) self.combobox_going_sequence.append(newbox) for i, box in enumerate(self.combobox_coming_sequence): self.sequence_grid.addWidget(box, 0, i) for i, box in enumerate(self.combobox_going_sequence): self.sequence_grid.addWidget(box, 1, i) def setup_truck_names(self): GoodStore.loading_time = self.data.loading_time Door.good_transfer_time = self.data.good_transfer_time self.data.truck_name_list = [] self.data.coming_truck_name_list = [] self.data.going_truck_name_list = [] for i in range(self.data.number_of_inbound_trucks): name = "inbound" + str(i) self.data.truck_name_list.append(name) self.data.coming_truck_name_list.append(name) self.truck_states[name] = "coming" for i in range(self.data.number_of_outbound_trucks): name = "outbound" + str(i) self.data.truck_name_list.append(name) self.data.going_truck_name_list.append(name) self.truck_states[name] = "coming" for i in range(self.data.number_of_compound_trucks): name = "compound" + str(i) self.data.truck_name_list.append(name) self.data.coming_truck_name_list.append(name) self.data.going_truck_name_list.append(name) self.truck_states[name] = "coming" def update_truck_numbers(self): self.data.update_truck_numbers() def solve_data_set(self): self.start_time = time.time() self.annealing = Annealing( self.data, int(self.tempereature_line_edit.text()), float(self.decav_factor_line_edit.text()) ) self.tabu = Tabu( self.data, int(self.number_of_tabu_line_edit.text()), int(self.number_of_tabu_neighbours_line_edit.text()) ) self.algorithms = {"annealing": self.annealing, "tabu": self.tabu} self.algorithm_name = str(self.solverComboBox.currentText()) self.function_type = str(self.function_combo_box.currentText()) self.algorithm = self.algorithms[self.algorithm_name] self.update_truck_numbers() self.data_set_number = self.data_set_spin_box.value() - 1 self.iteration_number = 0 self.number_of_iterations = int(self.numberOfIterationsLineEdit.text()) self.setup_truck_names() self.slow_solution = not self.fast_solve_check_box.isChecked() if self.slow_solution: self.solution_name = "data_set_{0}_{1}_{2}_{3}".format( self.data_set_number + 1, self.solverComboBox.currentText(), self.function_combo_box.currentText(), len(self.results) + 1, ) self.results[self.solution_name] = [] self.result_names_combo_box.addItem(self.solution_name) self.coming_sequence_table_model = SequenceTableModel(self.results[self.solution_name], 0, self.data) self.coming_sequence_table.setModel(self.coming_sequence_table_model) self.going_sequence_table_model = SequenceTableModel(self.results[self.solution_name], 1, self.data) self.going_sequence_table.setModel(self.going_sequence_table_model) if self.algorithm_name == "annealing": self.error_sequence_table_model = AnnealingErrorTableModel(self.results[self.solution_name], self.data) self.sequence_error_table.setModel(self.error_sequence_table_model) elif self.algorithm_name == "tabu": self.error_sequence_table_model = TabuErrorTableModel(self.results[self.solution_name], self.data) self.sequence_error_table.setModel(self.error_sequence_table_model) self.next_iteration() def save_results(self): self.current_result_data = ResultData(self.data) self.current_result_data.times = copy.deepcopy(self.result_times) self.sequence.error = self.calculate_error() self.current_result_data.sequence = copy.deepcopy(self.sequence) self.current_result_data.goods = self.solver.return_goods() self.result_times = {} self.results[self.solution_name].append(self.current_result_data) self.coming_sequence_table_model.insertRows(0, 0) self.going_sequence_table_model.insertRows(0, 0) self.error_sequence_table_model.insertRows(0, 0) def save_tabu_results(self): self.current_result_data = ResultData(self.data) self.current_result_data.times = {} self.sequence.error = float("inf") self.current_result_data.sequence = copy.deepcopy(self.sequence) self.current_result_data.goods = {} self.result_times = {} self.results[self.solution_name].append(self.current_result_data) self.coming_sequence_table_model.insertRows(0, 0) self.going_sequence_table_model.insertRows(0, 0) self.error_sequence_table_model.insertRows(0, 0) def next_iteration(self): print("next") try: self.solver = Solver(self.data_set_number, self.data) self.solver.done_signal.connect(self.iteration_end) self.solver.value_signal.connect(self.time_saver) print(self.iteration_number) if self.iteration_number == 0: self.sequence = copy.deepcopy(self.algorithm.start1()) self.iteration_number += 1 self.solver.set_sequence(self.sequence) self.solver.solve() elif self.iteration_number < self.number_of_iterations + 1: if self.algorithm_name == "annealing": new_sequence = self.algorithm.next_iteration(self.sequence, self.iteration_number) if self.slow_solution: self.current_result_data.sequence = copy.deepcopy(self.sequence) self.iteration_number += 1 self.sequence = new_sequence self.solver.set_sequence(self.sequence) self.solver.solve() elif self.algorithm_name == "tabu": print("tabu") if self.algorithm.generated_neighbour_number == self.algorithm.number_of_neighbours: print("if") self.algorithm.generated_neighbour_number = 0 decision_list = self.algorithm.choose_sequence() # if self.slow_solution: for i, decision in enumerate(decision_list): self.results[self.solution_name][-len(decision_list) + i].sequence.values[ "decision" ] = decision self.iteration_number += 1 self.next_iteration() else: new_sequence = self.algorithm.next_iteration(self.iteration_number) self.sequence = new_sequence self.algorithm.generated_neighbour_number += 1 if self.algorithm.check_tabu(self.sequence): self.save_tabu_results() self.next_iteration() else: self.solver.set_sequence(self.sequence) self.solver.solve() elif self.iteration_number == self.number_of_iterations + 1: self.end_time = time.time() self.solution_time = self.end_time - self.start_time self.solution_time_label.setText(str(int(self.solution_time))) self.stop() except: pass def check_iteration_finish(self): pass def iteration_end(self): print("end") try: self.save_results() if self.algorithm_name == "annealing": self.solver.not_finished = False self.solver.quit() self.solver.done_signal.disconnect() elif self.algorithm_name == "tabu": if self.algorithm.iteration_finish: self.algorithm.iteration_finish = False else: self.solver.not_finished = False self.solver.quit() self.solver.done_signal.disconnect() self.next_iteration() except: self.next_iteration() def calculate_error(self): total_error = 0 if self.function_type == "normal": for truck in self.solver.truck_list.values(): if truck.truck_name in self.data.going_truck_name_list: if truck.behaviour_list[truck.current_state] == "done": if truck.finish_time > truck.upper_bound: error = truck.finish_time - truck.upper_bound print("positive error") elif truck.finish_time < truck.lower_bound: error = truck.finish_time - truck.lower_bound # print('!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!negative error') # print(error) else: error = 0 if self.slow_solution: self.current_result_data.times[truck.truck_name].append(["upper bound", truck.upper_bound]) self.current_result_data.times[truck.truck_name].append(["lower bound", truck.lower_bound]) self.current_result_data.times[truck.truck_name].append(["error", error]) total_error += abs(error) elif self.function_type == "cmax": print("cmax") total_error = self.solver.current_time for truck in self.solver.truck_list.values(): if truck.truck_name in self.data.going_truck_name_list: if truck.behaviour_list[truck.current_state] == "done": self.current_result_data.times[truck.truck_name].append(["upper bound", truck.upper_bound]) self.current_result_data.times[truck.truck_name].append(["lower bound", truck.lower_bound]) elif self.function_type == "late_truck": for truck in self.solver.truck_list.values(): if truck.truck_name in self.data.going_truck_name_list: if truck.behaviour_list[truck.current_state] == "done": error = 0 if truck.finish_time > truck.upper_bound: error = truck.finish_time - truck.upper_bound total_error += 1 error = 1 self.current_result_data.times[truck.truck_name].append(["upper bound", truck.upper_bound]) self.current_result_data.times[truck.truck_name].append(["lower bound", truck.lower_bound]) self.current_result_data.times[truck.truck_name].append(["error", error]) return total_error def stop(self): print("stop") try: self.solver.done_signal.disconnect() except: pass def solve_one_sequence(self): self.data_set_number = self.data_set_spin_box.value() - 1 self.solution_name = "data_set{0}_simulation_{1}".format(self.data_set_number + 1, len(self.results) + 1) self.results[self.solution_name] = [] self.result_names_combo_box.addItem(self.solution_name) self.data_set_number = self.data_set_spin_box.value() - 1 self.setup_truck_names() self.solver = Solver(self.data_set_number, self.data) self.solver.time_signal.connect(self.time.display) self.solver.value_signal.connect(self.solver_truck_signal) self.solver.value_signal.connect(self.time_saver) self.time_constant.textChanged.connect(self.solver.time_step_change) self.solver.done_signal.connect(self.finished) self.solver.time_step = True self.sequence = Sequence() for box in self.combobox_coming_sequence: self.sequence.coming_sequence.append(box.currentText()) for box in self.combobox_going_sequence: self.sequence.going_sequence.append(box.currentText()) self.graphicsView.reset() self.graphicsView.update_scene() self.solver.set_sequence(self.sequence) self.solver.solve() def solver_truck_signal(self, time, name, state, arg): self.truck_states[name] = [state, arg] self.graphicsView.update_scene() def time_saver(self, time, name, state, arg): try: if self.slow_solution: if name in self.result_times.keys(): self.result_times[name].append([state, time]) else: self.result_times[name] = [[state, time]] except: pass def pause(self): try: self.solver.pause = True except: pass def resume(self): try: self.solver.pause = False except: pass def finished(self, time): self.current_result_data = ResultData(self.data) self.current_result_data.times = copy.deepcopy(self.result_times) self.sequence.error = self.calculate_error() self.current_result_data.sequence = copy.deepcopy(self.sequence) self.current_result_data.goods = self.solver.return_goods() self.results[self.solution_name].append(self.current_result_data) print("quit") self.solver.not_finished = False self.solver.quit() def setup_simulator(self): self.graphicsView.reset() self.graphicsView.truck_states = self.truck_states def show_results(self): try: iteration_number = int(self.result_iteration_number_line_edit.text()) - 1 if iteration_number > len(self.showing_result): self.result_iteration_number_line_edit.setText(str(len(self.showing_result))) iteration_number = len(self.showing_result) result_sequence_model = ResultSequenceTableModel(self.showing_result[iteration_number], self.data) self.sequence_table.setModel(result_sequence_model) result_good_model = ResultGoodTableModel(self.showing_result[iteration_number], self.data) self.good_in_out_table.setModel(result_good_model) self.good_in_out_table.resizeColumnsToContents() self.good_in_out_table.resizeRowsToContents() inbound_time_model = ResultTimeTableModel( self.showing_result[iteration_number], self.data.number_of_inbound_trucks, "inbound" ) self.inbound_time_table.setModel(inbound_time_model) outbound_time_model = ResultTimeTableModel( self.showing_result[iteration_number], self.data.number_of_outbound_trucks, "outbound" ) self.outbound_time_table.setModel(outbound_time_model) compound_time_model = ResultTimeTableModel( self.showing_result[iteration_number], self.data.number_of_compound_trucks, "compound" ) self.compound_time_table.setModel(compound_time_model) except: pass def change_result_name(self, name): self.solution_name = name self.showing_result = self.results[name] def print_results(self, results, iteration_number): pass def gams_output(self): file_name, _ = QFileDialog.getSaveFileName(self, "Save file", "/home") # try: gams_writer(file_name, self.data_set_spin_box.value() - 1, self.data)
default=0, type=int, help='Random seed for reproducible results.', required=False) parser.add_argument('--cpu', action='store_true', help='Disable GPU training') parser.add_argument('--no-msg', action='store_true', help='Hide all messages') args = parser.parse_args() args.gpu = not args.cpu args.verbose = not args.no_msg config = yaml.load(open(args.config, 'r'), Loader=yaml.FullLoader) # Set seed random.seed(args.seed) np.random.seed(args.seed) torch.manual_seed(args.seed) if torch.cuda.is_available(): torch.cuda.manual_seed_all(args.seed) # Train from src.solver import Trainer as Solver solver = Solver(config, args) solver.load_data() solver.build_model() solver.exec()
final_state = [] cnt = 0 print("{:<20} {:<10}".format('PHM positions', 'Failure of critical function')) print("------------- ----------------------------") for state in states: cnt += 1 if select and cnt < number: continue if select and cnt > number: break model_description = model.load_phm(model_description, state) # Build the model bn = BayesianNetwork(model_description) bayesian_model = bn.build() solver = Solver(bayesian_model, display, evidence) e = solver.run(mapquery=False, printed=False) if e < failure: final_state = state failure = e print("{:<20} {:.4E} *".format(cnt, e)) else: print("{:<20} {:.4E}".format(cnt, e)) if details: print('\n=====================\n') model_description = model.load_phm(model_description, final_state) # Build the model bn = BayesianNetwork(model_description) bayesian_model = bn.build() solver = Solver(bayesian_model, display_final, evidence) e = solver.run(mapquery=False, printed=True)
def main(args): # load dictionary and generate char_list, sos_id, eos_id char_list, sos_id, eos_id = process_dict(args.dict) vocab_size = len(char_list) tr_dataset = AudioDataset('train', args.batch_size) cv_dataset = AudioDataset('dev', args.batch_size) tr_loader = AudioDataLoader(tr_dataset, batch_size=1, num_workers=args.num_workers, shuffle=args.shuffle, feature_dim=args.feature_dim, char_list=char_list, path_list=tr_dataset.path_lst, label_list=tr_dataset.han_lst, LFR_m=args.LFR_m, LFR_n=args.LFR_n) cv_loader = AudioDataLoader(cv_dataset, batch_size=1, num_workers=args.num_workers, feature_dim=args.feature_dim, char_list=char_list, path_list=cv_dataset.path_lst, label_list=cv_dataset.han_lst, LFR_m=args.LFR_m, LFR_n=args.LFR_n) data = {'tr_loader': tr_loader, 'cv_loader': cv_loader} encoder = Encoder(args.d_input * args.LFR_m, args.d_low_dim, args.n_layers_enc, args.n_head, args.d_k, args.d_v, args.d_model, args.d_inner, dropout=args.dropout, pe_maxlen=args.pe_maxlen) decoder = Decoder( sos_id, eos_id, vocab_size, args.d_word_vec, args.n_layers_dec, args.n_head, args.d_k, args.d_v, args.d_model, args.d_inner, dropout=args.dropout, tgt_emb_prj_weight_sharing=args.tgt_emb_prj_weight_sharing, pe_maxlen=args.pe_maxlen) model = Transformer(encoder, decoder) print(model) model.cuda() # optimizer optimizier = TransformerOptimizer( torch.optim.Adam(model.parameters(), betas=(0.9, 0.98), eps=1e-09), args.init_lr, args.d_model, args.warmup_steps) # solver solver = Solver(data, model, optimizier, args) solver.train()
def test_ctor(self): solver = Solver("", "", False) self.assertEqual(solver.name, "") self.assertEqual(solver.quiet_mode, False)
def train(data_dir, epochs, batch_size, model_path, max_hours=None, continue_from=""): # General config # Task related json_dir = data_dir train_dir = data_dir + "tr" valid_dir = data_dir + "cv" sample_rate = 8000 segment_len = 4 cv_maxlen = 6 # Network architecture N = 256 # Number of filters in autoencoder L = 20 # Length of filters in conv autoencoder B = 256 # number of channels in conv blocks - after bottleneck 1x1 conv H = 512 # number of channels in inner conv1d block P = 3 # length of filter in inner conv1d blocks X = 8 # number of conv1d blocks in (also number of dilations) in each repeat R = 4 # number of repeats C = 2 # Number of speakers norm_type = 'gLN' # choices=['gLN', 'cLN', 'BN'] causal = 0 mask_nonlinear = 'relu' use_cuda = 1 half_lr = 1 # Half the learning rate when there's a small improvement early_stop = 1 # Stop learning if no imporvement after 10 epochs max_grad_norm = 5 # gradient clipping shuffle = 1 # Shuffle every epoch # batch_size = 3 num_workers = 4 # optimizer optimizer_type = "adam" lr = 1e-3 momentum = 0 l2 = 0 # Weight decay - l2 norm # save and visualize save_folder = "../egs/models" enable_checkpoint = 0 # enables saving checkpoints # continue_from = save_folder + "/speech_seperation_first_try.pth" # model to continue from # model_path = "speech_separation_first_try_more_epochs.pth" # TODO: Fix this print_freq = 20000 visdom_enabled = 1 visdom_epoch = 1 visdom_id = "Conv-TasNet Training" # TODO: Check what this does arg_solver = (use_cuda, epochs, half_lr, early_stop, max_grad_norm, save_folder, enable_checkpoint, continue_from, model_path, print_freq, visdom_enabled, visdom_epoch, visdom_id) # Datasets and Dataloaders tr_dataset = AudioDataset(train_dir, batch_size, sample_rate=sample_rate, segment=segment_len, max_hours=max_hours) cv_dataset = AudioDataset(valid_dir, batch_size=1, # 1 -> use less GPU memory to do cv sample_rate=sample_rate, segment=-1, cv_maxlen=cv_maxlen, max_hours=max_hours) # -1 -> use full audio tr_loader = AudioDataLoader(tr_dataset, batch_size=1, shuffle=shuffle, num_workers=num_workers) cv_loader = AudioDataLoader(cv_dataset, batch_size=1, num_workers=0) data = {'tr_loader': tr_loader, 'cv_loader': cv_loader} # model model = ConvTasNet(N, L, B, H, P, X, R, C, norm_type=norm_type, causal=causal, mask_nonlinear=mask_nonlinear) # print(model) if use_cuda: model = torch.nn.DataParallel(model) model.cuda() # optimizer if optimizer_type == 'sgd': optimizer = torch.optim.SGD(model.parameters(), lr=lr, momentum=momentum, weight_decay=l2) elif optimizer_type == 'adam': optimizer = torch.optim.Adam(model.parameters(), lr=lr, weight_decay=l2) else: print("Not support optimizer") return # solver solver = Solver(data, model, optimizer, arg_solver) # TODO: Fix solver thing solver.train()
def main(): # torch.set_default_tensor_type('torch.FloatTensor') # set up default cuda device device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") # Load the (preprocessed) CIFAR10 data. The preprocessing includes # channel swapping, normalization and train-val-test splitting. # Loading the datasets might take a while. datasetGen = DatasetGen() datasetGen.BinaryShinyPokemonDataset() data_dict = datasetGen.Subsample([0.6, 0.2, 0.2]) print("Train size: %i" % len(data_dict["X_train"])) print("Val size: %i" % len(data_dict["X_val"])) print("Test size: %i" % len(data_dict["X_test"])) train_data, val_data, test_data = ConvertDatasetDictToTorch(data_dict) from src.solver import Solver from torch.utils.data.sampler import SequentialSampler num_train = len(train_data) OverfitSampler = SequentialSampler(range(num_train)) train_loader = torch.utils.data.DataLoader(train_data, batch_size=64, shuffle=True, num_workers=4) val_loader = torch.utils.data.DataLoader(val_data, batch_size=64, shuffle=False, num_workers=4) ############################################################################ # Hyper parameter Grid search : Set grids below # ############################################################################ print(train_data) lr = 1e-3 kernelsize = 3 hidden_dims = [200] convArray = [64, 128] model = ClassificationCNN(input_dim=[3, 96, 96], num_classes=2, convolutionalDims=convArray, kernel_size=kernelsize, stride_conv=1, weight_scale=0.02, pool=2, stride_pool=2, hiddenDims=hidden_dims, dropout=0.0) model.to(device) solver = Solver(optim_args={"lr": lr, "weight_decay": 1e-3}) print( "training now with values: lr=%s, hidden_dim=%s, filtersize=%s, convArray=%s" % (lr, str(hidden_dims), kernelsize, str(convArray))) solver.train(model, train_loader, val_loader, log_nth=6, num_epochs=10, L1=False, reg=0.1) from src.vis_utils import visualize_grid # first (next) parameter should be convolutional conv_params = next(model.parameters()).cpu().data.numpy() grid = visualize_grid(conv_params.transpose(0, 2, 3, 1)) plt.imshow(grid.astype('uint8')) plt.axis('off') plt.gcf().set_size_inches(6, 6) plt.show()
class MainWindow(QWidget): """ Main window with control buttons logger and running output """ def __init__(self): QWidget.__init__(self) self.setWindowTitle("Cross Docking Project") self.data = DataStore() self.set_buttons() self.set_logger() self.set_layout() self.algorithm_list = {'annealing1': Annealing1} self.algorithm_name = 'annealing1' self.current_data_set_number = 0 # add these to gui self.number_of_iterations = 200 def set_buttons(self): """ set buttons for the main gui :return: """ self.new_data_set_button = QPushButton('New Data Set') self.new_data_set_button.clicked.connect(self.new_data_set) self.load_data_set_button = QPushButton('Load Data Set') self.load_data_set_button.clicked.connect(self.load_data) self.save_data_set_button = QPushButton('Save Data Set') self.save_data_set_button.clicked.connect(self.save_data) self.truck_data_button = QPushButton('Truck Data') self.truck_data_button.clicked.connect(self.show_truck_data_window) self.system_data_button = QPushButton('System Data') self.system_data_button.clicked.connect(self.show_data_set_window) self.algorithm_data_button = QPushButton('Algorithm Data') self.generate_data_set_button = QPushButton('Generate Data Set') self.generate_data_set_button.clicked.connect(self.generate_data_set) self.show_data_button = QPushButton('Show Data Set') self.show_data_button.clicked.connect(self.show_data_window) self.print_gams_button = QPushButton('Print gams output') self.print_gams_button.clicked.connect(self.print_gams) self.data_set_ready_button = QPushButton('Setup Data Set') self.data_set_ready_button.clicked.connect(self.setup_data_set) self.solve_step_button = QPushButton('Solve Next Step') self.solve_step_button.clicked.connect(self.solve_step) self.solve_step_button.setEnabled(False) self.solve_iteration_button = QPushButton('Solve Next Iteration') self.solve_iteration_button.clicked.connect(self.solve_iteration) self.solve_iteration_button.setEnabled(False) self.solve_data_set_button = QPushButton('Solve Data Set') self.solve_data_set_button.setEnabled(False) self.solve_data_set_button.clicked.connect(self.solve_data_set) self.solve_sequence_button = QPushButton('Solve a given sequence') self.solve_data_set_button.setEnabled(True) self.solve_sequence_button.clicked.connect(self.solve_sequence) self.show_solution_button = QPushButton('Show Best Solution') self.show_solution_button.setEnabled(False) self.show_solution_button.clicked.connect(self.show_solution) self.show_sequences_button = QPushButton('Show Sequences') self.show_sequences_button.setEnabled(False) self.show_sequences_button.clicked.connect(self.show_sequences) self.show_logger_button = QPushButton('Show Logger') self.show_simulation_button = QPushButton('Show Simulation') self.show_data_table = QPushButton('Show Run Time Data Table') self.debug_check = QCheckBox('Debug Mode') self.debug_check.stateChanged.connect(self.set_logger_output) self.data_set_number = QSpinBox() self.data_set_number.setMinimum(1) self.data_set_number.valueChanged.connect(self.set_data_set_number) def set_logger(self): """ setup logger with info output and a channel forward to screen output :return: """ self.logger = LogData() self.logger_root = logging.getLogger() self.logger_root.setLevel(logging.INFO) self.logger_ch = logging.StreamHandler(self.logger) self.logger_ch.setLevel(logging.INFO) self.logger_root.addHandler(self.logger_ch) def set_layout(self): """ set layout of the main screen :return: """ self.data_set_layout = QGridLayout() self.data_set_layout.addWidget(self.new_data_set_button, 1, 1) self.data_set_layout.addWidget(self.load_data_set_button, 1, 2) self.data_set_layout.addWidget(self.save_data_set_button, 1, 3) self.data_set_layout.addWidget(self.debug_check, 1, 4) self.data_set_layout.addWidget(self.truck_data_button, 2, 1) self.data_set_layout.addWidget(self.system_data_button, 2, 2) self.data_set_layout.addWidget(self.algorithm_data_button, 2, 3) self.data_set_layout.addWidget(self.generate_data_set_button, 3, 1) self.data_set_layout.addWidget(self.show_data_button, 3, 2) self.data_set_layout.addWidget(self.print_gams_button, 3, 3) self.data_set_layout.addWidget(self.data_set_ready_button, 4, 1) self.data_set_layout.addWidget(self.data_set_number, 4, 2) self.solver_layout = QGridLayout() self.solver_layout.addWidget(self.solve_step_button, 1, 1) self.solver_layout.addWidget(self.solve_iteration_button, 1, 2) self.solver_layout.addWidget(self.solve_data_set_button, 1, 3) self.solver_layout.addWidget(self.solve_sequence_button, 1, 4) self.solver_layout.addWidget(self.show_solution_button, 2, 1) self.interaction_layout = QGridLayout() self.interaction_layout.addWidget(self.show_logger_button, 1, 1) self.interaction_layout.addWidget(self.show_simulation_button, 1, 3) self.interaction_layout.addWidget(self.show_data_table, 1, 4) self.button_layout = QVBoxLayout() self.button_layout.addLayout(self.data_set_layout) self.button_layout.addLayout(self.solver_layout) # self.button_layout.addLayout(self.interaction_layout) self.layout = QGridLayout() self.layout.addLayout(self.button_layout, 1, 1) self.layout.addWidget(self.logger, 1, 2) self.setLayout(self.layout) def set_logger_output(self, state): """ setup logger output between info and debug depending on the check box on main screen :param state: :return: """ if state == Qt.Checked: self.logger_root.setLevel(logging.DEBUG) self.logger_ch.setLevel(logging.DEBUG) logging.info("Debug Mode") else: self.logger_root.setLevel(logging.INFO) self.logger_ch.setLevel(logging.INFO) logging.info("Normal Mode") def new_data_set(self): """ new data set """ self.data = DataStore() logging.debug('New Data Set') def load_data(self): """ loads prev saved data :return: """ file_name, _ = QFileDialog.getOpenFileName(self, 'Open file', '/home') try: self.data = pickle.load(open(file_name, 'rb')) logging.info('Loaded file: {0}'.format(file_name)) except Exception as e: logging.info(e) def save_data(self): """ saves current data :return: """ file_name, _ = QFileDialog.getSaveFileName(self, 'Save file', '/home') try: pickle.dump(self.data, open(file_name, 'wb')) logging.info('Saved to file: {0}'.format(file_name)) except Exception as e: logging.info(e) def show_truck_data_window(self): self.truck_data_window = TruckDataWindow(self.data) self.truck_data_window.exec_() def show_data_set_window(self): self.data_set_window = DataSetWindow(self.data) self.data_set_window.exec_() def show_data_window(self): self.data_window = ShowData(self.data) self.data_window.exec_() def generate_data_set(self): # ask if sure self.data.arrival_times = [] self.data.boundaries = [] self.model = Solver(self.data) for i in range(len(self.data.data_set_list)): self.model.current_data_set = i self.model.set_data() def print_gams(self): file_name, _ = QFileDialog.getSaveFileName(self, 'Open file', '/home') for i in range(len(self.data.data_set_list)): gams_writer(file_name + str(i), i, self.data) def set_data_set_number(self): self.current_data_set_number = self.data_set_number.value() - 1 def setup_data_set(self): # setup for one data set self.model = Solver(self.data) self.model.current_data_set = self.current_data_set_number self.model.load_data_set() self.algorithm = self.algorithm_list[self.algorithm_name]( self.number_of_iterations, self.current_data_set_number, self.model, self.data) logging.info("Solving using {0} data set {1}".format( self.algorithm_name, self.current_data_set_number + 1)) logging.info("Nuber of iterations {0}".format( self.number_of_iterations)) self.solve_step_button.setEnabled(True) self.solve_iteration_button.setEnabled(True) self.solve_data_set_button.setEnabled(True) self.solve_sequence_button.setEnabled(True) self.show_solution_button.setEnabled(True) self.show_sequences_button.setEnabled(True) def solve_step(self): self.algorithm.step_mode = True self.algorithm.solve() def solve_iteration(self): self.algorithm.step_mode = False self.algorithm.solve() def solve_data_set(self): self.algorithm.solve_data_set() def solve_sequence(self): logging.info( '--------------------Solving one sequence---------------------------------' ) self.set_sequence = SetSequence(self.data) self.set_sequence.exec_() sequence = self.set_sequence.set_sequence() sequence.print_sequence() self.one_time_model = Solver(self.data) self.one_time_model.current_data_set = self.current_data_set_number self.one_time_model.load_data_set() self.one_time_model.set_sequence(sequence) while not self.one_time_model.finish: self.one_time_model.next_step() total_error = 0 for truck in itertools.chain( self.one_time_model.outbound_trucks.values(), self.one_time_model.compound_trucks.values()): truck.calculate_error() logging.info("Truck {0}, error {1}\n".format( truck.truck_name, truck.error)) total_error += abs(truck.error) logging.info("Error: {0}\n".format(total_error)) def show_solution(self): pass def show_sequences(self): pass