def train_classifier(config: Config): config_json = config.toDictionary() print('train_classifier') print(config_json) from training.train import train from torch.utils.data.dataloader import DataLoader from data.loader_segmentation import Segmentation model = get_model(config.classifier_name) wandb.init(entity='kobus_wits', project='wass_classifier', name=config.sweep_id + '_c_' + config.classifier_name, config=config_json) wandb.watch(model) train( model=model, dataloaders = { 'train': DataLoader( Segmentation( config.classifier_dataset_root, source='train', augmentation='train', image_size=config.classifier_image_size ), batch_size=config.classifier_batch_size_train, shuffle=True, pin_memory=True, num_workers=4, prefetch_factor=4 ), }, epochs=config.classifier_epochs, validation_mod=10 ) wandb.finish()
def main(cfg, _log): init_seed(cfg.seed) _log.info("=> fetching img pairs.") train_set, valid_set = get_dataset(cfg) _log.info('{} samples found, {} train samples and {} test samples '.format( len(valid_set) + len(train_set), len(train_set), len(valid_set))) train_loader = torch.utils.data.DataLoader(train_set, batch_size=cfg.train.batch_size, num_workers=cfg.train.workers, pin_memory=True, shuffle=True) max_test_batch = 4 if type(valid_set) is torch.utils.data.ConcatDataset: valid_loader = [ torch.utils.data.DataLoader(s, batch_size=min(max_test_batch, cfg.train.batch_size), num_workers=min(4, cfg.train.workers), pin_memory=True, shuffle=False) for s in valid_set.datasets ] valid_size = sum([len(l) for l in valid_loader]) else: valid_loader = torch.utils.data.DataLoader( valid_set, batch_size=min(max_test_batch, cfg.train.batch_size), num_workers=min(4, cfg.train.workers), pin_memory=True, shuffle=False) valid_size = len(valid_loader) if cfg.train.epoch_size == 0: cfg.train.epoch_size = len(train_loader) if cfg.train.valid_size == 0: cfg.train.valid_size = valid_size cfg.train.epoch_size = min(cfg.train.epoch_size, len(train_loader)) cfg.train.valid_size = min(cfg.train.valid_size, valid_size) model = get_model(cfg.model) loss = get_loss(cfg.loss) trainer = get_trainer(cfg.trainer)(train_loader, valid_loader, model, loss, _log, cfg.save_root, cfg.train) for name, param in model.named_parameters(): if ("pyramid" in name) == False: param.requires_grad = False else: print(name, param.requires_grad) #parameter.requires_grad = False epoch, weights = load_checkpoint('checkpoints/Sintel/pwclite_ar.tar') print("traiiiiiiiiiiiiiiiiiiiiiiiiiiiiin", weights) trainer.model = model trainer.train()
def run_model_common(self, dataset, dataset_file_path, model_name, dim_predict): data_train, data_test = load_data(dataset, dataset_file_path, model_name) model = get_model(model_name, dataset, rand_seed=seed, step_size=step_size, device=device, flatten_weight=False) data_loader = DataLoader(data_train, batch_size=1, shuffle=False, num_workers=0) for i, (images, labels) in enumerate(data_loader): w = model.get_weight() model.assign_weight(w) model.model.train() images, labels = images.to(device), labels.to(device) model.optimizer.zero_grad() output = model.model(images) self.assertEqual(len(output[0]), dim_predict) loss = model.loss_fn(output, labels) loss.backward() model.optimizer.step() print(loss.item()) break
def main(): args = opts().parse() train_sampler, train_loader, val_loader, test_loader = get_dataloaders( dataset='cifar10', batch=args.batch_size, dataroot="../../data/cifar10", aug=args.aug, cutout=args.cutout, K=args.K ) if args.gpu > 0: cudnn.benchmark = True # model = wideresnet.Wide_ResNet(40, 2, 0.3, 10).to(args.device) model = get_model(args.model).to(args.device) _, best_score = train(model, train_loader, test_loader, args)
def main(cfg, _log): init_seed(cfg.seed) _log.info("=> fetching img pairs.") train_set, valid_set = get_dataset(cfg) _log.info('{} samples found, {} train samples and {} test samples '.format( len(valid_set) + len(train_set), len(train_set), len(valid_set))) train_loader = torch.utils.data.DataLoader(train_set, batch_size=cfg.train.batch_size, num_workers=cfg.train.workers, pin_memory=True, shuffle=True) max_test_batch = 4 if type(valid_set) is torch.utils.data.ConcatDataset: valid_loader = [ torch.utils.data.DataLoader(s, batch_size=min(max_test_batch, cfg.train.batch_size), num_workers=min(4, cfg.train.workers), pin_memory=True, shuffle=False) for s in valid_set.datasets ] valid_size = sum([len(l) for l in valid_loader]) else: valid_loader = torch.utils.data.DataLoader( valid_set, batch_size=min(max_test_batch, cfg.train.batch_size), num_workers=min(4, cfg.train.workers), pin_memory=True, shuffle=False) valid_size = len(valid_loader) if cfg.train.epoch_size == 0: cfg.train.epoch_size = len(train_loader) if cfg.train.valid_size == 0: cfg.train.valid_size = valid_size cfg.train.epoch_size = min(cfg.train.epoch_size, len(train_loader)) cfg.train.valid_size = min(cfg.train.valid_size, valid_size) model = get_model(cfg.model) loss = get_loss(cfg.loss) trainer = get_trainer(cfg.trainer)(train_loader, valid_loader, model, loss, _log, cfg.save_root, cfg.train) trainer.train()
def worker(id, cfg, shared): # init logger curr_time = datetime.datetime.now().strftime("%y%m%d%H%M%S") _log = init_logger(log_dir=cfg.save_root, filename=curr_time[6:] + '.log') if id == 0: _log.info(id, '=> will save everything to {}'.format(cfg.save_root)) # show configurations cfg_str = pprint.pformat(cfg) if id == 0: _log.info(id, '=> configurations \n ' + cfg_str) # Distributed if cfg.mp.enabled: if cfg.train.n_gpu > 0: dist.init_process_group(backend="nccl", init_method="env://", world_size=cfg.mp.workers, rank=id) else: dist.init_process_group(backend="gloo", init_method="env://", world_size=cfg.mp.workers, rank=id) # Get Model and Loss model = get_model(cfg, id) loss = get_loss(cfg, id) # Create Trainer trainer = get_trainer(cfg)(id, model, loss, _log, cfg.save_root, cfg, shared) # Train or Test try: if cfg.eval: trainer.eval() else: trainer.train() except Exception as e: import traceback traceback.print_exc() # Destroy if cfg.mp.enabled: dist.destroy_process_group()
def handle_segmentation(vargin, scan): tissues = vargin['tissues'] print('') if len(tissues) == 0: raise ValueError('No tissues specified for segmentation') for tissue in tissues: segment_weights_path = vargin[SEGMENTATION_WEIGHTS_DIR_KEY][0] tissue.find_weights(segment_weights_path) # Load model dims = scan.get_dimensions() input_shape = (dims[0], dims[1], 1) model = get_model(vargin[SEGMENTATION_MODEL_KEY], input_shape=input_shape, weights_path=tissue.weights_filepath) model.batch_size = vargin[SEGMENTATION_BATCH_SIZE_KEY] scan.segment(model, tissue)
def __init__(self, args, batch_size=128): super().__init__() self.args = args self.save_hyperparameters() self.batch_size = batch_size self.dataset = args.dataset self.model = get_model(args.model_name, args.num_classes, args) if self.args.weights_path: weights = torch.load(self.args.weights_path)['state_dict'] weights = OrderedDict([ (k[6:], v) for k, v in weights.items() if ('bn' not in k and 'downsample' not in k and 'fc' not in k) ]) #[6:] to remove 'model.' in front of keys self.model.load_state_dict(weights, False) if self.args.freeze_weights: for k, params in self.model.named_parameters(): if 'bn' in k or 'downsample' in k or 'fc' in k or 'binary_activation' in k: params.requires_grad = True else: params.requires_grad = False
def main(args): # print learning settings. print('GPU: {}'.format(args.gpu)) print('# Mini-batch size: {}'.format(args.batchsize)) print('# epoch: {}'.format(args.epoch)) print('Using {} dataset.'.format(args.dataset)) print('') # Load datasets. trainset, testset = get_dataset(args.dataset) # Data transfomer transformer = Transformer(trainset, pca=False, normalize=args.normalize, trans=args.augment) # Make transform datasets. trainset = D.TransformDataset(trainset, transformer.train) testset = D.TransformDataset(testset, transformer.test) # Setup dataset iterators. train_iter = BCIterator(trainset, args.batchsize, classes=args.classes) test_iter = chainer.iterators.SerialIterator(testset, args.batchsize, False, False) # Set CNN model. model = MultiplexClassifier(get_model(args.model, args.classes), lossfun=kl_divergence, accfun=accuracy_mix) # Setup GPU if args.gpu >= 0: cuda.get_device_from_id(args.gpu).use() model.to_gpu() # Run to get model information. one_predict(model, train_iter, args.gpu) print(str_info(model)) # setup trainer trainer = setup_trainer(args, train_iter, test_iter, model) # Run to get model information. one_predict(model, train_iter, args.gpu) print(str_info(model)) if args.resume: chainer.serializers.load_npz(args.resume, trainer) # run trainer.run()
def train_affinitynet(config: Config): config_json = config.toDictionary() print('train_affinitynet') print(config_json) from training.train import train from torch.utils.data.dataloader import DataLoader from data.loader_segmentation import Segmentation from artifacts.artifact_manager import artifact_manager model = get_model(config.affinity_net_name) wandb.init(entity='kobus_wits', project='wass_affinity', name=config.sweep_id + '_a_' + config.affinity_net_name, config=config_json) wandb.watch(model) train( model=model, dataloaders = { 'train': DataLoader( Segmentation( config.classifier_dataset_root, source='train', augmentation='train', image_size=config.affinity_net_image_size, requested_labels=['affinity'], affinity_root=artifact_manager.getDir() ), batch_size=config.affinity_net_batch_size, shuffle=False, pin_memory=False, num_workers=4, prefetch_factor=4 ), }, epochs=config.affinity_net_epochs, validation_mod=10 ) wandb.finish()
def __init__(self, settings: dict, settings_to_log: list): self.settings = settings self.settings_to_log = settings_to_log self.threshold = self.settings['threshold'] self.start_epoch = self.settings['start_epoch'] self.dataset = self.settings['dataset'] self.batch_size = self.settings['batch_size'] self.workers = self.settings['workers'] self.cuda = self.settings['cuda'] self.fp16 = self.settings['fp16'] self.epochs = self.settings['epochs'] self.ignore_index = self.settings['ignore_index'] self.loss_reduction = self.settings['loss_reduction'] # -------------------- Define Data loader ------------------------------ self.loaders, self.nclass, self.plotter = make_data_loader(settings) self.train_loader, self.val_loader, self.test_loader = [self.loaders[key] for key in ['train', 'val', 'test']] # -------------------- Define model ------------------------------------ self.model = get_model(self.settings) # -------------------- Define optimizer and its options ---------------- self.optimizer = define_optimizer(self.model, self.settings['optimizer'], self.settings['optimizer_params']) if self.settings['lr_scheduler']: self.lr_scheduler = LRScheduler(self.settings['lr_scheduler'], self.optimizer, self.batch_size) # -------------------- Define loss ------------------------------------- input_size = (self.batch_size, self.nclass, *self.settings['target_size']) self.criterion = CustomLoss(input_size=input_size, ignore_index=self.ignore_index, reduction=self.loss_reduction) self.evaluator = Evaluator(metrics=self.settings['metrics'], num_class=self.nclass, threshold=self.settings['threshold']) self.logger = MainLogger(loggers=self.settings['loggers'], settings=settings, settings_to_log=settings_to_log) if self.settings['resume']: self.resume_checkpoint(self.settings['resume']) self.metric_to_watch = 0.0
('finetune' , args.finetune), ('use_outer' , args.use_outer), ('box_usage', args.box_usage), ('feat_box' , feat_box), ('loss' , args.loss), ('optim' , args.optim), ('lr' , args.lr), ('lr_min' , args.lr_min), ('lr_decay' , args.lr_decay), ('weight_decay' , args.weight_decay), ('clip' , args.clip), ('encoder' , args.encoder), ('only_spatial' , args.only_spatial), ('phrase_context' , args.phrase_context), ('debug' , args.debug_mode)]) net = get_model(vocabs, config) if not os.path.exists(args.save_path): os.makedirs(args.save_path) snapshot_pfx = 'snapshot.' + ".".join([key.upper()+str(config[key]) for key in config.keys() if key[0] != 'f']) snapshot_model = os.path.join(args.save_path, snapshot_pfx + '.model') experiment_log = open(os.path.join(args.save_path, snapshot_pfx + '.log'),'w') out_file = os.path.join(args.save_path, snapshot_pfx + '.tst-eval.json') print("="*20) print("Starting training {} model".format(config['model'])) print("Snapshots {}.*\nDetails:".format(os.path.join(args.save_path, snapshot_pfx))) for key in config: print("{} : {}".format(key,config[key])) print("="*20)
def __init__(self): self.transforms = None self.index = 0 self.prev_index = -1 self.bridge = CvBridge() self.prev_seq = None self.just_started = True self.mode = rospy.get_param('~mode', 'stereo') self.plan = rospy.get_param('~plan', 0) self.return_mode = rospy.get_param('~return_mode', 0) print(self.mode, self.plan) params_file = 'real_sensor.json' # Planner self.planner = None if self.plan: self.planner = Planner(mode="real", params_file=params_file) # Params with open(params_file) as f: self.param = json.load(f) self.param["d_candi"] = img_utils.powerf(self.param["s_range"], self.param["e_range"], 64, 1.) # Gen Model Datum intrinsics = torch.tensor(self.param["intr_rgb"]).unsqueeze(0) / 4 intrinsics[0, 2, 2] = 1. intrinsics_up = torch.tensor(self.param["intr_rgb"]).unsqueeze(0) s_width = self.param["size_rgb"][0] / 4 s_height = self.param["size_rgb"][1] / 4 focal_length = np.mean( [intrinsics_up[0, 0, 0], intrinsics_up[0, 1, 1]]) h_fov = math.degrees( math.atan(intrinsics_up[0, 0, 2] / intrinsics_up[0, 0, 0]) * 2) v_fov = math.degrees( math.atan(intrinsics_up[0, 1, 2] / intrinsics_up[0, 1, 1]) * 2) pixel_to_ray_array = View.normalised_pixel_to_ray_array(\ width= int(s_width), height= int(s_height), hfov = h_fov, vfov = v_fov, normalize_z = True) pixel_to_ray_array_2dM = np.reshape( np.transpose(pixel_to_ray_array, axes=[2, 0, 1]), [3, -1]) pixel_to_ray_array_2dM = torch.from_numpy( pixel_to_ray_array_2dM.astype(np.float32)).unsqueeze(0) left_2_right = torch.tensor(self.param["left_2_right"]) if self.mode == "stereo" or self.mode == "stereo_lc": src_cam_poses = torch.cat( [left_2_right.unsqueeze(0), torch.eye(4).unsqueeze(0)]).unsqueeze(0) elif self.mode == "mono" or self.mode == "mono_lc": src_cam_poses = torch.cat( [torch.eye(4).unsqueeze(0), torch.eye(4).unsqueeze(0)]).unsqueeze(0) self.model_datum = dict() self.model_datum["intrinsics"] = intrinsics.cuda() self.model_datum["intrinsics_up"] = intrinsics_up.cuda() self.model_datum["unit_ray"] = pixel_to_ray_array_2dM.cuda() self.model_datum["src_cam_poses"] = src_cam_poses.cuda() self.model_datum["d_candi"] = self.param["d_candi"] self.model_datum["d_candi_up"] = self.param["d_candi"] self.model_datum["rgb"] = None self.model_datum["prev_output"] = None self.model_datum["prev_lc"] = None self.rgb_pinned = torch.zeros( (1, 2, 3, self.param["size_rgb"][1], self.param["size_rgb"][0])).float().pin_memory() self.dpv_pinned = torch.zeros( (1, 64, int(self.param["size_rgb"][1]), int(self.param["size_rgb"][0]))).float().pin_memory() self.pred_depth_pinned = torch.zeros( (int(self.param["size_rgb"][1]), int(self.param["size_rgb"][0]))).float().pin_memory() self.true_depth_pinned = torch.zeros( (int(self.param["size_rgb"][1]), int(self.param["size_rgb"][0]))).float().pin_memory() self.unc_pinned = torch.zeros(1, 64, int( self.param["size_rgb"][0])).float().pin_memory() __imagenet_stats = {'mean': [0.485, 0.456, 0.406],\ 'std': [0.229, 0.224, 0.225]} self.transformer = transforms.Normalize(**__imagenet_stats) # Load Model if self.mode == "stereo": model_name = 'default_stereo_ilim' elif self.mode == "mono": model_name = 'default_ilim' elif self.mode == "mono_lc": model_name = 'default_exp7_lc_ilim' elif self.mode == 'stereo_lc': model_name = 'default_stereo_exp7_lc_ilim' cfg_path = 'configs/' + model_name + '.json' model_path = '' with open(cfg_path) as f: self.cfg = EasyDict(json.load(f)) self.model = get_model(self.cfg, 0) epoch, weights = load_checkpoint('outputs/checkpoints/' + model_name + '/' + model_name + '_model_best.pth.tar') from collections import OrderedDict new_weights = OrderedDict() model_keys = list(self.model.state_dict().keys()) weight_keys = list(weights.keys()) for a, b in zip(model_keys, weight_keys): new_weights[a] = weights[b] weights = new_weights self.model.load_state_dict(weights) self.model = self.model.cuda() self.model.eval() print("Model Loaded") # ROS self.q_msg = deque([], 1) lth = ConsumerThread(self.q_msg, self.handle_msg) lth.setDaemon(True) lth.start() self.queue_size = 3 self.sync = functools.partial(ApproximateTimeSynchronizer, slop=0.01) self.left_camsub = message_filters.Subscriber( '/left_camera_resized/image_color_rect', sensor_msgs.msg.Image) self.right_camsub = message_filters.Subscriber( 'right_camera_resized/image_color_rect', sensor_msgs.msg.Image) self.depth_sub = message_filters.Subscriber( '/left_camera_resized/depth', sensor_msgs.msg.Image ) # , queue_size=self.queue_size, buff_size=2**24 self.ts = self.sync( [self.left_camsub, self.right_camsub, self.depth_sub], self.queue_size) self.ts.registerCallback(self.callback) self.prev_left_cammsg = None self.depth_pub = rospy.Publisher('ros_net/depth', sensor_msgs.msg.Image, queue_size=self.queue_size) self.depth_color_pub = rospy.Publisher('ros_net/depth_color', sensor_msgs.msg.Image, queue_size=self.queue_size) self.depth_lc_pub = rospy.Publisher('ros_net/depth_lc', sensor_msgs.msg.Image, queue_size=self.queue_size) self.dpv_pub = rospy.Publisher('ros_net/dpv_pub', TensorMsg, queue_size=self.queue_size) self.unc_pub = rospy.Publisher('ros_net/unc_pub', TensorMsg, queue_size=self.queue_size) self.debug_pub = rospy.Publisher('ros_net/debug', sensor_msgs.msg.Image, queue_size=self.queue_size) self.debug2_pub = rospy.Publisher('ros_net/debug2', sensor_msgs.msg.Image, queue_size=self.queue_size) self.sensed_pub = rospy.Publisher('ros_net/sensed_pub', TensorMsg, queue_size=self.queue_size)
def main(): setup_default_logging() args, args_text = _parse_args() args.prefetcher = not args.no_prefetcher args.distributed = False if 'WORLD_SIZE' in os.environ: args.distributed = int(os.environ['WORLD_SIZE']) > 1 if args.distributed and args.num_gpu > 1: logging.warning('Using more than one GPU per process in distributed mode is not allowed. Setting num_gpu to 1.') args.num_gpu = 1 args.device = 'cuda:0' args.world_size = 1 args.rank = 0 # global rank if args.distributed: args.num_gpu = 1 args.device = 'cuda:%d' % args.local_rank torch.cuda.set_device(args.local_rank) torch.distributed.init_process_group(backend='nccl', init_method='env://') args.world_size = torch.distributed.get_world_size() args.rank = torch.distributed.get_rank() assert args.rank >= 0 if args.distributed: logging.info('Training in distributed mode with multiple processes, 1 GPU per process. Process %d, total %d.' % (args.rank, args.world_size)) else: logging.info('Training with a single process on %d GPUs.' % args.num_gpu) torch.manual_seed(args.seed + args.rank) # my model use_aux = args.aux_weight > 0. if args.model_method == 'darts_NAS': if args.genotype is None: args.genotype = get_model.get_model(args.model_method, args.model_name) model = AugmentCNN_ImageNet(224, 3, args.init_channels, args.num_classes, args.layers, use_aux, args.genotype) elif args.model_method == 'my_model_collection': from models.my_searched_model import my_specialized _ = args.model_name.split(':') net_config_path = os.path.join(project_path, 'models', 'my_model_collection', _[0], _[1] + '.json') model = my_specialized(num_classes=args.num_classes, net_config=net_config_path, dropout_rate=args.drop) else: model_fun = get_model.get_model(args.model_method, args.model_name) model = model_fun(num_classes=args.num_classes, dropout_rate=args.drop) # set bn model.set_bn_param(args.bn_momentum, args.bn_eps) # model init model.init_model(model_init=args.model_init) # pdb.set_trace() # model = create_model( # args.model, # pretrained=args.pretrained, # num_classes=args.num_classes, # drop_rate=args.drop, # drop_connect_rate=args.drop_connect, # global_pool=args.gp, # bn_tf=args.bn_tf, # bn_momentum=args.bn_momentum, # bn_eps=args.bn_eps, # checkpoint_path=args.initial_checkpoint) if args.local_rank == 0: logging.info('Model %s created, param count: %d' % (args.model, sum([m.numel() for m in model.parameters()]))) data_config = resolve_data_config(vars(args), model=model, verbose=args.local_rank == 0) num_aug_splits = 0 if args.aug_splits > 0: assert args.aug_splits > 1, 'A split of 1 makes no sense' num_aug_splits = args.aug_splits if args.split_bn: assert num_aug_splits > 1 or args.resplit model = convert_splitbn_model(model, max(num_aug_splits, 2)) if args.num_gpu > 1: if args.amp: logging.warning( 'AMP does not work well with nn.DataParallel, disabling. Use distributed mode for multi-GPU AMP.') args.amp = False model = nn.DataParallel(model, device_ids=list(range(args.num_gpu))).cuda() else: model.cuda() optimizer = create_optimizer(args, model) use_amp = False if has_apex and args.amp: model, optimizer = amp.initialize(model, optimizer, opt_level='O1') use_amp = True if args.local_rank == 0: logging.info('NVIDIA APEX {}. AMP {}.'.format( 'installed' if has_apex else 'not installed', 'on' if use_amp else 'off')) # optionally resume from a checkpoint resume_state = {} resume_epoch = None if args.resume: resume_state, resume_epoch = resume_checkpoint(model, args.resume) if resume_state and not args.no_resume_opt: if 'optimizer' in resume_state: if args.local_rank == 0: logging.info('Restoring Optimizer state from checkpoint') optimizer.load_state_dict(resume_state['optimizer']) if use_amp and 'amp' in resume_state and 'load_state_dict' in amp.__dict__: if args.local_rank == 0: logging.info('Restoring NVIDIA AMP state from checkpoint') amp.load_state_dict(resume_state['amp']) del resume_state model_ema = None if args.model_ema: # Important to create EMA model after cuda(), DP wrapper, and AMP but before SyncBN and DDP wrapper model_ema = ModelEma( model, decay=args.model_ema_decay, device='cpu' if args.model_ema_force_cpu else '', resume=args.resume) if args.distributed: if args.sync_bn: assert not args.split_bn try: if has_apex: model = convert_syncbn_model(model) else: model = torch.nn.SyncBatchNorm.convert_sync_batchnorm(model) if args.local_rank == 0: logging.info( 'Converted model to use Synchronized BatchNorm. WARNING: You may have issues if using ' 'zero initialized BN layers (enabled by default for ResNets) while sync-bn enabled.') except Exception as e: logging.error('Failed to enable Synchronized BatchNorm. Install Apex or Torch >= 1.1') if has_apex: model = DDP(model, delay_allreduce=True) else: if args.local_rank == 0: logging.info("Using torch DistributedDataParallel. Install NVIDIA Apex for Apex DDP.") model = DDP(model, device_ids=[args.local_rank]) # can use device str in Torch >= 1.1 # NOTE: EMA model does not need to be wrapped by DDP lr_scheduler, num_epochs = create_scheduler(args, optimizer) start_epoch = 0 if args.start_epoch is not None: # a specified start_epoch will always override the resume epoch start_epoch = args.start_epoch elif resume_epoch is not None: start_epoch = resume_epoch if lr_scheduler is not None and start_epoch > 0: lr_scheduler.step(start_epoch) if args.local_rank == 0: logging.info('Scheduled epochs: {}'.format(num_epochs)) train_dir = os.path.join(args.data, 'train') if not os.path.exists(train_dir): logging.error('Training folder does not exist at: {}'.format(train_dir)) exit(1) dataset_train = Dataset(train_dir) collate_fn = None if args.prefetcher and args.mixup > 0: assert not num_aug_splits # collate conflict (need to support deinterleaving in collate mixup) collate_fn = FastCollateMixup(args.mixup, args.smoothing, args.num_classes) if num_aug_splits > 1: dataset_train = AugMixDataset(dataset_train, num_splits=num_aug_splits) loader_train = create_loader( dataset_train, input_size=data_config['input_size'], batch_size=args.batch_size, is_training=True, use_prefetcher=args.prefetcher, re_prob=args.reprob, re_mode=args.remode, re_count=args.recount, re_split=args.resplit, color_jitter=args.color_jitter, auto_augment=args.aa, num_aug_splits=num_aug_splits, interpolation=args.train_interpolation, mean=data_config['mean'], std=data_config['std'], num_workers=args.workers, distributed=args.distributed, collate_fn=collate_fn, pin_memory=args.pin_mem, ) eval_dir = os.path.join(args.data, 'val') if not os.path.isdir(eval_dir): eval_dir = os.path.join(args.data, 'validation') if not os.path.isdir(eval_dir): logging.error('Validation folder does not exist at: {}'.format(eval_dir)) exit(1) dataset_eval = Dataset(eval_dir) loader_eval = create_loader( dataset_eval, input_size=data_config['input_size'], batch_size=args.validation_batch_size_multiplier * args.batch_size, is_training=False, use_prefetcher=args.prefetcher, interpolation=data_config['interpolation'], mean=data_config['mean'], std=data_config['std'], num_workers=args.workers, distributed=args.distributed, crop_pct=data_config['crop_pct'], pin_memory=args.pin_mem, ) if args.jsd: assert num_aug_splits > 1 # JSD only valid with aug splits set train_loss_fn = JsdCrossEntropy(num_splits=num_aug_splits, smoothing=args.smoothing).cuda() validate_loss_fn = nn.CrossEntropyLoss().cuda() elif args.mixup > 0.: # smoothing is handled with mixup label transform train_loss_fn = SoftTargetCrossEntropy().cuda() validate_loss_fn = nn.CrossEntropyLoss().cuda() elif args.smoothing: train_loss_fn = LabelSmoothingCrossEntropy(smoothing=args.smoothing).cuda() validate_loss_fn = nn.CrossEntropyLoss().cuda() else: train_loss_fn = nn.CrossEntropyLoss().cuda() validate_loss_fn = train_loss_fn eval_metric = args.eval_metric best_metric = None best_epoch = None saver = None output_dir = '' if args.local_rank == 0: output_base = args.output if args.output else './output' exp_name = '-'.join([ datetime.now().strftime("%Y%m%d-%H%M%S"), args.model_method, args.model_name, str(data_config['input_size'][-1]) ]) output_dir = get_outdir(output_base, 'train', exp_name) decreasing = True if eval_metric == 'loss' else False saver = CheckpointSaver(checkpoint_dir=output_dir, decreasing=decreasing) with open(os.path.join(output_dir, 'args.yaml'), 'w') as f: f.write(args_text) try: for epoch in range(start_epoch, num_epochs): if args.distributed: loader_train.sampler.set_epoch(epoch) train_metrics = train_epoch( epoch, model, loader_train, optimizer, train_loss_fn, args, lr_scheduler=lr_scheduler, saver=saver, output_dir=output_dir, use_amp=use_amp, model_ema=model_ema) if args.distributed and args.dist_bn in ('broadcast', 'reduce'): if args.local_rank == 0: logging.info("Distributing BatchNorm running means and vars") distribute_bn(model, args.world_size, args.dist_bn == 'reduce') eval_metrics = validate(model, loader_eval, validate_loss_fn, args) if model_ema is not None and not args.model_ema_force_cpu: if args.distributed and args.dist_bn in ('broadcast', 'reduce'): distribute_bn(model_ema, args.world_size, args.dist_bn == 'reduce') ema_eval_metrics = validate( model_ema.ema, loader_eval, validate_loss_fn, args, log_suffix=' (EMA)') eval_metrics = ema_eval_metrics if lr_scheduler is not None: # step LR for next epoch lr_scheduler.step(epoch + 1, eval_metrics[eval_metric]) update_summary( epoch, train_metrics, eval_metrics, os.path.join(output_dir, 'summary.csv'), write_header=best_metric is None) if saver is not None: # save proper checkpoint with eval metric save_metric = eval_metrics[eval_metric] best_metric, best_epoch = saver.save_checkpoint( model, optimizer, args, epoch=epoch, model_ema=model_ema, metric=save_metric, use_amp=use_amp) except KeyboardInterrupt: pass if best_metric is not None: logging.info('*** Best metric: {0} (epoch {1})'.format(best_metric, best_epoch))
def main(): logger.info("Logger is set - training start") # set default gpu device id # torch.cuda.set_device(config.gpus[0]) # set seed np.random.seed(config.seed) torch.manual_seed(config.seed) torch.cuda.manual_seed_all(config.seed) if config.deterministic: torch.backends.cudnn.benchmark = False torch.backends.cudnn.deterministic = True torch.backends.cudnn.enabled = True else: torch.backends.cudnn.benchmark = True # get data with meta info if config.data_loader_type == 'torch': input_size, input_channels, n_classes, train_data, valid_data = get_data.get_data( config.dataset, config.data_path, config.cutout_length, auto_augmentation=config.auto_augmentation) train_loader = torch.utils.data.DataLoader(train_data, batch_size=config.batch_size, shuffle=True, num_workers=config.workers, pin_memory=True) valid_loader = torch.utils.data.DataLoader(valid_data, batch_size=config.batch_size, shuffle=False, num_workers=config.workers, pin_memory=True) elif config.data_loader_type == 'dali': input_size, input_channels, n_classes, train_data, valid_data = get_data.get_data_dali( config.dataset, config.data_path, batch_size=config.batch_size, num_threads=config.workers) train_loader = train_data valid_loader = valid_data else: raise NotImplementedError if config.label_smoothing > 0: from utils import LabelSmoothLoss criterion = LabelSmoothLoss(smoothing=config.label_smoothing).to(device) else: criterion = nn.CrossEntropyLoss().to(device) use_aux = config.aux_weight > 0. if config.model_method == 'darts_NAS': if config.genotype is None: config.genotype = get_model.get_model(config.model_method, config.model_name) if 'imagenet' in config.dataset.lower(): model = AugmentCNN_ImageNet(input_size, input_channels, config.init_channels, n_classes, config.layers, use_aux, config.genotype) else: model = AugmentCNN(input_size, input_channels, config.init_channels, n_classes, config.layers, use_aux, config.genotype) elif config.model_method == 'my_model_collection': from models.my_searched_model import my_specialized if config.structure_path is None: _ = config.model_name.split(':') net_config_path = os.path.join(project_path, 'models', 'my_model_collection', _[0], _[1] + '.json') else: net_config_path = config.structure_path model = my_specialized(num_classes=n_classes, net_config=net_config_path, dropout_rate=config.dropout_rate) else: model_fun = get_model.get_model(config.model_method, config.model_name) model = model_fun(num_classes=n_classes, dropout_rate=config.dropout_rate) # set bn model.set_bn_param(config.bn_momentum, config.bn_eps) # model init model.init_model(model_init=config.model_init) model.cuda() # model size total_ops, total_params = flops_counter.profile(model, [1, input_channels, input_size, input_size]) logger.info("Model size = {:.3f} MB".format(total_params)) logger.info("Model FLOPS with input {} = {:.3f} M".format(str([1, input_channels, input_size, input_size]), total_ops)) total_ops, total_params = flops_counter.profile(model, [1, 3, 224, 224]) logger.info("Model FLOPS with input [1,3,224,224] {:.3f} M".format(total_ops)) model = nn.DataParallel(model).to(device) # weights optimizer if not config.no_decay_keys == 'None': keys = config.no_decay_keys.split('#') optimizer = torch.optim.SGD([ {'params': model.module.get_parameters(keys, mode='exclude'), 'weight_decay': config.weight_decay}, {'params': model.module.get_parameters(keys, mode='include'), 'weight_decay': 0}, ], lr=config.lr, momentum=config.momentum) else: optimizer = torch.optim.SGD(model.parameters(), config.lr, momentum=config.momentum, weight_decay=config.weight_decay) lr_scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, config.epochs) best_top1 = 0. # training loop _size = get_iterator_length(train_loader) for epoch in range(config.epochs): lr_scheduler.step() if config.drop_path_prob > 0: drop_prob = config.drop_path_prob * epoch / config.epochs model.module.drop_path_prob(drop_prob) # training train(train_loader, model, optimizer, criterion, epoch) # validation cur_step = (epoch+1) * _size top1 = validate(valid_loader, model, criterion, epoch, cur_step) # save if best_top1 < top1: best_top1 = top1 is_best = True logger.info("Current best Prec@1 = {:.4%}".format(best_top1)) else: is_best = False utils.save_checkpoint(model, config.path, is_best) print("") logger.info("Final best Prec@1 = {:.4%}".format(best_top1))
class DatasetSplit(Dataset): def __init__(self, dataset, idxs): self.dataset = dataset self.idxs = list(idxs) def __len__(self): return len(self.idxs) def __getitem__(self, item): image, label = self.dataset[self.idxs[item]] return image, label model = get_model(model_name, dataset, rand_seed=seed, step_size=step_size, device=device, flatten_weight=flatten_weight) stat = CollectStatistics(results_file_name=fl_results_file_path) train_loader_list = [] dataiter_list = [] for n in range(n_nodes): train_loader_list.append( DataLoader(DatasetSplit(data_train, dict_users[n]), batch_size=batch_size_train, shuffle=True)) dataiter_list.append(iter(train_loader_list[n])) w_global_init = model.get_weight() w_global = copy.deepcopy(w_global_init)
def main(): print("evaluate start") # set default gpu device id # torch.cuda.set_device(config.gpus[0]) # set seed np.random.seed(config.seed) torch.manual_seed(config.seed) torch.cuda.manual_seed_all(config.seed) if config.deterministic: torch.backends.cudnn.benchmark = False torch.backends.cudnn.deterministic = True torch.backends.cudnn.enabled = True else: torch.backends.cudnn.benchmark = True # get data with meta info if config.data_loader_type == 'torch': input_size, input_channels, n_classes, train_data, valid_data = get_data.get_data( config.dataset, config.data_path, config.cutout_length, auto_augmentation=config.auto_augmentation) # train_loader = torch.utils.data.DataLoader(train_data, # batch_size=config.batch_size, # shuffle=True, # num_workers=config.workers, # pin_memory=True) valid_loader = torch.utils.data.DataLoader( valid_data, batch_size=config.batch_size, shuffle=False, num_workers=config.workers, pin_memory=False) elif config.data_loader_type == 'dali': input_size, input_channels, n_classes, train_data, valid_data = get_data.get_data_dali( config.dataset, config.data_path, batch_size=config.batch_size, num_threads=config.workers) # train_loader = train_data valid_loader = valid_data else: raise NotImplementedError use_aux = config.aux_weight > 0. if config.model_method == 'darts_NAS': if config.genotype is None: config.genotype = get_model.get_model(config.model_method, config.model_name) if 'imagenet' in config.dataset.lower(): model = AugmentCNN_ImageNet(input_size, input_channels, config.init_channels, n_classes, config.layers, use_aux, config.genotype) else: model = AugmentCNN(input_size, input_channels, config.init_channels, n_classes, config.layers, use_aux, config.genotype) elif config.model_method == 'my_model_collection': from models.my_searched_model import my_specialized if config.structure_path is None: _ = config.model_name.split(':') net_config_path = os.path.join(project_path, 'models', 'my_model_collection', _[0], _[1] + '.json') else: net_config_path = config.structure_path # model = my_specialized(num_classes=n_classes, net_config=net_config_path, # dropout_rate=config.dropout_rate) model = my_specialized(num_classes=n_classes, net_config=net_config_path, dropout_rate=0) else: model_fun = get_model.get_model(config.model_method, config.model_name) # model = model_fun(num_classes=n_classes, dropout_rate=config.dropout_rate) model = model_fun(num_classes=n_classes, dropout_rate=0) # load model ckpt = torch.load(config.pretrained) print(ckpt.keys()) # for k in model: # print(k) # return # set bn # model.set_bn_param(config.bn_momentum, config.bn_eps) for _key in list(ckpt['state_dict_ema'].keys()): if 'total_ops' in _key or 'total_params' in _key: del ckpt['state_dict_ema'][_key] model.load_state_dict(ckpt['state_dict_ema']) # model init # model.init_model(model_init=config.model_init) model.cuda() # model size total_ops, total_params = flops_counter.profile( model, [1, input_channels, input_size, input_size]) print("Model size = {:.3f} MB".format(total_params)) print("Model FLOPS with input {} = {:.3f} M".format( str([1, input_channels, input_size, input_size]), total_ops)) total_ops, total_params = flops_counter.profile(model, [1, 3, 224, 224]) print("Model FLOPS with input [1,3,224,224] {:.3f} M".format(total_ops)) model = nn.DataParallel(model).to(device) # CRITERION if config.label_smoothing > 0: from utils import LabelSmoothLoss criterion = LabelSmoothLoss( smoothing=config.label_smoothing).to(device) else: criterion = nn.CrossEntropyLoss().to(device) best_top1 = validate(valid_loader, model, criterion, 0, 0) print("Final best Prec@1 = {:.4%}".format(best_top1))
def save_cams(config: Config): config_json = config.toDictionary() print('save_cams') print(config_json) import shutil import cv2 import os import numpy as np from torch.utils.data.dataloader import DataLoader from data.loader_segmentation import Segmentation from artifacts.artifact_manager import artifact_manager # Set up model model = get_model(config.classifier_name) model.load() model.eval() model.to(model.device) # Set up data loader dataloader = DataLoader(Segmentation( config.classifier_dataset_root, source='train', augmentation='val', image_size=config.classifier_image_size, requested_labels=['classification', 'segmentation']), batch_size=config.cams_produce_batch_size, shuffle=False, num_workers=4, prefetch_factor=4) # Clear and create destination directory cam_path = os.path.join(artifact_manager.getDir(), 'cam') if (os.path.exists(cam_path)): shutil.rmtree(cam_path) os.makedirs(cam_path) label_cam_path = os.path.join(artifact_manager.getDir(), 'labels_cam') if (os.path.exists(label_cam_path)): shutil.rmtree(label_cam_path) os.makedirs(label_cam_path) for batch_no, batch in enumerate(dataloader): inputs_in = batch[0] labels_in = batch[1] datapacket_in = batch[2] # Run images through model and get raw cams with torch.no_grad(): cams = model.event({ 'name': 'get_cam', 'inputs': inputs_in, 'labels': labels_in, 'batch': batch_no + 1 }) # Save out cams for cam_no, cam in enumerate(cams): # Save out ground truth labels for testing the rest of the system if config.cams_save_gt_labels: cam = labels_in['segmentation'][cam_no][1:] cam = F.adaptive_avg_pool2d(cam, [32, 32]).numpy() for i in range(0, cam.shape[0]): cam[i] = cv2.blur(cam[i], (3, 3)) cam[i] = cv2.blur(cam[i], (3, 3)) # Disregard false positives gt_mask = labels_in['classification'][cam_no].numpy() gt_mask[gt_mask > 0.5] = 1 gt_mask[gt_mask <= 0.5] = 0 gt_mask = np.expand_dims(np.expand_dims(gt_mask, -1), -1) cam *= gt_mask # Scale CAM to match input size cam = np.moveaxis(cam, 0, -1) cam = cv2.resize( cam, (config.classifier_image_size, config.classifier_image_size), interpolation=cv2.INTER_LINEAR) cam = np.moveaxis(cam, -1, 0) # - Cut CAM from input size and upscale to original image size width = datapacket_in['width'][cam_no].detach().numpy() height = datapacket_in['height'][cam_no].detach().numpy() content_width = datapacket_in['content_width'][cam_no].detach( ).numpy() content_height = datapacket_in['content_height'][cam_no].detach( ).numpy() cam = cam[:, 0:content_height, 0:content_width] cam = np.moveaxis(cam, 0, -1) cam = cv2.resize(cam, (width, height), interpolation=cv2.INTER_LINEAR) cam = np.moveaxis(cam, -1, 0) # Normalize each cam map to between 0 and 1 cam_max = np.max(cam, (1, 2), keepdims=True) cam_norm = cam / (cam_max + 1e-5) cam_bg = ( 1 - np.max(cam_norm, axis=0, keepdims=True))**config.cams_bg_alpha cam_with_bg = np.concatenate((cam_bg, cam_norm), axis=0) label_cam = label_to_image(cam_with_bg) # Collapse cam from 3d into long 2d cam_norm = np.reshape( cam_norm, (cam_norm.shape[0] * cam_norm.shape[1], cam_norm.shape[2])) cam_norm[cam_norm > 1] = 1 cam_norm[cam_norm < 0] = 0 label_cam[label_cam > 1] = 1 label_cam[label_cam < 0] = 0 # Write image img_no = datapacket_in['image_name'][cam_no] cv2.imwrite( os.path.join(cam_path, img_no) + '.png', cam_norm * 255) cv2.imwrite( os.path.join(label_cam_path, img_no) + '.png', label_cam * 255) print('Save cam : ', img_no, end='\r') print('')
import socket import time import numpy as np from control_algorithm.adaptive_tau import ControlAlgAdaptiveTauServer from data_reader.data_reader import get_data from models.get_model import get_model from statistic.collect_stat import CollectStatistics from util.utils import send_msg, recv_msg, get_indices_each_node_case # Configurations are in a separate config.py file from config import * model = get_model(model_name) if hasattr(model, 'create_graph'): model.create_graph(learning_rate=step_size) if time_gen is not None: use_fixed_averaging_slots = True else: use_fixed_averaging_slots = False if batch_size < total_data: # Read all data once when using stochastic gradient descent train_image, train_label, test_image, test_label, train_label_orig = get_data(dataset, total_data, dataset_file_path) # This function takes a long time to complete, # putting it outside of the sim loop because there is no randomness in the current way of computing the indices indices_each_node_case = get_indices_each_node_case(n_nodes, MAX_CASE, train_label_orig) listening_sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
def train_net(args, logger, seed): os.environ["CUDA_VISIBLE_DEVICES"] = args.gpu_id logger.info('seed={}'.format(seed)) # init seed torch.manual_seed(seed) torch.cuda.manual_seed(seed) random.seed(seed) np.random.seed(seed) # cudnn.benchmark = True cudnn.benchmark = False cudnn.deterministic = True # cudnn writer = SummaryWriter(args.outpath) start_epoch = 0 val_best_acc = 0 val_best_acc_index = 0 # data_loader train_loader, val_loader, target_class_num, dataset_sizes = \ get_target_dataloader(args.target_dataset, args.batch_size, args.num_workers, args.target_data_dir, image_size=args.image_size, data_aug=args.data_aug, logger=logger) # model setting model_source, model_target = get_model(args.base_model_name, args.base_task, logger, args) # target_model split: (feature, classifier) model_feature, model_source_classifier, model_target_classifier = \ model_split(args.base_model_name, model_target, target_class_num, logger, args) if len(args.gpu_id) > 1: model_source = nn.DataParallel(model_source) model_feature = nn.DataParallel(model_feature) model_source_classifier = nn.DataParallel(model_source_classifier) model_target_classifier = nn.DataParallel(model_target_classifier) model_source = model_source.cuda() model_feature = model_feature.cuda() model_target_classifier = model_target_classifier.cuda() model_source_classifier = model_source_classifier.cuda() logger.info("push all model to dataparallel and then gpu") else: model_source = model_source.cuda() model_feature = model_feature.cuda() model_target_classifier = model_target_classifier.cuda() model_source_classifier = model_source_classifier.cuda() logger.info("push all model to gpu") # iterations -> epochs num_epochs = int(np.round(args.max_iter * args.batch_size / dataset_sizes)) step = [int(0.67 * num_epochs)] logger.info('num_epochs={}, step={}'.format(num_epochs, step)) # loss loss_fn = get_loss_type(loss_type=args.loss_type, logger=logger) # get feature_criterions if args.reg_type in ['channel_att_fea_map_learn', 'fea_loss']: feature_criterions = get_reg_criterions(args, logger) # optimizer and lr_scheduler optimizer, lr_scheduler = get_optimier_and_scheduler( args, model_feature, model_target_classifier, feature_criterions, step, logger) # init framework framework = TransferFramework(args, train_loader, val_loader, target_class_num, args.data_aug, args.base_model_name, model_source, model_feature, model_source_classifier, model_target_classifier, feature_criterions, loss_fn, num_epochs, optimizer, lr_scheduler, writer, logger, print_freq=args.print_freq) # epochs for epoch in range(start_epoch, num_epochs): # train epoch clc_loss, kl_loss, fea_loss, train_total_loss, train_top1_acc = framework.train( epoch) # val epoch val_loss, val_top1_acc = framework.val(epoch) # record into txt ours_record_epoch_data(args.outpath, epoch, clc_loss, kl_loss, fea_loss, train_total_loss, train_top1_acc, val_loss, val_top1_acc) if val_top1_acc >= val_best_acc: val_best_acc = val_top1_acc val_best_acc_index = epoch # save_checkpoint save_checkpoint(args.outpath, epoch, model_feature, model_source_classifier, model_target_classifier, optimizer, lr_scheduler, val_best_acc) logger.info( '||==>Val Epoch: Val_best_acc_index={}\tVal_best_acc={:.4f}\n'. format(val_best_acc_index, val_best_acc)) # break return val_best_acc
# Generate color palette palette = {0: (0, 0, 0)} for k, color in enumerate(sns.color_palette("hls", N_CLASSES + 1)): palette[k + 1] = tuple(np.asarray(255 * np.array(color), dtype='uint8')) def color_results(arr2d, palette): arr_3d = np.zeros((arr2d.shape[0], arr2d.shape[1], 3), dtype=np.uint8) for c, i in palette.items(): m = arr2d == c arr_3d[m] = i return arr_3d #load model and weights model = get_model(MODEL, args.dataset, N_CLASSES, N_BANDS, PATCH_SIZE) print('Loading weights from %s' % WEIGHTS + '/model_best.pth') model = model.to(device) model.load_state_dict(torch.load(WEIGHTS + '/model_best.pth')) model.eval() #testing model probabilities = test(model, WEIGHTS, img, PATCH_SIZE, N_CLASSES, device=device) prediction = np.argmax(probabilities, axis=-1) run_results = metrics(prediction, gt, n_classes=N_CLASSES) prediction[gt < 0] = -1 #color results colored_gt = color_results(gt + 1, palette)
def save_semseg( dataset_root, model_name, batch_size=8, image_size=256, use_gt_labels=False, ): print('Save semseg : ', locals()) import shutil import cv2 import os import numpy as np import torch.nn.functional as F import torch from models.get_model import get_model from torch.utils.data.dataloader import DataLoader from data.loader_segmentation import Segmentation from artifacts.artifact_manager import artifact_manager from data.voc2012 import label_to_image # Set up model model = get_model(model_name) model.load() model.to(model.device) model.train(False) # Set up data loader dataloader = DataLoader( Segmentation(dataset_root, source='val', source_augmentation='val', image_size=image_size, requested_labels=['classification', 'segmentation']), batch_size=batch_size, shuffle=False, num_workers=4, prefetch_factor=4, ) # Clear and create destination directory semseg_path = os.path.join(artifact_manager.getDir(), 'semseg_output') if (os.path.exists(semseg_path)): shutil.rmtree(semseg_path) os.makedirs(semseg_path) for batch_no, batch in enumerate(dataloader): inputs_in = batch[0] labels_in = batch[1] datapacket_in = batch[2] # Run images through model and get raw cams with torch.no_grad(): semsegs = model.event({ 'name': 'get_semseg', 'inputs': inputs_in, 'labels': labels_in, 'batch': batch_no + 1 }) semsegs = semsegs.detach().cpu().numpy() # Save out cams for semseg_no, semseg in enumerate(semsegs): # Save out ground truth labels for testing the rest of the system if use_gt_labels: semseg = labels_in['segmentation'][semseg_no][1:] semseg = F.adaptive_avg_pool2d(semseg, [32, 32]).numpy() for i in range(0, semseg.shape[0]): semseg[i] = cv2.blur(semseg[i], (3, 3)) semseg[i] = cv2.blur(semseg[i], (3, 3)) # # Disregard false positives # gt_mask = labels_in['classification'][semseg_no].numpy() # gt_mask[gt_mask > 0.5] = 1 # gt_mask[gt_mask <= 0.5] = 0 # gt_mask = np.expand_dims(np.expand_dims(gt_mask, -1), -1) # cam *= gt_mask # Upsample CAM to original image size # - Calculate original image aspect ratio width = datapacket_in['width'][semseg_no].detach().numpy() height = datapacket_in['height'][semseg_no].detach().numpy() aspect_ratio = width / height # - Calculate width and height to cut from upscaled CAM if aspect_ratio > 1: cut_width = image_size cut_height = round(image_size / aspect_ratio) else: cut_width = round(image_size * aspect_ratio) cut_height = image_size # - Upscale CAM to match input size semseg = np.moveaxis(semseg, 0, -1) semseg = cv2.resize(semseg, (image_size, image_size), interpolation=cv2.INTER_LINEAR) semseg = np.moveaxis(semseg, -1, 0) # - Cut CAM from input size and upscale to original image size semseg = semseg[:, 0:cut_height, 0:cut_width] semseg = np.moveaxis(semseg, 0, -1) semseg = cv2.resize(semseg, (width, height), interpolation=cv2.INTER_LINEAR) semseg = np.moveaxis(semseg, -1, 0) semseg_as_label = label_to_image(semseg) # Write image img_no = datapacket_in['image_name'][semseg_no] cv2.imwrite( os.path.join(semseg_path, img_no) + '.png', semseg_as_label * 255) print('Save cam : ', img_no, end='\r') print('')
def save_labels( dataset_root, model_name, batch_size=8, image_size=256, use_gt_labels=False, ): print('Save cams : ', locals()) import shutil import cv2 import os import numpy as np from torch.utils.data.dataloader import DataLoader from data.loader_segmentation import Segmentation from artifacts.artifact_manager import artifact_manager # Set up model model = get_model(model_name) model.load() model.to(model.device) # Set up data loader dataloader = DataLoader( Segmentation( dataset_root, source='trainval', source_augmentation='val', image_size=image_size, requested_labels=['classification', 'segmentation'] ), batch_size=batch_size, shuffle=False, num_workers=4, ) # Clear and create desintation directory cam_path = os.path.join(artifact_manager.getDir(), 'cam') if (os.path.exists(cam_path)): shutil.rmtree(cam_path) os.makedirs(cam_path) for batch_no, batch in enumerate(dataloader): inputs_in = batch[0] labels_in = batch[1] datapacket_in = batch[2] # Run images through model and get raw cams with torch.no_grad(): cams = model.event({ 'name': 'get_cam', 'inputs': inputs_in, 'labels': labels_in, 'batch': batch_no+1 }) # Save out cams for cam_no, cam in enumerate(cams): # Save out ground truth labels for testing the rest of the system if use_gt_labels: cam = labels_in['segmentation'][cam_no][1:] cam = F.adaptive_avg_pool2d(cam, [32, 32]).numpy() for i in range(0, cam.shape[0]): cam[i] = cv2.blur(cam[i], (3, 3)) cam[i] = cv2.blur(cam[i], (3, 3)) # Disregard false positives gt_mask = labels_in['classification'][cam_no].numpy() gt_mask[gt_mask > 0.5] = 1 gt_mask[gt_mask <= 0.5] = 0 gt_mask = np.expand_dims(np.expand_dims(gt_mask, -1), -1) cam *= gt_mask # Upsample CAM to original image size # - Calculate original image aspect ratio width = datapacket_in['width'][cam_no].detach().numpy() height = datapacket_in['height'][cam_no].detach().numpy() aspect_ratio = width / height # - Calculate width and height to cut from upscaled CAM if aspect_ratio > 1: cut_width = image_size cut_height = round(image_size / aspect_ratio) else: cut_width = round(image_size * aspect_ratio) cut_height = image_size # - Upscale CAM to match input size cam = np.moveaxis(cam, 0, -1) cam = cv2.resize(cam, (image_size, image_size), interpolation=cv2.INTER_LINEAR) cam = np.moveaxis(cam, -1, 0) # - Cut CAM from input size and upscale to original image size cam = cam[:, 0:cut_height, 0:cut_width] cam = np.moveaxis(cam, 0, -1) cam = cv2.resize(cam, (width, height), interpolation=cv2.INTER_LINEAR) cam = np.moveaxis(cam, -1, 0) # Normalize each cam map to between 0 and 1 cam_max = np.max(cam, (1, 2), keepdims=True) cam_norm = cam / (cam_max + 1e-5) # Collapse cam from 3d into long 2d cam_norm = np.reshape(cam_norm, (cam_norm.shape[0] * cam_norm.shape[1], cam_norm.shape[2])) cam_norm[cam_norm > 1] = 1 cam_norm[cam_norm < 0] = 0 # Write image img_no = datapacket_in['image_name'][cam_no] cv2.imwrite(os.path.join(cam_path, img_no) + '.png', cam_norm * 255) print('Save cam : ', img_no, end='\r') print('')
model_name = msg[1] dataset = msg[2] num_iterations_with_same_minibatch_for_tau_equals_one = msg[3] step_size = msg[4] batch_size = msg[5] total_data = msg[6] control_alg_server_instance = msg[7] indices_this_node = msg[8] read_all_data_for_stochastic = msg[9] use_min_loss = msg[10] sim = msg[11] c_comp = msg[12] w_file += str(indices_this_node) model = get_model(model_name) model2 = get_model( model_name ) # Used for computing loss_w_prev_min_loss for stochastic gradient descent, # so that the state of model can be still used by control algorithm later. if hasattr(model, 'create_graph'): model.create_graph(learning_rate=step_size) if hasattr(model2, 'create_graph'): model2.create_graph(learning_rate=step_size) # Assume the dataset does not change if read_all_data_for_stochastic or batch_size >= total_data: if batch_size_prev != batch_size or total_data_prev != total_data or ( batch_size >= total_data and sim_prev != sim): print('Reading all data samples used in training...')
from options.train_options import TrainOptions from data.get_dataset import get_dataset from models.get_model import get_model if __name__ == '__main__': opt = TrainOptions().parse() # get training options dataset = get_dataset(opt) dataloader = torch.utils.data.DataLoader( dataset, batch_size=opt.batch_size, shuffle=True, collate_fn=dataset.collate_fn ) model = get_model(opt) optimizer = torch.optim.Adam(model.parameters(), lr=opt.lr) num_batches = int(len(dataloader) / opt.batch_size) for epoch in range(opt.start_epochs, opt.start_epochs+opt.epochs): for i, (img_path, imgs, targets) in enumerate(dataloader): if len(opt.gpu_ids) > 0: model = model.to(opt.device) imgs = Variable(imgs.to(opt.device)) if targets is not None: targets = Variable(targets.to(opt.device), requires_grad=False) model.train() loss, yolo_outputs = model.forward(imgs, targets) optimizer.zero_grad() loss.backward()
def save_cams_random_walk(config: Config): config_json = config.toDictionary() print('save_cams_random_walk') print(config_json) import shutil import os from torch.utils.data.dataloader import DataLoader from data.loader_segmentation import Segmentation from artifacts.artifact_manager import artifact_manager # Set up model model = get_model(config.affinity_net_name) model.load() model.eval() model.to(model.device) # Set up data loader dataloader = DataLoader(Segmentation( config.classifier_dataset_root, source='train', augmentation='affinity_predict', image_size=config.affinity_net_image_size, requested_labels=['classification', 'segmentation']), batch_size=1, shuffle=False, num_workers=2, prefetch_factor=2) # Get cam source directory cam_path = os.path.join(artifact_manager.getDir(), 'cam') # Clear and create output directory labels_rw_path = os.path.join(artifact_manager.getDir(), 'labels_rw') if (os.path.exists(labels_rw_path)): shutil.rmtree(labels_rw_path) os.makedirs(labels_rw_path) count = 0 for batch_no, batch in enumerate(dataloader): inputs = batch[0] labels = batch[1] datapacket = batch[2] for image_no, image_name in enumerate(datapacket['image_name']): image = inputs['image'].cuda(non_blocking=True) image_width = datapacket['width'][image_no].numpy() image_height = datapacket['height'][image_no].numpy() channels = labels['classification'].shape[1] # Pad image image_width_padded = int(np.ceil(image_width / 8) * 8) image_height_padded = int(np.ceil(image_height / 8) * 8) image_padded = F.pad(image, (0, image_width_padded - image_width, 0, image_height_padded - image_height)) image_width_pooled = int(np.ceil(image_width_padded / 8)) image_height_pooled = int(np.ceil(image_height_padded / 8)) # Load cam cam_path_instance = os.path.join(cam_path, image_name + '.png') cam = cv2.imread(cam_path_instance, cv2.IMREAD_GRAYSCALE) cam = np.reshape(cam, ((channels, image_height, image_width))) cam = cam / 255.0 # Build cam background cam_background = ( 1 - np.max(cam, (0), keepdims=True))**config.affinity_net_bg_alpha cam = np.concatenate((cam_background, cam), axis=0) cam = cam.astype(np.float32) # Pad cam cam_padded_width = int(np.ceil(cam.shape[2] / 8) * 8) cam_padded_height = int(np.ceil(cam.shape[1] / 8) * 8) cam_padded = np.pad(cam, ((0, 0), (0, cam_padded_height - image_height), (0, cam_padded_width - image_width)), mode='constant') # Run images through model and get affinity matrix with torch.no_grad(): aff_mat = model.event({ 'name': 'infer_aff_net_dense', 'image': image_padded, }) aff_mat = torch.pow(aff_mat, config.affinity_net_beta) trans_mat = aff_mat / torch.sum(aff_mat, dim=0, keepdim=True) for _ in range(config.affinity_net_log_t): trans_mat = torch.matmul(trans_mat, trans_mat) cam_pooled = F.avg_pool2d(torch.from_numpy(cam_padded), 8, 8) cam_vec = cam_pooled.view(21, -1) cam_rw = torch.matmul(cam_vec.cuda(), trans_mat) cam_rw = cam_rw.view(1, 21, image_height_pooled, image_width_pooled) cam_rw = torch.nn.Upsample( (image_height_padded, image_width_padded), mode='bilinear')(cam_rw) cam_rw = cam_rw.cpu().data[0, :, :image_height, :image_width] label_rw = label_to_image(cam_rw) cv2.imwrite(os.path.join(labels_rw_path, image_name + '.png'), label_rw * 255) count += 1 print('Save cam : ', count, end='\r') print('')