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']
