def run():
step = int(config.get('BASIC_INFO', 'MODEL_STEP'))
print('*' * 50)
print('step {}'.format(step))
'''
define parameters
'''
mal_dir = config.get('PATH', 'MAL_DIR')
ben_dir = config.get('PATH', 'BEN_DIR')
label_file = config.get('PATH', 'LABEL_FILE')
batch_size = int(config.get('CLASSIFIER', 'BATCH_SIZE'))
k_fold_value = int(config.get('BASIC_INFO', 'K_FOLD_VALUE'))
'''
seperate data using K-fold cross validation
'''
mal_data = np.array(walk_dir(mal_dir))
ben_data = np.array(walk_dir(ben_dir))
cv = KFold(n_splits=k_fold_value, shuffle=True, random_state=0)
for (train_mal_idx,
eval_mal_idx), (train_ben_idx,
eval_ben_idx) in zip(cv.split(mal_data),
cv.split(ben_data)):
'''
load data
'''
print('load data')
train_data = data.DataLoader(mal_data[train_mal_idx],
ben_data[train_ben_idx],
batch_size=batch_size,
mode='train')
eval_data = data.DataLoader(mal_data[eval_mal_idx],
ben_data[eval_ben_idx],
batch_size=batch_size,
mode='evaluate')
print('load model')
model_dic = {
'epoch': int(config.get('CLASSIFIER', 'EPOCH')),
'gpu_num': int(config.get('CLASSIFIER', 'GPU_NUM')),
'keep_prob':
float(1 - float(config.get('CLASSIFIER', 'DROPOUT_PROB'))),
'learning_rate': float(config.get('CLASSIFIER', 'LEARNING_RATE')),
'model_storage': config.get('CLASSIFIER', 'MODEL_STORAGE'),
'model_network': config.get('CLASSIFIER', 'NETWORK'),
'net_input_size': int(config.get('CLASSIFIER', 'INPUT_SIZE')),
'net_output_size': int(config.get('CLASSIFIER', 'OUTPUT_SIZE')),
'net_type': config.get('CLASSIFIER', 'NETWORK')
}
classifier = model.KISNet(model_num=step,
train_data=train_data,
eval_data=eval_data,
model_dic=model_dic)
classifier.train()
classifier.evaluate()
pass
def train_epoch(epoch, model, optimizer, args):
losses = 0.0
dataset = VOCdetection(root=VOC_ROOT)
dataloader = data.DataLoader(dataset, args.batch_size, shuffle=False)
criteria = myloss(batch_size=args.batch_size)
i = 0
batch_num = 0
for (img, gt, width, height) in dataloader:
img = Variable(img)
labels = Variable(gt)
optimizer.zero_grad() # 优化器零梯度
y_pred = model(img) # 数据输入模型得输出
l, a, b, c, d = criteria(y_pred, labels) # 输出与真实值算损失
l.backward() # 损失反向传
optimizer.step() # 优化器走起来
losses += l.data[0]
batch_num += 1
writer.add_scalar('loss', l.data.numpy(), batch_num)
if l.data.numpy() < 1e-4:
break
print('No.{} batch || loss is {}'.format(batch_num, l.data[0]))
print("Epoch: {}, Ave loss: {}".format(epoch, losses / batch_num))
writer.close()
return losses / batch_num
def val(net, criterion):
dataset = VOCDetection(None, transform=SSDAugmentation(cfg['min_dim'],MEANS,'val'),phase='val')
data_loader = data.DataLoader(dataset, 1,num_workers=1,collate_fn=detection_collate,pin_memory=True)
data_size = len(dataset)
batch_iterator = iter(data_loader)
loss_all = 0
with torch.no_grad():
for step in range(0, data_size):
images, targets = next(batch_iterator)
images = Variable(images.cuda())
with torch.no_grad():
targets = [ann.cuda() for ann in targets]
out = net(images)
loss_l, loss_c = criterion(out, targets)
loss = loss_l + loss_c
loss_all = loss_all + loss.data
progress_bar(step, data_size, ' avg loss %.4f' % (loss_all/step))
return loss_all/data_size
def preds_targets_batch(net, dataset, cuda, num_images, batch_size):
batch_iterator = iter(
data.DataLoader(dataset,
batch_size,
shuffle=False,
collate_fn=detection_collate))
# dump predictions and assoc. ground truth to text file for now
#num_images = len(dataset)
targs = []
dets = []
for i in trange(num_images):
#print('Testing image {:d}/{:d}....'.format(i+1, num_images))
iid, xx, yy = get_iidxy(dataset.ids[i])
images, targets = next(batch_iterator)
#print(targets)
if len(targets[0]) != 0:
t = torch.cat(targets.copy(), 0)
t = torch.cat([t[:, 4:], t[:, :4]], 1)
t = add_col2(t, 1.0, 1)
t = addxy(t, iid, xx, yy).int()
targs.append(t)
#print(t)
x = Variable(images)
if cuda:
x = x.cuda()
y = net(x) # forward pass
detections = y.data
# scale each detection back up to the image
dets.append(get_dets(detections[0], iid, xx, yy))
dets = torch.cat(dets)
targs = torch.cat(targs)
return dets, targs
def create_dataset():
if args.dataset == 'COCO':
if args.dataset_root == VOC_ROOT:
if not os.path.exists(COCO_ROOT):
parser.error('Must specify dataset_root if specifying dataset')
print("WARNING: Using default COCO dataset_root because " +
"--dataset_root was not specified.")
args.dataset_root = COCO_ROOT
cfg = coco
dataset = COCODetection(root=args.dataset_root,
transform=SSDAugmentation(
cfg['min_dim'], MEANS))
elif args.dataset == 'VOC':
if args.dataset_root == COCO_ROOT:
parser.error('Must specify dataset if specifying dataset_root')
cfg = voc
dataset = VOCDetection(root=args.dataset_root,
transform=SSDAugmentation(
cfg['min_dim'], MEANS))
print('Loading the dataset...')
print('Training SSD on:', dataset.name)
print('Using the specified args:')
print(args)
data_loader = data.DataLoader(dataset,
args.batch_size,
num_workers=args.num_workers,
shuffle=True,
collate_fn=detection_collate,
pin_memory=True)
return cfg, data_loader
def print_all_stats():
dl = data.DataLoader(window_size=100,
threshold=1.0,
algo_name='enhanced',
features='comprehensive')
for trial_id in trial_sets.top_ids:
print("\nStats for trial: {}".format(trial_id))
print_stats(trial_id, dl)
def train():
torch.backends.cudnn.deterministic = True
random.seed(1)
torch.manual_seed(1)
torch.cuda.manual_seed(1)
np.random.seed(1)
dataset = COCODetection(image_path=cfg.dataset.train_images,
info_file=cfg.dataset.train_info,
transform=SSDAugmentation(MEANS))
setup_eval()
val_dataset = COCODetection(image_path=cfg.dataset.valid_images,
info_file=cfg.dataset.valid_info,
transform=BaseTransform(MEANS))
data_loader = data.DataLoader(dataset,
args.batch_size,
num_workers=args.num_workers,
shuffle=True,
collate_fn=detection_collate,
pin_memory=True)
val_loader = data.DataLoader(val_dataset,
args.batch_size,
num_workers=args.num_workers,
shuffle=True,
collate_fn=detection_collate,
pin_memory=True)
# Parallel wraps the underlying module, but when saving and loading we don't want that
# I don't use the timer during training (I use a different timing method).
# Apparently there's a race condition with multiple GPUs, so disable it just to be safe.
timer.disable_all()
criterion = MultiBoxLoss(num_classes=cfg.num_classes,
pos_threshold=cfg.positive_iou_threshold,
neg_threshold=cfg.negative_iou_threshold,
negpos_ratio=cfg.ohem_negpos_ratio)
if not os.path.exists('logs'):
os.mkdir('logs')
compute_validation_loss(data_loader, val_loader, criterion)
def test4(self):
cfg = wider
dataset = wf.WiderDetection(
root="/media/bigtree/DATA/data_ubuntu/wider_face",
transform=SSDWiderAugmentation(cfg['min_dim'], MEANS))
epoch_size = len(dataset)
data_loader = data.DataLoader(dataset,
args.batch_size,
num_workers=1,
shuffle=True,
collate_fn=detection_collate,
pin_memory=True)
# print(list(map(lambda x: len(x), dataset._bboxes)))
batch_iterator = iter(data_loader)
ssd_net = build_ssd('train', cfg['min_dim'], cfg['num_classes'])
net = ssd_net
if args.cuda:
# net = torch.nn.DataParallel(ssd_net)
cudnn.benchmark = True
net = net.cuda()
if not args.resume:
print('Initializing weights...')
ssd_net.extras.apply(weights_init)
ssd_net.loc.apply(weights_init)
ssd_net.conf.apply(weights_init)
optimizer = optim.SGD(net.parameters(),
lr=args.lr,
momentum=args.momentum,
weight_decay=args.weight_decay)
criterion = MultiBoxLoss(cfg['num_classes'], 0.5, True, 0, True, 3,
0.5, False, args.cuda)
'''
run one batch of batch to see if things work
'''
images, targets = next(batch_iterator)
# targets.data[0] = torch.tensor()
if args.cuda:
images = Variable(images.cuda())
targets = [Variable(ann.cuda(), volatile=True)\
for ann in targets]
else:
images = Variable(images)
targets = [Variable(ann, volatile=True) \
for ann in targets]
t0 = time.time()
out = net(images)
optimizer.zero_grad()
# print(out[0].shape, out[1].shape, out[2].shape)
loss_l, loss_c = criterion(out, targets)
loss = loss_l + loss_c
loss.backward()
optimizer.step()
t1 = time.time()
print("timer: {} seconds loss {} loc loss {}"
" conf loss {}".format(t1 - t0, loss.data[0], loss_l.data[0],
loss_c.data[0]))
def main():
# Set up a parser for command line arguments
parser = argparse.ArgumentParser("Visualize AFLW dataset (COCO-style annotations)")
parser.add_argument('-v', '--verbose', action='store_true', help="increase output verbosity")
parser.add_argument('--dataset_root', type=str, required=True, help='AFLW root directory')
parser.add_argument('--json', type=str, default='aflw_annotations.json', help="COCO json annotation file")
parser.add_argument('--batch_size', type=int, default=4, help="set batch size")
parser.add_argument('--dim', type=int, default=300, help="input image dimension")
parser.add_argument('-a', '--augment', action='store_true', help="apply augmentations")
args = parser.parse_args()
# Load AFLW dataset
if args.augment:
transform = Augmentor(size=args.dim, mean=(92, 101, 113))
else:
transform = BaseTransform(size=args.dim, mean=(0, 0, 0))
dataset = AFLW(root=args.dataset_root, json=args.json, transform=transform)
# Build data loader
data_loader = data.DataLoader(dataset=dataset, batch_size=args.batch_size, num_workers=1, shuffle=True,
collate_fn=detection_collate, pin_memory=True)
# Build batch iterator
batch_iterator = iter(data_loader)
try:
images, bbox_targets = next(batch_iterator)
except StopIteration:
batch_iterator = iter(data_loader)
images, bbox_targets = next(batch_iterator)
# Get images widths and heights and compute scale
height = images.size(2)
width = images.size(3)
scale = torch.Tensor([width, height, width, height])
for i in range(args.batch_size):
if args.verbose:
print("Image: %d" % i)
print("===================================================")
img = images[i].numpy().transpose(1, 2, 0).astype(np.uint8).copy()
for j in range(len(bbox_targets[i])):
# Get object's bounding box and label
bbox = bbox_targets[i][j][:4]
label = int(bbox_targets[i][j][-1])
pt = (bbox * scale).numpy()
cv2.rectangle(img, pt1=(pt[0], pt[1]), pt2=(pt[2], pt[3]), color=(255, 0, 255), thickness=2)
if args.verbose:
print("\tbbox = ({}, {}, {}, {}) (label = {})".format(int(pt[0]), int(pt[1]), int(pt[2]), int(pt[3]),
label))
cv2.imshow("AFLW: {}".format(i), img)
cv2.waitKey()
def validate(args, net, criterion, cfg):
validation_batch_size = 1
try:
# Turn off learning. Go to testing phase
net.eval()
dataset = GTDBDetection(args,
args.validation_data,
split='validate',
transform=SSDAugmentation(cfg['min_dim'],
mean=MEANS))
data_loader = data.DataLoader(dataset,
validation_batch_size,
num_workers=args.num_workers,
shuffle=False,
collate_fn=detection_collate,
pin_memory=True)
total = len(dataset)
done = 0
loc_loss = 0
conf_loss = 0
start = time.time()
for batch_idx, (images, targets, ids) in enumerate(data_loader):
done = done + len(images)
logging.debug('processing {}/{}'.format(done, total))
if args.cuda:
images = images.cuda()
targets = [ann.cuda() for ann in targets]
else:
images = Variable(images)
targets = [Variable(ann, volatile=True) for ann in targets]
y = net(images) # forward pass
loss_l, loss_c = criterion(y, targets)
loc_loss += loss_l.item() # data[0]
conf_loss += loss_c.item() # data[0]
end = time.time()
logging.debug('Time taken for validation ' +
str(datetime.timedelta(seconds=end - start)))
return (loc_loss + conf_loss) / (total / validation_batch_size)
except Exception as e:
logging.error("Could not validate", exc_info=True)
return 0
def main():
ssd_net = build_face_ssd('val')
net = ssd_net
net.load_state_dict(
torch.load('./checkpoints/SSD_wFace_matching_0.6_128.pth'))
net.eval()
dataset = WiderFaceDetection(root='/data00/kangyang/datasets/WIDER_FACE',
transform=SimpleTestAugmentation())
data_loader = data.DataLoader(dataset,
1,
num_workers=0,
shuffle=False,
collate_fn=detection_collate,
pin_memory=True)
cpu = False
if not cpu:
net = net.cuda()
for i_batch, (images, targets) in enumerate(data_loader):
if cpu:
pass
else:
with torch.no_grad():
blob = Variable(images.cuda())
targets = [Variable(ann) for ann in targets]
y = net(blob)
face_detections = y.data[0][1]
num_boxes = face_detections.shape[0]
count = 0
im = np.transpose(images[0], (1, 2, 0)).numpy().astype(np.uint8) + 128
im = im[:, :, ::-1]
im = np.ascontiguousarray(im)
im_height, im_width, _ = im.shape
for b in range(num_boxes):
if face_detections[b, 0] >= 0.3:
box = face_detections[b, 1:]
x1 = min(im_width, max(0, box[0] * im_width))
y1 = min(im_height, max(0, box[1] * im_height))
x2 = min(im_width, max(0, box[2] * im_width))
y2 = min(im_height, max(0, box[3] * im_height))
im = cv2.rectangle(im, (int(x1), int(y1)), (int(x2), int(y2)),
(255, 0, 0))
count += 1
print 'get fgboxes: {}'.format(count)
cv2.imwrite('test_{}.png'.format(i_batch), im)
if i_batch > 100:
break
def __init__(self, args, domain_path):
if args.data_aug:
augmentation = PitchAugmentation(args)
else:
augmentation = None
self.train_dataset = H5Dataset(args, domain_path / 'train', augmentation=augmentation)
self.train_loader = data.DataLoader(self.train_dataset,
batch_size=args.batch_size,
num_workers=args.num_workers,
pin_memory=True)
self.train_iter = iter(self.train_loader)
self.valid_dataset = H5Dataset(args, domain_path / 'val', augmentation=augmentation)
self.valid_loader = data.DataLoader(self.valid_dataset,
batch_size=args.batch_size,
num_workers=args.num_workers // 10 + 1,
pin_memory=True)
self.valid_iter = iter(self.valid_loader)
def data_creator(config):
# Within a machine, this code runs synchronously.
args = config["args"]
cfg = config["args"]
dataset = get_dataset(config, "train")
# cfg["num_classes"] = num_classes
data_loader = data.DataLoader(dataset,
args.batch_size,
num_workers=args.num_workers,
shuffle=True,
collate_fn=detection_collate,
pin_memory=True)
data_loader_test = get_dataset(config, "val")
return data_loader, data_loader_test
def _load(self):
"""
Loads the data and model objects
"""
args = self._args
_, self._params = utils.decide_config(args.root, args.name)
self._args.name = self._args.name.split("-")[0]
data_ = data.Data(args=args)
self.num_dev_samples = data_.dev_partition.shape[0]
self._device = torch.device(
"cuda:0" if torch.cuda.is_available() else "cpu")
dataset = data.InputDataset(input_data=data_, num_neg=data_.num_neg)
dev_dataset = data.InputDataset(input_data=data_,
num_neg=data_.num_neg,
partition="dev")
test_dataset = data.InputDataset(input_data=data_,
num_neg=data_.num_neg,
partition="test")
self._loader = data.DataLoader(
dataset=dataset,
batch_size=self._args.batch) # used for node clustering
self._dev_loader = data.DataLoader(
dataset=dev_dataset,
batch_size=self._args.batch) # used for link prediction
self._test_loader = data.DataLoader(
dataset=test_dataset, batch_size=self._args.batch
) # used for link prediction and attention visualization
self._negative_pairs = data_.negative_pairs
self._neighborhood = data_.neighborhood
self._mask = data_.neighborhood_mask
self._y = None
if hasattr(data_, "y"):
self._y = data_.y
self._model = model.Goat(num_nodes=data_.num_nodes, dim=data_.dim)
self._model.to(self._device)
def visualize_all_classifier_results():
trial_ids = trial_sets.top_ids
dl = data.DataLoader(window_size=100,
threshold=2.0,
algo_name='enhanced',
features='comprehensive')
for trial_id in trial_ids:
print("Trial {}".format(trial_id))
training_ids = trial_ids.copy()
training_ids.remove(trial_id)
visualize_classifier_results(training_ids, trial_id, dl)
def train():
dataset = VOCDetection(root=args.dataset_root,
transform=SSDAugmentation(512, MEANS))
data_loader = data.DataLoader(dataset,
args.batch_size,
num_workers=0,
shuffle=True,
collate_fn=detection_collate,
pin_memory=False)
model = EfficientDet(num_classes=21)
model = model.cuda()
optimizer = optim.AdamW(model.parameters(), lr=args.lr)
criterion = FocalLoss()
model.train()
iteration = 0
for epoch in range(args.num_epoch):
print('Start epoch: {} ...'.format(epoch))
total_loss = []
for idx, sample in enumerate(data_loader):
images = sample['img'].cuda()
classification, regression, anchors = model(images)
classification_loss, regression_loss = criterion(
classification, regression, anchors, sample['annot'])
classification_loss = classification_loss.mean()
regression_loss = regression_loss.mean()
loss = classification_loss + regression_loss
if bool(loss == 0):
continue
optimizer.zero_grad()
loss.backward()
torch.nn.utils.clip_grad_norm_(model.parameters(), 0.1)
optimizer.step()
total_loss.append(loss.item())
if (iteration % 100 == 0):
print(
'Epoch/Iteration: {}/{}, classification: {}, regression: {}, totol_loss: {}'
.format(epoch, iteration, classification_loss.item(),
regression_loss.item(), np.mean(total_loss)))
iteration += 1
torch.save(model.state_dict(),
'./weights/checkpoint_{}.pth'.format(epoch))
def create_fingertip_cdf():
THRESHOLD = 2.0
dl = data.DataLoader(window_size=100,
threshold=THRESHOLD,
algo_name='enhanced',
features='comprehensive')
fingertip_error = []
csv_file = open(data.GRAPH_CACHE + 'csv-fingertip.csv', 'w')
csvwriter = csv.writer(csv_file,
delimiter=',',
quotechar='|',
quoting=csv.QUOTE_MINIMAL)
csvwriter.writerow(['reflective', 'transitive'])
for trial_id in trial_sets.top_ids:
wrist_oxygen, fingertip_oxygen, transitive_oxygen = dl.load_all_oxygen(
trial_id)
for oF, oT in zip(fingertip_oxygen, transitive_oxygen):
csvwriter.writerow([oF, oT])
fingertip_error.append(np.square(np.subtract(oF, oT)))
fingertip_error = np.array(fingertip_error)
fingertip_error = fingertip_error[~np.isnan(fingertip_error)]
plt.figure()
sorted_data = np.sort(fingertip_error)
yvals = np.arange(len(sorted_data)) / float(len(sorted_data) - 1)
plt.plot(sorted_data, yvals)
# plt.legend(['Baseline', 'Enhanced'])
plt.ylim(0.0, 1.0)
plt.xlabel('RMSE')
plt.savefig(data.GRAPH_CACHE + 'cdf-fingertip.pdf')
csv_file.close()
def train():
# if args.dataset == 'COCO':
# if args.dataset_root == VOC_ROOT:
# if not os.path.exists(COCO_ROOT):
# parser.error('Must specify dataset_root if specifying dataset')
# print("WARNING: Using default COCO dataset_root because " +
# "--dataset_root was not specified.")
# args.dataset_root = COCO_ROOT
# cfg = coco
# dataset = COCODetection(root=args.dataset_root,
# transform=SSDAugmentation(cfg['min_dim'],
# MEANS))
# elif args.dataset == 'VOC':
# if args.dataset_root == COCO_ROOT:
# parser.error('Must specify dataset if specifying dataset_root')
cfg = voc
dataset = VOCDetection(root=VOC_ROOT,
transform=SSDAugmentation(cfg['min_dim'], MEANS))
epoch_size = len(dataset) // 32
print("epoch size: ", epoch_size)
data_loader = data.DataLoader(dataset,
32,
num_workers=6,
shuffle=True,
collate_fn=detection_collate,
pin_memory=True)
# create batch iterator
batch_iterator = iter(data_loader)
epoch = 0
for iteration in range(0, 22):
if iteration != 0 and (iteration % epoch_size == 0):
print("\nepoch: ", epoch)
epoch += 1
print("\riteration : %d \t, epoch: %d" % (iteration, epoch), end=' ')
# load train data
images, targets = next(batch_iterator)
def val(args, net, val_set, optimizer):
net.eval()
val_loader = data.DataLoader(val_set,
args.batch_size,
num_workers=args.num_workers,
shuffle=True,
collate_fn=detection_collate,
pin_memory=True)
# create batch iterator
batch_iterator = iter(val_loader)
eval_results = []
start_time = time.time()
for iteration in range(args.start_iter + args.ft_iter, args.max_iter):
try:
images, targets, _shape = next(batch_iterator)
except StopIteration:
batch_iterator = iter(val_loader)
images, targets, _shape = next(batch_iterator)
images = Variable(images.cuda())
targets = [Variable(ann.cuda(), volatile=True) for ann in targets]
out1, out2 = net(images, deform_map=False, test=False)
detections, reg_boxes = out1
eval_result = evaluate(images,
detections.data,
targets,
iteration,
0.1,
visualize=False,
post_combine=True)
eval_results.append(eval_result)
eval_results = list(map(list, zip(*eval_results)))
print(
" --- accuracy=%.4f, precision=%.4f, recall=%.4f, f1-score=%.4f, cost %.2f seconds ---"
% (avg(eval_results[0]), avg(eval_results[1]), avg(
eval_results[2]), avg(eval_results[3]), time.time() - start_time))
def test2(self):
cfg = wider
dataset = wf.WiderDetection(
root="/media/bigtree/DATA/data_ubuntu/wider_face",
transform=SSDWiderAugmentation(cfg['min_dim'], MEANS))
epoch_size = len(dataset)
data_loader = data.DataLoader(dataset,
args.batch_size,
num_workers=1,
shuffle=True,
collate_fn=detection_collate,
pin_memory=True)
batch_iterator = iter(data_loader)
img, targets = next(batch_iterator)
img1 = img[0].numpy()
# print(targets[0].numpy())
# print(img1.shape)
img1 = np.transpose(img1, (1, 2, 0))
img1 = (img1 / 122 + 1.0) / 2
cv2.imshow('img', img1)
cv2.waitKey(0)
# print(img1.shape)
# img1 = (img1/122 + 1.0) / 2
show_img_ = np.ascontiguousarray(img1)
print(targets[0].numpy() * 300)
for box in targets[0].numpy():
box = box * 300
xlb, ylb = box[0], box[1]
xrt, yrt = box[2], box[3]
cv2.rectangle(show_img_, (int(xlb), int(ylb)),
(int(xrt), int(yrt)), (0, 0, 0),
thickness=1)
cv2.imshow('show_img', show_img_)
cv2.waitKey(0)
print(img.shape)
def train():
if args.dataset == 'VOC':
cfg = voc
dataset = VOCDetection(root=args.dataset_root,
transform=SSDAugmentation(cfg['min_dim'],
MEANS))
print("Minimum number of dimensions", cfg['min_dim'])
print("Number of classes", cfg['num_classes'])
if args.visdom:
import visdom
viz = visdom.Visdom()
ssd_net = build_ssd('train', cfg['min_dim'], cfg['num_classes'])
net = ssd_net
if args.cuda:
net = torch.nn.DataParallel(ssd_net)
cudnn.benchmark = True
if args.resume:
print('Resuming training, loading {}...'.format(args.resume))
ssd_net.load_weights(args.resume)
ssd_net.conf.apply(weights_init)
else:
vgg_weights = torch.load(args.save_folder + args.basenet)
print('Loading base network...')
ssd_net.vgg.load_state_dict(vgg_weights)
if args.cuda:
net = net.cuda()
if not args.resume:
print('Initializing weights...')
# initialize newly added layers' weights with xavier method
ssd_net.extras.apply(weights_init)
ssd_net.loc.apply(weights_init)
ssd_net.conf.apply(weights_init)
optimizer = optim.SGD(net.parameters(), lr=args.lr, momentum=args.momentum,
weight_decay=args.weight_decay)
criterion = MultiBoxLoss(cfg['num_classes'], 0.5, True, 0, True, 3, 0.5,
False, args.cuda)
net.train()
# loss counters
loc_loss = 0
conf_loss = 0
epoch = 0
print('Loading the dataset...')
epoch_size = len(dataset) // args.batch_size
print('Training SSD on:', dataset.name)
print('Using the specified args:')
print(args)
step_index = 0
if args.visdom:
vis_title = 'SSD.PyTorch on ' + dataset.name
vis_legend = ['Loc Loss', 'Conf Loss', 'Total Loss']
iter_plot = create_vis_plot('Iteration', 'Loss', vis_title, vis_legend)
epoch_plot = create_vis_plot('Epoch', 'Loss', vis_title, vis_legend)
data_loader = data.DataLoader(dataset, args.batch_size,
num_workers=args.num_workers,
shuffle=True, collate_fn=detection_collate,
pin_memory=True)
# create batch iterator
batch_iterator = iter(data_loader)
for iteration in range(args.start_iter, cfg['max_iter']):
if args.visdom and iteration != 0 and (iteration % epoch_size == 0):
update_vis_plot(epoch, loc_loss, conf_loss, epoch_plot, None,
'append', epoch_size)
# reset epoch loss counters
loc_loss = 0
conf_loss = 0
epoch += 1
if iteration in cfg['lr_steps']:
step_index += 1
adjust_learning_rate(optimizer, args.gamma, step_index)
# load train data
try:
images, targets = next(batch_iterator)
except StopIteration:
batch_iterator = iter(data_loader)
images, targets = next(batch_iterator)
if args.cuda:
images = Variable(images.cuda())
targets = [Variable(ann.cuda(), volatile=True) for ann in targets]
else:
images = Variable(images)
targets = [Variable(ann, volatile=True) for ann in targets]
# forward
t0 = time.time()
out = net(images)
# backprop
optimizer.zero_grad()
loss_l, loss_c = criterion(out, targets)
loss = loss_l + loss_c
loss.backward()
optimizer.step()
t1 = time.time()
loc_loss += loss_l.item()
conf_loss += loss_c.item()
if iteration % 10 == 0:
print('timer: %.4f sec.' % (t1 - t0))
print('iter ' + repr(iteration) + ' || Loss: %.4f ||' % (loss.item()), end=' ')
if args.visdom:
update_vis_plot(iteration, loss_l.item(), loss_c.item(),
iter_plot, epoch_plot, 'append')
if iteration != 0 and iteration % 50 == 0:
print('Saving state, iter:', iteration)
torch.save(ssd_net.state_dict(), 'weights/ssd300_COCO_' +
repr(iteration) + '.pth')
torch.save(ssd_net.state_dict(),
args.save_folder + '' + args.dataset + '.pth')
def train():
#
#torch.cuda.set_device(1)
if args.dataset == 'COCO':
if args.dataset_root == VOC_ROOT:
if not os.path.exists(COCO_ROOT):
parser.error('Must specify dataset_root if specifying dataset')
print("WARNING: Using default COCO dataset_root because " +
"--dataset_root was not specified.")
args.dataset_root = COCO_ROOT
cfg = coco
dataset = COCODetection(root=args.dataset_root,
transform=SSDAugmentation(
cfg['min_dim'], MEANS))
elif args.dataset == 'VOC':
#if args.dataset_root == VOC_ROOT:
# parser.error('Must specify dataset if specifying dataset_root')
cfg = voc
dataset = VOCDetection(root=args.dataset_root,
transform=SSDAugmentation(
cfg['min_dim'], MEANS))
elif args.dataset == 'SSDD':
print('root is SSDD')
cfg = ssdd
dataset = SSDDDetection(root=args.dataset_root,
split='train',
transform=SSDAugmentation(
cfg['min_dim'], MEANS))
elif args.dataset == 'GFPlane':
print('root is GFPlane')
cfg = gfplane
dataset = GFPlaneDetection(root=args.dataset_root,
split='train',
transform=GFPlaneAugmentation(
cfg['min_dim'], MEANS))
elif args.dataset == 'CasiaShip':
print('root is CasiaShip')
cfg = casiaship
dataset = ShipDetection(root=args.dataset_root,
split='train',
transform=GFPlaneAugmentation(
cfg['min_dim'], MEANS))
elif args.dataset == 'BigShip':
print('root is Bigship')
cfg = casiaBigship
dataset = BigShipDetection(root=args.dataset_root,
split='train',
transform=GFPlaneAugmentation(
cfg['min_dim'], MEANS))
if args.visdom:
import visdom
viz = visdom.Visdom()
ssd_net = build_ssd('train', cfg, cfg['min_dim'], cfg['num_classes'])
#ssd_net = build_ssd('train',cfg, cfg['min_dim'], cfg['num_classes'])
#import pdb;pdb.set_trace()
net = ssd_net
if args.cuda:
net = torch.nn.DataParallel(ssd_net)
cudnn.benchmark = True
if args.resume:
print('Resuming training, loading {}...'.format(args.resume))
ssd_net.load_weights(args.resume)
else:
vgg_weights = torch.load(args.save_folder + args.basenet)
#import pdb;pdb.set_trace()
print('Loading base network...')
ssd_net.vgg.load_state_dict(vgg_weights)
if args.cuda:
net = net.cuda()
#import pdb;pdb.set_trace()
if not args.resume:
print('Initializing weights...')
# initialize newly added layers' weights with xavier method
ssd_net.extras.apply(weights_init)
ssd_net.loc.apply(weights_init)
ssd_net.conf.apply(weights_init)
optimizer = optim.SGD(net.parameters(),
lr=args.lr,
momentum=args.momentum,
weight_decay=args.weight_decay)
criterion = MultiBoxLoss_noobj(cfg['num_classes'], 0.5, True, 0, True, 3,
0.5, False, args.cuda)
net.train()
# loss counters
loc_loss = 0
conf_loss = 0
epoch = 0
print('Loading the dataset...')
epoch_size = len(dataset) // args.batch_size
print('Training SSD on:', dataset.name)
print('Using the specified args:')
print(args)
step_index = 0
if args.visdom:
vis_title = 'SSD.PyTorch on ' + dataset.name
vis_legend = ['Loc Loss', 'Conf Loss', 'Total Loss']
iter_plot = create_vis_plot('Iteration', 'Loss', vis_title, vis_legend)
epoch_plot = create_vis_plot('Epoch', 'Loss', vis_title, vis_legend)
data_loader = data.DataLoader(dataset,
args.batch_size,
num_workers=args.num_workers,
shuffle=True,
collate_fn=detection_collate,
pin_memory=True)
# create batch iterator
batch_iterator = iter(data_loader)
epoch = 0
epoch_iter = 0
for iteration in range(args.start_iter, cfg['max_iter']):
if args.visdom and iteration != 0 and (iteration % epoch_size == 0):
update_vis_plot(epoch, loc_loss, conf_loss, epoch_plot, None,
'append', epoch_size)
# reset epoch loss counters
loc_loss = 0
conf_loss = 0
epoch_iter = 0
epoch += 1
if iteration in cfg['lr_steps']:
step_index += 1
adjust_learning_rate(optimizer, args.gamma, step_index)
#import pdb;pdb.set_trace()
# load train data
try:
images, targets = next(batch_iterator)
except StopIteration:
print('next batch')
print('batch local loss: {}\nbatch conf loss:{}\n'.format(
loc_loss, conf_loss))
batch_iterator = iter(data_loader)
images, targets = next(batch_iterator)
loc_loss = 0
conf_loss = 0
epoch = epoch + 1
epoch_iter = 0
print('\nepoch: {} ,dataset trained finished!'.format(epoch))
#import pdb;pdb.set_trace()
if args.cuda:
images = Variable(images.to("cuda"))
targets = [Variable(ann.cuda(), volatile=True) for ann in targets]
else:
images = Variable(images)
targets = [Variable(ann, volatile=True) for ann in targets]
#import pdb;pdb.set_trace()
# forward
#import pdb;pdb.set_trace()
epoch_iter += 1
t0 = time.time()
out = net(images)
# backprop
optimizer.zero_grad()
#import pdb;pdb.set_trace()
loss_l, loss_c = criterion(out, targets)
#import pdb;pdb.set_trace()
loss = loss_l + loss_c
#print('')
loss.backward()
optimizer.step()
t1 = time.time()
loc_loss += loss_l.item()
conf_loss += loss_c.item()
#print('iter ' + repr(iteration) + ' || Loss: %.4f ||' %(loss.item())+\
# ' || Loss_l: %.4f' %(loss_l.item())+' || Loss_c: %.4f'%(loss_c.item()))
if iteration % 10 == 0:
print('timer: %.4f sec.' % (t1 - t0))
print('epoch: %d || '%(epoch),' iter ' + repr(iteration) + ' || '+str(epoch_iter)+'/'+str(len(batch_iterator))+' || Loss: %.4f ||' %(loss.item())+\
' || Loss_l: %.4f' %(loss_l.item())+' || Loss_c: %.4f'%(loss_c.item()), end=' ')
if args.visdom:
update_vis_plot(iteration, loss_l.data[0], loss_c.data[0],
iter_plot, epoch_plot, 'append')
if iteration != 0 and iteration % 5000 == 0:
print('Saving state, iter:', iteration)
save_path = 'weights/ssd512_Airbus512_' + repr(iteration) + '.pth'
torch.save(ssd_net.state_dict(), save_path)
test_online(save_path, cfg, loss, 'cut')
torch.save(ssd_net.state_dict(),
args.save_folder + '' + args.dataset + '.pth')
def train():
'''
get the dataset and dataloader
'''
print(args.dataset)
if args.dataset == 'COCO':
if not os.path.exists(COCO_ROOT):
parser.error('Must specify dataset_root if specifying dataset')
cfg = coco
dataset = COCODetection(root=COCO_ROOT,
transform=SSDAugmentation(
cfg['min_dim'], MEANS),
filename='train.txt')
elif args.dataset == 'VOC':
if not os.path.exists(VOC_ROOT):
parser.error('Must specify dataset_root if specifying dataset')
cfg = voc
dataset = VOCDetection(root=VOC_ROOT,
transform=SSDAugmentation(cfg['min_dim'],
mean=cfg['mean'],
std=cfg['std']))
print(len(dataset))
elif args.dataset == 'LAJI':
if not os.path.exists(LAJI_ROOT):
parser.error('Must specify dataset_root if specifying dataset')
cfg = laji_se_resnext101_32x4d
dataset = LAJIDetection(root=LAJI_ROOT,
transform=SSDAugmentation(cfg['min_dim'],
mean=cfg['mean'],
std=cfg['std']))
print(len(dataset))
data_loader = data.DataLoader(dataset,
args.batch_size,
num_workers=args.num_workers,
shuffle=True,
collate_fn=detection_collate,
pin_memory=True)
# build, load, the net
ssd_net = build_ssd('train', size=cfg['min_dim'], cfg=cfg)
'''
for name,param in ssd_net.named_parameters():
if param.requires_grad:
print(name)
'''
start_iter = args.start_iter
if args.resume:
print('Resuming training, loading {}...'.format(args.resume))
data_tmp = torch.load(args.resume)
data_tmp = {k.lstrip("module."): v for k, v in data_tmp.items()}
ssd_net.load_state_dict(data_tmp)
start_iter = int(args.resume.split("/")[-1].split("_")[-2])
print("start_iter is {}".format(start_iter))
if args.cuda:
net = ssd_net.cuda()
# net = torch.nn.DataParallel(net)
net.train()
#optimizer
optimizer = optim.SGD(net.parameters(),
lr=args.lr,
momentum=args.momentum,
weight_decay=args.weight_decay)
# optimizer = torch.optim.AdamW(net.parameters(), args.lr)
#loss:SmoothL1\Iou\Giou\Diou\Ciou
print(cfg['losstype'])
criterion = MultiBoxLoss(cfg=cfg,
overlap_thresh=0.5,
prior_for_matching=True,
bkg_label=0,
neg_mining=True,
neg_pos=3,
neg_overlap=0.5,
encode_target=False,
use_gpu=args.cuda,
loss_name=cfg['losstype'])
project_name = "_".join([args.net_name, args.config])
pth_path = os.path.join(args.save_path, project_name)
log_path = os.path.join(pth_path, 'tensorboard')
os.makedirs(pth_path, exist_ok=True)
os.makedirs(log_path, exist_ok=True)
writer = SummaryWriter(
log_path + f'/{datetime.datetime.now().strftime("%Y%m%d-%H%M%S")}/')
epoch_size = len(dataset) // args.batch_size
print('Training SSD on:', dataset.name, epoch_size)
iteration = args.start_iter
step_index = 0
loc_loss = 0
conf_loss = 0
step = 0
num_iter_per_epoch = len(data_loader)
lr_need_steps = list(cfg['lr_steps'])
for epoch in range(start_iter, args.max_epoch):
progress_bar = tqdm(data_loader)
for ii, batch_iterator in enumerate(progress_bar):
iteration += 1
if step in cfg['lr_steps']:
step_index += 1
adjust_learning_rate(optimizer, args.gamma, epoch, step_index,
iteration, num_iter_per_epoch)
# load train data
images, targets = batch_iterator
# print(images,targets)
if args.cuda:
images = images.cuda()
targets = [ann.cuda() for ann in targets]
else:
images = images
targets = [ann for ann in targets]
t0 = time.time()
out = net(images, 'train')
optimizer.zero_grad()
loss_l, loss_c = criterion(out, targets)
loss = weight * loss_l + loss_c
loss.backward()
optimizer.step()
t1 = time.time()
loc_loss += loss_l.item()
conf_loss += loss_c.item()
progress_bar.set_description(
'Step: {}. Epoch: {}/{}. Iteration: {}/{}. Cls loss: {:.5f}. Reg loss: {:.5f}. Total loss: {:.5f}'
.format(step, epoch, args.max_epoch, ii + 1,
num_iter_per_epoch, loss_c.item(), loss_l.item(),
loss.item()))
writer.add_scalars('Loss', {'train': loss}, step)
writer.add_scalars('Regression_loss', {'train': loss_l.item()},
step)
writer.add_scalars('Classfication_loss', {'train': loss_c.item()},
step)
current_lr = optimizer.param_groups[0]['lr']
writer.add_scalar('learning_rate', current_lr, step)
# print(iteration)
# if iteration % 10 == 0:
# print('timer: %.4f sec.' % (t1 - t0))
# print('iter ' + repr(iteration) + ' || Loss: %.4f ||' % (loss.item()), end=' ')
step += 1
# if epoch % 10 == 0 and epoch >60:
# # epoch>1000 and epoch % 50 == 0:
# print('Saving state, iter:', iteration)
# #print('loss_l:'+weight * loss_l+', loss_c:'+'loss_c')
# save_folder = args.work_dir+cfg['work_name']
# if not os.path.exists(save_folder):
# os.mkdir(save_folder)
# torch.save(net.state_dict(),args.work_dir+cfg['work_name']+'/ssd'+
# repr(epoch)+'_.pth')
if step != 0 and step % 4000 == 0:
torch.save(
net.state_dict(),
os.path.join(pth_path,
f'{args.net_name}_{epoch}_{step}.pth'))
loc_loss = 0
conf_loss = 0
torch.save(net.state_dict(),
os.path.join(pth_path, f'{args.net_name}_{epoch}_{step}.pth'))
def train():
if args.dataset == 'COCO':
if args.dataset_root == VOC_ROOT:
if not os.path.exists(COCO_ROOT):
parser.error('Must specify dataset_root if specifying dataset')
print("WARNING: Using default COCO dataset_root because " +
"--dataset_root was not specified.")
args.dataset_root = COCO_ROOT
cfg = coco
dataset = COCODetection(root=args.dataset_root,
transform=SSDAugmentation(
cfg['min_dim'], MEANS))
elif args.dataset == 'VOC':
if args.dataset_root == COCO_ROOT:
parser.error('Must specify dataset if specifying dataset_root')
cfg = voc
dataset = VOCDetection(root=args.dataset_root,
transform=SSDAugmentation(
cfg['min_dim'], MEANS))
elif args.dataset == 'OPIXray':
print('\nXray\n')
cfg = OPIXray
dataset = OPIXrayDetection(root=args.dataset_root,
image_sets=args.image_sets,
phase='train')
ssd_net = build_ssd('train', cfg['min_dim'], cfg['num_classes'])
#ssd_net = build_ssd('train', cfg['min_dim'], 21)
net = ssd_net
print(ssd_net)
if args.cuda:
net = torch.nn.DataParallel(ssd_net)
cudnn.benchmark = True
if args.resume:
print('Resuming training, loading {}...'.format(args.resume))
ssd_net.load_weights(args.resume)
else:
if not args.transfer:
vgg_weights = torch.load(args.save_folder + args.basenet)
print('Loading base network...')
ssd_net.vgg.load_state_dict(vgg_weights)
else:
print('Transfer learning...')
ssd_net.load_weights(args.transfer, isStrict=False)
ssd_net._conf.apply(weights_init)
ssd_net._modules['vgg'][0] = nn.Conv2d(4,
64,
kernel_size=3,
padding=1)
'''
pretrained_dict = torch.load(args.transfer)
model_dict = ssd_net.state_dict()
pretrained_dict = transfer_state_dict(pretrained_dict, model_dict)
model_dict.update(pretrained_dict) # 更新(合并)模型的参数
ssd_net = ssd_net.load_state_dict(model_dict)
'''
'''
pretrained_dict = torch.load(args.transfer)
model_dict = ssd_net.state_dict()
pretrained_dict = {k: v for k, v in pretrained_dict.items() if
k in model_dict and (k != 'vgg.33.weight') and (k != 'extras.0.weight') and (k != 'extras.2.weight')
and (k != 'extras.4.weight') and (k != 'extras.6.weight')} # filter out unnecessary keys
model_dict.update(pretrained_dict)
ssd_net.load_state_dict(model_dict)
nn.init.xavier_uniform_(ssd_net.vgg[33].weight)
'''
#ssd_net.vgg[33]
if args.cuda:
net = net.cuda()
if (not args.resume) & (not args.transfer):
print('Initializing weights...')
# initialize newly added layers' weights with xavier method
ssd_net.extras.apply(weights_init)
ssd_net.loc.apply(weights_init)
ssd_net._conf.apply(weights_init)
optimizer = optim.SGD(net.parameters(),
lr=args.lr,
momentum=args.momentum,
weight_decay=args.weight_decay)
criterion = MultiBoxLoss(cfg['num_classes'], 0.5, True, 0, True, 3, 0.5,
False, args.cuda)
net.train()
# loss counters
loc_loss = 0
conf_loss = 0
epoch = 0
print('Loading the dataset...')
epoch_size = len(dataset) // args.batch_size
print('Training SSD on:', dataset.name)
print('Using the specified args:')
print(args)
step_index = 0
if args.visdom:
vis_title = 'SSD on ' + dataset.name + '\n' + start_time
vis_legend = ['Loc Loss', 'Conf Loss', 'Total Loss']
iter_plot = create_vis_plot('Iteration', 'Loss', vis_title, vis_legend)
epoch_plot = create_vis_plot('Epoch', 'Loss', vis_title, vis_legend)
data_loader = data.DataLoader(dataset,
args.batch_size,
num_workers=args.num_workers,
shuffle=True,
collate_fn=detection_collate,
pin_memory=True)
# create batch iterator
batch_iterator = iter(data_loader)
for iteration in range(args.start_iter, cfg['max_iter']):
if iteration != 0 and (iteration % epoch_size == 0):
epoch += 1
#update_vis_plot(epoch, loc_loss, conf_loss, epoch_plot, None,
# 'append', epoch_size)
# reset epoch loss counters
loc_loss = 0
conf_loss = 0
if epoch % 5 == 0:
print('Saving state, epoch:', epoch)
#torch.save(ssd_net.state_dict(), args.save_folder + '/ssd300_SIXray_' +
# repr(epoch) + '.pth')
torch.save(
ssd_net.state_dict(), args.save_folder +
'/ssd300_Xray_knife_' + repr(epoch) + '.pth')
if iteration in cfg['lr_steps']:
step_index += 1
adjust_learning_rate(optimizer, args.gamma, step_index)
# load train data
print('iteration:', iteration)
try:
images, targets = next(batch_iterator)
except:
batch_iterator = iter(data_loader)
images, targets = next(batch_iterator)
print('Reload!')
if args.cuda:
images = Variable(images.cuda())
targets = [Variable(ann.cuda(), volatile=True) for ann in targets]
else:
images = Variable(images)
targets = [Variable(ann, volatile=True) for ann in targets]
# forward
images = images.type(torch.FloatTensor)
t0 = time.time()
out = net(images)
# backprop
optimizer.zero_grad()
loss_l, loss_c = criterion(out, targets)
loss = loss_l + loss_c
loss.backward()
optimizer.step()
t1 = time.time()
loc_loss += loss_l.item()
conf_loss += loss_c.item()
if iteration % 10 == 0:
print('timer: %.4f sec.' % (t1 - t0))
print('iter ' + repr(iteration) + ' || Loss: %.4f ||' %
(loss.item()),
end=' ')
if args.visdom:
update_vis_plot(iteration, loss_l.item(), loss_c.item(), iter_plot,
epoch_plot, 'append')
torch.save(ssd_net.state_dict(),
args.save_folder + '' + args.dataset + '.pth')
def train():
if args.dataset == 'COCO':
if args.dataset_root == VOC_ROOT:
if not os.path.exists(COCO_ROOT):
parser.error('Must specify dataset_root if specifying dataset')
print("WARNING: Using default COCO dataset_root because " +
"--dataset_root was not specified.")
args.dataset_root = COCO_ROOT
cfg = coco
dataset = COCODetection(root=args.dataset_root,
transform=SSDAugmentation(cfg['min_dim'],
MEANS))
elif args.dataset == 'VOC':
if args.dataset_root == COCO_ROOT:
parser.error('Must specify dataset if specifying dataset_root')
cfg = voc
dataset = VOCDetection(root=args.dataset_root,
transform=SSDAugmentation(cfg['min_dim'],
MEANS))
if args.visdom:
import visdom
viz = visdom.Visdom()
ssd_net = build_ssd('train', cfg['min_dim'], cfg['num_classes'])
net = ssd_net
if args.cuda:
net = torch.nn.DataParallel(ssd_net)
cudnn.benchmark = True
if args.resume:
print('Resuming training, loading {}...'.format(args.resume))
ssd_net.load_weights(args.resume)
else:
vgg_weights = torch.load(args.save_folder + args.basenet)
print('Loading base network...')
ssd_net.vgg.load_state_dict(vgg_weights)
if args.cuda:
net = net.cuda()
if not args.resume:
print('Initializing weights...')
# initialize newly added layers' weights with xavier method
ssd_net.extras.apply(weights_init)
ssd_net.loc.apply(weights_init)
ssd_net.conf.apply(weights_init)
optimizer = optim.SGD(net.parameters(), lr=args.lr, momentum=args.momentum,
weight_decay=args.weight_decay)
criterion = MultiBoxLoss(cfg['num_classes'], 0.5, True, 0, True, 3, 0.5,
False, args.cuda)
now_time = (datetime.datetime.now() + datetime.timedelta(hours=8)).strftime('%Y-%m-%d-%H-%M')
writer = SummaryWriter("runs/" + now_time[5:])
print('Loading the dataset...')
epoch_size = len(dataset) // args.batch_size
print('Training SSD on:', dataset.name)
print('Using the specified args:')
print(args)
data_loader = data.DataLoader(dataset, args.batch_size,
num_workers=args.num_workers,
shuffle=True, collate_fn=detection_collate,
pin_memory=True)
net.train()
# loss counters
loc_loss = 0
conf_loss = 0
loc_loss_epoch = 0.0
conf_loss_epoch = 0.0
total_loss_epoch = 0.0
# create batch iterator
step_index = 0
iteration = 0
max_epoches = int(cfg["max_iter"] / epoch_size)
for epoch in range(int(max_epoches+1)):
t0 = time.time()
for images, targets in data_loader:
iteration += 1
if iteration in cfg['lr_steps']:
step_index += 1
adjust_learning_rate(optimizer, args.gamma, step_index)
if args.cuda:
images = images.cuda()
for i in range(len(targets)):
targets[i] = targets[i].float().cuda()
else:
images = images
targets = targets
# forward
out = net(images)
# backprop
optimizer.zero_grad()
loss_l, loss_c = criterion(out, targets)
loss = loss_l + loss_c
loss.backward()
optimizer.step()
loc_loss += loss_l.item()
conf_loss += loss_c.item()
loc_loss_epoch += loss_l.item()
conf_loss_epoch += loss_c.item()
total_loss_epoch += loss.item()
writer.add_scalar("loss/total_loss_iterations", loss.item(), iteration)
if iteration % epoch_size == 0:
writer.add_scalar("loss/loc_loss", loc_loss_epoch / len(dataset), epoch)
writer.add_scalar("loss/conf_loss", conf_loss_epoch / len(dataset), epoch)
writer.add_scalar("loss/total_loss", total_loss_epoch / len(dataset), epoch)
loc_loss_epoch = 0.0
conf_loss_epoch = 0.0
total_loss_epoch = 0.0
if iteration % 10 == 0:
t1 = time.time()
print('Every 10 iterations timer: %.4f sec.' % (t1 - t0))
print('iter [' + repr(iteration + 1) + "/" + str(cfg["max_iter"]) + '] ||' +
'epoch [' + str(epoch+1) + "/" + str(max_epoches) + "] ||" +
'Batch-Loss: %.4f ||' % (loss.item()),
end=' ')
t0 = time.time()
if iteration % 5000 == 0:
print('Saving state, iter:', iteration)
torch.save(ssd_net.state_dict(), 'weights/ssd300_voc_pf_' +
repr(iteration+1) + '.pth')
torch.save(ssd_net.state_dict(),
args.save_folder + '' + args.dataset + '.pth')
def train():
args.dataset = 'VOC'
args.resume = 'vocinit'
args.batch_size = 16
args.num_workers = 2
ssd_net = build_ssd(cfg['min_dim'], cfg['num_classes'])
net = ssd_net
net = torch.nn.DataParallel(ssd_net)
cudnn.benchmark = True
if args.resume == 'vocinit':
args.resume = 'weights/base/ssd_300_VOC0712.pth'
print('Resuming training, loading {}...'.format(args.resume))
ssd_net.extras.apply(weights_init)
ssd_net.loc.apply(weights_init)
ssd_net.conf.apply(weights_init)
ssd_net.load_weights(args.resume, True)
elif args.resume == 'ours':
args.resume = 'weights/VOC.pth'
print('Resuming training, loading {}...'.format(args.resume))
ssd_net.load_weights(args.resume, False)
else: #random init
ssd_net.vgg.apply(weights_init)
ssd_net.extras.apply(weights_init)
ssd_net.loc.apply(weights_init)
ssd_net.conf.apply(weights_init)
net = net.cuda()
optimizer = optim.Adam(net.parameters(), lr=args.lr)
criterion = MultiBoxLoss(cfg['num_classes'], 0.5, 3)
net.train()
valloss = 10000000000
start_time = time.time()
for epoch in range(0,4):
dataset = VOCDetection(None, transform=SSDAugmentation(cfg['min_dim'],MEANS), phase = 'train')
data_loader = data.DataLoader(dataset, args.batch_size,
num_workers=args.num_workers,collate_fn=detection_collate,
pin_memory=True)
print('epoch ',epoch)
loss_all = 0
if epoch <= 1:
args.lr = 0.0001
set_lr(args.lr,optimizer)
elif epoch == 2:
args.lr = 0.00001
set_lr(args.lr,optimizer)
print('learning rate:', args.lr)
for iteration, (images,targets) in enumerate(data_loader):
images, targets = remove_redudant(images,targets)
images = Variable(images.cuda())
with torch.no_grad():
targets = [ann.cuda() for ann in targets]
out = net(images)
optimizer.zero_grad()
loss_l, loss_c = criterion(out, targets)
loss = loss_l + loss_c
loss.backward()
optimizer.step()
loss_all = loss_all + loss.data
if iteration % 500 == 0:
print('iter %4d'%iteration, ' || Loss: %2.4f ||' % (loss.data))
if iteration % 2000 == 0 and iteration > 0:
print("---total training time: %s seconds ---" % (time.time() - start_time))
curloss = val(net, criterion)
if valloss > curloss:
torch.save(ssd_net.state_dict(), args.save_folder + '' + args.dataset +'.pth')
valloss = curloss
print('model saved')
def train():
if args.dataset == 'COCO':
if args.dataset_root == VOC_ROOT:
if not os.path.exists(COCO_ROOT):
parser.error('Must specify dataset_root if specifying dataset')
print("WARNING: Using default COCO dataset_root because " +
"--dataset_root was not specified.")
args.dataset_root = COCO_ROOT
cfg = coco
dataset = COCODetection(root=args.dataset_root,
transform=SSDAugmentation(
cfg['min_dim'], MEANS))
elif args.dataset == 'VOC':
if args.dataset_root == COCO_ROOT:
parser.error('Must specify dataset if specifying dataset_root')
cfg = voc_ssd7
dataset = VOCDetection(root=args.dataset_root,
transform=SSDAugmentation(
cfg['min_dim'], MEANS))
if args.visdom:
import visdom
viz = visdom.Visdom()
ssd_net = build_ssd7('train', cfg['num_classes'])
print(ssd_net)
net = ssd_net
if args.cuda:
net = torch.nn.DataParallel(ssd_net)
cudnn.benchmark = True
if args.resume:
print('Resuming training, loading {}...'.format(args.resume))
ssd_net.load_weights(args.resume)
# else:
# mobilenet_weights = torch.load(args.save_folder + args.basenet)
# print('Loading base network...')
# ssd_net.mobilenet.load_state_dict(mobilenet_weights)
if args.cuda:
net = net.cuda()
if not args.resume:
print('Initializing weights...')
# initialize newly added layers' weights with xavier method
ssd_net.loc.apply(weights_init)
ssd_net.conf.apply(weights_init)
optimizer = optim.SGD(net.parameters(),
lr=args.lr,
momentum=args.momentum,
weight_decay=args.weight_decay)
# optimizer = optim.Adam(net.parameters(), lr=args.lr)
criterion = MultiBoxLoss(cfg['num_classes'], 0.5, True, 0, True, 3, 0.5,
False, args.cuda)
net.train()
# loss counters
loc_loss = 0
conf_loss = 0
epoch = 0
print('Loading the dataset...')
# args.batch_size = 64
epoch_size = len(dataset) // args.batch_size
print('Training SSD on:', dataset.name)
print('Using the specified args:')
print(args)
step_index = 0
if args.visdom:
vis_title = 'SSD.PyTorch on ' + dataset.name
vis_legend = ['Loc Loss', 'Conf Loss', 'Total Loss']
iter_plot = create_vis_plot('Iteration', 'Loss', vis_title, vis_legend)
epoch_plot = create_vis_plot('Epoch', 'Loss', vis_title, vis_legend)
data_loader = data.DataLoader(dataset,
args.batch_size,
num_workers=args.num_workers,
shuffle=True,
collate_fn=detection_collate,
pin_memory=True)
# create batch iterator
batch_iterator = iter(data_loader)
for iteration in range(args.start_iter, cfg['max_iter']):
if args.visdom and iteration != 0 and (iteration % epoch_size == 0):
update_vis_plot(epoch, loc_loss, conf_loss, epoch_plot, None,
'append', epoch_size)
# reset epoch loss counters
loc_loss = 0
conf_loss = 0
epoch += 1
if iteration in cfg['lr_steps']:
step_index += 1
adjust_learning_rate(optimizer, args.gamma, step_index)
# load train data
# images, targets = next(batch_iterator)
try:
images, targets = next(batch_iterator)
except StopIteration:
batch_iterator = iter(data_loader)
images, targets = next(batch_iterator)
if args.cuda:
# images = Variable(images.cuda())
# targets = [Variable(ann.cuda(), volatile=True) for ann in targets]
images = images.cuda()
targets = [ann.cuda() for ann in targets]
else:
images = Variable(images)
targets = [Variable(ann, volatile=True) for ann in targets]
# forward
t0 = time.time()
# print(images)
out = net(images)
# backprop
optimizer.zero_grad()
loss_l, loss_c = criterion(out, targets)
loss = loss_l + loss_c
loss.backward()
optimizer.step()
t1 = time.time()
# loc_loss += loss_l.data[0]
# conf_loss += loss_c.data[0]
loc_loss += loss_l.data
conf_loss += loss_c.data
if iteration % 10 == 0:
print('timer: %.4f sec.' % (t1 - t0))
# print('iter ' + repr(iteration) + ' || Loss: %.4f ||' % (loss.data[0]), end=' ')
print('iter ' + repr(iteration) + ' || Loss: %.4f ||' %
(loss.data),
end=' ')
if args.visdom:
# update_vis_plot(iteration, loss_l.data[0], loss_c.data[0],
# iter_plot, epoch_plot, 'append')
update_vis_plot(iteration, loss_l.data, loss_c.data, iter_plot,
epoch_plot, 'append')
if iteration != 0 and iteration % 5000 == 0:
print('Saving state, iter:', iteration)
torch.save(ssd_net.state_dict(),
'weights/ssd7_VOC_' + repr(iteration) + '.pth')
torch.save(ssd_net.state_dict(),
args.save_folder + '' + args.dataset + '.pth')
def train():
if args.dataset == 'COCO':
if args.dataset_root == VOC_ROOT:
if not os.path.exists(COCO_ROOT):
parser.error('Must specify dataset_root if specifying dataset')
print("WARNING: Using default COCO dataset_root because " +
"--dataset_root was not specified.")
args.dataset_root = COCO_ROOT
cfg = coco
dataset = COCODetection(root=args.dataset_root,
transform=SSDAugmentation(
cfg['min_dim'], MEANS))
elif args.dataset == 'VOC':
if args.dataset_root == COCO_ROOT:
parser.error('Must specify dataset if specifying dataset_root')
cfg = voc
dataset = VOCDetection(root=args.dataset_root,
transform=SSDAugmentation(
cfg['min_dim'], MEANS))
net = EfficientDet(num_class=cfg['num_classes'])
if args.cuda:
net = net.cuda()
# if args.cuda:
# net = torch.nn.DataParallel(net)
# cudnn.benchmark = True
optimizer = optim.AdamW(net.parameters(), lr=args.lr)
criterion = MultiBoxLoss(cfg['num_classes'], 0.5, True, 0, True, 3, 0.5,
False, args.cuda)
data_loader = data.DataLoader(dataset,
args.batch_size,
num_workers=args.num_workers,
shuffle=True,
collate_fn=detection_collate,
pin_memory=True)
net.train()
iteration = 0
for epoch in range(args.num_epoch):
print('\n Start epoch: {} ...'.format(epoch))
for idx, (images, targets) in enumerate(data_loader):
if args.cuda:
images = Variable(images.cuda())
targets = [
Variable(ann.cuda(), volatile=True) for ann in targets
]
else:
images = Variable(images)
targets = [Variable(ann, volatile=True) for ann in targets]
# forward
t0 = time.time()
out = net(images)
optimizer.zero_grad()
loss_l, loss_c = criterion(out, targets)
loss = loss_l + loss_c
loss.backward()
optimizer.step()
t1 = time.time()
if iteration % 10 == 0:
print('timer: %.4f sec.' % (t1 - t0))
print('iter ' + repr(iteration) + ' || Loss: %.4f ||' % (loss),
end=' ')
if iteration != 0 and iteration % 5000 == 0:
print('Saving state, iteration:', iteration)
torch.save(net.state_dict(),
'weights/Effi' + repr(idx) + '.pth')
iteration += 1
torch.save(net.state_dict(), args.save_folder + '' + args.dataset + '.pth')
def train():
#加载icdar数据
dataset = icdar_dataset.ICDARData(root=DATAROOT,
img_path=IMG_PATH,
txt_path=TXT_PATH)
# if args.visdom:
# import visdom
# viz = visdom.Visdom()
tb_net = build_tb('train')
net = tb_net
if args.cuda:
net = torch.nn.DataParallel(tb_net)
cudnn.benchmark = True
#是否从上次训练的断点处继续训练
if args.resume:
print('Resuming training, loading {}...'.format(args.resume))
tb_net.load_weights(args.resume)
else:
vgg_weights = torch.load(args.save_folder + args.basenet)
print('Loading base network...')
tb_net.vgg.load_state_dict(vgg_weights)
if args.cuda:
net = net.cuda()
if not args.resume:
print('Initializing weights...')
# initialize newly added layers' weights with xavier method
tb_net.extras.apply(weights_init)
tb_net.loc.apply(weights_init)
tb_net.conf.apply(weights_init)
optimizer = optim.SGD(net.parameters(),
lr=args.lr,
momentum=args.momentum,
weight_decay=args.weight_decay)
criterion = MultiBoxLoss(cfg['num_class'], 0.5, True, 0, True, 3, 0.5,
False, args.cuda)
net.train()
# loss counters
loc_loss = 0
conf_loss = 0
epoch = 0
print('Loading the dataset...')
epoch_size = len(dataset) // args.batch_size
# print('Training SSD on:', dataset.name)
print('Using the specified args:')
print(args)
step_index = 0
# if args.visdom:
# vis_title = 'SSD.PyTorch on ' + dataset.name
# vis_legend = ['Loc Loss', 'Conf Loss', 'Total Loss']
# iter_plot = create_vis_plot('Iteration', 'Loss', vis_title, vis_legend)
# epoch_plot = create_vis_plot('Epoch', 'Loss', vis_title, vis_legend)
data_loader = data.DataLoader(dataset,
args.batch_size,
num_workers=args.num_workers,
shuffle=True,
collate_fn=detection_collate,
pin_memory=True)
# create batch iterator
batch_iterator = iter(data_loader)
for iteration in range(args.start_iter, cfg['max_iter']):
# if args.visdom and iteration != 0 and (iteration % epoch_size == 0):
# update_vis_plot(epoch, loc_loss, conf_loss, epoch_plot, None,
# 'append', epoch_size)
# # reset epoch loss counters
# loc_loss = 0
# conf_loss = 0
# epoch += 1
if iteration in cfg['lr_steps']:
step_index += 1
adjust_learning_rate(optimizer, args.gamma, step_index)
# load train data
#images, targets = next(batch_iterator)
#print('images:', images)
try:
images, targets = next(batch_iterator)
except StopIteration:
batch_iterator = iter(data_loader)
images, targets = next(batch_iterator)
except Exception as e:
print("loading dta exception", e)
#print(images.type())
if args.cuda:
images = Variable(images.cuda())
with torch.no_grad():
targets = [Variable(ann.cuda()) for ann in targets]
else:
images = Variable(images)
with torch.no_grad():
targets = [Variable(ann) for ann in targets]
# forward
t0 = time.time()
#print(images.type())
out = net(images)
# backprop
optimizer.zero_grad()
loss_l, loss_c = criterion(out, targets)
loss = loss_l + loss_c
loss.backward()
optimizer.step()
t1 = time.time()
# print('loss_l:', loss_l)
# print('loss_c:', loss_c)
# loc_loss += loss_l.data.item()
# conf_loss += loss_c.data.item()
loc_loss += loss_l
conf_loss += loss_c
if iteration % 10 == 0:
print('timer: %.4f sec.' % (t1 - t0))
print('iter ' + repr(iteration) + ' || Loss: %.4f ||' %
(loss.data.item()),
end=' ')
# if args.visdom:
# update_vis_plot(iteration, loss_l.data[0], loss_c.data[0],
# iter_plot, epoch_plot, 'append')
if iteration != 0 and iteration % 5000 == 0:
print('Saving state, iter:', iteration)
torch.save(tb_net.state_dict(),
'weights/tb_ICDAR_' + repr(iteration) + '.pth')
torch.save(tb_net.state_dict(),
args.save_folder + '' + args.dataset + '.pth')
def train():
cfg = voc # voc是一个字典 里面包括网络的一系列参数信息
dataset = VOCDetection( # 是一个VOC数据的类
root=args.dataset_root, # 数据集的根目录
transform=SSDAugmentation(
cfg['min_dim'],
MEANS)) # 图片的预处理方法(输入图片的尺寸和均值) 原本类中定义为None 后面的MEANS我人为可以删除
if args.visdom: # 这里是可视化工具，不用管###################
import visdom
viz = visdom.Visdom()
ssd_net = build_ssd('train', cfg['min_dim'], cfg['num_classes'])
# 阶段【train or test】 输入图片尺寸大小 类别数
# build_ssd是一个放在ssd.py的函数
# return是一个类的对象，也就是class SSD(nn.Module)，ssd_net也就是SSD类的一个对象
# ssd_net拥有所有class SSD继承于nn.Module以及作者增加方法的所有属性
# 在SSD这个类中就定义了网络的base部分（修改全连接层后的VGG16）和extras部分（论文作者加入的多尺度feature map）和head部分
# 对选定的6个尺度下的feature map进行卷积操作得到的每个default box 的每一个分类类别的confidence以及位置坐标的信息
net = ssd_net # 到这里class类SSD只完成了__init__()并没有执行__forward__() net是一个类
if args.cuda: # 是否将模型放到多个个GPU上运行{我认为在我的任务中不要放在多线程GPU中}
net = torch.nn.DataParallel(ssd_net)
cudnn.benchmark = True
if args.resume: # 【resume】的默认值是None,表示不是接着某个断点来继续训练这个模型 【其实checkpoint里面最好还要加上优化器的保存】
# 【model_state_dict,optimizer_state_dict,epoch】 见深度之眼
print('Resuming training, loading {}...'.format(args.resume))
ssd_net.load_weights(args.resume)
else: # 那么就从weights文件夹下面直接加载预训练好vgg基础网络预训练权重
vgg_weights = torch.load(args.save_folder +
args.basenet) # 整个ssd_net中vgg基础网络的权重
print('Loading base network...')
ssd_net.vgg.load_state_dict(
vgg_weights
) # 只在整个ssd_net中的vgg模块中加载预训练好的权重，其余的extra，特征融合，CBAM模块没有加载预训练权重
if args.cuda: # 将模型结构放在GPU上训练
net = net.cuda()
if not args.resume: # ######################################################################
print('Initializing weights...'
) # 如果不是接着某个断点接着训练，那么其余extras loc con都会xavier方法初始化
# initialize newly added layers' weights with xavier method
ssd_net.extras.apply(
weights_init) # extras 模块由 xavier 方法默认初始化data和bias
ssd_net.loc.apply(weights_init) # loc 模块由 xavier 方法默认初始化data和bias
ssd_net.conf.apply(weights_init) # conf 模块由 xavier 方法默认初始化data和bias
# 【优化器】net.parameters()是网络结构中的参数，学习率，动量，权重衰减率
optimizer = optim.SGD(net.parameters(),
lr=args.lr,
momentum=args.momentum,
weight_decay=args.weight_decay)
# 定义损失函数部分【MultiBoxesLoss是一个类用于计算网络的损失，criterion是一个对象】
# 【损失函数】 关键！！！ criterion是个nn.Moudule的形式 里面包括两部分loss_c 和 loss_l
criterion = MultiBoxLoss(cfg['num_classes'], 0.5, True, 0, True, 3, 0.5,
False, args.cuda)
# 前向传播
net.train()
# loss counters
loc_loss = 0
conf_loss = 0
epoch = 0
print('Loading the dataset...')
epoch_size = len(dataset) // args.batch_size # 每个epoch中有多少个batch
print('Training SSD on:', dataset.name)
print('Using the specified args:')
print(args) # 讲设定的参数打印出来
step_index = 0
# 可视化部分
if args.visdom: # 默认值为False
vis_title = 'SSD.PyTorch on ' + dataset.name
vis_legend = ['Loc Loss', 'Conf Loss', 'Total Loss']
iter_plot = create_vis_plot('Iteration', 'Loss', vis_title, vis_legend)
epoch_plot = create_vis_plot('Epoch', 'Loss', vis_title, vis_legend)
data_loader = data.DataLoader(
dataset,
args.batch_size,
num_workers=args.num_workers, # 默认值我修改成了0
shuffle=True,
collate_fn=detection_collate, # collate_fn将一个batch_size数目的图片进行合并成batch
pin_memory=True)
batch_iterator = iter(data_loader) # batch迭代器 依次迭代batch
for iteration in range(args.start_iter, cfg['max_iter']): # 由最大迭代次数来迭代训练
if args.visdom and iteration != 0 and (
iteration % epoch_size == 0): # 因为args.visdom一直设置为False因此没有被调用
update_vis_plot(epoch, loc_loss, conf_loss, epoch_plot, None,
'append', epoch_size)
# reset epoch loss counters
loc_loss = 0
conf_loss = 0
epoch += 1
if iteration in cfg['lr_steps']: # 通过多少次epoch调节一次学习率
step_index += 1
adjust_learning_rate(optimizer, args.gamma, step_index)
# load train data
try:
images, targets = next(batch_iterator)
# targets 和image都是读取的训练数据
except StopIteration:
bath_iterator = iter(data_loader)
images, targets = next(bath_iterator)
# images=【batch_size,3,300,300】
# targets=【batch_size,num_object,5】
# num_object代表一张图里面有几个ground truth，5代表四个位置信息和一个label
if args.cuda: # 将数据放在cuda上
images = Variable(images.cuda())
targets = [Variable(ann.cuda(), volatile=True) for ann in targets]
else:
images = Variable(images)
targets = [Variable(ann, volatile=True) for ann in targets]
# forward
t0 = time.time()
# ##out是netforward的输出：是个元组，里面包括3个部分[loc conf priors]
out = net(images)
# ## backprop 优化器梯度清零
optimizer.zero_grad()
# ## criterion是nn.Module形式，下面是调用它的forward模式【重点看，里面包括难例挖掘的内容】
# ###################################【【【训练阶段的损失！！！】】】######################################
# ##输入参数1：网络结构net输出的out:[loc conf priors]
# ##输入参数2：targets:真实目标的位置标签值
loss_l, loss_c = criterion(
out, targets
) # criterion就是MultiBoxLoss类定义的对象，forward前传播返回的结果是【loss_l, loss_c】
loss = loss_l + loss_c # 总loss
loss.backward()
optimizer.step()
t1 = time.time()
# 下面两行好像没有使用
loc_loss += loss_l.data # ###到底是改成item()还是data
conf_loss += loss_c.data # ###到底是改成item()还是data
if iteration % 10 == 0:
print('timer: %.4f sec.' % (t1 - t0))
print('iter ' + repr(iteration) + ' || Loss: %.4f ||' % loss.data,
end=' ') # 到底是改成item()还是data
if args.visdom:
update_vis_plot(iteration, loss_l.data, loss_c.data, iter_plot,
epoch_plot, 'append')
if iteration != 0 and iteration % 500 == 0:
# 迭代多少次保存一次模型。 在尝试阶段，为了节省时间，建议将根据迭代次数保存模型的参数调低，例如调节到500
print('Saving state, iter:', iteration) # 保存的checkpoint
torch.save(ssd_net.state_dict(), 'weights/ssd300_VOC_' +
repr(iteration) + '.pth') # 保存模型的路径
torch.save(ssd_net.state_dict(), args.save_folder + '' + args.dataset +
'.pth') # 最后的保存：不是保存整个模型，只是保存了参数
