def get_eval(opt,net_path,args): ##################### Create Baseline Model #################### net = ModelWrapper(opt) load(net,net_path) ##################### Pruning Strategy Generation ############### compression_scheduler = distiller.file_config( net.get_compress_part(), net.optimizer, opt.compress_schedule_path ) compression_scheduler = SetCompressionScheduler( compression_scheduler, args["channel_config"] ) ###### Adaptive-BN-based Candidate Evaluation of Pruning Strategy ### thinning(net, compression_scheduler, input_tensor=args["dummy_input"]) flops_after, params_after = model_summary(net.get_compress_part(), args["dummy_input"]) ratio = flops_after / args["flops_before"] net = net.to(args["device"]) net.parallel(opt.gpu_ids) net.get_compress_part().train() with torch.no_grad(): for index, sample in enumerate(args["dataloader_train"]): _ = net.get_loss(sample) if index > 100: break strategy_score = net.get_eval_scores(args["dataloader_val"])["accuracy"] del net return 1-strategy_score,ratio
def filteredimage(self): im = self.img.copy() print "opening" for i in range(0, 12): im = GraphicsFilters.opening(im, 3) ArrayWriter(im.copy()).save("data/temp/t1_"+str(i)+".png") im = GraphicsFilters.deletecluster(im,100) ArrayWriter(im).save("data/temp/t2.png") print "opening" for i in range(0, 12): im = GraphicsFilters.opening(im, 3) ArrayWriter(im.copy()).save("data/temp/t3_"+str(i)+".png") print "closing" for i in range(0, 1): im = GraphicsFilters.closing(im, 5) ArrayWriter(im).save("data/temp/t4_"+str(i)+".png") im = GraphicsFilters.deletecluster(im,2000) ArrayWriter(im).save("data/temp/t5.png") print "thinning" im = thinning.thinning(im) return im
def filteredimage(self): im = self.img.copy() print "opening" for i in range(0, 12): im = GraphicsFilters.opening(im, 3) ArrayWriter(im.copy()).save("data/temp/t1_" + str(i) + ".png") im = GraphicsFilters.deletecluster(im, 100) ArrayWriter(im).save("data/temp/t2.png") print "opening" for i in range(0, 12): im = GraphicsFilters.opening(im, 3) ArrayWriter(im.copy()).save("data/temp/t3_" + str(i) + ".png") print "closing" for i in range(0, 1): im = GraphicsFilters.closing(im, 5) ArrayWriter(im).save("data/temp/t4_" + str(i) + ".png") im = GraphicsFilters.deletecluster(im, 2000) ArrayWriter(im).save("data/temp/t5.png") print "thinning" im = thinning.thinning(im) return im
def get_edge(image, show=False): # Resize image old_height, old_width = image.shape new_width = WIDTH new_height = int((new_width * old_height) / old_width) resized_image = cv2.resize(image, (new_width, new_height)) # Reduce image noise smoothened_image = cv2.bilateralFilter(resized_image, 5, 150, 30) # Normalise image normalised_image = cv2.normalize(smoothened_image, None, 0, 255, cv2.NORM_MINMAX, cv2.CV_8UC1) # Get image edge grad_x = cv2.Sobel(normalised_image, cv2.CV_16S, 1, 0) grad_y = cv2.Sobel(normalised_image, cv2.CV_16S, 0, 1) sobel_x = cv2.convertScaleAbs(grad_x) sobel_y = cv2.convertScaleAbs(grad_y) edges = cv2.addWeighted(sobel_x, 0.5, sobel_y, 0.5, 0) # Convert edges to binary _, binary_edges = cv2.threshold(edges, cv2.mean(edges)[0], 255, cv2.THRESH_BINARY) # Thin binary edges thinned_edges = thinning(binary_edges) if show: cv2.imshow("binary edges", binary_edges) cv2.imshow("thinned", thinned_edges) cv2.waitKey() # Display process steps # cv2.imshow('original', resized_image) # cv2.imshow('blurred', smoothened_image) # cv2.imshow('normalised', normalised_image) # cv2.imshow('edges', edges) # cv2.imshow('binary', binary_edges) # cv2.imshow('thinned', thinned_edges) # cv2.waitKey() # cv2.destroyAllWindows() return smoothened_image, thinned_edges
def main(opt): # basic settings os.environ["CUDA_VISIBLE_DEVICES"]=str(opt.gpu_ids)[1:-1] if torch.cuda.is_available(): device = 'cuda' torch.backends.cudnn.benchmark = True else: device = 'cpu' ##################### Get Dataloader #################### dataloader_train, dataloader_val = custom_get_dataloaders(opt) # dummy_input is sample input of dataloaders if hasattr(dataloader_val, 'dataset'): dummy_input = dataloader_val.dataset.__getitem__(0) dummy_input = dummy_input[0] dummy_input = dummy_input.unsqueeze(0) else: # for imagenet dali loader dummy_input = torch.rand(1, 3, 224, 224) ##################### Create Baseline Model #################### net = ModelWrapper(opt) net.load_checkpoint(opt.checkpoint) flops_before, params_before = model_summary(net.get_compress_part(), dummy_input) ##################### Pruning Strategy Generation ############### compression_scheduler = distiller.file_config(net.get_compress_part(), net.optimizer, opt.compress_schedule_path) num_layer = len(compression_scheduler.policies[1]) channel_config = get_pruning_strategy(opt, num_layer) # pruning strategy compression_scheduler = random_compression_scheduler(compression_scheduler, channel_config) ###### Adaptive-BN-based Candidate Evaluation of Pruning Strategy ### thinning(net, compression_scheduler, input_tensor=dummy_input) print(net) flops_after, params_after = model_summary(net.get_compress_part(), dummy_input) ratio = flops_after / flops_before print('FLOPs ratio:', ratio) if ratio < opt.flops_target - 0.005 or ratio > opt.flops_target + 0.005: # illegal pruning strategy return net = net.to(device) net.parallel(opt.gpu_ids) net.get_compress_part().train() with torch.no_grad(): for index, sample in enumerate(tqdm(dataloader_train, leave=False)): _ = net.get_loss(sample) if index > 50: break strategy_score = net.get_eval_scores(dataloader_val)['accuracy'] #################### Save Pruning Strategy and Score ######### log_file = open(opt.output_file, 'a+') log_file.write("{} {} ".format(strategy_score, ratio)) for item in channel_config: log_file.write("{} ".format(str(item))) log_file.write('\n') log_file.close() print('Eval Score:{}'.format(strategy_score))
off = 1 if (fill == ones).any(): i += 1 continue if not (sh == ones).all(): if not (sh2 == ones).all(): i += 1 continue sh = sh2 off = 2 if y > 16: print(roi_mask[y, (x + i):(x + i + FW)], fill, sh) print('FND', x + i, y) for j in range(off): for k in range(3): if (sh[k] == [255, 255, 255]).all(): roi_and[y + j + 1, (x + i + k)] = (0, 0, 255) i += 1 edges = cv2.Canny(cv2.resize(roi_and, (0, 0), fx=4.0, fy=4.0), 50, 150, apertureSize=5) #cv2.imshow('norm', closed) #cv2.resize(cv2.resize(img_rgb2, (0, 0), fx=0.5, fy=0.5), (0,0), fx=8.0, fy=8.0)) cv2.imshow('norm', thinning(cv2.resize(roi_mask, (0, 0), fx=2.0, fy=2.0))) #, cv2.COLOR_BGR2GRAY))) cv2.imshow( 'norm2', img_dbg ) # thinning(cv2.resize(closed, (0, 0), fx=4.0, fy=4.0))) #, cv2.COLOR_BGR2GRAY))) ley = cv2.waitKey(0)
def main(opt): # basic settings os.environ["CUDA_VISIBLE_DEVICES"] = str(opt.gpu_ids)[1:-1] if torch.cuda.is_available(): device = "cuda" torch.backends.cudnn.benchmark = True else: device = "cpu" ##################### Get Dataloader #################### dataloader_train, dataloader_val = custom_get_dataloaders(opt) # dummy_input is sample input of dataloaders if hasattr(dataloader_val, "dataset"): dummy_input = dataloader_val.dataset.__getitem__(0) dummy_input = dummy_input[0] dummy_input = dummy_input.unsqueeze(0) else: # for imagenet dali loader dummy_input = torch.rand(1, 3, 224, 224) ##################### Create Baseline Model #################### net = ModelWrapper(opt) net.load_checkpoint(opt.checkpoint) flops_before, params_before = model_summary(net.get_compress_part(), dummy_input) ##################### Load Pruning Strategy ############### compression_scheduler = distiller.file_config(net.get_compress_part(), net.optimizer, opt.compress_schedule_path) channel_config = get_channel_config(opt.search_result, opt.strategy_id) # pruning strategy compression_scheduler = random_compression_scheduler( compression_scheduler, channel_config) ###### Adaptive-BN-based Candidate Evaluation of Pruning Strategy ### thinning(net, compression_scheduler, input_tensor=dummy_input) flops_after, params_after = model_summary(net.get_compress_part(), dummy_input) ratio = flops_after / flops_before print("FLOPs ratio:", ratio) net = net.to(device) net.parallel(opt.gpu_ids) net.get_compress_part().train() with torch.no_grad(): for index, sample in enumerate(tqdm(dataloader_train, leave=False)): _ = net.get_loss(sample) if index > 100: break strategy_score = net.get_eval_scores(dataloader_val)["accuracy"] print("Result file:{}, Strategy ID:{}, Evaluation score:{}".format( opt.search_result, opt.strategy_id, strategy_score)) ##################### Fine-tuning ######################### lr_scheduler = optim.lr_scheduler.CosineAnnealingLR( net.optimizer, opt.epoch) reporter = Reporter(opt) best_acc = 0 net._net.train() for epoch in range(1, opt.epoch + 1): reporter.log_metric("lr", net.optimizer.param_groups[0]["lr"], epoch) train_loss = train_epoch( net, dataloader_train, net.optimizer, ) reporter.log_metric("train_loss", train_loss, epoch) lr_scheduler.step() scores = net.get_eval_scores(dataloader_val) print("==> Evaluation: Epoch={} Acc={}".format(epoch, str(scores))) reporter.log_metric("eval_acc", scores["accuracy"], epoch) if scores["accuracy"] > best_acc: best_acc = scores["accuracy"] reporter.log_metric("best_acc", best_acc, epoch) save_checkpoints( scores["accuracy"], net._net, reporter, opt.exp_name, epoch, ) print("==> Training epoch %d" % epoch)
flags[y,x] = 2 flags[np.where(flags==2)] = 1 return np.array(flags[1:-1,1:-1], dtype = np.uint8) if __name__ == "__main__": filename = sys.argv[1] threshold = int(sys.argv[2]) print("load data") reader = ImageReader(filename) ArrayWriter(reader.getrawarray()).save("data/0raw.png") print("threshhold = {0}".format(threshold)) img = reader.get2tonearray(lambda x: x < threshold) TwotoneArrayWriter(img).save("data/1twotone.png") print("filtering") print(" opening") img = Morphology.opening(img, 2, 0, 4) print(" delete cluster") img = ClusterDetector.deletecluster(img,4000) TwotoneArrayWriter(img).save("data/temp/t3.png") print(" thinning") ans = thinning.thinning(img) TwotoneArrayWriter(ans).save("data/2filtered.png")
i += 1 continue color = roi_and[y,(x+i+2)] fill = roi_mask[y+1,(x+i):(x+i+FW)] sh = roi_mask[y+2,(x+i):(x+i+FW)] sh2 = roi_mask[y+3,(x+i):(x+i+FW)] off = 1 if (fill == ones).any(): i += 1 continue if not (sh == ones).all(): if not (sh2 == ones).all(): i += 1 continue sh = sh2 off = 2 if y > 16: print(roi_mask[y,(x+i):(x+i+FW)], fill, sh) print('FND', x+i, y) for j in range(off): for k in range(3): if (sh[k] == [255,255,255]).all(): roi_and[y+j+1,(x+i+k)] = (0,0,255) i += 1 edges = cv2.Canny(cv2.resize(roi_and, (0, 0), fx=4.0, fy=4.0),50,150,apertureSize = 5) #cv2.imshow('norm', closed) #cv2.resize(cv2.resize(img_rgb2, (0, 0), fx=0.5, fy=0.5), (0,0), fx=8.0, fy=8.0)) cv2.imshow('norm', thinning(cv2.resize(roi_mask, (0, 0), fx=2.0, fy=2.0))) #, cv2.COLOR_BGR2GRAY))) cv2.imshow('norm2', img_dbg) # thinning(cv2.resize(closed, (0, 0), fx=4.0, fy=4.0))) #, cv2.COLOR_BGR2GRAY))) ley = cv2.waitKey(0)
def main(opt, channel_config, dataloader_train, dataloader_val, path): # basic settings torch.backends.cudnn.enabled = False os.environ["CUDA_VISIBLE_DEVICES"] = str(opt.gpu_ids)[1:-1] if torch.cuda.is_available(): device = "cuda" torch.backends.cudnn.benchmark = False else: device = "cpu" ##################### Get Dataloader #################### # dummy_input is sample input of dataloaders if hasattr(dataloader_val, "dataset"): dummy_input = dataloader_val.dataset.__getitem__(0) dummy_input = dummy_input[0] dummy_input = dummy_input.unsqueeze(0) else: # for imagenet dali loader dummy_input = torch.rand(1, 3, 224, 224) ##################### Create Baseline Model #################### net = ModelWrapper(opt) load(net, path) #net.load_checkpoint(opt.checkpoint) ##################### Load Pruning Strategy ############### compression_scheduler = distiller.file_config(net.get_compress_part(), net.optimizer, opt.compress_schedule_path) compression_scheduler = setCompressionScheduler(compression_scheduler, channel_config) ###### Adaptive-BN-based Candidate Evaluation of Pruning Strategy ### thinning(net, compression_scheduler, input_tensor=dummy_input) flops_after, params_after = model_summary(net.get_compress_part(), dummy_input) net = net.to(device) net.parallel(opt.gpu_ids) net.get_compress_part().train() t = tqdm(dataloader_train, leave=False) with torch.no_grad(): for index, sample in enumerate(t): _ = net.get_loss(sample) if index > 100: break strategy_score = net.get_eval_scores(dataloader_val)["accuracy"] old = strategy_score print("Evaluation score:{}".format(strategy_score)) ##################### Fine-tuning ######################### lr_scheduler = optim.lr_scheduler.CosineAnnealingLR(net.optimizer, 100, eta_min=5e-5) #lr_scheduler=optim.lr_scheduler.StepLR(net.optimizer,5,0.9) reporter = Reporter(opt) best_acc = strategy_score best_kappa = 0 net._net.train() for epoch in range(1, opt.epoch + 1): net.confusion_matrix.reset() reporter.log_metric("lr", net.optimizer.param_groups[0]["lr"], epoch) train_loss = train_epoch( net, dataloader_train, net.optimizer, ) reporter.log_metric("train_loss", train_loss, epoch) lr_scheduler.step() scores = net.get_eval_scores(dataloader_val) kappa = CaluKappa(net.confusion_matrix) print("==> Evaluation: Epoch={} Acc={}".format(epoch, str(scores))) reporter.log_metric("eval_acc", scores["accuracy"], epoch) reporter.log_metric("kappa", kappa, epoch) if scores["accuracy"] > best_acc: best_acc = scores["accuracy"] best_kappa = kappa save_checkpoints( scores["accuracy"], net._net, reporter, opt.exp_name, epoch, ) reporter.log_metric("best_acc", best_acc, epoch) save_checkpoints( scores["accuracy"], net._net, reporter, opt.exp_name, epoch, ) print("==> Training epoch %d" % epoch) """将模型转换为torch script保存""" ckpt_name = "{}_best.pth".format(opt.exp_name) load(net, os.path.join(reporter.ckpt_log_dir, ckpt_name)) net._net.eval() traced_script_module = torch.jit.trace(net._net, torch.rand(1, 3, 256, 256)) traced_script_module.save(os.path.join(reporter.log_dir, "model.pt")) del net return old, best_acc, best_kappa, flops_after, params_after