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