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()