def ssd_train_dataloader(net,
train_dataset,
data_shape=512,
batch_size=10,
num_workers=0):
'''
returns the train loader from gluoncv
'''
from gluoncv.data.batchify import Tuple, Stack, Pad
from gluoncv.data.transforms.presets.ssd import SSDDefaultTrainTransform
width, height = data_shape, data_shape
# use fake data to generate fixed anchors for target generation
with autograd.train_mode():
_, _, anchors = net(mx.nd.zeros((1, 3, height, width)))
batchify_fn = Tuple(Stack(), Stack(),
Stack()) # stack image, cls_targets, box_targets
new_SSDDefaultTrainTransform = SSDDefaultTrainTransform(
width, height, anchors)
new_SSDDefaultTrainTransform.__call__ = new_trainloader_call
train_loader = gluon.data.DataLoader(
train_dataset.transform(new_SSDDefaultTrainTransform),
batch_size,
True,
batchify_fn=batchify_fn,
last_batch="rollover",
num_workers=num_workers,
)
return train_loader
def Model(self, model_name, use_pretrained=True, use_gpu=True, gpu_devices=[0]):
self.system_dict["model_name"] = model_name;
self.system_dict["use_pretrained"] = use_pretrained;
if(self.system_dict["model_name"] in self.system_dict["model_set_1"]):
self.system_dict["local"]["net"] = gcv.model_zoo.get_model(self.system_dict["model_name"],
pretrained=self.system_dict["use_pretrained"]);
self.system_dict["local"]["net"].reset_class(self.system_dict["classes"])
self.system_dict["img_shape"] = (300, 300);
width, height = self.system_dict["img_shape"][0], self.system_dict["img_shape"][1]
with autograd.train_mode():
_, _, anchors = self.system_dict["local"]["net"](mx.nd.zeros((1, 3, height, width)))
batchify_fn = Tuple(Stack(), Stack(), Stack())
self.system_dict["local"]["train_loader"] = gluon.data.DataLoader(
self.system_dict["local"]["train_dataset"].transform(SSDDefaultTrainTransform(width, height, anchors)),
self.system_dict["batch_size"], True, batchify_fn=batchify_fn, last_batch='rollover',
num_workers=self.system_dict["num_workers"])
self.set_device(use_gpu=use_gpu ,gpu_devices=gpu_devices);
self.system_dict["local"]["net"].collect_params().reset_ctx(self.system_dict["local"]["ctx"])
elif((self.system_dict["model_name"] in self.system_dict["model_set_2"]) or (self.system_dict["model_name"] in self.system_dict["model_set_3"])
or (self.system_dict["model_name"] in self.system_dict["model_set_4"])):
self.system_dict["local"]["net"] = gcv.model_zoo.get_model(self.system_dict["model_name"],
pretrained=self.system_dict["use_pretrained"]);
self.system_dict["local"]["net"].reset_class(self.system_dict["classes"])
self.system_dict["img_shape"] = (512, 512);
width, height = self.system_dict["img_shape"][0], self.system_dict["img_shape"][1]
with autograd.train_mode():
_, _, anchors = self.system_dict["local"]["net"](mx.nd.zeros((1, 3, height, width)))
batchify_fn = Tuple(Stack(), Stack(), Stack())
self.system_dict["local"]["train_loader"] = gluon.data.DataLoader(
self.system_dict["local"]["train_dataset"].transform(SSDDefaultTrainTransform(width, height, anchors)),
self.system_dict["batch_size"], True, batchify_fn=batchify_fn, last_batch='rollover',
num_workers=self.system_dict["num_workers"])
self.set_device(use_gpu=use_gpu, gpu_devices=gpu_devices);
self.system_dict["local"]["net"].collect_params().reset_ctx(self.system_dict["local"]["ctx"])
elif((self.system_dict["model_name"] in self.system_dict["model_set_5"]) or (self.system_dict["model_name"] in self.system_dict["model_set_6"])) :
self.system_dict["local"]["net"] = gcv.model_zoo.get_model(self.system_dict["model_name"],
pretrained=self.system_dict["use_pretrained"]);
self.system_dict["local"]["net"].reset_class(self.system_dict["classes"])
self.system_dict["img_shape"] = (416, 416);
width, height = self.system_dict["img_shape"][0], self.system_dict["img_shape"][1]
train_transform = YOLO3DefaultTrainTransform(width, height, self.system_dict["local"]["net"])
batchify_fn = Tuple(*([Stack() for _ in range(6)] + [Pad(axis=0, pad_val=-1) for _ in range(1)]))
self.system_dict["local"]["train_loader"] = gluon.data.DataLoader(
self.system_dict["local"]["train_dataset"].transform(train_transform),
self.system_dict["batch_size"], True, batchify_fn=batchify_fn, last_batch='rollover',
num_workers=self.system_dict["num_workers"])
self.set_device(use_gpu=use_gpu, gpu_devices=gpu_devices);
self.system_dict["local"]["net"].collect_params().reset_ctx(self.system_dict["local"]["ctx"])
def get_dataloader(net, train_dataset, valid_dataset, data_shape, batch_size,
num_workers):
from gluoncv.data.batchify import Tuple, Stack, Pad
from gluoncv.data.transforms.presets.ssd import SSDDefaultTrainTransform
width, height = data_shape, data_shape
# use fake data to generate fixed anchors for target generation
with autograd.train_mode():
_, _, anchors = net(mx.nd.zeros((1, 3, height, width)))
batchify_fn = Tuple(Stack(), Stack(),
Stack()) # stack image, cls_targets, box_targets
train_loader = gluon.data.DataLoader(train_dataset.transform(
SSDDefaultTrainTransform(width, height, anchors)),
batch_size,
True,
batchify_fn=batchify_fn,
last_batch='rollover',
num_workers=num_workers)
val_batchify_fn = Tuple(Stack(), Pad(pad_val=-1))
val_loader = gluon.data.DataLoader(valid_dataset.transform(
SSDDefaultValTransform(width, height)),
batch_size,
False,
batchify_fn=val_batchify_fn,
last_batch='keep',
num_workers=num_workers)
eval_metric = VOC07MApMetric(iou_thresh=0.5, class_names=classes)
return train_loader, val_loader, eval_metric
def getDataloader(self, train_dataset, val_dataset):
width, height = self.args.data_shape, self.args.data_shape
# use fake data to generate fixed anchors for target generation
with autograd.train_mode():
foo, bar, anchors = self.net(
mx.nd.zeros((1, 3, height, width), self.ctx[0]))
anchors = anchors.as_in_context(mx.cpu())
batchify_fn = Tuple(Stack(), Stack(),
Stack()) # stack image, cls_targets, box_targets
train_loader = gluon.data.DataLoader(train_dataset.transform(
SSDDefaultTrainTransform(width, height, anchors)),
self.args.batch_size,
True,
batchify_fn=batchify_fn,
last_batch='rollover',
num_workers=self.args.num_workers)
val_batchify_fn = Tuple(Stack(), Pad(pad_val=-1))
val_loader = None
if val_dataset is not None:
val_loader = gluon.data.DataLoader(
val_dataset.transform(SSDDefaultValTransform(width, height)),
self.args.batch_size,
False,
batchify_fn=val_batchify_fn,
last_batch='keep',
num_workers=self.args.num_workers)
return train_loader, val_loader
def get_dataloader(net, train_dataset, val_dataset, data_shape, batch_size,
num_workers):
"""Get dataloader."""
width, height = data_shape, data_shape
# use fake data to generate fixed anchors for target generation
with autograd.train_mode():
_, _, anchors = net(mx.nd.zeros((1, 3, height, width)))
batchify_fn = Tuple(Stack(), Stack(),
Stack()) # stack image, cls_targets, box_targets
train_loader = gluon.data.DataLoader(train_dataset.transform(
SSDDefaultTrainTransform(width, height, anchors)),
batch_size,
True,
batchify_fn=batchify_fn,
last_batch='rollover',
num_workers=num_workers)
val_batchify_fn = Tuple(Stack(), Pad(pad_val=-1))
val_loader = gluon.data.DataLoader(val_dataset.transform(
SSDDefaultValTransform(width, height)),
batch_size,
False,
batchify_fn=val_batchify_fn,
last_batch='keep',
num_workers=num_workers)
return train_loader, val_loader
def get_dataloader(net, data_shape, batch_size, num_workers, ctx):
"""Get dataloader."""
width, height = data_shape, data_shape
# use fake data to generate fixed anchors for target generation
with autograd.train_mode():
_, _, anchors = net(mx.nd.zeros((1, 3, height, width), ctx))
anchors = anchors.as_in_context(mx.cpu())
batchify_fn = Tuple(Stack(), Stack(),
Stack()) # stack image, cls_targets, box_targets
# can I point that to a bundle of png files instead?
train_dataset = gdata.RecordFileDetection(
os.path.join(os.environ['SM_CHANNEL_TRAIN'], 'train.rec'))
# this is the folder with all the training images
train_folder = os.environ['SM_CHANNEL_TRAIN']
train_loader = gluon.data.DataLoader(train_dataset.transform(
SSDDefaultTrainTransform(width, height, anchors)),
batch_size,
True,
batchify_fn=batchify_fn,
last_batch='rollover',
num_workers=num_workers)
return train_loader
def get_coco_data_loaders(net, train_data, val_data, in_size, bs, n_workers,
ctx):
with autograd.train_mode():
fake_in_size = 1
channels = 3
_, _, anchors = net(
nd.zeros((fake_in_size, channels, in_size, in_size), ctx))
anchors = anchors.as_in_context(mx.cpu())
img_train_s = Stack()
class_targets = Stack()
box_targets = Stack()
train_batchify_fn = Tuple(img_train_s, class_targets, box_targets)
train_data_transformed = train_data.transform(
SSDDefaultTrainTransform(in_size, in_size, anchors))
train_data_loader = gluon.data.DataLoader(train_data_transformed,
batch_size=bs,
shuffle=True,
batchify_fn=train_batchify_fn,
last_batch='rollover',
num_workers=n_workers)
img_val_s = Stack()
padding = Pad(pad_val=-1)
val_batchify_fn = Tuple(img_val_s, padding)
val_data_transformed = val_data.transform(
SSDDefaultValTransform(in_size, in_size))
val_data_loader = gluon.data.DataLoader(val_data_transformed,
batch_size=bs,
shuffle=False,
batchify_fn=val_batchify_fn,
last_batch='keep',
num_workers=n_workers)
return train_data_loader, val_data_loader
def get_dataloader(model, train_dataset, validation_dataset, height, width,
batch_size, num_workers):
"""Data pre-processing. Returns mini batches of dataset with transformations
Args:
model (SSD model): Object detection model
train_dataset (Dataset): Training images and labels
validation_dataset (Dataset): Validation images and labels
height (int): Height of the training image
width (int): Width of training image
batch_size (int): Number of images in a mini batch
num_workers (int): Number of multiprocessing workers
Returns:
Dataloader : Mini batches of data
"""
with autograd.train_mode():
_, _, anchors = model(mx.nd.zeros((1, 3, height, width)))
batchify_fn = Tuple(Stack(), Stack(), Stack())
train_loader = gluon.data.DataLoader(train_dataset.transform(
SSDDefaultTrainTransform(height, width, anchors)),
batch_size,
True,
batchify_fn=batchify_fn,
last_batch='rollover',
num_workers=num_workers)
return train_loader
def get_dataloader(model, train_dataset, validation_dataset, height, width,
batch_size, num_workers):
"""
Get dataloader.
"""
import gluoncv as gcv
from gluoncv.data.batchify import Tuple, Stack, Pad
from gluoncv.data.transforms.presets.ssd import SSDDefaultTrainTransform
#In training mode, SSD returns three intermediate values
#cls_preds are the class predictions prior to softmax
#box_preds are bounding box offsets with one-to-one correspondence to anchors
with autograd.train_mode():
_, _, anchors = model(mx.nd.zeros((1, 3, height, width)))
batchify_fn = Tuple(Stack(), Stack(), Stack())
# SSDDefaultTrainTransform: data augmentation and prepprocessing
# random color jittering, random expansion with prob 0.5, random cropping
# resize with random interpolation, random horizontal flip,
# normalize (substract mean and divide by std)
train_loader = gluon.data.DataLoader(train_dataset.transform(
SSDDefaultTrainTransform(height, width, anchors)),
batch_size,
True,
batchify_fn=batchify_fn,
last_batch='rollover',
num_workers=num_workers)
return train_loader
def get_dataloader(net, data_shape, batch_size, num_workers, ctx):
"""Get dataloader."""
import os
os.system('pip3 install gluoncv --pre')
from gluoncv import data as gdata
from gluoncv.data.batchify import Tuple, Stack, Pad
from gluoncv.data.transforms.presets.ssd import SSDDefaultTrainTransform
width, height = data_shape, data_shape
# use fake data to generate fixed anchors for target generation
with autograd.train_mode():
_, _, anchors = net(mx.nd.zeros((1, 3, height, width), ctx))
anchors = anchors.as_in_context(mx.cpu())
batchify_fn = Tuple(Stack(), Stack(),
Stack()) # stack image, cls_targets, box_targets
train_dataset = gdata.RecordFileDetection(
os.path.join(os.environ['SM_CHANNEL_TRAIN'], 'train.rec'))
train_loader = gluon.data.DataLoader(train_dataset.transform(
SSDDefaultTrainTransform(width, height, anchors)),
batch_size,
True,
batchify_fn=batchify_fn,
last_batch='rollover',
num_workers=num_workers)
return train_loader
def get_dataloader(train_dataset, val_dataset, data_shape, batch_size, num_workers):
"""Get dataloader."""
width, height = data_shape, data_shape
train_loader = gdata.DetectionDataLoader(
train_dataset.transform(SSDDefaultTrainTransform(width, height)),
batch_size, True, last_batch='rollover', num_workers=num_workers)
val_loader = gdata.DetectionDataLoader(
val_dataset.transform(SSDDefaultValTransform(width, height)),
batch_size, False, last_batch='keep', num_workers=num_workers)
return train_loader, val_loader
def apply_transformation(img_width, img_height, image, label):
if not isinstance(image, nd.NDArray):
image = nd.array(image)
if image.shape[0] == 3:
image = tensor_to_image(image)
image = nd.array(image)
label = np.array(label)
transform = SSDDefaultTrainTransform(img_width, img_height)
image, label = transform(image, label)
return image, label
def get_traindataloader(net, train_dataset, data_shape, batch_size, num_workers, is_shuffle=True):
width, height = data_shape, data_shape
# use fake data to generate fixed anchors for target generation
with autograd.train_mode():
_, _, anchors = net(mx.nd.zeros((1, 3, height, width)))
#print(anchors) # mxnet ndarray, shape: 1 * 6132 * 4
batchify_fn = Tuple(Stack(), Stack(), Stack()) # stack image, cls_targets, box_targets
train_loader = gluon.data.DataLoader(
train_dataset.transform(SSDDefaultTrainTransform(width, height, anchors)),
batch_size, is_shuffle, batchify_fn=batchify_fn, last_batch='rollover', num_workers=num_workers)
return train_loader
def get_dataloader(net, train_dataset, data_shape, batch_size, num_workers):
from gluoncv.data.batchify import Tuple, Stack, Pad
from gluoncv.data.transforms.presets.ssd import SSDDefaultTrainTransform
width, height = data_shape, data_shape
# use fake data to generate fixed anchors for target generation
with autograd.train_mode():
_, _, anchors = net(mx.nd.zeros((1, 3, height, width)))
batchify_fn = Tuple(Stack(), Stack(), Stack()) # stack image, cls_targets, box_targets
train_loader = gluon.data.DataLoader(
train_dataset.transform(SSDDefaultTrainTransform(width, height, anchors)),
batch_size, True, batchify_fn=batchify_fn, last_batch='rollover', num_workers=num_workers)
return train_loader
def get_dataloader(net, train_dataset, val_dataset, data_shape, batch_size,
num_workers, ctx):
"""Loads data from a dataset and returns mini-batches of data, for both the training
and the validation set.
Arguments:
net: the Gluon model you will train, used to generate fake anchors for target generation.
train_dataset: Training dataset. Note that numpy and mxnet arrays can be directly used as a Dataset.
val_dataset: Validation dataset. Note that numpy and mxnet arrays can be directly used as a Dataset.
data_shape: Tuple, the input_shape of the model
batch_size: Size of mini-batch.
num_workers: The number of multiprocessing workers to use for data preprocessing.
ctx: Indicator to the usage of GPU.
Returns:
train_loader: Gluon training dataloader
val_loader: Gluon testing dataloader
Raises:
"""
width, height = data_shape
# use fake data to generate fixed anchors for target generation
with autograd.train_mode():
_, _, anchors = net(mx.nd.zeros((1, 3, height, width), ctx))
anchors = anchors.as_in_context(mx.cpu())
batchify_fn = Tuple(Stack(), Stack(),
Stack()) # stack image, cls_targets, box_targets
train_loader = gluon.data.DataLoader(
train_dataset.transform(
SSDDefaultTrainTransform(width, height, anchors)),
batch_size,
True,
batchify_fn=batchify_fn,
last_batch="rollover",
num_workers=num_workers,
)
val_batchify_fn = Tuple(Stack(), Pad(pad_val=-1))
val_loader = gluon.data.DataLoader(
val_dataset.transform(SSDDefaultValTransform(width, height)),
batch_size,
False,
batchify_fn=val_batchify_fn,
last_batch="keep",
num_workers=num_workers,
)
return train_loader, val_loader
def get_dataloader(net, train_dataset, val_dataset, data_shape, batch_size, num_workers):
"""Get dataloader."""
width, height = data_shape, data_shape
# use fake data to generate fixed anchors for target generation
with autograd.train_mode():
_, _, anchors = net(mx.nd.zeros((1, 3, height, width)))
train_loader = gdata.DetectionDataLoader(
train_dataset.transform(SSDDefaultTrainTransform(width, height, anchors)),
batch_size, True, last_batch='rollover', num_workers=num_workers)
val_loader = gdata.DetectionDataLoader(
val_dataset.transform(SSDDefaultValTransform(width, height)),
batch_size, False, last_batch='keep', num_workers=num_workers)
return train_loader, val_loader
def get_dataloader(net, train_dataset, val_dataset, data_shape, batch_size,
num_workers, ctx):
"""Get dataloader."""
width, height = data_shape, data_shape
# use fake data to generate fixed anchors for target generation
with autograd.train_mode():
_, _, anchors = net(mx.nd.zeros((1, 3, height, width), ctx))
# anchors: (1, N, 4): N 为 图片中anchors的数量
anchors = anchors.as_in_context(mx.cpu())
batchify_fn = Tuple(Stack(), Stack(),
Stack()) # stack image, cls_targets, box_targets
train_loader = gluon.data.DataLoader(train_dataset.transform(
SSDDefaultTrainTransform(width, height, anchors)),
batch_size,
shuffle=True,
batchify_fn=batchify_fn,
last_batch='rollover',
num_workers=num_workers)
"""
train_loader
每个batch按y给生成的N个fixed anchors标记这些anchors的类别和位置,
方便训练时用于计算loss， N对每个图片都是一样
训练模式时： cls_preds, box_preds, anchors = net(data)
train_loader中batch的x, y: y本就包含着该图片之前所有生成的锚框target的box位置信息即box_targets（batch_size, N, 4）, N是锚框的个数
以及每个锚框对应的类别即cls_targets(batch_size, N)
而val_loader是用与验证当前训练的网络，不是处于训练模式，得到的是图片预测objects的ids, scores, bboxes = net(data)
每个batch的y:(batch_size, n, 6（或者5）): 其中每个图片中n可能不一样， 取决于图片object的数量
这里的6： 0-4，是box的位置， 4-5是box对应的类别， 5-6是difficults(还没搞懂这个是什么，作用是啥， 若没有则上面为5, 有则为6)
"""
val_batchify_fn = Tuple(Stack(), Pad(pad_val=-1))
# stack image, and pad labels： labels的0-4：box, 4-5: cls
val_loader = gluon.data.DataLoader(val_dataset.transform(
SSDDefaultValTransform(width, height)),
batch_size,
shuffle=False,
batchify_fn=val_batchify_fn,
last_batch='keep',
num_workers=num_workers)
return train_loader, val_loader
def get_dataloader(self):
width, height = self.width, self.height
train_dataset = self.train_dataset
val_dataset = self.val_dataset
batch_size = self.batch_size
num_workers = self.num_workers
network = self.network
print('aqui 0')
if network == 'ssd':
# use fake data to generate fixed anchors for target generation
with autograd.train_mode():
_, _, anchors = self.net(mx.nd.zeros((1, 3, height, width)))
batchify_fn = Tuple(
Stack(), Stack(),
Stack()) # stack image, cls_targets, box_targets
train_loader = gluon.data.DataLoader(train_dataset.transform(
SSDDefaultTrainTransform(width, height, anchors)),
batch_size,
True,
batchify_fn=batchify_fn,
last_batch='rollover',
num_workers=num_workers)
# Val verdadeiro
val_batchify_fn = Tuple(Stack(), Pad(pad_val=-1))
val_loader = gluon.data.DataLoader(val_dataset.transform(
SSDDefaultValTransform(width, height)),
batch_size,
False,
batchify_fn=val_batchify_fn,
last_batch='keep',
num_workers=num_workers)
# use fake data to generate fixed anchors for target generation
with mx.Context(mx.gpu(0)):
anchors2 = anchors
val_loader_loss = gluon.data.DataLoader(val_dataset.transform(
SSDCustomValTransform(width, height, anchors2)),
batch_size,
True,
batchify_fn=batchify_fn,
last_batch='rollover',
num_workers=num_workers)
self.val_loader_loss = val_loader_loss
elif network == 'yolo':
print('aqui 1')
batchify_fn = Tuple(
*([Stack() for _ in range(6)] +
[Pad(axis=0, pad_val=-1)
for _ in range(1)])) # stack image, all targets generated
# if args.no_random_shape:
train_loader = gluon.data.DataLoader(train_dataset.transform(
YOLO3DefaultTrainTransform(width, height, self.net)),
batch_size,
True,
batchify_fn=batchify_fn,
last_batch='rollover',
num_workers=num_workers)
val_batchify_fn = Tuple(Stack(), Pad(pad_val=-1))
val_loader = gluon.data.DataLoader(val_dataset.transform(
YOLO3DefaultValTransform(width, height)),
batch_size,
False,
batchify_fn=val_batchify_fn,
last_batch='keep',
num_workers=num_workers)
print('aqui 2')
else:
raise ValueError("Network {} not implemented".format(network))
self.val_loader = val_loader
self.train_loader = train_loader
def Training(Learning_Rate, NombreEpoch):
learning_rate = float(Learning_Rate)
#train_images = glob.glob(data_dir+"*.jpg")
#print("We have {} images".format(len(train_images)))
#for pic in train_images:
# if pic.lower().endswith('.jpg'):
# resize_meta[pic] = resize(pic)
classes = [
"sacs", "pots", "meubles", "cartons", "matelas", "palette", "caddy",
"bidon", "chaise", "electromenager"
]
train_dataset = GTDataset(split='train')
validation_dataset = GTDataset(split='val')
test_dataset = GTDataset(split='test')
batch_size = 18
image_size = 512
num_workers = 8
num_epochs = NombreEpoch
ctx = [mx.gpu(0)] if mx.context.num_gpus() > 0 else [mx.cpu()]
net = gcv.model_zoo.get_model('ssd_512_resnet50_v1_coco', pretrained=True)
net.reset_class(classes)
with autograd.train_mode():
_, _, anchors = net(mx.nd.zeros((1, 3, image_size, image_size)))
train_transform = SSDDefaultTrainTransform(image_size, image_size, anchors)
batchify_fn = Tuple(Stack(), Stack(),
Stack()) # stack image, cls_targets, box_targets
train_data = gluon.data.DataLoader(
train_dataset.transform(train_transform),
batch_size,
True,
batchify_fn=batchify_fn,
last_batch='rollover',
num_workers=num_workers)
val_transform = SSDDefaultValTransform(image_size, image_size)
batchify_fn = Tuple(Stack(), Pad(pad_val=-1))
val_data = gluon.data.DataLoader(
validation_dataset.transform(val_transform),
batch_size,
False,
batchify_fn=batchify_fn,
last_batch='keep',
num_workers=num_workers)
if (num_epochs > 21):
steps_epochs = [
num_epochs - 20, num_epochs - 15, num_epochs - 10, num_epochs - 5
]
else:
steps_epochs = [1]
iterations_per_epoch = math.ceil(len(train_dataset) / batch_size)
steps_iterations = [s * iterations_per_epoch for s in steps_epochs]
#print("Learning rate drops after iterations: {}".format(steps_iterations))
schedule = mx.lr_scheduler.MultiFactorScheduler(step=steps_iterations,
factor=0.15)
schedule.base_lr = learning_rate
net.collect_params().reset_ctx(ctx)
trainer = gluon.Trainer(
net.collect_params(), 'sgd', {
'learning_rate': schedule.base_lr,
'wd': 0.0004,
'momentum': 0.9,
'lr_scheduler': schedule
})
mbox_loss = gcv.loss.SSDMultiBoxLoss()
ce_metric = mx.metric.Loss('CrossEntropy')
smoothl1_metric = mx.metric.Loss('SmoothL1')
#On cree le tableau pour stocker les mAP et les afficher dans un graphique
TabHistorymAP = []
TabEpoch = []
#On cree les tableaux pour les differentes classes, c'est pas opti, je sais
TabSac = []
TabPots = []
TabMeubles = []
TabCartons = []
TabMatelas = []
TabPalette = []
TabCaddy = []
TabBidon = []
TabChaise = []
TabElectromenager = []
best_val = 0
for epoch in range(num_epochs):
net.hybridize(static_alloc=True, static_shape=True)
#net.cast('float16')
ce_metric.reset()
smoothl1_metric.reset()
tic, btic = time.time(), time.time()
for i, batch in enumerate(train_data):
data = gluon.utils.split_and_load(batch[0],
ctx_list=ctx,
batch_axis=0)
cls_targets = gluon.utils.split_and_load(batch[1],
ctx_list=ctx,
batch_axis=0)
box_targets = gluon.utils.split_and_load(batch[2],
ctx_list=ctx,
batch_axis=0)
with autograd.record():
cls_preds, box_preds = [], []
for x in data:
cls_pred, box_pred, _ = net(x)
cls_preds.append(cls_pred)
box_preds.append(box_pred)
sum_loss, cls_loss, box_loss = mbox_loss(
cls_preds, box_preds, cls_targets, box_targets)
autograd.backward(sum_loss)
trainer.step(1)
ce_metric.update(0, [l * batch_size for l in cls_loss])
smoothl1_metric.update(0, [l * batch_size for l in box_loss])
name1, loss1 = ce_metric.get()
name2, loss2 = smoothl1_metric.get()
btic = time.time()
name, val = validate(net, val_data, ctx, classes, image_size)
#A priori on a la moyenne des mAP des classes directement à la fin du tableau
meanAP = val[10]
#On stock l'hisotrique des résultats par Epoch
TabHistorymAP.append(meanAP)
TabEpoch.append(epoch)
TabSac.append(val[0])
TabPots.append(val[1])
TabMeubles.append(val[2])
TabCartons.append(val[3])
TabMatelas.append(val[4])
TabPalette.append(val[5])
TabCaddy.append(val[6])
TabBidon.append(val[7])
TabChaise.append(val[8])
TabElectromenager.append(val[9])
print('[Epoch {}] Training cost: {:.3f}, Learning rate {}, mAP={:.3f}'.
format(epoch, (time.time() - tic), trainer.learning_rate,
meanAP))
# If validation accuracy improve, save the parameters
if meanAP > best_val:
net.save_parameters('ssd_resnet.trash.params')
best_val = meanAP
best_tab = val
best_epoch = epoch
print("Saving the parameters, best mAP {}".format(best_val))
print("Best mAP {}".format(best_val))
print("Best Epoch : " + str(best_epoch))
net.save_parameters('ssd_resnet.trash-FixedLR-mAP_' + str(best_val) +
'-Epoch_' + str(best_epoch) + '-LR_' +
str(learning_rate) + '.params')
print("Sac : " + str(best_tab[0]))
print("Pot : " + str(best_tab[1]))
print("Meuble : " + str(best_tab[2]))
print("Carton : " + str(best_tab[3]))
print("Matelas : " + str(best_tab[4]))
print("Palette : " + str(best_tab[5]))
print("Caddy : " + str(best_tab[6]))
print("Bidon : " + str(best_tab[7]))
print("Chaise : " + str(best_tab[8]))
print("Electromenager : " + str(best_tab[9]))
validation_dataset = GTDataset(data_path=args.data_location,
gt_prefix=args.gt_prefix,
split='val')
print('There are {} training images, {} validation images'.format(
len(train_dataset), len(validation_dataset)))
# instantiate the network
net = gcv.model_zoo.get_model(args.network,
pretrained=ast.literal_eval(args.pretrained))
net.reset_class(classes)
# train data iterator
with autograd.train_mode():
_, _, anchors = net(mx.nd.zeros((1, 3, image_size, image_size)))
train_transform = SSDDefaultTrainTransform(image_size, image_size, anchors)
batchify_fn = Tuple(Stack(), Stack(),
Stack()) # stack image, cls_targets, box_targets
train_data = gluon.data.DataLoader(
train_dataset.transform(train_transform),
batch_size,
True,
batchify_fn=batchify_fn,
last_batch='rollover',
num_workers=args.num_workers)
# validation data iterator
val_transform = SSDDefaultValTransform(image_size, image_size)
batchify_fn = Tuple(Stack(), Pad(pad_val=-1))
val_data = gluon.data.DataLoader(
validation_dataset.transform(val_transform),
def Model(self,
model_name,
use_pretrained=True,
use_gpu=True,
gpu_devices=[0]):
'''
User function: Set Model parameters
Available models
ssd_300_vgg16_atrous_coco
ssd_300_vgg16_atrous_voc
ssd_512_vgg16_atrous_coco
ssd_512_vgg16_atrous_voc
ssd_512_resnet50_v1_coco
ssd_512_resnet50_v1_voc
ssd_512_mobilenet1.0_voc
ssd_512_mobilenet1.0_coco
yolo3_darknet53_voc
yolo3_darknet53_coco
yolo3_mobilenet1.0_voc
yolo3_mobilenet1.0_coco
Args:
model_name (str): Select from available models
use_pretrained (bool): If True use pretrained weights else randomly initialized weights
use_gpu (bool): If True use GPU else run on CPU
gpu_devices (list): List of GPU device Ids
Returns:
None
'''
self.system_dict["model_name"] = model_name
self.system_dict["use_pretrained"] = use_pretrained
if (self.system_dict["model_name"] in self.system_dict["model_set_1"]):
self.system_dict["local"]["net"] = gcv.model_zoo.get_model(
self.system_dict["model_name"],
pretrained=self.system_dict["use_pretrained"])
self.system_dict["local"]["net"].reset_class(
self.system_dict["classes"])
self.system_dict["img_shape"] = (300, 300)
width, height = self.system_dict["img_shape"][0], self.system_dict[
"img_shape"][1]
with autograd.train_mode():
_, _, anchors = self.system_dict["local"]["net"](mx.nd.zeros(
(1, 3, height, width)))
batchify_fn = Tuple(Stack(), Stack(), Stack())
self.system_dict["local"]["train_loader"] = gluon.data.DataLoader(
self.system_dict["local"]["train_dataset"].transform(
SSDDefaultTrainTransform(width, height, anchors)),
self.system_dict["batch_size"],
True,
batchify_fn=batchify_fn,
last_batch='rollover',
num_workers=self.system_dict["num_workers"])
self.set_device(use_gpu=use_gpu, gpu_devices=gpu_devices)
self.system_dict["local"]["net"].collect_params().reset_ctx(
self.system_dict["local"]["ctx"])
elif (
(self.system_dict["model_name"] in self.system_dict["model_set_2"])
or
(self.system_dict["model_name"] in self.system_dict["model_set_3"])
or (self.system_dict["model_name"]
in self.system_dict["model_set_4"])):
self.system_dict["local"]["net"] = gcv.model_zoo.get_model(
self.system_dict["model_name"],
pretrained=self.system_dict["use_pretrained"])
self.system_dict["local"]["net"].reset_class(
self.system_dict["classes"])
self.system_dict["img_shape"] = (512, 512)
width, height = self.system_dict["img_shape"][0], self.system_dict[
"img_shape"][1]
with autograd.train_mode():
_, _, anchors = self.system_dict["local"]["net"](mx.nd.zeros(
(1, 3, height, width)))
batchify_fn = Tuple(Stack(), Stack(), Stack())
self.system_dict["local"]["train_loader"] = gluon.data.DataLoader(
self.system_dict["local"]["train_dataset"].transform(
SSDDefaultTrainTransform(width, height, anchors)),
self.system_dict["batch_size"],
True,
batchify_fn=batchify_fn,
last_batch='rollover',
num_workers=self.system_dict["num_workers"])
self.set_device(use_gpu=use_gpu, gpu_devices=gpu_devices)
self.system_dict["local"]["net"].collect_params().reset_ctx(
self.system_dict["local"]["ctx"])
elif (
(self.system_dict["model_name"] in self.system_dict["model_set_5"])
or (self.system_dict["model_name"]
in self.system_dict["model_set_6"])):
self.system_dict["local"]["net"] = gcv.model_zoo.get_model(
self.system_dict["model_name"],
pretrained=self.system_dict["use_pretrained"])
self.system_dict["local"]["net"].reset_class(
self.system_dict["classes"])
self.system_dict["img_shape"] = (416, 416)
width, height = self.system_dict["img_shape"][0], self.system_dict[
"img_shape"][1]
train_transform = YOLO3DefaultTrainTransform(
width, height, self.system_dict["local"]["net"])
batchify_fn = Tuple(*([Stack() for _ in range(6)] +
[Pad(axis=0, pad_val=-1) for _ in range(1)]))
self.system_dict["local"]["train_loader"] = gluon.data.DataLoader(
self.system_dict["local"]["train_dataset"].transform(
train_transform),
self.system_dict["batch_size"],
True,
batchify_fn=batchify_fn,
last_batch='rollover',
num_workers=self.system_dict["num_workers"])
self.set_device(use_gpu=use_gpu, gpu_devices=gpu_devices)
self.system_dict["local"]["net"].collect_params().reset_ctx(
self.system_dict["local"]["ctx"])
def Training(Args):
logging.basicConfig()
args = Args
# instantiate datasets
classes = [
"sacs", "pots", "meubles", "cartons", "matelas", "palette", "caddy",
"bidon", "chaise", "electromenager"
]
train_dataset = GTDataset(split='train')
validation_dataset = GTDataset(split='val')
test_dataset = GTDataset(split='test')
logging.info(
"There is {} training images, {} validation images, {} testing images".
format(len(train_dataset), len(validation_dataset), len(test_dataset)))
# instantiate model
batch_size = args.batch
image_size = 512
num_workers = args.workers
num_epochs = args.epochs
ctx = [mx.gpu(0)] if mx.context.num_gpus() > 0 else [mx.cpu()]
logging.info('using context ' + str(ctx))
net = gcv.model_zoo.get_model(args.basemodel, pretrained=True)
net.reset_class(classes)
# instantiate training iterator
with autograd.train_mode():
_, _, anchors = net(mx.nd.zeros((1, 3, image_size, image_size)))
train_transform = SSDDefaultTrainTransform(image_size, image_size, anchors)
batchify_fn = Tuple(Stack(), Stack(),
Stack()) # stack image, cls_targets, box_targets
train_data = gluon.data.DataLoader(
train_dataset.transform(train_transform),
batch_size,
shuffle=True,
batchify_fn=batchify_fn,
last_batch='rollover',
num_workers=num_workers)
# instantiate val iterator
val_transform = SSDDefaultValTransform(image_size, image_size)
batchify_fn = Tuple(Stack(), Pad(pad_val=-1))
val_data = gluon.data.DataLoader(
validation_dataset.transform(val_transform),
batch_size,
shuffle=False,
batchify_fn=batchify_fn,
last_batch='keep',
num_workers=num_workers)
# learning rate scheduler
scheduler = lr_scheduler.CosineScheduler(
max_update=int(args.max_update * args.epochs),
base_lr=args.base_lr,
final_lr=args.final_lr,
warmup_steps=int(args.warmup_steps * args.epochs),
warmup_begin_lr=args.warmup_begin_lr,
warmup_mode='linear')
# gluon trainer
net.collect_params().reset_ctx(ctx)
trainer = gluon.Trainer(net.collect_params(), args.opt, {
'learning_rate': args.base_lr,
'wd': 0.0004,
'momentum': args.momentum
})
# SSD losses
mbox_loss = gcv.loss.SSDMultiBoxLoss()
# training loop
best_val = 0
for epoch in range(num_epochs):
trainer.set_learning_rate(scheduler(epoch))
net.hybridize(static_alloc=True, static_shape=True)
tic = time.time()
for batch in train_data:
data = gluon.utils.split_and_load(batch[0],
ctx_list=ctx,
batch_axis=0)
cls_targets = gluon.utils.split_and_load(batch[1],
ctx_list=ctx,
batch_axis=0)
box_targets = gluon.utils.split_and_load(batch[2],
ctx_list=ctx,
batch_axis=0)
with autograd.record():
cls_preds, box_preds = [], []
for x in data:
cls_pred, box_pred, _ = net(x)
cls_preds.append(cls_pred)
box_preds.append(box_pred)
sum_loss, cls_loss, box_loss = mbox_loss(
cls_preds, box_preds, cls_targets, box_targets)
autograd.backward(sum_loss)
trainer.step(args.batch)
name, val = validate(net, val_data, ctx, classes, image_size)
#le mAP est le dernier élément du tableau
meanAP = val[10]
print('[Epoch {}] Training cost: {:.3f}, Learning rate {}, mAP={:.3f}'.
format(epoch, (time.time() - tic), trainer.learning_rate,
meanAP))
# If validation accuracy improve, save the parameters
if meanAP > best_val:
net.save_parameters(args.model_dir + '/ssd_resnet.trash.params')
best_val = meanAP
best_epoch = epoch
best_tab = val
print('Saving the parameters, best mAP {}'.format(best_val))
net.save_parameters(args.model_dir + '/ssd_resnet.trashai' + '-mAP_' +
str(best_val) + '_Lr' + str(args.base_lr) +
'-BestEpoch_' + str(best_epoch) + '.params')
print("Best mAP : {}".format(best_val))
print("Best Epoch : " + str(best_epoch))
print("Sac : " + str(best_tab[0]))
print("Pot : " + str(best_tab[1]))
print("Meuble : " + str(best_tab[2]))
print("Carton : " + str(best_tab[3]))
print("Matelas : " + str(best_tab[4]))
print("Palette : " + str(best_tab[5]))
print("Caddy : " + str(best_tab[6]))
print("Bidon : " + str(best_tab[7]))
print("Chaise : " + str(best_tab[8]))
print("Electromeganer : " + str(best_tab[9]))
