def panchaanga_json_comparer(city, date):
expected_content_path = os.path.join(
TEST_DATA_PATH, '%s-%s.json' % (city.name, date.get_date_str()))
panchaanga = daily.DailyPanchaanga(city=city, date=date)
timebudget.report(reset=True)
testing.json_compare(actual_object=panchaanga,
expected_content_path=expected_content_path)
return panchaanga
def test_timing(caplog):
# A separate function for convenient profiling.
# See data/timing_snapshot* for results/ progression.
caplog.set_level(logging.INFO)
city = City('Chennai', "13:05:24", "80:16:12", "Asia/Calcutta")
annual.get_panchaanga_for_civil_year(city=city,
year=2018,
allow_precomputed=False)
timebudget.report(reset=True)
def panchaanga_json_comparer(city,
year,
computation_system=ComputationSystem.TEST):
expected_content_path = os.path.join(TEST_DATA_PATH,
'%s-%d.json' % (city.name, year))
panchaanga = annual.get_panchaanga_for_civil_year(
city=city,
year=year,
computation_system=computation_system,
allow_precomputed=False)
timebudget.report(reset=True)
testing.json_compare(actual_object=panchaanga,
expected_content_path=expected_content_path)
def main():
logger.info("Logger is set - training start")
# set default gpu device id
torch.cuda.set_device(config.gpus[0])
# set seed
np.random.seed(config.seed)
torch.manual_seed(config.seed)
torch.cuda.manual_seed_all(config.seed)
torch.backends.cudnn.benchmark = True
# get data with meta info
input_size, input_channels, n_classes, train_data, valid_data = utils.get_data(
config.dataset, config.data_path, config.cutout_length, validation=True)
criterion = nn.CrossEntropyLoss().to(device)
use_aux = config.aux_weight > 0.
model = AugmentCNN(input_size, input_channels, config.init_channels, n_classes, config.layers,
use_aux, config.genotype)
model = nn.DataParallel(model, device_ids=config.gpus).to(device)
# model size
mb_params = utils.param_size(model)
logger.info("Model size = {:.3f} MB".format(mb_params))
# weights optimizer
optimizer = torch.optim.SGD(model.parameters(), config.lr, momentum=config.momentum,
weight_decay=config.weight_decay)
train_loader = torch.utils.data.DataLoader(train_data,
batch_size=config.batch_size,
shuffle=True,
num_workers=config.workers,
pin_memory=True)
valid_loader = torch.utils.data.DataLoader(valid_data,
batch_size=config.batch_size,
shuffle=False,
num_workers=config.workers,
pin_memory=True)
lr_scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, config.epochs)
best_top1 = 0.
# training loop
for epoch in range(config.epochs):
lr_scheduler.step()
drop_prob = config.drop_path_prob * epoch / config.epochs
model.module.drop_path_prob(drop_prob)
# training
train(train_loader, model, optimizer, criterion, epoch)
# validation
cur_step = (epoch+1) * len(train_loader)
top1 = validate(valid_loader, model, criterion, epoch, cur_step)
# save
if best_top1 < top1:
best_top1 = top1
is_best = True
else:
is_best = False
timebudget.report()
utils.save_checkpoint(model, config.path, is_best)
print("")
logger.info("Final best Prec@1 = {:.4%}".format(best_top1))
def main():
np.random.seed(args.seed)
cudnn.benchmark = True
cudnn.enabled = True
torch.manual_seed(args.seed)
# ================================================
total, used = os.popen(
'nvidia-smi --query-gpu=memory.total,memory.used --format=csv,nounits,noheader'
).read().split('\n')[args.gpu].split(',')
total = int(total)
used = int(used)
print('Total GPU mem:', total, 'used:', used)
# try:
# block_mem = 0.85 * (total - used)
# print(block_mem)
# x = torch.empty((256, 1024, int(block_mem))).cuda()
# del x
# except RuntimeError as err:
# print(err)
# block_mem = 0.8 * (total - used)
# print(block_mem)
# x = torch.empty((256, 1024, int(block_mem))).cuda()
# del x
#
#
# print('reuse mem now ...')
# ================================================
logging.info('GPU device = %d' % args.gpu)
logging.info("args = %s", args)
logging.info(f"seed = {args.seed}")
criterion = nn.CrossEntropyLoss().to(device)
model = Network(args.init_ch, 10, args.layers, criterion).to(device)
logging.info("Total param size = %f MB",
utils.count_parameters_in_MB(model))
# this is the optimizer to optimize
optimizer = optim.SGD(model.parameters(),
args.lr,
momentum=args.momentum,
weight_decay=args.wd)
train_transform, valid_transform = utils._data_transforms_cifar10(args)
train_data = dset.CIFAR10(root=args.data,
train=True,
download=True,
transform=train_transform)
num_train = len(train_data) # 50000
indices = list(range(num_train))
split = int(np.floor(args.train_portion * num_train)) # 25000
train_queue = torch.utils.data.DataLoader(
train_data,
batch_size=args.batchsz,
sampler=torch.utils.data.sampler.SubsetRandomSampler(indices[:split]),
pin_memory=True,
num_workers=0 if 'pydevd' in sys.modules else 4)
valid_queue = torch.utils.data.DataLoader(
train_data,
batch_size=args.batchsz,
sampler=torch.utils.data.sampler.SubsetRandomSampler(indices[split:]),
pin_memory=True,
num_workers=0 if 'pydevd' in sys.modules else 4)
scheduler = optim.lr_scheduler.CosineAnnealingLR(optimizer,
float(args.epochs),
eta_min=args.lr_min)
arch = Arch(model, args)
lines = [f'epoch\ttrain_acc\tval_acc']
genotype = ''
for epoch in range(args.epochs):
scheduler.step()
lr = scheduler.get_lr()[0]
logging.info('\nEpoch: %d lr: %e', epoch, lr)
genotype = model.genotype()
logging.info('Genotype: %s', genotype)
# print(F.softmax(model.alphas_normal, dim=-1))
# print(F.softmax(model.alphas_reduce, dim=-1))
# training
train_acc, train_obj = train(train_queue, valid_queue, model, arch,
criterion, optimizer, lr)
logging.info('train acc: %f', train_acc)
# validation
valid_acc, valid_obj = infer(valid_queue, model, criterion)
logging.info('valid acc: %f', valid_acc)
lines.append(f'{epoch}\t{train_acc}\t{valid_acc}')
timebudget.report()
utils.save(model, os.path.join(args.exp_path, 'search.pt'))
pathlib.Path(os.path.join(args.exp_path,
'search.tsv')).write_text('\n'.join(lines))
pathlib.Path(os.path.join(args.exp_path,
'genotype.txt')).write_text(str(genotype))
def main():
logger.info("Logger is set - training start")
# set default gpu device id
torch.cuda.set_device(config.gpus[0])
# set seed
np.random.seed(config.seed)
torch.manual_seed(config.seed)
torch.cuda.manual_seed_all(config.seed)
torch.backends.cudnn.benchmark = True
# get data with meta info
input_size, input_channels, n_classes, train_data = utils.get_data(
config.dataset, config.data_path, cutout_length=0, validation=False)
net_crit = nn.CrossEntropyLoss().to(device)
model = SearchCNNController(input_channels, config.init_channels, n_classes, config.layers,
net_crit, device_ids=config.gpus)
model = model.to(device)
# weights optimizer
w_optim = torch.optim.SGD(model.weights(), config.w_lr, momentum=config.w_momentum,
weight_decay=config.w_weight_decay)
# alphas optimizer
alpha_optim = torch.optim.Adam(model.alphas(), config.alpha_lr, betas=(0.5, 0.999),
weight_decay=config.alpha_weight_decay)
# split data to train/validation
n_train = len(train_data)
split = n_train // 2
indices = list(range(n_train))
train_sampler = torch.utils.data.sampler.SubsetRandomSampler(indices[:split])
valid_sampler = torch.utils.data.sampler.SubsetRandomSampler(indices[split:])
train_loader = torch.utils.data.DataLoader(train_data,
batch_size=config.batch_size,
sampler=train_sampler,
num_workers=config.workers,
pin_memory=True)
valid_loader = torch.utils.data.DataLoader(train_data,
batch_size=config.batch_size,
sampler=valid_sampler,
num_workers=config.workers,
pin_memory=True)
lr_scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(
w_optim, config.epochs, eta_min=config.w_lr_min)
architect = Architect(model, config.w_momentum, config.w_weight_decay)
# training loop
best_top1 = 0.
for epoch in range(config.epochs):
lr_scheduler.step()
lr = lr_scheduler.get_lr()[0]
model.print_alphas(logger)
# training
train(train_loader, valid_loader, model, architect, w_optim, alpha_optim, lr, epoch)
# validation
cur_step = (epoch+1) * len(train_loader)
top1 = validate(valid_loader, model, epoch, cur_step)
# log
# genotype
genotype = model.genotype()
logger.info("genotype = {}".format(genotype))
# genotype as a image
# plot_path = os.path.join(config.plot_path, "EP{:02d}".format(epoch+1))
# caption = "Epoch {}".format(epoch+1)
# plot(genotype.normal, plot_path + "-normal", caption)
# plot(genotype.reduce, plot_path + "-reduce", caption)
# save
if best_top1 < top1:
best_top1 = top1
best_genotype = genotype
is_best = True
else:
is_best = False
#utils.save_checkpoint(model, config.path, is_best)
print("")
timebudget.report()
logger.info("Final best Prec@1 = {:.4%}".format(best_top1))
logger.info("Best Genotype = {}".format(best_genotype))
def main():
np.random.seed(args.seed)
torch.cuda.set_device(args.gpu)
cudnn.benchmark = True
cudnn.enabled = True
torch.manual_seed(args.seed)
logging.info('gpu device = %d' % args.gpu)
logging.info("args = %s", args)
if not args.arch:
geno_s = pathlib.Path(geno_path).read_text()
else:
geno_s = "genotypes.%s" % args.arch
genotype = eval(geno_s)
model = Network(args.init_ch, 10, args.layers, args.auxiliary, genotype).cuda()
logging.info(f"seed = {args.seed}")
logging.info(f"geno_s = {geno_s}")
logging.info("param size = %fMB", utils.count_parameters_in_MB(model))
criterion = nn.CrossEntropyLoss().cuda()
optimizer = torch.optim.SGD(
model.parameters(),
args.lr,
momentum=args.momentum,
weight_decay=args.wd
)
train_transform, valid_transform = utils._data_transforms_cifar10(args)
train_data = dset.CIFAR10(root=args.data, train=True, download=True, transform=train_transform)
valid_data = dset.CIFAR10(root=args.data, train=False, download=True, transform=valid_transform)
train_queue = torch.utils.data.DataLoader(
train_data, batch_size=args.batchsz, shuffle=True, pin_memory=True, num_workers=0 if 'pydevd' in sys.modules else 2)
valid_queue = torch.utils.data.DataLoader(
valid_data, batch_size=args.batchsz, shuffle=False, pin_memory=True, num_workers=0 if 'pydevd' in sys.modules else 2)
scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, float(args.epochs))
lines = [f'epoch\ttrain_acc\tval_acc']
for epoch in range(args.epochs):
scheduler.step()
logging.info('epoch %d lr %e', epoch, scheduler.get_lr()[0])
model.drop_path_prob = args.drop_path_prob * epoch / args.epochs
train_acc, train_obj = train(train_queue, model, criterion, optimizer)
logging.info('train_acc: %f', train_acc)
valid_acc, valid_obj = infer(valid_queue, model, criterion)
logging.info('valid_acc: %f', valid_acc)
lines.append(f'{epoch}\t{train_acc}\t{valid_acc}')
timebudget.report()
utils.save(model, os.path.join(args.save, 'trained.pt'))
print('saved to: trained.pt')
pathlib.Path(os.path.join(args.exp_path, 'eval.tsv')).write_text('\n'.join(lines))
def local_spooky(no_full_screen: bool,
camera_resolution: str = '640x480',
**kwargs):
timebudget.set_quiet() # just print reports.
if not no_full_screen:
for _ in range(10):
print("Will run full screen. Press SPACEBAR key to exit...\n\n")
time.sleep(0.05)
spookifier = spooky.RoundRobinSpookifier(**kwargs)
try:
camera = cv2.VideoCapture(0)
camera.set(cv2.CAP_PROP_FPS, 15)
cam_width, cam_height = [
int(hw) for hw in camera_resolution.split('x')
]
camera.set(cv2.CAP_PROP_FRAME_WIDTH, cam_width)
camera.set(cv2.CAP_PROP_FRAME_HEIGHT, cam_height)
start_time = time.time()
frame_cnt = 0
recent_fps_time = None
show_perf = True
if no_full_screen:
display = cv2.namedWindow("Spooky")
else:
display = cv2.namedWindow("Spooky", cv2.WND_PROP_FULLSCREEN)
cv2.setWindowProperty("Spooky", cv2.WND_PROP_FULLSCREEN,
cv2.WINDOW_FULLSCREEN)
while True:
frame_cnt += 1
total_fps = frame_cnt / (time.time() - start_time)
if (frame_cnt % 3 == 0) and (show_perf):
if recent_fps_time:
current_fps = 3 / (time.time() - recent_fps_time)
else:
current_fps = float("nan")
recent_fps_time = time.time()
clear_screen()
print(
f"------------ At frame {frame_cnt} getting {current_fps:.1f}fps. Avg is {total_fps:.2f}fps"
)
timebudget.report('process_npimage', reset=True)
status_code, img = camera.read()
print(f"Captured image of shape {img.shape}")
img = spookifier.process_npimage(img, None)
flipped = flip_img(img)
cv2.imshow('Spooky', flipped)
key = cv2.waitKey(1)
if key == ord('e') or key == ord('E'): # E = embedding capture
e = spookifier.get_target_embedding()
with open("embeddings.txt", "at") as f:
f.write(str(e))
f.write("\n")
print("Recorded embedding")
elif key == ord('d') or key == ord('D'): # D = debug
current_time = time.time()
import pdb
pdb.set_trace()
elif key == ord('p') or key == ord('P'): # P = perf data
show_perf = not show_perf
elif key == 32 or key == ord('Q') or key == ord('q'):
print(f"Quitting")
return
elif key >= 0:
print(f"Key #{key} pressed. No action for this key.")
finally:
del (camera)
from timebudget import timebudget
@timebudget
def possibly_slow():
print('slow', end=' ', flush=True)
time.sleep(0.06)
@timebudget
def should_be_fast():
print('quick', end=' ', flush=True)
time.sleep(0.03)
@timebudget
def outer_loop():
possibly_slow()
possibly_slow()
should_be_fast()
should_be_fast()
possibly_slow()
time.sleep(0.2)
print("dance!")
for n in range(7):
outer_loop()
timebudget.report('outer_loop')
with timebudget("drawing"):
altitude_overlay.draw(frame.image)
location_overlay.draw(frame.image)
#cv2.putText(frame.image, format_timedelta(mission_time),(50,600),cv2.FONT_HERSHEY_COMPLEX_SMALL,4,(225,255,255))
if (args.live_view == True):
if (cv2.waitKey(25) & 0xFF == ord('q')):
break
with timebudget("Showing frame"):
cv2.imshow("Output Video", frame.image)
if output is not None:
with timebudget("Writing frame"):
output.write(frame.image)
progress_bar.update(int(frame.position_ms))
# When everything done, release the video capture object
if output is not None:
output.release()
# Closes all the frames
cv2.destroyAllWindows()
if __name__ == "__main__":
main()
timebudget.report('main')
import time
from timebudget import timebudget
with timebudget('load-file'):
readme = open('README.md', 'rt').read()
timebudget.report()