def run_warmup(self, zdist, states, actions, warm_up, train=True, M=None, prev_alpha=None, prev_read_v=None, force_sharp=False): ''' Run warm-up phase ''' batch_size = states[0].size(0) prev_state = None h, c = self.engine.init_hidden(batch_size) h = utils.check_gpu(self.opts.gpu, h) c = utils.check_gpu(self.opts.gpu, c) outputs, maps, zs, alphas, alpha_logits = [], [], [], [], [] init_maps = [] if utils.check_arg(self.opts, 'do_memory'): # initialize memory and alpha if M is None: M = self.memory.init_memory(batch_size) if prev_alpha is None: prev_alpha = utils.check_gpu( self.opts.gpu, torch.zeros(batch_size, self.memory.num_mem)) mem_wh = int(math.sqrt(prev_alpha.size(1))) prev_alpha[:, mem_wh * (mem_wh // 2) + mem_wh // 2] = 1.0 if prev_read_v is None: prev_read_v = utils.check_gpu( self.opts.gpu, torch.zeros(batch_size, self.opts.memory_dim)) alpha_losses = 0 base_imgs_all = [] hiddens = [] for i in range(warm_up): input_state = states[i] prev_state, m, prev_alpha, alpha_loss, z, M, prev_read_v, h, c, init_map, base_imgs, _, cur_hidden = self.run_step( input_state, h, c, actions[i], \ batch_size, prev_read_v, prev_alpha, M, zdist, step=i, force_sharp=force_sharp) outputs.append(prev_state) maps.append(m) alphas.append(prev_alpha) alpha_losses += alpha_loss zs.append(z) base_imgs_all.append(base_imgs) hiddens.append(cur_hidden) init_maps.append(init_map) warm_up_state = [h, c] if prev_state is None: prev_state = states[ 0] # warm_up is 0, the initial screen is always used return prev_state, warm_up_state, M, prev_read_v, prev_alpha, outputs, maps, alphas, alpha_losses, zs, base_imgs_all, 0, \ hiddens, init_maps
def main(): args = parser.parse_args() print_arguments(args) in_path = args.images_path print('cutting......') # in_path = 'input.png' cut_path = 'cut_map' comb_path = 'comb_map' outname = in_path + '_predict.png' h_step,w_step,h_rest,w_rest,img_shape,img_exp_shape,data_list = image_cut(in_path,cut_path) check_gpu(args.use_gpu) print('predicting......') infer(args,cut_path,data_list,comb_path) print('combining......') image_comb(h_step,w_step,h_rest,w_rest,img_shape,img_exp_shape,outname,comb_path)
def main(): parser = argparse.ArgumentParser() arg = parser.add_argument arg('--lr',type=float,default=0.1) arg('--n_epochs',type=int, default = 5) arg('--batch-size',type=int, default= 32) arg('--data_dir',type=str,default = 'chest_xray') arg('--model',type=str, default ='chexnet',choices = model_list.keys()) arg('--root',type=str,default ='runs/debug', help = 'checkpoint root') args = parser.parse_args() train_loader= generate_trainloaders(data_dir= args.data_dir, batch_size= args.batch_size) root = Path(args.root) root.mkdir(exist_ok = True, parents = True) model = model_list[args.model] loss = CrossEntropyLoss() utils.fit( init_optimizer= lambda lr:SGD(model.parameters(),lr = args.lr), args= args, model = model, train_loader = train_loader, criterion= loss, n_epochs= args.n_epochs, train_on_gpu=check_gpu(), dir_save = args.root, lr = args.lr, base_model=args.model )
def run_pipeline(): t_int = time.time() fprint = lambda msg: print( f'{msg} {"="*20} time elapsed = {(time.time()-t_int)/60:.2f} mins') fprint('Load train data') xtrain = pd.read_hdf('./data/train.h5', 'xtrain') xval = pd.read_hdf('./data/train.h5', 'xval') fprint('Load test') xtest = pd.read_hdf('./data/test.h5', 'xtest') fprint('categorizing features') cat_fts = [ 'city_get_first', 'platform_get_first', 'device_get_first', 'item_id', 'location' ] categorize(xtrain, xval, cat_fts, xtest) fprint('reducing memory') reduce_numeric_mem_usage(xtrain) reduce_numeric_mem_usage(xval) reduce_numeric_mem_usage(xtest) xtrain.set_index('session_id', inplace=True) xval.set_index('session_id', inplace=True) xtest.set_index('session_id', inplace=True) fprint('Start training') device = 'GPU' if check_gpu() else 'CPU' params = { 'iterations': 3000, 'learning_rate': 0.02, 'depth': 8, 'task_type': device } clf, categorical_ind, mrr = train_model(xtrain, xval, cat_fts, params) fprint('Make prediction on test set') # pred xtest test_pred = clf.predict_proba(xtest.values)[:, 1] xtest['pred'] = test_pred item_mapper = np.load('./data/item_id_mapper_reverse.npy').item() xtest['item_id'] = xtest['item_id'].map(item_mapper) test_imps_pred = xtest.groupby(level=0).apply(output_impressions) test_imps_pred = test_imps_pred.reset_index(name='recommendation') test_imps_pred.to_csv('./data/test_imps_pred.csv', index=False) # read sub sub = pd.read_csv('./data/submission_popular.csv') sub = pd.merge(sub, test_imps_pred, how='left', on='session_id') sub.to_csv('./data/sub.csv', index=False) sub.drop('item_recommendations', axis=1, inplace=True) sub.rename(columns={'recommendation': 'item_recommendations'}, inplace=True) sub.to_csv(f'./data/sub_mrr_{mrr:.4f}.csv', index=False) fprint('DONE')
def loading_model(self): print('Loading %s model' % (self.model_type)) if self.model_type == 'C3D': self.model = C3D() elif self.model_type == 'I3D': self.model = I3D(num_classes=400, modality='rgb') else: self.model = P3D199(pretrained=False, num_classes=400, dropout=self.dropout) # Transfer classes self.model = transfer_model(model=self.model, model_type=self.model_type, num_classes=self.num_classes) # Check gpu and run parallel if check_gpu() > 0: self.model = torch.nn.DataParallel(self.model).cuda() # define loss function (criterion) and optimizer if check_gpu() > 0: self.criterion = nn.CrossEntropyLoss().cuda() else: self.criterion = nn.CrossEntropyLoss() policies = get_optim_policies(model=self.model, modality=self.modality, enable_pbn=True) self.optimizer = optim.SGD(policies, lr=self.lr, momentum=self.momentum, weight_decay=self.weight_decay) file = os.path.join(self.data_folder, 'model_best.pth.tar') if os.path.isfile(file): print("=> loading checkpoint '{}'".format('model_best.pth.tar')) checkpoint = torch.load(file) self.start_epoch = checkpoint['epoch'] self.best_prec1 = checkpoint['best_prec1'] self.model.load_state_dict(checkpoint['state_dict']) self.optimizer.load_state_dict(checkpoint['optimizer']) print("=> loaded model best ") else: print("=> no model best found at ") exit() cudnn.benchmark = True
def validate(self, logger): batch_time = AverageMeter() losses = AverageMeter() acc = AverageMeter() top1 = AverageMeter() top5 = AverageMeter() # switch to evaluate mode self.model.eval() end = time.time() for i, (images, labels) in enumerate(self.val_loader): if check_gpu() > 0: images = images.cuda(async=True) labels = labels.cuda(async=True) image_var = torch.autograd.Variable(images) label_var = torch.autograd.Variable(labels) # compute y_pred y_pred = self.model(image_var) if self.model_type == 'I3D': y_pred = y_pred[0] loss = self.criterion(y_pred, label_var) # measure accuracy and record loss prec1, prec5 = accuracy(y_pred.data, labels, topk=(1, 5)) losses.update(loss.item(), images.size(0)) acc.update(prec1.item(), images.size(0)) top1.update(prec1.item(), images.size(0)) top5.update(prec5.item(), images.size(0)) # measure elapsed time batch_time.update(time.time() - end) end = time.time() if i % self.print_freq == 0: print('TrainVal: [{0}/{1}]\t' 'Time {batch_time.val:.3f} ({batch_time.avg:.3f})\t' 'Loss {loss.val:.4f} ({loss.avg:.4f})\t' 'Prec@1 {top1.val:.3f} ({top1.avg:.3f})\t' 'Prec@5 {top5.val:.3f} ({top5.avg:.3f})'.format( i, len(self.val_loader), batch_time=batch_time, loss=losses, top1=top1, top5=top5)) print(' * Accuracy {acc.avg:.3f} Loss {loss.avg:.3f}'.format( acc=acc, loss=losses)) logger.info(' * Accuracy {acc.avg:.3f} Loss {loss.avg:.3f}'.format( acc=acc, loss=losses)) return losses, acc
def train_mnist(project_id, epoch, train_per_epoch, interval): check_gpu(logger) project_metadata = get_metadata(project_id) train( dataset=load_mnist_dataset(project_id=project_id, buffer_size=60000, batch_size=256), gen=build_generator_model(), dis=build_discriminator_model(), gen_opt=keras.optimizers.Adam(1e-4), dis_opt=keras.optimizers.Adam(1e-4), logger=logger, epochs=epoch, start_epoch=0, interval=interval, train_per_epoch=train_per_epoch, sample_size=4, batch_size=32, visualize=visualize_mnist_sample, project_metadata=project_metadata, gen_input_generator=MnistInputGenerator(feat_dim=100), )
def process(self): acc = AverageMeter() top1 = AverageMeter() top5 = AverageMeter() losses = AverageMeter() log_file = os.path.join(self.data_folder, 'test.log') logger = Logger('test', log_file) # switch to evaluate mode self.model.eval() start_time = time.clock() print("Begin testing") for i, (images, labels) in enumerate(self.test_loader): if check_gpu() > 0: images = images.cuda(async=True) labels = labels.cuda(async=True) image_var = torch.autograd.Variable(images) label_var = torch.autograd.Variable(labels) # compute y_pred y_pred = self.model(image_var) loss = self.criterion(y_pred, label_var) # measure accuracy and record loss prec1, prec5 = accuracy(y_pred.data, labels, topk=(1, 5)) losses.update(loss.item(), images.size(0)) acc.update(prec1.item(), images.size(0)) top1.update(prec1.item(), images.size(0)) top5.update(prec5.item(), images.size(0)) if i % self.print_freq == 0: print('TestVal: [{0}/{1}]\t' 'Loss {loss.val:.4f} ({loss.avg:.4f})\t' 'Prec@1 {top1.val:.3f} ({top1.avg:.3f})\t' 'Prec@5 {top5.val:.3f} ({top5.avg:.3f})'.format( i, len(self.test_loader), loss=losses, top1=top1, top5=top5)) print( ' * Accuracy {acc.avg:.3f} Acc@5 {top5.avg:.3f} Loss {loss.avg:.3f}'.format(acc=acc, top5=top5, loss=losses)) end_time = time.clock() print("Total testing time %.2gs" % (end_time - start_time)) logger.info("Total testing time %.2gs" % (end_time - start_time)) logger.info( ' * Accuracy {acc.avg:.3f} Acc@5 {top5.avg:.3f} Loss {loss.avg:.3f}'.format(acc=acc, top5=top5, loss=losses))
def main(): parser = argparse.ArgumentParser() arg = parser.add_argument #arg('--model_path',type = str, default='checkpoints/finetune_chexnet_0.01_3') arg('--data_dir', type=str, default='chest_xray') arg('--batch-size', type=int, default=32) arg('--model_path', type=str, default='runs/debug/chexnet_0.1_5') args = parser.parse_args() model = utils.get_model(str(Path(args.model_path))) test_loader = generate_testloader(data_dir=args.data_dir, batch_size=args.batch_size) y_pred, y_test = utils.predict(model=model, testloader=test_loader, train_on_gpu=check_gpu()) print(y_pred) print(y_test)
def predict_image(model, image_path): model.eval() train_on_gpu = utils.check_gpu() print("Prediction in progress") image = Image.open(image_path).convert('RGB') # Define transformations for the image, should (note that imagenet models are trained with image size 224) transformation = transforms.Compose([ transforms.Resize((224, 224)), transforms.ToTensor(), transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) ]) # Preprocess the image image_tensor = transformation(image).float() # Add an extra batch dimension since pytorch treats all images as batches image_tensor = image_tensor.unsqueeze_(0) # Turn the input into a Variable input = Variable(image_tensor) if torch.cuda.is_available(): input = input.cuda() # Predict the class of the image output = model.forward(input) _, predicted = torch.max(output.data, 1) if train_on_gpu: all_predicted = predicted.cpu().numpy().tolist() #y_test += labels.cpu().numpy().tolist() else: all_predicted = predicted.numpy().tolist() #y_test += labels.numpy().tolist() return all_predicted[0] '''
def run_step(self, state, h, c, action, batch_size, prev_read_v, prev_alpha, M, zdist, read_only=False, step=0, decode=True, play=False, force_sharp=False): ''' Run the model one time step ''' # encode the image input if self.opts.input_detach: state = state.detach() s = self.simple_enc(state) # sample a noise z = utils.check_gpu(self.opts.gpu, zdist.sample((batch_size,))) # run dynamics engine prev_hidden = h[0].clone() h, c, cur_hidden = self.engine(h, c, s, action, z, prev_read_v=prev_read_v, step=step) # run memory module if self.opts.do_memory: base, M, alpha, prev_read_v = self.memory(cur_hidden, action, prev_hidden, prev_alpha, M, c=c[0], read_only=read_only, force_sharp=force_sharp) prev_alpha = alpha bases = base else: base = cur_hidden bases = [base] * self.num_components # run the rendering engine alpha_loss = 0 out, m, eloss, init_maps, base_imgs = self.graphics_renderer(bases, num_components=self.num_components) if utils.check_arg(self.opts, 'alpha_loss_multiplier') and self.opts.alpha_loss_multiplier > 0: # memory regularization for i in range(1, len(m)): alpha_loss += (m[i].abs().sum() / batch_size) prev_state = out return prev_state, m, prev_alpha, alpha_loss, z, M, prev_read_v, h, c, init_maps, base_imgs, 0, cur_hidden
def loading_model(self): print('Loading %s model' % (self.model_type)) if self.model_type == 'C3D': self.model = C3D() if self.pretrained: self.model.load_state_dict(torch.load('c3d.pickle')) elif self.model_type == 'I3D': if self.pretrained: self.model = I3D(num_classes=400, modality='rgb') self.model.load_state_dict( torch.load('kinetics_i3d_model_rgb.pth')) else: self.model = I3D(num_classes=self.num_classes, modality='rgb') else: if self.pretrained: print("=> using pre-trained model") self.model = P3D199(pretrained=True, num_classes=400, dropout=self.dropout) else: print("=> creating model P3D") self.model = P3D199(pretrained=False, num_classes=400, dropout=self.dropout) # Transfer classes self.model = transfer_model(model=self.model, model_type=self.model_type, num_classes=self.num_classes) # Check gpu and run parallel if check_gpu() > 0: self.model = torch.nn.DataParallel(self.model).cuda() # define loss function (criterion) and optimizer self.criterion = nn.CrossEntropyLoss() if check_gpu() > 0: self.criterion = nn.CrossEntropyLoss().cuda() params = self.model.parameters() if self.model_type == 'P3D': params = get_optim_policies(model=self.model, modality=self.modality, enable_pbn=True) self.optimizer = optim.SGD(params=params, lr=self.lr, momentum=self.momentum, weight_decay=self.weight_decay) # self.scheduler = optim.lr_scheduler.ReduceLROnPlateau(optimizer=self.optimizer, mode='min', patience=10, verbose=True) # optionally resume from a checkpoint if self.resume: if os.path.isfile(self.resume): print("=> loading checkpoint '{}'".format(self.resume)) checkpoint = torch.load(self.resume) self.start_epoch = checkpoint['epoch'] self.best_prec1 = checkpoint['best_prec1'] self.model.load_state_dict(checkpoint['state_dict']) self.optimizer.load_state_dict(checkpoint['optimizer']) print("=> loaded checkpoint '{}' (epoch {})".format( self.evaluate, checkpoint['epoch'])) else: print("=> no checkpoint found at '{}'".format(self.resume)) if self.evaluate: file_model_best = os.path.join(self.data_folder, 'model_best.pth.tar') if os.path.isfile(file_model_best): print( "=> loading checkpoint '{}'".format('model_best.pth.tar')) checkpoint = torch.load(file_model_best) self.start_epoch = checkpoint['epoch'] self.best_prec1 = checkpoint['best_prec1'] self.model.load_state_dict(checkpoint['state_dict']) self.optimizer.load_state_dict(checkpoint['optimizer']) print("=> loaded checkpoint '{}' (epoch {})".format( self.evaluate, checkpoint['epoch'])) else: print("=> no checkpoint found at '{}'".format(self.resume)) cudnn.benchmark = True
################################################################## ################################################################## ########################## MAIN ########################## ################################################################## ################################################################## # Saving settings model_dir = os.path.join(opt.checkpoint_path, opt.name) os.mkdir(model_dir) if not os.path.isdir(model_dir) else None saver = Saver(model_dir, args=opt) # Define model and optimiser gpu = utils.check_gpu() device = torch.device( "cuda:{}".format(gpu) if torch.cuda.is_available() else "cpu") model = SegNet(sigma=opt.sigma).to(device) optimizer = optim.Adam(model.parameters(), lr=1e-4) # Recover weights, if required if opt.recover: ckpt_file = os.path.join(model_dir, opt.reco_type + '_weights.pth') ckpt = torch.load(ckpt_file, map_location=device) model.load_state_dict(ckpt['model_state_dict']) epoch = ckpt['iter_nb'] + 1 print('Model recovered from {}.'.format(ckpt_file)) if 'optimizer_state_dict' in ckpt: optimizer.load_state_dict(ckpt['optimizer_state_dict']) print('Optimizer recovered from {}.'.format(ckpt_file))
def main(): args = parser.parse_args() print_arguments(args) check_gpu(args.use_gpu) eval(args)
def init_memory(self, bs): memory = self.mem_bias.clone().repeat(bs, 1, 1) return utils.check_gpu(self.opts.gpu, memory)
#from torch.autograd import Variable #from PIL import Image #import torch from torch.optim import SGD as SGD from torch.nn import CrossEntropyLoss import torch import utils from prepare_train_test_val import generate_testloader from models import chexnet, resnet from utils import predict, check_gpu import argparse from pathlib import Path train_on_gpu = check_gpu() if not train_on_gpu: print('Cuda is not available for testing.Testing on CPU.......') else: print('Cuda is available for testing. Testing on GPU.......') def get_model(model_path): model = chexnet() state = torch.load(str(model_path)) state = { key.replace('module.', ''): value for key, value in state['model'].items() } model.load_state_dict(state)
def forward(self, h, a, prev_h, prev_alpha, M, c=None, read_only=False, play=False, force_sharp=False): bs = a.size(0) if self.opts.mem_use_h: memory_q_input = h else: h_norm = F.normalize(h, dim=1) prev_h_norm = F.normalize(prev_h, dim=1) memory_q_input = h_norm - prev_h_norm kernels = self.get_kernel(a).view(-1, 1, 3, 3) # flipping kernels (e.g. kernel of Left == flipped kernel of Right new_a = a.cpu().numpy() _, action_label = torch.max(a, 1) action_label = action_label.long().cpu().numpy() mask = np.zeros((bs, 1)) for i in range(bs): if 'pacman' in self.opts.data: if action_label[i] == 2: new_a[i][1] = 1.0 new_a[i][2] = 0.0 mask[i][0] = 1.0 elif action_label[i] == 4: new_a[i][3] = 1.0 new_a[i][4] = 0.0 mask[i][0] = 1.0 elif 'vizdoom' in self.opts.data: if action_label[i] == 0: new_a[i][1] = 1.0 new_a[i][0] = 0.0 mask[i][0] = 1.0 mask = utils.check_gpu(self.opts.gpu, torch.FloatTensor(mask)).view(-1, 1, 1, 1) new_a = utils.check_gpu(self.opts.gpu, torch.FloatTensor(new_a)) flipped_kernels = torch.flip( self.get_kernel(new_a).view(-1, 1, 3, 3), [2, 3]) kernels = (1 - mask) * kernels + mask * flipped_kernels if self.opts.softmax_kernel: if force_sharp: tmp = torch.zeros_like(kernels.view(bs, -1)) tmp[0][kernels.view(bs, -1).max(1)[1]] = 1.0 kernels = tmp else: kernels = F.softmax(kernels.view(bs, -1) / self.opts.alpha_T, dim=1) kernels = kernels.view(bs, 1, 3, 3) gate = self.get_gate(memory_q_input) if force_sharp: if gate[0] > 0.5: gate = torch.ones_like(gate) else: gate = torch.zeros_like(gate) mem_h = int(math.sqrt(self.num_mem)) alpha = self.conv2d_with_kernel(prev_alpha.view(bs, 1, mem_h, mem_h), kernels, v_dim=1) alpha = alpha.view(bs, -1) alpha = alpha * gate + prev_alpha * (1 - gate) if force_sharp: tmp = torch.zeros_like(alpha) tmp[0][alpha.view(bs, -1).max(1)[1]] = 1.0 alpha = tmp if not read_only: tmp = self.get_vars_h(h) erase_v = tmp[:, :self.opts.memory_dim] add_v = tmp[:, 1 * self.opts.memory_dim:2 * self.opts.memory_dim] other_v = tmp[:, 2 * self.opts.memory_dim:] erase_v = F.sigmoid(erase_v) M = self.write(erase_v, add_v, alpha, M) read_v, block_read_v = self.read(alpha, M) final_h = [read_v, other_v] return final_h, M, alpha, read_v
def plot_similarity(labels, features, rotation): print("Calculating inner product of embedding vectors") corr = np.inner(features, features) print("Plotting...") sns.set(font_scale=1.2) g = sns.heatmap( corr, xticklabels=labels, yticklabels=labels, vmin=0, vmax=1, cmap="YlOrRd") g.set_xticklabels(labels, rotation=rotation) g.set_title("Semantic Textual Similarity") check_gpu() # module_url = 'https://tfhub.dev/google/universal-sentence-encoder-multilingual-large/1' module_url = 'https://tfhub.dev/google/universal-sentence-encoder/2' tf_hub_embedder = hub.Module(module_url) # Hyperparameter search for number of clusters for k-means n_clusters = [5, 10, 12, 14, 16] clustering_method = 'kmeans' logger.info("Loading data") files = glob.glob('tweets/cdnpoli_*.csv') df = pd.read_csv(files[0]) for file in files[1:]: df_tmp = pd.read_csv(file)
def loading_model(self): print('Loading %s model' % (self.model_type)) pretrained = None if self.pretrained: pretrained = 'imagenet' if self.model_type == 'inceptionv4': self.model = inceptionv4(num_classes=1000, pretrained=pretrained) if self.pretrained: num_ftrs = self.model.last_linear.in_features self.model.last_linear = nn.Linear(num_ftrs, self.num_classes) # free all layers: for i, param in self.model.named_parameters(): param.requires_grad = False # unfreeze last layers: ct = [] for name, child in self.model.features.named_children(): if "4" in ct: for param in child.parameters(): param.requires_grad = True ct.append(name) else: num_ftrs = self.model.last_linear.in_features self.model.last_linear = nn.Linear(num_ftrs, self.num_classes) else: print('no model') exit() # Check gpu and run parallel if check_gpu() > 0: self.model = torch.nn.DataParallel(self.model).cuda() # self.model.cuda() # define loss function (criterion) and optimizer self.criterion = nn.CrossEntropyLoss() if check_gpu() > 0: self.criterion = nn.CrossEntropyLoss().cuda() params = list( filter(lambda p: p.requires_grad, self.model.parameters())) self.optimizer = optim.SGD(params=params, lr=self.lr, momentum=self.momentum, weight_decay=self.weight_decay) file = os.path.join(self.data_folder, 'model_best.pth.tar') if os.path.isfile(file): print("=> loading checkpoint '{}'".format('model_best.pth.tar')) checkpoint = torch.load(file) self.start_epoch = checkpoint['epoch'] self.best_prec1 = checkpoint['best_prec1'] self.model.load_state_dict(checkpoint['state_dict']) self.optimizer.load_state_dict(checkpoint['optimizer']) print("=> loaded best model") else: print("=> no model best found at ") exit() cudnn.benchmark = True
def loading_model(self): print('Loading %s model' % (self.model_type)) pretrained = None if self.pretrained: pretrained = 'imagenet' if self.model_type == 'inceptionv4': self.model = inceptionv4(num_classes=1000, pretrained=pretrained) if self.pretrained: num_ftrs = self.model.last_linear.in_features self.model.last_linear = nn.Linear(num_ftrs, self.num_classes) #free all layers: for i, param in self.model.named_parameters(): param.requires_grad = False #unfreeze last layers: ct = [] for name, child in self.model.features.named_children(): if "4" in ct: for param in child.parameters(): param.requires_grad = True ct.append(name) else: num_ftrs = self.model.last_linear.in_features self.model.last_linear = nn.Linear(num_ftrs, self.num_classes) elif self.model_type == 'iresetv2': self.model = inceptionresnetv2(num_classes=self.num_classes, pretrained=pretrained) else: print('no model') exit() cudnn.benchmark = True # Check gpu and run parallel if check_gpu() > 0: self.model = torch.nn.DataParallel(self.model).cuda() # self.model.cuda() # define loss function (criterion) and optimizer self.criterion = nn.CrossEntropyLoss() if check_gpu() > 0: self.criterion = nn.CrossEntropyLoss().cuda() params = self.model.parameters() if self.pretrained: params = list( filter(lambda p: p.requires_grad, self.model.parameters())) self.optimizer = optim.SGD(params=params, lr=self.lr, momentum=self.momentum, weight_decay=self.weight_decay) # self.scheduler = optim.lr_scheduler.ReduceLROnPlateau(optimizer=self.optimizer, mode='min', factor=0.1, # patience=10, verbose=True, min_lr=0) self.scheduler = optim.lr_scheduler.StepLR(optimizer=self.optimizer, step_size=10, gamma=0.1) # self.optimizer = optim.Adam(params, lr=self.lr) # optionally resume from a checkpoint if self.resume: if os.path.isfile(self.resume): print("=> loading checkpoint '{}'".format(self.resume)) checkpoint = torch.load(self.resume) self.start_epoch = checkpoint['epoch'] self.best_prec1 = checkpoint['best_prec1'] self.model.load_state_dict(checkpoint['state_dict']) self.optimizer.load_state_dict(checkpoint['optimizer']) print("=> loaded checkpoint (epoch {})".format( checkpoint['epoch'])) else: print("=> no checkpoint found at '{}'".format(self.resume)) if self.evaluate: file_model_best = os.path.join(self.data_folder, 'model_best.pth.tar') if os.path.isfile(file_model_best): print( "=> loading checkpoint '{}'".format('model_best.pth.tar')) checkpoint = torch.load(file_model_best) self.start_epoch = checkpoint['epoch'] self.best_prec1 = checkpoint['best_prec1'] self.model.load_state_dict(checkpoint['state_dict']) self.optimizer.load_state_dict(checkpoint['optimizer']) print("=> loaded checkpoint (epoch {})".format( checkpoint['epoch'])) else: print("=> no checkpoint found at '{}'".format(self.resume)) cudnn.benchmark = True
logits = [] for batch in tqdm(test_dataloader): b_input_ids, b_attn_mask = tuple(t.to(device) for t in batch) with torch.no_grad(): logits.append(model(b_input_ids, b_attn_mask)) logits = torch.cat(logits, dim=0) prob = F.softmax(logits, dim=1).cpu().numpy() return prob ############################################################################### if __name__ == "__main__": set_seed() device = check_gpu() print("\nPreparing train data...") d = load_data("/home/jessica/data/SciCite/train.jsonl") data = pd.DataFrame.from_dict(d).T data = data.loc[:, ["string", "label"]] # replace categorical labels with numbers label_map = {"background": 0, "method": 1, "result": 2} data["label"].replace(label_map, inplace=True) # train-valid split X_train, X_valid, y_train, y_valid = train_test_split( data.string, data.label, test_size=0.3 )
def train(self, logger, epoch): batch_time = AverageMeter() data_time = AverageMeter() losses = AverageMeter() acc = AverageMeter() top1 = AverageMeter() top5 = AverageMeter() rate = get_learning_rate(self.optimizer)[0] # switch to train mode self.model.train() end = time.time() for i, (images, target) in enumerate(self.train_loader): # adjust learning rate scheduler step self.scheduler.batch_step() # measure data loading time data_time.update(time.time() - end) if check_gpu() > 0: images = images.cuda(async=True) target = target.cuda(async=True) image_var = torch.autograd.Variable(images) label_var = torch.autograd.Variable(target) self.optimizer.zero_grad() # compute y_pred y_pred = self.model(image_var) if self.model_type == 'I3D': y_pred = y_pred[0] loss = self.criterion(y_pred, label_var) # measure accuracy and record loss prec1, prec5 = accuracy(y_pred.data, target, topk=(1, 5)) losses.update(loss.item(), images.size(0)) acc.update(prec1.item(), images.size(0)) top1.update(prec1.item(), images.size(0)) top5.update(prec5.item(), images.size(0)) # compute gradient and do SGD step loss.backward() self.optimizer.step() # measure elapsed time batch_time.update(time.time() - end) end = time.time() if i % self.print_freq == 0: print('Epoch: [{0}/{1}][{2}/{3}]\t' 'Time {batch_time.val:.3f} ({batch_time.avg:.3f})\t' 'Data {data_time.val:.3f} ({data_time.avg:.3f})\t' 'Lr {rate:.5f}\t' 'Loss {loss.val:.4f} ({loss.avg:.4f})\t' 'Prec@1 {top1.val:.3f} ({top1.avg:.3f})\t' 'Prec@5 {top5.val:.3f} ({top5.avg:.3f})'.format( epoch, self.epochs, i, len(self.train_loader), batch_time=batch_time, data_time=data_time, rate=rate, loss=losses, top1=top1, top5=top5)) logger.info('Epoch: [{0}/{1}]\t' 'Time {batch_time.val:.3f} ({batch_time.avg:.3f})\t' 'Data {data_time.val:.3f} ({data_time.avg:.3f})\t' 'Lr {rate:.5f}\t' 'Loss {loss.val:.4f} ({loss.avg:.4f})\t' 'Prec@1 {top1.val:.3f} ({top1.avg:.3f})\t' 'Prec@5 {top5.val:.3f} ({top5.avg:.3f})'.format( epoch, self.epochs, batch_time=batch_time, data_time=data_time, rate=rate, loss=losses, top1=top1, top5=top5)) return losses, acc
def process(self): acc = AverageMeter() top1 = AverageMeter() top5 = AverageMeter() losses = AverageMeter() log_file = os.path.join(self.data_folder, 'test.log') logger = Logger('test', log_file) # switch to evaluate mode self.model.eval() start_time = time.clock() print("Begin testing") predicted, probs = [], [] for i, (images, labels) in enumerate(self.test_loader): if check_gpu() > 0: images = images.cuda(async=True) labels = labels.cuda(async=True) images = torch.autograd.Variable(images) labels = torch.autograd.Variable(labels) if self.tencrop: # Due to ten-cropping, input batch is a 5D Tensor batch_size, number_of_crops, number_of_channels, height, width = images.size( ) # Fuse batch size and crops images = images.view(-1, number_of_channels, height, width) # Compute model output output_batch_crops = self.model(images) # Average predictions for each set of crops output_batch = output_batch_crops.view(batch_size, number_of_crops, -1).mean(1) label_repeated = labels.repeat(10, 1).transpose( 1, 0).contiguous().view(-1, 1).squeeze() loss = self.criterion(output_batch_crops, label_repeated) else: output_batch = self.model(images) loss = self.criterion(output_batch, labels) # measure accuracy and record loss prec1, prec5 = accuracy(output_batch.data, labels, topk=(1, 5)) # print(prec1, prec5) losses.update(loss.item(), images.size(0)) acc.update(prec1.item(), images.size(0)) top1.update(prec1.item(), images.size(0)) top5.update(prec5.item(), images.size(0)) if i % self.print_freq == 0: print('TestVal: [{0}/{1}]\t' 'Loss {loss.val:.4f} ({loss.avg:.4f})\t' 'Prec@1 {top1.val:.3f} ({top1.avg:.3f})\t' 'Prec@5 {top5.val:.3f} ({top5.avg:.3f})'.format( i, len(self.test_loader), loss=losses, top1=top1, top5=top5)) print( ' * Accuracy {acc.avg:.3f} Acc@5 {top5.avg:.3f} Loss {loss.avg:.3f}' .format(acc=acc, top5=top5, loss=losses)) end_time = time.clock() print("Total testing time %.2gs" % (end_time - start_time)) logger.info("Total testing time %.2gs" % (end_time - start_time)) logger.info(' * Accuracy {acc.avg:.3f} Loss {loss.avg:.3f}'.format( acc=acc, top5=top5, loss=losses))
def validate(self, logger): batch_time = AverageMeter() losses = AverageMeter() acc = AverageMeter() top1 = AverageMeter() top5 = AverageMeter() # switch to evaluate mode self.model.eval() end = time.time() for i, (images, labels) in enumerate(self.val_loader): if check_gpu() > 0: images = images.cuda(async=True) labels = labels.cuda(async=True) images = torch.autograd.Variable(images) labels = torch.autograd.Variable(labels) if self.tencrop: # Due to ten-cropping, input batch is a 5D Tensor batch_size, number_of_crops, number_of_channels, height, width = images.size( ) # Fuse batch size and crops images = images.view(-1, number_of_channels, height, width) # Compute model output output_batch_crops = self.model(images) # Average predictions for each set of crops output_batch = output_batch_crops.view(batch_size, number_of_crops, -1).mean(1) label_repeated = labels.repeat(10, 1).transpose( 1, 0).contiguous().view(-1, 1).squeeze() loss = self.criterion(output_batch_crops, label_repeated) else: output_batch = self.model(images) loss = self.criterion(output_batch, labels) # measure accuracy and record loss prec1, prec5 = accuracy(output_batch.data, labels, topk=(1, 5)) losses.update(loss.item(), images.size(0)) acc.update(prec1.item(), images.size(0)) top1.update(prec1.item(), images.size(0)) top5.update(prec5.item(), images.size(0)) # measure elapsed time batch_time.update(time.time() - end) end = time.time() if i % self.print_freq == 0: print('TrainVal: [{0}/{1}]\t' 'Time {batch_time.val:.3f} ({batch_time.avg:.3f})\t' 'Loss {loss.val:.4f} ({loss.avg:.4f})\t' 'Prec@1 {top1.val:.3f} ({top1.avg:.3f})\t' 'Prec@5 {top5.val:.3f} ({top5.avg:.3f})'.format( i, len(self.val_loader), batch_time=batch_time, loss=losses, top1=top1, top5=top5)) print(' * Accuracy {acc.avg:.3f} Loss {loss.avg:.3f}'.format( acc=acc, loss=losses)) logger.info(' * Accuracy {acc.avg:.3f} Loss {loss.avg:.3f}'.format( acc=acc, loss=losses)) return losses, acc