def __init__(self): self.device = torch.device( 'cuda' if torch.cuda.is_available() else 'cpu') self.use_cuda = torch.cuda.is_available() self.net = model.Net().cuda() if self.use_cuda else model.Net() self.optimizer = None self.train_accuracies = [] self.test_accuracies = [] self.start_epoch = 1
def build_net(self): '''build network based on arguments input''' self.net = model.Net(self.state_size, self.hidden_size, self.action_size, \ self.n_layers, output_activation=self.output_activation, discrete=self.discrete) self.net_optimizer = optim.Adam(self.net.parameters(), lr=self.lr) if self.nn_baseline: self.critic = model.Net(self.state_size, self.hidden_size, 1, self.n_layers, \ output_activation=None, discrete=self.discrete) self.base_optimizer = optim.Adam(self.critic.parameters(), lr=self.lr)
def index(request): if request.method == "POST": # Write the binary string representing the image to a file, # and use PIL's from-file image loader to make the PIL image "img" variable. # Transform to a tensor to pass into the model. with open("image_temp", "wb") as f: f.write(request.body) with open("image_temp", "rb") as f: img = Image.open(f) image_tensor = transforms.ToTensor()(img) os.remove("image_temp") # Loading the trained model PATH = os.path.join(os.getcwd(), '..', 'backend/wildlifeTrainer/wild_net.pth') net = model.Net() net.load_state_dict(torch.load(PATH)) # Transform the input and retrieve model prediction transform = transforms.Compose( [transforms.Resize(size=(96, 96)), transforms.ToTensor()]) input_img = torch.unsqueeze(transform(img), 0) probabilities = torch.nn.Softmax(dim=1)(net(input_img)) # Return the probabilities in Python list form (converted to a JS array in the HTTP response) return JsonResponse({ 'data': getTopFiveProbabilities( zipProbabilityAndClassNames( torch.squeeze(probabilities).tolist(), model.getClassNames())) }) else: return HttpResponse()
def main(): dataset_name = 'vqa1' target_name = os.path.join('logs', '{}_test.pth'.format(dataset_name)) print('will save to {}'.format(target_name)) cudnn.benchmark = True test_loader = data.get_loader(test=True) checkpoint = torch.load('logs/2017-08-04_00:55:19.pth') tokens = len(checkpoint['vocab']['question']) + 1 net = torch.nn.DataParallel(model.Net(tokens)) net.load_state_dict(checkpoint['weights']) optimizer = optim.Adam([p for p in net.parameters() if p.requires_grad]) tracker = [] tracker.load_state_dict(checkpoint['tracker']) config.load_state_dict(checkpoint['config']) t = run_test(net, test_loader, optimizer, tracker, prefix='test', epoch=1) results = { 'name': dataset_name, 'tracker': tracker.to_dict(), 'weights': net.state_dict(), 'eval': { 'answers': t[0], 'accuracies': t[1], 'idx': t[2],
def train(args): kwargs = {'num_workers': 2, 'pin_memory': True} if args.cuda else {} train_loader = data.DataLoader( datasets.MNIST('./data', train=True, download=True, transform=transforms.ToTensor()), batch_size=args.batch_size, shuffle=True, **kwargs) test_loader = data.DataLoader( datasets.MNIST('./data', train=False, transform=transforms.ToTensor()), batch_size=args.test_batch_size, shuffle=True, **kwargs) if args.binary == 'connect': net = model.BinaryConnect(args.in_features, args.out_features) elif args.binary == 'bnn': net = model.BinaryNet(args.in_features, args.out_features) elif args.binary == 'nn': net = model.Net(args.in_features, args.out_features) # net = nn.DataParallel(net) print(net) if args.cuda: net.cuda() if args.optimizer == 'Adam': optimizer = optim.Adam(net.parameters(), lr=args.lr) elif args.optimizer == 'LBFGS': if args.line_search_fn is None: optimizer = optim.LBFGS(net.parameters(), lr=args.lr) elif args.line_search_fn == 'strong_wolfe': optimizer = optim.LBFGS(net.parameters(), lr=args.lr, line_search_fn='strong_wolfe') criterion = nn.NLLLoss() for epoch in range(1, args.epochs+1): train_epoch(epoch, net, criterion, optimizer, train_loader, args) test_epoch(net, criterion, test_loader, args)
def test(): #model1 net = model.Net(num=10) #model2 #net = model.FinetuneNet(num=10) #如果用resnet152,就得将图像size设置成为224x224,用my_transform2 net.load_state_dict(torch.load('./checkpoints/dnn_model_00_0420.pkl')) batch_size = 20 test_data = tv.datasets.CIFAR10(root="./cifar/", train=False, download=True, transform=my_transform) test_dataloader = torch.utils.data.DataLoader(dataset=test_data, \ shuffle=True, \ batch_size=batch_size) dataiter = iter(test_dataloader) for i in range(10): imgs, labels = next(dataiter) y_head = net(imgs) y_head = y_head.data.max(1, keepdim=True)[1].view(batch_size) diff = y_head - labels #print y_head, labels, diff error_cnt = int(torch.nonzero(diff).shape[0]) right_rate = (batch_size - error_cnt) * 100.0 / batch_size print right_rate, "%"
def __init__(self, model_path, save_path, kernel, scale, conf, method_num, num_of_adaptation): methods = ['direct', 'direct', 'bicubic', 'direct'] self.save_results = True self.max_iters = num_of_adaptation self.display_iter = 1 self.upscale_method = 'cubic' self.noise_level = 0.0 self.back_projection = False self.back_projection_iters = 4 self.model_path = model_path self.save_path = save_path self.method_num = method_num self.ds_method = methods[self.method_num] self.kernel = kernel self.scale = scale self.scale_factors = [self.scale, self.scale] self.mse, self.mse_rec, self.interp_mse, self.interp_rec_mse, self.mse_steps = [], [], [], [], [] self.psnr = [] self.iter = 0 self.device = torch.device( "cuda" if torch.cuda.is_available() else "cpu") self.model = model.Net() self.learning_rate = 0.02 self.loss_fn = torch.nn.L1Loss() self.opt = torch.optim.SGD(self.model.parameters(), lr=self.learning_rate)
def testModel(): # Load the data _, testloader = model.getTrainAndTestLoaders() dataiter = iter(testloader) # Load our trained model PATH = 'wild_net.pth' net = model.Net() net.load_state_dict(torch.load(PATH)) ''' # Test some sample images images, labels = dataiter.next() outputs = net(images) print(outputs) _, predicted = torch.max(outputs, 1) print('Predicted: ', ' '.join('%5s' % model.getClassNames()[predicted[j]] for j in range(4))) ''' # Let's see how it tests on the whole data set correct = 0 total = 0 with torch.no_grad(): for data in testloader: images, labels = data outputs = net(images) _, predicted = torch.max(outputs.data, 1) total += labels.size(0) correct += (predicted == labels).sum().item() print( 'Accuracy of the network on the {0:.0f} test images: {1:.2f}%'.format( len(testloader), 100 * correct / total))
def __init__(self, trial, step, size, scale_list, meta_batch_size, meta_lr, meta_iter, task_batch_size, task_lr, task_iter, data_generator, checkpoint_dir): print('[*] Initialize Training') self.trial = trial self.step = step self.HEIGHT = size[0] self.WIDTH = size[1] self.CHANNEL = size[2] self.scale_list = scale_list self.META_BATCH_SIZE = meta_batch_size self.META_LR = meta_lr self.META_ITER = meta_iter self.TASK_BATCH_SIZE = task_batch_size self.TASK_LR = task_lr self.TASK_ITER = task_iter # self.data_generator=data_generator self.checkpoint_dir = checkpoint_dir self.device = torch.device( "cuda" if torch.cuda.is_available() else "cpu") '''model''' self.model = model.Net() checkpoint = torch.load(self.checkpoint_dir) self.model.load_state_dict(checkpoint) self.model = self.model.to(self.device) '''loss''' self.loss_fn = nn.L1Loss() '''Optimizers''' self.pretrain_op = optim.Adam(self.model.parameters(), lr=self.META_LR) self.opt = optim.Adam(self.model.parameters(), lr=self.META_LR)
def model_func(wrapped_import, inputs): if wrapped_import: model = wrapped_import("model") else: import model net = model.Net() net = net.eval() # disable dropout return net(inputs)
def main(): # Load the parameters from json file args = parser.parse_args() image_dir = args.image_dir label_dir = args.label_dir cp_dir = args.checkpoints_dir logging.basicConfig(filename='train.log', level=logging.INFO) logging.info('Started') json_path = os.path.join(args.model_dir, 'params.json') assert os.path.isfile(json_path), "No json configuration file found at {}".format(json_path) params = utils.Params(json_path) #split data train_image, train_label, dev_image, dev_label, test_image, test_label = data_split(image_dir, label_dir) #load data train_dataset = EMDataset(train_image, train_label) dev_dataset = EMDataset(dev_image, dev_label) test_dataset = EMDataset(test_image, test_label) train_dataloader = DataLoader(train_dataset, batch_size=params.batch_size, shuffle=True) dev_dataloader = DataLoader(dev_dataset, batch_size=params.batch_size, shuffle=True) test_dataloader = DataLoader(test_dataset, batch_size=params.batch_size, shuffle=True) #use GPU device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") net = model.Net(1,6) if torch.cuda.device_count() > 1: net = nn.DataParallel(net) net.to(device) # define loss class_weights = torch.FloatTensor(params.class_weights) criterion = nn.CrossEntropyLoss(weight=class_weights).cuda() #initialize optimiser optimizer = optim.Adam(net.parameters(), lr=params.learning_rate) #training and evaluate epoch_train_loss= [] epoch_test_loss = [] for epoch in range(params.num_epochs): net.train() logging.info('epoch'+ str(epoch+1)+' start!') f_train_acc = [[] for i in range(6)] f_test_acc = [[] for i in range(6)] train(net, train_dataloader, device, optimizer, criterion, epoch, epoch_train_loss,f_train_acc) logging.info('epoch' + str(epoch + 1) + ' train_loss: ' + str(epoch_train_loss)) logging.info('epoch' + str(epoch + 1) + ' train_acc: ' + str(f_train_acc)) #save model torch.save(net.state_dict(), os.path.join(cp_dir, 'cp{}.pth'.format(epoch + 1))) #evaluate the model on test set. test(net, test_dataloader, device, criterion, epoch, epoch_test_loss, f_test_acc) logging.info('epoch' + str(epoch + 1) + ' test_loss: ' + str(epoch_test_loss)) logging.info('epoch' + str(epoch + 1) + ' test_acc: ' + str(f_test_acc)) logging.info('epoch'+ str(epoch+1)+' end!')
def main(): if len(sys.argv) > 1: name = ' '.join(sys.argv[1:]) else: from datetime import datetime name = datetime.now().strftime("%Y-%m-%d_%H:%M:%S") target_name = os.path.join('logs', '{}.pth'.format(name)) print('will save to {}'.format(target_name)) cudnn.benchmark = True # train_loader = data.get_loader(config.train_path, train=True) test_loader = data.get_loader(config.test_path, test=True) cap_vcb = test_loader.dataset.token_to_index hash_vcb = test_loader.dataset.answer_to_index inv_hash_dict = {v: k for k, v in hash_vcb.items()} inv_cap_dict = {v: k for k, v in cap_vcb.items()} net = model.Net(test_loader.dataset.num_tokens[0], test_loader.dataset.num_tokens[1], [], []).to(device) # net = model.Net(train_loader.dataset.num_tokens[0],train_loader.dataset.num_tokens[1]).to(device) # optimizer = optim.Adam([p for p in net.parameters() if p.requires_grad]) # print(torch.load('logs/' + args.model_path)['weights']) net.load_state_dict(torch.load('logs/' + args.model_path)['weights']) tracker = utils.Tracker() # for k,v in vars(config).items(): # print(k) # sdfsd #BRING THIS BACK # criterion = nn.CrossEntropyLoss(ignore_index = PAD_IDX) criterion = nn.CrossEntropyLoss( ignore_index=test_loader.dataset.answer_to_index['<pad>']) config_as_dict = { k: v for k, v in vars(config).items() if not k.startswith('__') and not k.startswith('os') and not k.startswith('expanduser') and not k.startswith('platform') } r = run(net, test_loader, tracker, criterion, cap_vcb, hash_vcb, train=False, prefix='test', epoch=0) with open('output/hashtags.csv', 'w') as f: for key in r[0].keys(): f.write("%s,%s\n" % (key, r[0][key])) with open('output/captions.csv', 'w') as f: for key in r[1].keys(): f.write("%s,%s\n" % (key, r[1][key])) with open('output/predictions.csv', 'w') as f: for key in r[2].keys(): f.write("%s,%s\n" % (key, r[2][key]))
def main(objects, **kwargs): nets = [ model.Net(objects).cuda(), model.Baseline(objects).cuda(), ] loader = get_loader(objects, **kwargs) plins = run(nets, loader, 1000, train=True) accs = run(nets, loader, 200, train=False) return {'plins': plins, 'accs': accs}
def main(): if len(sys.argv) > 1: name = ' '.join(sys.argv[1:]) else: from datetime import datetime name = datetime.now().strftime("%Y-%m-%d_%H:%M:%S") target_name = os.path.join('logs', '{}.pth'.format(name)) print('will save to {}'.format(target_name)) cudnn.benchmark = True train_loader = data.get_loader(train=True) val_loader = data.get_loader(val=True) with open('embedding/word_embedding.p', "rb") as f: embedding_model = cPickle.load(f) net = model.Net(embedding_model).to(device) # net = model.Net(train_loader.dataset.num_tokens).to(device) net = nn.DataParallel(net) optimizer = optim.Adam([p for p in net.parameters() if p.requires_grad]) tracker = utils.Tracker() config_as_dict = { k: v for k, v in vars(config).items() if (not k.startswith('__')) and (type(v) is not ModuleType) } for i in range(config.epochs): _ = run(net, train_loader, optimizer, tracker, train=True, prefix='train', epoch=i) r = run(net, val_loader, optimizer, tracker, train=False, prefix='val', epoch=i) results = { 'name': name, 'tracker': tracker.to_dict(), 'config': config_as_dict, 'weights': net.state_dict(), 'eval': { 'answers': r[0], 'accuracies': r[1], 'idx': r[2], }, 'vocab': train_loader.dataset.vocab, } torch.save(results, target_name)
def main(): if len(sys.argv) > 1: # 外界获得的参数列表:['/home/users2/xcm09/VQA/train.py'] name = ' '.join(sys.argv[1:]) else: from datetime import datetime name = datetime.now().strftime("%Y-%m-%d_%H:%M:%S") target_name = os.path.join('logs', '{}.pth'.format(name)) print('模型 will save to {}'.format(target_name)) cudnn.benchmark = True train_loader = data.get_loader(train=True) val_loader = data.get_loader(val=True) net = model.Net(train_loader.dataset.num_tokens).cuda() # 15193 # net = nn.DataParallel(model.Net(train_loader.dataset.num_tokens), device_ids=config.device_ids).cuda() optimizer = optim.Adam([p for p in net.parameters() if p.requires_grad]) tracker = utils.Tracker() config_as_dict = { k: v for k, v in vars(config).items() if not k.startswith('__') } for i in range(config.epochs): a = time() _ = run(net, train_loader, optimizer, tracker, train=True, prefix='train', epoch=i) r = run(net, val_loader, optimizer, tracker, train=False, prefix='val', epoch=i) results = { 'name': name, 'tracker': tracker.to_dict(), 'config': config_as_dict, 'weights': net.state_dict(), 'eval': { 'answers': r[0], 'accuracies': r[1], 'idx': r[2], }, 'vocab': train_loader.dataset.vocab, } torch.save(results, target_name) b = time() - a print('该epoch耗时%d:%d' % (b // 60, b % 60))
def main(**hp): # add hyper parameters hp['drng'] = (-hp['drng'], hp['drng']) #hp['drng'] = (0, 12) hp['trng'] = 1.0 hp['views'] = 9 hp['pad'] = 12 hp['uncrt'] = True hp['rgw'] = 1.0 hp['rgl1'] = False hp['cll1'] = False hp['tri'] = False hp['mine'] = False dataset = hci4d.HCI4D(hp['dset'], nviews=(hp['views'], hp['views']), cache=False) dataloader = torch.utils.data.DataLoader(dataset, batch_size=1, shuffle=False, num_workers=1) # create output directory if not os.path.exists(hp['out']): os.makedirs(hp['out']) # 1st device for all parameters device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") # create net and load parameters net = model.Net(hp) dl_utils.load_model_params(net, hp['prms']) for p in net.parameters(): p.requires_grad = False net.eval() # parallelize for multiple gpus if hp['gpus'] > 1: net = torch.nn.DataParallel(net, list(range(hp['gpus']))) net.to(device) # loop over the dataset for j, data in enumerate(dataloader): print(f'Processing Scene {j}...') # process scene proc = process.Process(net, device, hp) disp, uncert, pred, loss, runtime = proc(data) # save results dataset.save_batch(hp['out'], data[-1], disp.cpu().numpy(), uncert.cpu().numpy(), runtime) return 0
def main(): if len(sys.argv) > 1: name = ' '.join(sys.argv[1:]) else: from datetime import datetime name = datetime.now().strftime("%Y-%m-%d_%H:%M:%S") target_name = os.path.join('logs', '{}.pth'.format(name)) model_name = os.path.join('logs', '{}_model.pth'.format(name)) print('will save to {}'.format(target_name)) cudnn.benchmark = True train_loader = data.get_loader(train=True) val_loader = data.get_loader(val=True) net = nn.DataParallel(model.Net(train_loader.dataset.num_tokens)).cuda() optimizer = optim.Adam([p for p in net.parameters() if p.requires_grad]) tracker = utils.Tracker() config_as_dict = {k: v for k, v in vars(config).items() if not k.startswith('__')} for i in range(config.epochs): _ = run(net, train_loader, optimizer, tracker, train=True, prefix='train', epoch=i) r = run(net, val_loader, optimizer, tracker, train=False, prefix='val', epoch=i) results = { 'name': name, 'epoch': i, 'tracker': tracker.to_dict(), 'config': config_as_dict, 'weights': net.state_dict(), 'eval': { 'answers': r[0], 'accuracies': r[1], 'idx': r[2], }, 'optimizer' : optimizer.state_dict(), 'vocab': train_loader.dataset.vocab, } torch.save(results, target_name) # save best model so far val_acc = torch.FloatTensor(tracker.to_dict()['val_acc']) val_acc = val_acc.mean(dim=1).numpy() is_best = True for j in range(len(val_acc) - 1): if val_acc[-1] <= val_acc[j]: is_best = False if is_best: save_model = { 'epoch': i, 'weights': net.state_dict() } torch.save(save_model, model_name)
def main(args): start_time = time.time() if args.edit_set: print('evaluating on edited VQA') else: print('evaluating original VQA') cudnn.benchmark = True output_qids_answers = [] if args.split == 'train2014': _, val_loader = data.get_loader(train=True) #val=True) ## data shuffled only in train elif args.split == 'val2014': _, val_loader = data.get_loader(val=True) elif args.split == 'test2015': _, val_loader = data.get_loader(test=True) #test_loader = data.get_loader(test=True) if args.model_type == 'no_attn': net = nn.DataParallel(model2.Net(val_loader.dataset.num_tokens)).cuda() model_path = os.path.join(config.model_path_no_attn) results_file = os.path.join(config.results_no_attn_pth) res_pkl = os.path.join(config.results_no_attn_pkl) MODEL_name = 'CNN_LSTM' elif args.model_type == 'with_attn': net = nn.DataParallel(model.Net(val_loader.dataset.num_tokens)).cuda() model_path = os.path.join(config.model_path_show_ask_attend_answer) results_file = os.path.join(config.results_with_attn_pth) res_pkl = os.path.join(config.results_with_attn_pkl) MODEL_name = 'SAAA' print('loading model from', model_path) net.load_state_dict(torch.load(model_path)["weights"]) ### so here you load the weights, essentially the model print(net) net.eval() r = run(net, val_loader, args.edit_set, MODEL_name) print('saving results to '+ res_pkl ) if args.edit_set: output_qids_answers += [ { 'ans_id': p.item(), 'img_id': id,'ques_id':qid.item(),'ss_vc': np.float16(softmax_vector.tolist())} #np.float32(softmax_vector).tolist() for p,id,qid, softmax_vector in zip(r[0],r[1], r[2], r[3])] else: output_qids_answers += [ { 'ans_id': p.item(), 'img_id': id.item(),'ques_id':qid.item(),'ss_vc': np.float16(softmax_vector.tolist())} for p,id,qid, softmax_vector in zip(r[0],r[1], r[2], r[3])] with open(res_pkl, 'wb') as f: pickle.dump(output_qids_answers,f, pickle.HIGHEST_PROTOCOL) print('saving pkl complete') print('time_taken:', time.time() - start_time)
def main(): path = 'logs/' files = [] file = '2020-02-05_00:29:21.pth' results = torch.load(f=path+file, map_location='cpu') train_loader = data.get_loader(train=True) test_loader = data.get_loader(test=True) net = model.Net(train_loader.dataset.num_tokens).cuda() net.load_state_dict(results['weights']) print(net)
def __init__(self, batch_size=64, download=True, epochs=10): self.net = model.Net() self.transform = transforms.Compose([ transforms.ToTensor(), transforms.Normalize((0.1307, ), (0.3081, )) ]) self.batch_size = batch_size self.download = download self.device = 'cpu' self.epochs = epochs self._create_loader() self._create_op()
def train(): learning_rate = 0.0001 net = model.Net() loss_fn = nn.L1Loss() optimizer = optim.Adam(net.parameters(), lr=learning_rate) '''data''' datapath = '' predataset = dataset.preTrainDataset(datapath) dataloader = DataLoder(predataset, batch_size=64, num_workers=1, shuffle=True, drop_last=True) device = torch.device("cuda" if torch.cuda.is_available() else "cpu") step = 0 with tqdm.tqdm(total=100000, miniters=1, mininterval=0) as progress: while True: for inputs in dataloader: net.train() hr, lr = inputs[-1][0], inputs[-1][1] hr = hr.to(device) lr = lr.to(device) out = net(lr) loss = loss_fn(hr, out) progress.set_description("Iteration: {iter} Loss: {loss}, Learning Rate: {lr}".format( \ iter=step, loss=loss.item(), lr=learning_rate)) progress.update() if step > 0 and step % 30000 == 0: learning_rate = learning_rate / 10 adjust_learning_rate(optimizer, new_lr=learning_rate) print("Learning rate reduced to {lr}".format( lr=learning_rate)) optimizer.zero_grad() loss.backward() nn.utils.clip_grad_norm_(net.parameters(), 10) optimizer.step() step += 1 if step > 100000: print('Done training.') break save_path = os.path.join('./checkpoint', 'Pretrain.pth') torch.save(net.state_dict(), save_path) print("Model is saved !")
def main(): path = sys.argv[1] test_loader = data.get_loader(test=True) log = torch.load(path) tokens = len(log['vocab']['question']) + 1 net = torch.nn.DataParallel(model.Net(tokens)).cuda() net.load_state_dict(log['weights']) r = run(net, test_loader) print('answers', r[0], 'accuracies', r[1], 'idx', r[2])
def main(): start_time = datetime.datetime.now() start_time_str = start_time.strftime("%Y-%m-%d_%H-%M-%S") progress_file = start_time_str + '_progress.csv' cudnn.benchmark = True train_loader = data.get_loader(train=True) val_loader = data.get_loader(val=True) net = nn.DataParallel(model.Net(train_loader.dataset.num_tokens)).cuda() optimizer = optim.Adam([p for p in net.parameters() if p.requires_grad]) tracker = utils.Tracker() config_as_dict = { k: v for k, v in vars(config).items() if not k.startswith('__') } train_loss_list = [] train_acc_list = [] val_loss_list = [] val_acc_list = [] max_acc = 0 for i in range(config.epochs): print('epoch %d' % i) print('train') train_loss, train_acc = run(net, train_loader, optimizer, tracker, train=True, prefix='train', epoch=i) print('validation') val_loss, val_acc = run(net, val_loader, optimizer, tracker, train=False, prefix='val', epoch=i) train_loss_list.append(train_loss) train_acc_list.append(train_acc) val_loss_list.append(val_loss) val_acc_list.append(val_acc) write_progress(train_acc_list, train_loss_list, val_acc_list, val_loss_list, progress_file) if val_acc > max_acc and val_acc > 0.45: print('model saved') torch.save(net.state_dict(), start_time_str + '_best_model.pkl') max_acc = val_acc
def train(): net = model.Net() weights_file = 'networks/network_7' # net.load_state_dict(torch.load('networks/network_7')) net.to(dtype=dtype, device=device) data = torch.load('../data/train.bin') val_data = torch.load('../data/validation.bin') epochs = 5 batch_size = 16 lr = 1e-5 alpha, beta = 0.9,0.99 regulirizer = 0.00001 optimizer = optim.SGD(net.parameters(), lr=lr)#, betas = (alpha,beta)) num_batches = 512 f= open(weights_file+".txt","w+") f.write("lr : "+str(lr)) f.write("\nbatch_size : "+str(batch_size)) f.write("\nalpha : "+str(alpha)) f.write("\nbeta : "+str(beta)) f.write("\nnum_batches : "+str(num_batches)) # training loop for epoch in range(epochs): t=time.time() for i in range(num_batches): input, target = readBatch(batch_size,data) optimizer.zero_grad() output = net(input) criterion = nn.MSELoss() l2_reg = 0 for param in net.parameters(): l2_reg += torch.norm(param) loss = criterion(output, target) + regulirizer * l2_reg if (i+1)%num_batches==0: t = time.time()-t print(epoch,loss) f.write("\nepoch "+str(epoch)) f.write("\n"+str(loss)) f.write("\ntime elapsed:"+str(t)) print("time elapsed:",t) t = time.time() loss.backward() # Does Backpropogation optimizer.step() # Does the update if((epoch+1)%1==0): for pp in optimizer.param_groups: pp['lr'] /= 4 torch.save(net.state_dict(), weights_file) print(list((net.parameters()))[-2]) f.close() torch.save(net.state_dict(), weights_file)
def main(): trainset, testset = dataloader.get_datasets() trainloader, testloader = dataloader.get_loader() net = model.Net() criterion = functions.get_criterion() optimizer = functions.get_optimizer(net, 0.001, 0.9) writer = set_tensorboard_writer('runs/fashion_mnist_experiment_2') show_image_tensorboard(writer, trainloader) show_model_tensorboard(writer, net, trainloader) show_projector_tensorboard(writer, trainset) train(trainloader, net, optimizer, criterion, writer) test(testloader, net, writer) close_tensorboard_writer(writer)
def populate_network(network, path): net=model.Net() #net.load_state_dict(torch.load(path)) dicts=torch.load(path) input_tensor = network.add_input(name=ModelData.INPUT_NAME, dtype=ModelData.DTYPE, shape=ModelData.INPUT_SHAPE) tensor=input_tensor dict={k: v for k, v in dicts.items()} list_keys=list(dict.keys()) print('all keys are',list_keys) for name,module in net.named_modules(): print('current layer is ',name) if isinstance(module,nn.Conv2d): w = module.weight.data.cpu().numpy() b=module.bias.data.cpu().numpy() shape=w.shape print(shape) if name in list_keys[0]: conv=network.add_convolution(input=input_tensor, num_output_maps=shape[0], kernel_shape=(shape[2], shape[3]), kernel=w,bias=b) else: conv = network.add_convolution(input=tensor.get_output(0), num_output_maps=shape[0], kernel_shape=(shape[2], shape[3]), kernel=w, bias=b) conv.stride = (1, 1) pool = network.add_pooling(input=conv.get_output(0), type=trt.PoolingType.MAX, window_size=(2, 2)) pool.stride = (2, 2) tensor=pool elif isinstance(module,nn.MaxPool2d): pool = network.add_pooling(input=tensor.get_output(0), type=trt.PoolingType.MAX, window_size=(2, 2)) pool.stride = (2, 2) pool.get_output(0).name = name tensor=pool elif isinstance(module,nn.Linear): w = module.weight.data.cpu().numpy() b = module.bias.data.cpu().numpy() shape = w.shape print(shape) ipt=tensor.get_output(0) fc = network.add_fully_connected(input=ipt, num_outputs=shape[0], kernel=w, bias=b) fc.get_output(0).name = name tensor=fc elif isinstance(module,nn.ReLU): relu= network.add_activation(input=tensor.get_output(0), type=trt.ActivationType.RELU) relu.get_output(0).name=name tensor=relu tensor.get_output(0).name = ModelData.OUTPUT_NAME network.mark_output(tensor=tensor.get_output(0))
def graph(self): self.left = tf.placeholder(tf.uint8) self.right = tf.placeholder(tf.uint8) self.gt = tf.placeholder(tf.string) limg = tf.expand_dims(tf.to_float(self.left)/255.0,0) rimg = tf.expand_dims(tf.to_float(self.right)/255.0,0) cv,lrl = lowrescv(limg,rimg) lrl = 2.0*lrl-1.0 limg = 2.0*limg-1.0 self.net = model.Net() dout = self.net.predict(limg,cv,lrl) self.dout = tf.squeeze(dout,0)
def prediction(img_bytes): tensor = transform_image(img_bytes) device = torch.device("cpu") m = model.Net() m.load_state_dict( torch.load("mnist_cnn.pt", map_location=torch.device('cpu'))) m.eval() with torch.no_grad(): tensor = tensor.to(device) outputs = m.forward(tensor) # print(outputs) y_hat = outputs.argmax(dim=1, keepdim=True) return y_hat.item()
def train(self, model, embedding_dim, lstm_hidden, fc_input, fc_hidden, epochs, lr, freeze=True, test_path=None): """ Train all the models in committee. :param model: Type of model, must be one of [bilstm/hybrid-cat/hybrid-add/cnn/bow]. :param embedding_dim: Length of reserved vocabulary, used to build embedding layer. :param lstm_hidden: Dimension of lstm hidden state, used to build bilstm model. :param fc_input: Dimension of input full connect layer. :param fc_hidden: Dimension of hidden full connect layer. :param epochs: How many epochs it trains. :param lr: Learning rate. :param freeze: Freezing embedding layer or not. if True, weight in embedding layer will not be changed during training. :param test_path: Test file path, use to validate the model after every epoch. """ self.model = model test_set = None loaders = [] criterion = [] optimizers = [] if test_path is not None: test_set = md.QuestionSet(test_path, self.vocabulary_path, self.labels_path, self.stop_words_path, self.pre_train_path, self.k) for i in range(0, len(self.subsets)): loaders.append(DataLoader(self.subsets[i])) net = md.Net(model, self.subsets[i].vocab_size(), embedding_dim, lstm_hidden, fc_input, fc_hidden, self.subsets[i].label_size(), pre_train_weight=self.subsets[i].get_pre_train_weight(), freeze=freeze) self.classifiers.append(net) criterion.append(torch.nn.CrossEntropyLoss()) optimizers.append(torch.optim.SGD(net.parameters(), lr=lr)) for e in range(0, epochs): for i in range(0, len(self.subsets)): for t, (cla, train) in enumerate(loaders[i]): if self.model == 'cnn': train = self.normalize(train) self.classifiers[i].train() optimizers[i].zero_grad() cla_pred = self.classifiers[i](train) loss = criterion[i](cla_pred, cla) loss.backward() optimizers[i].step() if test_set is not None: acc, acc_rate = self.test(test_set) print('ensemble: %d, model: %s, epoch: %d, stop_words: %s, pre_train_embedding: %s, k: %d, freeze: %s,' ' train_set: %s, test_set: %s, acc: %d, acc rate: %f' % (len(self.subsets), self.model, e + 1, self.stop_words_path, self.pre_train_path, self.k, freeze, self.data_path, test_path, acc, acc_rate))
def main(args): dataset = data.Dataset(args.data_dir) criterion = nn.CrossEntropyLoss() net = model.Net(data.VOCAB_SIZE) if os.path.isfile(args.model_filename): checkpoint = (torch.load(args.model_filename) if (torch.cuda.is_available()) else torch.load( filename, map_location=lambda storage, loc: storage)) net.load_state_dict(checkpoint['state_dict']) if (torch.cuda.is_available()): net.cuda() print('\nRunning test') epoch_end = False total_loss = [] test_step = 0 num_correct = 0 test_size = len(dataset.dataset['test']) while epoch_end == False: test_step += 1 minibatch, epoch_end = dataset.get_next_minibatch('test', 1) batch_tensor = Variable(minibatch[0]) labels_tensor = Variable(minibatch[1]) if (torch.cuda.is_available()): batch_tensor = batch_tensor.cuda() labels_tensor = labels_tensor.cuda() output = net.forward(batch_tensor) label_index = torch.max(labels_tensor, 1)[1] output_index = torch.max(output, 1)[1] num_correct += (label_index == output_index).sum().type( torch.LongTensor) loss = criterion(output, label_index) total_loss.append(loss.data) sys.stdout.write('Test step %i/%i\r' % (test_step, test_size)) sys.stdout.flush() total_loss = float(sum(total_loss)[0]) / float(len(total_loss)) print('\nTest loss: %f' % total_loss) print('\nAccuracy: %f%%' % ((float(num_correct) / float(test_size)) * 100))