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()