def main():
from argparse import ArgumentParser
parser = ArgumentParser()
parser.add_argument("model", help="Path to model")
parser.add_argument("target", help="Path to target code")
parser.add_argument("-i", "--input", metavar="path", default=None,
help="Path to starting code")
parser.add_argument("-l", "--log", metavar="path", default="search-log.json",
help="Path to log file")
args = parser.parse_args()
clgen_log.init(verbose=True)
# load and train model
modelpath = args.model
if modelpath.endswith(".tar.bz2"):
m = model.from_tar(modelpath)
else:
model_json = clgen.load_json_file(modelpath)
m = clgen.model.from_json(model_json)
m.train()
# read target code
with open(args.target) as infile:
target_code = infile.read()
# read start code if provided
start_code = None
if args.input:
with open(args.input) as infile:
start_code = infile.read()
search(m, target_code, args.log, start_code=start_code)
def main():
from argparse import ArgumentParser
parser = ArgumentParser()
parser.add_argument("model", help="Path to model")
parser.add_argument("target", help="Path to target code")
parser.add_argument("-i", "--input", metavar="path", default=None,
help="Path to starting code")
parser.add_argument("-l", "--log", metavar="path", default="search-log.json",
help="Path to log file")
args = parser.parse_args()
clgen_log.init(verbose=True)
# load and train model
modelpath = args.model
if modelpath.endswith(".tar.bz2"):
m = model.from_tar(modelpath)
else:
model_json = clgen.load_json_file(modelpath)
m = clgen.model.from_json(model_json)
m.train()
# read target code
with open(args.target) as infile:
target_code = infile.read()
# read start code if provided
start_code = None
if args.input:
with open(args.input) as infile:
start_code = infile.read()
search(m, target_code, args.log, start_code=start_code)
def main():
import sys
log.init(verbose=True)
m = model.from_json(clgen.load_json_file(sys.argv[1]))
s = sampler.from_json({
"kernels": {
"args": [
"__global float*", "__global float*", "__global float*",
"const int"
],
"max_length":
5000,
"temperature":
1
},
"sampler": {
"batch_size": 1000,
"max_batches": 1,
"static_checker": False,
"dynamic_checker": False
}
})
print("Corpus size:", m.corpus.size)
print("Vocab size: ", m.corpus.vocab_size)
print()
clgen.platform_info()
print()
outpath = "./benchmark-" + fs.basename(sys.argv[1])
info = evaluate(m, s)
clgen.write_file(outpath, clgen.format_json(info))
def main():
import sys
log.init(verbose=True)
m = model.from_json(clgen.load_json_file(sys.argv[1]))
s = sampler.from_json({
"kernels": {
"args": [
"__global float*",
"__global float*",
"__global float*",
"const int"
],
"max_length": 5000,
"temperature": 1
},
"sampler": {
"batch_size": 1000,
"max_batches": 1,
"static_checker": False,
"dynamic_checker": False
}
})
print("Corpus size:", m.corpus.size)
print("Vocab size: ", m.corpus.vocab_size)
print()
clgen.platform_info()
print()
outpath = "./benchmark-" + fs.basename(sys.argv[1])
info = evaluate(m, s)
clgen.write_file(outpath, clgen.format_json(info))
def main():
log.init(verbose=True)
m = model.from_json(clgen.load_json_file(sys.argv[1]))
c = corpus.Corpus.from_json({"path": "~/data/github"})
print("CLgen: ", clgen.version())
print("Corpus size:", c.size)
print("Vocab size: ", c.vocab_size)
m.train()
p, _ = corpus.most_common_prototypes(c, 20)
for i, row in enumerate(p):
outpath = "./inference-p" + str(i + 1) + "-" + fs.basename(sys.argv[1])
if fs.exists(outpath):
continue
_, prototype = row
argspec = [' '.join(x.split()[:-1]) for x in prototype.split(',')]
print("argspec", ','.join([str(x) for x in argspec]))
s = sampler.from_json({
"kernels": {
"args": argspec,
"max_length": 5000
},
"sampler": {
"batch_size": 2000,
"max_batches": 1,
"static_checker": False,
"dynamic_checker": False
}
})
info = evaluate(m, s)
clgen.write_file(outpath, clgen.format_json(info))
def parse_args(self, args=None, namespace=None):
"""
See python argparse.ArgumentParser.parse_args().
"""
if args is None:
args = sys.argv[1:]
# --version option overrides the normal argument parsing process.
if len(args) == 1 and args[0] == "--version":
print_version_and_exit()
ret = super(ArgumentParser, self).parse_args(args, namespace)
if ret.version:
print_version_and_exit()
# set log level
log.init(ret.verbose)
return ret
def main():
log.init(verbose=True)
m = model.from_json(clgen.load_json_file(sys.argv[1]))
c = corpus.Corpus.from_json({"path": "~/data/github"})
print("CLgen: ", clgen.version())
print("Corpus size:", c.size)
print("Vocab size: ", c.vocab_size)
m.train()
p, _ = corpus.most_common_prototypes(c, 20)
for i, row in enumerate(p):
outpath = "./inference-p" + str(i + 1) + "-" + fs.basename(sys.argv[1])
if fs.exists(outpath):
print("skipped result for", outpath)
continue
else:
print("starting result for", outpath)
_, prototype = row
argspec = [' '.join(x.split()[:-1]) for x in prototype.split(',')]
print("argspec", ','.join([str(x) for x in argspec]))
s = sampler.from_json({
"kernels": {
"args": argspec,
"max_length": 5000
},
"sampler": {
"batch_size": 2000,
"max_batches": 1,
"static_checker": False,
"dynamic_checker": False
}
})
info = evaluate(m, s)
clgen.write_file(outpath, clgen.format_json(info))
def main(self, args: List[str]=sys.argv[1:]):
"""
A deep learning program generator for the OpenCL programming language.
The core operations of CLgen are:
1. OpenCL files are collected from a model specification file.
2. These files are preprocessed into an OpenCL kernel database.
3. A training corpus is generated from the input files.
4. A machine learning model is trained on the corpus of files.
5. The trained model is sampled for new kernels.
6. The samples are tested for compilability.
This program automates the execution of all six stages of the pipeline.
The pipeline can be interrupted and resumed at any time. Results are cached
across runs. If installed with CUDA support, NVIDIA GPUs will be used to
improve performance where possible.
"""
parser = ArgumentParser(
prog="clgen",
description=inspect.getdoc(self),
epilog="""
For information about a specific command, run `clgen <command> --help`.
""" + __help_epilog__,
formatter_class=RawDescriptionHelpFormatter)
# TODO:
# parser.add_argument(
# "-l", "--lang", metavar="<language>",
# help="programming language (default: OpenCL)")
parser.add_argument(
"-v", "--verbose", action="store_true",
help="increase output verbosity")
parser.add_argument(
"--version", action="store_true",
help="show version information and exit")
parser.add_argument(
"--debug", action="store_true",
help="in case of error, print debugging information")
parser.add_argument(
"--profile", action="store_true",
help=("enable internal API profiling. When combined with --verbose, "
"prints a complete profiling trace"))
parser.add_argument(
"--corpus-dir", metavar="<corpus>",
type=FileType("r"),
help="print path to corpus cache")
parser.add_argument(
"--model-dir", metavar="<model>",
type=FileType("r"),
help="print path to model cache")
parser.add_argument(
"--sampler-dir", metavar=("<model>", "<sampler>"),
type=FileType("r"), nargs=2,
help="print path to sampler cache")
subparser = parser.add_subparsers(title="available commands")
subparsers = [
_register_test_parser,
_register_train_parser,
_register_sample_parser,
_register_db_parser,
_register_fetch_parser,
_register_ls_parser,
_register_preprocess_parser,
_register_features_parser,
_register_atomize_parser,
_register_cache_parser,
]
for register_fn in subparsers:
register_fn(subparser)
args = parser.parse_args(args)
# set log level
log.init(args.verbose)
# set debug option
if args.debug:
os.environ["DEBUG"] = "1"
# set profile option
if args.profile:
prof.enable()
# options whch override the normal argument parsing process.
if args.version:
version = clgen.version()
print(f"clgen {version} made with \033[1;31m♥\033[0;0m by "
"Chris Cummins <*****@*****.**>.")
elif args.corpus_dir:
model = clgen.Model.from_json(jsonutil.loads(args.corpus_dir.read()))
print(model.corpus.cache.path)
elif args.model_dir:
model = clgen.Model.from_json(jsonutil.loads(args.model_dir.read()))
print(model.cache.path)
elif args.sampler_dir:
model = clgen.Model.from_json(jsonutil.loads(args.sampler_dir[0].read()))
sampler = clgen.Sampler.from_json(jsonutil.loads(args.sampler_dir[1].read()))
print(sampler.cache(model).path)
else:
# strip the arguments from the top-level parser
dispatch_func = args.dispatch_func
opts = vars(args)
del opts["version"]
del opts["verbose"]
del opts["debug"]
del opts["profile"]
del opts["corpus_dir"]
del opts["model_dir"]
del opts["sampler_dir"]
del opts["dispatch_func"]
run(dispatch_func, **opts)
