def test_script(self, execute_manager):
# The test script should execute the standard Django test
# command with any apps given as its arguments.
test.main('cheeseshop.development', 'spamm', 'eggs')
# We only care about the arguments given to execute_manager
self.assertEqual(execute_manager.call_args[1],
{'argv': ['test', 'test', 'spamm', 'eggs']})
def test_deeply_nested_settings(self, execute_manager):
# Settings files can be more than two levels deep. We need to
# make sure the test script can properly import those. To
# demonstrate this we need to add another level to our
# sys.modules entries.
settings = mock.sentinel.SettingsModule
nce = mock.sentinel.NCE
nce.development = settings
sys.modules['cheeseshop'].nce = nce
sys.modules['cheeseshop.nce'] = nce
sys.modules['cheeseshop.nce.development'] = settings
test.main('cheeseshop.nce.development', 'tilsit', 'stilton')
self.assertEqual(execute_manager.call_args[0], (settings,))
def run(): global USE_GPUS val_num = np.random.randint(1, 6) cifar10_input.set_constants(train=True, val_num=val_num) if USE_GPUS: import cifar10_multi_gpu_train cifar10_multi_gpu_train.main() else: import cifar10_train cifar10_train.main() if TEST: test.main() else: cifar10_input.set_constants(train=False, val_num=val_num) cifar10_eval.main()
def run_tests(self):
# import here, because outside the eggs aren't loaded
here = os.path.abspath(os.path.dirname(__file__))
sys.path.insert(0, os.path.join(here, 'test'))
import test
errno = test.main(self.pytest_args.split())
sys.exit(errno)
def exampleSetup(): import test data4,data5,handover_starts,l0,U0,l1,U1e,U1,l2,U2,U2e,ainds,alabs = test.main() def loader(handover_starts,data_object,n): try: starts = [handover_starts[n],handover_starts[n+1]] except IndexError: starts = [handover_starts[n],data_object.num_vectors-1] return starts def runTasks(data_obj,task_obj,n,max_ind=10): inds = np.random.randint(max_ind,size=n) for i in inds: task_obj.update(data_obj,loader(handover_starts,data_obj,i)) #initializing a task for the data4 object then showing the times for each path member task = Task(data4,loader(handover_starts,data4,0)) print task.times out = task.printTaskDef() #updating a task for the data4 object then showing the times for each path member task.update(data4,loader(handover_starts,data4,1)) print task.times out = task.printTaskDef() #or can do: task = Task(data4,loader(handover_starts,data4,0)) n = 20 #run 20 random updates from the handover set runTasks(data4,task,n,max_ind=11)
from utils import *
import test
if __name__ == "__main__":
kwargs = get_init_arguments()
test.main(**kwargs)
import pyximport; pyximport.install() from test import main main()
from test import main from .graphics.test_histogram_mpl import * from .serialization.test_histogram_hist import * from .serialization.test_histogram_hdf5 import * from .serialization.test_histogram_numpy import * from .serialization.test_histogram_root import * from .serialization.test_serialization import * from .test_histogram import * from .test_histogram_axis import * from .test_run_control import * main()
total_run_time += time_use
tree_information = {
'max_depth': master.max_depth,
'min_bag_size': master.min_bag_size,
'total_run_time': total_run_time,
'avg_run_time': total_run_time/(number_of_tree*1.0),
'file_list': file_list
}
with open(os.path.join(tree_root_folder, mainfile), 'w') as f:
json.dump(tree_information, f, indent=2)
print('\n{} Tree(s) creation successful'.format(number_of_tree))
print('Total run time: {} sec'.format(total_run_time))
print('Avg run time per tree: {} sec'.format(1.0*total_run_time/number_of_tree*1.0))
if __name__ == '__main__':
if len(sys.argv) < 3:
print('Usage: {} <main JSON file name> <dataset file> [optional:number of tree]')
sys.exit(1)
elif len(sys.argv) == 3:
main(sys.argv[1], sys.argv[2])
elif len(sys.argv) == 4:
main(sys.argv[1], sys.argv[2], int(sys.argv[3]))
clmax = 5
test.main(clmax, os.path.join(tree_root_folder, sys.argv[1]))
# --------------------------------------------------------
# Deformable Convolutional Networks
# Copyright (c) 2017 Microsoft
# Licensed under The MIT License [see LICENSE for details]
# Written by Haozhi Qi
# --------------------------------------------------------
import os
import sys
os.environ['PYTHONUNBUFFERED'] = '1'
os.environ['MXNET_CUDNN_AUTOTUNE_DEFAULT'] = '0'
os.environ['MXNET_ENABLE_GPU_P2P'] = '0'
# os.environ['MXNET_ENGINE_TYPE'] = 'NaiveEngine'
this_dir = os.path.dirname(__file__)
sys.path.insert(0, os.path.join(this_dir, '..', '..', 'fpn'))
import train_end2end
import test
if __name__ == "__main__":
train_end2end.main()
test.main()
def main(args, hpnames):
# separate mode or best score mode
repetition = 1
if args.separate_mode:
repetition = args.repetition
args.repetition = 1 # separate model (non best score model)
# TODO: record model configuration in checkpoint
if len(args.tracker.model.backbone.return_layers) == 0:
args.tracker.model.backbone.return_layers = ['layer3']
if len(args.tracker.dcf.layers) == 0:
args.tracker.dcf.layers = ['layer2', 'layer3']
# create dir for result
layers_info = 'trtr_layer'
for layer in args.tracker.model.backbone.return_layers:
layers_info += '_' + layer[-1]
if args.use_baseline_tracker:
layers_info += '_baseline'
else:
layers_info += '_dcf_layer'
for layer in args.tracker.dcf.layers:
layers_info += '_' + layer[-1]
if args.separate_mode:
args.save_path += '_separate'
args.result_path = os.path.join(
args.save_path,
os.path.splitext(os.path.basename(args.tracker.checkpoint))[0],
layers_info)
dataset_path = os.path.join(args.result_path, args.dataset)
if not os.path.isdir(dataset_path):
os.makedirs(dataset_path)
hparams = dict()
for name in hpnames:
val = args
for idx, n in enumerate(name.split('.')):
if idx == len(name.split('.')) - 1:
default_value = getattr(val, n[:-1])
val = getattr(val, n)
if len(val) == 0:
hparams[name] = [default_value]
else:
hparams[name] = [type(default_value)(v) for v in val]
hparams['runs'] = list(range(1, repetition + 1))
tracker_num = len(list(itertools.product(*hparams.values())))
for tracker_id, hparam_set in enumerate(
itertools.product(*hparams.values())):
t = time.time()
print("start {}/{} tracker test".format(tracker_id + 1, tracker_num))
model_name = ''
if args.use_baseline_tracker:
model_name = 'baseline_'
for idx, (name, val) in enumerate(zip(hparams.keys(), hparam_set)):
args_temp = args
for str_id, n in enumerate(name[:-1].split('.')):
if str_id == len(name.split('.')) - 1:
setattr(args_temp, n, val)
args_temp = getattr(args_temp, n)
if args.use_baseline_tracker and 'dcf' in name:
continue
model_name += name[:-1].replace('tracker.', '').replace(
'postprocess.', '').replace('.', '_') + "_" + str(val).replace(
'.', 'p')
if idx < len(hparam_set) - 1:
model_name += '_'
if not args.use_baseline_tracker:
model_name += '_false_positive' # workaround to distinguish with old model name
if args.tracker.model.transformer_mask:
model_name += '_with_transformer_mask'
#print(model_name)
model_dir = os.path.join(dataset_path, model_name)
if not os.path.isdir(model_dir):
os.makedirs(model_dir)
args.model_name = model_name
with open(os.path.join(model_dir, 'log.txt'), 'a') as f:
f.write('parameters: \n')
f.write('{}'.format(vars(args)) + '\n\n')
# create tracker
if args.use_baseline_tracker:
tracker = build_baseline_tracker(args.tracker)
else:
tracker = build_online_tracker(args.tracker)
# start test with benchmark
benchmark.main(args, tracker)
du = round(time.time() - t)
print("finish {}/{} tracker test, take {}, rest {} ".format(
tracker_id + 1, tracker_num, datetime.timedelta(seconds=du),
datetime.timedelta(seconds=du * (tracker_num - tracker_id - 1))))
r += k
i += len(k)
break
else:
if not s[i].isspace():
r += s[i]
i += 1
print(r)
with open("liczba-min.cpp", "w") as file:
file.write(r)
print("= Compiling =")
compile_ok = 0 == system(
"g++ -O2 -pedantic -Wextra -Wall -std=c++98 -c liczba-min.cpp -o liczba-min.o"
)
if compile_ok:
compile_ok = 0 == system(
"g++ -O2 -pedantic -Wextra -Wall -std=c++98 -o liczba-min.exe liczba-min.o"
)
if compile_ok:
print("= Testing =")
test_ok = test.main("liczba-min.exe", False)
else:
test_ok = None
if compile_ok and test_ok:
print("Success!")
print(f"Length: {len(r)}")
else:
print("Failure.")
print(f"Compilation OK: {compile_ok}\nTests OK: {test_ok}")
system("pause")
def main():
usage = "Usage: vcfPytools.py [tool] [options]\n\n" + \
"Available tools:\n" + \
" annotate:\n\tAnnotate the vcf file with membership in other vcf files.\n" + \
" extract:\n\tExtract vcf records from a region.\n" + \
" filter:\n\tFilter the vcf file.\n" + \
" indel:\n\tIndel manipulation tools.\n" + \
" intersect:\n\tGenerate the intersection of two vcf files.\n" + \
" merge:\n\tMerge a list of vcf files.\n" + \
" multi:\n\tFind the intersections and unique fractions of multiple vcf files.\n" + \
" sort:\n\tSort a vcf file.\n" + \
" stats:\n\tGenerate statistics from a vcf file.\n" + \
" union:\n\tGenerate the union of two vcf files.\n" + \
" unique:\n\tGenerate the unique fraction from two vcf files.\n" + \
" validate:\n\tValidate the input vcf file.\n\n" + \
"vcfPytools.py [tool] --help for information on a specific tool."
# Determine the requested tool.
if len(sys.argv) > 1:
tool = sys.argv[1]
else:
print >> sys.stderr, usage
exit(1)
if tool == "annotate":
import annotate
success = annotate.main()
elif tool == "extract":
import extract
success = extract.main()
elif tool == "filter":
import filter
success = filter.main()
elif tool == "intersect":
import intersect
success = intersect.main()
elif tool == "indel":
import indel
success = indel.main()
elif tool == "multi":
import multi
success = multi.main()
elif tool == "merge":
import merge
success = merge.main()
elif tool == "sort":
import sort
success = sort.main()
elif tool == "stats":
import stats
success = stats.main()
elif tool == "union":
import union
success = union.main()
elif tool == "unique":
import unique
success = unique.main()
elif tool == "test":
import test
success = test.main()
elif tool == "validate":
import validate
success = validate.main()
elif tool == "--help" or tool == "-h" or tool == "?":
print >> sys.stderr, usage
else:
print >> sys.stderr, "Unknown tool: ", tool
print >> sys.stderr, "\n", usage
exit(1)
# If program completed properly, terminate.
if success == 0: exit(0)
def compute_termfreq(list_top_k, file_path):
return test.main(list_top_k, file_path)
opt.kps = info.kps
if not if_exist:
csv_writer.writerow(write_test_title())
for op, mdl, name, fold in zip(option_ls, model_ls, name_ls, folder_ls):
log = [fold, name]
info = torch.load(op)
cfg = info.struct
backbone = info.backbone
opt.kps = info.kps
opt.DUC = info.DUC
print("Testing model {}".format(mdl))
benchmark, overall, part, thresholds = main(backbone, cfg, test_data, mdl)
for item in benchmark:
log.append(item)
log.append(computer)
for item in overall:
if isinstance(item, torch.Tensor):
item = item.tolist()
log.append(item)
log.append(" ")
for indicator in part:
for kp in indicator:
if isinstance(kp, torch.Tensor):
kp = kp.tolist()
def google():
main()
if False:
from test2 import main
def _parse_args():
parser = argparse.ArgumentParser(description="Run Bert finetune for qa")
parser.add_argument('data_folder',
type=Path,
help='./release2/test/ca_data')
parser.add_argument('--config_path',
type=Path,
help='config_path',
default="./dataset")
parser.add_argument(
'--model_path',
type=str,
help='model_path',
default="./lightning_logs/version_63/checkpoints/epoch=1.ckpt")
parser.add_argument('--predict_path',
type=str,
help='predict_path',
default="./prediction.csv")
args = parser.parse_args()
return args
if __name__ == '__main__':
args = _parse_args()
combine_lines.main(args)
preprocess.main(args)
test.main(args)
def main():
essay_name = [
1, 6, 7, 8, 13, 15, 16, 17, 21, 22, 23, 24, 25, 26, 27, 28, 29, 10, 14,
37, 38, 39, 40, 41, 42, 43, 44, 45, 46
]
test_essays = [
1, 9, 11, 12, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 62, 63
]
uni_essay_list = []
bi_essay_list = []
tri_essay_list = []
read_files(uni_essay_list, 1, essay_name)
read_files(bi_essay_list, 2, essay_name)
read_files(tri_essay_list, 3, essay_name)
hamilton = ngram.model("HAMILTON", {}, {}, {}, {}, {})
madison = ngram.model("HAMILTON", {}, {}, {}, {}, {})
hamilton.unigram = ngram.unigram("HAMILTON", uni_essay_list)
madison.unigram = ngram.unigram("MADISON", uni_essay_list)
hamilton.bigram, hamilton.bigram_generate = ngram.bigram(
"HAMILTON", bi_essay_list)
madison.bigram, madison.bigram_generate = ngram.bigram(
"MADISON", bi_essay_list)
hamilton.trigram, hamilton.trigram_generate = ngram.trigram(
"HAMILTON", tri_essay_list)
madison.trigram, madison.trigram_generate = ngram.trigram(
"MADISON", tri_essay_list)
for i in range(2):
hamilton_generate_uni_essay = ngram.unigram_generator(
hamilton.unigram, sum(hamilton.unigram.values()))
hamilton_generate_bi_essay = ngram.bigram_generator(
hamilton.bigram_generate.copy())
hamilton_generate_tri_essay = ngram.trigram_generator(
hamilton.trigram_generate.copy())
madison_generate_uni_essay = ngram.unigram_generator(
madison.unigram, sum(madison.unigram.values()))
madison_generate_bi_essay = ngram.bigram_generator(
madison.bigram_generate.copy())
madison_generate_tri_essay = ngram.trigram_generator(
madison.trigram_generate.copy())
print(
"********************************** HAMILTON UNIGRAM ESSAY :**************************************"
)
print(hamilton_generate_uni_essay)
print(
"HAMILTON: ",
test.unigram_test(hamilton_generate_uni_essay.split(" "),
hamilton.unigram,
sum(hamilton.unigram.values())))
print(
"MADISON: ",
test.unigram_test(hamilton_generate_uni_essay.split(" "),
madison.unigram, sum(madison.unigram.values())),
"\n")
print(
"********************************** HAMILTON BIGRAM ESSAY :**************************************"
)
print(hamilton_generate_bi_essay)
print(
"HAMILTON: ",
test.bigram_test(hamilton_generate_bi_essay.split(" "),
hamilton.bigram, len(hamilton.bigram.keys()),
hamilton.unigram))
print(
"MADISON: ",
test.bigram_test(hamilton_generate_bi_essay.split(" "),
madison.bigram, len(madison.bigram.keys()),
madison.unigram), "\n")
print(
"********************************** HAMILTON TRIGRAM ESSAY :**************************************"
)
print(hamilton_generate_tri_essay)
print(
"HAMILTON",
test.trigram_test(hamilton_generate_tri_essay.split(" "),
hamilton.bigram, len(hamilton.trigram.keys()),
hamilton.trigram))
print(
"MADISON",
test.trigram_test(hamilton_generate_tri_essay.split(" "),
madison.bigram, len(madison.trigram.keys()),
madison.trigram), "\n")
print(
"********************************** MADISON UNIGRAM ESSAY :**************************************"
)
print(madison_generate_uni_essay)
print(
"HAMILTON: ",
test.unigram_test(madison_generate_uni_essay.split(" "),
hamilton.unigram,
sum(hamilton.unigram.values())))
print(
"MADISON: ",
test.unigram_test(madison_generate_uni_essay.split(" "),
madison.unigram, sum(madison.unigram.values())),
"\n")
print(
"********************************** MADISON BIGRAM ESSAY :**************************************"
)
print(madison_generate_bi_essay, "\n")
print(
"HAMILTON: ",
test.bigram_test(madison_generate_bi_essay.split(" "),
hamilton.bigram, len(hamilton.bigram.keys()),
hamilton.unigram))
print(
"MADISON: ",
test.bigram_test(madison_generate_bi_essay.split(" "),
madison.bigram, len(madison.bigram.keys()),
madison.unigram), "\n")
print(
"********************************** MADISON TRIGRAM ESSAY :**************************************"
)
print(madison_generate_tri_essay)
print(
"HAMILTON",
test.trigram_test(madison_generate_tri_essay.split(" "),
hamilton.bigram, len(hamilton.trigram.keys()),
hamilton.trigram))
print(
"MADISON",
test.trigram_test(madison_generate_tri_essay.split(" "),
madison.bigram, len(madison.trigram.keys()),
madison.trigram), "\n")
test.main(test_essays, hamilton.unigram, hamilton.bigram, hamilton.trigram,
madison.unigram, madison.bigram, madison.trigram)
def test():
import test
print('Starting Testing')
test.main()
def run():
if args.English:
test.main("en")
elif args.Hindi:
test.main("hi")
elif args.Spanish:
test.main("es")
elif args.French:
test.main("fr")
elif args.Arabic:
test.main("ar")
elif args.Bengali:
test.main("bn")
elif args.Russian:
test.main("ru")
elif args.Portuguese:
test.main("pt")
elif args.Indonesian:
test.main("id")
else:
test.main("en")
type=float,
default=0.0005,
help='L2 Reg rate')
parser.add_argument('--batch', type=int, default=32, help='batch size')
parser.add_argument('--epoch',
type=int,
default=500,
help='number of epochs to train')
parser.add_argument('--no-shuffle',
action='store_true',
default=False,
help='don\'t shuffle training data')
""" test options """
parser.add_argument('--load_model', default=None, help='path to model')
parser.add_argument('--load_word', default=None, help='path to words')
parser.add_argument('--load_label', default=None, help='path to labels')
parser.add_argument('--load_emb', default=None, help='path to embs')
argv = parser.parse_args()
print
print argv
print
if argv.mode == 'train':
import train
train.main(argv)
else:
import test
test.main(argv)
def main(opt):
os.makedirs('weights', exist_ok=True)
# Configure run
data_config = parse_data_config(opt.data_config_path)
num_classes = int(data_config['classes'])
if platform == 'darwin': # MacOS (local)
train_path = data_config['train']
else: # linux (cloud, i.e. gcp)
train_path = '../coco/trainvalno5k.part'
# Initialize model
model = Darknet(opt.cfg, opt.img_size)
# Get dataloader
dataloader = load_images_and_labels(train_path,
batch_size=opt.batch_size,
img_size=opt.img_size,
augment=True)
# Reload saved optimizer state
start_epoch = 0
best_loss = float('inf')
if opt.resume:
checkpoint = torch.load('weights/latest.pt', map_location='cpu')
model.load_state_dict(checkpoint['model'])
if torch.cuda.device_count() > 1:
print('Using ', torch.cuda.device_count(), ' GPUs')
model = nn.DataParallel(model)
model.to(device).train()
# # Transfer learning (train only YOLO layers)
# for i, (name, p) in enumerate(model.named_parameters()):
# if p.shape[0] != 650: # not YOLO layer
# p.requires_grad = False
# Set optimizer
if opt.optimizer is 'Adam':
optimizer = torch.optim.Adam(filter(lambda p: p.requires_grad,
model.parameters()),
lr=1e-4,
weight_decay=5e-4)
else:
optimizer = torch.optim.SGD(filter(lambda p: p.requires_grad,
model.parameters()),
lr=1e-3,
momentum=.9,
weight_decay=5e-4)
start_epoch = checkpoint['epoch'] + 1
if checkpoint['optimizer'] is not None:
optimizer.load_state_dict(checkpoint['optimizer'])
best_loss = checkpoint['best_loss']
del checkpoint # current, saved
else:
# Initialize model with darknet53 weights (optional)
if not os.path.isfile('weights/darknet53.conv.74'):
os.system(
'wget https://pjreddie.com/media/files/darknet53.conv.74 -P weights'
)
load_weights(model, 'weights/darknet53.conv.74')
if torch.cuda.device_count() > 1:
print('Using ', torch.cuda.device_count(), ' GPUs')
model = nn.DataParallel(model)
model.to(device).train()
# Set optimizer
if opt.optimizer is 'Adam':
optimizer = torch.optim.Adam(filter(lambda p: p.requires_grad,
model.parameters()),
lr=1e-4,
weight_decay=5e-4)
else:
optimizer = torch.optim.SGD(filter(lambda p: p.requires_grad,
model.parameters()),
lr=1e-3,
momentum=.9,
weight_decay=5e-4)
# Set scheduler
# scheduler = torch.optim.lr_scheduler.MultiStepLR(optimizer, milestones=[54, 61], gamma=0.1)
model_info(model)
t0, t1 = time.time(), time.time()
mean_recall, mean_precision = 0, 0
print('%11s' * 16 %
('Epoch', 'Batch', 'x', 'y', 'w', 'h', 'conf', 'cls', 'total', 'P',
'R', 'nTargets', 'TP', 'FP', 'FN', 'time'))
for epoch in range(opt.epochs):
epoch += start_epoch
# Update scheduler (automatic)
# scheduler.step()
# Update scheduler (manual) at 0, 54, 61 epochs to 1e-3, 1e-4, 1e-5
if epoch > 50:
lr = 1e-4
else:
lr = 1e-3
for g in optimizer.param_groups:
g['lr'] = lr
ui = -1
rloss = defaultdict(float) # running loss
metrics = torch.zeros(3, num_classes)
optimizer.zero_grad()
for i, (imgs, targets) in enumerate(dataloader):
if sum([len(x) for x in targets]) < 1: # if no targets continue
continue
# SGD burn-in
if (epoch == 0) & (i <= 1000):
lr = 1e-3 * (i / 1000)**4
for g in optimizer.param_groups:
g['lr'] = lr
# Compute loss, compute gradient, update parameters
loss = model(imgs.to(device),
targets,
batch_report=opt.batch_report)
loss.backward()
# accumulated_batches = 1 # accumulate gradient for 4 batches before stepping optimizer
# if ((i+1) % accumulated_batches == 0) or (i == len(dataloader) - 1):
optimizer.step()
optimizer.zero_grad()
# Running epoch-means of tracked metrics
ui += 1
for key, val in model.losses.items():
rloss[key] = (rloss[key] * ui + val) / (ui + 1)
if opt.batch_report:
TP, FP, FN = metrics
metrics += model.losses['metrics']
# Precision
precision = TP / (TP + FP)
k = (TP + FP) > 0
if k.sum() > 0:
mean_precision = precision[k].mean()
# Recall
recall = TP / (TP + FN)
k = (TP + FN) > 0
if k.sum() > 0:
mean_recall = recall[k].mean()
s = ('%11s%11s' + '%11.3g' * 14) % (
'%g/%g' % (epoch, opt.epochs - 1), '%g/%g' %
(i, len(dataloader) - 1), rloss['x'], rloss['y'], rloss['w'],
rloss['h'], rloss['conf'], rloss['cls'], rloss['loss'],
mean_precision, mean_recall, model.losses['nT'],
model.losses['TP'], model.losses['FP'], model.losses['FN'],
time.time() - t1)
t1 = time.time()
print(s)
# Update best loss
loss_per_target = rloss['loss'] / rloss['nT']
if loss_per_target < best_loss:
best_loss = loss_per_target
# Save latest checkpoint
checkpoint = {
'epoch': epoch,
'best_loss': best_loss,
'model': model.state_dict(),
'optimizer': optimizer.state_dict()
}
torch.save(checkpoint, 'weights/latest.pt')
# Save best checkpoint
if best_loss == loss_per_target:
os.system('cp weights/latest.pt weights/best.pt')
# Save backup weights every 5 epochs
if (epoch > 0) & (epoch % 5 == 0):
os.system('cp weights/latest.pt weights/backup' + str(epoch) +
'.pt')
# Calculate mAP
test.opt.weights_path = 'weights/latest.pt'
mAP, R, P = test.main(test.opt)
# Write epoch results
with open('results.txt', 'a') as file:
file.write(s + '%11.3g' * 3 % (mAP, P, R) + '\n')
# Save final model
dt = time.time() - t0
print('Finished %g epochs in %.2fs (%.2fs/epoch)' % (epoch, dt, dt /
(epoch + 1)))
def evaluate(sb, options):
state = EvalState()
phase_argv = ['--sandbox', sb.get_root()]
with ioutil.WorkingDir(sb.get_root()) as td:
with sb.lock('eval') as lock:
try:
try:
if not options.no_update:
with Phase(state, EvalPhase.UPDATE, lock) as phase:
state.err = update(sb, lock)
if not state.err:
with Phase(state, EvalPhase.BUILD, lock) as phase:
argv = get_build_phase_args(phase_argv, options)
state.err = build.main(argv)
if not state.err:
with Phase(state, EvalPhase.TEST, lock) as phase:
argv = get_test_phase_args(["test"], options)
state.err = test.main(argv)
if (not state.err) and sb.get_sandboxtype().get_should_publish():
with Phase(state, EvalPhase.PUBLISH, lock) as phase:
state.err = publish.main(phase_argv)
except:
txt = traceback.format_exc()
print(txt)
# It is possible for us to get an exception as we try to enter
# a phase (including the first one). In such a case, we need
# to work extra hard to help the user understand what's wrong.
txt = txt.replace('\r', '').replace('\n', '; ').replace(',', ' ')
state.reason = 'exception in build process itself: ' + txt
if not state.timestamps:
state.timestamps.append(time.time())
state.phase = EvalPhase.UPDATE
finally:
if os.path.exists(os.path.join(sb.get_root(), 'notify.txt')):
if (not sb.get_sandboxtype().get_notify_on_success()) and (not state.err):
os.remove('%snotify.txt' % sb.get_root())
else:
notify = open('%snotify.txt' % sb.get_root(), 'r')
emails = notify.read()
notify.close()
body = ''
if os.path.exists(os.path.join(sb.get_root(), 'eval-log.txt')):
body = os.path.join(sb.get_root(), 'eval-log.txt')
os.remove('%snotify.txt' % sb.get_root())
bi = buildinfo.BuildInfo()
if state.err:
status = 'Failed'
else:
status = 'Succeeded'
subject = '%s build of %s on %s %s.' % (sb.get_variant(), sb.get_top_component(), bi.host, status)
arguments = '--to %s --sender sadm --subject "%s" --host smtp.example.com --port 587' % (emails, subject) # TODO KIM TO CONF
arguments += ' --username [email protected] --password password' # TODO KIM TO CONF
if body:
arguments += ' --body "%s"' % body
os.system('python %s/buildscripts/mailout.py %s' % (sb.get_code_root(), arguments))
if not state.err:
state.reason = ''
if _should_report(sb, options):
report(sb, state)
else:
print('Skipping report phase.')
return state.err
parser.add_argument('--init_emb', default=None, help='Initial embedding to be loaded')
parser.add_argument('--opt', default='adam', help='optimization method')
parser.add_argument('--lr', type=float, default=0.01, help='learning rate')
parser.add_argument('--reg', type=float, default=0.0001, help='L2 Reg rate')
parser.add_argument('--batch', type=int, default=32, help='batch size')
parser.add_argument('--epoch', type=int, default=500, help='number of epochs to train')
parser.add_argument('--no-shuffle', action='store_true', default=False, help='don\'t shuffle training data')
""" test options """
parser.add_argument('--model', default=None, help='path to model')
parser.add_argument('--arg_dict', default=None, help='path to arg dict')
parser.add_argument('--vocab_dict', default=None, help='path to vocab dict')
parser.add_argument('--emb_dict', default=None, help='path to emb dict')
argv = parser.parse_args()
print
print argv
print
if argv.mode == 'train':
import train
train.main(argv)
else:
import test
assert argv.model is not None
assert argv.arg_dict is not None
assert argv.vocab_dict is not None
assert argv.emb_dict is not None
test.main(argv)
__author__ = 'EL13115'
import Tkinter
import tkFileDialog
import test
root = Tkinter.Tk()
filename = tkFileDialog.askopenfilename(parent=root, title='Choose a file')
help_class = test.main_args()
if filename != None:
help_class.url = filename
test.main(help_class)
else:
test.main(help_class)
root.mainloop()
'Intended Audience :: Developers',
'Intended Audience :: Information Technology',
'License :: OSI Approved :: BSD License',
'Programming Language :: Cython',
'Programming Language :: Python :: 2',
'Programming Language :: Python :: 2.3',
'Programming Language :: Python :: 2.4',
'Programming Language :: Python :: 2.5',
'Programming Language :: Python :: 2.6',
'Programming Language :: Python :: 3',
'Programming Language :: Python :: 3.0',
'Programming Language :: C',
'Operating System :: OS Independent',
'Topic :: Text Processing :: Markup :: HTML',
'Topic :: Text Processing :: Markup :: XML',
'Topic :: Software Development :: Libraries :: Python Modules'
],
package_dir = {'': 'src'},
packages = ['lxml', 'lxml.html'],
ext_modules = setupinfo.ext_modules(
STATIC_INCLUDE_DIRS, STATIC_LIBRARY_DIRS,
STATIC_CFLAGS, STATIC_BINARIES),
**extra_options
)
if OPTION_RUN_TESTS:
print("Running tests.")
import test
sys.exit( test.main(sys.argv[:1]) )
def generate(): test.parsedata(T.get()) prog_list = test.main() output = sorted(list(prog_list), key=len) T2.insert(END, output[0])
return yesterday_round
current_round = utils.get_current_round()
yesterday_round = get_yesterdays_round()
if str(current_round) == str(yesterday_round):
print(datetime.now())
print('--Still the same round as yesterday--')
print('--No code called for today--', end="\n\n")
else:
print(datetime.now())
save_current_round(current_round)
print("--Round changed from {} to {}--".format(yesterday_round,
current_round))
main.main(current_round, yesterday_round)
print("--main.main() Called--")
print('--Current round saved--', end="\n\n")
def test_settings_error(self, sys_exit):
# When the settings file cannot be imported the test runner
# wil exit with a message and a specific exit code.
test.main('cheeseshop.tilsit', 'stilton')
self.assertEqual(sys_exit.call_args, ((1,), {}))
def main():
"""TODO: Docstring for main.
:returns: TODO
"""
test.main()
output_dir + '/%s-%s' % (test, plot_file),
)
if __name__ == "__main__":
parser = OptionParser()
parser.add_option('-b', '--BuildName', default=None)
(options, args) = parser.parse_args()
print "Are you sure you want to rerun the entire test suite? (y/n)"
print "You will create a lot of images and it may take a while"
res = raw_input()
if res == 'y':
print "RUNNING ALL TEST CASES AND SAVING IT"
test.main(options.BuildName)
dir_name = make_dir_name()
if not os.path.exists(dir_name):
os.mkdir(dir_name)
print 'Copying data to ' + dir_name
shutil.copy('test_results/test_event_results.html', dir_name)
shutil.copy('test_results/test_event_results.csv', dir_name)
shutil.copy('test_results/test_frame_results.html', dir_name)
shutil.copy('test_results/test_frame_results.csv', dir_name)
# so that it renders in github
shutil.copy('test_results/test_event_results_bw.html', dir_name + '/' + 'README.md')
shutil.copy('test_results/test_frame_results_bw.html', dir_name + '/' + 'README.md')
copy_test_plots('test_suite/test_cases/', dir_name)
#!/usr/bin/env python # -*- coding: UTF-8 -*- # # Copyright 2016 sadikovi # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # import sys import test sys.exit(test.main())
invalidButNotRejected = '%:$|!#$%#$U%O\\/^'
lock, _ = self.testConstructor(filename=invalidButNotRejected)
self.assertEqual(invalidButNotRejected, lock.filename)
def test_obtain_AND_release(self):
lock, filename = self.testConstructor()
self.failUnless(lock.obtain())
self.failUnless(os.path.exists(lock.filename))
lock.release()
self.failIf(os.path.exists(lock.filename))
def test_release_invalid(self):
# Make sure the FSLock doesn't segfault if the lock file gets deleted
# out from under it. It's allowed to raise an exception, though.
lock, filename = self.testConstructor()
self.failUnless(lock.obtain())
self.failUnless(os.path.exists(lock.filename))
os.remove(lock.filename)
try:
lock.release()
except:
pass
if __name__ == '__main__':
import test
test.main(suite=getFullTestSuite())
def main():
# constants
num_channels = cfg.config['num_channels']
classes = cfg.config['classes']
num_classes = len(classes)
height = cfg.config['height']
width = cfg.config['width']
anchors = cfg.config['anchors']
num_anchors = len(anchors[0])
nms_iou = cfg.config['NMS_IoU']
confidency = cfg.config['confidency']
cuda = cfg.config['CUDA']
weight_path = cfg.config['path']['detect_weight']
# unloaded net
net = None
# main loop
while True:
# print usage
# print('Available commands:')
# print(' detect image_path output_path')
# print(' train')
# print(' test')
# print(' quit | q | exit')
print('The Detector is Ready.')
# get user input
with open('pipe', 'r') as pipe:
command = pipe.read().replace('\n', '')
# condition to quit
if command == 'q':
break
elif command == 'quit':
break
elif command == 'exit':
break
command = command.split(' ')
# detect
if command[0] == 'detect':
if len(command) != 3:
print('usage: detect image_path output_path')
else:
image_path = command[1]
output_path = command[2]
# load net if it is not loaded
if net is None:
net = model.YOLOv3(num_channels, num_classes, num_anchors)
if cuda:
net = net.cuda()
net.load_state_dict(torch.load(weight_path))
print('Load weight from {}'.format(weight_path))
# load image
image = pre.load_image(image_path, height, width, cuda)
# predict and write bbox
prediction = detect.detect(net, image, anchors, confidency,
nms_iou, cuda)
detect.write_prediction(prediction, output_path, height, width)
# train
elif command[0] == 'train':
if len(command) != 1:
print('usage: train')
train.main()
# test
elif command[0] == 'test':
if len(command) != 1:
print('usage: test')
test.main()
# show usage
else:
print('{}: Unknown command.'.format(command))
def run(self):
self.run_command('build')
import test
test.main()
#!/usr/bin/env python
#_*_coding:utf-8_*_
# 测试模块调用
# 直接使用脚本名调用即可
# 会生成 .pyc文件
import test
test.main("aaaa")
def main(argv):
arg_parser = argparse.ArgumentParser(
description='Update the Python Project Template using diff3.')
arg_parser.add_argument(
'current_project_directory',
help='Directory for the project wanting to be updated')
# arg_parser.add_argument(
# 'old_ppt_directory',
# help='PPT version from which this project originated')
# arg_parser.add_argument(
# 'new_ppt_directory',
# help='PPT version to which this project should be updated')
args = arg_parser.parse_args(args=argv[1:])
# Find the .ppt-version file and read the commit hash from it.
ppt_version_path = os.path.join(
args.current_project_directory, '.ppt-version')
if not os.path.exists(ppt_version_path):
raise SystemExit(
'PPT version cookie not found: {0}'.format(ppt_version_path))
with open(ppt_version_path) as ppt_version_file:
for line in ppt_version_file:
# Allow for comments in the file.
if not line.startswith('#'):
old_revision = line.rstrip()
break
# Grab the path to metadata from setup.py, as we know where that file is.
# We're not sure of the directory where metadata.py resides. We need to
# change directories instead of importing the module directly because there
# are dependent imports.
print("Finding project's `metadata.py' file...")
with cwd(args.current_project_directory):
current_project_setup_module = imp.load_source(
'setup', os.path.join(args.current_project_directory, 'setup.py'))
package_name = current_project_setup_module.metadata.package
metadata_path = os.path.join(
args.current_project_directory, package_name, 'metadata.py')
if not os.path.exists(metadata_path):
raise SystemExit(
'Project metadata file not found: {0}'.format(metadata_path))
# Setup the new PPT directory.
print('Setting up new PPT directory...')
new_ppt_directory = mkdtemp(prefix='ppt-new-')
test.main(['unused_progname',
'--metadata-path', metadata_path,
new_ppt_directory])
# Setup the old PPT directory.
print('Setting up old PPT directory...')
old_ppt_directory = mkdtemp(prefix='ppt-old-')
test.main(['unused_progname',
'--metadata-path', metadata_path,
'--revision', old_revision,
old_ppt_directory])
dirs = [
args.current_project_directory,
old_ppt_directory,
new_ppt_directory,
]
with cwd(args.current_project_directory):
git_ls_files = subprocess.check_output(
['git', 'ls-files']).splitlines()
# Don't diff3 the version cookie.
git_ls_files.remove('.ppt-version')
print('Running diff3...')
for git_path in git_ls_files:
paths = []
for dir_ in dirs:
path = os.path.join(dir_, git_path)
if not os.path.exists(path):
path = '/dev/null'
paths.append(path)
process = subprocess.Popen(
['diff3', '--merge'] + paths,
stdout=subprocess.PIPE)
diff3_out, diff3_err = process.communicate()
if process.returncode != 0:
print('{0}: merge conflicts found, please resolve manually'.format(
paths[0]))
with open(paths[0], 'w') as current_file:
current_file.write(diff3_out)
new_revision = subprocess.check_output(
['git', 'rev-parse', 'HEAD']).rstrip()
print('Updating PPT version cookie (revision {0})...'.format(new_revision))
# Open file for reading and writing.
with open(ppt_version_path, 'r+') as ppt_version_file:
# Strip off the last line.
new_contents_lines = ppt_version_file.readlines()[:-1]
# Append the new revision.
new_contents_lines.append(new_revision)
# Write new contents to file.
new_contents = ''.join(new_contents_lines)
ppt_version_file.seek(0)
print(new_contents, file=ppt_version_file)
print('Removing temporary directories...')
for dir_ in [old_ppt_directory, new_ppt_directory]:
shutil.rmtree(dir_)
def main(expdir, recipe, computing):
'''main function'''
if not os.path.isdir(expdir):
raise Exception('Could not find expdir %s' % expdir)
#read the testing config file
testconf = ConfigParser()
testconf.read(os.path.join(recipe, 'test.cfg'))
#read the data config file
if not os.path.exists(os.path.join(recipe, 'database.cfg')):
raise Exception('cannot find database.cfg in %s' % recipe)
dataconf = ConfigParser()
dataconf.read(os.path.join(recipe, 'database.cfg'))
if os.path.exists(os.path.join(recipe, 'testfeats')):
shutil.copyfile(os.path.join(recipe, 'testfeats'),
os.path.join(expdir, 'testfeats'))
shutil.copyfile(os.path.join(recipe, 'testtasks'),
os.path.join(expdir, 'testtasks'))
elif os.path.exists(os.path.join(expdir, 'testfeats')):
print('exists')
else:
#create the training files
fid = open(os.path.join(expdir, 'testfeats'), 'w')
tid = open(os.path.join(expdir, 'testtasks'), 'w')
for s in testconf.get('test', 'datasections').split(' '):
with open(os.path.join(dataconf.get(s, 'features'), 'feats')) as f:
lines = f.readlines()
lines = [s + '_' + line for line in lines]
fid.writelines(lines)
with open(dataconf.get(s, 'tasks')) as f:
lines = f.readlines()
lines = [s + '_' + line for line in lines]
tid.writelines(lines)
fid.close()
tid.close()
if computing in ('condor', 'condor_gpu'):
#create the outputs directory
if not os.path.isdir(os.path.join(expdir, 'outputs')):
os.makedirs(os.path.join(expdir, 'outputs'))
if computing == 'condor_gpu':
jobfile = 'run_script_GPU.job'
else:
jobfile = 'run_script.job'
#only submit the job if it not running yet
in_queue = os.popen('if condor_q -nobatch -wide | grep -q %s; '
'then echo true; else echo false; fi' %
expdir).read().strip() == 'true'
#submit the condor job
if not in_queue:
os.system('condor_submit expdir=%s script=test'
' assist/condor/%s' % (expdir, jobfile))
else:
test.main(expdir)
def main(argv):
arg_parser = argparse.ArgumentParser(
description='Update the Python Project Template using diff3.')
arg_parser.add_argument(
'current_project_directory',
help='Directory for the project wanting to be updated')
# arg_parser.add_argument(
# 'old_ppt_directory',
# help='PPT version from which this project originated')
# arg_parser.add_argument(
# 'new_ppt_directory',
# help='PPT version to which this project should be updated')
args = arg_parser.parse_args(args=argv[1:])
# Grab the path to metadata from setup.py, as we know where that file is.
old_revision, ppt_version_path = handle_git_ppt_version(args)
# We're not sure of the directory where metadata.py resides. We need to
# change directories instead of importing the module directly because there
# are dependent imports.
print("Finding project's `metadata.py' file...")
with cwd(args.current_project_directory):
current_project_setup_module = imp.load_source(
'setup', os.path.join(args.current_project_directory, 'setup.py'))
package_name = current_project_setup_module.metadata.package
metadata_path = os.path.join(args.current_project_directory, package_name,
'metadata.py')
if not os.path.exists(metadata_path):
raise SystemExit(
'Project metadata file not found: {0}'.format(metadata_path))
# Setup the new PPT directory.
print('Setting up new PPT directory...')
new_ppt_directory = mkdtemp(prefix='ppt-new-')
test.main([
'unused_progname', '--metadata-path', metadata_path, new_ppt_directory
])
# Setup the old PPT directory.
print('Setting up old PPT directory...')
old_ppt_directory = mkdtemp(prefix='ppt-old-')
test.main([
'unused_progname', '--metadata-path', metadata_path, '--revision',
old_revision, old_ppt_directory
])
dirs = [
args.current_project_directory,
old_ppt_directory,
new_ppt_directory,
]
with cwd(args.current_project_directory):
git_ls_files = subprocess.check_output(['git',
'ls-files']).splitlines()
# Don't diff3 the version cookie.
git_ls_files.remove('.ppt-version')
print('Running diff3...')
for git_path in git_ls_files:
paths = []
for dir_ in dirs:
path = os.path.join(dir_, git_path)
if not os.path.exists(path):
path = '/dev/null'
paths.append(path)
process = subprocess.Popen(['diff3', '--merge'] + paths,
stdout=subprocess.PIPE)
diff3_out, diff3_err = process.communicate()
if process.returncode != 0:
print('{0}: merge conflicts found, please resolve manually'.format(
paths[0]))
with open(paths[0], 'w') as current_file:
current_file.write(diff3_out)
new_revision = subprocess.check_output(['git', 'rev-parse',
'HEAD']).rstrip()
print('Updating PPT version cookie (revision {0})...'.format(new_revision))
# Open file for reading and writing.
with open(ppt_version_path, 'r+') as ppt_version_file:
# Strip off the last line.
new_contents_lines = ppt_version_file.readlines()[:-1]
# Append the new revision.
new_contents_lines.append(new_revision)
# Write new contents to file.
new_contents = ''.join(new_contents_lines)
ppt_version_file.seek(0)
print(new_contents, file=ppt_version_file)
print('Removing temporary directories...')
for dir_ in [old_ppt_directory, new_ppt_directory]:
shutil.rmtree(dir_)
def test():
import test
test.main()
def runtest():
'''
Runs the test.py.
'''
from test import main
main()
def main():
py.init()
continuer = 1
son = py.mixer.Sound("enclume.wav")
fenetre = py.display.set_mode((1200, 700))
fond = py.image.load("background1.jpg").convert()
perso = py.image.load("rund.png").convert_alpha()
persog = py.image.load("rung.png").convert_alpha()
enfantok = py.image.load("ice_bucket1.png").convert_alpha()
enfantmouille = py.image.load("ice_bucket4.png").convert_alpha()
py.font.init() #initialisation du texte de fond
font = py.font.Font(None, 36)
text = font.render("Ice Bucket Challenge 2014", 1, (0, 0, 0))
fond.blit(text, (10, 10))
position_enfants = [(random.randint(0, 1110), random.randint(0, 570)),
(random.randint(0, 1110), random.randint(0, 570)),
(random.randint(0, 1110), random.randint(0, 570)),
(random.randint(0, 1110), random.randint(0, 570)),
(random.randint(0, 1110), random.randint(0, 570)),
(random.randint(0, 1110), random.randint(0, 570)),
(random.randint(0, 1110), random.randint(0, 570))]
renverse = np.ones(7)
perso_x = 0
perso_y = 0
droite = True
fenetre.blit(fond, (0, 0))
fenetre.blit(perso, (perso_x, perso_y))
py.display.flip()
count = 0
py.key.set_repeat(20, 1)
lastfalse = random.randint(0, 6)
renverse[lastfalse] = 0
pasttime = py.time.get_ticks()
while continuer and count < 10:
if (py.time.get_ticks() - pasttime) >= 700:
pasttime = py.time.get_ticks()
renverse[lastfalse] = 1
lastfalse = random.randint(0, 6)
renverse[lastfalse] = 0
for event in py.event.get(
): #On parcours la liste de tous les événements reçus
if (event.type == QUIT): #Si un de ces événements est de type QUI
continuer = 0
if event.type == MOUSEMOTION:
perso_x = event.pos[0] - 20
perso_y = event.pos[1] - 20
# if event.type == KEYDOWN: #fait bouger le personnage à droite ou à gauche
# if event.key == K_RIGHT:
# perso_x=perso_x+2
# droite=True
# if event.key == K_LEFT:
# perso_x=perso_x-2
# droite=False
# if event.key == K_UP:
# perso_y=perso_y-2
# if event.key == K_DOWN:
# perso_y=perso_y+2
if event.type == MOUSEBUTTONDOWN:
if event.button == 1:
if (perso_x > position_enfants[lastfalse][0] - 90
and perso_x < position_enfants[lastfalse][0] + 83
and perso_y < position_enfants[lastfalse][1] + 100
and
perso_y > position_enfants[lastfalse][1] - 127):
count += 1
son.play()
position_enfants[lastfalse] = (random.randint(0, 1110),
random.randint(0, 570))
fenetre.blit(fond, (0, 0))
for i in range(0, 6):
if (renverse[i]):
fenetre.blit(enfantok, position_enfants[i])
else:
fenetre.blit(enfantmouille, position_enfants[i])
if droite:
fenetre.blit(perso, ((perso_x, perso_y)))
else:
fenetre.blit(persog, ((perso_x, perso_y)))
py.display.flip()
fenetre = py.display.set_mode((693, 623))
thefloor = py.image.load("floor_is.jpg").convert()
fenetre.blit(thefloor, (0, 0))
py.mixer.init() #initialisation de la musique
py.mixer.music.load("grrr.wav")
py.mixer.music.play()
py.display.flip()
time.sleep(4)
test.main()
def 輸入檔案並測驗():
filename = tkFileDialog.askopenfilename()
print(filename)
狀況欄["text"]= "我覺得這是" + test.main(filename)
self.tok('0', [(0,1,'<NUM>','0')])
self.tok('0.', [(0,1,'<NUM>','0')])
self.tok('-1', [(0,2,'<NUM>','-1')])
self.tok('+1', [(1,2,'<NUM>','1')])
self.tok('+12.', [(1,3,'<NUM>','12')])
self.tok('-12.', [(0,3,'<NUM>','-12')])
self.tok('+.1', [(1,3,'<NUM>','.1')])
self.tok('+.1.', [(1,3,'<NUM>','.1')])
self.tok('-.1', [(0,3,'<NUM>','-.1')])
self.tok('-.1.', [(0,3,'<NUM>','-.1')])
self.tok('-1.5abc', [(0,4,'<NUM>','-1.5'), (4,7,'<ALPHANUM>','abc')])
self.tok('-123.4567-abc', [(0,9,'<NUM>','-123.4567'), (10,13,'<ALPHANUM>','abc')])
### SUPPORT ###
def _nameOfTestFile():
# Can't naively use __file__ because it changes from 'test_analysis.py'
# to 'test_analysis.py[c|o]' upon bytecode compilation, and the bytecode
# file isn't suitable for [ASCII-oriented] tokenization.
return test_base.getFilenameOfThisPythonTestModule(__file__)
def _textOfTestFile():
return file(_nameOfTestFile(), 'rb').read()
if __name__ == '__main__':
import test
test.main(suite=getFullTestSuite(), createTestIndex=False)
def evaluate(sb, options):
state = EvalState()
phase_argv = ['--sandbox', sb.get_root()]
with ioutil.WorkingDir(sb.get_root()) as td:
with sb.lock('eval') as lock:
try:
try:
if not options.no_update:
with Phase(state, EvalPhase.UPDATE, lock) as phase:
state.err = update(sb, lock)
if not state.err:
with Phase(state, EvalPhase.BUILD, lock) as phase:
argv = get_build_phase_args(phase_argv, options)
state.err = build.main(argv)
if not state.err:
with Phase(state, EvalPhase.TEST, lock) as phase:
argv = get_test_phase_args(["test"], options)
state.err = test.main(argv)
if (not state.err
) and sb.get_sandboxtype().get_should_publish():
with Phase(state, EvalPhase.PUBLISH, lock) as phase:
state.err = publish.main(phase_argv)
except:
txt = traceback.format_exc()
print(txt)
# It is possible for us to get an exception as we try to enter
# a phase (including the first one). In such a case, we need
# to work extra hard to help the user understand what's wrong.
txt = txt.replace('\r',
'').replace('\n',
'; ').replace(',', ' ')
state.reason = 'exception in build process itself: ' + txt
if not state.timestamps:
state.timestamps.append(time.time())
state.phase = EvalPhase.UPDATE
finally:
if os.path.exists(os.path.join(sb.get_root(), 'notify.txt')):
if (not sb.get_sandboxtype().get_notify_on_success()) and (
not state.err):
os.remove('%snotify.txt' % sb.get_root())
else:
notify = open('%snotify.txt' % sb.get_root(), 'r')
emails = notify.read()
notify.close()
body = ''
if os.path.exists(
os.path.join(sb.get_root(), 'eval-log.txt')):
body = os.path.join(sb.get_root(), 'eval-log.txt')
os.remove('%snotify.txt' % sb.get_root())
bi = buildinfo.BuildInfo()
if state.err:
status = 'Failed'
else:
status = 'Succeeded'
subject = '%s build of %s on %s %s.' % (sb.get_variant(
), sb.get_top_component(), bi.host, status)
arguments = '--to %s --sender sadm --subject "%s" --host smtp.example.com --port 587' % (
emails, subject) # TODO KIM TO CONF
arguments += ' --username [email protected] --password password' # TODO KIM TO CONF
if body:
arguments += ' --body "%s"' % body
os.system('python %s/buildscripts/mailout.py %s' %
(sb.get_code_root(), arguments))
if not state.err:
state.reason = ''
if _should_report(sb, options):
report(sb, state)
else:
print('Skipping report phase.')
return state.err
np.random.seed(params['seed'])
random.seed(params['seed'])
lasagne.random.set_rng(np.random)
# save directory
w2v_filename = params['word2vec'].split('/')[-1].split(
'.')[0] if params['word2vec'] else 'None'
save_path = ('experiments/' + params['model'] + '/' +
params['dataset'].split('/')[0] +
'/reg%s' % params['regularizer'] + '%.3f' % params['lambda'] +
'_nhid%d' % params['nhidden'] + '_nlayers%d' % params['nlayers'] +
'_dropout%.1f' % params['dropout'] + '_%s' % w2v_filename +
'_chardim%d' % params['char_dim'] +
'_train%d' % params['train_emb'] +
'_subsample%d' % params['subsample'] +
'_seed%d' % params['seed'] + '_use-feat%d' % params['use_feat'] +
'_traincut%.1f' % params['train_cut'] +
'_gf%s' % params['gating_fn'] + '{}/'.format(NAME))
if not os.path.exists(save_path): os.makedirs(save_path)
# train
if params['mode'] < 2:
train.main(save_path, params)
# test
if params['mode'] == 0 or params['mode'] == 2:
test.main(save_path, params)
elif params['mode'] == 3:
test.main(save_path, params, mode='validation')
import os
from test import main
import numpy as np
import subprocess
mac_f1_list = []
mic_f1_list = []
NMI_list = []
ARI_list = []
os.environ['MKL_THREADING_LAYER'] = 'GNU'
seeds = [228, 7243, 3295, 4020, 8149, 4832, 741, 6538, 7850, 6391]
for i in seeds:
p = subprocess.Popen("python main.py --seed {}".format(i), shell=True)
p.wait()
p.kill()
macro_f1_mean, micro_f1_mean, NMI, ARI = main()
mac_f1_list.append(macro_f1_mean)
mic_f1_list.append(micro_f1_mean)
NMI_list.append(NMI)
ARI_list.append(ARI)
print(
'\n************************** Average results *******************************'
)
print('Macro-F1: {:.4f}, {:.4f}, {:.4f}, {:.4f}'.format(
*np.mean(np.array(mac_f1_list), axis=0).tolist()))
print('Micro-F1: {:.4f}, {:.4f}, {:.4f}, {:.4f}'.format(
*np.mean(np.array(mic_f1_list), axis=0).tolist()))
print('NMI: {:.4f}, ARI: {:.4f}'.format(np.mean(NMI_list), np.mean(ARI_list)))
an appropriate version of Cython installed.
""" + branch_link) % {
"branch_version": versioninfo.branch_version()
}) + versioninfo.changes()),
classifiers=[
versioninfo.dev_status(), 'Intended Audience :: Developers',
'Intended Audience :: Information Technology',
'License :: OSI Approved :: BSD License',
'Programming Language :: Cython',
'Programming Language :: Python :: 2',
'Programming Language :: Python :: 2.4',
'Programming Language :: Python :: 2.5',
'Programming Language :: Python :: 2.6',
'Programming Language :: Python :: 2.7',
'Programming Language :: Python :: 3',
'Programming Language :: Python :: 3.1',
'Programming Language :: Python :: 3.2',
'Programming Language :: Python :: 3.3', 'Programming Language :: C',
'Operating System :: OS Independent',
'Topic :: Text Processing :: Markup :: HTML',
'Topic :: Text Processing :: Markup :: XML',
'Topic :: Software Development :: Libraries :: Python Modules'
],
**setup_extra_options())
if OPTION_RUN_TESTS:
print("Running tests.")
import test
sys.exit(test.main(sys.argv[:1]))
def test_overall(self):
""" Test via test frameworks.
"""
import bfs1
import bfs2
import bfserr
import test
self.assertEqual([], test.main(''))
self.assertEqual([], test.main('-v'))
self.assertEqual([], test.main('-e edgelist.txt'))
self.assertEqual([], test.main('-e edgelist.txt -v'))
self.assertEqual([], test.main('-d 5 -m 7'))
self.assertEqual([], test.main('-d 5 -m 7 -v'))
self.assertEqual([], test.main('-r 1 -n 8000 -f 0.001'))
self.assertEqual([], test.main('-r 1 -n 8000 -f 0.001 -v'))
self.assertEqual([], test.main('-r 1 -n 1000 -f 0.001'))
self.assertNotEqual([], test.test('', example_err=True))
self.assertNotEqual([], test.test('-e edgelist.txt', file_err=True))
self.assertEqual([], test.test('', tree_err=True)) # it doesn't test
self.assertNotEqual([], test.test('-r 1', ran_err=True))
self.assertRaisesRegexp(SystemExit, '0',
test.main, '-h')
self.assertRaisesRegexp(SystemExit, str(test.invalid_input_exit_code),
test.main, '--invalid_option')
self.assertRaisesRegexp(SystemExit, str(test.invalid_input_exit_code),
test.main, '-d a')
self.assertRaisesRegexp(SystemExit, str(test.invalid_input_exit_code),
test.main, '-d -1')
self.assertRaisesRegexp(SystemExit, str(test.invalid_input_exit_code),
test.main, '-m a')
self.assertRaisesRegexp(SystemExit, str(test.invalid_input_exit_code),
test.main, '-m -1')
self.assertRaisesRegexp(SystemExit, str(test.invalid_input_exit_code),
test.main, '-r a')
self.assertRaisesRegexp(SystemExit, str(test.invalid_input_exit_code),
test.main, '-n a')
self.assertRaisesRegexp(SystemExit, str(test.invalid_input_exit_code),
test.main, '-n -1')
self.assertRaisesRegexp(SystemExit, str(test.invalid_input_exit_code),
test.main, '-f a')
self.assertRaisesRegexp(SystemExit, str(test.invalid_input_exit_code),
test.main, '-f -1')
self.assertEqual((0, [1]), bfs1.bfs1(1, 1, dict()))
self.assertEqual((0, [1]), bfs2.bfs2(1, 1, dict()))
self.assertIsNone(bfserr.bfserr_none(1, 1, dict()))
self.assertNotEqual(0, bfserr.bfserr_len(1, 1, dict())[0])
self.assertEqual(0, bfserr.bfserr_len(0, 1, dict())[0])
self.assertNotEqual([1], bfserr.bfserr_node(1, 1, dict())[1])
self.assertIsNone(bfs1.bfs1(0, 1, dict()))
self.assertIsNone(bfserr.bfserr_none(0, 1, dict()))
self.assertIsNone(bfserr.bfserr_node(0, 1, dict()))
self.assertEqual((1, 0, [], 'el_arr'),
test.bfs_input_helper(True, 3, 4, [], 'el', [],
{4:0, 3:1}))
self.assertIsNone(test.bfs_output_helper(True, None, dict()))
self.assertEqual((1, [3, 4]), test.bfs_output_helper(True,
(1, [1, 0]),
{0:4, 1:3}))
self.assertNotEqual([], test.test_example([], [], [], False, True))
with open(f_name, 'w') as f:
json.dump(config, f)
# generate_experiments()
with open("results.out", 'w') as out:
sys.stdout = out
if single_model:
configs = [""]
else:
configs = os.listdir(path_to_experiment_configs)
full_results = pd.DataFrame()
for i in range(repetitions):
for f in configs:
print(f)
if not single_model:
copyfile(os.path.join(path_to_experiment_configs, f),
"config.json")
environments, scores = test.main(algorithm)
df = pd.DataFrame(scores)
df['config'] = f
df['env'] = environments
df['rep'] = i
df['mean'] = np.mean(scores, axis=1)
df['std'] = np.std(scores, axis=1)
full_results = full_results.append(df)
full_results.to_csv(f'full_results_{algorithm.algorithm}.csv', index=False)
i = 0
while i < len(s):
for k in KEEP:
if s[i:i+len(k)] == k:
r += k
i += len(k)
break
else:
if not s[i].isspace():
r += s[i]
i += 1
print(r)
with open("maska-min.cpp", "w") as file:
file.write(r)
print("= Compiling =")
compile_ok = 0 == system("g++ -O2 -pedantic -Wextra -Wall -std=c++98 -c maska-min.cpp -o maska-min.o")
if compile_ok:
compile_ok = 0 == system("g++ -O2 -pedantic -Wextra -Wall -std=c++98 -o maska-min.exe maska-min.o")
if compile_ok:
print("= Testing =")
test_ok = test.main("maska-min.exe", False)
else:
test_ok = None
if compile_ok and test_ok:
print("Success!")
print(f"Length: {len(r)}")
else:
print("Failure.")
print(f"Compilation OK: {compile_ok}\nTests OK: {test_ok}")
system("pause")
# --------------------------------------------------------
# Deformable Convolutional Networks
# Copyright (c) 2017 Microsoft
# Licensed under The Apache-2.0 License [see LICENSE for details]
# Written by Yuwen Xiong
# --------------------------------------------------------
import os
import sys
os.environ['PYTHONUNBUFFERED'] = '1'
os.environ['MXNET_CUDNN_AUTOTUNE_DEFAULT'] = '0'
os.environ['MXNET_ENABLE_GPU_P2P'] = '0'
this_dir = os.path.dirname(__file__)
sys.path.insert(0, os.path.join(this_dir, '..', '..', 'rfcn'))
import train_rfcn
import test
if __name__ == "__main__":
train_rfcn.main()
test.main()
def post(self, request):
tmp = json.dumps(test.main(request.POST.get('url')))
return HttpResponse(tmp)
def run(self):
self.run_command('build')
import test
test.main()
def main():
usage = "Usage: vcfPytools.py [tool] [options]\n\n" + \
"Available tools:\n" + \
" annotate:\n\tAnnotate the vcf file with membership in other vcf files.\n" + \
" extract:\n\tExtract vcf records from a region.\n" + \
" filter:\n\tFilter the vcf file.\n" + \
" indel:\n\tIndel manipulation tools.\n" + \
" intersect:\n\tGenerate the intersection of two vcf files.\n" + \
" merge:\n\tMerge a list of vcf files.\n" + \
" multi:\n\tFind the intersections and unique fractions of multiple vcf files.\n" + \
" sort:\n\tSort a vcf file.\n" + \
" stats:\n\tGenerate statistics from a vcf file.\n" + \
" union:\n\tGenerate the union of two vcf files.\n" + \
" unique:\n\tGenerate the unique fraction from two vcf files.\n" + \
" validate:\n\tValidate the input vcf file.\n\n" + \
"vcfPytools.py [tool] --help for information on a specific tool."
# Determine the requested tool.
if len(sys.argv) > 1:
tool = sys.argv[1]
else:
print >> sys.stderr, usage
exit(1)
if tool == "annotate":
import annotate
success = annotate.main()
elif tool == "extract":
import extract
success = extract.main()
elif tool == "filter":
import filter
success = filter.main()
elif tool == "intersect":
import intersect
success = intersect.main()
elif tool == "indel":
import indel
success = indel.main()
elif tool == "multi":
import multi
success = multi.main()
elif tool == "merge":
import merge
success = merge.main()
elif tool == "sort":
import sort
success = sort.main()
elif tool == "stats":
import stats
success = stats.main()
elif tool == "union":
import union
success = union.main()
elif tool == "unique":
import unique
success = unique.main()
elif tool == "test":
import test
success = test.main()
elif tool == "validate":
import validate
success = validate.main()
elif tool == "--help" or tool == "-h" or tool == "?":
print >> sys.stderr, usage
else:
print >> sys.stderr, "Unknown tool: ",tool
print >> sys.stderr, "\n", usage
exit(1)
# If program completed properly, terminate.
if success == 0: exit(0)
