def main():
print('Loading model from %s' % (args.ckpt))
net = RetinaNet()
load_checkpoint('%s' % (args.ckpt), net)
net.eval()
use_cuda = torch.cuda.is_available()
device = torch.device("cuda" if use_cuda else "cpu")
print('Device used:', device)
net = net.to(device)
encoder = DataEncoder()
if args.vmode:
if not os.path.exists("%s" % (args.pred_root)):
os.makedirs("%s" % (args.pred_root))
visualize(encoder, net, device, args.image_root, val_image_list,
args.pred_root)
if args.mmode:
if not os.path.exists("./mPA"):
os.makedirs("./mPA")
if os.path.exists("./mPA/detection-results"):
print("Remove Pred file")
os.system("rm -rf ./mPA/detection-results")
os.makedirs("./mPA/detection-results")
if not os.path.exists("./mPA/detection-results"):
os.makedirs("./mPA/detection-results")
mPA_pred(encoder, net, device, args.image_root, args.anno_root)
return 0
def run_train(args):
assert torch.cuda.is_available(), 'Error: CUDA not found!'
best_loss = float('inf') # best test loss
start_epoch = 0 # start from epoch 0 or last epoch
# Data
print('==> Preparing data..')
trainloader = get_train_loader(img_dir=settings.IMG_DIR,
batch_size=batch_size)
#trainloader = get_small_train_loader()
print(trainloader.num)
#testloader = get_train_loader(img_dir=settings.IMG_DIR)
# Model
net = RetinaNet()
#net.load_state_dict(torch.load('./model/net.pth'))
net.load_state_dict(torch.load('./ckps/best_0.pth'))
net = torch.nn.DataParallel(net,
device_ids=range(torch.cuda.device_count()))
net.cuda()
criterion = FocalLoss()
#optimizer = optim.SGD(net.parameters(), lr=args.lr, momentum=0.9, weight_decay=1e-4)
optimizer = optim.Adam(net.parameters(), lr=args.lr)
iter_save = 200
bgtime = time.time()
# Training
for epoch in range(start_epoch, start_epoch + 100):
print('\nEpoch: %d' % epoch)
net.train()
#net.module.freeze_bn()
train_loss = 0
for batch_idx, (inputs, loc_targets,
cls_targets) in enumerate(trainloader):
inputs = Variable(inputs.cuda())
loc_targets = Variable(loc_targets.cuda())
cls_targets = Variable(cls_targets.cuda())
optimizer.zero_grad()
loc_preds, cls_preds = net(inputs)
loss = criterion(loc_preds, loc_targets, cls_preds, cls_targets)
loss.backward()
optimizer.step()
#train_loss += loss.data[0]
sample_num = (batch_idx + 1) * batch_size
avg_loss = running_loss(loss.data[0])
print(
'Epoch: {}, num: {}/{} train_loss: {:.3f} | run_loss: {:.3f} min: {:.1f}'
.format(epoch, sample_num, trainloader.num, loss.data[0],
avg_loss, (time.time() - bgtime) / 60),
end='\r')
if batch_idx % iter_save == 0:
torch.save(
net.module.state_dict(),
'./ckps/best_{}.pth'.format(batch_idx // iter_save % 5))
log.info('batch: {}, loss: {:.4f}'.format(batch_idx, avg_loss))
def main():
print('==> chooseing data..')
transform = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.485, 0.456, 0.406), (0.229, 0.224, 0.225))
])
# Model
net = RetinaNet()
criterion = FocalLoss()
# optimizer = optim.Adam(net.parameters(), lr=0.001, betas=(0.9, 0.999), eps=1e-08, weight_decay=1e-4)
optimizer = optim.SGD(net.parameters(),
lr=0.001,
momentum=0.9,
weight_decay=1e-4)
load_model_epoch = args.load_model_epoch
checkpoint = torch.load(
'./checkpoint/{}_ckpt.pth'.format(load_model_epoch)) # max_epoch
net = torch.nn.DataParallel(net,
device_ids=range(torch.cuda.device_count()))
net.cuda()
net.load_state_dict(checkpoint['net'])
optimizer.load_state_dict(checkpoint['optimizer'])
start_epoch = checkpoint['epoch']
test(start_epoch, transform, net, criterion, optimizer)
def main():
# assert torch.cuda.is_available(), 'Error: CUDA not found!'
best_loss = float('inf') # best test loss
start_epoch = 0 # start from epoch 0 or last epoch
save_model_path = args.model
# Data
print('==> Preparing data..')
transform = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.485, 0.456, 0.406), (0.229, 0.224, 0.225))
])
# Model
net = RetinaNet()
net.load_state_dict(torch.load('./model/net.pth'))
net = torch.nn.DataParallel(net,
device_ids=range(torch.cuda.device_count()))
net.cuda()
criterion = FocalLoss()
# optimizer = optim.Adam(net.parameters(), lr=args.lr, betas=(0.9, 0.999), eps=1e-08, weight_decay=1e-4)
optimizer = optim.SGD(net.parameters(),
lr=args.lr,
momentum=0.9,
weight_decay=1e-4)
for epoch in range(start_epoch, start_epoch + args.train_epoch):
train(epoch + 1, transform, net, optimizer, criterion)
save_model(epoch + 1, save_model_path, net, optimizer)
def make_model():
resnet50_backbone = get_backbone()
loss_fn = RetinaNetLoss(num_classes)
model = RetinaNet(num_classes, resnet50_backbone)
optimizer = tf.optimizers.SGD(learning_rate=learning_rate_fn, momentum=0.9)
model.compile(loss=loss_fn, optimizer=optimizer)
return model
def main(_):
assert tfe.num_gpus() > 0, 'Make sure the GPU device exists'
device_name = '/gpu:{}'.format(args.cuda_device)
print('\n==> ==> ==> Using device {}'.format(device_name))
# Load the dataset
train_ds, val_ds = [
dataset_generator(
mode,
conf.input_size,
num_epochs=1,
batch_size=conf.batch_size,
buffer_size=10000) # TODO edit this when in real training
for mode in ['train', 'val']
]
# Create the model and optimizer
model = RetinaNet()
optimizer = tf.train.RMSPropOptimizer(conf.learning_rate)
# Define the path to the TensorBoard summary
train_dir, val_dir = [
os.path.join(conf.summary_dir, mode) for mode in ['train', 'val']
]
tf.gfile.MakeDirs(conf.summary_dir)
train_summary_writer = tf.contrib.summary.create_summary_file_writer(
train_dir, flush_millis=10000, name='train')
val_summary_writer = tf.contrib.summary.create_summary_file_writer(
val_dir, flush_millis=10000, name='val')
checkpoint_prefix = os.path.join(conf.checkpoint_dir, 'ckpt')
with tfe.restore_variables_on_create(
tf.train.latest_checkpoint(conf.checkpoint_dir)):
with tf.device(device_name):
epoch = tfe.Variable(1., name='epoch')
best_loss = tfe.Variable(tf.float32.max, name='best_loss')
print('==> ==> ==> Start training from epoch {:.0f}...\n'.format(
epoch.numpy()))
while epoch <= conf.num_epochs + 1:
gs = tf.train.get_or_create_global_step()
with train_summary_writer.as_default():
train_one_epoch(model, optimizer, train_ds, epoch.numpy())
with val_summary_writer.as_default():
eval_loss = validate(model, val_ds, epoch.numpy())
# Save the best loss
if eval_loss < best_loss:
best_loss.assign(
eval_loss) # do NOT be copied directly, SHALLOW!
all_variables = (model.variables + optimizer.variables() +
[gs] + [epoch] + [best_loss])
tfe.Saver(all_variables).save(checkpoint_prefix,
global_step=gs)
epoch.assign_add(1)
def build_model(cfg):
cfg.build_backbone = build_backbone
cfg.build_anchor_generator = build_anchor_generator
model = RetinaNet(cfg)
logger = logging.getLogger(__name__)
logger.info("Model:\n{}".format(model))
return model
def load_model(backbone):
print('loading model...')
model = torch.load(os.path.join('model', 'restnet101_8K.pth'))
net = RetinaNet(backbone=backbone, num_classes=len(cfg.classes))
net = torch.nn.DataParallel(net,
device_ids=range(torch.cuda.device_count()))
net.cuda()
cudnn.benchmark = True
net.load_state_dict(model['net'])
return net
def __init__(self, device='cuda', verbose=False):
self.verbose = verbose
self.net = RetinaNet(backbone=cfg.backbone,
num_classes=2,
pretrained=False)
checkpoint = torch.load(os.path.join('ckpts', 'retina_fp16_2e4',
'12_ckpt.pth'),
map_location=device)
errors = self.net.load_state_dict(checkpoint['net'])
logging.warning('Errors from loading Retina model: {}'.format(errors))
self.net = self.net.half().eval().to(device)
self.net.device = device
def train(total_epochs=1, interval=100, resume=False, ckpt_path = ''):
print("Loading training dataset...")
train_dset = OpenImagesDataset(root='./data/train',
list_file ='./data/tmp/train_images_bbox.csv',
transform=transform, train=True, input_size=600)
train_loader = data.DataLoader(train_dset, batch_size=4, shuffle=True, num_workers=4, collate_fn=train_dset.collate_fn)
print("Loading completed.")
#val_dset = OpenImagesDataset(root='./data/train',
# list_file='./data/tmp/train_images_bbox.csv', train=False, transform=transform, input_size=600)
#val_loader = torch.utils.data.DataLoader(val_dset, batch_size=1, shuffle=False, num_workers=4, collate_fn=val_dset.collate_fn)
net = RetinaNet()
net.load_state_dict(torch.load('./model/net.pth'))
criterion = FocalLoss()
net.cuda()
criterion.cuda()
optimizer = optim.SGD(net.parameters(), lr=1e-3, momentum=0.9, weight_decay=1e-4)
best_val_loss = 1000
start_epoch=0
if resume:
if os.path.isfile(ckpt_path):
print(f'Loading from the checkpoint {ckpt_path}')
checkpoint = torch.load(ckpt_path)
start_epoch = checkpoint['epoch']
best_val_loss = checkpoint['best_val_loss']
net.load_state_dict(checkpoint['state_dict'])
optimizer.load_state_dict(checkpoint['optimizer'])
print(f'Loaded checkpoint {ckpt_path}, epoch : {start_epoch}')
else:
print(f'No check point found at the path {ckpt_path}')
for epoch in range(start_epoch, total_epochs):
train_one_epoch(train_loader, net, criterion, optimizer, epoch, interval)
val_loss = 0
#val_loss = validate(val_loader, net, criterion, interval)
if val_loss < best_val_loss:
best_val_loss = val_loss
save_checkpoint({
'epoch': epoch+1,
'state_dict': net.state_dict(),
'best_val_loss': best_val_loss,
'optimizer' : optimizer.state_dict()
}, is_best=True)
def _create_losses(input_queue, num_classes, train_config):
"""Creates loss function for a DetectionModel.
Args:
input_queue: BatchQueue object holding enqueued tensor_dicts.
num_classes: num of classes, integer
Returns:
Average sum of loss of given input batch samples with shape
"""
(images, groundtruth_boxes_list, groundtruth_classes_list,
anchors_list) = _get_inputs(input_queue,
num_classes,
batch_size=train_config.batch_size)
images = [
preprocess(image,
im_height=train_config.im_height,
im_width=train_config.im_width,
preprocess_options=train_config.data_augmentation_ops)
for image in images
]
images = tf.concat(images, 0)
net = RetinaNet()
loc_preds, cls_preds = net(images, num_classes + 1, anchors=9)
# get num of anchor overlapped with ground truth box
cls_gt = [anchor.get_field("gt_labels") for anchor in anchors_list]
loc_gt = [anchor.get_field("gt_encoded_boxes") for anchor in anchors_list]
# pos anchor count for each image
gt_anchor_nums = tf.map_fn(
lambda x: tf.reduce_sum(tf.cast(tf.greater(x, 0), tf.int32)), cls_gt)
# get valid anchor indices
valid_anchor_indices = tf.squeeze(tf.where(tf.greater_equal(cls_gt, 0)))
# skip ignored anchors (iou belong to 0.4 to 0.5)
[valid_cls_preds,
valid_cls_gt] = map(lambda x: tf.gather(x, valid_anchor_indices, axis=1),
[cls_preds, cls_gt])
# classification loss: convert to onehot code
cls_loss = tf.multiply(focal_loss(valid_cls_gt, valid_cls_preds),
1. / tf.to_float(gt_anchor_nums))
# location regression loss
valid_cls_indices = tf.squeeze(tf.where(tf.greater(cls_gt, 0)))
# skip negative and ignored anchors
[valid_loc_preds,
valid_loc_gt] = map(lambda x: tf.gather(x, valid_cls_indices, axis=1),
[loc_preds, loc_gt])
loc_loss = regression_loss(valid_loc_preds,
valid_loc_gt,
weights=tf.expand_dims(
1. / tf.to_float(gt_anchor_nums), 1))
loss = (tf.reduce_sum(loc_loss) + tf.reduce_sum(cls_loss)) / tf.size(
gt_anchor_nums, out_type=tf.float32)
return loss
def test_retinanet():
"""test retinanet"""
net = RetinaNet(classes=80)
x = Variable(torch.rand(1, 3, 500, 500), volatile=True)
now = time.time()
net.cuda()
predictions = net(x)
later = time.time()
print(later - now)
for prediction in predictions:
print(prediction.size())
def evaluate_threshold(img_ids, cls_threshold, bbox_dict):
dloader = get_test_loader(img_ids,
img_dir=settings.IMG_DIR,
batch_size=batch_size)
# Model
net = RetinaNet()
net.load_state_dict(torch.load(CKP_FILE))
#net = torch.nn.DataParallel(net, device_ids=range(torch.cuda.device_count()))
net.cuda()
net.eval()
bgtime = time.time()
encoder = DataEncoder()
encoder.class_threshold = cls_threshold
true_objects_num = 0
pred_objects_num = 0
for batch_idx, inputs in enumerate(dloader):
inputs = Variable(inputs.cuda())
loc_preds, cls_preds = net(inputs)
for i in range(len(loc_preds)):
boxes, labels, scores = encoder.decode(
loc_preds[i].data, cls_preds[i].data,
(settings.IMG_SZ, settings.IMG_SZ))
pred_objects_num += len(scores)
for img_idx in range(len(inputs)):
img_id = dloader.img_ids[batch_idx * batch_size + img_idx]
if img_id in bbox_dict:
true_objects_num += len(bbox_dict[img_id])
print('{} / {}, {} / {}, {:.4f}, {:.2f} min'.format(
batch_size * (batch_idx + 1), dloader.num, pred_objects_num,
true_objects_num, cls_threshold, (time.time() - bgtime) / 60),
end='\r')
print('\n')
print('=>>> {}/{}, {}, {:.4f}\n'.format(
pred_objects_num, true_objects_num,
pred_objects_num - true_objects_num, cls_threshold))
def predict():
assert torch.cuda.is_available(), 'Error: CUDA not found!'
print('==> Preparing data..')
dloader = get_test_loader(get_test_ids(),
img_dir=settings.TEST_IMG_DIR,
batch_size=batch_size)
print(dloader.num)
# Model
net = RetinaNet()
net.load_state_dict(torch.load(CKP_FILE))
#net = torch.nn.DataParallel(net, device_ids=range(torch.cuda.device_count()))
net.cuda()
bgtime = time.time()
encoder = DataEncoder()
net.eval()
prediction_strings = []
for batch_idx, inputs in enumerate(dloader):
inputs = Variable(inputs.cuda())
loc_preds, cls_preds = net(inputs)
print('{} / {} {:.2f}'.format(batch_size * (batch_idx + 1),
dloader.num,
(time.time() - bgtime) / 60),
end='\r')
for i in range(len(loc_preds)):
boxes, labels, scores = encoder.decode(
loc_preds[i].data, cls_preds[i].data,
(settings.IMG_SZ, settings.IMG_SZ))
prediction_strings.append(
_get_prediction_string(boxes, labels, scores))
print(len(prediction_strings))
print(prediction_strings[:3])
submission = pd.DataFrame({
'ImageId': dloader.img_ids,
'PredictionString': prediction_strings
})
submission.to_csv('sub7.csv', index=False)
def train_obj():
# Model
net = RetinaNet()
net = torch.nn.DataParallel(net,
device_ids=range(
torch.cuda.device_count()))
net.cuda()
criterion = FocalLoss()
optimizer = optim.SGD(net.parameters(),
lr=args.lr,
momentum=0.9,
weight_decay=1e-4)
scheduler_obj = torch.optim.lr_scheduler.LambdaLR(
optimizer,
lr_lambda=lambda x: (1 - x / (len(trainloader) * epochs))**0.9)
obj_trainer = ObjDetTrainer(net, criterion, optimizer, scheduler_obj,
trainloader, valloader, device)
obj_trainer.train(epochs, True)
def test():
input_size = (448, 448)
dataset = dataset_generator('val', input_size, 1, 16, 100)
box_encoder = BoxEncoder()
model = RetinaNet()
with tf.device("gpu:0"):
for i, (image, loc_trues,
cls_trues) in enumerate(tfe.Iterator(dataset)):
print('loc_trues shape: {}'.format(loc_trues.shape))
print('cls_trues shape: {}'.format(cls_trues.shape))
loc_preds, cls_preds = model(image)
with tf.device("cpu:0"):
# Decode one by one in a batch
loc_preds, cls_preds, score = box_encoder.decode_batch(
loc_preds.cpu(), cls_preds.cpu(), input_size)
print('loc_preds {} shape: {}'.format(loc_preds,
loc_preds.shape))
print('cls_preds {} shape: {}'.format(cls_preds,
cls_preds.shape))
print('score {} shape: {}'.format(score, score.shape))
break
def test():
# with tf.device("/gpu:0"):
# [batch_size, #anchors]s
# loc_preds = tf.random_uniform([3, 10, 4])
# loc_trues = tf.random_uniform([3, 10, 4])
# cls_preds = tf.random_uniform([3, 10, 12])
# cls_trues = tf.random_uniform([3, 10])
from inputs import dataset_generator
from retinanet import RetinaNet
dataset = dataset_generator('train', (448, 448), 1, 16, 100)
model = RetinaNet()
with tf.device("/gpu:0"):
for i, (image, loc_trues,
cls_trues) in enumerate(tfe.Iterator(dataset)):
loc_preds, cls_preds = model(image, training=True)
loc_loss, cls_loss = loss_fn(loc_preds, loc_trues, cls_preds,
cls_trues)
print(
"Step 0: Location loss: {:.5f} | Class loss: {:.5f}".format(
loc_loss.numpy(), cls_loss.numpy()))
break
# model backbone
if args.backbone == 'resnet18':
backbone = resnet18_features
elif args.backbone == 'resnet34':
backbone = resnet34_features
elif args.backbone == 'resnet50':
backbone = resnet50_features
elif args.backbone == 'resnet101':
backbone = resnet101_features
elif args.backbone == 'resnet152':
backbone = resnet152_features
else:
raise ValueError('Invalid model backbone')
# RetinaNet model
model = RetinaNet(80, backbone, pretrained=True)
optimizer = optim.SGD(model.parameters(),
lr=0.01,
momentum=0.9,
weight_decay=0.0001)
# TODO: enable more flexible lr profile
scheduler = lr_scheduler.MultiStepLR(
optimizer,
# Milestones are set assuming batch size is 16:
# 60000 / batch_size = 3750
# 80000 / batch_size = 5000
milestones=[3750, 5000],
gamma=0.1)
num_workers=8,
collate_fn=trainset.collate_fn)
testset = ListDataset(
list_file='/group/proteindl/ps793/Dota/val_retina_dota_nd.txt',
train=False,
transform=transform,
input_size=1024)
testloader = torch.utils.data.DataLoader(testset,
batch_size=2,
shuffle=False,
num_workers=8,
collate_fn=testset.collate_fn)
# Model
net = RetinaNet(num_classes=15)
net.load_state_dict(torch.load('./model/dota_15c_9ma.pth'))
if resume:
print('==> Resuming from checkpoint..')
checkpoint = torch.load('./checkpoint/ckpt.pth')
net.load_state_dict(checkpoint['net'])
best_loss = checkpoint['loss']
start_epoch = checkpoint['epoch']
net = torch.nn.DataParallel(net, device_ids=range(torch.cuda.device_count()))
net.cuda()
if fix == 'head':
for param in net.module.fpn.conv1.parameters():
param.requires_grad = False
for param in net.module.fpn.bn1.parameters():
from fpn import FPN50
from retinanet import RetinaNet
print('Loading pretrained ResNet50 model..')
d = torch.load('./model/resnet50.pth')
print('Loading into FPN50..')
fpn = FPN50()
dd = fpn.state_dict()
for k in d.keys():
if not k.startswith('fc'): # skip fc layers
dd[k] = d[k]
print('Saving RetinaNet..')
net = RetinaNet()
for m in net.modules():
if isinstance(m, nn.Conv2d):
init.normal(m.weight, mean=0, std=0.01)
if m.bias is not None:
init.constant(m.bias, 0)
elif isinstance(m, nn.BatchNorm2d):
m.weight.data.fill_(1)
m.bias.data.zero_()
pi = 0.01
init.constant(net.cls_head[-1].bias, -math.log((1 - pi) / pi))
net.fpn.load_state_dict(dd)
torch.save(net.state_dict(), 'net.pth')
print('Done!')
transforms.ToTensor(),
transforms.Normalize((0.485, 0.456, 0.406), (0.229, 0.224, 0.225))
])
trainset = NRF(root='./data', image_set=args.type, transform=transform, input_size=768)
trainloader = torch.utils.data.DataLoader(trainset, batch_size=16, shuffle=True, num_workers=4, collate_fn=trainset.collate_fn)
ckpt_dir = os.path.join('./checkpoint_list_wise/albertsons', args.ckpt)
if not os.path.exists(ckpt_dir):
os.makedirs(ckpt_dir)
# Model
print('==> Setting up network..')
if args.type == 'prod':
print('im gonno use Retina_Net')
net = RetinaNet(num_classes=1, num_anchors=15, backbone=args.net)
elif args.type == 'tag':
net = TagNet(num_classes=1, num_anchors=9)
else:
raise TypeError('Unknown detection type, choose "prod" or "tag"')
if args.resume:
print('==> Resuming from checkpoint..')
checkpoint = torch.load('/media/Darius/shayeree/training/checkpoint_list_wise/albertsons/Retina50ProdB1/ckpt_0005_0.1237.pth')
net.load_state_dict(checkpoint['net'])
best_loss = checkpoint['loss']
start_epoch = checkpoint['epoch']
else:
params_dict = torch.load('./model/{:s}.pth'.format(args.net))
net_dict = net.fpn.state_dict()
params_dict = {k: v for k, v in params_dict.items() if k in net_dict}
print("Using the resnet101 as backbone.")
fpn_backbone = fpn.FPN101()
net_dict = fpn_backbone.state_dict()
pretrained_dict = torch.load('model/resnet101-5d3b4d8f.pth')
pretrained_dict = {
k: v
for k, v in pretrained_dict.items() if k in net_dict
}
net_dict.update(pretrained_dict)
fpn_backbone.load_state_dict(net_dict)
else:
#使用resnet50从头训练
print("Training from scratch")
# Model
net = RetinaNet(fpn=fpn_backbone)
args.resume = False
if args.resume:
print('==> Resuming from checkpoint..')
checkpoint = torch.load('./checkpoint/ckpt.pth')
net.load_state_dict(checkpoint['net'])
best_loss = checkpoint['loss']
start_epoch = checkpoint['epoch']
net = torch.nn.DataParallel(net, device_ids=range(torch.cuda.device_count()))
net.cuda()
criterion = FocalLoss()
optimizer = optim.SGD(net.parameters(),
lr=args.lr,
momentum=0.9,
return
for c in childrens:
foo(c)
# resnet = models.alexnet()
# resnet = models.resnet152()
model = model
foo(model)
input = Variable(torch.rand(3, size, size).unsqueeze(0),
requires_grad=True).cuda()
out = model(input)
total_flops = (sum(list_conv) + sum(list_linear) + sum(list_bn) +
sum(list_relu) + sum(list_pooling))
print(' + Number of FLOPs: %.2fG' % (total_flops / 1e9))
if __name__ == "__main__":
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
# Set up model
model = RetinaNet().to(device)
# summary(model, input_size=(3,opt.img_size,opt.img_size))
total = sum([param.nelement() for param in model.parameters()])
print(' + Number of params: %.2fM' % (total / 1e6))
print_model_parm_flops(model, opt.img_size)
#!/usr/bin/env python
# coding=utf-8
#import torchvision.models as models
import torch
from thop import profile
#print(torch.__version__)
#model = models.inception_v3()
from retinanet import RetinaNet
model = RetinaNet()
#input = torch.randn(1, 3, 224, 224)
input = torch.randn(1, 3, 600, 600)
flops, params = profile(model, inputs=(input, ))
print("params:", params)
print("flops:", flops)
from retinanet import RetinaNet
from datasets import CocoDetection
train_loader = torch.utils.data.DataLoader(
CocoDetection(root="./datasets/COCO/train2017",
annFile="./datasets/COCO/annotations/instances_train2017.json",
transform=transforms.Compose([
transforms.ToTensor(),
# normalized because of the pretrained imagenet
transforms.Normalize((0.1307,), (0.3081,))
])),
# batch size should be 16
batch_size=1, shuffle=True)
model = RetinaNet(classes=80)
model.eval()
optimizer = optim.SGD(model.parameters(),
lr=0.01,
momentum=0.9,
weight_decay=0.0001)
scheduler = lr_scheduler.MultiStepLR(optimizer,
# Milestones are set assuming batch size is 16:
# 60000 / batch_size = 3750
# 80000 / batch_size = 5000
milestones=[3750, 5000],
gamma=0.1)
# scale_ratios=[1., pow(2, 1/3.), pow(2, 2/3.)],
# init_feat_stride=8.)
#v20
prod_encoder = DataEncoder(areas=[32*32., 64*64., 128*128., 256*256., 512*512.],
aspect_ratios=[1/4., 1/2., 1/1., 2/1., 4/1.],
scale_ratios=[1., pow(2, 1/3.), pow(2, 2/3.)],
init_feat_stride=8.)
# ckpts = os.listdir(args.ckpt_dir)
# ckpts = ['ckpt_0060_0.0661.pth']
ckpts = ['ckpt_0017_10540.0801.pth']
# ckpts = ['ckpt_0022_0.0131.pth', 'ckpt_0026_0.0127.pth', 'ckpt_0030_0.0125.pth']
#v20
net = RetinaNet(num_classes=1, num_anchors=15)
# #v23
# net = RetinaNet(num_classes=1, num_anchors=21)
# net = TagNet(num_classes=1, num_anchors=9)
for ckpt in ckpts:
net.load_state_dict(torch.load(os.path.join(args.ckpt_dir, ckpt))['net'])
net.eval()
net.cuda()
chunk_sizes = [4096]
threshes = [0.5]
overlaps = [256]
experiment = 1
for chunk_size in chunk_sizes:
fontScale = 0.4
thickness = 1
t_size, _ = cv2.getTextSize(text, fontFace, fontScale + 0.1, thickness)
p_org = tuple(np.amax(poly['poly'], 0))
p_top = (p_org[0] - t_size[0], p_org[1] - t_size[1])
p = (p_top[0] + 1, p_org[1] - 1)
cv2.rectangle(img, p_top, p_org, bg, cv2.FILLED)
cv2.putText(img, text, p, fontFace, fontScale, [255, 255, 255], 1,
cv2.LINE_AA)
return img
batch_size = 16
network = RetinaNet("eval_thn", project_dir="/root/retinanet").cuda()
network.load_state_dict(
torch.load(
"/root/retinanet/training_logs/model_13/checkpoints/model_13_epoch_50.pth"
))
test_dataset = DatasetThnSeqSynscapes(thn_data_path="/root/deeplabv3/data/thn")
#test_dataset = DatasetThnSeq(thn_data_path="/root/deeplabv3/data/thn")
bbox_encoder = BboxEncoder(img_h=test_dataset.img_height,
img_w=test_dataset.img_width)
num_test_batches = int(len(test_dataset) / batch_size)
print("num_test_batches:", num_test_batches)
test_loader = torch.utils.data.DataLoader(dataset=test_dataset,
import torchvision.utils as utils
from torch.autograd import Variable
from fcn_inception_smallMap import FCN
from retinanet import RetinaNet
from encoder import DataEncoder
from PIL import Image, ImageDraw
import os
import cv2
import time
import math
import numpy as np
os.environ["CUDA_VISIBLE_DEVICES"] = "1"
print('Loading model..')
net_det = RetinaNet().cuda()
net_det.load_state_dict(
torch.load('../pytorch-retinanet/checkpoint/model_10_.pth')['net'])
net_det.eval()
net_det = torch.nn.DataParallel(net_det,
device_ids=range(torch.cuda.device_count()))
net_map = FCN().cuda()
net_map.load_state_dict(
torch.load('./../dense_finetune/models/inception_smallMap_3_0.8880.pth'))
net_map.eval()
net_map = torch.nn.DataParallel(net_map,
device_ids=range(torch.cuda.device_count()))
transform = transforms.Compose([
transforms.ToTensor(),
pred_bboxes = pred_bboxes.int()
pred_bboxes[:, 0] = torch.clamp(pred_bboxes[:, 0], min=0)
pred_bboxes[:, 1] = torch.clamp(pred_bboxes[:, 1], min=0)
pred_bboxes[:, 2] = torch.clamp(pred_bboxes[:, 2],
max=self.image_w - 1)
pred_bboxes[:, 3] = torch.clamp(pred_bboxes[:, 3],
max=self.image_h - 1)
# pred bboxes shape:[anchor_nums,4]
return pred_bboxes
if __name__ == '__main__':
from retinanet import RetinaNet
net = RetinaNet(resnet_type="resnet50")
image_h, image_w = 640, 640
cls_heads, reg_heads, batch_anchors = net(
torch.autograd.Variable(torch.randn(3, 3, image_h, image_w)))
annotations = torch.FloatTensor([[[113, 120, 183, 255, 5],
[13, 45, 175, 210, 2]],
[[11, 18, 223, 225, 1],
[-1, -1, -1, -1, -1]],
[[-1, -1, -1, -1, -1],
[-1, -1, -1, -1, -1]]])
decode = RetinaDecoder(image_w, image_h)
batch_scores, batch_classes, batch_pred_bboxes = decode(
cls_heads, reg_heads, batch_anchors)
print("1111", batch_scores.shape, batch_classes.shape,
batch_pred_bboxes.shape)
train_transform_list.insert(0, transforms.Scale(cfg.scale))
train_transform = transforms.Compose(train_transform_list)
val_transform = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize(cfg.mean, cfg.std)
])
trainset = VocLikeDataset(image_dir=cfg.image_dir, annotation_dir=cfg.annotation_dir, imageset_fn=cfg.train_imageset_fn,
image_ext=cfg.image_ext, classes=cfg.classes, encoder=DataEncoder(),
transform=train_transform)
trainloader = torch.utils.data.DataLoader(trainset, batch_size=cfg.batch_size, shuffle=True,
num_workers=cfg.num_workers, collate_fn=trainset.collate_fn)
print('Building model...')
net = RetinaNet(backbone=cfg.backbone, num_classes=len(cfg.classes))
net = torch.nn.DataParallel(net, device_ids=range(torch.cuda.device_count()))
net.cuda()
criterion = FocalLoss(len(cfg.classes))
optimizer = optim.SGD(net.parameters(), lr=lr, momentum=cfg.momentum, weight_decay=cfg.weight_decay)
# special_layers=nn.ModuleList(net.subnet_classes)
# special_layers_params=list(map(id,special_layers.parameters()))
# base_params=filter(lambda p:id(p) not in special_layers_params ,net.parameters())
# optimizer=torch.optim.SGD([{'params':base_params},{'params':special_layers_params.parameters(),'lr':0.001}],lr=lr, momentum=cfg.momentum, weight_decay=cfg.weight_decay)
def save_checkpoint(loss, net, n):
global best_loss
loss /= n
if loss < best_loss:
