LU/smt-optimizer
1
1
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

修改生成数据方式和网络训练方式

Browse Source
This commit is contained in:
hit-lu
2024-04-06 13:44:05 +08:00
parent bae7e4e2c3
commit 6fa1f53f69
8 changed files with 194 additions and 96 deletions
Download Patch File Download Diff File Expand all files Collapse all files

134
generator.py
View File

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