From 6fa1f53f690a896b49c5db9e6c39a5150e594900 Mon Sep 17 00:00:00 2001 From: hit-lu Date: Sat, 6 Apr 2024 13:44:05 +0800 Subject: [PATCH] =?UTF-8?q?=E4=BF=AE=E6=94=B9=E7=94=9F=E6=88=90=E6=95=B0?= =?UTF-8?q?=E6=8D=AE=E6=96=B9=E5=BC=8F=E5=92=8C=E7=BD=91=E7=BB=9C=E8=AE=AD?= =?UTF-8?q?=E7=BB=83=E6=96=B9=E5=BC=8F?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- base_optimizer/optimizer_common.py | 2 +- base_optimizer/optimizer_feederpriority.py | 1 - base_optimizer/optimizer_hybridgenetic.py | 2 - base_optimizer/optimizer_interface.py | 2 +- generator.py | 134 +++++++++++++++------ optimizer.py | 36 ++++-- optimizer_genetic.py | 4 +- optimizer_hyperheuristic.py | 109 +++++++++++------ 8 files changed, 194 insertions(+), 96 deletions(-) diff --git a/base_optimizer/optimizer_common.py b/base_optimizer/optimizer_common.py index 49de976..9845420 100644 --- a/base_optimizer/optimizer_common.py +++ b/base_optimizer/optimizer_common.py @@ -173,7 +173,7 @@ def timer_wrapper(func): start_time = time.time() result = func(*args, **kwargs) - print("function {} running time : {} s".format(func.__name__, time.time() - start_time)) + print(f"function {func.__name__} running time : {time.time() - start_time:.3f} s") return result return measure_time diff --git a/base_optimizer/optimizer_feederpriority.py b/base_optimizer/optimizer_feederpriority.py index f5723bf..70dcc8d 100644 --- a/base_optimizer/optimizer_feederpriority.py +++ b/base_optimizer/optimizer_feederpriority.py @@ -66,7 +66,6 @@ def feeder_allocate(component_data, pcb_data, feeder_data, figure=False): nozzle_assigned_counter = optimal_nozzle_assignment(component_data, pcb_data) head_assign_indexes = list(range(max_head_index)) nozzle_pattern, optimal_nozzle_pattern, optimal_nozzle_points = [], None, 0 - # nozzle_pattern = ['CN220', 'CN065','CN065','CN065','CN065','CN220'] # 先排序 nozzle_pattern_list = [] diff --git a/base_optimizer/optimizer_hybridgenetic.py b/base_optimizer/optimizer_hybridgenetic.py index 120a8dc..c1a1dcb 100644 --- a/base_optimizer/optimizer_hybridgenetic.py +++ b/base_optimizer/optimizer_hybridgenetic.py @@ -294,8 +294,6 @@ def convert_individual_2_result(component_data, component_point_pos, designated_ @timer_wrapper def optimizer_hybrid_genetic(pcb_data, component_data, hinter=True): - random.seed(0) - np.random.seed(0) nozzle_assigned_counter = optimal_nozzle_assignment(component_data, pcb_data) # nozzle assignment result: diff --git a/base_optimizer/optimizer_interface.py b/base_optimizer/optimizer_interface.py index 7ccc19b..d032462 100644 --- a/base_optimizer/optimizer_interface.py +++ b/base_optimizer/optimizer_interface.py @@ -80,7 +80,7 @@ def base_optimizer(machine_index, pcb_data, component_data, feeder_data=None, me if hinter: optimization_assign_result(component_data, pcb_data, component_result, cycle_result, feeder_slot_result, - nozzle_hinter=True, component_hinter=False, feeder_hinter=True) + nozzle_hinter=True, component_hinter=True, feeder_hinter=True) print('----- Placement machine ' + str(machine_index) + ' ----- ') print('-Cycle counter: {}'.format(info.cycle_counter)) diff --git a/generator.py b/generator.py index 2f29419..1a34fc0 100644 --- a/generator.py +++ b/generator.py @@ -1,3 +1,6 @@ +import random + +import numpy as np import pandas as pd from base_optimizer.optimizer_common import * @@ -8,53 +11,58 @@ class DataMgr: self.min_placement_points = 100 self.max_placement_points = 800 - self.max_component_types = 50 + self.max_component_types = 30 self.default_feeder_limit = 1 self.nozzle_type_list = ['CN065', 'CN140', 'CN220', 'CN040'] - self.x_range = [50, 100, 150, 200, 300, 400, 500] - self.y_range = [50, 100, 150, 200, 300, 400, 500] + # self.x_range = [50, 100, 150, 200, 300, 400, 500] + # self.y_range = [50, 100, 150, 200, 300, 400, 500] + + self.x_range = [400] + self.y_range = [200] self.counter = 0 + self.update = 10 self.pre_file = None + self.part_col = ["part", "desc", "fdr", "nz", 'camera', 'group', 'feeder-limit', 'points'] + self.component_data = pd.DataFrame(columns=self.part_col) # the component list update for several rounds - def generator(self): + def generator(self, mode='Train'): boundary = [random.choice(self.x_range), random.choice(self.y_range)] - total_points = random.randint(self.min_placement_points, self.max_placement_points) # determine the nozzle type of component - component_list = defaultdict(str) - for cp_idx in range(min(random.randint(1, self.max_component_types), total_points)): - component_list['C' + str(cp_idx)] = random.choice(self.nozzle_type_list) + if self.counter % 10 == 0 or mode == 'test': + self.component_data = self.component_data.loc[[]] + total_points = random.randint(self.min_placement_points, self.max_placement_points) + total_nozzles = random.randint(1, len(self.nozzle_type_list)) + selected_nozzle = random.sample(self.nozzle_type_list, total_nozzles) + for cp_idx in range(min(random.randint(1, self.max_component_types), total_points)): + part, nozzle = 'C' + str(cp_idx), random.choice(selected_nozzle) + self.component_data = pd.concat([self.component_data, pd.DataFrame( + [part, '', 'SM8', nozzle, '飞行相机1', 'CHIP-Rect', self.default_feeder_limit, 0], + index=self.part_col).T], ignore_index=True) + + random_fractions = np.random.rand(len(self.component_data)) + normalized_fractions = random_fractions / random_fractions.sum() + for cp_idx, fraction in enumerate(normalized_fractions): + self.component_data.iloc[cp_idx].points = round(fraction * total_points) step_col = ["ref", "x", "y", "z", "r", "part", "desc", "fdr", "nz", "hd", "cs", "cy", "sk", "bl", "ar", "pl", "lv"] pcb_data = pd.DataFrame(columns=step_col) + idx = 1 + for _, data in self.component_data.iterrows(): + for _ in range(data.points): + part, nozzle = data.part, data.nz + pos_x, pos_y = np.random.uniform(0, boundary[0]), np.random.uniform(0, boundary[1]) + pcb_data = pd.concat([pcb_data, pd.DataFrame([['R' + str(idx), -pos_x, pos_y, + 0.000, 0.000, part, '', 'A', '1-0 ' + nozzle, 1, 1, 1, 0, + 1, 1, 1, 'L0']], columns=pcb_data.columns)], ignore_index=True) + idx += 1 - for idx in range(total_points): - part = random.choice(list(component_list.keys())) - nozzle = component_list[part] - - pos_x, pos_y = np.random.uniform(0, boundary[0]), np.random.uniform(0, boundary[1]) - pcb_data = pd.concat([pcb_data, pd.DataFrame([['R' + str(idx), -pos_x, pos_y, - 0.000, 0.000, part, '', 'A', '1-0 ' + nozzle, 1, 1, 1, 0, - 1, 1, 1, 'L0']], columns=pcb_data.columns)], ignore_index=True) - - part_col = ["part", "desc", "fdr", "nz", 'camera', 'group', 'feeder-limit', 'points'] - component_data = pd.DataFrame(columns=part_col) - - for _, data in pcb_data.iterrows(): - part, nozzle = data.part, data.nz.split(' ')[1] - if part not in component_data['part'].values: - component_data = pd.concat([component_data, pd.DataFrame( - [part, '', 'SM8', nozzle, '飞行相机1', 'CHIP-Rect', self.default_feeder_limit, 0], index=part_col).T], - ignore_index=True) - - part_index = component_data[component_data['part'] == part].index.tolist()[0] - component_data.loc[part_index, 'points'] += 1 self.counter += 1 - return pcb_data, component_data + return pcb_data, self.component_data - def recorder(self, file_path, info: OptInfo, pcb_data, component_data): + def recorder(self, file_handle, info: OptInfo, pcb_data, component_data): lineinfo = '{:.6f}'.format(info.placement_time) + '\t' + str(info.cycle_counter) + '\t' + str( info.nozzle_change_counter) + '\t' + str(info.pickup_counter) + '\t' + '{:.3f}'.format( info.pickup_movement) + '\t' + '{:.3f}'.format(info.placement_movement) @@ -62,6 +70,11 @@ class DataMgr: lineinfo += '\t' + '{:.3f}'.format(pcb_data['x'].max() - pcb_data['x'].min()) + '\t' + '{:.3f}'.format( pcb_data['y'].max() - pcb_data['y'].min()) + part_xposition, part_yposition = defaultdict(list), defaultdict(list) + for _, data in pcb_data.iterrows(): + part_xposition[data['part']].append(data['x']) + part_yposition[data['part']].append(data['y']) + point_counter, component_counter = 0, 0 nozzle_type = set() for _, data in component_data.iterrows(): @@ -75,11 +88,12 @@ class DataMgr: for _, data in component_data.iterrows(): lineinfo += '\t' + data.part + '\t' + data.nz + '\t' + str(data.points) - lineinfo += '\n' + # lineinfo += '\t' + str( + # round((np.average(part_xposition[data.part]) + stopper_pos[0] - slotf1_pos[0]) / slot_interval)) + + lineinfo += '\n' + file_handle.write(lineinfo) - with open(file_path, 'a') as f: - f.write(lineinfo) - f.close() def saver(self, file_path: str, pcb_data): lineinfo = '' @@ -103,12 +117,23 @@ class DataMgr: for idx, nozzle in enumerate(self.nozzle_type_list): cp2nz[nozzle] = idx + # === general info === total_points = sum(points for points in cp_points.values()) total_component_types, total_nozzle_types = len(cp_points.keys()), len(set(cp_nozzle.values())) data = [total_points, total_component_types, total_nozzle_types] data.extend([width, height]) + # === nozzle info === + data_slice = [0 for _ in range(len(self.nozzle_type_list))] for component, points in cp_points.items(): + idx = cp2nz[cp_nozzle[component]] + data_slice[idx] += points + data.extend(data_slice) + + # === component info === + cp_items = [[component, points] for component, points in cp_points.items()] + cp_items = sorted(cp_items, key=lambda x: (-x[1], x[0])) + for component, points in cp_items: nozzle = cp_nozzle[component] data_slice = [0 for _ in range(len(self.nozzle_type_list))] @@ -120,15 +145,43 @@ class DataMgr: return data + def decode(self, line_info): + boundary = [random.choice(self.x_range), random.choice(self.y_range)] + items = line_info.split('\t') + total_points, total_component_types = int(items[8]), int(items[9]) + + part_col = ["part", "desc", "fdr", "nz", 'camera', 'group', 'feeder-limit', 'points'] + step_col = ["ref", "x", "y", "z", "r", "part", "desc", "fdr", "nz", "hd", "cs", "cy", "sk", "bl", "ar", "pl", + "lv"] + + component_data = pd.DataFrame(columns=part_col) + pcb_data = pd.DataFrame(columns=step_col) + + idx = 1 + for cp_counter in range(total_component_types): + # todo: 这里为了调试暂时未修改 + part, nozzle = items[11 + cp_counter * 3], items[12 + cp_counter * 3] + points = int(items[13 + cp_counter * 3]) + + component_data = pd.concat([component_data, pd.DataFrame( + [part, '', 'SM8', nozzle, '飞行相机1', 'CHIP-Rect', self.default_feeder_limit, points], index=part_col).T], + ignore_index=True) + + for _ in range(points): + pos_x, pos_y = np.random.uniform(0, boundary[0]), np.random.uniform(0, boundary[1]) + pcb_data = pd.concat([pcb_data, pd.DataFrame([['R' + str(idx), -pos_x, pos_y, 0.000, 0.000, part, '', + 'A', '1-0 ' + nozzle, 1, 1, 1, 0, 1, 1, 1, 'L0']], + columns=pcb_data.columns)], ignore_index=True) + return pcb_data, component_data + def loader(self, file_path): train_data, time_data = [], [] cycle_data, nozzle_change_data, pickup_data, movement_data, point_data = [], [], [], [], [] - pcb_width, pcb_height = [], [] with open(file_path, 'r') as file: line = file.readline() while line: items = line.split('\t') - total_points, total_component_types = int(items[8]), int(items[9]) + total_points, total_component_types = float(items[8]), float(items[9]) cycle_data.append(float(items[1])) nozzle_change_data.append(float(items[2])) @@ -140,7 +193,7 @@ class DataMgr: time_data.append(float(items[0])) cp_points, cp_nozzle = defaultdict(int), defaultdict(str) - for cp_counter in range(total_component_types): + for cp_counter in range(int(total_component_types)): component_type, nozzle_type = items[11 + cp_counter * 3], items[12 + cp_counter * 3] points = int(items[13 + cp_counter * 3]) @@ -152,5 +205,8 @@ class DataMgr: return train_data, time_data, cycle_data, nozzle_change_data, pickup_data, movement_data, point_data def get_feature(self): - return self.max_component_types * len(self.nozzle_type_list) + 5 + return (self.max_component_types + 1) * len(self.nozzle_type_list) + 5 + + def get_update_round(self): + return self.update diff --git a/optimizer.py b/optimizer.py index 8312848..4110d1f 100644 --- a/optimizer.py +++ b/optimizer.py @@ -24,7 +24,7 @@ def optimizer(pcb_data, component_data, line_optimizer, machine_optimizer, machi return assignment_result_cpy = copy.deepcopy(assignment_result) - placement_points, placement_time = [], [] + placement_points, assembly_info = [], [] partial_pcb_data, partial_component_data = defaultdict(pd.DataFrame), defaultdict(pd.DataFrame) for machine_index in range(machine_number): partial_pcb_data[machine_index] = pd.DataFrame(columns=pcb_data.columns) @@ -128,24 +128,33 @@ def optimizer(pcb_data, component_data, line_optimizer, machine_optimizer, machi for info in part_info: partial_component_data[machine_index].loc[info[0], 'feeder-limit'] = math.ceil(info[2] / max_avl_feeder) - placement_time.append(base_optimizer(machine_index + 1, data, partial_component_data[machine_index], + assembly_info.append(base_optimizer(machine_index + 1, data, partial_component_data[machine_index], feeder_data=pd.DataFrame(columns=['slot', 'part', 'arg']), - method=machine_optimizer, hinter=True).placement_time) + method=machine_optimizer, hinter=True)) - average_time, standard_deviation_time = sum(placement_time) / machine_number, 0 + with open('model/lr_model.pkl', 'rb') as f: + lr = pickle.load(f) + + average_time, standard_deviation_time = sum( + [assembly_info[m].placement_time for m in range(machine_number)]) / machine_number, 0 for machine_index in range(machine_number): - total_component_types = 0 - for points in assignment_result_cpy[machine_index]: - if points: - total_component_types += 1 - print('assembly time for machine ' + str(machine_index + 1) + ': ' + str( - placement_time[machine_index]) + ' s, ' + 'total placements: ' + str(placement_points[machine_index]) - + ', total component types: ' + str(total_component_types)) - standard_deviation_time += pow(placement_time[machine_index] - average_time, 2) + total_component_types = sum(1 if pt else 0 for pt in assignment_result_cpy[machine_index]) + placement_time = assembly_info[machine_index].placement_time + + regression_time = lr.coef_[0][0] * assembly_info[machine_index].cycle_counter + lr.coef_[0][1] * assembly_info[ + machine_index].nozzle_change_counter + lr.coef_[0][2] * assembly_info[machine_index].pickup_counter + \ + lr.coef_[0][3] * assembly_info[machine_index].pickup_movement + lr.coef_[0][4] * \ + placement_points[machine_index] + lr.intercept_[0] + + print(f'assembly time for machine {machine_index + 1: d}: {placement_time: .3f} s, total placement: ' + f'{placement_points[machine_index]}, total component types {total_component_types: d}', end=', ') + print(f'regression time: {regression_time: .3f} s') + standard_deviation_time += pow(placement_time - average_time, 2) standard_deviation_time /= machine_number standard_deviation_time = math.sqrt(standard_deviation_time) - print('finial assembly time: ' + str(max(placement_time)) + 's, standard deviation: ' + str(standard_deviation_time)) + print(f'finial assembly time: {max(info.placement_time for info in assembly_info): .3f} s, ' + f'standard deviation: {standard_deviation_time: .3f}') @timer_wrapper @@ -169,6 +178,7 @@ def main(): # 加载PCB数据 pcb_data, component_data, _ = load_data(params.filename, default_feeder_limit=params.feeder_limit, cp_auto_register=params.auto_register, load_feeder_data=False) # 加载PCB数据 + optimizer(pcb_data, component_data, params.line_optimizer, params.machine_optimizer, params.machine_number) diff --git a/optimizer_genetic.py b/optimizer_genetic.py index bcf5635..20a45dd 100644 --- a/optimizer_genetic.py +++ b/optimizer_genetic.py @@ -283,7 +283,6 @@ def assemblyline_optimizer_genetic(pcb_data, component_data, machine_number): # the number of generation: 500 crossover_rate, mutation_rate = 0.8, 0.1 population_size, n_generations = 200, 500 - # population_size, n_generations = 30, 50 # the number of placement points, the number of available feeders, and nozzle type of component respectively component_points, component_feeders, component_nozzle = defaultdict(int), defaultdict(int), defaultdict(str) @@ -300,7 +299,7 @@ def assemblyline_optimizer_genetic(pcb_data, component_data, machine_number): device = torch.device("cuda" if torch.cuda.is_available() else "cpu") net = Net(input_size=data_mgr.get_feature(), output_size=1).to(device) - net.load_state_dict(torch.load('model_state.pth')) + net.load_state_dict(torch.load('model/net_model.pth')) # optimizer = torch.optim.Adam(net.parameters(), lr=0.1) # optimizer.load_state_dict(torch.load('optimizer_state.pth')) @@ -361,6 +360,7 @@ def assemblyline_optimizer_genetic(pcb_data, component_data, machine_number): best_individual = population[np.argmax(pop_val)] val, assignment_result = cal_individual_val(component_points, component_feeders, component_nozzle, machine_number, best_individual, data_mgr, net) + print('final value: ', val) # available feeder check for part_index, data in component_data.iterrows(): diff --git a/optimizer_hyperheuristic.py b/optimizer_hyperheuristic.py index 3f0060e..94c347a 100644 --- a/optimizer_hyperheuristic.py +++ b/optimizer_hyperheuristic.py @@ -1,6 +1,8 @@ +import os import pickle import numpy as np +import torch.nn from base_optimizer.optimizer_interface import * from generator import * @@ -9,11 +11,11 @@ os.environ['KMP_DUPLICATE_LIB_OK'] = 'True' class Net(torch.nn.Module): - def __init__(self, input_size, output_size): + def __init__(self, input_size, hidden_size=1024, output_size=1): super(Net, self).__init__() - self.fc1 = torch.nn.Linear(input_size, 1024) + self.fc1 = torch.nn.Linear(input_size, hidden_size) self.relu = torch.nn.ReLU() # 激活函数 - self.fc2 = torch.nn.Linear(1024, output_size) + self.fc2 = torch.nn.Linear(hidden_size, output_size) def forward(self, x): x = self.fc1(x) @@ -22,6 +24,19 @@ class Net(torch.nn.Module): return x +class LSTMNet(torch.nn.Module): + def __init__(self, input_size, hidden_size=256, output_size=1, num_layers=1): + super(LSTMNet, self).__init__() + + self.lstm = torch.nn.LSTM(input_size, hidden_size, num_layers) + self.fc = torch.nn.Linear(hidden_size, output_size) + + def forward(self, x): + x, _ = self.lstm(x) # x is input with size (seq_len, batch_size, input_size) + x = self.fc(x) + return x[-1, :, ] + + def selective_initialization(component_points, population_size, machine_number): # assignment_result = [[0 for _ in range(len(component_points))] for _ in range(machine_number)] assignment_result = [] @@ -44,58 +59,74 @@ def optimizer_hyperheuristc(pcb_data, component_data, machine_number): if __name__ == '__main__': warnings.simplefilter(action='ignore', category=FutureWarning) - train_file, test_file = 'train_data.txt', 'test_data.txt' - num_epochs = 30000 + parser = argparse.ArgumentParser(description='network training implementation') + parser.add_argument('--train', default=True, type=bool, help='determine whether training the network') + parser.add_argument('--save', default=True, type=bool, + help='determine whether saving the parameters of network, linear regression model, etc.') + parser.add_argument('--overwrite', default=False, type=bool, + help='determine whether overwriting the training and testing data') + parser.add_argument('--train_file', default='train_data.txt', type=str, help='training file path') + parser.add_argument('--test_file', default='test_data.txt', type=str, help='testing file path') + parser.add_argument('--num_epochs', default=15000, type=int, help='number of epochs for training process') + parser.add_argument('--batch_size', default=100000, type=int, help='size of training batch') + parser.add_argument('--lr', default=1e-4, type=float, help='learning rate for the network') + + params = parser.parse_args() data_mgr = DataMgr() device = torch.device("cuda" if torch.cuda.is_available() else "cpu") - # batch_size = 40000 - # for _ in range(batch_size): - # pcb_data, component_data = data_mgr.generator() # random generate a PCB data - # # data_mgr.remover() # 移除最近一次保存数据 - # # data_mgr.saver('data/' + train_file, pcb_data) # 保存新数据 - # - # info = base_optimizer(1, pcb_data, component_data, - # feeder_data=pd.DataFrame(columns=['slot', 'part', 'arg']), method='feeder_scan', - # hinter=True) - # - # data_mgr.recorder('opt/' + train_file, info, pcb_data, component_data) + if params.overwrite: + file = {params.train_file: params.batch_size, + params.test_file: params.batch_size // data_mgr.get_update_round() // 5} + for file_name, file_batch_size in file.items(): + for _ in range(int(file_batch_size)): + with open('opt/' + file_name, 'a') as f: + mode = file_name.split('.')[0].split('_')[0] + pcb_data, component_data = data_mgr.generator(mode) # random generate a PCB data + # data_mgr.remover() # remove the last saved data + # data_mgr.saver('data/' + file_name, pcb_data) # save new data - train, save = True, True - learning_rate = 0.0005 + info = base_optimizer(1, pcb_data, component_data, + feeder_data=pd.DataFrame(columns=['slot', 'part', 'arg']), + method='feeder_scan', + hinter=True) + + data_mgr.recorder(f, info, pcb_data, component_data) + f.close() net = Net(input_size=data_mgr.get_feature(), output_size=1).to(device) - if train: - data = data_mgr.loader('opt/' + train_file) + if params.train: + data = data_mgr.loader('opt/' + params.train_file) x_fit, y_fit = np.array(data[2:]).T, np.array([data[1]]).T lr = LinearRegression() lr.fit(x_fit, y_fit) - x_train, y_train = np.array(data[0]), lr.predict(x_fit) # np.array(data[1]) + x_train, y_train = np.array(data[0][::10]), lr.predict(x_fit[::10]) + # x_train, y_train = np.array(data[0]), np.array(data[2]) + x_train = torch.from_numpy(x_train.reshape((-1, np.shape(x_train)[1]))).float().to(device) y_train = torch.from_numpy(y_train.reshape((-1, 1))).float().to(device) - optimizer = torch.optim.Adam(net.parameters(), lr=learning_rate) - # scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=1000, gamma=0.1) + optimizer = torch.optim.Adam(net.parameters(), lr=params.lr) + # scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=6000, gamma=0.8) loss_func = torch.nn.MSELoss() - for epoch in range(num_epochs): + for epoch in range(params.num_epochs): pred = net(x_train) loss = loss_func(pred, y_train) optimizer.zero_grad() loss.backward() optimizer.step() # scheduler.step() - if epoch % 200 == 0: + if epoch % 50 == 0: print('Epoch: ', epoch, ', Loss: ', loss.item()) if loss.item() < 1e-4: break net_predict = net(x_train).view(-1) - # pred_time, real_time = net_predict.cpu().detach().numpy(), y_train.view(-1).cpu().detach().numpy() - pred_time, real_time = net_predict.cpu().detach().numpy(), np.array(data[1]) + pred_time, real_time = net_predict.cpu().detach().numpy(), y_train.view(-1).cpu().detach().numpy() pred_error = np.array([]) for t1, t2 in np.nditer([pred_time, real_time]): @@ -107,21 +138,24 @@ if __name__ == '__main__': mse = np.linalg.norm((net_predict - y_train.view(-1)).cpu().detach().numpy()) print(f'mean square error for training data result : {mse: 2f} ') - if save: - torch.save(net.state_dict(), 'model_state.pth') - with open('lr_model.pkl', 'wb') as f: + if params.save: + if not os.path.exists('model'): + os.mkdir('model') + torch.save(net.state_dict(), 'model/net_model.pth') + with open('model/lr_model.pkl', 'wb') as f: pickle.dump(lr, f) - joblib.dump(lr, "lr_model.m") - # torch.save(optimizer.state_dict(), 'optimizer_state.pth') + # torch.save(optimizer.state_dict(), 'model/optimizer_state.pth') else: - with open('lr_model.pkl', 'rb') as f: + with open('model/lr_model.pkl', 'rb') as f: lr = pickle.load(f) - net.load_state_dict(torch.load('model_state.pth')) + net.load_state_dict(torch.load('model/net_model.pth')) # optimizer = torch.optim.Adam(net.parameters(), lr=learning_rate) - # optimizer.load_state_dict(torch.load('optimizer_state.pth')) + # optimizer.load_state_dict(torch.load('model/optimizer_state.pth')) - data = data_mgr.loader('opt/' + test_file) + data = data_mgr.loader('opt/' + params.test_file) + # x_test, y_test = np.array(data[0]), np.array(data[1]) x_test, y_test = np.array(data[0]), lr.predict(np.array(data[2:]).T) + x_test, y_test = torch.from_numpy(x_test.reshape((-1, np.shape(x_test)[1]))).float().to(device), \ torch.from_numpy(y_test.reshape((-1, 1))).float().to(device) @@ -133,7 +167,8 @@ if __name__ == '__main__': pred_error = np.array([]) for t1, t2 in np.nditer([pred_time, real_time]): pred_error = np.append(pred_error, abs(t1 - t2) / (t2 + 1e-10) * 100) - + print(pred_time) + print(real_time) print('--------------------------------------') print(f'average prediction error for test data : {np.average(pred_error): .2f}% ') print(f'maximum prediction error for test data : {np.max(pred_error): .2f}% ')