def train_single_model(params): # use GPU if available params['cuda'] = torch.cuda.is_available() # log into the appropriate directory utils.set_logger(os.path.join('train.log')) # Set the random seed for reproducible experiments torch.manual_seed(1337) if params.cuda: torch.cuda.manual_seed(1337) # dynamic import of net net = import_module('model.{}'.format(params.model_name)) model = net.Net(params).cuda() if params.cuda else net.Net(params) if params.cuda and params.multi_gpu == 1 and torch.cuda.device_count() > 1: print('Using', torch.cuda.device_count(), 'GPUs.') model = nn.DataParallel(model) # Create the input data pipeline logging.info("Loading the datasets...") dataloaders = data_loader.fetch_dataloader(['train', 'test'], data_dir, params) train_dl = dataloaders['train'] val_dl = dataloaders['test'] optimizer = optim.Adam(model.parameters(), lr=params.learning_rate) # fetch loss function and metrics loss_fn = net.loss_fn metrics = net.metrics # Train the model logging.info("Starting training for {} epoch(s)".format(params.num_epochs)) train_and_evaluate(model, train_dl, val_dl, optimizer, loss_fn, metrics, params, 'experiments/' + params.exp_name, restore_file)
def main(data_dir, model_dir, restore_file): """ Evaluate the model on the test set. """ # Load the parameters json_path = Path(model_dir) / 'hyper_params.json' assert json_path.is_file( ), "No json configuration file found at {}".format(json_path) hyper_params = utils.HyperParams(json_path) # use GPU if available #hyper_params.cuda = torch.cuda.is_available() # use GPU is available hyper_params.cuda = torch.device( 'cuda:0') if torch.cuda.is_available() else -1 # Set the random seed for reproducible experiments torch.manual_seed(230) if hyper_params.cuda is not -1: with torch.cuda.device(str(hyper_params.cuda)[-1]): torch.cuda.manual_seed(230) # Get the logger utils.set_logger(Path(model_dir) / 'evaluate.log') # Create the input data pipeline logging.info("Creating the dataset...") # fetch dataloaders dataloaders = data_loader.fetch_dataloader( ['test'], data_dir + hyper_params.augmentation, hyper_params) test_dl = dataloaders['test'] logging.info("- done.") # Define the model model = getattr(net, hyper_params.model, None) assert model is not None, "Model {} couldn't be found!".format( hyper_params.model) model = model(hyper_params).to( device=hyper_params.cuda) if hyper_params.cuda is not -1 else model( hyper_params) loss_fn = getattr(loss, hyper_params.loss, None) assert loss_fn is not None, "Loss Fn {} couldn't be found!".format( hyper_params.loss) metrics_dict = metric.metrics_dict logging.info("Starting evaluation") # Reload weights from the saved file utils.load_checkpoint(str(Path(model_dir) / (restore_file + '.pth.tar')), model) # Evaluate test_metrics = evaluate(model, loss_fn, test_dl, metrics_dict, model_dir, hyper_params) save_path = str( Path(model_dir) / "metrics_test_{}.json".format(restore_file)) utils.save_dict_to_json(test_metrics, save_path)
def train(self, data_dir = 'data/GTSDB/', model_dir = 'experiment/', restore = None): print("Loading the datasets...") data = data_loader.fetch_dataloader(['train', 'val'], data_dir, self.params) train_data = data['train'] val_data = data['val'] print("- done.") optimizer = optim.Adam(self.model.parameters(), lr=self.params.learning_rate) loss_fn = net.yolo_v1_loss print("Starting training for {} epoch(s)".format(self.params.num_epochs)) train_fn.train_and_evaluate(self.model, train_data, val_data, optimizer, loss_fn, params, model_dir, restore)
def plot_validation(model): """Plots predictions for whole validation set""" test_loader = data_loader.fetch_dataloader('data/val', batch_size=8) with torch.no_grad(): for images, y, _, fname in tqdm(test_loader): images = images.to(device) outputs = model(images) _, preds = torch.max(outputs.data, 1) preds, y = preds.cpu().numpy(), y.numpy() for b in range(preds.shape[0]): image = plot_fast(preds[b], y[b]) imageio.imwrite('preds/' + fname[b], image.astype(np.uint8))
def runEvaluate(model_dir, data_dir, restore_file): """ Evaluate the model on the test set. """ # Load the parameters 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) # use GPU if available params.cuda = torch.cuda.is_available() # use GPU is available # Set the random seed for reproducible experiments torch.manual_seed(231) if params.cuda: torch.cuda.manual_seed(231) # Get the logger # utils.set_logger(os.path.join(args.model_dir, 'evaluate.log')) # Create the input data pipeline logging.info("Creating the dataset...") # fetch dataloaders dataloaders = data_loader.fetch_dataloader(['train'], args.data_dir, params) test_dl = dataloaders['train'] logging.info("- done.") # Define the model model = net.Net(params).cuda() if params.cuda else net.Net(params) loss_fn = net.loss_fn metrics = net.metrics logging.info("Starting evaluation") # Reload weights from the saved file utils.load_checkpoint( os.path.join(args.model_dir, args.restore_file + '.pth.tar'), model) # Evaluate test_metrics = evaluate(model, loss_fn, test_dl, metrics, params) save_path = os.path.join( args.model_dir, "metrics_training_{}.json".format(args.restore_file)) utils.save_dict_to_json(test_metrics, save_path)
# pdb.set_trace() # use GPU if available params.cuda = torch.cuda.is_available() # Set the random seed for reproducible experiments torch.manual_seed(230) if params.cuda: torch.cuda.manual_seed(230) # Set the logger utils.set_logger(os.path.join(args.model_dir, 'train.log')) # Create the input data pipeline logging.info("Loading the datasets...") # fetch dataloaders dataloaders = data_loader.fetch_dataloader(['train', 'val'], args.data_dir, params) train_dl = dataloaders['train'] val_dl = dataloaders['val'] logging.info("- done.") # Define the model and optimizer model = net.Net(params).cuda() if params.cuda else net.Net(params) optimizer = optim.Adam(model.parameters(), lr=params.learning_rate) # fetch loss function and metrics loss_fn = net.loss_fn metrics = net.metrics # Train the model logging.info("Starting training for {} epoch(s)".format(params.num_epochs))
# Set the random seed for reproducible experiments random.seed(230) torch.manual_seed(230) if params.cuda: torch.cuda.manual_seed(230) # Set the logger utils.set_logger(os.path.join(args.model_dir, 'train.log')) # Create the input data pipeline logging.info("Loading the datasets...") # fetch dataloaders, considering full-set vs. sub-set scenarios if params.subset_percent < 1.0: train_dl = data_loader.fetch_subset_dataloader('train', params) else: train_dl, _ = data_loader.fetch_dataloader('train', params) dev_dl, _ = data_loader.fetch_dataloader('dev', params) logging.info("- done.") """Based on the model_version, determine model/optimizer and KD training mode WideResNet and DenseNet were trained on multi-GPU; need to specify a dummy nn.DataParallel module to correctly load the model parameters """ if "distill" in params.model_version: student_model_load_start = time.time() # train a 5-layer CNN or a 18-layer ResNet with knowledge distillation if params.model_version == "cnn_distill": model = net.Net(params).cuda() if params.cuda else net.Net(params) optimizer = optim.Adam(model.parameters(), lr=params.learning_rate)
os.makedirs(logdir) # copy params as backupt to logdir shutil.copy(json_path, os.path.join(logdir, "params.json")) # utils.set_logger(os.path.join(args.model_dir, 'train.log')) utils.set_logger(os.path.join(logdir, 'train.log')) # Create the input data pipeline logging.info("Loading the datasets...") # fetch dataloaders # dataloaders = data_loader.fetch_dataloader(['train', 'val'], args.data_dir, params) # dataloaders = data_loader.fetch_dataloader(['train', 'val'], "data", params) # dataloaders = data_loader.fetch_dataloader(types = ["train", "valid"]) dataloaders = data_loader.fetch_dataloader(args, params, setting, ["train", "valid"]) train_dl = dataloaders['train'] valid_dl = dataloaders['valid'] if setting.num_classes > 1 and params.balance_classes: train_labels = train_dl.dataset.df[setting.outcome[0]].values class_weights = compute_class_weight('balanced', np.unique(train_labels), train_labels) # valid_dl = train_dl logging.info("- done.") # print("allocated mem after dataloaders %s" % (torch.cuda.max_memory_allocated(0))) # Define the model and optimizer # if covar_mode: # model = net.TNet(params).cuda() if params.cuda else net.TNet(params)
# use GPU if available params.cuda = torch.cuda.is_available() # Set the random seed for reproducible experiments torch.manual_seed(230) if params.cuda: torch.cuda.manual_seed(230) # Set the logger utils.set_logger(os.path.join(args.model_dir, 'train.log')) # Create the input data pipeline logging.info("Loading the datasets...") # fetch dataloaders dataloaders = data_loader.fetch_dataloader(os.getcwd(), params) train_dl = dataloaders['train'] #mini_train_dl = dataloaders['mini-train'] val_dl = dataloaders['val'] #mini_val_dl = dataloaders['mini-val'] logging.info("- done.") if args.model_id == 'resnet50': model = models.resnet50(pretrained=True) elif args.model_id == 'resnet101': model = models.resnet101(pretrained=True) #Freeze First 5 Layers lt = 6 cntr = 0 for child in model.children():
# Set the random seed for reproducible experiments random.seed(230) torch.manual_seed(230) if params.cuda: torch.cuda.manual_seed(230) # Set the logger utils.set_logger(os.path.join(args.model_dir, 'train.log')) # Create the input data pipeline logging.info("Loading the datasets...") # fetch dataloaders, considering full-set vs. sub-set scenarios if params.subset_percent < 1.0: train_dl = data_loader.fetch_subset_dataloader('train', params) else: train_dl = data_loader.fetch_dataloader('train', params) dev_dl = data_loader.fetch_dataloader('dev', params) logging.info("- done.") """Based on the model_version, determine model/optimizer and KD training mode WideResNet and DenseNet were trained on multi-GPU; need to specify a dummy nn.DataParallel module to correctly load the model parameters """ if "distill" in params.model_version: # train a 5-layer CNN or a 18-layer ResNet with knowledge distillation if params.model_version == "cnn_distill": model = net.Net(params).cuda() if params.cuda else net.Net(params) optimizer = optim.Adam(model.parameters(), lr=params.learning_rate)
def fetch_data(datadir, params): """ fetch the dataset dataloaders """ dl = data_loader.fetch_dataloader(['train', 'test'], datadir, params) return dl
#G_optimizer = optim.Adam(paramsG, lr=lr, betas=(0.5, 0.999)) #paramsD = list(D_model.conv4.parameters()) + list(D_model.conv4_bn.parameters()) + list(D_model.conv5.parameters()) #D_optimizer = optim.Adam(paramsD, lr=lr, betas=(0.5, 0.999)) ''' # fetch loss function loss_fn = net.loss_fn # Set the logger utils.set_logger(os.path.join(model_dir, 'train.log')) # Create the input data pipeline logging.info("Loading the datasets...") # data_loader train_loader = data_loader.fetch_dataloader(data_dir, batch_size, dataset) print('dataset length ' + str(len(train_loader.dataset))) # Train the model logging.info("Starting training for {} epoch(s)".format(train_epoch)) train_and_evaluate(param_cuda, dataset, G_model, D_model, G_optimizer, D_optimizer, loss_fn, train_loader, train_epoch, model_dir, restore_file=restore_file)
parameters = utils.Params(json_path) # Record whether GPU is available parameters.cuda = torch.cuda.is_available() # Set random seed for reproducible experiments torch.manual_seed(230) if parameters.cuda: torch.cuda.manual_seed(230) # Configure logger utils.set_logger(os.path.join(arguments.model_dir, 'train.log')) # Create data loaders for training and validation data logging.info('Loading train and validation datasets...') data_loaders = data_loader.fetch_dataloader(['train', 'val'], arguments.data_dir, parameters, arguments.small, arguments.use_tencrop) train_data_loader = data_loaders['train'] validation_data_loader = data_loaders['val'] logging.info('...done.') # Configure model and optimizer model = net.DenseNet169( parameters).cuda() if parameters.cuda else net.DenseNet169(parameters) optimizer = optim.Adam(model.parameters(), lr=parameters.learning_rate, weight_decay=parameters.L2_penalty) # Configure schedule for decaying learning rate scheduler = optim.lr_scheduler.ReduceLROnPlateau( optimizer,
params.cuda = torch.cuda.is_available() # Set the random seed for reproducible experiments torch.manual_seed(230) if params.cuda: torch.cuda.manual_seed(230) # Set the logger utils.set_logger(os.path.join(args.model_dir, 'train.log')) # Create the input data pipeline logging.info("Loading the datasets...") # fetch dataloaders # dataloaders = data_loader.fetch_dataloader(['train', 'val'], args.data_dir, params) # dataloaders = data_loader.fetch_dataloader(['train', 'val'], "data", params) dataloaders = data_loader.fetch_dataloader(types = ["train", "valid"]) # dataloaders = data_loader.fetch_dataloader(types = ["train"]) train_dl = dataloaders['train'] valid_dl = dataloaders['valid'] logging.info("- done.") # Define the model and optimizer model = net.Net(params).cuda() if params.cuda else net.Net(params) optimizer = optim.Adam(model.parameters(), lr=params.learning_rate) # fetch loss function and metrics loss_fn = net.loss_fn metrics = net.metrics
# Record whether GPU is available parameters.cuda = torch.cuda.is_available() # Set random seed for reproducible experiments torch.manual_seed(230) if parameters.cuda: torch.cuda.manual_seed(230) # Configure logger utils.set_logger(os.path.join(arguments.model_dir, 'evaluate_ensemble.log')) # Create data loaders for test data logging.info('Loading test dataset...') test_dataloader = data_loader.fetch_dataloader( ['test'], arguments.data_dir, parameters, arguments.small, arguments.use_tencrop)['test'] logging.info('...done.') # Configure model; return feature vectors on each input densenet_model = net.DenseNet169(parameters, return_features=True) if parameters.cuda: densenet_model = densenet_model.cuda() # Load weights from trained model utils.load_checkpoint( os.path.join(arguments.model_dir, arguments.restore_file + '.pth.tar'), densenet_model) # Features file names are of the form # features_directory/{train, val, test}_features_and_labels.txt # with 'small_' prepended if user specifies '--small'
# 判断GPU是否可用 args.cuda = torch.cuda.is_available() # 设置随机种子来重构实验 torch.manual_seed(230) if args.cuda: print('Training on GPU!') torch.cuda.manual_seed(230) # 创建日志文件 utils.set_logger(os.path.join(args.model_dir, 'train.log')) logging.info("Loading the datasets...") # 获取数据 dataloaders = data_loader.fetch_dataloader(['train', 'val'], args) train_dl = dataloaders['train'] val_dl = dataloaders['val'] logging.info("- done.") # 定义网络结构与优化器 model = net.Net().cuda() if args.cuda else net.Net() optimizer = optim.Adam(model.parameters(), lr=args.learning_rate) # 定义损失函数与指标 loss_fn = net.loss_fn metrics = net.metrics # 训练与评估 logging.info("Starting training for {} epoch(s)".format(args.num_epochs))
parameters = utils.Params(json_path) # Record whether GPU is available parameters.cuda = torch.cuda.is_available() # Set random seed for reproducible experiments torch.manual_seed(230) if parameters.cuda: torch.cuda.manual_seed(230) # Configure logger utils.set_logger(os.path.join(arguments.model_dir, 'train_embedding.log')) # Create data loaders for training and validation data logging.info('Loading train datasets...') data_loaders = data_loader.fetch_dataloader(['train'], arguments.data_dir, parameters, arguments.small, False, True) train_data_loader = data_loaders['train'] logging.info('...done.') # Configure model and optimizer model = net.DenseNet169( parameters, True).cuda() if parameters.cuda else net.DenseNet169( parameters, True) optimizer = optim.Adam(model.parameters(), lr=parameters.learning_rate, weight_decay=parameters.L2_penalty) # Configure schedule for decaying learning rate scheduler = optim.lr_scheduler.ReduceLROnPlateau( optimizer,
# use GPU if available params.cuda = torch.cuda.is_available() # use GPU is available # Set the random seed for reproducible experiments torch.manual_seed(230) if params.cuda: torch.cuda.manual_seed(230) # Get the logger utils.set_logger(os.path.join(args.model_dir, 'evaluate.log')) # Create the input data pipeline logging.info("Loading the dataset...") # fetch dataloaders # train_dl = data_loader.fetch_dataloader('train', params) dev_dl = data_loader.fetch_dataloader('dev', params) logging.info("- done.") # Define the model graph model = resnet.ResNet18().cuda() if params.cuda else resnet.ResNet18() optimizer = optim.SGD(model.parameters(), lr=params.learning_rate, momentum=0.9, weight_decay=5e-4) # fetch loss function and metrics loss_fn_kd = net.loss_fn_kd metrics = resnet.metrics logging.info("Starting evaluation...")
'bin_edges': binedges_list, 'weight_pt_hist': weight_pt_hist, 'weight_eta_hist': weight_eta_hist, 'weight_puppi_hist': weight_puppi_hist, 'weight_CH_hist': weight_CH_hist, 'weight_qT_hist': weight_qT_hist, } utils.save(weights, 'weight.plt') return result if __name__ == '__main__': args = parser.parse_args() dataloaders = data_loader.fetch_dataloader(data_dir=osp.join( os.environ['PWD'], args.data), batch_size=60, validation_split=0.5) train_dl = dataloaders['train'] test_dl = dataloaders['test'] print(len(train_dl), len(test_dl)) #model = net.Net().to('cuda') #model = torch.jit.script(net.Net(7, 3)).to('cuda') # [px, py, pt, eta, d0, dz, mass], [pdgid, charge, fromPV] model = net.Net(8, 3).to('cuda') #optimizer = torch.optim.Adam(model.parameters(), lr=0.001, weight_decay=5e-3) optimizer = torch.optim.AdamW(model.parameters(), lr=0.001) scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer, factor=0.5, patience=500, threshold=0.05)
from util import load_model from torchvision import transforms def test(test_loader, model = None): device = torch.device('cuda:2' if torch.cuda.is_available() else 'cpu') if (model == None): model = load_model(device) correct, total = 0, 0 with torch.no_grad(): for images, _, labels, _ in test_loader: flipped_img = torch.flip(images, [3]).to(device) # horizontal flip of image images, labels = images.to(device), labels.to(device).type(torch.cuda.LongTensor) outputs = model(images) outputs_flipped = torch.flip(model(flipped_img), [3]) avg_output = (outputs + outputs_flipped) / 2 _, predicted = torch.max(avg_output.data, 1) total += labels.shape[0] * labels.shape[1] * labels.shape[2] correct += (predicted == labels).sum().item() return correct, total if __name__ == '__main__': test_loader = data_loader.fetch_dataloader('data/val', batch_size=8) correct, total = test(test_loader) t = datetime.datetime.fromtimestamp(time.time()).strftime('%Y-%m-%d %H:%M:%S') print('Time : {} Accuracy on test data: {:.4f} %'.format(t, 100 * correct / total))
def train_and_evaluate(model, optimizer, scheduler, loss_fn, metrics, params, model_dir, restore_file=None): """Train the model and evaluate every epoch. Args: model: (torch.nn.Module) the neural network train_dataloader: (DataLoader) a torch.utils.data.DataLoader object that fetches training data val_dataloader: (DataLoader) a torch.utils.data.DataLoader object that fetches validation data optimizer: (torch.optim) optimizer for parameters of model loss_fn: a function that takes batch_output and batch_labels and computes the loss for the batch metrics: (dict) a dictionary of functions that compute a metric using the output and labels of each batch params: (Params) hyperparameters model_dir: (string) directory containing config, weights and log restore_file: (string) optional- name of file to restore from (without its extension .pth.tar) """ # reload weights from restore_file if specified if restore_file is not None: restore_path = os.path.join(args.model_dir, args.restore_file + '.pth.tar') logging.info("Restoring parameters from {}".format(restore_path)) utils.load_checkpoint(restore_path, model, optimizer) best_val_loss = 1e10 best_test_loss = 1e10 for epoch in range(params.num_epochs): logging.info("Generate the train and test datasets...") # fetch dataloaders for every epoch dataloaders = data_loader.fetch_dataloader(['train', 'val', 'test'], args.data_dir, params) logging.info("- done.") # Run one epoch logging.info("Epoch {}/{}".format(epoch + 1, params.num_epochs)) # compute number of batches in one epoch (one full pass over the training set) train(model, optimizer, loss_fn, dataloaders['train'], metrics, params) # Evaluate for one epoch on validation set val_metrics = evaluate(model, loss_fn, dataloaders['val'], metrics, params, 'Val') val_loss = val_metrics['rmse'] is_best_val = val_loss <= best_val_loss # Evaluate for one epoch on test set test_metrics = evaluate(model, loss_fn, dataloaders['test'], metrics, params, 'Test') test_loss = test_metrics['rmse'] is_best_test = test_loss <= best_test_loss # Note that step should be called after validation # scheduler.step(val_loss) # for param_group in optimizer.param_groups: # print(param_group['lr']) # Save weights utils.save_checkpoint( { 'epoch': epoch + 1, 'state_dict': model.state_dict(), 'optim_dict': optimizer.state_dict() }, is_best=is_best_val, checkpoint=model_dir) # If best_eval, best_save_path # if is_best and (epoch > params.num_epochs/3): if is_best_val: logging.info("- Found new best val result") best_val_loss = val_loss # Save metrics in a json file in the model directory best_json_path = os.path.join(model_dir, "metrics_val_best_weights.json") utils.save_dict_to_json(val_metrics, best_json_path) if is_best_test: logging.info("- Found new best test result") best_test_loss = test_loss # Save metrics in a json file in the model directory best_json_path = os.path.join(model_dir, "metrics_test_best_weights.json") utils.save_dict_to_json(test_metrics, best_json_path) best_prediction = get_predictions(model, dataloaders['test'], params) with open(os.path.join(args.model_dir, "best_test.pk"), 'wb') as f: pickle.dump(best_prediction, f)
params.cuda = torch.cuda.is_available() # use GPU is available # Set the random seed for reproducible experiments torch.manual_seed(230) if params.cuda: torch.cuda.manual_seed(230) # Get the logger utils.set_logger(os.path.join(args.model_dir, 'analysis.log')) # Create the input data pipeline logging.info("Loading the dataset...") # fetch dataloaders # train_dl = data_loader.fetch_dataloader('train', params) # dev_dl = data_loader.fetch_dataloader('dev', params) dataloader = data_loader.fetch_dataloader(args.dataset, params) logging.info("- done.") # Define the model graph model = resnet.ResNet18().cuda() if params.cuda else resnet.ResNet18() # fetch loss function and metrics metrics = resnet.metrics logging.info("Starting analysis...") # Reload weights from the saved file utils.load_checkpoint(os.path.join(args.model_dir, args.restore_file + '.pth.tar'), model) # Evaluate and analyze
# Set the random seed for reproducible experiments random.seed(230) torch.manual_seed(230) if params.cuda: torch.cuda.manual_seed(230) # Set the logger utils.set_logger(os.path.join(args.model_dir, 'train.log')) # # Create the input data pipeline logging.info("Loading the datasets...") # fetch dataloaders, considering full-set vs. sub-set scenarios if params.subset_percent < 1.0: train_dl = data_loader.fetch_subset_dataloader('train', params) else: train_dl = data_loader.fetch_dataloader('train', params, os.path.join(args.data_dir)) dev_dl = data_loader.fetch_dataloader('dev', params, os.path.join(args.data_dir)) logging.info("- done.") """Based on the model_version, determine model/optimizer and KD training mode WideResNet and DenseNet were trained on multi-GPU; need to specify a dummy nn.DataParallel module to correctly load the model parameters """ if args.model_student == '3CNN': model = net.Net_3CNN(params).cuda() if params.cuda else net.Net(params) print("Model student 3CNN is selected") elif args.model_student == '5CNN': model = net.Net_5CNN(params).cuda() if params.cuda else net.Net(params) print("Model student 5CNN is selected")
import model.net as net import model.data_loader as data_loader import numpy as np import torch.nn as nn import torch if __name__ == '__main__': test_loader = data_loader.fetch_dataloader('/scidata/fruits-360/Test', batch_size=128) device = torch.device('cuda:1' if torch.cuda.is_available() else 'cpu') model = net.Net() model.load_state_dict(torch.load("model.pth")) model.to(device) model.eval() correct, total = 0, 0 with torch.no_grad(): for images, labels in test_loader: images, labels = images.to(device), labels.to(device) outputs = model(images) _, predicted = torch.max(outputs.data, 1) total += labels.size(0) correct += (predicted == labels).sum().item() print('Accuracy on test data: {:.4f} %'.format(100 * correct / total))
if torch.cuda.is_available(): device = "cuda:0" # Set the random seed for reproducible experiments torch.manual_seed(230) if device == "cuda:0": torch.cuda.manual_seed(230) # Set the logger utils.set_logger(os.path.join(model_dir, 'train.log')) # Define the model and optimizer crnn_model = crnn.CRNN(128).cuda() if device == "cuda:0" else crnn.CRNN(128) optimizer = optim.Adam(crnn_model.parameters(), lr=lr, betas=(0.5, 0.999)) # fetch loss function and metrics loss_fn = crnn.loss_fn # Create the input data pipeline logging.info("Loading the datasets...") # fetch dataloaders dataloaders = data_loader.fetch_dataloader(['train', 'val', 'test'], data_dir, batch_size) train_dl = dataloaders['train'] val_dl = dataloaders['val'] test_dl = dataloaders['test'] logging.info("- done.") # Train the model logging.info("Starting training for {} epoch(s)".format(epochs)) train_and_evaluate(crnn_model, train_dl, val_dl, optimizer, loss_fn, model_dir, epochs)
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) params.cuda = torch.cuda.is_available() torch.manual_seed(230) if params.cuda: torch.cuda.manual_seed(230) utils.set_logger(os.path.join(args.model_dir, 'train.log')) logging.info("Loading the datasets...") dataloader = data_loader.fetch_dataloader(['train', 'val'], args.data_dir, args.mask_dir, args.dataset_dir, params) train_dl = dataloader['train'] val_dl = dataloader['val'] logging.info("-done") model = net.FCN(20+1).cuda() if params.cuda else net.FCN(20+1) optimizer = optim.Adam(model.parameters(), lr=params.learning_rate) loss_fn = net.loss_fn metrics = net.metrics logging.info("Starting training for {} epoch(s)".format(params.num_epochs)) train_and_evaluate(model, train_dl, val_dl, optimizer, loss_fn, metrics, params, args.model_dir, args.restore_file)
# use GPU if available params.cuda = torch.cuda.is_available() # use GPU is available # Set the random seed for reproducible experiments torch.manual_seed(230) if params.cuda: torch.cuda.manual_seed(230) # Get the logger utils.set_logger(os.path.join(args.model_dir, 'evaluate.log')) # Create the input data pipeline logging.info("Creating the dataset...") # fetch dataloaders dataloaders = data_loader.fetch_dataloader(['test'], args.data_dir, params) test_dl = dataloaders['test'] logging.info("- done.") # Define the model model = net.Net(params).cuda() if params.cuda else net.Net(params) loss_fn = net.loss_fn metrics = net.metrics logging.info("Starting evaluation") # Reload weights from the saved file utils.load_checkpoint(os.path.join(args.model_dir, args.restore_file + '.pth.tar'), model)
loss = loss_fn(result, data.x, data.y, data.batch) loss.backward() optimizer.step() # update the average loss loss_avg_arr.append(loss.item()) loss_avg.update(loss.item()) t.set_postfix(loss='{:05.3f}'.format(loss_avg())) t.update() scheduler.step(np.mean(loss_avg_arr)) print('Training epoch: {:02d}, MSE: {:.4f}'.format(epoch, np.mean(loss_avg_arr))) if __name__ == '__main__': args = parser.parse_args() dataloaders = data_loader.fetch_dataloader(data_dir=osp.join(os.environ['PWD'],'data'), batch_size=30, validation_split=.1) train_dl = dataloaders['train'] test_dl = dataloaders['test'] #model = net.Net().to('cuda') #model = torch.jit.script(net.Net(7, 3)).to('cuda') # [px, py, pt, eta, d0, dz, mass], [pdgid, charge, fromPV] model = net.Net(8, 3).to('cuda') #optimizer = torch.optim.Adam(model.parameters(), lr=0.001, weight_decay=5e-3) optimizer = torch.optim.AdamW(model.parameters(),lr=0.001) scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer, factor=0.5, patience=500, threshold=0.05) first_epoch = 0 best_validation_loss = 10e7 deltaR = 0.4 loss_fn = net.loss_fn
import model.net as net import model.data_loader as data_loader from preproc import * from util import * from torch import FloatTensor from tqdm import tqdm torch.manual_seed(0) text = open("data/train.txt", "r").read() sent = text.split('\n') corp = CorpusPreprocessor(text) train_loader = data_loader.fetch_dataloader(sent, corp) model = net.net(n_letters, 256, 3, 2, 100) criterion = torch.nn.CrossEntropyLoss() optimizer = torch.optim.Adam(model.parameters(), lr=1e-3) device = torch.device('cuda:1' if torch.cuda.is_available() else 'cpu') model = model.to(device) for epoch in range(10): losss = 0.0 correct, total = 0, 0 for i, (x, z, y) in enumerate(tqdm(train_loader)): x, y, z = sentToTensor(x[0]).to(device), y.to(device), lineToTensor( z[0]).to(device) optimizer.zero_grad() outputs = model(x, z) loss = criterion(outputs, y) losss += loss loss.backward()
def fetch_train_batch(datadir, params): """ fetch a random batch from the trainset """ dl = data_loader.fetch_dataloader(['train'], datadir, params) return iter(dl['train']).next()
'small_' if arguments.small else '') + arguments.dataset_type + '_features_and_labels.txt' features_file_path = os.path.join(arguments.features_directory, features_file_name) # Extract feature vectors and write out to user-specified file (if such file does not yet exist) if os.path.isfile(features_file_path): logging.info('Features file detected; skipping feature extraction') else: logging.info('Features file not detected; now extracting features...') # Create data loader for the revelant part (train, val, or test) of the dataset logging.info('Loading ' + ('small ' if arguments.small else '') + arguments.dataset_type + ' dataset...') train_data_loader = data_loader.fetch_dataloader( [arguments.dataset_type], arguments.data_directory, parameters, arguments.small)[arguments.dataset_type] logging.info('...done.') # Configure model model = net.DenseNet169(parameters, return_features=True) if parameters.cuda: model = model.cuda() # Load weights from trained model utils.load_checkpoint( os.path.join(arguments.model_directory, arguments.restore_file + '.pth.tar'), model) extract_feature_vectors(model, train_data_loader, parameters, features_file_path) logging.info('...done.')
params.cuda = torch.cuda.is_available() # use GPU is available # Set the random seed for reproducible experiments torch.manual_seed(230) if params.cuda: torch.cuda.manual_seed(230) # Get the logger utils.set_logger(os.path.join(args.model_dir, 'analysis.log')) # Create the input data pipeline logging.info("Loading the dataset...") # fetch dataloaders # train_dl = data_loader.fetch_dataloader('train', params) # dev_dl = data_loader.fetch_dataloader('dev', params) dataloader = data_loader.fetch_dataloader(args.dataset, params) logging.info("- done.") # Define the model graph model = resnet.ResNet18().cuda() if params.cuda else resnet.ResNet18() # fetch loss function and metrics metrics = resnet.metrics logging.info("Starting analysis...") # Reload weights from the saved file utils.load_checkpoint(os.path.join(args.model_dir, args.restore_file + '.pth.tar'), model) # Evaluate and analyze