def func(env, *args):
name = args[0]
os = env.getscope() # Get the old scope
ns = {}
for item in env.getscope():
if isinstance(env.getval(item), eval.Proc):
ns[item] = env.getval(item) # Save procedures in the new scope
env.scopes[env.scope] = ns
args = eval.parse_args(args, env) # Parse arguments
need = args[1] # Get the arguments needed
env.scopes[env.scope] = os # Restore the old scope
args = eval.parse_args(args, env) # Parse arguments again
body = args[2] # Get the body
@eval.proc(env, name, len(need), *[eval.ANY] * len(need)) # Create a procedure
def run(env, *args):
args = eval.parse_args(args, env) # Parse arguments
env.scopes.append({}) # Create a new scope
env.scope += 1
i = 0
env.scopes[env.scope].update(env.scopes[env.scope - 1]) # Add the old scope to it
for var in need: # Set up arguments
env.setval(str(var), args[i])
i += 1
env.setval(name, run) # Allow recursion
out = _eval(env, body) # Run the code
env.scope -= 1
env.scopes.pop() # Delete our scope
return out
return run
def __init__(
self,
weights='./crow_vision_yolact/data/yolact/weights/weights_yolact_kuka_17/crow_base_35_457142.pth',
config=None,
batchsize=1,
top_k=25,
score_threshold=0.1,
display_text=True,
display_bboxes=True,
display_masks=True,
display_scores=True):
self.score_threshold = score_threshold
self.top_k = top_k
self.batchsize = batchsize
# initialize a yolact net for inference
## YOLACT setup
# setup config
if config is not None:
if '.obj' in config:
with open(config, 'rb') as f:
config = dill.load(f)
set_cfg(config)
self.class_names_tuple = get_class_names_tuple()
parse_args([
'--top_k=' + str(top_k),
'--score_threshold=' + str(score_threshold),
'--display_text=' + str(display_text),
'--display_bboxes=' + str(display_bboxes),
'--display_masks=' + str(display_masks),
'--display_scores=' + str(display_scores),
])
# CUDA setup for yolact
torch.backends.cudnn.fastest = True
torch.set_default_tensor_type('torch.cuda.FloatTensor')
#YOLACT net itself
with torch.no_grad():
net = Yolact().cuda(torch.cuda.current_device())
net.load_weights(weights)
net.eval()
net.detect.use_fast_nms = True
net.detect.use_cross_class_nms = False
self.net = net
print("YOLACT network available as self.net")
#for debug,benchmark
self.duration = 0.0
def use(env, *args):
args = eval.parse_args(args, env) # Same process as useg
for arg in args:
try:
import_env = eval.Env(arg + '.wave')
for name in env.getscope():
import_env.setval(name, env.getscope()[name])
import_env.run()
ldict = import_env.getscope()
env.setval(arg, ldict)
env.pyvars.update(import_env.pyvars)
except FileNotFoundError:
try:
try:
import_env = eval.Env(None)
importlib.import_module(arg).setup(import_env)
env.pyvars[arg] = import_env.getscope()
except AttributeError:
lib = importlib.import_module(arg)
env.pyvars[arg] = lib
except ImportError:
try:
import_env = eval.Env(os.path.abspath('lib/' + arg + '.wave'))
for name in env.getscope():
import_env.setval(name, env.getscope()[name])
import_env.run()
ldict = import_env.getscope()
env.setval(arg, ldict)
env.pyvars.update(import_env.pyvars)
except FileNotFoundError:
errors._UseError(f'Could not find {arg}.wave or {arg}.py').throw()
def main(DeepForest_config, model=None, args=None):
# parse arguments
if args is None:
args = sys.argv[1:]
args = parse_args(args)
#Add seperate dir
#save time for logging
dirname = datetime.now().strftime("%Y%m%d_%H%M%S")
if args.save_path:
save_path = args.save_path + dirname
# make save path if it doesn't exist
if not os.path.exists(save_path):
os.makedirs(save_path)
else:
save_path = None
#Evaluation metrics
site = DeepForest_config["evaluation_site"]
#create the NEON mAP generator
NEON_generator = create_NEON_generator(args.batch_size, DeepForest_config)
#NEON plot mAP
recall, precision = evaluate_pr(NEON_generator,
model,
iou_threshold=args.iou_threshold,
score_threshold=args.score_threshold,
max_detections=args.max_detections,
save_path=save_path,
experiment=None)
return [recall, precision]
def main(DeepForest_config, model=None, args=None):
# parse arguments
if args is None:
args = sys.argv[1:]
args = parse_args(args)
#Add seperate dir
#save time for logging
dirname = datetime.now().strftime("%Y%m%d_%H%M%S")
save_path = DeepForest_config["save_image_path"] + dirname
os.makedirs(save_path)
print("save path is {}".format(save_path))
#Evaluation metrics
site = DeepForest_config["evaluation_site"]
#create the NEON mAP generator
NEON_generator = create_NEON_generator(args.batch_size, DeepForest_config)
#NEON plot mAP
recall, precision = evaluate_pr(NEON_generator,
model,
iou_threshold=args.iou_threshold,
score_threshold=args.score_threshold,
max_detections=args.max_detections,
save_path=save_path,
experiment=None)
return [recall, precision]
def useg(env, *args):
args = eval.parse_args(args, env) # Parse args
for arg in args:
try: # Try to open a local file first
import_env = eval.Env(arg + '.wave')
for name in env.getscope():
import_env.setval(name, env.getscope()[name])
import_env.run()
env.pyvars.update(import_env.pyvars)
for name in import_env.getscope():
env.setval(name, import_env.getscope()[name])
except FileNotFoundError: # If we can't do that then try to import a Python module
try:
try:
importlib.import_module(arg).setup(env)
except AttributeError:
lib = importlib.import_module(arg)
env.pyvars[arg] = lib
except ImportError: # If we can't do that then try to open a standard library file
try:
import_env = eval.Env(os.path.abspath('lib/' + arg + '.wave'))
for name in env.getscope():
import_env.setval(name, env.getscope()[name])
import_env.run()
env.pyvars.update(import_env.pyvars)
for name in import_env.getscope():
env.setval(name, import_env.getscope()[name])
except FileNotFoundError: # If we can't do that then give up
errors._UseError(f'Could not find {arg}.wave or {arg}.py').throw()
def _object(env, *args):
args = eval.parse_args(args, env)
out = {}
l = args[0]
for i in range(0, len(l), 2): # Set up keys and values
out[l[i]] = l[i + 1]
return out
def bool_print(env, *args):
args = eval.parse_args(args, env)
arg = args[0]
if arg: # Print as a boolean
print('true', end='')
else:
print('false', end='')
def _while(env, *args):
args = eval.parse_args(args, env)
expr = args[0] # Get the expression and body
body = args[1]
if isinstance(body, str): # Format strings
body = '"' + body + '"'
while _eval(env, expr): # Go
_eval(env, body)
def list_print(env, *args):
args = eval.parse_args(args, env)
arg = args[0]
print('[', end='') # Opening bracket
for item in arg:
_print(env, item)
print(' ', end='') # Print items
print('\x08]', end='') # Remove the last space and print a bracket
def _for(env, *args):
var = args[0] # Get the variable, iterable, and body
args = eval.parse_args(args, env)
iter = args[1]
body = args[2]
if isinstance(body, str): # Format strings
body = '"' + body + '"'
for item in iter: # Go
env.setval(var, item)
_eval(env, body)
def node_print(env, *args):
args = eval.parse_args(args, env) # Just like list-print
arg = args[0]
print('(', end='')
for item in arg.node:
if isinstance(item, list):
node_print(env, Node(item)) # Recursive printing
else:
print(item, end=' ')
print('\x08)', end='')
def _eval(env, *args):
args = eval.parse_args(args, env)
arg = args[0]
if isinstance(arg, eval.Node): # If it is a node, evaluate that
return arg.eval(env)
else: # Otherwise, run a string
eval_env = eval.Env(code=str(arg))
setup(eval_env)
eval_env.run()
env.scopes[env.scope].update(eval_env.getscope())
def object_print(env, *args):
args = eval.parse_args(args, env)
arg = args[0]
print('{', end='') # Just like list-print
for key in arg:
value = arg[key]
print(key, end=':')
_print(env, value) # Prints key and value
print(' ', end='')
print('\x08}', end='')
def switch(env, *args):
args = eval.parse_args(args, env) # Get the expression, values, and outputs
expr = args[0]
vals = args[1]
outs = args[2]
i = 0
for val in vals:
if expr == val: # If we find a match, run that
return _eval(env, outs[i])
i += 1
return _eval(env, outs[-1]) # Run the last thing
def _if(env, *args):
args = eval.parse_args(args, env) # Parse the args
t = args[1] # True code
f = args[2] # False code
if isinstance(t, str): # Format strings correctly
t = '"' + t + '"'
if isinstance(f, str):
f = '"' + f + '"'
expr = args[0] # Get the expression
if expr: # Choose some code to evaluate
return _eval(env, t)
return _eval(env, f)
def py(env, *args):
pyvars = env.getscope() # Set up globals()
pyvars['env'] = env
pyvars['eval'] = eval
pyvars['data'] = data
pyvars.update(env.pyvars)
args = eval.parse_args(args, env)
exec(f'_ = {args[0]}', pyvars) # Yes, this is insecure, but if the user does something bad, it only harms their computer
p = env.getscope().keys()
for key in p:
if key in env.pyvars:
del env.pyvars[key]
return pyvars['_'] # Return the output
def run(env, *args):
args = eval.parse_args(args, env) # Parse arguments
env.scopes.append({}) # Create a new scope
env.scope += 1
i = 0
env.scopes[env.scope].update(env.scopes[env.scope - 1]) # Add the old scope to it
for var in need: # Set up arguments
env.setval(str(var), args[i])
i += 1
env.setval(name, run) # Allow recursion
out = _eval(env, body) # Run the code
env.scope -= 1
env.scopes.pop() # Delete our scope
return out
def _print(env, *args):
args = eval.parse_args(args, env)
methods = {
data.num_t: number_print,
data.arr_t: list_print,
data.str_t: string_print,
data.node_t: node_print,
data.bool_t: bool_print,
data.obj_t: object_print,
data.nil_t: nil_print,
}
for arg in args:
for type in methods:
if isinstance(arg, type):
methods[type](env, arg) # Call the correct method
def main(DeepForest_config, args=None):
# parse arguments
if args is None:
args = sys.argv[1:]
args = parse_args(args)
# make sure keras is the minimum required version
check_keras_version()
# optionally choose specific GPU
if args.gpu:
os.environ['CUDA_VISIBLE_DEVICES'] = args.gpu
keras.backend.tensorflow_backend.set_session(get_session())
#Add seperate dir
#save time for logging
dirname = datetime.now().strftime("%Y%m%d_%H%M%S")
# make save path if it doesn't exist
if args.save_path is not None and not os.path.exists(args.save_path +
dirname):
os.makedirs(args.save_path + dirname)
#Evaluation metrics
site = DeepForest_config["evaluation_site"]
#create the NEON mAP generator
NEON_generator = create_NEON_generator(args.batch_size, DeepForest_config)
# load the model
print('Loading model, this may take a second...')
model = models.load_model(args.model,
backbone_name=args.backbone,
convert=args.convert_model,
nms_threshold=DeepForest_config["nms_threshold"])
#print(model.summary())
#NEON plot mAP
recall, precision = evaluate_pr(NEON_generator,
model,
iou_threshold=args.iou_threshold,
score_threshold=args.score_threshold,
max_detections=args.max_detections,
save_path=args.save_path + dirname,
experiment=None)
return [recall, precision]
def add(env, *args):
args = eval.parse_args(args, env)
return args[0] + args[1]
def lt(env, *args):
args = eval.parse_args(args, env)
return args[0] < args[1]
def mod(env, *args):
args = eval.parse_args(args, env)
return args[0] % args[1]
def pow(env, *args):
args = eval.parse_args(args, env)
return args[0]**args[1]
def div(env, *args):
args = eval.parse_args(args, env)
return args[0] / args[1]
def mul(env, *args):
args = eval.parse_args(args, env)
return args[0] * args[1]
def setup_eval():
eval_script.parse_args([
'--no_bar', '--batch_size=' + str(args.eval_batch_size),
'--output_json', '--score_threshold=' + str(cfg.eval_conf_thresh),
'--mask_det_file=' + args.save_folder + 'eval_mask_det.json'
])
def le(env, *args):
args = eval.parse_args(args, env)
return args[0] != args[1]
def setup_eval():
eval_script.parse_args(
['--no_bar', '--max_images=' + str(args.validation_size)])
def sub(env, *args):
args = eval.parse_args(args, env)
return args[0] - args[1]
