def __init__(self):
self.cfg = cfg
# Load data
print('===> Loading data')
self.train_loader = load_data(
cfg.DATASET, 'train') if 'train' in cfg.PHASE else None
self.eval_loader = load_data(cfg.DATASET,
'eval') if 'eval' in cfg.PHASE else None
self.test_loader = load_data(cfg.DATASET,
'test') if 'test' in cfg.PHASE else None
self.visualize_loader = load_data(
cfg.DATASET, 'visualize') if 'visualize' in cfg.PHASE else None
# Build model
print('===> Building model')
self.model, self.priorbox = create_model(cfg.MODEL)
with torch.no_grad():
self.priors = torch.Tensor(self.priorbox.forward())
self.detector = Detect(cfg.POST_PROCESS, self.priors)
# Utilize GPUs for computation
self.use_gpu = torch.cuda.is_available()
self.device = torch.device("cuda:0" if self.use_gpu else "cpu")
if self.use_gpu:
print('Utilize GPUs for computation')
print('Number of GPU available', torch.cuda.device_count())
# self.model.cuda()
# self.priors.cuda()
self.model = self.model.to(device)
self.priors = self.priors.to(device)
cudnn.benchmark = True
# if torch.cuda.device_count() > 1:
# self.model = torch.nn.DataParallel(self.model).module
# Print the model architecture and parameters
print('Model architectures:\n{}\n'.format(self.model))
# print('Parameters and size:')
# for name, param in self.model.named_parameters():
# print('{}: {}'.format(name, list(param.size())))
# print trainable scope
print('Trainable scope: {}'.format(cfg.TRAIN.TRAINABLE_SCOPE))
trainable_param = self.trainable_param(cfg.TRAIN.TRAINABLE_SCOPE)
self.optimizer = self.configure_optimizer(trainable_param,
cfg.TRAIN.OPTIMIZER)
self.exp_lr_scheduler = self.configure_lr_scheduler(
self.optimizer, cfg.TRAIN.LR_SCHEDULER)
self.max_epochs = cfg.TRAIN.MAX_EPOCHS
# metric
self.criterion = MultiBoxLoss(cfg.MATCHER, self.priors, self.use_gpu)
# Set the logger
self.writer = SummaryWriter(log_dir=cfg.LOG_DIR)
self.output_dir = cfg.EXP_DIR
self.checkpoint = cfg.RESUME_CHECKPOINT
self.checkpoint_prefix = cfg.CHECKPOINTS_PREFIX
def __init__(self):
self.cfg = cfg
# Load data
logger.info('Loading data')
self.loaders = {}
if isinstance(cfg.PHASE, (str, unicode)):
cfg.PHASE = [cfg.PHASE]
for phase in cfg.PHASE:
self.loaders[phase] = load_data(cfg.DATASET, phase)
# Build model
logger.info("Building model...")
self.model, self.priorbox = create_model(cfg.MODEL)
with torch.no_grad():
self.priors = self.priorbox.forward()
self.detector = Detect(cfg.POST_PROCESS, self.priors)
# Utilize GPUs for computation
self.use_gpu = torch.cuda.is_available()
if self.use_gpu:
logger.info('Utilize GPUs for computation')
logger.info('Number of GPU available: {}'.format(
torch.cuda.device_count()))
self.model.cuda()
self.priors.cuda()
cudnn.benchmark = True
# if torch.cuda.device_count() > 1:
# self.model = torch.nn.DataParallel(self.model).module
# Print the model architecture and parameters
logger.info('Model architectures:\n{}\n'.format(self.model))
logger.debug('Parameters and size:')
for name, param in self.model.named_parameters():
logger.debug('{}: {}'.format(name, list(param.size())))
# print trainable scope
logger.debug('Trainable scope: {}'.format(cfg.TRAIN.TRAINABLE_SCOPE))
trainable_param = self.trainable_param(cfg.TRAIN.TRAINABLE_SCOPE)
self.optimizer = self.configure_optimizer(trainable_param,
cfg.TRAIN.OPTIMIZER)
self.exp_lr_scheduler = self.configure_lr_scheduler(
self.optimizer, cfg.TRAIN.LR_SCHEDULER)
self.max_epochs = cfg.TRAIN.MAX_EPOCHS
# metric
loss_func = FocalLoss if cfg.MATCHER.USE_FOCAL_LOSS else MultiBoxLoss
self.criterion = loss_func(cfg.MATCHER, self.priors, self.use_gpu)
# Set the logger
self.writer = SummaryWriter(log_dir=cfg.LOG_DIR)
self.output_dir = cfg.EXP_DIR
self.checkpoint = cfg.RESUME_CHECKPOINT
self.checkpoints_kept = cfg.TRAIN.CHECKPOINTS_KEPT
self.checkpoint_prefix = cfg.CHECKPOINTS_PREFIX
def __init__(self):
self.cfg = cfg
# Load data
print('===> Loading data')
self.train_loader = load_data(cfg.DATASET, 'train') if 'train' in cfg.PHASE else None
self.eval_loader = load_data(cfg.DATASET, 'eval') if 'eval' in cfg.PHASE else None
self.test_loader = load_data(cfg.DATASET, 'test') if 'test' in cfg.PHASE else None
self.visualize_loader = load_data(cfg.DATASET, 'visualize') if 'visualize' in cfg.PHASE else None
if self.train_loader and hasattr(self.train_loader.dataset, "num_classes"):
cfg.POST_PROCESS.NUM_CLASSES = cfg.MATCHER.NUM_CLASSES=cfg.MODEL.NUM_CLASSES=self.train_loader.dataset.num_classes
elif self.eval_loader and hasattr(self.eval_loader.dataset, "num_classes"):
cfg.POST_PROCESS.NUM_CLASSES = cfg.MATCHER.NUM_CLASSES=cfg.MODEL.NUM_CLASSES=self.eval_loader.dataset.num_classes
elif self.test_loader and hasattr(self.test_loader.dataset, "num_classes"):
cfg.POST_PROCESS.NUM_CLASSES = cfg.MATCHER.NUM_CLASSES=cfg.MODEL.NUM_CLASSES = self.test_loader.dataset.num_classes
elif self.visualize_loader and hasattr(self.visualize_loader.dataset, "num_classes"):
cfg.POST_PROCESS.NUM_CLASSES = cfg.MATCHER.NUM_CLASSES=cfg.MODEL.NUM_CLASSES = self.visualize_loader.dataset.num_classes
# Build model
print('===> Building model, num_classes is '+str(cfg.MODEL.NUM_CLASSES))
self.model, self.priorbox = create_model(cfg.MODEL,cfg.LOSS.CONF_DISTR)
self.priors = Variable(self.priorbox.forward(), volatile=True)
self.detector = Detect(cfg.POST_PROCESS, self.priors)
# Utilize GPUs for computation
self.use_gpu = torch.cuda.is_available()
if self.use_gpu:
print('Utilize GPUs for computation')
print('Number of GPU available', torch.cuda.device_count())
self.model.cuda()
self.priors.cuda()
if torch.cuda.device_count() > 1:
print('-----DataParallel-----------')
self.model = torch.nn.DataParallel(self.model)
self.model.cuda()
#self.dp_model = torch.nn.DataParallel(self.model)
#self.model = torch.nn.DataParallel(self.model).module
#self.model = self.dp_model.module
cudnn.benchmark = True
# Print the model architecture and parameters
#print('Model architectures:\n{}\n'.format(self.model))
# print('Parameters and size:')
# for name, param in self.model.named_parameters():
# print('{}: {}'.format(name, list(param.size())))
# print trainable scope
print('Trainable scope: {}'.format(cfg.TRAIN.TRAINABLE_SCOPE))
trainable_param = self.trainable_param(cfg.TRAIN.TRAINABLE_SCOPE)
self.optimizer = self.configure_optimizer(trainable_param, cfg.TRAIN.OPTIMIZER)
self.exp_lr_scheduler = self.configure_lr_scheduler(self.optimizer, cfg.TRAIN.LR_SCHEDULER)
self.max_epochs = cfg.TRAIN.MAX_EPOCHS
# metric
#self.criterion = MultiBoxLoss(cfg.MATCHER, self.priors, self.use_gpu)
self.criterion = FocalLoss(cfg.MATCHER, self.priors, self.use_gpu, cfg.LOSS)
# Set the logger
self.writer = SummaryWriter(log_dir=cfg.LOG_DIR)
self.output_dir = cfg.EXP_DIR
self.checkpoint = cfg.RESUME_CHECKPOINT
self.pretrained= cfg.PRETRAINED
self.checkpoint_prefix = cfg.CHECKPOINTS_PREFIX
def __init__(self):
self.cfg = cfg
# set up logging
if not os.path.exists(cfg.LOG_DIR):
os.mkdir(cfg.LOG_DIR)
# utils.setup_logging(os.path.join(cfg.LOG_DIR, "log.txt"))
logging.basicConfig(filename=os.path.join(cfg.LOG_DIR, "log.txt"),
level=logging.INFO)
# Load data
logging.info('===> Loading data, phase %s' % cfg.PHASE)
self.train_loader = load_data(
cfg.DATASET, 'train') if 'train' in cfg.PHASE else None
self.eval_loader = load_data(cfg.DATASET,
'eval') if 'eval' in cfg.PHASE else None
self.test_loader = load_data(cfg.DATASET,
'test') if 'test' in cfg.PHASE else None
self.visualize_loader = load_data(
cfg.DATASET, 'visualize') if 'visualize' in cfg.PHASE else None
# Build model
logging.info('===> Building model')
self.model, self.priorbox = create_model(cfg.MODEL)
self.priors = self.priorbox.forward()
self.detector = Detect(cfg.POST_PROCESS, self.priors)
# Utilize GPUs for computation
self.use_gpu = torch.cuda.is_available()
if self.use_gpu:
logging.info('Utilize GPUs for computation')
logging.info('Number of GPU available: %d' %
torch.cuda.device_count())
self.model.cuda()
self.priors.cuda()
cudnn.benchmark = True
# if torch.cuda.device_count() > 1:
# self.model = torch.nn.DataParallel(self.model).module
# Print the model architecture and parameters
# logging.info('Model architectures:\n{}\n'.format(self.model))
# logging.info('Parameters and size:')
# for name, param in self.model.named_parameters():
# logging.info('{}: {}'.format(name, list(param.size())))
# logging.info trainable scope
logging.info('Trainable scope: {}'.format(cfg.TRAIN.TRAINABLE_SCOPE))
trainable_param = self.trainable_param(cfg.TRAIN.TRAINABLE_SCOPE)
self.optimizer = self.configure_optimizer(trainable_param,
cfg.TRAIN.OPTIMIZER)
self.exp_lr_scheduler = self.configure_lr_scheduler(
self.optimizer, cfg.TRAIN.LR_SCHEDULER)
self.max_epochs = cfg.TRAIN.MAX_EPOCHS
# metric
self.criterion = MultiBoxLoss(cfg.MATCHER, self.priors, self.use_gpu)
# Set the logger
self.writer = SummaryWriter(log_dir=cfg.LOG_DIR)
self.output_dir = cfg.EXP_DIR
self.checkpoint = cfg.RESUME_CHECKPOINT
self.checkpoint_prefix = cfg.CHECKPOINTS_PREFIX
def __init__(self, ifTrain=True):
self.cfg = cfg
# Load data
print('===> Loading data')
self.ifTrain = ifTrain
if self.ifTrain:
self.train_loader = load_data(
cfg.DATASET, 'train') if 'train' in cfg.PHASE else None
#self.eval_loader = load_data(cfg.DATASET, 'eval') if 'eval' in cfg.PHASE else None
else:
test_image_dir = os.path.join('./data/', 'ship_test_v2')
# transforms = transform.Compose([transform.Lambda(lambda x: cv2.cvtColor(np.asarray(x),cv2.COLOR_RGB2BGR)),transform.Resize([300,300]), transform.ToTensor()])
# test_set = torchvision.datasets.ImageFolder(test_image_dir, transform = transforms)
# self.test_loader = torch.utils.data.DataLoader(test_set,batch_size=8,shuffle=False,num_workers=8)
self.train_loader = load_data(
cfg.DATASET, 'train') if 'train' in cfg.PHASE else None
#self.test_loader = load_data(cfg.DATASET, 'test') if 'test' in cfg.PHASE else None
self.visualize_loader = load_data(
cfg.DATASET, 'visualize') if 'visualize' in cfg.PHASE else None
# Build model
print('===> Building model')
self.model, self.priorbox = create_model(cfg.MODEL)
self.priors = Variable(self.priorbox.forward(), volatile=True)
self.detector = Detect(cfg.POST_PROCESS, self.priors)
# Utilize GPUs for computation
self.use_gpu = torch.cuda.is_available()
#self.use_gpu = False
if self.use_gpu:
print('Utilize GPUs for computation')
print('Number of GPU available', torch.cuda.device_count())
self.model.cuda()
self.priors.cuda()
cudnn.benchmark = True
if torch.cuda.device_count() > 1:
self.model = torch.nn.DataParallel(self.model).module
#device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
#device = torch.device("cpu")
#self.model = self.model.to(device)
# Print the model architecture and parameters
print('Model architectures:\n{}\n'.format(self.model))
# print('Parameters and size:')
# for name, param in self.model.named_parameters():
# print('{}: {}'.format(name, list(param.size())))
# print trainable scope
print('Trainable scope: {}'.format(cfg.TRAIN.TRAINABLE_SCOPE))
trainable_param = self.trainable_param(cfg.TRAIN.TRAINABLE_SCOPE)
# print('trainable_param ', trainable_param)
self.optimizer = self.configure_optimizer(trainable_param,
cfg.TRAIN.OPTIMIZER)
self.exp_lr_scheduler = self.configure_lr_scheduler(
self.optimizer, cfg.TRAIN.LR_SCHEDULER)
self.max_epochs = cfg.TRAIN.MAX_EPOCHS
# metric
# print('priors ', self.priors)
self.criterion = MultiBoxLoss(cfg.MATCHER, self.priors, self.use_gpu)
# Set the logger
self.writer = SummaryWriter(log_dir=cfg.LOG_DIR)
self.output_dir = cfg.EXP_DIR
self.checkpoint = cfg.RESUME_CHECKPOINT
self.checkpoint_prefix = cfg.CHECKPOINTS_PREFIX
def __init__(self):
self.cfg = cfg
self.use_gpu = torch.cuda.is_available()
if self.use_gpu:
torch.set_default_tensor_type('torch.cuda.FloatTensor')
# Load data
print('===> Loading data')
if 'train_mimic' == cfg.PHASE[0] or 'train' == cfg.PHASE[0]:
self.train_loader_1 = load_data(cfg.DATASET, 'train')
print(cfg.DATASET.DATASET, len(self.train_loader_1))
if cfg.DATASET2.DATASET in cfg.DATASET.DATASETS:
self.train_loader_2 = load_data(cfg.DATASET2, 'train')
print(cfg.DATASET2.DATASET, len(self.train_loader_1))
else:
self.train_loader_2 = None
self.test_loader = load_data(cfg.DATASET,
'test') if 'test' in cfg.PHASE1 else None
self.corr_loader = load_data(
cfg.DATASET,
'correlation') if 'correlation' in cfg.PHASE1 else None
print('===> Building model')
self.model, self.priorbox, feature_maps = create_model(cfg.MODEL)
sizes = []
boxes = []
for maps in feature_maps:
sizes.append(maps[0] * maps[1])
for box in cfg.MODEL.ASPECT_RATIOS:
boxes.append(len(box) * 2)
self.priors = Variable(self.priorbox.forward(), volatile=True)
self.detector = Detect_fast(cfg.POST_PROCESS, self.priors)
self.Discriminator = Discriminator(cfg.LOG_DIR, cfg.MODEL.NETS,
cfg.MODEL_MIMIC.NETS,
cfg.DISCTRIMINATOR, sizes, boxes)
self.Correlation = Correlation(cfg.CORRELATION, sizes, boxes)
self.Trainer = Trainer()
self.Traier_mimic = Traier_mimic(cfg.TRAIN_MIMIC, sizes, boxes,
cfg.DISCTRIMINATOR.TYPE)
self.Tester = Tester(cfg.POST_PROCESS)
if 'train_mimic' == cfg.PHASE[0] or 'correlation' == cfg.PHASE[0]:
self.model_mimic = create_model(cfg.MODEL_MIMIC)
self.model_mimic.load_state_dict(
torch.load(cfg.MODEL_MIMIC.WEIGHTS))
self.DNet = self.Discriminator.create_discriminator()
# Utilize GPUs for computation
if self.use_gpu:
print('Utilize GPUs for computation')
print('Number of GPU available', torch.cuda.device_count())
cudnn.benchmark = True
# self.model_mimic = torch.nn.DataParallel(self.model_mimic)
# for i in range(len(self.DNet)):
# self.DNet[i] = torch.nn.DataParallel(self.DNet[i])
self.model.cuda()
self.priors.cuda()
if 'train_mimic' == cfg.PHASE[0] or 'correlation' == cfg.PHASE[0]:
self.model_mimic.cuda()
for i in range(len(self.DNet)):
self.DNet[i] = self.DNet[i].cuda()
# if 'train_mimic' == cfg.PHASE[0]:
# print('Model mimim architectures:\n{}\n'.format(self.model_mimic))
# for i in range(len(self.DNet)):
# print('Hello')
# print(self.DNet[i])
# print('Parameters and size:')
# for name, param in self.model.named_parameters():
# print('{}: {}'.format(name, list(param.size())))
# print trainable scope
# print('Trainable scope: {}'.format(cfg.TRAIN.TRAINABLE_SCOPE))
if 'train_mimic' == cfg.PHASE[0] or 'correlation' == cfg.PHASE[0]:
self.optimizer = self.configure_optimizer(self.model,
cfg.TRAIN.OPTIMIZER)
self.DNet_optim = []
for i in range(len(self.DNet)):
self.DNet_optim.append(
self.configure_optimizer(self.DNet[i],
cfg.DISCTRIMINATOR.OPTIMIZER))
self.optimizer_GENERATOR = self.configure_optimizer(
self.model, cfg.TRAIN_MIMIC.OPTIMIZER)
self.exp_lr_scheduler_g = self.configure_lr_scheduler(
self.optimizer_GENERATOR, cfg.TRAIN.LR_SCHEDULER)
else:
self.optimizer = self.configure_optimizer(self.model,
cfg.TRAIN.OPTIMIZER)
self.phase = cfg.PHASE
self.exp_lr_scheduler = self.configure_lr_scheduler(
self.optimizer, cfg.TRAIN.LR_SCHEDULER)
self.max_epochs = cfg.TRAIN.MAX_EPOCHS
# metric
self.criterion = MultiBoxLoss(cfg.MATCHER, self.priors, self.use_gpu)
self.criterion_GaN = nn.BCELoss()
self.pos = POSdata(cfg.MATCHER, self.priors, self.use_gpu)
# Set the logger
self.writer = SummaryWriter(log_dir=cfg.LOG_DIR)
if not os.path.exists(cfg.LOG_DIR):
os.mkdir(cfg.LOG_DIR)
shutil.copyfile('./lib/utils/config_parse.py',
cfg.LOG_DIR + 'hiperparameters.py')
a = os.listdir(cfg.LOG_DIR)
for i in range(1, 100):
if not 'Correlation_' + str(i) + '.txt' in a:
self.logger = cfg.LOG_DIR + 'Correlation_' + str(i) + '.txt'
self.loglosses = cfg.LOG_DIR + 'Correlation_loss_' + str(
i) + '.txt'
break
f = open(self.logger, 'w')
f.close()
f = open(self.loglosses, 'w')
f.close()
self.output_dir = cfg.LOG_DIR
self.checkpoint = cfg.RESUME_CHECKPOINT
self.checkpoint_prefix = cfg.CHECKPOINTS_PREFIX
self.model.loc.apply(self.weights_init)
self.model.conf.apply(self.weights_init)
self.model.extras.apply(self.weights_init)
if 'train' == cfg.PHASE[0]:
if torch.cuda.device_count() > 1:
self.model = torch.nn.DataParallel(self.model)
def __init__(self, phase="train"):
self.cfg = cfg
creat_log(self.cfg, phase=phase)
for k, v in cfg.items():
print(k, ": ", v)
log_str = '\rEpoch {k}: {v}'.format(k=k, v=v)
logging.info(log_str)
# Load data
print('===> Loading data')
logging.info('===> Loading data')
self.train_loader = load_data(
cfg.DATASET, 'train') if 'train' in cfg.PHASE else None
self.eval_loader = load_data(cfg.DATASET,
'eval') if 'eval' in cfg.PHASE else None
self.test_loader = load_data(cfg.DATASET,
'test') if 'test' in cfg.PHASE else None
self.visualize_loader = load_data(
cfg.DATASET, 'visualize') if 'visualize' in cfg.PHASE else None
# Build model
print('===> Building model')
logging.info('===> Building model')
self.model, self.priorbox = create_model(cfg.MODEL)
with torch.no_grad():
self.priors = Variable(self.priorbox.forward())
self.detector = Detect(cfg.POST_PROCESS, self.priors)
os.makedirs(self.cfg['EXP_DIR'], exist_ok=True)
# Utilize GPUs for computation
self.use_gpu = torch.cuda.is_available()
print('Model architectures:\n{}\n'.format(self.model))
logging.info('Model architectures:\n{}\n'.format(self.model))
from lib.utils.torchsummary import summary
summary_text = summary(
self.model.cuda(),
(3, cfg.MODEL.IMAGE_SIZE[0], cfg.MODEL.IMAGE_SIZE[1]))
logging.info('\n'.join(summary_text))
# num_params = 0
# for name, param in self.model.named_parameters():
# num_params += param.numel()
# # print(name, param.size(), param.numel())
# print("%40s %20s %20s" % (name, num_params, param.numel()))
# print(num_params/1e4)
# df = torch_summarize_df(input_size=(3, 512, 512), model=self.model)
# # df['name'], list(df['class_name']), df['input_shape'], df["output_shape"], list(df['nb_params'])
# print(df)
# for name, param in self.model.named_parameters():
# print(name, param.size())
# from thop import profile
#
# flops, params = profile(self.model, input_size=(1, 3, 512, 128))
# count = 0
# for p in self.model.parameters():
# count += p.data.nelement()
# self.multi_gpu = True
self.multi_gpu = False
if self.use_gpu:
print('Utilize GPUs for computation')
logging.info('Utilize GPUs for computation')
# print('Number of GPU available', torch.cuda.device_count())
self.model.cuda()
self.priors.cuda()
cudnn.benchmark = True
# os.environ['CUDA_VISIBLE_DEVICES'] = "4,5,6,7" # "0,1,2,3,4,5,6,7"
if torch.cuda.device_count() > 1 and self.multi_gpu:
self.model = torch.nn.DataParallel(self.model.cuda())
cudnn.benchmark = True
# self.model = torch.nn.DataParallel(self.model).module
# Print the model architecture and parameters
# print('Parameters and size:')
# for name, param in self.model.named_parameters():
# print('{}: {}'.format(name, list(param.size())))
# print trainable scope
print('Trainable scope: {}'.format(cfg.TRAIN.TRAINABLE_SCOPE))
logging.info('Trainable scope: {}'.format(cfg.TRAIN.TRAINABLE_SCOPE))
trainable_param = self.trainable_param(cfg.TRAIN.TRAINABLE_SCOPE)
self.optimizer = self.configure_optimizer(trainable_param,
cfg.TRAIN.OPTIMIZER)
self.exp_lr_scheduler = self.configure_lr_scheduler(
self.optimizer, cfg.TRAIN.LR_SCHEDULER)
self.max_epochs = cfg.TRAIN.MAX_EPOCHS
# metric
self.criterion = MultiBoxLoss(cfg.MATCHER, self.priors, self.use_gpu)
# Set the logger
self.writer = SummaryWriter(logdir=cfg.LOG_DIR)
self.output_dir = cfg.EXP_DIR
self.checkpoint = cfg.RESUME_CHECKPOINT
self.checkpoint_prefix = cfg.CHECKPOINTS_PREFIX
