コード例 #1
0
ファイル: demo.py プロジェクト: abogdanova/SwarmGE
def main(MAXEVALS=MAXEVALS, current_batch=current_batch, number_of_batches=number_of_batches):
    print("Benchmarking solver %s, %s" % (str(solver), time.asctime(), ))
    t0 = time.clock()
    if 11 < 3:
        # simple Pythonic use case, never leaves a problem unfree()ed, ctrl-C "safe"
        print('Pythonic usecase ...'); sys.stdout.flush()
        found_problems, addressed_problems = 0, 0
        for problem in Benchmark(suite_name, suite_options, 
                                 observer_name, observer_options):
            found_problems += 1
            # use problem only under some conditions, mainly for testing
            if 11 < 3 and not ('f11' in problem.id and 'i03' in problem.id):
                continue
            coco_optimize(problem, MAXEVALS)
            addressed_problems += 1
        print("%s done (%d of %d problems benchmarked), %s (%f s)." 
                % (suite_name, addressed_problems, found_problems,
                   time.asctime(), (time.clock()-t0)/60**0))
    
    elif 1 < 3:
        # usecase with batches
        print('Batch usecase ...'); sys.stdout.flush()
        bm = Benchmark(suite_name, suite_options, observer_name, observer_options)  
        addressed_problems = []
        for problem_index in bm.problem_indices: # bm.next_problem_index(problem_index) is also available
            if (problem_index + current_batch - 1) % number_of_batches:
                continue
            problem = bm.get_problem(problem_index)
            # print("%4d: " % problem_index, end="")
            coco_optimize(problem, MAXEVALS)
            problem.free()  # preferably free would not be necessary, but how?
            addressed_problems += [problem_index]
        print("%s done (%d of %d problems benchmarked%s), %s (%f min)." % 
               (suite_name, len(addressed_problems), len(bm),
                 ((" in batch %d of %d" % (current_batch, number_of_batches))
                   if number_of_batches > 1 else ""), time.asctime(), (time.clock()-t0)/60))

    elif 1 < 3:
        # generic example with batches, similarly possible in all languages
        print('Generic usecase with batches...'); sys.stdout.flush()
        bm = Benchmark(suite_name, suite_options, observer_name, observer_options)  
        found_problems, addressed_problems = 0, 0
        problem_index = -1  # first index is not necessarily 0!
        while True:
            problem_index = bm.next_problem_index(problem_index)
            if problem_index < 0: 
                break 
            found_problems += 1
            if (problem_index + current_batch - 1) % number_of_batches:
                continue
            problem = bm.get_problem(problem_index) 
            # use problem only under some conditions, mainly for testing
            if 1 or ('d20' in problem.id and 'i01' in problem.id):
                print("%4d: " % problem_index, end="")
                coco_optimize(problem, MAXEVALS)
                addressed_problems += 1
            problem.free()  # preferably free would not be necessary
        print("%s done (%d of %d problems benchmarked%s), %s (%f min)." % 
               (suite_name, addressed_problems, found_problems,
                 ((" in batch %d of %d" % (current_batch, number_of_batches))
                   if number_of_batches > 1 else ""), time.asctime(), (time.clock()-t0)/60, ))
コード例 #2
0
ファイル: demo.py プロジェクト: NDManh/numbbo
def main(MAXEVALS=MAXEVALS, current_batch=current_batch, number_of_batches=number_of_batches):
    print("Benchmarking solver %s, %s" % (str(solver), time.asctime()))
    t0 = time.clock()
    if 11 < 3:
        # simple Pythonic use case, never leaves a problem unfree()ed, ctrl-C "safe"
        print("Pythonic usecase ...")
        sys.stdout.flush()
        found_problems, addressed_problems = 0, 0
        for problem in Benchmark(suite_name, suite_options, observer_name, observer_options):
            found_problems += 1
            # use problem only under some conditions, mainly for testing
            if 11 < 3 and not ("f11" in problem.id and "i03" in problem.id):
                continue
            coco_optimize(problem, MAXEVALS)
            addressed_problems += 1
        print(
            "%s done (%d of %d problems benchmarked), %s (%f s)."
            % (suite_name, addressed_problems, found_problems, time.asctime(), (time.clock() - t0) / 60 ** 0)
        )

    elif 1 < 3:
        # usecase with batches
        print("Batch usecase ...")
        sys.stdout.flush()
        bm = Benchmark(suite_name, suite_options, observer_name, observer_options)
        addressed_problems = []
        for problem_index in bm.problem_indices:  # bm.next_problem_index(problem_index) is also available
            if (problem_index + current_batch - 1) % number_of_batches:
                continue
            problem = bm.get_problem(problem_index)
            # print("%4d: " % problem_index, end="")
            coco_optimize(problem, MAXEVALS)
            problem.free()  # preferably free would not be necessary, but how?
            addressed_problems += [problem_index]
        print(
            "%s done (%d of %d problems benchmarked%s), %s (%f min)."
            % (
                suite_name,
                len(addressed_problems),
                len(bm),
                ((" in batch %d of %d" % (current_batch, number_of_batches)) if number_of_batches > 1 else ""),
                time.asctime(),
                (time.clock() - t0) / 60,
            )
        )

    elif 1 < 3:
        # generic example with batches, similarly possible in all languages
        print("Generic usecase with batches...")
        sys.stdout.flush()
        bm = Benchmark(suite_name, suite_options, observer_name, observer_options)
        found_problems, addressed_problems = 0, 0
        problem_index = -1  # first index is not necessarily 0!
        while True:
            problem_index = bm.next_problem_index(problem_index)
            if problem_index < 0:
                break
            found_problems += 1
            if (problem_index + current_batch - 1) % number_of_batches:
                continue
            problem = bm.get_problem(problem_index)
            # use problem only under some conditions, mainly for testing
            if 1 or ("d20" in problem.id and "i01" in problem.id):
                print("%4d: " % problem_index, end="")
                coco_optimize(problem, MAXEVALS)
                addressed_problems += 1
            problem.free()  # preferably free would not be necessary
        print(
            "%s done (%d of %d problems benchmarked%s), %s (%f min)."
            % (
                suite_name,
                addressed_problems,
                found_problems,
                ((" in batch %d of %d" % (current_batch, number_of_batches)) if number_of_batches > 1 else ""),
                time.asctime(),
                (time.clock() - t0) / 60,
            )
        )

    if 11 < 3:
        # generic usecase, possible if solver can be cast into a coco_optimizer_t *
        # which might often not be a straight forward type conversion, because (i) the
        # optimizer takes a function (pointer) as input, (ii) argument passing to
        # the optimizer seems not possible (e.g. max budget) unless the interface
        # is changed and (iii) argument passing to the function might be impossible
        # to negotiate.
        print("Minimal usecase, doesn't work though")
        Benchmark(
            coco_optimize,
            suite_name,
            suite_options,  # suite options are in the possible future
            observer_name,
            observer_options,
        )
コード例 #3
0
                continue
            coco_optimize(problem, MAXEVALS)
            addressed_problems += 1
        print("%s done (%d of %d problems benchmarked), %s (%f s)." 
                % (suite_name, addressed_problems, found_problems,
                   time.asctime(), (time.clock()-t0)/60**0))
    
    elif 1 < 3:
        # usecase with batches
        print('Batch usecase ...'); sys.stdout.flush()
        bm = Benchmark(suite_name, suite_options, observer_name, observer_options)  
        addressed_problems = []
        for problem_index in bm.problem_indices: # bm.next_problem_index(problem_index) is also available
            if (problem_index + current_batch - 1) % number_of_batches:
                continue
            problem = bm.get_problem(problem_index)
            # print("%4d: " % problem_index, end="")
            coco_optimize(problem, MAXEVALS)
            problem.free()  # preferably free would not be necessary, but how?
            addressed_problems += [problem_index]
        print("%s done (%d of %d problems benchmarked%s), %s (%f min)." % 
               (suite_name, len(addressed_problems), len(bm),
                 ((" in batch %d of %d" % (current_batch, number_of_batches))
                   if number_of_batches > 1 else ""), time.asctime(), (time.clock()-t0)/60))

    elif 1 < 3:
        # generic example with batches, similarly possible in all languages
        print('Generic usecase with batches...'); sys.stdout.flush()
        bm = Benchmark(suite_name, suite_options, observer_name, observer_options)  
        found_problems, addressed_problems = 0, 0
        problem_index = -1  # first index is not necessarily 0!
コード例 #4
0
ファイル: demo.py プロジェクト: ShaulSalomon/coco
def main(MAXEVALS=MAXEVALS, current_batch=current_batch, number_of_batches=number_of_batches):
    print("Benchmarking solver %s, %s" % (str(solver), time.asctime(), ))
    t0 = time.clock()
    if 11 < 3:
        # simple Pythonic use case, never leaves a problem unfree()ed, ctrl-C "safe"
        print('Pythonic usecase ...'); sys.stdout.flush()
        found_problems, addressed_problems = 0, 0
        for problem in Benchmark(suite_name, suite_options, 
                                 observer_name, observer_options):
            found_problems += 1
            # use problem only under some conditions, mainly for testing
            if 11 < 3 and not ('f11' in problem.id and 'i03' in problem.id):
                continue
            coco_optimize(problem, MAXEVALS)
            addressed_problems += 1
        print("%s done (%d of %d problems benchmarked), %s (%f s)." 
                % (suite_name, addressed_problems, found_problems,
                   time.asctime(), (time.clock()-t0)/60**0))
    
    elif 1 < 3:
        # usecase with batches
        print('Batch usecase ...'); sys.stdout.flush()
        bm = Benchmark(suite_name, suite_options, observer_name, observer_options)  
        addressed_problems = []
        for problem_index in bm.problem_indices: # bm.next_problem_index(problem_index) is also available
            if (problem_index + current_batch - 1) % number_of_batches:
                continue
            problem = bm.get_problem(problem_index)
            # print("%4d: " % problem_index, end="")
            coco_optimize(problem, MAXEVALS)
            problem.free()  # preferably free would not be necessary, but how?
            addressed_problems += [problem_index]
        print("%s done (%d of %d problems benchmarked%s), %s (%f min)." % 
               (suite_name, len(addressed_problems), len(bm),
                 ((" in batch %d of %d" % (current_batch, number_of_batches))
                   if number_of_batches > 1 else ""), time.asctime(), (time.clock()-t0)/60))

    elif 1 < 3:
        # generic example with batches, similarly possible in all languages
        print('Generic usecase with batches...'); sys.stdout.flush()
        bm = Benchmark(suite_name, suite_options, observer_name, observer_options)  
        found_problems, addressed_problems = 0, 0
        problem_index = -1  # first index is not necessarily 0!
        while True:
            problem_index = bm.next_problem_index(problem_index)
            if problem_index < 0: 
                break 
            found_problems += 1
            if (problem_index + current_batch - 1) % number_of_batches:
                continue
            problem = bm.get_problem(problem_index) 
            # use problem only under some conditions, mainly for testing
            if 1 or ('d20' in problem.id and 'i01' in problem.id):
                print("%4d: " % problem_index, end="")
                coco_optimize(problem, MAXEVALS)
                addressed_problems += 1
            problem.free()  # preferably free would not be necessary
        print("%s done (%d of %d problems benchmarked%s), %s (%f min)." % 
               (suite_name, addressed_problems, found_problems,
                 ((" in batch %d of %d" % (current_batch, number_of_batches))
                   if number_of_batches > 1 else ""), time.asctime(), (time.clock()-t0)/60, ))