def run(args) : # pick out the action. if args['action'] == 'train': engine.train(args) else: engine.test(args)
def run(args): import engine # pick out the action. if args['action'] == 'train': engine.train(args) elif args['action'] == 'continue': engine.cont(args) else: engine.test(args)
def main(args): utils.init_distributed_mode(args) print(args) device = torch.device(args.device) # Data loading code print("Loading data") dataset_test, num_classes = get_dataset(args.dataset, 'test', args.root_path, args.use_channel) print("Creating data loaders") if args.distributed: sampler_test = torch.utils.data.distributed.DistributedSampler( dataset_test, shuffle=False) else: sampler_test = torch.utils.data.SequentialSampler(dataset_test) dataloader_test = torch.utils.data.DataLoader(dataset_test, batch_size=1, sampler=sampler_test, num_workers=args.workers) print("Creating model") # maskrcnn_resnet50_fpn model = maskrcnn_resnet50_fpn(num_classes=num_classes, pretrained=args.pretrained) # set iou between boxes for nms: 0.7 model.roi_heads.nms_thresh = 0.3 # set the max num of rois: 1000 model.roi_heads.detections_per_img = 1000 # default: 0.05, 0.5 model.roi_heads.score_thresh = 0.05 model.to(device) model_without_ddp = model if args.distributed: model = torch.nn.parallel.DistributedDataParallel( model, device_ids=[args.gpu]) model_without_ddp = model.module checkpoint = torch.load(args.resume, map_location='cpu') model_without_ddp.load_state_dict(checkpoint['model']) test(model, dataloader_test, device, is_vis=args.vis, draw_bbox=False, vis_dir=args.vis_dir)
def index(request): url = '' platforms = [] if 'url' in request.GET: form = SiteForm(data=request.GET) if form.is_valid(): platforms = engine.test(form.cleaned_data['url']) else: form = SiteForm() return render_to_response('index.html', {'form':form, 'platforms':platforms, 'media_root': settings.STATIC_ROOT }, context_instance=RequestContext(request))
def index(request): url = '' site = None if 'url' in request.GET: form = SiteForm(data=request.GET) if form.is_valid(): site = engine.test(form.cleaned_data['url'], 'force' in request.GET) else: form = SiteForm() return render_to_response('index.html', {'form':form, 'site':site, 'media_root': settings.STATIC_ROOT, 'next': request.get_full_path() }, context_instance=RequestContext(request))
optimizer = optim.SGD(params_cnn_fnn, lr=args.lr, momentum=0.6, weight_decay=0.0005) lr_scheduler = torch.optim.lr_scheduler.CyclicLR(optimizer, base_lr=1e-3, max_lr=6e-3) # lr_scheduler = CosineAnnealingLR(optimizer, 50, eta_min=1e-3, last_epoch=-1) model_save_path = args.save_final_model_path print("Start training") start_time = time.time() for epoch in range(args.epochs): print("Executing Epoch: " + str(epoch)) engine.train(model_cnn, model_fnn, optimizer, train_loader, device, epoch, save=model_save_path) lr_scheduler.step() if epoch % 10 == 0: print("Testing Epoch: " + str(epoch)) engine.test(model_cnn, model_fnn, test_loader, device, epoch) total_time = time.time() - start_time total_time_str = str(datetime.timedelta(seconds=int(total_time))) print('Training time {}'.format(total_time_str))
test([ [ 'get chain', 'You cannot get that.\n'], [ 'get egg', 'You cannot get that.\n' ], [ 'go west', '''You are in a beautiful garden - there is a well in front of you. There is a door going east from here. There is a gate going outside from here. You see a frog on the floor. You see a chain on the floor. '''], [ 'unlock gate', 'Unlock gate how?\n'], [ 'unlock gate with key', 'You don\'t have the key.\n'], [ 'get chain', 'You are now carrying the chain.\n'], [ 'drop bucket', 'You don\'t have the bucket.\n'], [ 'drop chain', 'You dropped the chain in the garden.\n'], [ 'get chain', 'You are now carrying the chain.\n'], [ 'go east', '''You are in the bedroom of a wizards house - there is a wizard snoring loudly on the bed. There is a door going west from here. There is a stairway going upstairs from here. You see a bucket on the floor. You see a bottle on the floor. '''], [ 'get bucket', 'You are now carrying the bucket.\n'], [ 'go upstairs', '''You are in the attic of the wizards house - there is a giant welding torch in the corner. There is a stairway going downstairs from here. '''], [ 'weld chain to bucket', 'The chain is now securely welded to the bucket.\n'], [ 'go downstairs', '''You are in the bedroom of a wizards house - there is a wizard snoring loudly on the bed. There is a door going west from here. There is a stairway going upstairs from here. You see a bottle on the floor. '''], [ 'go west', '''You are in a beautiful garden - there is a well in front of you. There is a door going east from here. There is a gate going outside from here. You see a frog on the floor. '''], [ 'dunk bucket in well', 'The bucket is now full of water.\n'], [ 'go east', '''You are in the bedroom of a wizards house - there is a wizard snoring loudly on the bed. There is a door going west from here. There is a stairway going upstairs from here. You see a bottle on the floor. '''], [ 'splash wizard with bucket', '''The wizard awakens from his slumber. He greets you warmly and drops a key. But he is confused why you woke him. What now? '''], [ 'splash wizard with bucket', 'You have already done that.\n' ], [ 'get key', 'You are now carrying the key.\n'], [ 'go west', '''You are in a beautiful garden - there is a well in front of you. There is a door going east from here. There is a gate going outside from here. You see a frog on the floor. '''], [ 'break gate', 'I don\'t know how to break gate.\n'], [ 'unlock gate', 'Unlock gate how?\n'], [ 'unlock gate with key', 'You unlock the gate! It\'s very dark outside...\n'], [ 'go outside', '''You are in the middle of the deep woods. only a few rays of sunlight reach the ground from here. The porch of the wizard\'s house is to your right. There is a gate going inside from here. You see a cake on the floor. '''], [ 'go', 'Go what?\n'], [ 'get cake', '''You are now carrying the cake. YES! CAKE! YOU WIN THE GAME 100000000 TIMES!!! ''']] )
EPOCHS = 10 BATCH_SIZE = 32 LR = 1e-3 MAX_LOSS = 9999 device = torch.device("cuda" if torch.cuda.is_available() else "cpu") transform = transforms.Compose( [transforms.ToTensor(), transforms.Normalize((0.1307, ), (0.3081, ))]) train_set, test_set = dataset.create_dataset(transform) train_loader = torch.utils.data.DataLoader(train_set, batch_size=BATCH_SIZE, shuffle=True) test_loader = torch.utils.data.DataLoader(test_set, batch_size=BATCH_SIZE, shuffle=False) model = model.Net().to(device) optimizer = optim.Adam(model.parameters(), lr=LR) scheduler = StepLR(optimizer, step_size=1) for epoch in range(1, EPOCHS + 1): train_loss = engine.train(model, device, train_loader, optimizer, epoch) test_loss = engine.test(model, device, test_loader) scheduler.step() if test_loss < MAX_LOSS: torch.save(model.state_dict(), "mnist_cnn.pt")
device=DEVICE, batch_size=BATCH_SIZE ) if TEST: net = restore_net(PATH_TO_TEST_MODEL) net.eval() net.to(DEVICE) # after the training run function for train/val/test loader loader = test_loader ecgs, y_true, y_pred = test( net=net, test_loader=loader, device=DEVICE, batch_size=BATCH_SIZE, plot_ecg=False, plot_ecg_windows_size=WINDOWS_SIZE ) eval( ecgs=ecgs, y_true=y_true, y_pred=y_pred, labels=[0, 1, 2, 3, 4], target_names=['none', 'p_wave', 'qrs', 't_wave', 'extrasystole'], plot_acc=True, plot_loss=True, plot_conf_matrix=True, plot_ecg=True, plot_ecg_windows_size=WINDOWS_SIZE
def run(): Seed = 1234 random.seed(Seed) np.random.seed(Seed) torch.manual_seed(Seed) torch.cuda.manual_seed(Seed) torch.backends.cudnn.deterministic = True train, valid, test, SRC, TRG = dataset.create_dataset() train_iterator, valid_iterator, test_iterator = BucketIterator.splits( (train, valid, test), sort_key=lambda x: len(x.source), batch_size=config.BATCH_SIZE, device=config.device) INPUT_DIM = len(SRC.vocab) OUTPUT_DIM = len(TRG.vocab) HID_DIM = 256 ENC_LAYERS = 3 DEC_LAYERS = 3 ENC_HEADS = 8 DEC_HEADS = 8 ENC_PF_DIM = 512 DEC_PF_DIM = 512 ENC_DROPOUT = 0.1 DEC_DROPOUT = 0.1 enc = model.Encoder(INPUT_DIM, HID_DIM, ENC_LAYERS, ENC_HEADS, ENC_PF_DIM, ENC_DROPOUT, config.device) dec = model.Decoder(OUTPUT_DIM, HID_DIM, DEC_LAYERS, DEC_HEADS, DEC_PF_DIM, DEC_DROPOUT, config.device) SRC_PAD_IDX = SRC.vocab.stoi[SRC.pad_token] TRG_PAD_IDX = TRG.vocab.stoi[TRG.pad_token] model_tr = model.Seq2Seq(enc, dec, SRC_PAD_IDX, TRG_PAD_IDX, config.device).to(config.device) def initialize_weights(m): if hasattr(m, 'weight') and m.weight.dim() > 1: nn.init.xavier_uniform_(m.weight.data) model_tr.apply(initialize_weights) optimizer = optim.Adam(model_tr.parameters(), lr=config.LEARNING_RATE) TRG_PAD_IDX = TRG.vocab.stoi[TRG.pad_token] criterion = nn.CrossEntropyLoss(ignore_index=TRG_PAD_IDX) def epoch_time(start_time, end_time): elapsed_time = end_time - start_time elapsed_mins = int(elapsed_time / 60) elapsed_secs = int(elapsed_time - (elapsed_mins * 60)) return elapsed_mins, elapsed_secs if (args.action == 'train'): best_valid_loss = float('inf') for epoch in tqdm(range(config.N_EPOCHS)): start_time = time.time() train_loss = config.train(model_tr, train_iterator, optimizer, criterion, config.CLIP) valid_loss = config.evaluate(model_tr, valid_iterator, criterion) end_time = time.time() epoch_mins, epoch_secs = epoch_time(start_time, end_time) if valid_loss < best_valid_loss: best_valid_loss = valid_loss torch.save(model_tr.state_dict(), 'model.bin') with open(config.RESULTS_SAVE_FILE, 'a') as f: print( f'Epoch: {epoch+1:02} | Time: {epoch_mins}m {epoch_secs}s', file=f) print( f'\tTrain Loss: {train_loss:.3f} | Train PPL: {math.exp(train_loss):7.3f}', file=f) print( f'\t Val. Loss: {valid_loss:.3f} | Val. PPL: {math.exp(valid_loss):7.3f}', file=f) elif (args.action == 'test'): model_tr.load_state_dict(torch.load('model.bin')) test_loss, t, o = engine.test(model_tr, test_iterator, criterion, TRG) metric_val = 0 for i in range(len(t)): metric_val = metric_val + metric_utils.compute_metric( o[i], 1.0, t[i]) print('Nl2Cmd Metric | ', metric_val / len(t)) print( f'| Test Loss: {test_loss:.3f} | Test PPL: {math.exp(test_loss):7.3f} |' ) elif (args.action == 'save_vocab'): print('Source Vocab Length', len(SRC.vocab)) print('Target vocab length', len(TRG.vocab)) s1 = '\n'.join(k for k in SRC.vocab.itos) s2 = '\n'.join(k for k in TRG.vocab.itos) with open('NL_vocabulary.txt', 'w') as f: f.write(s1) with open('Bash_vocabulary.txt', 'w') as f: f.write(s2)
def _train(num_epochs, resume, net, device, directory, trainloader, testloader): writer = SummaryWriter() net = net.to(device) if device == 'cuda': net = torch.nn.DataParallel(net) cudnn.benchmark = True criterion = torch.nn.CrossEntropyLoss() optimizer = optim.SGD(net.parameters(), lr=0.1, momentum=0.9, weight_decay=1e-3) # usual 5e-4 # load from checkpoint if resume: print('==> Resuming from checkpoint...') checkpoint = torch.load(f'{directory}/last_ckpt.pth') net.load_state_dict(checkpoint['net']) optimizer.load_state_dict(checkpoint['optim']) start_epoch = checkpoint['epoch'] + 1 best_acc = torch.load(f'{directory}/best_ckpt.pth')['acc'] scheduler = torch.optim.lr_scheduler.MultiStepLR( optimizer, milestones=[60, 70, 75, 80, 85, 95], gamma=0.1, verbose=True, last_epoch=checkpoint['epoch']) # create history file else: best_acc = 0 start_epoch = 0 scheduler = torch.optim.lr_scheduler.MultiStepLR( optimizer, milestones=[60, 80, 100, 150], gamma=0.1, verbose=True) with open(f"{directory}/history.txt", "w") as f: f.write("epoch,train_loss,train_acc,test_loss,test_acc\n") # loop through number of epochs for epoch in range(start_epoch, num_epochs): train_loss, train_acc = train_one_epoch(net, optimizer, criterion, trainloader, epoch, device) test_loss, test_acc = test(net, criterion, testloader, device) # save losses and accuracies into txt file with open(f"{directory}/history.txt", "a") as f: f.write( f"{epoch},{train_loss:.4f},{train_acc:.4f},{test_loss:.4f},{test_acc:.4f}\n" ) # save checkpoint state = { 'net': net.state_dict(), 'acc': test_acc, 'epoch': epoch, 'optim': optimizer.state_dict() } torch.save(state, f'{directory}/last_ckpt.pth') if test_acc > best_acc: torch.save(state, f'{directory}/best_ckpt.pth') best_acc = test_acc scheduler.step() writer.add_scalar('train/loss', train_loss, epoch) writer.add_scalar('test/loss', test_loss, epoch) writer.add_scalar('train/acc', train_acc, epoch) writer.add_scalar('test/acc', test_acc, epoch) writer.close()
import torch import torch.backends.cudnn as cudnn from model import ResNet50 from datasets import BinaryDatasets, MultiwaySubDatasets, MultiwayDatasets from engine import test _, testloader = BinaryDatasets(['cat']) # _, testloader = BinaryDatasets(['bird'], ['cat', 'deer', 'dog', 'frog', 'horse']) # # _, testloader = MultiwaySubDatasets(['airplane', 'automobile', 'ship', 'truck']) net = ResNet50(2) net.to("cuda") net = torch.nn.DataParallel(net) cudnn.benchmark = True net.eval() for class_ in cfg.CLASSES_TO_RUN: ckpt = torch.load(f"checkpoints/10way/{class_}/last_ckpt.pth") net.load_state_dict(ckpt['net']) criterion = torch.nn.CrossEntropyLoss() # neg = cfg.CLASSES_TO_RUN.copy() # neg.remove(class_) # _, testloader = BinaryDatasets([class_], neg) test_loss, acc = test(net, criterion, testloader, "cuda") print(f"{acc:.4f}")
lsepLoss = losses.LSEPLoss() rankingLoss = torch.nn.MarginRankingLoss(margin=args.margin) criterion = [ mseLoss, bceLoss, rankingLoss, tripletLoss, warpLoss, lsepLoss, ceLoss ] # optimizer = torch.optim.SGD(model.parameters(), lr=args.lr, momentum=args.momentum) optimizer = torch.optim.Adam(filter(lambda p: p.requires_grad, model.parameters()), lr=args.lr, amsgrad=True) bestAcc = 0 for epoch in range(startEpoch, args.epochs + 1): engine.train(trainLoader, model, criterion, optimizer, epoch, plotter, writer, args.log, classCount, args.consiW, args.alignW, args.visEncW, args.labEncW, args.rankW, device, args.topK, args.theta) acc = engine.test(testLoader, model, criterion, epoch, plotter, writer, classCount, args.consiW, args.alignW, args.visEncW, args.labEncW, args.rankW, device, args.topK, args.theta) # remember best acc and save checkpoint is_best = acc > bestAcc bestAcc = max(acc, bestAcc) utils.save_checkpoint( { 'epoch': epoch + 1, 'stateDict': model.state_dict(), 'perfMetric': bestAcc, }, is_best, args.name)
from ui import cursesUI, pygameUI, terminalUI import argparse import sys import logging logger = logging.getLogger(__name__) parser = argparse.ArgumentParser() parser.add_argument('--ui', help="Choose the output UI", type=str, choices=['terminal', 'curses', 'pygame'], default="curses") parser.add_argument('--test', type=str, choices=['engine']) if __name__ == '__main__': logging.basicConfig( filename="Hoplite.log", format="%(module)s:%(lineno)d %(levelname)s %(message)s", level="DEBUG") results = parser.parse_args(sys.argv[1:]) if results.ui == 'curses': cursesUI() elif results.test == "engine": import engine engine.test()