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 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 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 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 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 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)
class RetinaDetector:
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 detect(self, img):
with torch.no_grad():
boxes, labels, scores = hires_prediction(img,
self.net,
verbose=self.verbose)
return boxes, labels, scores
# 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:
for thresh in threshes:
for overlap in overlaps:
experiment += 1
print("="*200)
# path define
data_dir = './raw/'
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(),
transforms.Normalize((0.485, 0.456, 0.406), (0.229, 0.224, 0.225))
])
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,
batch_size=batch_size,
shuffle=False,
num_workers=4)
import torch
import torchvision.transforms as transforms
from torch.autograd import Variable
from retinanet import RetinaNet
from encoder import DataEncoder
from PIL import Image, ImageDraw
from datagen import ListDataset
import cv2
import numpy as np
print('Loading model..')
net = RetinaNet()
mod = torch.load('ckpt.pth')
net.load_state_dict(mod['net'])
net.eval()
print('Loss', mod['loss'])
transform = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.485, 0.456, 0.406), (0.229, 0.224, 0.225))
])
dataset = ListDataset(
root='/media/braf3002/hdd2/Downloads/MIO-TCD-Localization/test',
list_file='/media/braf3002/hdd2/Downloads/MIO-TCD-Localization/gt_test.csv',
train=False,
transform=transform,
input_size=600,
max_size=1000)
print('Building model...')
net = RetinaNet(backbone=cfg.backbone, num_classes=99)
net.cuda()
cudnn.benchmark = True
if args.resume:
print('Resuming from checkpoint..')
# checkpoint = torch.load(os.path.join('ckpts', args.exp, '29_ckpt.pth'), map_location='cuda')
# checkpoint = torch.load(os.path.join('ckpts', 'efnet4', '29_ckpt.pth'), map_location='cuda')
model_state = net.state_dict()
checkpoint = torch.load(
'/media/grisha/hdd1/icevision/efnet_detector_wo_cls.pth',
map_location='cuda')
model_state.update(checkpoint)
net.load_state_dict(model_state)
# net.load_state_dict(checkpoint)
# start_epoch = checkpoint['epoch']
# lr = cfg.lr
criterion = FocalLoss(99)
# optimizer = optim.Adam(net.parameters(), lr=cfg.lr,weight_decay=cfg.weight_decay)
optimizer = optim.SGD(net.parameters(),
lr=cfg.lr,
momentum=cfg.momentum,
nesterov=True)
cosine_lr = CosineAnnealingWarmRestarts(optimizer,
T_0=len(trainloader),
T_mult=2)
lr_s = GradualWarmupScheduler(optimizer,
transform = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.485,0.456,0.406), (0.229,0.224,0.225))
])
trainset = ListDataset(root='/search/odin/liukuang/data/voc_all_images',
list_file='./data/voc12_train.txt', train=True, transform=transform, input_size=600)
trainloader = torch.utils.data.DataLoader(trainset, batch_size=16, shuffle=True, num_workers=8, collate_fn=trainset.collate_fn)
testset = ListDataset(root='/search/odin/liukuang/data/voc_all_images',
list_file='./data/voc12_val.txt', train=False, transform=transform, input_size=600)
testloader = torch.utils.data.DataLoader(testset, batch_size=16, shuffle=False, num_workers=8, collate_fn=testset.collate_fn)
# Model
net = RetinaNet()
net.load_state_dict(torch.load('./model/net.pth'))
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, weight_decay=1e-4)
# Training
def train(epoch):
import torch
import torchvision.transforms as transforms
from torch.autograd import Variable
from retinanet import RetinaNet
from encoder import DataEncoder
from PIL import Image, ImageDraw
print('Loading model..')
net = RetinaNet()
net.load_state_dict(torch.load('./checkpoint/params.pth'))
net.eval()
transform = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.485,0.456,0.406), (0.229,0.224,0.225))
])
print('Loading image..')
img = Image.open('./image/000001.jpg')
w = h = 600
img = img.resize((w,h))
print('Predicting..')
x = transform(img)
x = x.unsqueeze(0)
x = Variable(x, volatile=True)
loc_preds, cls_preds = net(x)
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}
net_dict.update(params_dict)
net.fpn.load_state_dict(net_dict)
#net,optimizer=amp.initialize(net,optimizer,opt_level='01',loss_scale="dynamic")
#net = torch.nn.DataParallel(net, device_ids=range(torch.cuda.device_count()))
net.cuda()
criterion = FocalLoss(num_classes=1)
optimizer = optim.SGD(net.parameters(), lr=args.lr, momentum=0.9, weight_decay=1e-4)
amp_handle = amp.init(enabled=True, verbose=True)
import torch
import torchvision.transforms as transforms
from torchsummary import summary
from torch.autograd import Variable
from retinanet import RetinaNet
from encoder import DataEncoder
from PIL import Image, ImageDraw
import cv2
import time
print('Loading model..')
net = RetinaNet()
net.load_state_dict(torch.load('checkpoint/ckpt.pth')['net'])
net.eval()
net.cuda()
#summary(net, (3, 224, 224))
transform = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.485, 0.456, 0.406), (0.229, 0.224, 0.225))
])
print('Loading image..')
#img = Image.open('./image/000001.jpg')
cap = cv2.VideoCapture('Z:\\u_zhh\\video\\jy2.mp4')
while True:
ret, cv2img = cap.read() # 名称不能有汉字
def train():
args = parse_args()
assert torch.cuda.is_available(), 'Error: CUDA not found!'
assert args.focal_loss, "OHEM + ce_loss is not working... :("
if not os.path.exists(args.save_folder):
os.mkdir(args.save_folder)
if not os.path.exists(args.logdir):
os.mkdir(args.logdir)
###########################################################################
# Data
###########################################################################
print('==> Preparing data..')
trainset = ListDataset(root='/mnt/9C5E1A4D5E1A2116/datasets/',
dataset=args.dataset,
train=True,
transform=Augmentation_traininig,
input_size=args.input_size,
multi_scale=args.multi_scale)
trainloader = torch.utils.data.DataLoader(trainset,
batch_size=args.batch_size,
shuffle=True,
num_workers=args.num_workers,
collate_fn=trainset.collate_fn)
###########################################################################
# Training Detail option\
stepvalues = (10000, 20000, 30000, 40000, 50000) if args.dataset in ["SynthText"] \
else (2000, 4000, 6000, 8000, 10000)
best_loss = float('inf') # best test loss
start_epoch = 0 # start from epoch 0 or last epoch
iteration = 0
cur_lr = args.lr
mean = (0.485, 0.456, 0.406)
var = (0.229, 0.224, 0.225)
step_index = 0
pEval = None
###########################################################################
# Model
###########################################################################
# set model (focal_loss vs OHEM_CE loss)
if args.focal_loss:
imagenet_pretrain = 'weights/retinanet_se50.pth'
criterion = FocalLoss()
num_classes = 1
else:
imagenet_pretrain = 'weights/retinanet_se50_OHEM.pth'
criterion = OHEM_loss()
num_classes = 2
net = RetinaNet(num_classes)
# Restore model weights
net.load_state_dict(torch.load(imagenet_pretrain))
if args.resume:
print('==> Resuming from checkpoint..', args.resume)
checkpoint = torch.load(args.resume)
net.load_state_dict(checkpoint['net'])
#start_epoch = checkpoint['epoch']
#iteration = checkpoint['iteration']
#cur_lr = checkpoint['lr']
#step_index = checkpoint['step_index']
# optimizer.load_state_dict(state["optimizer"])
print("multi_scale : ", args.multi_scale)
print("input_size : ", args.input_size)
print("stepvalues : ", stepvalues)
print("start_epoch : ", start_epoch)
print("iteration : ", iteration)
print("cur_lr : ", cur_lr)
print("step_index : ", step_index)
print("num_gpus : ", torch.cuda.device_count())
# Data parellelism for multi-gpu training
net = torch.nn.DataParallel(net,
device_ids=range(torch.cuda.device_count()))
net.cuda()
# Put model in training mode and freeze batch norm.
net.train()
net.module.freeze_bn() # you must freeze batchnorm
###########################################################################
# Optimizer
###########################################################################
optimizer = optim.SGD(net.parameters(),
lr=cur_lr,
momentum=0.9,
weight_decay=1e-4)
#optimizer = optim.Adam(net.parameters(), lr=cur_lr)
###########################################################################
# Utils
###########################################################################
encoder = DataEncoder()
writer = SummaryWriter(log_dir=args.logdir)
###########################################################################
# Training loop
###########################################################################
t0 = time.time()
for epoch in range(start_epoch, 10000):
if iteration > args.max_iter:
break
for inputs, loc_targets, cls_targets in 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)
loc_loss, cls_loss = criterion(loc_preds, loc_targets, cls_preds,
cls_targets)
loss = loc_loss + cls_loss
loss.backward()
optimizer.step()
if iteration % 20 == 0:
t1 = time.time()
print(
'iter ' + repr(iteration) + ' (epoch ' + repr(epoch) +
') || loss: %.4f || l loc_loss: %.4f || l cls_loss: %.4f (Time : %.1f)'
% (loss.sum().item(), loc_loss.sum().item(),
cls_loss.sum().item(), (t1 - t0)))
# t0 = time.time()
writer.add_scalar('loc_loss', loc_loss.sum().item(), iteration)
writer.add_scalar('cls_loss', cls_loss.sum().item(), iteration)
writer.add_scalar('loss', loss.sum().item(), iteration)
# show inference image in tensorboard
infer_img = np.transpose(inputs[0].cpu().numpy(), (1, 2, 0))
infer_img *= var
infer_img += mean
infer_img *= 255.
infer_img = np.clip(infer_img, 0, 255)
infer_img = infer_img.astype(np.uint8)
h, w, _ = infer_img.shape
boxes, labels, scores = encoder.decode(loc_preds[0],
cls_preds[0], (w, h))
boxes = boxes.reshape(-1, 4, 2).astype(np.int32)
if boxes.shape[0] != 0:
# infer_img = infer_img/np.float32(255)
# print(boxes)
# print(
# f"infer_img prior to cv2.polylines - dtype: {infer_img.dtype}, shape: {infer_img.shape}, min: {infer_img.min()}, max: {infer_img.max()}")
# print(
# f"boxes prior to cv2.polylines - dtype: {boxes.dtype}, shape: {boxes.shape}, min: {boxes.min()}, max: {boxes.max()}")
infer_img = cv2.polylines(infer_img.copy(), boxes, True,
(0, 255, 0), 4)
# print(
# f"infer_img - dtype: {infer_img.dtype}, shape: {infer_img.shape}, min: {infer_img.min()}, max: {infer_img.max()}")
writer.add_image('image',
infer_img,
iteration,
dataformats="HWC")
writer.add_scalar('input_size', h, iteration)
writer.add_scalar('learning_rate', cur_lr, iteration)
t0 = time.time()
if iteration % args.save_interval == 0 and iteration > 0:
print('Saving state, iter : ', iteration)
state = {
'net': net.module.state_dict(),
"optimizer": optimizer.state_dict(),
'iteration': iteration,
'epoch': epoch,
'lr': cur_lr,
'step_index': step_index
}
model_file = args.save_folder + \
'ckpt_' + repr(iteration) + '.pth'
torch.save(state, model_file)
if iteration in stepvalues:
step_index += 1
cur_lr = adjust_learning_rate(cur_lr, optimizer, args.gamma,
step_index)
if iteration > args.max_iter:
break
if args.evaluation and iteration % args.eval_step == 0:
try:
if pEval is None:
print("Evaluation started at iteration {} on IC15...".
format(iteration))
eval_cmd = "CUDA_VISIBLE_DEVICES=" + str(args.eval_device) + \
" python eval.py" + \
" --tune_from=" + args.save_folder + 'ckpt_' + repr(iteration) + '.pth' + \
" --input_size=1024" + \
" --output_zip=result_temp1"
pEval = Popen(eval_cmd,
shell=True,
stdout=PIPE,
stderr=PIPE)
elif pEval.poll() is not None:
(scorestring, stderrdata) = pEval.communicate()
hmean = float(
str(scorestring).strip().split(":")[3].split(",")
[0].split("}")[0].strip())
writer.add_scalar('test_hmean', hmean, iteration)
print("test_hmean for {}-th iter : {:.4f}".format(
iteration, hmean))
if pEval is not None:
pEval.kill()
pEval = None
except Exception as e:
print("exception happened in evaluation ", e)
if pEval is not None:
pEval.kill()
pEval = None
iteration += 1
# Training Detail option\
stepvalues = (10000, 20000, 30000, 40000,
50000) if args.dataset in ["SynthText"] else (2000, 4000, 6000,
8000, 10000)
best_loss = float('inf') # best test loss
start_epoch = 0 # start from epoch 0 or last epoch
iteration = 0
cur_lr = args.lr
mean = (0.485, 0.456, 0.406)
var = (0.229, 0.224, 0.225)
step_index = 0
pEval = None
# Model
net = RetinaNet(num_classes)
net.load_state_dict(torch.load(imagenet_pretrain))
if args.resume:
print('==> Resuming from checkpoint..', args.resume)
checkpoint = torch.load(args.resume)
net.load_state_dict(checkpoint['net'])
#start_epoch = checkpoint['epoch']
#iteration = checkpoint['iteration']
#cur_lr = checkpoint['lr']
#step_index = checkpoint['step_index']
#optimizer.load_state_dict(state["optimizer"])
print("multi_scale : ", args.multi_scale)
print("input_size : ", args.input_size)
print("stepvalues : ", stepvalues)
print("start_epoch : ", start_epoch)
#bbox_dict, _ = load_small_train_ids()
train_data = get_train_data()
IMG_DIR = settings.TRAIN_IMG_DIR
#IMG_DIR = settings.TEST_IMG_DIR
val_ids = get_val_ids()[:100]
#val_ids = ['353d3a524120046c', '3576033ecd412822', '351e1266649364be', '357fe840ff5bf6d3', '89f6490612d9ae52', '35cc71035da293d0', '354cb68600c29cee', '8aa665e7810453b6', '3530be997286cf58', '37191563d6e5fc80']
#test_ids = ['0000048549557964', '0000071d71a0a6f6', '000018acd19b4ad3', '00001bcc92282a38', '0000201cd362f303', '000020780ccee28d', '000023aa04ab09ed', '0000253ea4ecbf19', '0000286a5c6a3eb5', '00002f4ff380c64c']
#test_ids = ['00000b4dcff7f799', '00001a21632de752', '0000d67245642c5f', '0001244aa8ed3099', '000172d1dd1adce0', '0001c8fbfb30d3a6', '0001dd930912683d', '0002c96937fae3b3', '0002f94fe2d2eb9f', '000305ba209270dc']
img_id = '00436515-870c-4b36-a041-de91049b9ab4'
print('Loading model..')
net = RetinaNet()
#net.load_state_dict(torch.load('./model/best_512.pth'))
net.load_state_dict(torch.load('./ckps/best_1.pth'))
net.eval()
net.cuda()
transform = transforms.Compose([transforms.ToTensor()])
print('Loading image..')
img = cv2.imread(os.path.join(
IMG_DIR,
img_id + '.jpg')) #Image.open(os.path.join(IMG_DIR, img_id+'.jpg'))
w = h = settings.IMG_SZ
#img = img.resize((w,h))
print('Predicting..')
x = transform(img)
x = x.unsqueeze(0).cuda()
testloader = torch.utils.data.DataLoader(testset,
batch_size=batch_sizes,
shuffle=False,
num_workers=8,
collate_fn=testset.collate_fn)
encoder = DataEncoder()
evaluation(model, batch_sizes, testloader, the_classes, encoder, thresh,
im_size, im_size)
map = eval(the_classes)
return map
if __name__ == '__main__':
batch_sizes = 1
transform = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.485, 0.456, 0.406), (0.229, 0.224, 0.225))
])
test_path = '/home/ecust/gmy/pytorch-retinanet-master/pytorch-retinanet-master/data/NEU-DET/valid/labels'
print('Loading model..')
net = RetinaNet()
# net = torch.nn.DataParallel(net)
# cudnn.benchmark = True
net.load_state_dict(torch.load('checkpoints/ckpt_208.pth'))
# net.load_state_dict(torch.load('weights/ckpt_1175.pth'))
evaluate(net, transform, test_path, batch_sizes, thresh=0.001, im_size=300)
lib_path_network = os.path.abspath(os.path.join('..', 'network'))
sys.path.append(lib_path_datasets)
sys.path.append(lib_path_network)
from encoder import DataEncoder
from coco_json_dataset import COCOJsonDataset
from minibatch import _get_image_blob
from retinanet import RetinaNet
from torch.autograd import Variable
import torch
import cv2
import numpy as np
import time
# network
net = RetinaNet()
net.load_state_dict(torch.load('../pretrained_model/net.pth'))
print('==> Resuming from checkpoint..')
checkpoint = torch.load('../checkpoint/ckpt.pth')
net.load_state_dict(checkpoint['net'])
net.cuda()
net.eval()
# encoder
encoder = DataEncoder()
# inputs
# get the dict of class_ind to coco_cat_id
root = '/mnt/xfs1/home/chenqiang/data/coco'
cache_dir = '../cache_dir'
eval_dataset_name = 'minival2014'
eval_dataset = COCOJsonDataset(root=root,
testset = ListDataset(
root='/home/deva/s165/RFBNet-master/data/VOCdevkit/VOC2008/JPEGImages',
list_file='./data/test.txt',
train=False,
transform=transform,
input_size=512)
testloader = torch.utils.data.DataLoader(testset,
batch_size=8,
shuffle=False,
num_workers=8,
collate_fn=testset.collate_fn)
# Model
net = RetinaNet()
net.load_state_dict(torch.load('./model/net.pth'))
args.resume = True
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,
'lr': lr
}
#ckpt_path = os.path.join('ckpts', args.exp)
ckpt_path = '.store'
if not os.path.isdir(ckpt_path):
os.makedirs(ckpt_path)
torch.save(state, os.path.join(ckpt_path, 'ckpt3.pth'))
best_loss = loss
ckpt_path = '.store'
map_location = lambda storage, loc: storage
#net.load_state_dict(torch.load('.store\\ckpt.pth')['net'])
net.load_state_dict(torch.load('.store/ckpt3.pth',
map_location=map_location)['net'],
strict=False)
#lr=0.01
#net.load_state_dict(torch.load( '.store//ckpt.pth')['net'])
for epoch in range(start_epoch + 1, start_epoch + cfg.num_epochs + 1):
if epoch in cfg.lr_decay_epochs:
lr *= 0.1
for param_group in optimizer.param_groups:
param_group['lr'] = lr
print('\nTrain Epoch: %d' % epoch)
net.train()
train_loss = 0
for batch_idx, (inputs, loc_targets,
cls_targets) in enumerate(trainloader):
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():
param.requires_grad = False
help="size of the batches")
parser.add_argument(
"--n_cpu",
type=int,
default=0,
help="number of cpu threads to use during batch generation")
parser.add_argument("--img_size",
type=int,
default=300,
help="size of each image dimension")
args = parser.parse_args()
os.makedirs("output", exist_ok=True)
net = RetinaNet()
net.load_state_dict(torch.load(args.trained_model))
net.cuda()
dataloader = DataLoader(
ImageFolder(args.dataset_root, img_size=args.img_size),
batch_size=args.batch_size,
shuffle=False,
num_workers=args.n_cpu,
)
TIME = 0
for batch_i, (img_paths, input_imgs) in enumerate(dataloader):
if torch.cuda.is_available():
input_imgs = input_imgs.cuda()
