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 get_loaders(opt): """ Make dataloaders for train and validation sets """ # train loader norm_method = Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) spatial_transform = Compose([ Scale((opt.sample_size, opt.sample_size)), Resize(256), CenterCrop(224), ToTensor(), norm_method ]) temporal_transform = TemporalRandomCrop(25) 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.num_workers, pin_memory=True) # validation loader target_transform = ClassLabel() temporal_transform = LoopPadding(25) 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, num_workers=opt.num_workers, pin_memory=True) return train_loader, val_loader
def get_traininfo(opt, norm_method): 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([ RandomRotate(), RandomResize(), crop_method, 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) train_logger = Logger(os.path.join(opt.result_path, 'train.log'), ['epoch', 'loss', 'prec1', 'prec5', 'lr']) train_batch_logger = Logger( os.path.join(opt.result_path, 'train_batch.log'), ['epoch', 'batch', 'iter', 'loss', 'prec1', 'prec5', 'lr']) return train_loader, train_logger, train_batch_logger
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_loaders(opt): """ Make dataloaders for train and validation sets """ # train loader opt.mean = get_mean(opt.norm_value, dataset=opt.mean_dataset) 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) spatial_transform = Compose([ # crop_method, Scale((opt.sample_size, opt.sample_size)), # RandomHorizontalFlip(), ToTensor(opt.norm_value), norm_method ]) temporal_transform = TemporalRandomCrop(16) 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.num_workers, pin_memory=True) # validation loader spatial_transform = Compose([ Scale((opt.sample_size, opt.sample_size)), # CenterCrop(opt.sample_size), ToTensor(opt.norm_value), norm_method ]) target_transform = ClassLabel() temporal_transform = LoopPadding(16) 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, num_workers=opt.num_workers, pin_memory=True) return train_loader, val_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()
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, shuffle=True, 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']) if opt.nesterov: dampening = 0
def main(): opt = parse_opts() ecd_name, cls_name = opt.model_name.split('-') ecd_model = get_encoder_net(ecd_name) cls_model = get_end_net(cls_name) cfg.encoder_model = ecd_name cfg.classification_model = cls_name if opt.debug: cfg.debug = opt.debug else: if opt.tensorboard == 'TEST': cfg.tensorboard = opt.model_name else: cfg.tensorboard = opt.tensorboard cfg.flag = opt.flag model = cls_model(cfg, encoder=CNNencoder( cfg, ecd_model(pretrained=True, path=opt.encoder_model))) cfg.video_path = os.path.join(cfg.root_path, cfg.video_path) cfg.annotation_path = os.path.join(cfg.root_path, cfg.annotation_path) cfg.list_all_member() torch.manual_seed(cfg.manual_seed) print('##########################################') print('####### model 仅支持单GPU') print('##########################################') model = model.cuda() print(model) criterion = nn.CrossEntropyLoss() if cfg.cuda: criterion = criterion.cuda() norm_method = Normalize([0, 0, 0], [1, 1, 1]) print('##########################################') print('####### train') print('##########################################') assert cfg.train_crop in ['random', 'corner', 'center'] if cfg.train_crop == 'random': crop_method = (cfg.scales, cfg.sample_size) elif cfg.train_crop == 'corner': crop_method = MultiScaleCornerCrop(cfg.scales, cfg.sample_size) elif cfg.train_crop == 'center': crop_method = MultiScaleCornerCrop(cfg.scales, cfg.sample_size, crop_positions=['c']) spatial_transform = Compose([ crop_method, RandomHorizontalFlip(), ToTensor(cfg.norm_value), norm_method ]) temporal_transform = TemporalRandomCrop(cfg.sample_duration) target_transform = ClassLabel() training_data = get_training_set(cfg, spatial_transform, temporal_transform, target_transform) train_loader = torch.utils.data.DataLoader(training_data, batch_size=cfg.batch_size, shuffle=True, num_workers=cfg.n_threads, drop_last=False, pin_memory=True) optimizer = model.get_optimizer(lr1=cfg.lr, lr2=cfg.lr2) scheduler = lr_scheduler.ReduceLROnPlateau(optimizer, 'min', patience=cfg.lr_patience) print('##########################################') print('####### val') print('##########################################') spatial_transform = Compose([ Scale(cfg.sample_size), CenterCrop(cfg.sample_size), ToTensor(cfg.norm_value), norm_method ]) temporal_transform = LoopPadding(cfg.sample_duration) target_transform = ClassLabel() validation_data = get_validation_set(cfg, spatial_transform, temporal_transform, target_transform) val_loader = torch.utils.data.DataLoader(validation_data, batch_size=cfg.batch_size, shuffle=False, num_workers=cfg.n_threads, drop_last=False, pin_memory=True) print('##########################################') print('####### run') print('##########################################') if cfg.debug: logger = None else: path = get_log_dir(cfg.logdir, name=cfg.tensorboard, flag=cfg.flag) logger = Logger(logdir=path) cfg.save_config(path) for i in range(cfg.begin_epoch, cfg.n_epochs + 1): train_epoch(i, train_loader, model, criterion, optimizer, cfg, logger) validation_loss = val_epoch(i, val_loader, model, criterion, cfg, logger) scheduler.step(validation_loss)
spatial_transform = Compose([ Scale([opt.sample_size, opt.sample_size]), RandomHorizontalFlip(), ToTensor(opt.norm_value), norm_method ]) else: spatial_transform = Compose([ Scale([opt.sample_size, opt.sample_size]), ToTensor(opt.norm_value), norm_method ]) temporal_transform = TemporalRandomCrop(opt.sample_duration) target_transform = Label() opt.dataset = 'diem' training_data_diem = get_training_set(opt, spatial_transform, temporal_transform, target_transform) opt.dataset = 'coutrot1' training_data_coutrot1 = get_training_set(opt, spatial_transform, temporal_transform, target_transform) opt.dataset = 'coutrot2' training_data_coutrot2 = get_training_set(opt, spatial_transform, temporal_transform, target_transform) opt.dataset = 'summe' training_data_summe = get_training_set(opt, spatial_transform, temporal_transform, target_transform) opt.dataset = 'etmd' training_data_etmd = get_training_set(opt, spatial_transform,
elif opt.train_crop == 'center': crop_method = MultiScaleCornerCrop(opt.scales, opt.sample_size, crop_positions=['c']) spatial_transform = Compose([ Scale((256, 256)), crop_method, RandomHorizontalFlip(), ToTensor(opt.norm_value), norm_method ]) temporal_transform = TemporalRandomCrop(opt.sample_duration, 1) target_transform = ClassLabel() if opt.model.endswith('flow'): training_data = get_training_set(opt, spatial_transform, temporal_transform, target_transform, modality='flow') elif opt.model.endswith('pose'): training_data = get_training_set(opt, spatial_transform, temporal_transform, target_transform, modality='pose') elif opt.model.endswith('depth'): training_data = get_training_set(opt, spatial_transform, temporal_transform, target_transform, modality='depth') elif opt.model.endswith('part'):
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))
]) annotateData = pd.read_csv(opt.annotation_file, sep=',', header=0) keys = annotateData[annotateData.Dataset == 'Train']['Location'] values = annotateData[annotateData.Dataset == 'Train']['MeanID'] annotationDictionary = dict(zip(keys, values)) temporal_transform = TemporalCenterRandomCrop(opt.sample_duration) """if opt.temporal_crop == 'Random': temporal_transform = TemporalRandomCrop(opt.sample_duration) else: temporal_transform = TemporalCenterRandomCrop(opt.sample_duration)""" target_transform = ClassLabel() training_data = get_training_set(opt, spatial_transforms, temporal_transform, target_transform, annotationDictionary) train_loader = torch.utils.data.DataLoader(training_data, batch_size=opt.batch_size, shuffle=True, 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', 'means']) if opt.nesterov: dampening = 0 else:
def create_dataloader(args): if args.root_path != '': args.video_path = os.path.join(args.root_path, args.video_path) args.annotation_path = os.path.join(args.root_path, args.annotation_path) args.result_path = os.path.join(args.root_path, args.result_path) if args.resume_path: args.resume_path = os.path.join(args.root_path, args.resume_path) if args.pretrain_path: # args.pretrain_path = os.path.join(args.root_path, args.pretrain_path) args.pretrain_path = os.path.abspath(args.pretrain_path) args.scales = [args.initial_scale] for i in range(1, args.n_scales): args.scales.append(args.scales[-1] * args.scale_step) args.mean = get_mean(args.norm_value, dataset=args.mean_dataset) args.std = get_std(args.norm_value) if args.no_mean_norm and not args.std_norm: norm_method = Normalize([0, 0, 0], [1, 1, 1]) elif not args.std_norm: norm_method = Normalize(args.mean, [1, 1, 1]) else: norm_method = Normalize(args.mean, args.std) assert args.train_crop in ['random', 'corner', 'center'] if args.train_crop == 'random': crop_method = MultiScaleRandomCrop(args.scales, args.sample_size) elif args.train_crop == 'corner': crop_method = MultiScaleCornerCrop(args.scales, args.sample_size) elif args.train_crop == 'center': crop_method = MultiScaleCornerCrop(args.scales, args.sample_size, crop_positions=['c']) spatial_transform = Compose([ crop_method, RandomHorizontalFlip(), ToTensor(args.norm_value), norm_method ]) temporal_transform = TemporalRandomCrop(args.sample_duration) target_transform = ClassLabel() training_data = get_training_set(args, spatial_transform, temporal_transform, target_transform) train_loader = torch.utils.data.DataLoader(training_data, batch_size=args.batch_size, shuffle=True, num_workers=args.n_threads, pin_memory=True) spatial_transform = Compose([ # Scale(args.sample_size), Scale(int(args.sample_size / args.scale_in_test)), # CenterCrop(args.sample_size), CornerCrop(args.sample_size, args.crop_position_in_test), ToTensor(args.norm_value), norm_method ]) temporal_transform = TemporalCenterCrop(args.sample_duration) target_transform = ClassLabel() validation_data = get_validation_set(args, spatial_transform, temporal_transform, target_transform) val_loader = torch.utils.data.DataLoader(validation_data, batch_size=1, shuffle=False, num_workers=args.n_threads, pin_memory=True) return train_loader, val_loader
def main(): # parameters # ???should we adjust the learning rate during the training process? ??? learn_rate = 1e-4 num_epochs = 600 # 最大迭代次数 max_patience = 60 # 停止训练的参数 result_rp = '../result/model/' exp_name = 'P3D_saliency' batch_size = 3 n_threads = 16 # 'Temporal duration of inputs' sample_duration = 16 # the data for devison norm_value = 255 # Height and width of inputs sample_size = 224 # Number of validation samples for each activity n_val_samples = 3 video_path = '/data1/guoxi/p3d_floder/resized_dataset/dataset/' reference_path = '/data1/guoxi/p3d_floder/resized_dataset/reference_dataset/' # video_path = '/data1/guoxi/p3d_floder/resized_dataset_for_test/dataset/' # reference_path = '/data1/guoxi/p3d_floder/resized_dataset_for_test/reference_dataset/' mean = [0.485, 0.456, 0.406] std = [0.229, 0.224, 0.225] norm_method = Normalize(mean, std) RandomCrop_transform = Compose([ # 图像预处理一般用Compose把多个步骤整合到一起 joint_transforms.JointRandomCrop( 224 ), # 在一个随机的位置进行裁剪 'JpegImageFile' object does not support indexing ]) RandomHorizontalFlip_transform = Compose([ # 图像预处理一般用Compose把多个步骤整合到一起 joint_transforms.JointRandomHorizontalFlip(), # 以0.5的概率水平翻转给定的PIL图像 ]) RandomErase_transform = Compose( [joint_transforms.RandomErase(probability=0.5, sh=0.4, r1=0.3)]) spatial_transform = Compose([ToTensor(norm_value=norm_value), norm_method]) # 空间变换 target_transform = Compose([ToTensor(norm_value=norm_value)]) opt = [video_path, sample_duration] train_data = dataset.get_training_set(opt, reference_path, spatial_transform, target_transform, RandomCrop_transform, RandomHorizontalFlip_transform, RandomErase_transform) train_loader = torch.utils.data.DataLoader( train_data, batch_size=batch_size, shuffle=True, num_workers=n_threads, pin_memory=True ) # 使用多进程加载的进程数 是否将数据保存在pin memory区,pin memory中的数据转到GPU会快一些 validation_data = dataset.get_validation_set(opt, reference_path, spatial_transform, target_transform, None, None, None) val_loader = torch.utils.data.DataLoader(validation_data, batch_size=batch_size, shuffle=False, num_workers=n_threads, pin_memory=True) inputs, targets = next(iter(train_loader)) print('inputs.size(), inputs.min(), inputs.max()', inputs.size(), inputs.min(), inputs.max()) print('targets.size(), targets.min(), targets.max():', targets.size(), targets.min(), targets.max()) # every time we load weights, which may be slow model_cla = network_cla.P3D199(pretrained=True, num_classes=400) cla_dict = model_cla.state_dict() model = network_seg.P3D199() # model.apply(utils.weights_init) seg_dict = model.state_dict() pretrained_dict = {k: v for k, v in cla_dict.items() if k in seg_dict} seg_dict.update(pretrained_dict) model.load_state_dict(seg_dict) model.cuda() model = nn.DataParallel(model) commen_layers = [ 'conv1_custom', 'bn1', 'relu', 'maxpool', 'maxpool_2', 'layer1', 'layer2', 'layer3' ] # seperate layers, to set different lr param_exist = [] param_add = [] for k, (name, module) in enumerate(model.named_children()): # existing layers if name in commen_layers: # print('existing layer: ', name) for param in module.parameters(): param_exist.append(param) # adding layers else: # print('adding layer: ', name) for param in module.parameters(): param_add.append(param) print(' + Number of params: {}'.format( sum([p.data.nelement() for p in model.parameters()]))) optimizer = optim.Adam([{ 'params': param_exist, 'lr': learn_rate * 0.1 }, { 'params': param_add }]) criterion = nn.BCELoss().cuda() exp_dir = result_rp + exp_name ##!!! existing directory will be removed if os.path.exists(exp_dir): shutil.rmtree(exp_dir) exp = experiment.Experiment(exp_name, result_rp) exp.init() for epoch in range(num_epochs): since = time.time() ### Train ### trn_loss = utils.train(model, train_loader, optimizer, criterion) print('Epoch {:d}: Train - Loss: {:.4f}'.format(epoch, trn_loss)) time_elapsed = time.time() - since print('Train Time {:.0f}m {:.0f}s'.format(time_elapsed // 60, time_elapsed % 60)) ### Test ### val_loss = utils.test(model, val_loader, criterion) print('Val - Loss: {:.4f}'.format(val_loss)) time_elapsed = time.time() - since print('Total Time {:.0f}m {:.0f}s\n'.format(time_elapsed // 60, time_elapsed % 60)) ### Save Metrics ### exp.save_history('train', trn_loss) exp.save_history('val', val_loss) ### Checkpoint ### exp.save_weights(model, trn_loss, val_loss) exp.save_optimizer(optimizer, val_loss) ## Early Stopping ## if (epoch - exp.best_val_loss_epoch) > max_patience: print(("Early stopping at epoch %d since no " + "better loss found since epoch %.3").format( epoch, exp.best_val_loss)) break exp.epoch += 1
#RandomHorizontalFlip(), # RandomRotate(), # RandomResize(), #crop_method, # MultiplyValues(), # Dropout(), # SaltImage(), # Gaussian_blur(), # SpatialElasticDisplacement(), ToTensor(opt.norm_value) ]) transform_flow = Compose([ToTensor(opt.norm_value)]) #temporal_transform = TemporalRandomCrop(opt.sample_duration, opt.downsample) #target_transform = ClassLabel() if opt.model == 'resnet' or opt.model == 'slowfastnet': training_data = get_training_set(opt, spatial_transform) if opt.model == 'flow': training_data = get_flow_training_set(opt, transform_flow) train_loader = torch.utils.data.DataLoader(training_data, batch_size=opt.batch_size, shuffle=True, num_workers=opt.n_threads, pin_memory=True) train_logger = Logger(os.path.join(opt.result_path, 'train.log'), ['epoch', 'loss', 'prec1', 'prec5', 'lr']) train_batch_logger = Logger( os.path.join(opt.result_path, 'train_batch.log'), [ 'epoch', 'batch', 'iter', 'loss', 'prec1', 'prec5', 'lr', 'correlation' ])
args = opt() #argsの読み出し args.arch = "ResNet-{}".format(args.model_depth) #実行するアーキテクチャを書き込む spatial_transform = Compose([ ToTensor(), #1iterごとに読み込まれる各フレーム(PIL Image)をTensorへ変換する ]) temporal_transform = TemporalRandomCrop4flow() #時間方向の前処理,今回はなし target_transform = ClassLabel() #学習する正解データ,2クラス分類なのでラベル accuracies = AverageMeter() #各回におけるaccとその平均 with open(os.path.join("./result", 'opts.json'), 'w') as args_file: json.dump(vars(args), args_file) model = generate_model(args) #モデルの読み込み(pretrainがあれば重みも読み込んでおく) criterion = nn.CrossEntropyLoss() #損失関数の定義CrossEntropyLoss criterion.cuda() #criterionをcudaへ変更 training_data = get_training_set(args, spatial_transform, temporal_transform, target_transform) #データローダに入力するデータセットの作成 train_loader = torch.utils.data.DataLoader(training_data, batch_size=args.batch_size, shuffle=True, pin_memory=True) train_logger = Logger("./result/train.log", ["epoch", "loss", "acc", "lr"]) optimizer = optim.Adam(model.parameters(), lr=args.learning_rate, weight_decay=args.weight_decay) for epoch in range(1, args.n_epoch + 1): train_epoch(epoch, train_loader, model, criterion, optimizer, args, train_logger) print("finish")
opt = parser.parse_args() 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])
def main(): opt = parse_opts() print(opt) seed = 0 random.seed(seed) np.random.seed(seed) torch.manual_seed(seed) # torch.backends.cudnn.deterministic = True # torch.backends.cudnn.benchmark = False # CUDA for PyTorch use_cuda = torch.cuda.is_available() device = torch.device(f"cuda:{opt.gpu}" if use_cuda else "cpu") train_transform = transforms.Compose([ #transforms.RandomCrop(32, padding=3), transforms.Resize((224, 224)), transforms.RandomHorizontalFlip(), transforms.ColorJitter(brightness=[0.5, 1]), # transforms.RandomRotation(180), GaussianNoise(0.5), # transforms.RandomRotation(10), transforms.ToTensor(), transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) ]) test_transform = transforms.Compose([ #transforms.RandomCrop(32, padding=3), transforms.Resize((224, 224)), transforms.ToTensor(), transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) ]) training_data = get_training_set(opt, train_transform) training_data = ConcatDataset(training_data) validation_data = get_validation_set(opt, test_transform) validation_data = ConcatDataset(validation_data) train_loader = torch.utils.data.DataLoader(training_data, batch_size=opt.batch_size, shuffle=True, num_workers=0) val_loader = torch.utils.data.DataLoader(validation_data, batch_size=opt.batch_size, shuffle=True, num_workers=0) print(f'Number of training examples: {len(train_loader.dataset)}') print(f'Number of validation examples: {len(val_loader.dataset)}') # tensorboard summary_writer = tensorboardX.SummaryWriter(log_dir='tf_logs') # define model model = ResidualNet("ImageNet", opt.depth, opt.num_classes, "CBAM") if opt.resume_path: checkpoint = torch.load(opt.resume_path) model.load_state_dict(checkpoint['model_state_dict']) epoch = checkpoint['epoch'] print("Model Restored from Epoch {}".format(epoch)) opt.start_epoch = epoch + 1 model.to(device) criterion = nn.CrossEntropyLoss() optimizer = optim.Adam(model.parameters(), weight_decay=opt.wt_decay) scheduler = lr_scheduler.ReduceLROnPlateau(optimizer, 'min', patience=opt.lr_patience) if opt.resume_path: checkpoint = torch.load(opt.resume_path) optimizer.load_state_dict(checkpoint['optimizer_state_dict']) scheduler.load_state_dict(checkpoint['scheduler_state_dict']) th = 100000 # start training for epoch in range(opt.start_epoch, opt.epochs + 1): # train, test model train_loss, train_acc = train_epoch(model, train_loader, criterion, optimizer, device, opt) val_loss, val_acc = val_epoch(model, val_loader, criterion, device) scheduler.step(val_loss) lr = optimizer.param_groups[0]['lr'] # saving weights to checkpoint if (epoch) % opt.save_interval == 0: # write summary summary_writer.add_scalar('losses/train_loss', train_loss, global_step=epoch) summary_writer.add_scalar('losses/val_loss', val_loss, global_step=epoch) summary_writer.add_scalar('acc/train_acc', train_acc, global_step=epoch) summary_writer.add_scalar('acc/val_acc', val_acc, global_step=epoch) summary_writer.add_scalar('lr_rate', lr, global_step=epoch) state = { 'epoch': epoch, 'model_state_dict': model.state_dict(), 'optimizer_state_dict': optimizer.state_dict(), 'scheduler_state_dict': scheduler.state_dict() } if val_loss < th: torch.save( state, os.path.join('./snapshots', f'{opt.dataset}_model.pth')) print("Epoch {} model saved!\n".format(epoch)) th = val_loss
crop_positions=['c']) elif opt.train_crop == 'driver focus': crop_method = DriverFocusCrop(opt.scales, opt.sample_size) train_spatial_transform = Compose([ Scale(opt.sample_size), ToTensor(opt.norm_value) #, norm_method ]) train_temporal_transform = UniformIntervalCrop(opt.sample_duration, opt.interval) train_target_transform = Compose([ Scale(opt.sample_size), ToTensor(opt.norm_value) #, norm_method ]) train_horizontal_flip = RandomHorizontalFlip() training_data = get_training_set(opt, train_spatial_transform, train_horizontal_flip, train_temporal_transform, train_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) train_logger = Logger(os.path.join(opt.result_path, 'convlstm-train.log'), ['epoch', 'loss', 'lr']) train_batch_logger = Logger( os.path.join(opt.result_path, 'convlstm-train_batch.log'), ['epoch', 'batch', 'iter', 'loss', 'lr']) if opt.nesterov: dampening = 0 else:
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)
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
crop_method, #MultiplyValues(), #Dropout(), #SaltImage(), #Gaussian_blur(), #SpatialElasticDisplacement(), ToTensor(opt.norm_value), norm_method ]) temporal_transform = TemporalRandomCrop(opt.sample_duration, opt.downsample) target_transform = ClassLabel() # opt.view = "front" #A for anomalies, N for normal, all for anomaly+normal training_data1 = get_training_set(opt, 'A', opt.view, opt.image_type, spatial_transform, temporal_transform, target_transform) training_data2 = get_training_set(opt, 'N', opt.view, opt.image_type, spatial_transform, temporal_transform, target_transform) # print (training_data1.__len__()) train_loader1 = torch.utils.data.DataLoader(training_data1, batch_size=opt.batch_size, shuffle=True, num_workers=opt.n_threads, pin_memory=True, drop_last=True) train_loader2 = torch.utils.data.DataLoader(training_data2, batch_size=opt.batch_size, shuffle=True, num_workers=opt.n_threads,
def main(): opt = parse_opts() print(opt) seed = 0 random.seed(seed) np.random.seed(seed) torch.manual_seed(seed) torch.backends.cudnn.deterministic = True torch.backends.cudnn.benchmark = False # CUDA for PyTorch use_cuda = torch.cuda.is_available() device = torch.device(f"cuda:{opt.gpu}" if use_cuda else "cpu") train_transform = transforms.Compose([ #transforms.RandomCrop(32, padding=3), transforms.Resize((opt.img_H, opt.img_W)), transforms.RandomHorizontalFlip(), transforms.RandomRotation(10), transforms.ToTensor(), transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[ 0.229, 0.224, 0.225]) ]) test_transform = transforms.Compose([ #transforms.RandomCrop(32, padding=3), transforms.Resize((opt.img_H, opt.img_W)), transforms.ToTensor(), transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[ 0.229, 0.224, 0.225]) ]) training_data = get_training_set(opt, train_transform) validation_data = get_validation_set(opt, test_transform) n_train_examples = int(len(training_data)*0.8) n_valid_examples = len(training_data) - n_train_examples # split data training_data, validation_data = torch.utils.data.random_split(training_data, [n_train_examples, n_valid_examples]) train_loader = torch.utils.data.DataLoader(training_data, batch_size=opt.batch_size, shuffle=True, num_workers=1) val_loader = torch.utils.data.DataLoader(validation_data, batch_size=opt.batch_size, shuffle=True, num_workers=1) print(f'Number of training examples: {len(train_loader.dataset)}') print(f'Number of validation examples: {len(val_loader.dataset)}') # tensorboard summary_writer = tensorboardX.SummaryWriter(log_dir='tf_logs') # define model model = resnet18(num_classes=opt.num_classes) # if torch.cuda.device_count() > 1: # print("Let's use", torch.cuda.device_count(), "GPUs!") # model = nn.DataParallel(model) model = model.to(device) if opt.nesterov: dampening = 0 else: dampening = opt.dampening #define optimizer and criterion # optimizer = optim.Adam(model.parameters()) # 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) # criterion = nn.CrossEntropyLoss() # define optimizer and criterion optimizer = optim.Adam(model.parameters()) # loss function criterion = BCEWithLogitsLoss() # resume model, optimizer if already exists if opt.resume_path: checkpoint = torch.load(opt.resume_path) model.load_state_dict(checkpoint['model_state_dict']) optimizer.load_state_dict(checkpoint['optimizer_state_dict']) epoch = checkpoint['epoch'] print("Model Restored from Epoch {}".format(epoch)) start_epoch = epoch + 1 else: start_epoch = 1 # start training #th = 10000 for epoch in range(start_epoch, opt.epochs+1): val_loss, val_mAP = val_epoch(model, val_loader, criterion, device, opt)
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) print(opt) torch.manual_seed(opt.manual_seed) model, parameters = generate_model(opt) print(model) criterion = nn.CrossEntropyLoss() if not opt.no_cuda: criterion = criterion.cuda() criterion_pose = nn.L1Loss().cuda() if not opt.no_train: training_data = get_training_set(opt) train_loader = torch.utils.data.DataLoader(training_data, batch_size=opt.batch_size, shuffle=True, 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']) if opt.nesterov: dampening = 0 else: dampening = opt.dampening
# check if cuda is available 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,
#RandomHorizontalFlip(), #RandomRotate(), #RandomResize(), #crop_method, #MultiplyValues(), #Dropout(), #SaltImage(), #Gaussian_blur(), #SpatialElasticDisplacement(), ToTensor(opt.norm_value) #, norm_method ]) temporal_transform = TemporalRandomCrop(opt.sample_duration, opt.downsample) target_transform = ClassLabel() training_data1 = get_training_set(opt, 'A', 'top', spatial_transform, temporal_transform, target_transform) training_data2 = get_training_set(opt, 'N', 'top', spatial_transform, temporal_transform, target_transform) #print (training_data1.__len__()) train_loader1 = torch.utils.data.DataLoader(training_data1, batch_size=opt.batch_size, shuffle=True, num_workers=opt.n_threads, pin_memory=True, drop_last=True) train_loader2 = torch.utils.data.DataLoader(training_data2, batch_size=opt.batch_size, shuffle=True, num_workers=opt.n_threads, pin_memory=True, drop_last=True)
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, image_type=opt.image_type) train_loader = torch.utils.data.DataLoader(training_data, batch_size=opt.batch_size, shuffle=True, 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']) if opt.nesterov: dampening = 0
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, shuffle=True, 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']) if opt.nesterov: dampening = 0 else: dampening = opt.dampening
def main(): opt = parse_opts() # Path configurations opt.annotation_path = os.path.join(opt.annotation_directory, opt.annotation_path) save_result_dir_name = \ os.path.join(opt.result_path, get_prefix() + '_{}{}_{}_epochs'.format(opt.model, opt.model_depth, opt.n_epochs)) if not os.path.exists(save_result_dir_name): os.mkdir(save_result_dir_name) opt.result_path = os.path.join(opt.result_path, save_result_dir_name) # For data generator opt.scales = [opt.initial_scale] for epoch in range(1, opt.n_scales): opt.scales.append(opt.scales[-1] * opt.scale_step) opt.arch = '{}-{}'.format(opt.model, opt.model_depth) # Model model, parameters = generate_model(opt) # print(model) # Loss function criterion = nn.CrossEntropyLoss() if not opt.no_cuda: criterion = criterion.cuda() # Normalizing if not opt.no_mean_norm: opt.mean = get_mean(opt.norm_value, dataset=opt.mean_dataset) opt.std = get_std(opt.norm_value, dataset=opt.std_dataset) norm_method = Normalize(opt.mean, opt.std) else: norm_method = Normalize([0, 0, 0], [1, 1, 1]) print(opt) with open(os.path.join(opt.result_path, 'opts.json'), 'w') as opt_file: json.dump(vars(opt), opt_file) # **************************** TRAINING CONFIGURATIONS ************************************ assert opt.train_crop in ['corner', 'center'] if 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() train_loader_list = [] if not opt.no_cross_validation: annotation_list = os.listdir(opt.annotation_directory) for annotation in annotation_list: opt.annotation_path = os.path.join(opt.annotation_directory, annotation) 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) train_loader_list.append(train_loader) else: 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) train_loader_list.append(train_loader) 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.SGD(parameters, lr=opt.learning_rate, momentum=opt.momentum, dampening=opt.dampening, weight_decay=opt.weight_decay) scheduler = lr_scheduler.ReduceLROnPlateau(optimizer, 'min', patience=opt.lr_patience) # ***************************** VALIDATION CONFIGURATIONS ********************************* 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() val_loader_list = [] if not opt.no_cross_validation: annotation_list = os.listdir(opt.annotation_directory) for annotation in annotation_list: opt.annotation_path = os.path.join(opt.annotation_directory, annotation) 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, num_workers=opt.n_threads, pin_memory=True) val_loader_list.append(val_loader) else: 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, num_workers=opt.n_threads, pin_memory=True) val_loader_list.append(val_loader) val_logger = Logger(os.path.join(opt.result_path, 'val.log'), ['epoch', 'loss', 'acc']) # **************************************** TRAINING **************************************** epoch_avg_time = AverageMeter() train_loss_list = [] train_acc_list = [] valid_acc_list = [] best_accuracy = 0 current_train_data = 0 current_valid_data = 0 opt.frequence_cross_validation = round(opt.n_epochs / opt.n_cross_validation_sets + 0.5) for epoch in range(opt.begin_epoch, opt.n_epochs + 1): epoch_start_time = time.time() print('Epoch #' + str(epoch)) # optimizer = regulate_learning_rate(optimizer, epoch, opt.frequence_regulate_lr) train_loader = train_loader_list[current_train_data] if not opt.no_cross_validation and epoch % opt.frequence_cross_validation == 0: print('\t##### Cross-validation: switch training data #####') current_train_data = (current_train_data + 1) % len(train_loader_list) train_loader = train_loader_list[current_train_data] train_loss, train_acc = train_epoch(epoch, train_loader, model, criterion, optimizer, opt, train_logger, train_batch_logger) val_loader = val_loader_list[current_valid_data] if not opt.no_cross_validation and epoch % opt.frequence_cross_validation == 0: print('\t##### Cross-validation: switch validation data #####') current_valid_data = (current_valid_data + 1) % len(val_loader_list) val_loader = val_loader_list[current_valid_data] validation_acc = val_epoch(epoch, val_loader, model, criterion, opt, val_logger) train_loss_list.append(train_loss) train_acc_list.append(train_acc) valid_acc_list.append(validation_acc) # Save model with best accuracy if validation_acc > best_accuracy: best_accuracy = validation_acc save_file_path = os.path.join(opt.result_path, 'best_model.pth') states = { 'epoch': epoch + 1, 'arch': opt.arch, 'state_dict': model.state_dict(), 'optimizer': optimizer.state_dict() } torch.save(states, save_file_path) epoch_end_time = time.time() - epoch_start_time epoch_avg_time.update(epoch_end_time) print('\tTime left: ' + str(round(epoch_avg_time.avg * (opt.n_epochs - epoch) / 60, 1)) + ' minutes') # ******************************* SAVING RESULTS OF TRAINING ****************************** save_pictures(np.linspace(1, opt.n_epochs, opt.n_epochs), train_loss_list, 'red', 'Loss', os.path.join(opt.result_path, 'train_loss.png')) save_pictures(np.linspace(1, opt.n_epochs, opt.n_epochs), train_acc_list, 'blue', 'Accuracy', os.path.join(opt.result_path, 'train_accuracy.png')) save_pictures(np.linspace(1, opt.n_epochs, opt.n_epochs), valid_acc_list, 'blue', 'Accuracy', os.path.join(opt.result_path, 'validation_accuracy.png'))