def ejecuta(self): for f in self.ficheros: print(f) g = Greedy(f, self.semilla) antes = time.time() gs = g.greedy() despues = time.time() self.tiempos.append(despues - antes) self.valores.append(g.evalua_sol(gs)) self.imprime()
def test_sum_by_profit(self): ksf = KnapsackFile("test.txt") lines = ksf.getlines() items = Greedy.create_items(lines) weight_items = Greedy.sum_by_value(limit=6, list_of_items=items, func=lambda item: item.profit) self.assertIs(len(weight_items), 1) weight_items = Greedy.sum_by_value(limit=7, list_of_items=items, func=lambda item: item.profit) self.assertIs(len(weight_items), 2) weight_items = Greedy.sum_by_value(limit=9, list_of_items=items, func=lambda item: item.profit) self.assertIs(len(weight_items), 3)
def preorderDTLsort(DTLReconGraph, ParasiteRoot): """This takes in a DTL dictionary and parasite root and returns a sorted list, orderedKeysL, that is ordered by level from smallest to largest, where level 0 is the root and the highest level has tips.""" keysL = Greedy.orderDTL(DTLReconGraph, ParasiteRoot) uniqueKeysL = Greedy.sortHelper(DTLReconGraph, keysL) orderedKeysL = [] levelCounter = 0 while len(orderedKeysL) < len(uniqueKeysL): for mapping in uniqueKeysL: if mapping[-1] == levelCounter: orderedKeysL = orderedKeysL + [mapping] levelCounter += 1 return orderedKeysL
def main(): """Main function""" # Dictionary that stores all the nodes of the graph # in which the keys are the nodes' IDs dataNodes = {} # Readin data readInput(dataNodes) # Using Greedy algorithm Greedy.greedySearch(dataNodes, INITIAL_NODE, FINAL_NODE) # Using A* algorithm AStar.aStarSearch(dataNodes, INITIAL_NODE, FINAL_NODE)
def main(): """ Main function. Calls initailizing functions and then calls the requested Algorithm Args: None Returns: None Globals: None Called By: cmd.exe Calls: init() Greedy.init() """ instanceDir = init() if instanceDir == -1: return -1 for file in os.listdir(instanceDir): instance = Utility.init(instanceDir, file) result = Greedy.main(instance) Utility.outputFileGenerator(result, file)
def pre_process(self) -> dict: # obtain D2 greedy = Greedy.Greedy(self.G, INF, self.rho2, self.rho2, self.heuristic) greedy.run() self.D2 = greedy.D2 # print (self.D2) # gernerate subgraph for each node in D2 dic = {} for u in self.D2: sub = self.sub_graph(u) g = Greedy.Greedy(sub, INF, self.rho1, self.rho1, self.heuristic) g.run() # obtain D1 (actually D2 in Greedy output) dic[u] = g.D2 return dic
def test_sort_by_efficiency(self): ksf = KnapsackFile("test.txt") lines = ksf.getlines() items = Greedy.create_items(lines) items = Greedy.sort_by_efficiency(items, descending=True) last = 0.0 for i in items: if last is not 0.0: self.assertTrue(i.efficiency < last) last = i.efficiency items = Greedy.sort_by_efficiency(items, descending=False) last = 0.0 for i in items: if last is not 0.0: self.assertTrue(i.efficiency > last) last = i.efficiency
def test_item_creation(self): ksf = KnapsackFile("test.txt") lines = ksf.getlines() items = Greedy.create_items(lines) for i in items: self.assertIsInstance(i, Greedy.Item, "i is Not an Item object") self.assertIsNotNone(i, "Item creation failed.")
def main(): xDB = readJSON('res/xDB.json') bmDir = 'bm/fun' designers = [] designers.append(Greedy.GreedyDesigner(xDB, 'maxHeavy')) # MCDesigner # ... (avgD, minD, maxD) = getXDBStat() # Process all benchmarks for charFile in glob.glob(bmDir + '/*.csv'): with open(charFile, 'r') as file: pts = [[float(n) for n in re.split(', *| *', l.strip())] for l in file.read().split('\n')] spec = {'coms': pts} npts = np.asarray(pts) # Use total length/avgD as heuristic. avgD is average xDB pair distance targetLen = int(np.ceil(sum(np.linalg.norm(npts-np.roll(npts, 1, axis=0), axis=1)) / avgD)) for designer in designers: designerName = designer.__class__.__name__ print 'Benchmarking {} on {}, target length={}'.format( designerName, charFile, targetLen) startTime = time.clock() (nodes,shape,score) = designer.design(spec, targetLen) print "{:.2f}s, score: {}".format(time.clock() - startTime, score) makePdbFromNodes(xDB, nodes, 'res/centered_pdb/pair', charFile.replace('.csv', '_' + designerName + '_FUN.pdb'))
def estado_estadisticas(vista): global campo lim = 2000 carpeta = "IA_80" victorias = [] for i in range(0, lim + 1, 50): print(str(i)) network = import_network(carpeta + "/IA_java_" + str(i) + ".txt") contador_nn = 0 for j in range(200): campo = mdl.Campo() campo.rellenar(mdl.training_2, mdl.training_1) ia_greedy = Greedy.IA("T2", campo, 0.5) ia_nn = IA(network, "T1", campo, 0.5) tiempo = 0 while True: dt = 200 tiempo += dt campo.actualizar(dt / 1000) if campo.revisarDerrota("T1"): break elif campo.revisarDerrota("T2"): contador_nn += 1 break if tiempo > 600000: print("SE METIO EN UN LOOP") break ia_greedy.jugar(dt) ia_nn.jugar(dt) victorias.append(contador_nn) print(str(victorias)) return "menu"
def output_2(self, heu): # fix d datas_greedy = [['ER07', 'ER47', 'SF', 'NSM2', 'NSM10']] datas_R1 = [['ER07', 'ER47', 'SF', 'NSM2', 'NSM10']] datas_R2 = [['ER07', 'ER47', 'SF', 'NSM2', 'NSM10']] d = 10 for rho1 in range(1, 11): for rho2 in range(1, 11): avg_greedy = [0.0, 0.0, 0.0, 0.0, 0.0] avg_R1 = [0.0, 0.0, 0.0, 0.0, 0.0] avg_R2 = [0.0, 0.0, 0.0, 0.0, 0.0] for i in range(0, 5): er07 = self.ER(1000, 0.01) er47 = self.ER(1000, 0.04) sf = self.SF(1000) sm02 = self.SM(2) sm10 = self.SM(10) dic = {0: er07, 1: er47, 2: sf, 3: sm02, 4: sm10} for j in range(0, 5): g = Greedy.Greedy(dic[j], d, rho1, rho2, heu) g.run() avg_greedy[j] += len(g.D1) r1 = Replacement.ReplacementA(dic[j], d, rho1, rho2, heu) r1.run() avg_R1[j] += len(r1.D1) r2 = Replacement.ReplacementB(dic[j], d, rho1, rho2, heu) r2.run() avg_R2[j] += len(r2.D1) print(i) for j in range(0, 5): avg_greedy[j] = avg_greedy[j] / 10 avg_R1[j] = avg_R1[j] / 10 avg_R2[j] = avg_R2[j] / 10 datas_greedy.append(avg_greedy) datas_R1.append(avg_R1) datas_R2.append(avg_R2) with open('2_greedy_' + heu + '.csv', 'w', newline='') as f: writer = csv.writer(f) for row in datas_greedy: writer.writerow(row) with open('2_r1_' + heu + '.csv', 'w', newline='') as f: writer = csv.writer(f) for row in datas_R1: writer.writerow(row) with open('2_r2_' + heu + '.csv', 'w', newline='') as f: writer = csv.writer(f) for row in datas_R2: writer.writerow(row)
def preorderDTLsort(DTL, ParasiteRoot): """This takes in a DTL reconciliation graph and parasite root and returns a sorted list, orderedKeysL, that is ordered by level from largest to smallest, where level 0 is the root and the highest level has tips.""" keysL = Greedy.orderDTL(DTL, ParasiteRoot) uniqueKeysL = Greedy.sortHelper(DTL, keysL) orderedKeysL = [] levelCounter = 0 while len(orderedKeysL) < len(keysL): for mapping in keysL: if mapping[-1] == levelCounter: orderedKeysL = orderedKeysL + [mapping] levelCounter += 1 lastLevel = orderedKeysL[-1][1] return orderedKeysL
def runGreedy(nbmanchots, run, iterations): for i in range(run): tabMachines = creerManchots(nbmanchots) nbiterations2.append(i+1) gains2.append(g.Greedy(iterations, tabMachines)) print(gains2) return nbiterations2, gains2
def run_test(algorithm, dataset): if algorithm == "BruteForce": result = BruteForce.BruteForce(dataset[1]) test_result = TestResult(result[0], dataset[0][0], dataset[0][1], dataset[0][2], dataset[0][3], dataset[0][4], result[3], result[1], 1).get_result() elif algorithm == "BranchNBound": result = BranchNBound.BranchNBound(dataset[1]) test_result = TestResult(result[0], dataset[0][0], dataset[0][1], dataset[0][2], dataset[0][3], dataset[0][4], result[3], result[1], 1).get_result() elif algorithm == "Greedy": #bb_result = BranchNBound.BranchNBound(dataset[1]) result = Greedy.better_greedy(dataset[1]) test_result = TestResult(result[0], dataset[0][0], dataset[0][1], dataset[0][2], dataset[0][3], dataset[0][4], result[3], result[1], result[1]).get_result() elif algorithm == "Randomized": #bb_result = BranchNBound.BranchNBound(dataset[1]) result = Randomized.better_result_of_randomized(dataset[1]) test_result = TestResult(result[0], dataset[0][0], dataset[0][1], dataset[0][2], dataset[0][3], dataset[0][4], result[3], result[1], result[1]).get_result() elif algorithm == "MinSpanTree": #bb_result = BranchNBound.BranchNBound(dataset[1]) result = MinSpanTree.MinSpanTree(dataset[1]) test_result = TestResult(result[0], dataset[0][0], dataset[0][1], dataset[0][2], dataset[0][3], dataset[0][4], result[3], result[1], result[1]).get_result() elif algorithm == "EA_hillclimbing": #bb_result = BranchNBound.BranchNBound(dataset[1]) result = EA_hillclimbing.hillclimbing_algorithm(dataset[1], dataset[0][0]) test_result = TestResult(result[0], dataset[0][0], dataset[0][1], dataset[0][2], dataset[0][3], dataset[0][4], result[3], result[1], result[1]).get_result() elif algorithm == "Genetic": #bb_result = BranchNBound.BranchNBound(dataset[1]) result = GA.genetic_algorithm(dataset[1], dataset[0][0]) test_result = TestResult(result[0], dataset[0][0], dataset[0][1], dataset[0][2], dataset[0][3], dataset[0][4], result[3], result[1], result[1]).get_result() elif algorithm == "TwoOpt": #bb_result = BranchNBound.BranchNBound(dataset[1]) result = TwoOpt.two_opt(dataset[1]) test_result = TestResult(result[0], dataset[0][0], dataset[0][1], dataset[0][2], dataset[0][3], dataset[0][4], result[3], result[1], result[1]).get_result() else: raise Exception("Wrong algorithm chosen!") return test_result
def rootGenerator(DTLReconGraph, parasiteTree): """Generates a list of the roots in a DTL graph""" parasiteRoot = Greedy.findRoot(parasiteTree) preOrder = preorderDTLsort(DTLReconGraph, parasiteRoot) rootList = [] for key in preOrder: if key[1] == 0: rootList.append(key[0]) return rootList
def get_up(CityNum, Dist): """ 函数名:get_up(CityNum,Dist) 函数功能: 通过贪心算法求取目标函数的上界 输入 1 CityNum:城市数量 2 Dist:城市间距离矩阵 输出 1 Path_Up:分支界限法的上界 其他说明:无 """ Path_Up = Greedy.GreedyMethond(CityNum, Dist)[0] return Path_Up
def estadoEntrenamiento(vista): global campo clock = pygame.time.Clock() network = import_network("IA_50_50_50/IA_java_3550.txt") #network = Network(50, [300, 100, 20]) seguir = True contador_greedy = 0 contador_nn = 0 while seguir: campo = mdl.Campo() campo.rellenar(mdl.training_2, mdl.training_1) ia_greedy = Greedy.IA("T2", campo, 0.5) ia_nn = IA(network, "T1", campo, 0.5) vista.setCampo(campo) vista.setJugador(jugador) termino = False while True: dt = 200 #dt=clock.tick(60) for event in pygame.event.get(): if event.type == KEYDOWN: if event.key == K_SPACE: seguir = False campo.actualizar(dt / 1000) ver = False if ver: vista.dibujarCampoEntrenamiento() pygame.display.flip() if campo.revisarDerrota("T1"): #ia_greedy.escribir_jugadas("jugadas.txt") contador_greedy += 1 termino = True elif campo.revisarDerrota("T2"): #ia_nn.escribir_jugadas("jugadas.txt") contador_nn += 1 termino = True if termino: break ia_greedy.jugar(dt) ia_nn.jugar(dt) #jugadas=ia_greedy.get_jugadas() #ia_nn.entrenar_greedy(jugadas,10,0.0002) #ia_nn.entrenar_jugadas(10,0.0002) #network.export_network("IA_java2.txt") print("greedy: " + str(contador_greedy)) print("nn: " + str(contador_nn)) return "menu"
def pre_process(self) -> dict: # obtain D1 (actually D2 in Greedy output) greedy = Greedy.Greedy(self.G, INF, self.rho1, self.rho1, self.heuristic) greedy.run() self.D1 = greedy.D2 # print(self.D1) # gernerate subgraph for each node in V dic = {} for v in self.G.nodes(): dic[v] = self.cover_nodes(v) return dic
def run_test(fileName, max_k): cache_dir = './cache' D = 2. T = 3. L = 1. host, paras, phi = newickFormatReader.getInput(fileName) if not os.path.exists(cache_dir): os.makedirs(cache_dir) f = open('%s/README' % cache_dir, 'w') f.write( 'This directory holds a cache of reconciliation graph for the TreeLife data set' ) f.close() cache_location = '%s/%s.graph' % (cache_dir, os.path.split(fileName)[1]) if not os.path.isfile(cache_location): print >> sys.stderr, 'A reconciliation graph has not been built yet for this newick file' print >> sys.stderr, 'Doing so now and caching it in {%s}...' % cache_location DictGraph, numRecon = DP.DP(host, paras, phi, D, T, L) f = open(cache_location, 'w+') f.write(repr(DictGraph)) f.close() print >> sys.stderr, 'Loading reonciliation graph from cache' f = open(cache_location) DictGraph = eval(f.read()) f.close() scoresList, dictReps = Greedy.Greedy(DictGraph, paras) print >> sys.stderr, 'Found cluster representatives using point-collecting' graph = ReconGraph.ReconGraph(DictGraph) setReps = [ ReconGraph.dictRecToSetRec(graph, dictRep) for dictRep in dictReps ] random.seed(0) extra_reps = [KMeans.get_template(graph) for i in xrange(max_k)] representatives = setReps + extra_reps print >> sys.stderr, 'Starting K Means algorithm ... ' print >> sys.stderr, 'Printing Average and Maximum cluster radius at each step' for i in xrange(1, max_k + 1): print 'k = %d' % i KMeans.k_means(graph, 10, i, 0, representatives[:i])
def preparaJuego(vista): global campo global jugador global ia global ia2 campo = mdl.Campo() tipoIA = escogerTipoIA() campo.rellenar(tipoJugador, tipoIA) jugador = Jugador.Jugador(campo, tipoJugador) vista.setCampo(campo) vista.setJugador(jugador) ia2 = Greedy.IA(tipoIA.nombre, campo, 0.8) network = import_network("IA_50_50_50/IA_java_3550.txt") ia = IA(network, tipoIA.nombre, campo, 2)
def output_4(self, heu): # fix d datas_greedy = [['Real1']] datas_R1 = [['Real1']] datas_R2 = [['Real1']] d = 10 for rho1 in range (1,11): for rho2 in range(1, 11): avg_greedy = 0.0 avg_R1 = 0.0 avg_R2 = 0.0 for i in range(0, 5): G = self.College() g = Greedy.Greedy(G, d, rho1, rho2, heu) g.run() avg_greedy += len(g.D1) r1 = Replacement.ReplacementA(G, d, rho1, rho2, heu) r1.run() avg_R1 += len(r1.D1) r2 = Replacement.ReplacementB(G, d, rho1, rho2, heu) r2.run() avg_R2 += len(r2.D1) print(i) avg_greedy = avg_greedy / 10 avg_R1 = avg_R1 / 10 avg_R2 = avg_R2 / 10 datas_greedy.append(avg_greedy) datas_R1.append(avg_R1) datas_R2.append(avg_R2) with open('2_greedy_' + heu + '.csv', 'w', newline='') as f: writer = csv.writer(f) for row in datas_greedy: writer.writerow(row) with open('2_r1_' + heu + '.csv', 'w', newline='') as f: writer = csv.writer(f) for row in datas_R1: writer.writerow(row) with open('2_r2_' + heu + '.csv', 'w', newline='') as f: writer = csv.writer(f) for row in datas_R2: writer.writerow(row)
def Reconcile(argList): """Takes command-line arguments of a .newick file, duplication, transfer, and loss costs, the type of scoring desired and possible switch and loss ranges. Creates Files for the host, parasite, and reconciliations""" fileName = argList[1] #.newick file D = float(argList[2]) # Duplication cost T = float(argList[3]) # Transfer cost L = float(argList[4]) # Loss cost freqType = argList[5] # Frequency type # Optional inputs if freqType == xscape switchLo = float(argList[6]) # Switch lower boundary switchHi = float(argList[7]) # Switch upper boundary lossLo = float(argList[8]) # Loss lower boundary lossHi = float(argList[9]) # Loss upper boundary host, paras, phi = newickFormatReader.getInput(fileName) hostRoot = cycleCheckingGraph.findRoot(host) hostv = cycleCheckingGraph.treeFormat(host) Order = orderGraph.date(hostv) # Default scoring function (if freqtype== Frequency scoring) DTLReconGraph, numRecon = DP.DP(host, paras, phi, D, T, L) print DTLReconGraph, numRecon #uses xScape scoring function if freqType == "xscape": DTLReconGraph = calcCostscapeScore.newScoreWrapper(fileName, switchLo, \ switchHi, lossLo, lossHi, D, T, L) #uses Unit scoring function elif freqType == "unit": DTLReconGraph = unitScoreDTL(host, paras, phi, D, T, L) DTLGraph = copy.deepcopy(DTLReconGraph) scoresList, rec = Greedy.Greedy(DTLGraph, paras) for n in range(len(rec)): graph = cycleCheckingGraph.buildReconciliation(host, paras, rec[n]) currentOrder = orderGraph.date(graph) if currentOrder == "timeTravel": rec[n], currentOrder = detectCycles.detectCyclesWrapper( host, paras, rec[n]) currentOrder = orderGraph.date(currentOrder) hostOrder = hOrder(hostv, currentOrder) hostBranchs = branch(hostv, hostOrder) if n == 0: newickToVis.convert(fileName, hostBranchs, n, 1) else: newickToVis.convert(fileName, hostBranchs, n, 0) # filename[:-7] is the file name minus the .newick reconConversion.convert(rec[n], DTLReconGraph, paras, fileName[:-7], n)
def freqSummation(argList): """Takes as input an argument list containing a newick file of host and parasite trees as well as their phi mapping, duplication, transfer, and loss costs, the type of frequency scoring to be used, as well as switch and loss cost ranges for xscape scoring, and returns a file containing the list of scores for each individual reconciliation, the sum of the those scores, the total cost of those reconciliations and the number of reconciliations of those trees.""" newickFile = argList[1] D = float(argList[2]) T = float(argList[3]) L = float(argList[4]) freqType = argList[5] switchLo = float(argList[6]) switchHi = float(argList[7]) lossLo = float(argList[8]) lossHi = float(argList[9]) fileName = newickFile[:-7] f = open(fileName + "freqFile.txt", 'w') host, paras, phi = newickFormatReader.getInput(newickFile) DTL, numRecon = DP.DP(host, paras, phi, D, T, L) if freqType == "Frequency": newDTL = DTL elif freqType == "xscape": newDTL = calcCostscapeScore.newScoreWrapper(newickFile, switchLo, switchHi, lossLo, lossHi, D, T, L) elif freqType == "unit": newDTL = MasterReconciliation.unitScoreDTL(host, paras, phi, D, T, L) scoresList, reconciliation = Greedy.Greedy(newDTL, paras) totalSum = 0 for score in scoresList: totalSum += score for index in reconciliation: totalCost = 0 for key in index: if index[key][0] == "L": totalCost += L elif index[key][0] == "T": totalCost += T elif index[key][0] == "D": totalCost += D f.write(str(scoresList) + '\n') f.write(str(totalSum) + '\n') f.write(str(totalCost) + '\n') f.write(str(numRecon)) f.close()
def SFpp(layout, s_d, rank, n): ub = 100 cont = 0 for r in rank: while True: (s, pos) = search_highest(layout, r, ub, s_d) if layout.sorted_elements[s] > len(layout.stacks[s]) + pos: break #element is sorted c = force_move(layout, s, pos, s_d) ub = r cont += 1 if cont == n: return if r == c: break while cont < n: Greedy.SF_move_d(layout, s_d) cont += 1
def eden(i): bfs = BFS.main("./labyrinths/" + i) print("---") ids = IDS.main("./labyrinths/" + i) print("---") dfs = DFS.main("./labyrinths/" + i) print("---") tss = TSS.main("./labyrinths/" + i) print("---") ast = AStar.main("./labyrinths/" + i) print("---") dijkstra = Dijkstra.main("./labyrinths/" + i) print("---") greedy = Greedy.main("./labyrinths/" + i) print("---") greedyHeuristics = GreedyHeuristics.main("./labyrinths/" + i) print("###########################################################################")
def main(): xDB = readJSON('res/xDB.json') bmDir = 'bm/l10' designers = [] designers.append(Greedy.GreedyDesigner(xDB, 'maxHeavy')) # MCDesigner # ... # Process all benchmarks for jsonFile in glob.glob(bmDir + '/*.json'): spec = readJSON(jsonFile) targetLen = len(spec['nodes']) for designer in designers: designerName = designer.__class__.__name__ inputName = jsonFile.replace('.json', '') print 'Benchmarking {} on {}, target length={}'.format( designerName, inputName, targetLen) startTime = time.clock() (nodes,shape,score,fRot) = designer.design(inputName, spec, targetLen) print "{:.2f}s, score: {}".format(time.clock() - startTime, score) if nodes == spec['nodes']: print 'Pass' else: print 'Failed' pauseCode() makePdbFromNodes(xDB, nodes, 'res/centered_pdb/pair', jsonFile.replace('.json', suffixPdb( designerName, 'PCT', 1.0, targetLen)), fRot)
def preorder_dtl_sort(dtl_recon_graph, parasite_root): """ :param dtl_recon_graph: one of the outputs from DP, directly outputted by buildDTLReconGraph (see top of file for structure of the DTLReconGraph) :param parasite_root: The root node of the parasite tree, represented as a string :return: an ordered list of tuples, in order of increasing level. Each element is of the form ((P, H), L), where P is a parasite node and H is a host node, and the parasite node is mapped onto the host node in the first tuple in the overarching tuple. The second element is the level in the tree at which the (P,H) tuple occurs. Note level 0 is the root and the highest level represents tips. """ keys_l = Greedy.orderDTL(dtl_recon_graph, parasite_root) ordered_keys_l = [ ] # We could marginally improve efficiency here by locking list length, but we don't do that here level_counter = 0 while len(ordered_keys_l) < len(keys_l): to_add = [] for mapping in keys_l: if mapping[-1] == level_counter: to_add += [mapping] ordered_keys_l += to_add level_counter += 1 return ordered_keys_l
def Reconcile(argList): """Takes command-line arguments of a .newick file, duplication, transfer, and loss costs, the type of scoring desired and possible switch and loss ranges. Creates Files for the host, parasite, and reconciliations""" fileName = argList[1] #.newick file D = float(argList[2]) # Duplication cost T = float(argList[3]) # Transfer cost L = float(argList[4]) # Loss cost freqType = argList[5] # Frequency type # Optional inputs if freqType == xscape switchLo = float(argList[6]) # Switch lower boundary switchHi = float(argList[7]) # Switch upper boundary lossLo = float(argList[8]) # Loss lower boundary lossHi = float(argList[9]) # Loss upper boundary host, paras, phi = newickFormatReader.getInput(fileName) hostRoot = ReconciliationGraph.findRoot(host) # Default scoring function (if freqtype== Frequency scoring) DTLReconGraph, numRecon = DP.DP(host, paras, phi, D, T, L) #uses xScape scoring function # if freqType == "xscape": # DTLReconGraph = calcCostscapeScore.newScoreWrapper(fileName, switchLo, \ # switchHi, lossLo, lossHi, D, T, L) #uses Unit scoring function if freqType == "unit": DTLReconGraph = unitScoreDTL(host, paras, phi, D, T, L) DTLGraph = copy.deepcopy(DTLReconGraph) scoresList, recs = Greedy.Greedy(DTLGraph, paras) infeasible_recs = [] for rec in recs: if orderGraph.date(ReconciliationGraph.buildReconciliation(host, paras, rec)) == False: infeasible_recs.append(rec) return infeasible_recs, recs
def reducer(self, key, dataset): config = configparser.ConfigParser() config_file = ops.get_local_path('ConfigFile.ini') config.read(config_file) i = 0 data_set = {} # Prepare the data for the greedy for data in dataset: i += 1 for axe in data: data_set[i] = data[axe] i += 1 medoids = Greedy.greedy(data_set, int(config['DEFAULT']['GREEDY_2'])) # Yield all the medoids for medoid in medoids.values(): data_str = "" for axe in medoid: if data_str == "": data_str = str(axe) else: data_str = data_str + " " + str(axe) yield "", data_str
def main(): xDB = readJSON('res/xDB.json') bmDir = 'bm/l10' designers = [] designers.append(Greedy.GreedyDesigner(xDB, 'maxHeavy')) # MCDesigner # ... # Process all benchmarks for jsonFile in glob.glob(bmDir + '/*.json'): spec = readJSON(jsonFile) # we add one point between each pair of com coms = np.asarray(spec['coms']) targetLen = len(coms) mids = np.asarray([np.mean(p, axis=0) for p in zip(coms, np.roll(coms, -1, axis=0))[0:-1]]) spec['coms'] = np.append([val for p in zip(coms, mids) for val in p], [coms[-1]], axis=0) for designer in designers: designerName = designer.__class__.__name__ print 'Benchmarking {} on {}, target length={}'.format( designerName, jsonFile, targetLen) startTime = time.clock() (nodes,shape,score) = designer.design(spec, targetLen) print "{:.2f}s, score: {}".format(time.clock() - startTime, score) if nodes == spec['nodes']: print 'Pass' else: print 'Failed' # pauseCode() makePdbFromNodes(xDB, nodes, 'res/centered_pdb/pair', jsonFile.replace('.json', '_' + designerName + '_LV2.pdb'))