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