def DRLagent_generator(filename): grid_info = init.read(filename) for item in init.gridParameters(grid_info).items(): print(item) gridParameters = init.gridParameters(grid_info) # # GridGraph graphcase = graph.GridGraph(init.gridParameters(grid_info)) capacity = graphcase.generate_capacity() gridX, gridY, gridZ = graphcase.generate_grid() # Real Router for Multiple Net # Note: pinCoord input as absolute length coordinates gridGraphSearch = twoPinASearch.AStarSearchGraph(gridParameters, capacity) # Sort net halfWireLength = init.VisualGraph( init.gridParameters(grid_info)).bounding_length() sortedHalfWireLength = sorted(halfWireLength.items(), key=operator.itemgetter(1), reverse=True) # Large2Small netSort = [] for i in range(gridParameters['numNet']): order = int(sortedHalfWireLength[i][0]) netSort.append(order) routeListMerged = [] routeListNotMerged = [] # Getting two pin list combo (For RL) twopinListCombo = [] for i in range(len(init.gridParameters(grid_info)['netInfo'])): netNum = i netPinList = [] netPinCoord = [] for j in range(0, gridParameters['netInfo'][netNum]['numPins']): pin = tuple([ int((gridParameters['netInfo'][netNum][str(j + 1)][0] - gridParameters['Origin'][0]) / gridParameters['tileWidth']), int((gridParameters['netInfo'][netNum][str(j + 1)][1] - gridParameters['Origin'][1]) / gridParameters['tileHeight']), int(gridParameters['netInfo'][netNum][str(j + 1)][2]), int(gridParameters['netInfo'][netNum][str(j + 1)][0]), int(gridParameters['netInfo'][netNum][str(j + 1)][1]) ]) if pin[0:3] in netPinCoord: continue else: netPinList.append(pin) netPinCoord.append(pin[0:3]) twoPinList = [] for i in range(len(netPinList) - 1): pinStart = netPinList[i] pinEnd = netPinList[i + 1] twoPinList.append([pinStart, pinEnd]) # print('Two pin list vanilla:',twoPinList,'\n') twoPinListVanilla = twoPinList # Insert Tree method to decompose two pin problems here twoPinList = tree.generateMST(twoPinList) # Remove pin pairs that are in the same grid nullPairList = [] for i in range(len(twoPinListVanilla)): if twoPinListVanilla[i][0][:3] == twoPinListVanilla[i][1][:3]: nullPairList.append(twoPinListVanilla[i]) for i in range(len(nullPairList)): twoPinListVanilla.reomove(nullPairList[i]) # Remove pin pairs that are in the same grid nullPairList = [] for i in range(len(twoPinList)): if twoPinList[i][0][:3] == twoPinList[i][1][:3]: nullPairList.append(twoPinList[i]) for i in range(len(nullPairList)): twoPinList.reomove(nullPairList[i]) # Key: use original sequence of two pin pairs # twopinListCombo.append(twoPinListVanilla) for i in range(len(init.gridParameters(grid_info)['netInfo'])): netNum = int(sortedHalfWireLength[i][0]) # i # Sort the pins by a heuristic such as Min Spanning Tree or Rectilinear Steiner Tree netPinList = [] netPinCoord = [] for j in range(0, gridParameters['netInfo'][netNum]['numPins']): pin = tuple([ int((gridParameters['netInfo'][netNum][str(j + 1)][0] - gridParameters['Origin'][0]) / gridParameters['tileWidth']), int((gridParameters['netInfo'][netNum][str(j + 1)][1] - gridParameters['Origin'][1]) / gridParameters['tileHeight']), int(gridParameters['netInfo'][netNum][str(j + 1)][2]), int(gridParameters['netInfo'][netNum][str(j + 1)][0]), int(gridParameters['netInfo'][netNum][str(j + 1)][1]) ]) if pin[0:3] in netPinCoord: continue else: netPinList.append(pin) netPinCoord.append(pin[0:3]) twoPinList = [] for i in range(len(netPinList) - 1): pinStart = netPinList[i] pinEnd = netPinList[i + 1] twoPinList.append([pinStart, pinEnd]) # Insert Tree method to decompose two pin problems here twoPinList = tree.generateMST(twoPinList) # Remove pin pairs that are in the same grid nullPairList = [] for i in range(len(twoPinList)): if twoPinList[i][0][:3] == twoPinList[i][1][:3]: nullPairList.append(twoPinList[i]) for i in range(len(nullPairList)): twoPinList.reomove(nullPairList[i]) # Key: Use MST sorted pin pair sequence under half wirelength sorted nets twopinListCombo.append(twoPinList) # for i in range(1): for i in range(len(init.gridParameters(grid_info)['netInfo'])): # Determine nets to wire based on sorted nets (stored in list sortedHalfWireLength) # print('Routing net No.',init.gridParameters(grid_info)['netInfo'][int(sortedHalfWireLength[i][0])]['netName']) # (above output is to get actual netName) netNum = int(sortedHalfWireLength[i][0]) # Sort the pins by a heuristic such as Min Spanning Tree or Rectilinear Steiner Tree netPinList = [] netPinCoord = [] for j in range(0, gridParameters['netInfo'][netNum]['numPins']): pin = tuple([ int((gridParameters['netInfo'][netNum][str(j + 1)][0] - gridParameters['Origin'][0]) / gridParameters['tileWidth']), int((gridParameters['netInfo'][netNum][str(j + 1)][1] - gridParameters['Origin'][1]) / gridParameters['tileHeight']), int(gridParameters['netInfo'][netNum][str(j + 1)][2]), int(gridParameters['netInfo'][netNum][str(j + 1)][0]), int(gridParameters['netInfo'][netNum][str(j + 1)][1]) ]) if pin[0:3] in netPinCoord: continue else: netPinList.append(pin) netPinCoord.append(pin[0:3]) twoPinList = [] for i in range(len(netPinList) - 1): pinStart = netPinList[i] pinEnd = netPinList[i + 1] twoPinList.append([pinStart, pinEnd]) # Insert Tree method to decompose two pin problems here twoPinList = tree.generateMST(twoPinList) # Remove pin pairs that are in the same grid nullPairList = [] for i in range(len(twoPinList)): if twoPinList[i][0][:3] == twoPinList[i][1][:3]: nullPairList.append(twoPinList[i]) for i in range(len(nullPairList)): twoPinList.reomove(nullPairList[i]) i = 1 routeListSingleNet = [] for twoPinPair in twoPinList: pinStart = twoPinPair[0] pinEnd = twoPinPair[1] route, cost = twoPinASearch.AStarSearchRouter( pinStart, pinEnd, gridGraphSearch) routeListSingleNet.append(route) i += 1 mergedrouteListSingleNet = [] for list in routeListSingleNet: # if len(routeListSingleNet[0]) == 2: # mergedrouteListSingleNet.append(list[0]) # mergedrouteListSingleNet.append(list[1]) # else: for loc in list: if loc not in mergedrouteListSingleNet: mergedrouteListSingleNet.append(loc) routeListMerged.append(mergedrouteListSingleNet) routeListNotMerged.append(routeListSingleNet) twopinlist_nonet = [] for net in twopinListCombo: for pinpair in net: twopinlist_nonet.append(pinpair) # Get two pin numbers twoPinNum = 0 twoPinNumEachNet = [] for i in range(len(init.gridParameters(grid_info)['netInfo'])): netNum = int(sortedHalfWireLength[i][0]) # i twoPinNum = twoPinNum + ( init.gridParameters(grid_info)['netInfo'][netNum]['numPins'] - 1) twoPinNumEachNet.append( init.gridParameters(grid_info)['netInfo'][netNum]['numPins'] - 1) graphcase.max_step = 50 #20 graphcase.twopin_combo = twopinlist_nonet graphcase.net_pair = twoPinNumEachNet # Setting the session to allow growth, so it doesn't allocate all GPU memory. gpu_ops = tf.GPUOptions(allow_growth=True) config = tf.ConfigProto(gpu_options=gpu_ops) sess = tf.Session(config=config) # Setting this as the default tensorflow session. keras.backend.tensorflow_backend.set_session(sess) # You want to create an instance of the DQN_Agent class here, and then train / test it. model_path = '../model/' data_path = '../data/' environment_name = 'grid' if not os.path.exists(model_path): os.makedirs(model_path) if not os.path.exists(data_path): os.makedirs(data_path) agent = DQN_Implementation.DQN_Agent(environment_name, sess, graphcase) episodes = agent.max_episodes return agent, episodes, model_path, data_path, environment_name
# pinEnd = tuple([int((gridParameters['netInfo'][netNum][str(j+1)][0]-gridParameters['Origin'][0])/gridParameters['tileWidth']), # int((gridParameters['netInfo'][netNum][str(j+1)][1]-gridParameters['Origin'][1])/gridParameters['tileHeight']), # int(gridParameters['netInfo'][netNum][str(j+1)][2]), # int(gridParameters['netInfo'][netNum][str(j+1)][0]), # int(gridParameters['netInfo'][netNum][str(j+1)][1])]) # # # Remove pin pairs that are in the same grid # if pinStart[:3] == pinEnd[:3]: # continue # else: # twoPinList.append([pinStart,pinEnd]) # print('Two pin list:',twoPinList,'\n') # Insert Tree method to decompose two pin problems here twoPinList = tree.generateMST(twoPinList) # print('Two pin list after:', twoPinList, '\n') # Remove pin pairs that are in the same grid again nullPairList = [] for i in range(len(twoPinList)): if twoPinList[i][0][:3] == twoPinList[i][1][:3]: nullPairList.append(twoPinList[i]) for i in range(len(nullPairList)): twoPinList.reomove(nullPairList[i]) i = 1 routeListSingleNet = [] for twoPinPair in twoPinList: pinStart = twoPinPair[0]
def DRL_implementation(filename, globali): try: # Filename corresponds to benchmark to route # filename = '3d.txt' # filename = '8by8small.gr' # 8-by-8 10 nets toy sample # filename = '8by8simplee.gr' # 8-by-8 10 nets toy sample # filename = 'adaptecSmall.gr' # filename = '4by4small.gr' # 3-by-3 nets toy sample # filename = '4by4simple.gr' # 3-by-3 nets toy sample # filename = 'adaptec1.capo70.2d.35.50.90.gr' # # Getting Net Info grid_info = init.read(filename) gridParameters = init.gridParameters(grid_info) # # GridGraph graphcase = graph.GridGraph(init.gridParameters(grid_info)) capacity = graphcase.generate_capacity() # print ('capacity before route: ',capacity.shape) gridX, gridY, gridZ = graphcase.generate_grid() # Real Router for Multiple Net # Note: pinCoord input as absolute length coordinates gridGraphSearch = twoPinASearch.AStarSearchGraph( gridParameters, capacity) # Sort net halfWireLength = init.VisualGraph( init.gridParameters(grid_info)).bounding_length() # print('Half Wire Length:',halfWireLength) sortedHalfWireLength = sorted(halfWireLength.items(), key=operator.itemgetter(1), reverse=True) # Large2Small # sortedHalfWireLength = sorted(halfWireLength.items(),key=operator.itemgetter(1),reverse=False) # Small2Large netSort = [] for i in range(gridParameters['numNet']): order = int(sortedHalfWireLength[i][0]) netSort.append(order) # random order the nets # print('netSort Before',netSort) # random.shuffle(netSort) # print('netSort After',netSort) routeListMerged = [] routeListNotMerged = [] # Getting two pin list combo (For RL) twopinListCombo = [] twopinListComboCleared = [] for i in range(len(init.gridParameters(grid_info)['netInfo'])): netNum = i netPinList = [] netPinCoord = [] for j in range(0, gridParameters['netInfo'][netNum]['numPins']): pin = tuple([ int((gridParameters['netInfo'][netNum][str(j + 1)][0] - gridParameters['Origin'][0]) / gridParameters['tileWidth']), int((gridParameters['netInfo'][netNum][str(j + 1)][1] - gridParameters['Origin'][1]) / gridParameters['tileHeight']), int(gridParameters['netInfo'][netNum][str(j + 1)][2]), int(gridParameters['netInfo'][netNum][str(j + 1)][0]), int(gridParameters['netInfo'][netNum][str(j + 1)][1]) ]) if pin[0:3] in netPinCoord: continue else: netPinList.append(pin) netPinCoord.append(pin[0:3]) twoPinList = [] for i in range(len(netPinList) - 1): pinStart = netPinList[i] pinEnd = netPinList[i + 1] twoPinList.append([pinStart, pinEnd]) twoPinListVanilla = twoPinList # Insert Tree method to decompose two pin problems here twoPinList = tree.generateMST(twoPinList) # print('Two pin list after:', twoPinList, '\n') # Remove pin pairs that are in the same grid nullPairList = [] for i in range(len(twoPinListVanilla)): if twoPinListVanilla[i][0][:3] == twoPinListVanilla[i][1][:3]: nullPairList.append(twoPinListVanilla[i]) for i in range(len(nullPairList)): twoPinListVanilla.reomove(nullPairList[i]) # Remove pin pairs that are in the same grid nullPairList = [] for i in range(len(twoPinList)): if twoPinList[i][0][:3] == twoPinList[i][1][:3]: nullPairList.append(twoPinList[i]) for i in range(len(nullPairList)): twoPinList.reomove(nullPairList[i]) # Key: use original sequence of two pin pairs twopinListComboCleared.append(twoPinListVanilla) # print('twopinListComboCleared',twopinListComboCleared) twoPinEachNetClear = [] for i in twopinListComboCleared: num = 0 for j in i: num = num + 1 twoPinEachNetClear.append(num) # print('twoPinEachNetClear',twoPinEachNetClear) for i in range(len(init.gridParameters(grid_info)['netInfo'])): netNum = int(sortedHalfWireLength[i][0]) # i # Sort the pins by a heuristic such as Min Spanning Tree or Rectilinear Steiner Tree netPinList = [] netPinCoord = [] for j in range(0, gridParameters['netInfo'][netNum]['numPins']): pin = tuple([ int((gridParameters['netInfo'][netNum][str(j + 1)][0] - gridParameters['Origin'][0]) / gridParameters['tileWidth']), int((gridParameters['netInfo'][netNum][str(j + 1)][1] - gridParameters['Origin'][1]) / gridParameters['tileHeight']), int(gridParameters['netInfo'][netNum][str(j + 1)][2]), int(gridParameters['netInfo'][netNum][str(j + 1)][0]), int(gridParameters['netInfo'][netNum][str(j + 1)][1]) ]) if pin[0:3] in netPinCoord: continue else: netPinList.append(pin) netPinCoord.append(pin[0:3]) twoPinList = [] for i in range(len(netPinList) - 1): pinStart = netPinList[i] pinEnd = netPinList[i + 1] twoPinList.append([pinStart, pinEnd]) # Insert Tree method to decompose two pin problems here twoPinList = tree.generateMST(twoPinList) # print('Two pin list after:', twoPinList, '\n') # Remove pin pairs that are in the same grid nullPairList = [] for i in range(len(twoPinList)): if twoPinList[i][0][:3] == twoPinList[i][1][:3]: nullPairList.append(twoPinList[i]) for i in range(len(nullPairList)): twoPinList.reomove(nullPairList[i]) # Key: Use MST sorted pin pair sequence under half wirelength sorted nets twopinListCombo.append(twoPinList) # print('twopinListCombo',twopinListCombo) # for i in range(1): for i in range(len(init.gridParameters(grid_info)['netInfo'])): # Determine nets to wire based on sorted nets (stored in list sortedHalfWireLength) # print('*********************') # print('Routing net No.',init.gridParameters(grid_info)['netInfo'][int(sortedHalfWireLength[i][0])]['netName']) # (above output is to get actual netName) # print('Routing net No.',sortedHalfWireLength[i][0]) netNum = int(sortedHalfWireLength[i][0]) # Sort the pins by a heuristic such as Min Spanning Tree or Rectilinear Steiner Tree netPinList = [] netPinCoord = [] for j in range(0, gridParameters['netInfo'][netNum]['numPins']): pin = tuple([ int((gridParameters['netInfo'][netNum][str(j + 1)][0] - gridParameters['Origin'][0]) / gridParameters['tileWidth']), int((gridParameters['netInfo'][netNum][str(j + 1)][1] - gridParameters['Origin'][1]) / gridParameters['tileHeight']), int(gridParameters['netInfo'][netNum][str(j + 1)][2]), int(gridParameters['netInfo'][netNum][str(j + 1)][0]), int(gridParameters['netInfo'][netNum][str(j + 1)][1]) ]) if pin[0:3] in netPinCoord: continue else: netPinList.append(pin) netPinCoord.append(pin[0:3]) twoPinList = [] for i in range(len(netPinList) - 1): pinStart = netPinList[i] pinEnd = netPinList[i + 1] twoPinList.append([pinStart, pinEnd]) # Insert Tree method to decompose two pin problems here twoPinList = tree.generateMST(twoPinList) # Remove pin pairs that are in the same grid nullPairList = [] for i in range(len(twoPinList)): if twoPinList[i][0][:3] == twoPinList[i][1][:3]: nullPairList.append(twoPinList[i]) for i in range(len(nullPairList)): twoPinList.reomove(nullPairList[i]) i = 1 routeListSingleNet = [] for twoPinPair in twoPinList: pinStart = twoPinPair[0] pinEnd = twoPinPair[1] route, cost = twoPinASearch.AStarSearchRouter( pinStart, pinEnd, gridGraphSearch) routeListSingleNet.append(route) i += 1 mergedrouteListSingleNet = [] for list in routeListSingleNet: # if len(routeListSingleNet[0]) == 2: # mergedrouteListSingleNet.append(list[0]) # mergedrouteListSingleNet.append(list[1]) # else: for loc in list: if loc not in mergedrouteListSingleNet: mergedrouteListSingleNet.append(loc) routeListMerged.append(mergedrouteListSingleNet) routeListNotMerged.append(routeListSingleNet) # Update capacity and grid graph after routing one pin pair # # WARNING: there are some bugs in capacity update # # # print(route) # capacity = graph.updateCapacity(capacity, mergedrouteListSingleNet) # gridGraph = twoPinASearch.AStarSearchGraph(gridParameters, capacity) # print('\nRoute List Merged:',routeListMerged) twopinlist_nonet = [] for net in twopinListCombo: for pinpair in net: twopinlist_nonet.append(pinpair) # Get two pin numbers twoPinNum = 0 twoPinNumEachNet = [] for i in range(len(init.gridParameters(grid_info)['netInfo'])): netNum = int(sortedHalfWireLength[i][0]) # i twoPinNum = twoPinNum + ( init.gridParameters(grid_info)['netInfo'][netNum]['numPins'] - 1) twoPinNumEachNet.append( init.gridParameters(grid_info)['netInfo'][netNum]['numPins'] - 1) # print('twoPinNumEachNet debug1: ',twoPinNumEachNet) # print('twopinlist_nonet',twopinlist_nonet) # DRL Module from here graphcase.max_step = 50 #20 graphcase.twopin_combo = twopinlist_nonet graphcase.net_pair = twoPinNumEachNet # print('graphcase.twopin_combo',graphcase.twopin_combo) # Setting the session to allow growth, so it doesn't allocate all GPU memory. gpu_ops = tf.GPUOptions(allow_growth=True) config = tf.ConfigProto(gpu_options=gpu_ops) sess = tf.Session(config=config) # Setting this as the default tensorflow session. keras.backend.tensorflow_backend.set_session(sess) # You want to create an instance of the DQN_Agent class here, and then train / test it. model_path = '../model/' data_path = '../data/' environment_name = 'grid' if not os.path.exists(model_path): os.makedirs(model_path) if not os.path.exists(data_path): os.makedirs(data_path) agent = DQN_Implementation.DQN_Agent(environment_name, sess, graphcase) # Burn in with search # Get a list of (observation, action, reward, observation_next, is_terminal) # with Route List Merged (solution given with A*search plus tree) graphcaseBurnIn = graph.GridGraph(init.gridParameters(grid_info)) graphcaseBurnIn.max_step = 10000 observationCombo = [] actionCombo = [] rewardCombo = [] observation_nextCombo = [] is_terminalCombo = [] for enumerator in range(300): for i in range(gridParameters['numNet']): goal = routeListMerged[i][-1] graphcaseBurnIn.goal_state = (goal[3], goal[4], goal[2], goal[0], goal[1]) for j in range(len(routeListMerged[i]) - 1): position = routeListMerged[i][j] nextposition = routeListMerged[i][j + 1] graphcaseBurnIn.current_state = (position[3], position[4], position[2], position[0], position[1]) # print(graphcaseBurnIn.state2obsv()) observationCombo.append(graphcaseBurnIn.state2obsv()) action = graph.get_action(position, nextposition) # print('action',action) actionCombo.append(action) graphcaseBurnIn.step(action) rewardCombo.append(graphcaseBurnIn.instantreward) # graphcaseBurnIn.current_state = (nextposition[3],nextposition[4], # nextposition[2],nextposition[0],nextposition[1]) observation_nextCombo.append(graphcaseBurnIn.state2obsv()) is_terminalCombo.append(False) is_terminalCombo[-1] = True # if testing using training function, comment burn_in agent.replay = DQN_Implementation.Replay_Memory( ) #Remove memeory of previous training agent.burn_in_memory_search(observationCombo, actionCombo, rewardCombo, observation_nextCombo, is_terminalCombo) twoPinNum = 0 twoPinNumEachNet = [] for i in range(len(init.gridParameters(grid_info)['netInfo'])): twoPinNum = twoPinNum + ( init.gridParameters(grid_info)['netInfo'][i]['numPins'] - 1) twoPinNumEachNet.append( init.gridParameters(grid_info)['netInfo'][i]['numPins'] - 1) # print ("Two pin num: ",len(graphcase.twopin_combo)) twoPinNum = len(graphcase.twopin_combo) twoPinNumEachNet = graphcase.twopin_combo # Training DRL savepath = model_path #32by32simple_model_train" # model_file = "../32by32simple_model_train/model_24000.ckpt" # print ('twoPinNumEachNet debug2',twoPinNumEachNet) # graphcase.max_step = 50 #20 # graphcase.twopin_combo = twopinlist_nonet # graphcase.net_pair = twoPinNumEachNet # Reinitialze grid graph parameters before training on new benchmarks agent.gridParameters = gridParameters agent.gridgraph.max_step = 50 agent.goal_state = None agent.init_state = None agent.gridgraph.capacity = capacity agent.gridgraph.route = [] agent.gridgraph.twopin_combo = twopinlist_nonet agent.gridgraph.twopin_pt = 0 agent.gridgraph.twopin_rdn = None agent.gridgraph.reward = 0.0 agent.gridgraph.instantreward = 0.0 agent.gridgraph.best_reward = 0.0 agent.gridgraph.best_route = [] agent.gridgraph.route_combo = [] agent.gridgraph.net_pair = twoPinEachNetClear agent.gridgraph.instantrewardcombo = [] agent.gridgraph.net_ind = 0 agent.gridgraph.pair_ind = 0 agent.gridgraph.posTwoPinNum = 0 agent.gridgraph.passby = np.zeros_like(capacity) agent.previous_action = -1 episodes = agent.max_episodes solution_combo_filled,reward_plot_combo,reward_plot_combo_pure,solutionTwoPin,posTwoPinNum \ = agent.train(twoPinNum,twoPinEachNetClear,netSort,savepath,model_file=None) # pkl.dump(solution_combo_filled,fileObject) # fileObject.close() # Generate output file for DRL solver # print('posTwoPinNum',posTwoPinNum) # print('len(graphcase.twopin_combo)',len(graphcase.twopin_combo)) if posTwoPinNum >= len(graphcase.twopin_combo): #twoPinNum: # Plot reward and save reward data n = np.linspace(1, episodes, len(reward_plot_combo)) plt.figure() plt.plot(n, reward_plot_combo) plt.xlabel('episodes') plt.ylabel('reward') plt.savefig('test_benchmark_{dumpBench}.DRLRewardPlot.jpg'.format( dumpBench=globali + 1)) # plt.show() # plt.close() n = np.linspace(1, episodes, len(reward_plot_combo_pure)) plt.figure() plt.plot(n, reward_plot_combo_pure) plt.xlabel('episodes') plt.ylabel('reward') plt.savefig( 'test_benchmark_{dumpBench}.DRLRewardPlotPure.jpg'.format( dumpBench=globali + 1)) filenameplot = '%s.rewardData' % filename np.save(filenameplot, reward_plot_combo) # dump solution of DRL f = open( 'solutionsDRL/test_benchmark_{dumpBench}.gr.DRLsolution'. format(dumpBench=globali + 1), 'w+') # for i in range(1): twoPinSolutionPointer = 0 routeListMerged = solution_combo_filled for i in range(gridParameters['numNet']): singleNetRouteCache = [] indicator = i netNum = int(sortedHalfWireLength[i][0]) # i i = netNum value = '{netName} {netID} {cost}\n'.format( netName=gridParameters['netInfo'][indicator]['netName'], netID=gridParameters['netInfo'][indicator]['netID'], cost=0) #max(0,len(routeListMerged[indicator])-1)) f.write(value) for j in range(len(routeListMerged[indicator]) - 1): a = routeListMerged[indicator][j] b = routeListMerged[indicator][j + 1] if (a[3], a[4], a[2], b[3], b[4], b[2]) not in singleNetRouteCache: singleNetRouteCache.append( (a[3], a[4], a[2], b[3], b[4], b[2])) singleNetRouteCache.append( (b[3], b[4], b[2], a[3], a[4], a[2])) diff = [ abs(a[2] - b[2]), abs(a[3] - b[3]), abs(a[4] - b[4]) ] if diff[1] > 2 or diff[2] > 2: continue elif diff[1] == 2 or diff[2] == 2: # print('Alert') continue elif diff[0] == 0 and diff[1] == 0 and diff[2] == 0: continue elif diff[0] + diff[1] + diff[2] >= 2: continue else: value = '({},{},{})-({},{},{})\n'.format( int(a[0]), int(a[1]), a[2], int(b[0]), int(b[1]), b[2]) f.write(value) twoPinSolutionPointer = twoPinSolutionPointer + 1 f.write('!\n') f.close() # Plot of routing for multilple net (RL solution) fig = plt.figure() ax = fig.add_subplot(111, projection='3d') ax.set_zlim(-0.5, 2.5) # Visualize solution for twoPinRoute in solutionTwoPin: x = [] y = [] z = [] for i in range(len(twoPinRoute)): # print(routeList[i]) # diff = [abs(routeList[i][2]-routeList[i+1][2]), # abs(routeList[i][3]-routeList[i+1][3]), # abs(routeList[i][4]-routeList[i+1][4])] # if diff[1] > 2 or diff[2] > 2: # continue # elif diff[1] == 2 or diff[2] == 2: # # print('Alert') # continue # elif diff[0] == 0 and diff[1] == 0 and diff[2] == 0: # continue # elif diff[0] + diff[1] + diff[2] >= 2: # continue # else: x.append(twoPinRoute[i][3]) y.append(twoPinRoute[i][4]) z.append(twoPinRoute[i][2]) ax.plot(x, y, z) plt.xlim([0, gridParameters['gridSize'][0] - 1]) plt.ylim([0, gridParameters['gridSize'][1] - 1]) plt.savefig( 'DRLRoutingVisualize test_benchmark_{dumpBench}.png'.format( dumpBench=globali + 1)) # plt.show() # plt.close() else: print("DRL fails with existing max episodes! : (") except IndexError: print("Invalid Benchmarks! ") agent.sess.close() tf.reset_default_graph() # graphcase.posTwoPinNum = 0 return