def run_computation(index, input_file, definition): from dask_cluster import start_cluster input = definition["inputs"][int(index)] output = definition["outputs"][int(index)] is_pbs = "PBS_JOBID" in os.environ workdir = get_workdir( os.environ.get("PBS_JOBID", "local-{}".format(index)), input_file, output) if not os.path.exists(workdir): os.makedirs(workdir) with open(os.path.join(workdir, os.path.basename(input_file)), "w") as dst: definition["index"] = index json.dump(definition, dst, indent=4) dask_cluster = None if definition.get("dask"): start_cluster(port=DASK_PORT, path=BENCHMARK_DIR) dask_cluster = "{}:{}".format(socket.gethostname(), DASK_PORT) graph_frame = load_graphs([input]) frame = load_resultfile(output, True) if is_pbs: with open(os.path.join(workdir, "output"), "w") as out: with open(os.path.join(workdir, "error"), "w") as err: sys.stdout = out sys.stderr = err run_benchmark(parse_configs(definition, graph_frame), frame, output, True, parse_timeout(definition.get("timeout")), dask_cluster) else: run_benchmark(parse_configs(definition, graph_frame), frame, output, True, parse_timeout(definition.get("timeout")), dask_cluster)
def run_cifar_benchmark(n_iter=10, n_skip=5, batch_size=4, transformer_type='cpu'): inputs, data, train_set = get_fake_cifar(batch_size, n_iter) model = get_mini_resnet(inputs) optimizer = GradientDescentMomentum(0.01, 0.9) train_loss = ng.cross_entropy_multi(model(inputs['image']), ng.one_hot(inputs['label'], axis=ax.Y)) batch_cost = ng.sequential( [optimizer(train_loss), ng.mean(train_loss, out_axes=())]) batch_cost_computation_op = ng.computation(batch_cost, "all") feed_dict = fill_feed_dict(train_set, inputs) benchmarks = dict() benchmarks['cifar_msra_fprop'] = run_benchmark(batch_cost_computation_op, transformer_type, feed_dict, n_skip, n_iter) print_benchmark_results(benchmarks)
help="precision of the computation in bits", ) parser.add_argument( "-b", "--benchmark", type=int, default=1, dest="benchmark", help="number of times to benchmark this application (default 1 - " "normal execution)", ) args = parser.parse_args() if args.P == 16: run_benchmark( run_black_scholes, args.benchmark, "Black Scholes", (args.N, np.float16), ) elif args.P == 32: run_benchmark( run_black_scholes, args.benchmark, "Black Scholes", (args.N, np.float32), ) elif args.P == 64: run_benchmark( run_black_scholes, args.benchmark, "Black Scholes", (args.N, np.float64),
#!/usr/bin/python3 from benchmark import run_benchmark from benchmark import print_results from unit_preference_methods import * from splitting_methods import * results = run_benchmark(100, 3, 4.4, 0.2, 5, 5, [max_unit_choice], [two_clause_choice, jeroslow_wang_choice]) print_results(results)
dest="I", help="number of iterations to run", ) parser.add_argument( "-n", "--num", type=int, default=100, dest="N", help="number of elements in one dimension", ) parser.add_argument( "-t", "--time", dest="timing", action="store_true", help="perform timing", ) parser.add_argument( "-b", "--benchmark", type=int, default=1, dest="benchmark", help="number of times to benchmark this application (default 1 " "- normal execution)", ) args = parser.parse_args() run_benchmark(run_stencil, args.benchmark, "Stencil", (args.N, args.I, args.timing))
def main(): parser = cli.init_parser() args = parser.parse_args() log.setLevel(logging.DEBUG if args.debug else logging.INFO) config.DEBUG = args.debug config.UPDATE = args.properties or args.templates config.BENCHMARK = args.benchmark config.SIMILARITY_METRIC = args.metric config.THRESHOLD = args.similarity config.FIGURES = args.figures log.debug(f'Started in DEBUG mode') log.info('Hit CTRL+D to exit') properties = None filtered_properties = None templates = [] # update properties if asked or if we're trying to update templates without a properties.json file if args.properties or (args.templates and not has_properties_cache()): log.info('Updating properties') timer.tic() properties = update() log.info(f'Cached properties in: {timer.tocvalue()}') if args.templates or not has_templates_cache(): log.info('Regenerating templates from cached properties') log.info( f'Using {config.MIN_PROPERTY_REFERENCE_COUNT} as minimum reference requirement' ) timer.tic() if properties == None: properties = load_properties_from_cache() total_properties = 0 for property_type in properties: total_properties += len(properties[property_type]) log.info( f'{len(properties.keys())} property types with {total_properties} total properties found' ) filtered_properties = get_filtered_properties(properties) templates = generate_templates_from_properties(filtered_properties) log.info(f'Generated {len(templates)} question templates') save_to_file(templates, filename=config.TEMPLATES_FILENAME) log.info(f'Templates created in: {timer.tocvalue()}') else: log.debug('Loading templates from cache') templates = load_templates_from_cache() if args.benchmark and args.question: log.error('Cannot ask question and run benchmarks at the same time') sys.exit(-1) if args.log or args.benchmark: now = datetime.now() current_time = now.strftime("%Y:%m:%d-%H:%M:%S") log_file = logging.FileHandler( f'results/{current_time}-benchmarks.log') log.addHandler(log_file) log.info(f'Loaded {len(templates)} templates') log.info( f"Using '{config.SIMILARITY_METRIC}' as similarity metric, with threshold of {config.THRESHOLD}" ) if args.benchmark: log.info('Running benchmarks...') run_benchmark(templates) elif args.question: answer = get_answer(args.question, templates) log.info(answer) elif args.ask: while True: try: question = input("Ask a question:\n") if question == '': continue answer = get_answer(question, templates) log.info(answer) log.info('') except KeyboardInterrupt as interrupt: log.info('') continue except EOFError: log.info('\nExiting\n') sys.exit(0) else: parser.print_help()
def main(): run_benchmark('ufo_benchmark', 'cu2qu.ufo', 'fonts_to_quadratic', setup_suffix='defcon', repeat=10)
dest="S", help="number of iterations between sampling the log likelihood", ) parser.add_argument( "--benchmark", type=int, default=1, dest="benchmark", help="number of times to benchmark this application (default 1 - " "normal execution)", ) args = parser.parse_args() if args.P == 16: run_benchmark( run_linear_regression, args.benchmark, "LINREG(H)", (args.N, args.F, np.float16, args.I, args.S, args.B), ) elif args.P == 32: run_benchmark( run_linear_regression, args.benchmark, "LINREG(S)", (args.N, args.F, np.float32, args.I, args.S, args.B), ) elif args.P == 64: run_benchmark( run_linear_regression, args.benchmark, "LINREG(D)", (args.N, args.F, np.float64, args.I, args.S, args.B),
type=int, default=4, dest="sentence", help="sentence length", ) parser.add_argument( "-w", "--word", type=int, default=10, dest="word", help="word size" ) parser.add_argument( "-t", "--time", dest="timing", action="store_true", help="perform timing", ) parser.add_argument( "--benchmark", type=int, default=1, dest="benchmark", help="number of times to benchmark this application (default 1 - " "normal execution)", ) args = parser.parse_args() run_benchmark( run_lstm, args.benchmark, "LSTM Forward", (args.batch, args.hidden, args.sentence, args.word, args.timing), )
dest="S", help="number of iterations between sampling the log likelihood", ) parser.add_argument( "--benchmark", type=int, default=1, dest="benchmark", help="number of times to benchmark this application (default 1 - " "normal execution)", ) args = parser.parse_args() if args.P == 16: run_benchmark( run_logistic_regression, args.benchmark, "LOGREG(H)", (args.N, args.F, np.float16, args.I, args.S, args.B), ) elif args.P == 32: run_benchmark( run_logistic_regression, args.benchmark, "LOGREG(S)", (args.N, args.F, np.float32, args.I, args.S, args.B), ) elif args.P == 64: run_benchmark( run_logistic_regression, args.benchmark, "LOGREG(D)", (args.N, args.F, np.float64, args.I, args.S, args.B),
"--benchmark", type=int, default=1, dest="benchmark", help="number of times to benchmark this application (default 1 - " "normal execution)", ) args = parser.parse_args() if args.P == 16: run_benchmark( run_kmeans, args.benchmark, "KMEANS(H)", ( args.C, args.D, np.float16, args.I, args.N * 1000, args.S, args.benchmark > 1, ), ) elif args.P == 32: run_benchmark( run_kmeans, args.benchmark, "KMEANS(S)", ( args.C, args.D, np.float32,
dest="verbose", action="store_true", help="print verbose output", ) parser.add_argument( "-b", "--benchmark", type=int, default=1, dest="benchmark", help="number of times to benchmark this application (default 1 - " "normal execution)", ) args = parser.parse_args() run_benchmark( run_cg, args.benchmark, "PreCG" if args.precondition else "CG", ( args.N, args.corners, args.precondition, args.conv_iters, args.max_iters, args.check, args.timing, args.verbose, ), )
type=float, default=0.1, dest="weight", help="standard deviation of weights for initialization", ) parser.add_argument( "-b", "--benchmark", type=int, default=1, dest="benchmark", help="number of times to benchmark this application (default 1 - " "normal execution)", ) args = parser.parse_args() run_benchmark( run_lstm, args.benchmark, "LSTM Full", ( args.file_name, args.hidden, args.steps, args.loops, args.rate, args.weight, args.dump, args.timing, ), )
"-t", "--time", dest="timing", action="store_true", help="perform timing", ) parser.add_argument( "-v", "--verbose", dest="verbose", action="store_true", help="print verbose output", ) parser.add_argument( "-b", "--benchmark", type=int, default=1, dest="benchmark", help="number of times to benchmark this application (default 1 - " "normal execution)", ) args = parser.parse_args() run_benchmark( run_jacobi, args.benchmark, "Jacobi", (args.N, args.iters, args.check, args.timing, args.verbose), )
args = parser.parse_args() log.init_log() # set working directory to this file's path handler.set_working_directory() build_all = True logging.info("Main module: build.py.") if (args.core == True or args.format == True or args.tools == True): build_all = False configurations = loader.get_configs_from_json() if (configurations is None): logging.error("No valid configurations were loaded.") sys.exit(1) resolve_dependencies(configurations) if (build_all == True): build_projects(configurations, build_core=True,\ build_formats=True, build_tools=True) else: build_projects(configurations, args.core, args.format, \ args.tools) if (args.generate == True): for config in configurations: generate.generate_models(config) if (args.benchmark == True): for config in configurations: benchmark.run_benchmark(config)
parser.add_argument( "-p", "--precision", type=int, default=32, dest="P", help="number of bits of precision to use for the gemm computation " "(16,32,64)", ) parser.add_argument( "-b", "--benchmark", type=int, default=1, dest="benchmark", help="number of times to benchmark this application (default 1 - " "normal execution)", ) args = parser.parse_args() if args.P == 16: run_benchmark(run_gemm, args.benchmark, "HGEMM", (args.N, args.I, np.float16)) elif args.P == 32: run_benchmark(run_gemm, args.benchmark, "SGEMM", (args.N, args.I, np.float32)) elif args.P == 64: run_benchmark(run_gemm, args.benchmark, "DGEMM", (args.N, args.I, np.float64)) else: raise TypeError("Precision must be one of 16, 32, or 64")