def _train_epoch(self, save_histogram=False): self.model.train() running_loss = 0 running_acc = 0 for iter, (inputs, targets) in enumerate(tqdm(self.train_loader)): inputs = inputs.to(device()) targets = targets.to(device()) if self.onecycle is not None: lr, mom = next(self.onecycle) self.update_lr(lr) self.update_mom(mom) with torch.set_grad_enabled(True): outputs = self.model(inputs) batch_loss = self.criterion(outputs, targets) batch_acc = accuracy(outputs, targets) batch_loss.backward() self.optimizer.step() self.optimizer.zero_grad() running_loss += batch_loss.item() running_acc += batch_acc.item() if self.log_every(iter): self.writer.add_scalars( "loss", {"train_loss": running_loss / float(iter + 1)}, (self._epoch_count - 1) * len(self.train_loader) + iter) self.writer.add_scalars( "acc", {"train_acc": running_acc / float(iter + 1)}, (self._epoch_count - 1) * len(self.train_loader) + iter) epoch_loss = running_loss / len(self.train_loader) epoch_acc = running_acc / len(self.train_loader) print(f"train loss: {epoch_loss:.5f} train acc: {epoch_acc:.5f}") return epoch_loss, epoch_acc
def get_net(cf_net, parent_snapshot, gpu): if parent_snapshot: net = main.load_snapshot(parent_snapshot) else: net = getattr(main, cf_net['call'])(**dict_drop(cf_net, 'call')) if isinstance(gpu, int): net.to(device(gpu)) else: net = torch.nn.DataParallel(net, gpu) net.to(device(gpu[0])) return net
def multiexit_error_coocc(net, n_exits, val_iter, gpu): errors = torch.zeros(n_exits, n_exits) net.to(device(gpu)) for X, y in val_iter: logits_list = net.train(False)(X.to(device(gpu))) err = [logits.max(dim=1)[1].cpu() != y for logits in logits_list] for i in range(n_exits): for j in range(i, n_exits): errors[i][j] += (err[i] * err[j]).float().sum() del net for i in range(n_exits): for j in range(i): errors[i][j] = errors[j][i] return errors
def train(self, train_dataset, test_dataset, tokenizer, output_dir): model = BertForSequenceClassification.from_pretrained( 'bert-base-uncased') model.to(device()) self.full_train(train_dataset, test_dataset, model, tokenizer, output_dir) return model
def epoch_train_func( self, model, dataset, optimizer, scheduler, ): train_loss = 0.0 train_sampler = RandomSampler(dataset) data = DataLoader(dataset, sampler=train_sampler, batch_size=self.settings['train_batch_size']) for step, batch in enumerate(tqdm(data, desc="Iteration")): model.train() batch = tuple(t.to(device()) for t in batch) inputs = batch_to_inputs(batch) outputs = model(**inputs) loss = outputs[0] loss.backward() train_loss += loss.item() optimizer.step() model.zero_grad() scheduler.step() return train_loss / len(data)
def train(self, X, y, y_real, output_dir): X_split = [normalize(t.split()) for t in X] split_arrays = train_test_split(X_split, y, y_real, test_size=self.settings['test_size'], stratify=y_real) X_train, X_test, y_train, y_test, y_real_train, y_real_test = split_arrays text_field = data.Field() text_field.build_vocab(X_train, max_size=10000) # pad X_train_pad = [pad(s, self.settings['max_seq_length']) for s in tqdm(X_train, desc='pad')] X_test_pad = [pad(s, self.settings['max_seq_length']) for s in tqdm(X_test, desc='pad')] # to index X_train_index = [to_indexes(text_field.vocab, s) for s in tqdm(X_train_pad, desc='to index')] X_test_index = [to_indexes(text_field.vocab, s) for s in tqdm(X_test_pad, desc='to index')] train_dataset = self.to_dataset(X_train_index, y_train, y_real_train) val_dataset = self.to_dataset(X_test_index, y_test, y_real_test) model = self.model(text_field) model.to(device()) self.full_train(model, train_dataset, val_dataset, output_dir) torch.save(text_field, os.path.join(output_dir, self.vocab_name)) return model, text_field.vocab
def evaluate(self, model, eval_dataset, epoch): train_settings = self.settings eval_sampler = SequentialSampler(eval_dataset) data_loader = DataLoader(eval_dataset, sampler=eval_sampler, batch_size=train_settings['eval_batch_size']) eval_loss = 0.0 acc = 0.0 num_examples = 0 model.eval() predictions = None labels = None for batch in tqdm(data_loader, desc="Evaluating"): batch = tuple(t.to(device()) for t in batch) with torch.no_grad(): inputs = batch_to_inputs(batch) outputs = model(**inputs) tmp_eval_loss, logits = outputs[:2] eval_loss += tmp_eval_loss.item() probs = torch.softmax(logits, dim=1) pred_label = torch.argmax(logits, dim=1) acc += torch.sum(pred_label == batch[3]).cpu().numpy() num_examples += len(batch[3]) predictions, labels = self.stack(predictions, labels, probs, batch[3]) self.log_pr(labels, predictions, epoch) return eval_loss / len(data_loader), acc / num_examples
def __init__(self, model, criterion, optimizer, train_loader, val_loader=None, name="experiment", experiments_dir="runs", save_dir=None, div_lr=1): self.device = device() self.model = model.to(self.device) self.criterion = criterion self.optimizer = optimizer self.train_loader = train_loader self.val_loader = val_loader self.div_lr = div_lr self.update_lr(self.optimizer.defaults['lr']) self._epoch_count = 0 self._best_loss = None self._best_acc = None if save_dir is None: save_dir = f"{self.get_num_dir(experiments_dir):04d}-{get_git_hash()}-{name}" self._save_dir = os.path.join(experiments_dir, save_dir) self.writer = Logger(self._save_dir) atexit.register(self.cleanup)
def evaluate(model: nn.Module, dataset: Dataset, pretrained: bool = False, visualizer: Visualizer = None) -> None: loader = DataLoader(dataset, batch_size=dataset.BATCH_SIZE, shuffle=dataset.SHUFFLE) if pretrained: model.load_state_dict( torch.load(os.path.join(config.LOG_PATH, config.NAME))) logger.info("[+] Evaluating model...") imgize = torchvision.transforms.ToPILImage() with torch.no_grad(): model.eval() for batch_idx, samples in enumerate(loader): images, raw_path = device( [samples['image']], gpu=config.USE_GPU)[0], samples['raw_path'] outputs = model(images)['out'] output_mask = outputs.argmax(1) for mask, path in zip(output_mask, raw_path): _mask = torch.where(mask == 1, torch.ones_like(mask) * 255, torch.zeros_like(mask)).byte() _mask = imgize(_mask.cpu()) filename = os.path.basename(path) _mask.save(os.path.join(config.OUT_PATH, filename)) logger.info("[+] Done.")
def test(self, test_loader): self.model.eval() running_loss = 0 running_acc = 0 for iter, (inputs, targets) in enumerate(tqdm(test_loader)): inputs = inputs.to(device()) targets = targets.to(device()) with torch.set_grad_enabled(False): outputs = self.model(inputs) batch_loss = self.criterion(outputs, targets) batch_acc = accuracy(outputs, targets) running_loss += batch_loss.item() running_acc += batch_acc.item() epoch_loss = running_loss / len(test_loader) epoch_acc = running_acc / len(test_loader) print(f"test loss: {epoch_loss:.5f} test acc: {epoch_acc:.5f}") return epoch_loss, epoch_acc
def multiexit_agreement(net, n_exits, val_iter, gpu): agreements = torch.zeros(n_exits, n_exits, device=device(gpu)) net.to(device(gpu)) n = 0 for X, y in val_iter: logits_list = net.train(False)(X.to(device(gpu))) pred = [logits.max(dim=1)[1] for logits in logits_list] n += len(pred[0]) for i in range(n_exits): for j in range(i + 1, n_exits): agreements[i][j] += (pred[i] == pred[j]).float().sum() del net for i in range(n_exits): agreements[i][i] = n for j in range(i): agreements[i][j] = agreements[j][i] return agreements.cpu()
def main_FCNN(): # Step 01: Get Input Resources and Model Configuration parser = app_argparse() args = parser.parse_args() print(args) INPUT_IMAGE_PATH = args.input_RGB LABEL_IMAGE_PATH = args.input_GT WEIGHTS_FILE_PATH = args.output_model_path LOSS_PLOT_PATH = args.output_loss_plot use_gpu = args.use_gpu use_pretrain = args.use_pretrain epochs = args.epochs batch_size = args.batch_size tile_size = args.tile_size learning_rate = args.learning_rate weight_decay = args.weight_decay # Step 02: load the pretrained model device = utils.device(use_gpu=use_gpu) # init model structure model = FCNN() # model = utils.load_weights_from_disk(model) if use_pretrain: model = utils.load_entire_model(model, WEIGHTS_FILE_PATH, use_gpu) print("use pretrained model!") train_loader = dataset.training_loader( image_path=INPUT_IMAGE_PATH, label_path=LABEL_IMAGE_PATH, batch_size=batch_size, tile_size=tile_size, shuffle=True # use shuffle ) # turn the shuffle model, stats = train( model=model, train_loader=train_loader, device=device, epochs=epochs, batch_size=batch_size, tile_size=tile_size, learning_rate=learning_rate, weight_decay=weight_decay, ) # comment the following section to compare the results with 4 workers and pin_memory in dataloader. # Step 03: save the model # model_path = utils.save_weights_to_disk(model) model_path = utils.save_entire_model(model, WEIGHTS_FILE_PATH) # save the loss figure and data stats.save_loss_plot(LOSS_PLOT_PATH)
def evaluate(cf_test, cf_loss, batch_size, snapshot_name, gpu): net = main.load_snapshot(snapshot_name).to(device(gpu)) loss_f = getattr(main, cf_loss['call'])(**dict_drop(cf_loss, 'call')) Data = getattr(main, cf_test['call']) test_iter = Data(split='test', batch_size=batch_size, gpu=gpu, **dict_drop(cf_test, 'call')) print('\t'.join(loss_f.metric_names)) val_metrics = main.validate(loss_f, net, test_iter, gpu) print(utils.tab_str(*val_metrics))
def main_UNet_II(): # TODO: Get through CLI arg # Step 01: Get Input Resources and Model Configuration parser = app_argparse() args = parser.parse_args() # print(args) use_gpu = args.use_gpu # tile_size = args.tile_size tile_size = (200, 200) INPUT_IMAGE_PATH = args.input_RGB LABEL_IMAGE_PATH = args.input_GT # WEIGHTS_FILE_PATH = args.output_model_path WEIGHTS_FILE_PATH = "weights/Adam.UNet.weights.II.pt" OUTPUT_IMAGE_PATH = args.output_images # Step 02: Get Input Resources and Model Configuration device = utils.device(use_gpu=use_gpu) model = UNet() # model = utils.load_weights_from_disk(model) model = utils.load_entire_model(model, WEIGHTS_FILE_PATH, use_gpu) print("use pretrained model!") # print(model) # summary(model, (3, tile_size[0], tile_size[1])) # this is issue !!! loader = dataset.full_image_loader( INPUT_IMAGE_PATH, LABEL_IMAGE_PATH, tile_size=tile_size) prediction = predict(model, loader, device=device, class_label=ClassLabel.house) # Step 03: save the output input_image = utils.input_image(INPUT_IMAGE_PATH) pred_image, mask_image = utils.overlay_class_prediction( input_image, prediction) pred_image_path = OUTPUT_IMAGE_PATH + "/prediction.png" pred_image.save(pred_image_path) pred_mask_path = OUTPUT_IMAGE_PATH + "/mask.png" mask_image.save(pred_mask_path) print("(i) Prediction and Mask image saved at {}".format(pred_image_path)) print("(ii) Mask image saved at {}".format(pred_mask_path)) # Step 04: Check the metrics img_gt = np.array(Image.open(LABEL_IMAGE_PATH), dtype=np.int32) img_mask = np.array(Image.open(pred_mask_path), dtype=np.int32) metricComputation(img_gt, img_mask)
def evaluate_dataset(model, dataloader): model.eval() running_metrics = None for images_lowres, images_fullres, targets in dataloader: images_lowres, images_fullres, targets = utils.device( [images_lowres, images_fullres, targets]) with torch.no_grad(): predictions = model(images_lowres, images_fullres) psnr = compute_psnr(predictions, targets) running_metrics = utils.update_metrics(running_metrics, {'psnr': psnr}, len(dataloader)) model.train() return running_metrics
def train(cf_trn, cf_val, cf_opt, cf_loss, cf_scheduler, batch_size, val_batch_size, gpu, n_epochs, parent_snapshot, snapshot_name, save_interval): torch.backends.cudnn.benchmark = True main_gpu = gpu if isinstance(gpu, int) else gpu[0] dvc = device(main_gpu) net = get_net() loss_f = getattr(main, cf_loss['call'])(**dict_drop(cf_loss, 'call')) Opt = getattr(torch.optim, cf_opt['call']) opt = Opt(net.parameters(), **dict_drop(cf_opt, 'call')) ep = int(parent_snapshot.split('_')[-1][2:]) if parent_snapshot else 0 Scheduler = getattr(torch.optim.lr_scheduler, cf_scheduler['call']) scheduler = Scheduler(opt, last_epoch=-1, **dict_drop(cf_scheduler, 'call')) for i in range(ep): scheduler.step() Data = getattr(main, cf_trn['call']) trn_iter = Data(split='train', batch_size=batch_size, gpu=main_gpu, **dict_drop(cf_trn, 'call')) Data = getattr(main, cf_val['call']) val_iter = Data(split='val', batch_size=val_batch_size, gpu=main_gpu, **dict_drop(cf_val, 'call')) if save_interval: saver = utils.IntervalSaver(snapshot_name, ep, save_interval) else: saver = utils.RecordSaver(snapshot_name, ep) print('\t'.join(['ep', 'loss'] + loss_f.metric_names)) while ep < n_epochs: scheduler.step() for trn_tuple in trn_iter: trn_tuple = [t.to(dvc) for t in trn_tuple] opt.zero_grad() loss = loss_f(net.train(True), *trn_tuple, ep) loss.backward() opt.step() ep += 1 trn_metrics = loss_f.trn_metrics() val_metrics = main.validate(loss_f, net, val_iter, main_gpu) print(utils.tab_str(ep, loss, *trn_metrics)) print(utils.tab_str('', 0.0, *val_metrics)) saver.save(val_metrics[0], net, main_gpu, ep) del net, opt, trn_iter, val_iter
def update(self, labels_true, labels_pred): def _hist(l_true, l_pred): mask = (l_true >= 0) & (l_true < self.n_classes) hist = np.bincount( self.n_classes * l_true[mask].astype(int) + l_pred[mask], minlength=self.n_classes**2).reshape(self.n_classes, self.n_classes) return hist _labels_true, _labels_pred = device([labels_true, labels_pred], gpu=False, numpy=True) for lt, lp in zip(_labels_true, _labels_pred): self.confusion_matrix += _hist(lt.flatten(), lp.flatten())
def dev_model(args): # modified from __main__ in train.py # Get the arguments from GUI INPUT_IMAGE_PATH = args.input_RGB LABEL_IMAGE_PATH = args.input_GT WEIGHTS_FILE_PATH = args.output_model_path LOSS_PLOT_PATH = args.output_loss_plot use_gpu = args.use_gpu use_pretrain = args.use_pretrain epochs = args.epochs batch_size = args.batch_size tile_size = (args.tile_size_height, args.tile_size_width) learning_rate = args.learning_rate weight_decay = args.weight_decay device = utils.device(use_gpu=use_gpu) # init model structure model = FCNN() # model = utils.load_weights_from_disk(model) if use_pretrain: model = utils.load_entire_model(model, WEIGHTS_FILE_PATH, use_gpu) print("use pretrained model!") train_loader = dataset.training_loader( image_path=INPUT_IMAGE_PATH, label_path=LABEL_IMAGE_PATH, batch_size=batch_size, tile_size=tile_size, shuffle=True, # use shuffle ) # turn the shuffle model, stats = train( model=model, train_loader=train_loader, device=device, epochs=epochs, batch_size=batch_size, tile_size=tile_size, learning_rate=learning_rate, weight_decay=weight_decay, ) # model_path = utils.save_weights_to_disk(model) model_path = utils.save_entire_model(model, WEIGHTS_FILE_PATH) # save the loss figure and data stats.save_loss_plot(LOSS_PLOT_PATH) print("[>>>] Passed!")
def train(model: nn.Module, dataset: Dataset, validate_data: Dataset = None) -> None: loader = DataLoader(dataset, batch_size=dataset.BATCH_SIZE, shuffle=dataset.BATCH_SIZE) optimizer = getattr(torch.optim, config.TRAIN.OPTIMIZER)(model.parameters(), **config.TRAIN.OPTIM_PARAMS) overall_iter = 0 evaluation = ConfusionMatrix(dataset.get_num_class()) model.train() for epoch in range(config.TRAIN.NUM_EPOCHS): total_loss = 0 for batch_idx, samples in enumerate(loader): images, target = device([samples['image'], samples['mask']], gpu=config.USE_GPU) outputs = model(images)['out'] output_mask = outputs.argmax(1) batch_loss = Loss.cross_entropy2D(outputs, target, False) total_loss += batch_loss.item() overall_loss = total_loss / ((batch_idx + 1)) evaluation.update(output_mask, target) optimizer.zero_grad() batch_loss.backward() optimizer.step() if batch_idx % config.PRINT_BATCH_FREQ == 0: metrics = evaluation() logger.info(f'Train Epoch: {epoch}, {batch_idx}') logger.info( f'Batch loss: {batch_loss.item():.6f}, Overall loss: {overall_loss:.6f}' ) for met in beautify(metrics[0]): logger.info(f'{met}') logger.info(f'Classwise IoU') for met in beautify(metrics[1]): logger.info(f'{met}') logger.info("\n") overall_iter += 1 if config.SAVE_ITER_FREQ and overall_iter % config.SAVE_ITER_FREQ == 0: torch.save( model.state_dict(), os.path.join(config.LOG_PATH, config.NAME + f"-iter={overall_iter}"))
def _validate_epoch(self): self.model.eval() running_loss = 0 running_acc = 0 for iter, (inputs, targets) in enumerate(tqdm(self.val_loader)): inputs = inputs.to(device()) targets = targets.to(device()) with torch.set_grad_enabled(False): outputs = self.model(inputs) batch_loss = self.criterion(outputs, targets) batch_acc = accuracy(outputs, targets) running_loss += batch_loss.item() running_acc += batch_acc.item() if self.log_every(iter): self.writer.add_scalars( "loss", {"val_loss": running_loss / float(iter + 1)}, (self._epoch_count - 1) * len(self.val_loader) + iter) self.writer.add_scalars( "acc", {"val_acc": running_acc / float(iter + 1)}, (self._epoch_count - 1) * len(self.val_loader) + iter) epoch_loss = running_loss / len(self.val_loader) epoch_acc = running_acc / len(self.val_loader) print(f"val loss: {epoch_loss:.5f} val acc: {epoch_acc:.5f}") return epoch_loss, epoch_acc
optimizer.zero_grad() loss.backward() optimizer.step() return model, training_stats if __name__ == '__main__': # TODO: Get through CLI args epochs = 100 batch_size = 1 use_gpu = True tile_size = (256, 256) device = utils.device(use_gpu=use_gpu) model = UNet() train_loader = dataset.training_loader(batch_size=batch_size, tile_size=tile_size) model, stats = train(model=model, train_loader=train_loader, device=device, epochs=epochs, batch_size=batch_size, tile_size=tile_size) model_path = utils.save_weights_to_disk(model) print('(i) Model saved at {}'.format(model_path))
n_epochs, train_loader, test_loader, model, optimizer, scheduler = conf.params( ) print_freq = 50 best_metrics = None running_metrics = None for epoch in range(1, n_epochs + 1): print('Starting epoch: %d' % epoch) scheduler.step() for batch, (images_lowres, images_fullres, targets) in enumerate(train_loader): step_num = utils.step_num(epoch, batch, train_loader) images_lowres, images_fullres, targets = utils.device( [images_lowres, images_fullres, targets]) predictions = model(images_lowres, images_fullres) loss = F.mse_loss(predictions, targets) optimizer.zero_grad() loss.backward() optimizer.step() running_metrics = utils.update_metrics( running_metrics, { 'mse': loss.item(), 'psnr': compute_psnr_from_mse(loss) }, print_freq) if (step_num + 1) % print_freq == 0:
def train(self, train_dataset, tokenizer, output_dir): model = BertForSequenceClassification.from_pretrained( '/export/home/yug125/lzh/simple_version/bert-base-uncased') model.to(device()) self.full_train(train_dataset, model, tokenizer, output_dir) return model
from utils import parse_train_args, load_data, device from model import build_model, build_adam_optimizer, build_nllloss_criterion, train_model, save_check_point # Parse command-line arguments args = parse_train_args() # Train and validation data loaders train_data_loader = load_data(args.data_dir, 'train') validation_data_loader = load_data(args.data_dir, 'valid') # Device device = device(args.gpu) # Build model, optimizer, criterion model = build_model(arch=args.arch, hidden_units=args.hidden_units, device=device) optimizer = build_adam_optimizer(model, learning_rate=args.learning_rate) criterion = build_nllloss_criterion() # Train model, evaluate and print result train_model(model, criterion, optimizer, args.epochs, train_data_loader, validation_data_loader, device, 40) # Save check point of the model check_point_file_name_prefix = 'check_point' check_point_file_ext = '.pth' save_check_point( model, optimizer, args.save_dir + '/' + check_point_file_name_prefix + '_' + args.arch + check_point_file_ext)
set_seed(3) # 1. get data train_df = pd.read_csv(TRAIN_FILE, encoding='utf-8', sep='\t') bert_model = BertForSequenceClassification.from_pretrained(ROOT_DATA_PATH) UNCASED = '/export/home/yug125/lzh/simple_version/bert-base-uncased/' # your path for model and vocab VOCAB = 'bert-base-uncased-vocab.txt' tokenizer = BertTokenizer.from_pretrained(os.path.join(UNCASED, VOCAB)) train_dataset = df_to_dataset(train_df, tokenizer, distillation_settings['max_seq_length']) sampler = SequentialSampler(train_dataset) data = DataLoader(train_dataset, sampler=sampler, batch_size=distillation_settings['train_batch_size']) bert_model.to(device()) bert_model.eval() bert_logits = None for batch in tqdm(data, desc="bert logits"): batch = tuple(t.to(device()) for t in batch) inputs = batch_to_inputs(batch) with torch.no_grad(): outputs = bert_model(**inputs) _, logits = outputs[:2] logits = logits.cpu().numpy() if bert_logits is None: bert_logits = logits
def validate(loss_f, net, val_iter, gpu): metrics = [] for val_tuple in val_iter: val_tuple = [t.to(device(gpu)) for t in val_tuple] metrics += [loss_f.metrics(net, *val_tuple)] return [sum(metric) / len(metric) for metric in zip(*metrics)]
def main_UNet_via_Folder(): # Step 01: Get Input Resources and Model Configuration parser = app_argparse() args = parser.parse_args() # INPUT_IMAGE_PATH = args.input_RGB # LABEL_IMAGE_PATH = args.input_GT INPUT_IMAGE_PATH = "data/Aerial/RGBRandom" LABEL_IMAGE_PATH = "data/Aerial/GTRandom" # WEIGHTS_FILE_PATH = args.output_model_path WEIGHTS_FILE_PATH = "weights/Adam.UNet.weights.II.pt" # LOSS_PLOT_PATH = args.output_loss_plot OUTPUT_IMAGE_PATH = args.output_images print(args) use_gpu = args.use_gpu use_pretrain = True # epochs = args.epochs epochs = 10 batch_size = args.batch_size tile_size = args.tile_size learning_rate = args.learning_rate weight_decay = args.weight_decay # Step 02: load the pretrained model device = utils.device(use_gpu=use_gpu) # init model structure model = UNet() # model = utils.load_weights_from_disk(model) if use_pretrain and Path(WEIGHTS_FILE_PATH).is_file(): model = utils.load_entire_model(model, WEIGHTS_FILE_PATH, use_gpu) print("use pretrained model!") else: print("build new model") train_loader = dataset.create_image_loader( image_path=INPUT_IMAGE_PATH, label_path=LABEL_IMAGE_PATH, batch_size=batch_size, shuffle=True # use shuffle ) # turn the shuffle model, stats = train( model=model, train_loader=train_loader, device=device, epochs=epochs, batch_size=batch_size, tile_size=tile_size, learning_rate=learning_rate, weight_decay=weight_decay, ) # comment the following section to compare the results with 4 workers and pin_memory in dataloader. # Step 03: save the model # model_path = utils.save_weights_to_disk(model) model_path = utils.save_entire_model(model, WEIGHTS_FILE_PATH) # save the loss figure and data stats.save_loss_plot(OUTPUT_IMAGE_PATH)
def predict(net, X, gpu): X = X.to(device(gpu)) net.to(device(gpu)) _, pred = net.train(False)(X).max(dim=1) return pred.cpu().numpy()
def unwrap_input(outputs, inputs): return outputs, inputs['class_id'].to(device())
def to_device(text, bert_prob, real_label): text = text.to(device()) bert_prob = bert_prob.to(device()) real_label = real_label.to(device()) return text, bert_prob, real_label