def __init__(self, opt): self.opt = opt dataset = 'cityscapes_seq_full' self.workspace = os.path.join(os.path.dirname(os.path.realpath(__file__)), '..') self.jobname = dataset + '_gpu8_refine_genmask_linklink_256_1node' self.modeldir = self.jobname + 'model' self.sampledir = os.path.join(self.workspace, self.jobname) self.parameterdir = self.sampledir + '/params' self.useHallucination = False if not os.path.exists(self.parameterdir): os.makedirs(self.parameterdir) # whether to start training from an existing snapshot self.load = False self.iter_to_load = 62000 # Write parameters setting file if os.path.exists(self.parameterdir): utils.save_parameters(self) ''' Cityscapes''' train_Dataset = get_training_set(opt) test_Dataset = get_test_set(opt) self.trainloader = DataLoader(train_Dataset, batch_size=opt.batch_size, shuffle=False, num_workers=opt.workers, pin_memory=True, drop_last=True) self.testloader = DataLoader(test_Dataset, batch_size=2, shuffle=False, num_workers=opt.workers, pin_memory=True, drop_last=True)
def model_process(count, model): opt = parse_opts() if opt.root_path != '': opt.video_path = os.path.join(opt.root_path, opt.video_path) opt.annotation_path = os.path.join(opt.root_path, opt.annotation_path) opt.result_path = os.path.join(opt.root_path, opt.result_path) if opt.resume_path: opt.resume_path = os.path.join(opt.root_path, opt.resume_path) if opt.pretrain_path: opt.pretrain_path = os.path.join(opt.root_path, opt.pretrain_path) opt.scales = [opt.initial_scale] for i in range(1, opt.n_scales): opt.scales.append(opt.scales[-1] * opt.scale_step) #opt.arch = '{}-{}'.format(opt.model, opt.model_depth) opt.mean = get_mean(opt.norm_value, dataset=opt.mean_dataset) opt.std = get_std(opt.norm_value) #print(opt) #print(opt.result_path) with open(os.path.join(opt.result_path, 'opts.json'), 'w') as opt_file: json.dump(vars(opt), opt_file) torch.manual_seed(opt.manual_seed) #print(model) criterion = nn.CrossEntropyLoss() if not opt.no_cuda: criterion = criterion.cuda() if opt.no_mean_norm and not opt.std_norm: norm_method = Normalize([0, 0, 0], [1, 1, 1]) elif not opt.std_norm: norm_method = Normalize(opt.mean, [1, 1, 1]) else: norm_method = Normalize(opt.mean, opt.std) print('testing is run') if opt.test: spatial_transform = Compose([ Scale(int(opt.sample_size / opt.scale_in_test)), CornerCrop(opt.sample_size, opt.crop_position_in_test), ToTensor(opt.norm_value), norm_method ]) temporal_transform = LoopPadding(opt.sample_duration) target_transform = VideoID() test_data = get_test_set(opt, spatial_transform, temporal_transform, target_transform) test_loader = torch.utils.data.DataLoader(test_data, batch_size=opt.batch_size, shuffle=False, num_workers=opt.n_threads, pin_memory=True) tester.test(count, test_loader, model, opt, test_data.class_names)
def __init__(self, opt): self.opt = opt print("Random Seed: ", self.opt.seed) torch.manual_seed(self.opt.seed) torch.cuda.manual_seed_all(self.opt.seed) dataset = opt.dataset self.suffix = '_' + opt.suffix self.refine = True self.useHallucination = False self.jobname = dataset + self.suffix self.modeldir = self.jobname + 'model' # whether to start training from an existing snapshot self.load = True self.iter_to_load = opt.iter_to_load ''' Cityscapes''' from cityscapes_dataloader_w_mask_two_path import Cityscapes test_Dataset = get_test_set(opt) self.sampledir = os.path.join( '../city_scapes_test_results', self.jobname, self.suffix + '_' + str(self.iter_to_load) + '_' + str(opt.seed) + '_iterative') if not os.path.exists(self.sampledir): os.makedirs(self.sampledir) self.testloader = DataLoader(test_Dataset, batch_size=opt.batch_size, shuffle=False, pin_memory=True, num_workers=8) # Create Folder for test images. self.output_image_dir = self.sampledir + '_images' self.output_image_dir_before = self.sampledir + '_images_before' self.output_bw_flow_dir = self.sampledir + '_bw_flow' self.output_fw_flow_dir = self.sampledir + '_fw_flow' self.output_bw_mask_dir = self.sampledir + '_bw_mask' self.output_fw_mask_dir = self.sampledir + '_fw_mask' make_save_dir(self.output_image_dir) make_save_dir(self.output_image_dir_before) make_save_dir(self.output_bw_flow_dir) make_save_dir(self.output_fw_flow_dir) make_save_dir(self.output_fw_mask_dir) make_save_dir(self.output_bw_mask_dir)
def build_dataset(self): root_path = "datasets/" train_set = get_training_set(root_path + self.dataset) test_set = get_test_set(root_path + self.dataset) self.training_data_loader = DataLoader(dataset=train_set, num_workers=self.threads, batch_size=self.batch_size, shuffle=True) self.testing_data_loader = DataLoader(dataset=test_set, num_workers=self.threads, batch_size=self.batch_size, shuffle=False)
def load_knifey(): knifey.maybe_download_and_extract() dataset = knifey.load() x_train, y_train_cls, y_train = dataset.get_training_set() x_test, y_test_cls, y_test = dataset.get_test_set() cls_names = dataset.class_names y_train = y_train.astype(np.float32) y_test = y_test.astype(np.float32) y_train_cls = y_train_cls.astype(np.int32) y_test_cls = y_test_cls.astype(np.int32) data = (x_train, y_train_cls, y_train, x_test, y_test_cls, y_test, cls_names) return data
def get_testinfo(opt, norm_method): spatial_transform = Compose([ Scale(opt.sample_size), CenterCrop(opt.sample_size), ToTensor(opt.norm_value), norm_method ]) # temporal_transform = LoopPadding(opt.sample_duration) target_transform = ClassLabel() test_data = get_test_set(opt, spatial_transform, target_transform) test_loader = torch.utils.data.DataLoader( test_data, batch_size=1, # batchsize must be 1 shuffle=False, num_workers=opt.n_threads, pin_memory=True) return test_loader
def __init__(self,in_dir,save_folder=None): # dataset dataset = dataset.load_cached(cache_path='gdrive/My Drive/Colab Notebooks/data/', in_dir=in_dir) # number of classes self.num_classes = dataset.num_classes # get training set image_paths_train, cls_train, self.labels_train = dataset.get_training_set() # get test set image_paths_test, self.cls_test, self.labels_test = dataset.get_test_set() ##############################IMAGE PARAMETERS##################################### self.img_size = 128 self.num_channels = 3 # batch size self.train_batch_size = 64 self.test_batch_size = 64 ################################################################################### # placeholder: setting the matrix(mapping) # @params dtype: data type # @params shape: shape of input data # @params name: name of placeholder # x: feature, x_imange: reshape of feature self.x = tf.placeholder(tf.float32, shape=[None, self.img_size,self.img_size,self.num_channels], name='x') self.x_image = tf.reshape(self.x, [-1, self.img_size, self.img_size, self.num_channels]) # placeholder: setting the matrix(mapping) # y true value self.y_true = tf.placeholder(tf.float32, shape=[None, self.num_classes], name='y_true') # tf.argmax: return the max value self.y_true_cls = tf.argmax(self.y_true, axis=1) #The True class Value self.keep_prob = tf.placeholder(tf.float32) self.keep_prob_2 = tf.placeholder(tf.float32) self.y_pred_cls = None # train images self.train_images= self.load_images(image_paths_train) # test images self.test_images= self.load_images(image_paths_test) self.save_folder=save_folder self.optimizer,self.accuracy = self.define_model()
def test(self, annotation_path='', video_path=''): opt = self.opt if annotation_path != '': opt.annotation_path = annotation_path if opt.root_path != '': opt.annotation_path = os.path.join(opt.root_path, opt.annotation_path) # if video_path != '': # opt.video_path = video_path # if opt.root_path != '': # opt.video_path = os.path.join(opt.root_path, opt.video_path) if not os.path.exists(opt.result_path): os.makedirs(opt.result_path) with open(os.path.join(opt.result_path, 'opts.json'), 'w') as opt_file: json.dump(vars(opt), opt_file) if opt.no_mean_norm and not opt.std_norm: norm_method = Normalize([0, 0, 0], [1, 1, 1]) elif not opt.std_norm: norm_method = Normalize(opt.mean, [1, 1, 1]) else: norm_method = Normalize(opt.mean, opt.std) # original spatial_transform = Compose([ #Scale(opt.sample_size), Scale(112), CenterCrop(112), ToTensor(opt.norm_value), norm_method ]) temporal_transform = TemporalCenterCrop(opt.sample_duration) target_transform = ClassLabel() test_data = get_test_set(opt, spatial_transform, temporal_transform, target_transform) test_loader = torch.utils.data.DataLoader(test_data, batch_size=opt.batch_size, shuffle=False, num_workers=opt.n_threads, pin_memory=True) test_logger = Logger(os.path.join(opt.result_path, 'test.log'), ['top1', 'precision', 'recall']) if opt.resume_path: print('loading checkpoint {}'.format(opt.resume_path)) checkpoint = torch.load(opt.resume_path) assert opt.arch == checkpoint['arch'] opt.begin_epoch = checkpoint['epoch'] self.model.load_state_dict(checkpoint['state_dict']) recorder = [] self.model.eval() batch_time = AverageMeter() top1 = AverageMeter() precisions = AverageMeter() recalls = AverageMeter() y_true = [] y_pred = [] end_time = time.time() for i, (inputs, targets) in enumerate(test_loader): if not opt.no_cuda: targets = targets.cuda(non_blocking=True) #inputs = Variable(torch.squeeze(inputs), volatile=True) with torch.no_grad(): inputs = Variable(inputs) targets = Variable(targets) outputs = self.model(inputs) if not opt.no_softmax_in_test: outputs = F.softmax(outputs, dim=1) recorder.append(outputs.data.cpu().numpy().copy()) y_true.extend(targets.cpu().numpy().tolist()) y_pred.extend(outputs.argmax(1).cpu().numpy().tolist()) _cls = outputs.argmax(1).cpu().numpy().tolist()[0] prec1 = self.calculate_accuracy(outputs, targets, topk=(1, )) precision = calculate_precision(outputs, targets) recall = calculate_recall(outputs, targets) top1.update(prec1[0], inputs.size(0)) precisions.update(precision, inputs.size(0)) recalls.update(recall, inputs.size(0)) batch_time.update(time.time() - end_time) end_time = time.time() test_logger.log({ 'top1': top1.avg, 'precision': precisions.avg, 'recall': recalls.avg }) print('-----Evaluation is finished------') print('Overall Prec@1 {:.05f}%'.format(top1.avg * 100)) return y_pred, y_true, test_data
# Height and width of inputs # sample_size = 224 # 因为dataset已经resize过,不用resize了 # Number of validation samples for each activity n_val_samples = 3 video_path = '/data1/guoxi/p3d_floder/resized_dataset/dataset/' mean = [0.485, 0.456, 0.406] std = [0.229, 0.224, 0.225] norm_method = Normalize(mean, std) spatial_transform = Compose([ToTensor(norm_value=norm_value), norm_method]) # temporal_transform = LoopPadding(sample_duration) # padding transform 如果不够16帧扩容到16帧 target_transform = Compose([ToTensor(norm_value=norm_value)]) opt = [video_path, sample_duration] test_data = dataset.get_test_set(opt, spatial_transform, target_transform, split='val') test_loader = torch.utils.data.DataLoader(test_data, batch_size=batch_size, shuffle=False, num_workers=n_threads, pin_memory=True) model = network_seg.P3D199() model = torch.nn.DataParallel(model) state_dict = torch.load(weight_path) model.load_state_dict(state_dict['state_dict']) model = model.cuda() model.eval() for clip_sets, name_video, names_frames, total_mask in test_loader: # print('clip_sets = ') # print(clip_sets) # print('name_video = ')
def main(): save_path = '../result/mask_matlab/' if not os.path.exists(save_path): os.mkdir(save_path) batch_size = 1 n_threads = 1 # 'Temporal duration of inputs' sample_duration = 16 # the data for devision norm_value = 255 # Height and width of inputs # sample_size = 224 # 因为dataset已经resize过,不用resize了 # Number of validation samples for each activity n_val_samples = 3 video_path = '/data1/guoxi/p3d_floder/resized_dataset/dataset/' mean = [0.485, 0.456, 0.406] std = [0.229, 0.224, 0.225] norm_method = Normalize(mean, std) spatial_transform = Compose([ToTensor(norm_value=norm_value), norm_method]) # temporal_transform = LoopPadding(sample_duration) # padding transform 如果不够16帧扩容到16帧 target_transform = Compose([ToTensor(norm_value=norm_value)]) opt = [video_path, sample_duration] test_data = dataset.get_test_set(opt, spatial_transform, target_transform, split='val') test_loader = torch.utils.data.DataLoader(test_data, batch_size=batch_size, shuffle=False, num_workers=n_threads, pin_memory=True) model = network_seg.P3D199() model = torch.nn.DataParallel(model) weight_path = '../result/model/P3D_saliency/weights/best_weights.pth' state_dict = torch.load(weight_path) model.load_state_dict(state_dict['state_dict']) model = model.cuda() model.eval() for clip_sets, name_video, names_frames, total_mask in test_loader: # print('clip_sets = ') # print(clip_sets) # print('name_video = ') # print(name_video) # print('names_frames = ') # print(names_frames) # result # clip_sets =[tensor([[[[[0.6049, 0.9817, 1.2214, ..., -0.9534, -0.9705, -1.0562],.... # name_video =['d2857f0faa'] # names_frames =[['00000'], ['00005'], ['00010'], ['00015'], ['00020'], ['00025'], ['00030'], ['00035'], ['00040'], ['00045'], # ['00050'], ['00055'], ['00060'], ['00065'], ['00070'], ['00075'], ['00080'], ['00085'], ['00090'], ['00095'], # ['00100'], ['00105'], ['00110'], ['00115'], ['00120'], ['00125'], ['00130'], ['00135'], ['00140'], ['00145'], # ['00150'], ['00155'], ['00160'], ['00165'], ['00170'], ['00175']] for iord, clip_set in enumerate(clip_sets[:-1]): #i_order for mask_tol_num, clip in enumerate(clip_set): with torch.no_grad(): masks = model(clip.cuda()) masks.squeeze_() for j in range(sample_duration): order = iord * sample_duration + j mask_path = save_path + name_video[0] + '/' + str( mask_tol_num + 1) + '/' if not os.path.exists(mask_path): os.makedirs(mask_path) mask_save_path = mask_path + names_frames[order][0] + '.png' mask = masks[j, :, :] mask_numpy = mask.data.cpu().numpy() mask_numpy = mask_numpy * 255 mask_numpy = mask_numpy.astype(np.uint8) pure_mask = Image.fromarray(mask_numpy, mode='L') pure_mask.save(mask_save_path) # dispose the last clip clip_set = clip_sets[-1] for mask_tol_num, clip in enumerate(clip_set): with torch.no_grad(): masks = model(clip.cuda()) masks.squeeze_() for j in range(-1, -1 - sample_duration, -1): mask_path = save_path + name_video[0] + '/' + str( mask_tol_num + 1) + '/' if not os.path.exists(mask_path): os.makedirs(mask_path) mask_save_path = mask_path + names_frames[j][0] + '.png' mask = masks[j, :, :] mask_numpy = mask.data.cpu().numpy() mask_numpy = mask_numpy * 255 mask_numpy = mask_numpy.astype(np.uint8) pure_mask = Image.fromarray(mask_numpy, mode='L') pure_mask.save(mask_save_path)
print('run') for i in range(opt.begin_epoch, opt.n_epochs + 1): if not opt.no_train: train_epoch(i, train_loader, model, criterion, optimizer, opt, train_logger, train_batch_logger) if not opt.no_val: validation_loss = val_epoch(i, val_loader, model, criterion, opt, val_logger) if not opt.no_train and not opt.no_val: scheduler.step(validation_loss) if opt.test: spatial_transform = Compose([ Scale(int(opt.sample_size / opt.scale_in_test)), CornerCrop(opt.sample_size, opt.crop_position_in_test), ToTensor(opt.norm_value), norm_method ]) temporal_transform = LoopPadding(opt.sample_duration) target_transform = VideoID() test_data = get_test_set(opt, spatial_transform, temporal_transform, target_transform) test_loader = torch.utils.data.DataLoader( test_data, batch_size=opt.batch_size, shuffle=False, num_workers=opt.n_threads, pin_memory=True) test.test(test_loader, model, opt, test_data.class_names)
def objective(trial): opt = parse_opts() if trial: opt.weight_decay = trial.suggest_uniform('weight_decay', 0.01, 0.1) opt.learning_rate = trial.suggest_uniform('learning_rate', 1 - 5, 1 - 4) if opt.root_path != '': opt.video_path = os.path.join(opt.root_path, opt.video_path) opt.annotation_path = os.path.join(opt.root_path, opt.annotation_path) opt.result_path = os.path.join(opt.root_path, opt.result_path) if opt.resume_path: opt.resume_path = os.path.join(opt.root_path, opt.resume_path) if opt.pretrain_path: opt.pretrain_path = os.path.join(opt.root_path, opt.pretrain_path) opt.scales = [opt.initial_scale] for i in range(1, opt.n_scales): opt.scales.append(opt.scales[-1] * opt.scale_step) opt.arch = '{}-{}'.format(opt.model, opt.model_depth) opt.mean = get_mean(opt.norm_value, dataset=opt.mean_dataset) opt.std = get_std(opt.norm_value) print(opt) with open(os.path.join(opt.result_path, 'opts.json'), 'w') as opt_file: json.dump(vars(opt), opt_file) torch.manual_seed(opt.manual_seed) model, parameters = generate_model(opt) print(model) criterion = nn.CrossEntropyLoss() if not opt.no_cuda: criterion = criterion.cuda() if opt.no_mean_norm and not opt.std_norm: norm_method = Normalize([0, 0, 0], [1, 1, 1]) elif not opt.std_norm: norm_method = Normalize(opt.mean, [1, 1, 1]) else: norm_method = Normalize(opt.mean, opt.std) # norm_method = Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)) if not opt.no_train: assert opt.train_crop in ['random', 'corner', 'center'] if opt.train_crop == 'random': crop_method = MultiScaleRandomCrop(opt.scales, opt.sample_size) elif opt.train_crop == 'corner': crop_method = MultiScaleCornerCrop(opt.scales, opt.sample_size) elif opt.train_crop == 'center': crop_method = MultiScaleCornerCrop(opt.scales, opt.sample_size, crop_positions=['c']) spatial_transform = Compose([ crop_method, RandomHorizontalFlip(), ToTensor(opt.norm_value), norm_method ]) temporal_transform = TemporalRandomCrop(opt.sample_duration) target_transform = ClassLabel() training_data = get_training_set(opt, spatial_transform, temporal_transform, target_transform) train_loader = torch.utils.data.DataLoader( training_data, batch_size=opt.batch_size, # sampler option is mutually exclusive with shuffle shuffle=False, sampler=ImbalancedDatasetSampler(training_data), num_workers=opt.n_threads, pin_memory=True) train_logger = Logger(os.path.join(opt.result_path, 'train.log'), ['epoch', 'loss', 'acc', 'lr']) train_batch_logger = Logger( os.path.join(opt.result_path, 'train_batch.log'), ['epoch', 'batch', 'iter', 'loss', 'acc', 'lr']) optimizer = optim.Adam(parameters, lr=opt.learning_rate, weight_decay=opt.weight_decay) scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer, verbose=True, factor=0.1**0.5) if not opt.no_val: spatial_transform = Compose([ Scale(opt.sample_size), CenterCrop(opt.sample_size), ToTensor(opt.norm_value), norm_method ]) temporal_transform = LoopPadding(opt.sample_duration) target_transform = ClassLabel() validation_data = get_validation_set(opt, spatial_transform, temporal_transform, target_transform) val_loader = torch.utils.data.DataLoader( validation_data, batch_size=opt.batch_size, shuffle=False, sampler=ImbalancedDatasetSampler(validation_data), num_workers=opt.n_threads, pin_memory=True) val_logger = Logger(os.path.join(opt.result_path, 'val.log'), ['epoch', 'loss', 'acc']) if opt.resume_path: print('loading checkpoint {}'.format(opt.resume_path)) checkpoint = torch.load(opt.resume_path) assert opt.arch == checkpoint['arch'] opt.begin_epoch = checkpoint['epoch'] model.load_state_dict(checkpoint['state_dict']) if not opt.no_train: optimizer.load_state_dict(checkpoint['optimizer']) print('run') writer = SummaryWriter( comment= f"_wd{opt.weight_decay}_lr{opt.learning_rate}_ft_begin{opt.ft_begin_index}_pretrain{not opt.pretrain_path == ''}" ) for i in range(opt.begin_epoch, opt.n_epochs + 1): if not opt.no_train: epoch, losses_avg, accuracies_avg = train_epoch( i, train_loader, model, criterion, optimizer, opt, train_logger, train_batch_logger) writer.add_scalar('loss/train', losses_avg, epoch) writer.add_scalar('acc/train', accuracies_avg, epoch) if not opt.no_val: epoch, val_losses_avg, val_accuracies_avg = val_epoch( i, val_loader, model, criterion, opt, val_logger) writer.add_scalar('loss/val', val_losses_avg, epoch) writer.add_scalar('acc/val', val_accuracies_avg, epoch) if not opt.no_train and not opt.no_val: scheduler.step(val_losses_avg) print('=' * 100) if opt.test: spatial_transform = Compose([ Scale(int(opt.sample_size / opt.scale_in_test)), CornerCrop(opt.sample_size, opt.crop_position_in_test), ToTensor(opt.norm_value), norm_method ]) temporal_transform = LoopPadding(opt.sample_duration) target_transform = VideoID() test_data = get_test_set(opt, spatial_transform, temporal_transform, target_transform) test_loader = torch.utils.data.DataLoader(test_data, batch_size=opt.batch_size, shuffle=False, num_workers=opt.n_threads, pin_memory=True) test.test(test_loader, model, opt, test_data.class_names) writer.close() return val_losses_avg
max_sequence_length=getattr(config, "max_sequence_length", 500), max_title_length=getattr(config, "max_title_length", 26), max_question_length=getattr(config, "max_question_length", 260), max_answer_length=getattr(config, "max_answer_length", 210), head_tail=getattr(config, "head_tail", True), use_folds=None, model_type=config.model_type, ) if original_args.model_type == "bert": tokenizer = BertTokenizer.from_pretrained( original_args.bert_model, do_lower_case=("uncased" in args.bert_model)) elif original_args.model_type == "roberta": tokenizer = RobertaTokenizer.from_pretrained(original_args.bert_model) test_set = get_test_set(original_args, test_df, tokenizer) test_loader = DataLoader(test_set, batch_size=original_args.batch_size, shuffle=False) if not os.path.exists(args.output_dir): os.makedirs(args.output_dir) for fold in range(config.folds): print() print("Fold:", fold) print() fold_checkpoints = os.path.join(experiment.checkpoints, "fold{}".format(fold))
logging.getLogger("transformers").setLevel(logging.ERROR) seed_everything(args.seed) # load the data train_df = pd.read_csv(os.path.join(args.data_path, "train.csv")) test_df = pd.read_csv(os.path.join(args.data_path, "test.csv")) submission = pd.read_csv(os.path.join(args.data_path, "sample_submission.csv")) if args.model_type == "bert": tokenizer = BertTokenizer.from_pretrained( args.bert_model, do_lower_case=("uncased" in args.bert_model)) elif args.model_type == "roberta": tokenizer = RobertaTokenizer.from_pretrained(args.bert_model) test_set = get_test_set(args, test_df, tokenizer) test_loader = DataLoader(test_set, batch_size=args.batch_size, shuffle=False) for fold, train_set, valid_set, train_fold_df, val_fold_df in cross_validation_split( args, train_df, tokenizer): print() print("Fold:", fold) print() valid_loader = DataLoader(valid_set, batch_size=args.batch_size, shuffle=False, drop_last=False) fold_checkpoints = os.path.join(experiment.checkpoints,
def train_and_evaluate(net_name="aein_net", epochs = 250, train_batch_size=64, learning_rate=1e-3, optimizer="adam"): train_set_size = 680 val_test_set_size = 340 input_width = input_height = 224 channel = 3 output_size = 17 train_set_1 = dataset.get_train_set(1) train_set_1 = train_set_1.shuffle(buffer_size=10000) train_set_1 = train_set_1.batch(train_batch_size) validation_set_1 = dataset.get_validation_set(1) validation_set_1 = validation_set_1.batch(68) test_set_1 = dataset.get_test_set(1) test_set_1 = test_set_1.batch(68) X = tf.placeholder(tf.float32, [None, input_height, input_width, channel]) if net_name == 'aein_net': y_pred = aein_net.aein_net(X) elif net_name == 'alex_net': y_pred = alex_net.alex_net(X) elif net_name == 'vgg_16': y_pred = vgg_16.vgg_16(X) else: y_pred = aein_net.aein_net(X) y_true = tf.placeholder(tf.float32, [None, output_size]) loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=y_pred, labels=y_true)) if optimizer == 'adam': optimizer = tf.train.AdamOptimizer(learning_rate) elif optimizer == 'momentum': optimizer = tf.train.MomentumOptimizer(learning_rate, 0.9) elif optimizer == 'gradient_descent': optimizer = tf.train.GradientDescentOptimizer(learning_rate) elif optimizer == 'rmsprop': optimizer = tf.train.RMSPropOptimizer(learning_rate) else: optimizer = tf.train.AdamOptimizer(learning_rate) update_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS) with tf.control_dependencies(update_ops): train_op = optimizer.minimize(loss) itr_trn_1 = train_set_1.make_initializable_iterator() next_element_trn_1 = itr_trn_1.get_next() with tf.Session() as sess: sess.run(tf.global_variables_initializer()) start_train_time = time.time() accuracies = [] losses = [] epochs_arr = [] epochs_10_arr = [] print("Start to train classifier, model: " + net_name) for epoch in range(epochs): print("------------------ Epoch %d starts ------------------" % (epoch + 1)) sess.run(itr_trn_1.initializer) batch_idx = 1 while True: try: X_batch, Y_batch = sess.run(next_element_trn_1) last_train_op_time = time.time() _, l = sess.run([train_op, loss], feed_dict={X: X_batch, y_true: Y_batch}) losses.append(l) epochs_arr.append(epoch) print("epoch: %d, batch: %d, loss: %f, time cost: %f" % ( epoch + 1, batch_idx, l, time.time() - last_train_op_time)) batch_idx += 1 except tf.errors.OutOfRangeError: # this epoch ends break if (epoch + 1) % 10 == 0: print() print("------------------ evaluating accuracy on validation set ------------------") accuracy = utils.evaluate(validation_set_1, sess, X, y_true, y_pred) print("accuracy: %f" % accuracy) print() accuracies.append(accuracy) epochs_10_arr.append(epoch + 1) print("Classifier has been trained, total time: %f" % (time.time() - start_train_time)) print() print("------------------ evaluating accuracy on test set ------------------") print("accuracy: %f" % utils.evaluate(test_set_1, sess, X, y_true, y_pred)) print() utils.save_result(net_name, epochs_arr, losses, epochs_10_arr, accuracies)
print(opt) if opt.cuda and not torch.cuda.is_available(): raise Exception("No GPU found, please run without --cuda") cudnn.benchmark = True torch.manual_seed(opt.seed) if opt.cuda: torch.cuda.manual_seed(opt.seed) print('===> Loading datasets') train_set = get_training_set() test_set = get_test_set() training_data_loader = DataLoader(dataset=train_set, num_workers=opt.threads, batch_size=opt.batchSize, shuffle=True) testing_data_loader = DataLoader(dataset=test_set, num_workers=opt.threads, batch_size=opt.testBatchSize, shuffle=False) print('===> Building model') netG = define_G(opt.input_nc, opt.output_nc, opt.ngf, 'batch', False, [0]) netD = define_D(opt.input_nc + opt.output_nc, opt.ndf, 'batch', False, [0]) criterionGAN = GANLoss()
def main(): resnet_in = generate_model(opt) resnet_in.module.fc = Identity() model = ReNet34(resnet_in, encode_length=encode_length) if opt.no_mean_norm and not opt.std_norm: norm_method = Normalize([0, 0, 0], [1, 1, 1]) elif not opt.std_norm: norm_method = Normalize(opt.mean, [1, 1, 1]) else: norm_method = Normalize(opt.mean, opt.std) if not opt.no_train: assert opt.train_crop in ['random', 'corner', 'center'] if opt.train_crop == 'random': crop_method = MultiScaleRandomCrop(opt.scales, opt.sample_size) elif opt.train_crop == 'corner': crop_method = MultiScaleCornerCrop(opt.scales, opt.sample_size) elif opt.train_crop == 'center': crop_method = MultiScaleCornerCrop(opt.scales, opt.sample_size, crop_positions=['c']) ## train loader spatial_transform = Compose([ crop_method, RandomHorizontalFlip(), ToTensor(opt.norm_value), norm_method ]) temporal_transform = TemporalRandomCrop(opt.sample_duration) target_transform = ClassLabel() training_data = get_training_set(opt, spatial_transform, temporal_transform, target_transform) train_loader = torch.utils.data.DataLoader(training_data, batch_size=opt.batch_size, shuffle=True, num_workers=opt.n_threads, pin_memory=True) ## test loader spatial_transform = Compose([ Scale(int(opt.sample_size / opt.scale_in_test)), CornerCrop(opt.sample_size, opt.crop_position_in_test), ToTensor(opt.norm_value), norm_method ]) temporal_transform = LoopPadding(opt.sample_duration) target_transform = ClassLabel() test_data = get_test_set(opt, spatial_transform, temporal_transform, target_transform) test_loader = torch.utils.data.DataLoader(test_data, batch_size=opt.batch_size, shuffle=False, num_workers=opt.n_threads, pin_memory=True) ## Database loader spatial_transform = Compose([ Scale(int(opt.sample_size / opt.scale_in_test)), CornerCrop(opt.sample_size, opt.crop_position_in_test), ToTensor(opt.norm_value), norm_method ]) temporal_transform = LoopPadding(opt.sample_duration) target_transform = ClassLabel() validation_data = get_validation_set(opt, spatial_transform, temporal_transform, target_transform) database_loader = torch.utils.data.DataLoader( validation_data, batch_size=opt.batch_size, shuffle=False, num_workers=opt.n_threads, pin_memory=True) if opt.nesterov: dampening = 0 else: dampening = opt.dampening optimizer = optim.SGD(model.parameters(), lr=opt.learning_rate, momentum=opt.momentum, dampening=dampening, weight_decay=opt.weight_decay, nesterov=opt.nesterov) scheduler = lr_scheduler.ReduceLROnPlateau(optimizer, 'min', patience=opt.lr_patience) if opt.resume_path: print('loading checkpoint {}'.format(opt.resume_path)) checkpoint = torch.load(opt.resume_path) assert opt.arch == checkpoint['arch'] opt.begin_epoch = checkpoint['epoch'] model.load_state_dict(checkpoint['state_dict']) if not opt.no_train: optimizer.load_state_dict(checkpoint['optimizer']) for state in optimizer.state.values(): for k, v in state.items(): if torch.is_tensor(v): state[k] = v.cuda() print('run') for epoch in range(opt.begin_epoch, opt.n_epochs + 1): model.cuda().train() for i, (images, labels) in enumerate(train_loader): images = Variable(images.cuda()) labels = Variable(labels.cuda().long()) # Forward + Backward + Optimize optimizer.zero_grad() x, _, b = model(images) target_b = F.cosine_similarity(b[:int(labels.size(0) / 2)], b[int(labels.size(0) / 2):]) target_x = F.cosine_similarity(x[:int(labels.size(0) / 2)], x[int(labels.size(0) / 2):]) loss = F.mse_loss(target_b, target_x) loss.backward() optimizer.step() scheduler.step() # Test the Model if (epoch + 1) % 10 == 0: model.eval() retrievalB, retrievalL, queryB, queryL = compress( database_loader, test_loader, model) result_map = calculate_top_map(qB=queryB, rB=retrievalB, queryL=queryL, retrievalL=retrievalL, topk=100) print('--------mAP@100: {}--------'.format(result_map))
def main(): save_path = '../result/mask_added/' tem_path = '../result/mask_add_tem/' batch_size = 1 n_threads = 1 # 'Temporal duration of inputs' sample_duration = 16 # the data for devision norm_value = 255 # Height and width of inputs # sample_size = 224 # 因为dataset已经resize过,不用resize了 # Number of validation samples for each activity n_val_samples = 3 video_path = '/data1/guoxi/p3d_floder/resized_dataset/dataset/' mean = [0.485, 0.456, 0.406] std = [0.229, 0.224, 0.225] norm_method = Normalize(mean, std) spatial_transform = Compose([ToTensor(norm_value=norm_value), norm_method]) # temporal_transform = LoopPadding(sample_duration) # padding transform 如果不够16帧扩容到16帧 target_transform = Compose([ToTensor(norm_value=norm_value)]) opt = [video_path, sample_duration] test_data = dataset.get_test_set(opt, spatial_transform, target_transform, split='val') test_loader = torch.utils.data.DataLoader(test_data, batch_size=batch_size, shuffle=False, num_workers=n_threads, pin_memory=True) # inputs, name_video, names_frames = next(iter(test_loader)) # print('type(name_video):', type(name_video[0]), len(name_video)) # print(name_video[0]) # print('type(names_frames):', type(names_frames), len(names_frames)) # print(names_frames[0]) # print('inputs.size(), targets.size():', inputs.size(), targets.size()) model = network_seg.P3D199() model = torch.nn.DataParallel(model) weight_path = '../result/model/P3D_saliency/weights/best_weights.pth' state_dict = torch.load(weight_path) model.load_state_dict(state_dict['state_dict']) model = model.cuda() model.eval() for clip_sets, name_video, names_frames, total_mask in test_loader: # print('clip_sets = ') # print(clip_sets) # print('name_video = ') # print(name_video) # print('names_frames = ') # print(names_frames) # result # clip_sets =[tensor([[[[[0.6049, 0.9817, 1.2214, ..., -0.9534, -0.9705, -1.0562],.... # name_video =['d2857f0faa'] # names_frames =[['00000'], ['00005'], ['00010'], ['00015'], ['00020'], ['00025'], ['00030'], ['00035'], ['00040'], ['00045'], # ['00050'], ['00055'], ['00060'], ['00065'], ['00070'], ['00075'], ['00080'], ['00085'], ['00090'], ['00095'], # ['00100'], ['00105'], ['00110'], ['00115'], ['00120'], ['00125'], ['00130'], ['00135'], ['00140'], ['00145'], # ['00150'], ['00155'], ['00160'], ['00165'], ['00170'], ['00175']] # count = -1 for iord, clip_set in enumerate(clip_sets[:-1]): #i_order # print(' ') # count += 1 # print(clip_sets[count]) # print(iord) # print(clip) # print('clip.size(), clip.max(), clip.min():', clip.size(), clip.max(), clip.min()) # torch.Size([1, 3, 16, 224, 224]) for mask_tol_num, clip in enumerate(clip_set): # print(clip.size()) with torch.no_grad(): masks = model(clip.cuda()) # print(masks.size()) masks.squeeze_() # print(masks.size()) # print('masks.size(), masks.max(), masks.min():') # print(masks.size(), masks.max(), masks.min()) for j in range(sample_duration): order = iord * sample_duration + j mask_save_path = tem_path + name_video[ 0] + '/' + names_frames[order][0] + '/' if not os.path.exists(mask_save_path): os.makedirs(mask_save_path) mask_name = str(mask_tol_num + 1) + '.png' # print(mask_name) mask_path = mask_save_path + mask_name mask = masks[j, :, :] # print(mask.size()) # mask.unsqueeze_(dim=0) # print(mask.size()) # mask.unsqueeze_(dim=0) # print(mask.size()) # mask *= 255 # print('masks.size(), masks.max(), masks.min():') # print(mask.size(), mask.max(), mask.min()) # torchvision.utils.save_image(mask, mask_path) # print(mask) mask_numpy = mask.data.cpu().numpy() # print(mask_numpy) mask_numpy = mask_numpy * 255 mask_numpy = mask_numpy.astype(np.uint8) # print(mask.size()) # mask.unsqueeze_(dim=0) # print(mask.size()) # mask.unsqueeze_(dim=0) # print(mask.size()) # mask *= 255 # print('masks.size(), masks.max(), masks.min():') # print(mask.size(), mask.max(), mask.min()) # torchvision.utils.save_image(mask, mask_path) # print(mask) # print(type(mask)) <class 'torch.Tensor'> # print(mask.dtype) torch.float32 # print((mask>1).nonzero()) [] pure_mask = Image.fromarray(mask_numpy, mode='L') pure_mask.save(mask_path) # dispose the last clip clip_set = clip_sets[-1] for mask_tol_num, clip in enumerate(clip_set): with torch.no_grad(): masks = model(clip.cuda()) masks.squeeze_() for j in range(-1, -1 - sample_duration, -1): mask_save_path = tem_path + name_video[0] + '/' + names_frames[ j][0] + '/' if not os.path.exists(mask_save_path): os.makedirs(mask_save_path) mask_name = str(mask_tol_num + 1) + '.png' # print(mask_name) mask_path = mask_save_path + mask_name mask = masks[j, :, :] # print(mask.size()) # mask.unsqueeze_(dim=0) # print(mask.size()) # mask.unsqueeze_(dim=0) # torchvision.utils.save_image(mask, mask_path) # print(mask) mask_numpy = mask.data.cpu().numpy() # print(mask_numpy) mask_numpy = mask_numpy * 255 mask_numpy = mask_numpy.astype(np.uint8) # print(mask.size()) # mask.unsqueeze_(dim=0) # print(mask.size()) # mask.unsqueeze_(dim=0) # print(mask.size()) # mask *= 255 # print('masks.size(), masks.max(), masks.min():') # print(mask.size(), mask.max(), mask.min()) # torchvision.utils.save_image(mask, mask_path) # print(mask) # print(type(mask)) <class 'torch.Tensor'> # print(mask.dtype) torch.float32 # print((mask>1).nonzero()) [] pure_mask = Image.fromarray(mask_numpy, mode='L') pure_mask.save(mask_path) print('Done with evaluation') print('make data now') fol_set = os.listdir(tem_path) fol_set.sort() for fol_name in fol_set: img_rp = tem_path + fol_name + '/' img_set = os.listdir(img_rp) img_set.sort() for img_name in img_set: sep_img_rp = img_rp + img_name + '/' sep_img_set = os.listdir(sep_img_rp) sep_img_set.sort() mask_added = np.zeros((224, 224), dtype=np.float32) # dtype? for sep_img_name in sep_img_set: mask_rp = sep_img_rp + sep_img_name mask = Image.open(mask_rp) # print(mask.mode) mask_tem = np.asarray(mask, dtype=np.float32) mask_added = mask_added + mask_tem mask_added = mask_added.astype(np.uint8) mask_save_path = save_path + fol_name + '_' + img_name + '.png' mask_added_final = Image.fromarray(mask_added, mode='L') mask_added_final.save(mask_save_path)
temporal_transform = ShuffleFrames(opt.sample_duration) else: temporal_transform = LoopPadding(opt.sample_duration) temp_crop_method = TemporalRandomCrop(opt.sample_duration) # else: # temp_crop_method = TemporalSparseSample(opt.sample_duration) # if opt.test_reverse: # temporal_transform = Compose([ # temp_crop_method, # ReverseFrames(opt.sample_duration)]) # elif opt.test_shuffle: # temporal_transform = Compose([ # temp_crop_method, # ShuffleFrames(opt.sample_duration)]) # else: # temporal_transform = temp_crop_method target_transform = VideoID() test_data = get_test_set(opt, spatial_transform, temporal_transform, target_transform, inner_temp_transform=temp_crop_method) test_loader = torch.utils.data.DataLoader(test_data, batch_size=opt.batch_size, shuffle=False, num_workers=opt.n_threads, pin_memory=True) test.test(test_loader, model, opt, test_data.class_names)
in_planes=2) parameters = flow_model.parameters pytorch_total_params = sum(p.numel() for p in flow_model.parameters() if p.requires_grad) print("Total number of RGBmodel trainable parameters: ", pytorch_total_params) print(flow_model) spatial_transform = Compose([ Scale((opt.sample_size, opt.sample_size)), # MultiScaleCornerCrop(opt.scales, opt.sample_size, crop_positions=['c']), ToTensor(opt.norm_value) ]) transform_flow = Compose([ToTensor(opt.norm_value)]) RGB_test_data = get_test_set(opt, spatial_transform) RGB_test_loader = torch.utils.data.DataLoader(RGB_test_data, batch_size=10, shuffle=False, num_workers=opt.n_threads, pin_memory=True) flow_test_data = get_flow_test_set(opt, transform_flow) flow_test_loader = torch.utils.data.DataLoader(flow_test_data, batch_size=10, shuffle=False, num_workers=opt.n_threads, pin_memory=True) print('loading RGB checkpoint {}'.format(opt.resume_path)) checkpoint = torch.load(RGB_state_dict) best_prec1 = checkpoint['best_prec1']
def main_worker(gpu, ngpus_per_node, opt, test_results=None): opt.gpu = gpu # suppress printing if not master if opt.multiprocessing_distributed and opt.gpu != 0: def print_pass(*args): pass builtins.print = print_pass if opt.gpu is not None: print("Use GPU: {} for training".format(opt.gpu)) if opt.distributed: if opt.dist_url == "env://" and opt.rank == -1: opt.rank = int(os.environ["RANK"]) if opt.multiprocessing_distributed: # For multiprocessing distributed training, rank needs to be the # global rank among all the processes opt.rank = opt.rank * ngpus_per_node + gpu dist.init_process_group(backend=opt.dist_backend, init_method=opt.dist_url, world_size=opt.world_size, rank=opt.rank) opt.batch_size = int(opt.batch_size / ngpus_per_node) opt.n_threads = int( (opt.n_threads + ngpus_per_node - 1) / ngpus_per_node) if opt.rank % ngpus_per_node == 0: if not os.path.exists(opt.result_path): os.makedirs(opt.result_path) opt.arch = '{}-{}'.format(opt.model, opt.model_depth) with open(os.path.join(opt.result_path, 'opts.json'), 'w') as opt_file: json.dump(vars(opt), opt_file) if not opt.no_train: training_data = get_training_set(opt) opt.N_data = len(training_data) if opt.distributed: train_sampler = torch.utils.data.distributed.DistributedSampler( training_data) else: train_sampler = None train_loader = torch.utils.data.DataLoader( training_data, batch_size=opt.batch_size, shuffle=(train_sampler is None), num_workers=opt.n_threads, pin_memory=True, drop_last=True, sampler=train_sampler) model, parameters = generate_model(opt) if opt.phase == 'finetuning': criterion = nn.CrossEntropyLoss().cuda(opt.gpu) elif opt.phase == 'pretraining': criterion = NCECriterion(len(training_data)).cuda(opt.gpu) else: raise NotImplementedError('not implement {} phase'.format( opt.phase)) train_logger = Logger( os.path.join(opt.result_path, 'train.log.rank{}'.format(opt.rank)), ['epoch', 'loss', 'acc', 'lr']) train_batch_logger = Logger( os.path.join(opt.result_path, 'train_batch.log.{}'.format(opt.rank)), ['epoch', 'batch', 'iter', 'loss', 'acc', 'lr']) optimizer = optim.SGD(parameters, lr=opt.learning_rate, momentum=opt.momentum, weight_decay=opt.weight_decay) if opt.phase == 'finetuning': scheduler = lr_scheduler.ReduceLROnPlateau( optimizer, 'max', patience=opt.lr_patience, min_lr=1e-6, factor=opt.lr_factor) if not opt.no_val: validation_data = get_validation_set(opt) if opt.distributed: val_sampler = torch.utils.data.distributed.DistributedSampler( validation_data) else: val_sampler = None val_loader = torch.utils.data.DataLoader(validation_data, batch_size=opt.batch_size, shuffle=(val_sampler is None), num_workers=opt.n_threads, pin_memory=True, drop_last=True, sampler=val_sampler) val_logger = Logger( os.path.join(opt.result_path, 'val.log.rank{}'.format(opt.rank)), ['epoch', 'acc1', 'acc5'] if opt.phase == 'finetuning' else ['epoch', 'recall@1', 'recall@10']) if opt.test: model, parameters = generate_model(opt) test_data = get_test_set(opt) idx_to_labels = test_data.get_idx_to_label() if opt.distributed: test_sampler = torch.utils.data.distributed.DistributedSampler( test_data, shuffle=False) else: test_sampler = None test_loader = torch.utils.data.DataLoader( test_data, batch_size=opt.batch_size, shuffle=(test_sampler is None), num_workers=opt.n_threads, pin_memory=True, drop_last=False, sampler=test_sampler) if opt.resume_path: print('==>loading checkpoint {}'.format(opt.resume_path)) if opt.gpu is None: checkpoint = torch.load(opt.resume_path) else: # Map model to be loaded to specified single gpu. loc = 'cuda:{}'.format(opt.gpu) checkpoint = torch.load(opt.resume_path, map_location=loc) opt.begin_epoch = checkpoint['epoch'] model.load_state_dict(checkpoint['state_dict']) if not opt.no_train: optimizer.load_state_dict(checkpoint['optimizer']) else: opt.begin_epoch = 1 torch.backends.cudnn.benchmark = True if opt.rank % ngpus_per_node == 0: summary_writer = SummaryWriter(log_dir=opt.result_path) else: summary_writer = None for i in range(opt.begin_epoch, opt.n_epochs + 1): if not opt.no_train: if opt.distributed: train_sampler.set_epoch(i) train_epoch(i, train_loader, model, criterion, optimizer, opt, train_logger, train_batch_logger, summary_writer) if not opt.no_val: if opt.phase == 'finetuning': val_acc = val_finetune_epoch(i, val_loader, model, opt, val_logger, summary_writer) elif opt.phase == 'pretraining': val_acc = val_pretrain_epoch(i, val_loader, model, opt, val_logger, summary_writer) if not opt.no_train and not opt.no_val: if opt.phase == 'finetuning': scheduler.step(val_acc) elif opt.phase == 'pretraining': adjuest_learning_rate(optimizer, i, opt) if opt.test: test.test(test_loader, model, opt, idx_to_labels, test_results) if opt.multiprocessing_distributed and opt.gpu == 0: result_json = {} finish_procs = 0 while (finish_procs < ngpus_per_node): rst = test_results.get() if rst == -1: finish_procs += 1 else: result_json[rst[0]] = rst[1] with open( os.path.join(opt.result_path, '{}.json'.format(opt.test_subset)), 'w') as f: json.dump({'results': result_json}, f)
'I3D_BSL_rhand' ]: spatial_transform = Compose([ Scale((256, 256)), CenterCrop(224), ToTensor(opt.norm_value), norm_method ]) temporal_transform = LoopPadding(64) target_transform = VideoID() target_transform = TargetCompose([ClassLabel(), VideoID()]) if opt.model.endswith('flow'): test_data = get_test_set(opt, spatial_transform, temporal_transform, target_transform, modality='flow') elif opt.model.endswith('pose'): test_data = get_test_set(opt, spatial_transform, temporal_transform, target_transform, modality='pose') elif opt.model.endswith('depth'): test_data = get_test_set(opt, spatial_transform, temporal_transform, target_transform, modality='depth') elif opt.model.endswith('part'):
if opt.cuda and not torch.cuda.is_available(): raise Exception("No GPU found, please run without --cuda") # open this allows you to enable the inbuilt cudnn auto-tuner to find the best algorithm to use for your hardware. # if NN structure is fixed during training, it is recommanded to open cudnn.benchmark = True # define random seed no. torch.manual_seed(opt.seed) if opt.cuda: torch.cuda.manual_seed(opt.seed) print('===> Loading datasets') root_path = "dataset/" # call function in data.py:to pass trainset address and transfer direction to DatasetFromFolder class train_set = get_training_set(root_path + opt.dataset, opt.direction) test_set = get_test_set(root_path + opt.dataset, opt.direction) # pass trainset to loader training_data_loader = DataLoader(dataset=train_set, num_workers=opt.threads, batch_size=opt.batch_size, shuffle=True) testing_data_loader = DataLoader(dataset=test_set, num_workers=opt.threads, batch_size=opt.test_batch_size, shuffle=False) device = torch.device("cuda:0" if opt.cuda else "cpu") # initialize model print('===> Building models') net_g = define_G(opt.input_nc, opt.output_nc,
# ]) # else: # temp_transform = temp_crop_method target_transform = ClassLabel() # validation_data = get_validation_set( # args, spatial_transform, temp_transform, target_transform, # score_sens_mode=True) # val_loader = torch.utils.data.DataLoader( # validation_data, # batch_size=1, # shuffle=False, # num_workers=args.n_threads, # pin_memory=True) test_data = get_test_set(args, spatial_transform, temp_transform, target_transform, score_sens_mode=True, inner_temp_transform=temp_crop_method) test_loader = torch.utils.data.DataLoader(test_data, batch_size=1, shuffle=False, num_workers=args.n_threads, pin_memory=True) val_logger = Logger(os.path.join(args.result_path, 'val.log'), ['epoch', 'loss', 'acc']) if args.model_path: print('loading checkpoint {}'.format(args.model_path)) checkpoint = torch.load(args.model_path) assert args.arch == checkpoint['arch']
if not opt.no_train: train_epoch(i, train_loader, model, criterion, optimizer, opt, train_logger, train_batch_logger) if not opt.no_val: validation_loss = val_epoch(i, val_loader, model, criterion, opt, val_logger) if not opt.no_train and not opt.no_val: scheduler.step(validation_loss) if opt.test: spatial_transform = Compose([ Scale(int(opt.sample_size / opt.scale_in_test)), CornerCrop(opt.sample_size, opt.crop_position_in_test), ToTensor(opt.norm_value), norm_method ]) temporal_transform = LoopPadding(opt.sample_duration) target_transform = VideoID() test_data = get_test_set(opt, spatial_transform, temporal_transform, target_transform, image_type=opt.image_type) test_loader = torch.utils.data.DataLoader(test_data, batch_size=opt.batch_size, shuffle=False, num_workers=opt.n_threads, pin_memory=True) test.test(test_loader, model, opt, test_data.class_names)
print('run') for i in range(opt.begin_epoch, opt.n_epochs + 1): if not opt.no_train: train_epoch(i, train_loader, model, criterion, optimizer, opt, train_logger, train_batch_logger) if not opt.no_val: validation_loss = val_epoch(i, val_loader, model, criterion, opt, val_logger) if not opt.no_train and not opt.no_val: scheduler.step(validation_loss) if opt.test: spatial_transform = Compose([ Scale(int(opt.sample_size / opt.scale_in_test)), CornerCrop(opt.sample_size, opt.crop_position_in_test), ToTensor(opt.norm_value), norm_method ]) temporal_transform = LoopPadding(opt.sample_duration) target_transform = VideoID() test_data = get_test_set(opt, spatial_transform, temporal_transform, target_transform) test_loader = torch.utils.data.DataLoader(test_data, batch_size=opt.batch_size, shuffle=False, num_workers=opt.n_threads, pin_memory=True) test.test(test_loader, model, opt, test_data.class_names)
# ]) # else: # temporal_transform = temp_crop_method target_transform = ClassLabel() # validation_data = get_validation_set( # args, spatial_transform, temp_transform, target_transform, # score_sens_mode=True) # val_loader = torch.utils.data.DataLoader( # validation_data, # batch_size=1, # shuffle=False, # num_workers=args.n_threads, # pin_memory=True) test_data = get_test_set(args, spatial_transform, temp_transform, target_transform, score_inf_mode=True) test_loader = torch.utils.data.DataLoader(test_data, batch_size=1, shuffle=False, num_workers=args.n_threads, pin_memory=True) val_logger = Logger(os.path.join(args.result_path, 'val.log'), ['epoch', 'loss', 'acc']) if args.first_model_path: print('loading checkpoint {}'.format(args.first_model_path)) checkpoint = torch.load(args.first_model_path) assert args.arch == checkpoint['arch']