def main(args): savedir = '/home/shyam.nandan/NewExp/final_code/save/' + args.savedir #change path here if not os.path.exists(savedir): os.makedirs(savedir) with open(savedir + '/opts.txt', "w") as myfile: myfile.write(str(args)) rmodel = UNet() rmodel = torch.nn.DataParallel(rmodel).cuda() pretrainedEnc = torch.nn.DataParallel(ERFNet_imagenet(1000)) pretrainedEnc.load_state_dict( torch.load(args.pretrainedEncoder)['state_dict']) pretrainedEnc = next(pretrainedEnc.children()).features.encoder model = Net(NUM_CLASSES) model = fill_weights(model, pretrainedEnc) model = torch.nn.DataParallel(model).cuda() #model = train(args, rmodel, model, False) PATH = '/home/shyam.nandan/NewExp/final_code/results/CB_iFL/rmodel_best.pth' rmodel.load_state_dict(torch.load(PATH)) PATH = '/home/shyam.nandan/NewExp/final_code/results/CB_iFL/model_best.pth' model.load_state_dict(torch.load(PATH)) model = train(args, rmodel, model, False)
def main(args): savedir = args.savedir if not os.path.exists(savedir): os.makedirs(savedir) with open(savedir + '/opts.txt', "w") as myfile: myfile.write(str(args)) #Load Model assert os.path.exists(args.model + ".py"), "Error: model definition not found" model_file = importlib.import_module(args.model) model = model_file.Net(NUM_CLASSES) copyfile(args.model + ".py", savedir + '/' + args.model + ".py") if args.cuda: model = torch.nn.DataParallel(model).cuda() if args.state: #if args.state is provided then load this state for training #Note: this only loads initialized weights. If you want to resume a training use "--resume" option!! def load_my_state_dict(model, state_dict): #custom function to load model when not all dict keys are there own_state = model.state_dict() for name, param in state_dict.items(): if name not in own_state: continue own_state[name].copy_(param) return model #print(torch.load(args.state)) model = load_my_state_dict(model, torch.load(args.state)) #train(args, model) if (not args.decoder): print("========== ENCODER TRAINING ===========") model = train(args, model, True) #Train encoder if (args.trainInOneGo): args.resume = False #CAREFUL: for some reason, after training encoder alone, the decoder gets weights=0. #We must reinit decoder weights or reload network passing only encoder in order to train decoder print("========== DECODER TRAINING ===========") if (not args.state): if args.pretrainedEncoder: print("Loading encoder pretrained in imagenet") from erfnet_imagenet import ERFNet as ERFNet_imagenet pretrainedEnc = torch.nn.DataParallel(ERFNet_imagenet(1000)) pretrainedEnc.load_state_dict(torch.load(args.pretrainedEncoder)['state_dict']) pretrainedEnc = next(pretrainedEnc.children()).features.encoder if (not args.cuda): pretrainedEnc = pretrainedEnc.cpu() #because loaded encoder is probably saved in cuda else: pretrainedEnc = next(model.children()).encoder model = model_file.Net(NUM_CLASSES, encoder=pretrainedEnc) #Add decoder to encoder if args.cuda: model = torch.nn.DataParallel(model).cuda() #When loading encoder reinitialize weights for decoder because they are set to 0 when training dec model = train(args, model, False) #Train decoder print("========== TRAINING FINISHED ===========")
def __init__(self, classes, embed_dim, resnet, pretrained_model=None, pretrained=True, use_torch_up=False): super().__init__() assert(isinstance(classes , dict)), f"num_labels should be dict, got {type(classes)}" self.datasets = list(classes.keys()) self.embed_dim = embed_dim pretrainedEnc = torch.nn.DataParallel(ERFNet_imagenet(1000)) pretrainedEnc.load_state_dict(torch.load("erfnet_encoder_pretrained.pth.tar")['state_dict']) pretrainedEnc = next(pretrainedEnc.children()).features.encoder model = ECANet(num_classes=1000, encoder=pretrainedEnc) #Add decoder to encoder pmodel = nn.DataParallel(model) #pmodel = pmodel.cuda() self.base = nn.Sequential(*list(model.children())[:-2]) ## Encoder. #self.base = model[:-2] self.seg = nn.ModuleList() ## Decoder 1d conv self.up = nn.ModuleList() ## Decoder upsample (non-trainable) for n_labels in classes.values(): m = nn.Conv2d(model.out_dim, n_labels, kernel_size=1, bias=True) n = m.kernel_size[0] * m.kernel_size[1] * m.out_channels m.weight.data.normal_(0, math.sqrt(2. / n)) m.bias.data.zero_() self.seg.append(m) if use_torch_up: self.up.append(nn.UpsamplingBilinear2d(scale_factor=8)) else: up = nn.ConvTranspose2d(n_labels, n_labels, 16, stride=8, padding=4, output_padding=0, groups=n_labels, bias=False) fill_up_weights(up) up.weight.requires_grad = False self.up.append(up) ## Encoder output module m = nn.Conv2d(model.out_dim , self.embed_dim , kernel_size=1, bias=True) n = m.kernel_size[0] * m.kernel_size[1] * m.out_channels m.weight.data.normal_(0, math.sqrt(2. / n)) m.bias.data.zero_() self.en_map = m self.en_up = nn.ConvTranspose2d(self.embed_dim , self.embed_dim , 16, stride=8, padding=4 ,output_padding=0,groups=self.embed_dim, bias=False) fill_up_weights(self.en_up) self.en_up.weight.requires_grad = False
def main(): savedir = ARGS_SAVE_DIR if not os.path.exists(savedir): os.makedirs(savedir) #os.makedirs(savedir + '/plotdata') model_file = importlib.import_module(ARGS_MODEL) model = model_file.Net(NUM_CLASSES) copyfile(ARGS_MODEL + ".py", savedir + '/' + ARGS_MODEL + ".py") if ARGS_CUDA: model = torch.nn.DataParallel(model).cuda() if ARGS_STATE: def load_my_state_dict(model, state_dict): own_state = model.state_dict() for name, param in state_dict.items(): if name not in own_state: continue own_state[name].copy_(param) return model model = load_my_state_dict(model, torch.load(ARGS_STATE)) if (not ARGS_DECODER): print("#################### ENCODER TRAINING ####################") model = train(model, True) print("#################### DECODER TRAINING ####################") if (not ARGS_STATE): if ARGS_PRETRAINED_ENCODER: print("Loading encoder pretrained in imagenet") from erfnet_imagenet import ERFNet as ERFNet_imagenet pretrainedEnc = torch.nn.DataParallel(ERFNet_imagenet(1000)) pretrainedEnc.load_state_dict( torch.load(ARGS_PRETRAINED_ENCODER)['state_dict']) pretrainedEnc = next(pretrainedEnc.children()).features.encoder if (not ARGS_CUDA): pretrainedEnc = pretrainedEnc.cpu() else: pretrainedEnc = next(model.children()).encoder model = model_file.Net(NUM_CLASSES, encoder=pretrainedEnc) if ARGS_CUDA: model = torch.nn.DataParallel(model).cuda() model = train(model, False) print("#################### TRAINING FINISHED ####################")
def main(): class Args(): cuda = True # NOTE: cpu-only has not been tested so you might have to change code if you deactivate this flag model = "erfnet" state = False port = 8097 datadir = "/esat/toyota/trace/deeplearning/datasets_public/cityscapes/leftImg8bit_trainvaltest" height = 512 num_epochs = 5 num_workers = 4 batch_size = 2 steps_loss = 50 steps_plot = 50 epochs_save = 0 # You can use this value to save model every X epochs savedir = "~/Document/thesis_kontras/" decoder = False pretrainedEncoder = False # , default="../trained_models/erfnet_encoder_pretrained.pth.tar") visualize = False iouTrain = False # recommended: False (takes more time to train otherwise) iouVal = True resume = False args = Args() savedir = f'../save/{args.savedir}' if not os.path.exists(savedir): os.makedirs(savedir) with open(savedir + '/opts.txt', "w") as myfile: myfile.write(str(args)) #Load Model assert os.path.exists(args.model + ".py"), "Error: model definition not found" model_file = importlib.import_module(args.model) model = model_file.Net(NUM_CLASSES) copyfile(args.model + ".py", savedir + '/' + args.model + ".py") if args.cuda: model = torch.nn.DataParallel(model).cuda() if args.state: #if args.state is provided then load this state for training #Note: this only loads initialized weights. If you want to resume a training use "--resume" option!! """ try: model.load_state_dict(torch.load(args.state)) except AssertionError: model.load_state_dict(torch.load(args.state, map_location=lambda storage, loc: storage)) #When model is saved as DataParallel it adds a model. to each key. To remove: #state_dict = {k.partition('model.')[2]: v for k,v in state_dict} #https://discuss.pytorch.org/t/prefix-parameter-names-in-saved-model-if-trained-by-multi-gpu/494 """ def load_my_state_dict(model, state_dict): #custom function to load model when not all dict keys are there own_state = model.state_dict() for name, param in state_dict.items(): if name not in own_state: continue own_state[name].copy_(param) return model #print(torch.load(args.state)) model = load_my_state_dict(model, torch.load(args.state)) """ def weights_init(m): classname = m.__class__.__name__ if classname.find('Conv') != -1: #m.weight.data.normal_(0.0, 0.02) n = m.kernel_size[0] * m.kernel_size[1] * m.out_channels m.weight.data.normal_(0, math.sqrt(2. / n)) elif classname.find('BatchNorm') != -1: #m.weight.data.normal_(1.0, 0.02) m.weight.data.fill_(1) m.bias.data.fill_(0) #TO ACCESS MODEL IN DataParallel: next(model.children()) #next(model.children()).decoder.apply(weights_init) #Reinitialize weights for decoder next(model.children()).decoder.layers.apply(weights_init) next(model.children()).decoder.output_conv.apply(weights_init) #print(model.state_dict()) f = open('weights5.txt', 'w') f.write(str(model.state_dict())) f.close() """ #train(args, model) if (not args.decoder): print("========== ENCODER TRAINING ===========") model = train(args, model, True) #Train encoder #CAREFUL: for some reason, after training encoder alone, the decoder gets weights=0. #We must reinit decoder weights or reload network passing only encoder in order to train decoder print("========== DECODER TRAINING ===========") if (not args.state): if args.pretrainedEncoder: print("Loading encoder pretrained in imagenet") from erfnet_imagenet import ERFNet as ERFNet_imagenet pretrainedEnc = torch.nn.DataParallel(ERFNet_imagenet(1000)) pretrainedEnc.load_state_dict(torch.load(args.pretrainedEncoder)['state_dict']) pretrainedEnc = next(pretrainedEnc.children()).features.encoder if (not args.cuda): pretrainedEnc = pretrainedEnc.cpu() #because loaded encoder is probably saved in cuda else: pretrainedEnc = next(model.children()).encoder model = model_file.Net(NUM_CLASSES, encoder=pretrainedEnc) #Add decoder to encoder if args.cuda: model = torch.nn.DataParallel(model).cuda() #When loading encoder reinitialize weights for decoder because they are set to 0 when training dec model = train(args, model, False) #Train decoder print("========== TRAINING FINISHED ===========")
def main(args): savedir = f'../save/{args.savedir}' if not os.path.exists(savedir): os.makedirs(savedir) with open(savedir + '/opts.txt', "w") as myfile: myfile.write(str(args)) #Load Model assert os.path.exists(args.model + ".py"), "Error: model definition not found" model_file = importlib.import_module(args.model) model = model_file.Net(NUM_CLASSES) copyfile(args.model + ".py", savedir + '/' + args.model + ".py") if args.cuda: model = torch.nn.DataParallel(model).cuda() if args.state: #if args.state is provided then load this state for training #Note: this only loads initialized weights. If you want to resume a training use "--resume" option!! """ try: model.load_state_dict(torch.load(args.state)) except AssertionError: model.load_state_dict(torch.load(args.state, map_location=lambda storage, loc: storage)) #When model is saved as DataParallel it adds a model. to each key. To remove: #state_dict = {k.partition('model.')[2]: v for k,v in state_dict} #https://discuss.pytorch.org/t/prefix-parameter-names-in-saved-model-if-trained-by-multi-gpu/494 """ def load_my_state_dict( model, state_dict ): #custom function to load model when not all dict keys are there own_state = model.state_dict() for name, param in state_dict.items(): if name not in own_state: continue own_state[name].copy_(param) return model #print(torch.load(args.state)) model = load_my_state_dict(model, torch.load(args.state)) """ def weights_init(m): classname = m.__class__.__name__ if classname.find('Conv') != -1: #m.weight.data.normal_(0.0, 0.02) n = m.kernel_size[0] * m.kernel_size[1] * m.out_channels m.weight.data.normal_(0, math.sqrt(2. / n)) elif classname.find('BatchNorm') != -1: #m.weight.data.normal_(1.0, 0.02) m.weight.data.fill_(1) m.bias.data.fill_(0) #TO ACCESS MODEL IN DataParallel: next(model.children()) #next(model.children()).decoder.apply(weights_init) #Reinitialize weights for decoder next(model.children()).decoder.layers.apply(weights_init) next(model.children()).decoder.output_conv.apply(weights_init) #print(model.state_dict()) f = open('weights5.txt', 'w') f.write(str(model.state_dict())) f.close() """ #train(args, model) if (not args.decoder): print("========== ENCODER TRAINING ===========") model = train(args, model, True) #Train encoder #CAREFUL: for some reason, after training encoder alone, the decoder gets weights=0. #We must reinit decoder weights or reload network passing only encoder in order to train decoder print("========== DECODER TRAINING ===========") if (not args.state): if args.pretrainedEncoder: print("Loading encoder pretrained in imagenet") from erfnet_imagenet import ERFNet as ERFNet_imagenet pretrainedEnc = torch.nn.DataParallel(ERFNet_imagenet(1000)) pretrainedEnc.load_state_dict( torch.load(args.pretrainedEncoder)['state_dict'], False) pretrainedEnc = next(pretrainedEnc.children()).features.encoder if (not args.cuda): pretrainedEnc = pretrainedEnc.cpu( ) #because loaded encoder is probably saved in cuda else: pretrainedEnc = next(model.children()).encoder model = model_file.Net(NUM_CLASSES, encoder=pretrainedEnc) #Add decoder to encoder if args.cuda: model = torch.nn.DataParallel(model).cuda() #When loading encoder reinitialize weights for decoder because they are set to 0 when training dec model = train(args, model, False) #Train decoder print("========== TRAINING FINISHED ===========")
args['dataset']['kwargs']['transform']) dataset_it = torch.utils.data.DataLoader( dataset, batch_size=1, shuffle=False, drop_last=False, num_workers=4, pin_memory=True if args['cuda'] else False) pretrainedEnc = True if args['pretrain_encoder']['apply']: print("Loading encoder pretrained in imagenet") from erfnet_imagenet import ERFNet as ERFNet_imagenet pretrainedEnc = torch.nn.DataParallel(ERFNet_imagenet(1000)) pretrainedEnc.load_state_dict( torch.load(args['pretrain_encoder']['path'])['state_dict']) pretrainedEnc = next(pretrainedEnc.children()).features.encoder model = get_model(args['model']['name'], args['model']['kwargs']['num_classes'], pretrainedEnc) model = torch.nn.DataParallel(model).to(device) if os.path.exists(args['checkpoint_path']): print("model_loaded") state = torch.load(args['checkpoint_path']) model.load_state_dict(state['model_state_dict'], strict=True) else: assert (False, 'checkpoint_path {} does not exist!'.format( args['checkpoint_path']))
def main(args): savedir = '../save/'+args.savedir if not os.path.exists(savedir): os.makedirs(savedir) with open(savedir + '/opts.txt', "w") as myfile: myfile.write(str(args)) #Load Model assert os.path.exists(args.model + ".py"), "Error: model definition not found" model_file = importlib.import_module(args.model) model = model_file.Net(20) copyfile(args.model + ".py", savedir + '/' + args.model + ".py") if args.cuda: model = torch.nn.DataParallel(model).cuda() #model = ModelDataParallel(model).cuda() if args.state: #if args.state is provided then load this state for training #Note: this only loads initialized weights. If you want to resume a training use "--resume" option!! def load_my_state_dict(model, state_dict): #custom function to load model when not all dict keys are there own_state = model.state_dict() for name, param in state_dict.items(): if name not in own_state: continue own_state[name].copy_(param) return model #print(torch.load(args.state)) model = load_my_state_dict(model, torch.load(args.state)) #train(args, model) print("========== TRAINING ===========") if (not args.state): if args.pretrainedEncoder: print("Loading encoder pretrained in imagenet") from erfnet_imagenet import ERFNet as ERFNet_imagenet pretrainedEnc = torch.nn.DataParallel(ERFNet_imagenet(1000)) pretrainedEnc.load_state_dict(torch.load(args.pretrainedEncoder)['state_dict']) pretrainedEnc = next(pretrainedEnc.children()).features.encoder if (not args.cuda): pretrainedEnc = pretrainedEnc.cpu() #because loaded encoder is probably saved in cuda else: pretrainedEnc = next(model.children()).encoder model = model_file.Net(20, encoder=pretrainedEnc) #Add decoder to encoder model = model.cuda() if args.cuda: model = torch.nn.DataParallel(model).cuda() def load_my_state_dict(model, state_dict): #custom function to load model when not all dict keys are there own_state = model.state_dict() for name, param in state_dict.items(): if name not in own_state: continue own_state[name].copy_(param) return model defSegNet = defectSegmentationNet(20,model) defSegNet = torch.nn.DataParallel(defSegNet).cuda() road_segNet_file = importlib.import_module('erfnet2') roadSeg_model = road_segNet_file.Net(20) roadSeg_model = torch.nn.DataParallel(roadSeg_model).cuda() cascadeNet_model = cascadeNet(roadSeg_model,defSegNet) cascadeNet_model = torch.nn.DataParallel(cascadeNet_model).cuda() cascadeNet_model = load_my_state_dict(cascadeNet_model,torch.load('../save/release_version_test/model_best.pth')) #When loading encoder reinitialize weights for decoder because they are set to 0 when training dec model = train(args, cascadeNet_model, False) #Train decoder print("========== TRAINING FINISHED ===========")
def main(args): savedir = f'../save/{args.savedir}' if not os.path.exists(savedir): os.makedirs(savedir) with open(savedir + '/opts.txt', "w") as myfile: myfile.write(str(args)) #Load Model assert os.path.exists(args.model + ".py"), "Error: model definition not found" model_file = importlib.import_module(args.model) model = model_file.ERFNet(NUM_CLASSES) copyfile(args.model + ".py", savedir + '/' + args.model + ".py") if args.cuda: model = torch.nn.DataParallel(model).cuda() if args.state: def load_my_state_dict( model, state_dict ): #custom function to load model when not all dict keys are there own_state = model.state_dict() for name, param in state_dict.items(): if name not in own_state: continue own_state[name].copy_(param) return model #print(torch.load(args.state)) model = load_my_state_dict(model, torch.load(args.state)) #train(args, model) if (not args.decoder): print("========== ENCODER TRAINING ===========") model = train(args, model, True) #Train encoder #CAREFUL: for some reason, after training encoder alone, the decoder gets weights=0. #We must reinit decoder weights or reload network passing only encoder in order to train decoder print("========== DECODER TRAINING ===========") if (not args.state): if args.pretrainedEncoder: print("Loading encoder pretrained in imagenet") from erfnet_imagenet import ERFNet as ERFNet_imagenet pretrainedEnc = torch.nn.DataParallel(ERFNet_imagenet(1000)) pretrainedEnc.load_state_dict( torch.load(args.pretrainedEncoder)['state_dict']) pretrainedEnc = next(pretrainedEnc.children()).features.encoder if (not args.cuda): pretrainedEnc = pretrainedEnc.cpu( ) #because loaded encoder is probably saved in cuda else: pretrainedEnc = next(model.children()).encoder model = model_file.ERFNet( NUM_CLASSES, encoder=pretrainedEnc) #Add decoder to encoder if args.cuda: model = torch.nn.DataParallel(model).cuda() #When loading encoder reinitialize weights for decoder because they are set to 0 when training dec # TODO 加载cityscape的训练权重,然后再做迁移学习 # weightspath = "../save/cityscape_6classes_2/model_best.pth" # # def load_my_state_dict(model, state_dict): #custom function to load model when not all dict elements # # own_state = model.state_dict() # # for name, param in state_dict.items(): # # if name not in own_state: # # continue # # own_state[name].copy_(param) # # return model # # model = load_my_state_dict(model, torch.load(weightspath)) # weights_cityscape = torch.load(weightspath) # # 删除掉不匹配的权重层 # del weights_cityscape['module.decoder.output_conv.weight'] # del weights_cityscape['module.decoder.output_conv.bias'] # model.load_state_dict(weights_cityscape, strict=False) model = train(args, model, False) #Train decoder save_path = f'../save/{args.savedir}/weight_final.pth' torch.save(model.state_dict(), save_path) print("========== TRAINING FINISHED ===========")
def main(args): modelpath = args.loadDir + args.loadModel weightspath = args.loadDir + args.loadWeights print("Loading model: " + modelpath) print("Loading weights: " + weightspath) #Import ERFNet model from the folder #Net = importlib.import_module(modelpath.replace("/", "."), "ERFNet") if args.pretrainedEncoder: pretrainedEnc = torch.nn.DataParallel(ERFNet_imagenet(1000)) #pretrainedEnc.load_state_dict(torch.load(args.pretrainedEncoder)['state_dcit']) pretrainedEnc = next(pretrainedEnc.children()).features.encoder if (not args.cuda): pretrainedEnc = pretrainedEnc.cpu() model = ERFNet(NUM_CLASSES, encoder=pretrainedEnc) else: model = ERFNet(NUM_CLASSES) model = torch.nn.DataParallel(model) if args.cuda: model = model.cuda() #model.load_state_dict(torch.load(args.state)) #model.load_state_dict(torch.load(weightspath)) #not working if missing key def load_my_state_dict( model, state_dict ): #custom function to load model when not all dict elements own_state = model.state_dict() for name, param in state_dict.items(): if name not in own_state: continue own_state[name].copy_(param) return model model = load_my_state_dict(model, torch.load(weightspath)) print("Model and weights LOADED successfully") model.eval() if (not os.path.exists(args.datadir)): print("Error: datadir could not be loaded") dataset_test = avlane(args.datadir, input_transform_lot, label_transform_lot, 'test') loader = DataLoader(dataset_test, num_workers=args.num_workers, batch_size=args.batch_size, shuffle=False) # For visualizer: # must launch in other window "python3.6 -m visdom.server -port 8097" # and access localhost:8097 to see it if (args.visualize): vis = visdom.Visdom() fig = plt.figure() ax = fig.gca() h = ax.imshow(Image.new('RGB', (640 * 2, 480), 0)) print(len(loader.dataset)) iouEvalTest = iouEval_binary(NUM_CLASSES) with torch.no_grad(): for step, (images, labels, filename) in enumerate(loader): #print(images.shape) if args.cuda: images = images.cuda() labels = labels.cuda() inputs = Variable(images) targets = labels outputs = model(inputs) preds = torch.where(outputs > 0.5, torch.ones([1], dtype=torch.long).cuda(), torch.zeros([1], dtype=torch.long).cuda()) #preds = torch.where(outputs > 0.5, torch.ones([1], dtype=torch.uint8).cuda(), torch.zeros([1], dtype=torch.uint8).cuda()) # b x 1 x h x w #label = outputs[0].max(0)[1].byte().cpu().data #label_cityscapes = cityscapes_trainIds2labelIds(label.unsqueeze(0)) #label_color = Colorize()(label.unsqueeze(0)) # iou iouEvalTest.addBatch(preds[:, 0], targets[:, 0]) # no_grad handles it already iouTest = iouEvalTest.getIoU() iouStr = "test IOU: " + '{:0.2f}'.format( iouTest.item() * 100) + "%" print(iouStr) # save the output filenameSave = os.path.join(args.loadDir, 'test_results', filename[0].split("test/")[1]) os.makedirs(os.path.dirname(filenameSave), exist_ok=True) #image_transform(label.byte()).save(filenameSave) #label_save = ToPILImage()(label) pred = preds.to(torch.uint8).squeeze(0).cpu() # 1xhxw pred_save = pred_transform_lot(pred) #pred_save.save(filenameSave) # concatenate data & result im1 = Image.open( os.path.join(args.datadir, 'data/test', filename[0].split("test/")[1])).convert('RGB') im2 = pred_save dst = Image.new('RGB', (im1.width + im2.width, im1.height)) dst.paste(im1, (0, 0)) dst.paste(im2, (im1.width, 0)) filenameSaveConcat = os.path.join(args.loadDir, 'test_results_concat', filename[0].split("test/")[1]) os.makedirs(os.path.dirname(filenameSaveConcat), exist_ok=True) #dst.save(filenameSaveConcat) # wrtie iou on dst font = ImageFont.truetype( '/usr/share/fonts/truetype/freefont/FreeMonoBold.ttf', 36) d = ImageDraw.Draw(dst) d.text((900, 0), iouStr, font=font, fill=(255, 255, 0)) # show video h.set_data(dst) plt.draw() plt.axis('off') plt.pause(1e-2) if (args.visualize): vis.image(label_save.numpy()) print(step, filenameSave)