update

app.py

@@ -9,124 +9,193 @@ import torch
 import yaml
 from PIL import Image
 from subprocess import call
-
-ROOT_PATH = sys.path[0]  # 根目录
-
-# 模型路径
-model_path = "ultralytics/yolov5"
-# 模型名称临时变量
-model_name_tmp = ""
-# 设备临时变量
-device_tmp = ""
-# 文件后缀
-suffix_list = [".csv", ".yaml"]
-def parse_args(known=False):
-    parser = argparse.ArgumentParser(description="Gradio LIVE")
-    parser.add_argument(
-        "--model_name", "-mn", default="yolov5s", type=str, help="model name"
-    )
-    parser.add_argument(
-        "--model_cfg",
-        "-mc",
-        default="./model_config/model_name_p5_all.yaml",
-        type=str,
-        help="model config",
-    )
-    parser.add_argument(
-        "--cls_name",
-        "-cls",
-        default="./cls_name/cls_name.yaml",
-        type=str,
-        help="cls name",
-    )
-    parser.add_argument(
-        "--nms_conf",
-        "-conf",
-        default=0.5,
-        type=float,
-        help="model NMS confidence threshold",
-    )
-    parser.add_argument(
-        "--nms_iou", "-iou", default=0.45, type=float, help="model NMS IoU threshold"
-    )
-
-    parser.add_argument(
-        "--label_dnt_show",
-        "-lds",
-        action="store_false",
-        default=True,
-        help="label show",
-    )
-    parser.add_argument(
-        "--device",
-        "-dev",
-        default="cpu",
-        type=str,
-        help="cuda or cpu, hugging face only cpu",
-    )
-    parser.add_argument(
-        "--inference_size", "-isz", default=640, type=int, help="model inference size"
-    )
-
-    args = parser.parse_known_args()[0] if known else parser.parse_args()
-    return args
-#  模型加载
-def model_loading(model_name, device):
-
-    # 加载本地模型
-    model = torch.hub.load(model_path, model_name, force_reload=True, device=device)
-
-    return model
-# 检测信息
-def export_json(results, model, img_size):
-
-    return [
-        [
-            {
-                "id": int(i),
-                "class": int(result[i][5]),
-                "class_name": model.model.names[int(result[i][5])],
-                "normalized_box": {
-                    "x0": round(result[i][:4].tolist()[0], 6),
-                    "y0": round(result[i][:4].tolist()[1], 6),
-                    "x1": round(result[i][:4].tolist()[2], 6),
-                    "y1": round(result[i][:4].tolist()[3], 6),
-                },
-                "confidence": round(float(result[i][4]), 2),
-                "fps": round(1000 / float(results.t[1]), 2),
-                "width": img_size[0],
-                "height": img_size[1],
-            }
-            for i in range(len(result))
-        ]
-        for result in results.xyxyn
-    ]
-def yolo_det(img, experiment_id, device=None, model_name=None, inference_size=None, conf=None, iou=None, label_opt=None, model_cls=None):
-
-    global model, model_name_tmp, device_tmp
-
-    if model_name_tmp != model_name:
-        # 模型判断，避免反复加载
-        model_name_tmp = model_name
-        model = model_loading(model_name_tmp, device)
-    elif device_tmp != device:
-        device_tmp = device
-        model = model_loading(model_name_tmp, device)
-
-    # -----------模型调参-----------
-    model.conf = conf  # NMS 置信度阈值
-    model.iou = iou  # NMS IOU阈值
-    model.max_det = 1000  # 最大检测框数
-    model.classes = model_cls  # 模型类别
-
-    results = model(img, size=inference_size)  # 检测
-    results.render(labels=label_opt)  # 渲染
-
-    det_img = Image.fromarray(results.imgs[0])  # 检测图片
-
-    det_json = export_json(results, model, img.size)[0]  # 检测信息
-
-    return det_img, det_json
+import pydiffvg
+import torch
+import cv2
+import matplotlib.pyplot as plt
+import random
+import argparse
+import math
+import errno
+from tqdm import tqdm
+import yaml
+from easydict import EasyDict as edict
+from main import main_func
+
+def parse_args():
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--debug', action='store_true', default=False)
+    parser.add_argument("--config", default="config/base.yaml", type=str)
+    parser.add_argument("--experiment", type=str)
+    parser.add_argument("--seed", type=int)
+    parser.add_argument("--target", type=str, help="target image path")
+    parser.add_argument('--log_dir', metavar='DIR', default="log/debug")
+    parser.add_argument('--initial', type=str, default="random", choices=['random', 'circle'])
+    parser.add_argument('--signature', nargs='+', type=str)
+    parser.add_argument('--seginit', nargs='+', type=str)
+    parser.add_argument("--num_segments", type=int, default=4)
+    # parser.add_argument("--num_paths", type=str, default="1,1,1")
+    # parser.add_argument("--num_iter", type=int, default=500)
+    # parser.add_argument('--free', action='store_true')
+    # Please ensure that image resolution is divisible by pool_size; otherwise the performance would drop a lot.
+    # parser.add_argument('--pool_size', type=int, default=40, help="the pooled image size for next path initialization")
+    # parser.add_argument('--save_loss', action='store_true')
+    # parser.add_argument('--save_init', action='store_true')
+    # parser.add_argument('--save_image', action='store_true')
+    # parser.add_argument('--save_video', action='store_true')
+    # parser.add_argument('--print_weight', action='store_true')
+    # parser.add_argument('--circle_init_radius',  type=float)
+    cfg = edict()
+    args = parser.parse_args()
+    cfg.debug = args.debug
+    cfg.config = args.config
+    cfg.experiment = args.experiment
+    cfg.seed = args.seed
+    cfg.target = args.target
+    cfg.log_dir = args.log_dir
+    cfg.initial = args.initial
+    cfg.signature = args.signature
+    # set cfg num_segments in command
+    cfg.num_segments = args.num_segments
+    if args.seginit is not None:
+        cfg.seginit = edict()
+        cfg.seginit.type = args.seginit[0]
+        if cfg.seginit.type == 'circle':
+            cfg.seginit.radius = float(args.seginit[1])
+    return cfg
+
+
+
+
+
+def run_live(img, experiment_id):
+    main_func(img, experiment_id)
+    return 0, 1
+
+
+
+
+
+
+
+
+
+# ROOT_PATH = sys.path[0]  # 根目录
+# # 模型路径
+# model_path = "ultralytics/yolov5"
+# # 模型名称临时变量
+# model_name_tmp = ""
+# # 设备临时变量
+# device_tmp = ""
+# # 文件后缀
+# suffix_list = [".csv", ".yaml"]
+# def parse_args(known=False):
+#     parser = argparse.ArgumentParser(description="Gradio LIVE")
+#     parser.add_argument(
+#         "--model_name", "-mn", default="yolov5s", type=str, help="model name"
+#     )
+#     parser.add_argument(
+#         "--model_cfg",
+#         "-mc",
+#         default="./model_config/model_name_p5_all.yaml",
+#         type=str,
+#         help="model config",
+#     )
+#     parser.add_argument(
+#         "--cls_name",
+#         "-cls",
+#         default="./cls_name/cls_name.yaml",
+#         type=str,
+#         help="cls name",
+#     )
+#     parser.add_argument(
+#         "--nms_conf",
+#         "-conf",
+#         default=0.5,
+#         type=float,
+#         help="model NMS confidence threshold",
+#     )
+#     parser.add_argument(
+#         "--nms_iou", "-iou", default=0.45, type=float, help="model NMS IoU threshold"
+#     )
+#
+#     parser.add_argument(
+#         "--label_dnt_show",
+#         "-lds",
+#         action="store_false",
+#         default=True,
+#         help="label show",
+#     )
+#     parser.add_argument(
+#         "--device",
+#         "-dev",
+#         default="cpu",
+#         type=str,
+#         help="cuda or cpu, hugging face only cpu",
+#     )
+#     parser.add_argument(
+#         "--inference_size", "-isz", default=640, type=int, help="model inference size"
+#     )
+#
+#     args = parser.parse_known_args()[0] if known else parser.parse_args()
+#     return args
+# #  模型加载
+# def model_loading(model_name, device):
+#
+#     # 加载本地模型
+#     model = torch.hub.load(model_path, model_name, force_reload=True, device=device)
+#
+#     return model
+# # 检测信息
+# def export_json(results, model, img_size):
+#
+#     return [
+#         [
+#             {
+#                 "id": int(i),
+#                 "class": int(result[i][5]),
+#                 "class_name": model.model.names[int(result[i][5])],
+#                 "normalized_box": {
+#                     "x0": round(result[i][:4].tolist()[0], 6),
+#                     "y0": round(result[i][:4].tolist()[1], 6),
+#                     "x1": round(result[i][:4].tolist()[2], 6),
+#                     "y1": round(result[i][:4].tolist()[3], 6),
+#                 },
+#                 "confidence": round(float(result[i][4]), 2),
+#                 "fps": round(1000 / float(results.t[1]), 2),
+#                 "width": img_size[0],
+#                 "height": img_size[1],
+#             }
+#             for i in range(len(result))
+#         ]
+#         for result in results.xyxyn
+#     ]
+# def yolo_det(img, experiment_id, device=None, model_name=None, inference_size=None, conf=None, iou=None, label_opt=None, model_cls=None):
+#
+#     global model, model_name_tmp, device_tmp
+#
+#     if model_name_tmp != model_name:
+#         # 模型判断，避免反复加载
+#         model_name_tmp = model_name
+#         model = model_loading(model_name_tmp, device)
+#     elif device_tmp != device:
+#         device_tmp = device
+#         model = model_loading(model_name_tmp, device)
+#
+#     # -----------模型调参-----------
+#     model.conf = conf  # NMS 置信度阈值
+#     model.iou = iou  # NMS IOU阈值
+#     model.max_det = 1000  # 最大检测框数
+#     model.classes = model_cls  # 模型类别
+#
+#     results = model(img, size=inference_size)  # 检测
+#     results.render(labels=label_opt)  # 渲染
+#
+#     det_img = Image.fromarray(results.imgs[0])  # 检测图片
+#
+#     det_json = export_json(results, model, img.size)[0]  # 检测信息
+#
+#     return det_img, det_json
 
 
 def run_cmd(command):
@@ -150,25 +219,25 @@ run_cmd("python main.py --config config/base.yaml --experiment experiment_5x1 --
 
 
 
-# yaml文件解析
-def yaml_parse(file_path):
-    return yaml.safe_load(open(file_path, "r", encoding="utf-8").read())
-
-
-# yaml csv 文件解析
-def yaml_csv(file_path, file_tag):
-    file_suffix = Path(file_path).suffix
-    if file_suffix == suffix_list[0]:
-        # 模型名称
-        file_names = [i[0] for i in list(csv.reader(open(file_path)))]  # csv版
-    elif file_suffix == suffix_list[1]:
-        # 模型名称
-        file_names = yaml_parse(file_path).get(file_tag)  # yaml版
-    else:
-        print(f"{file_path}格式不正确！程序退出！")
-        sys.exit()
-
-    return file_names
+# # yaml文件解析
+# def yaml_parse(file_path):
+#     return yaml.safe_load(open(file_path, "r", encoding="utf-8").read())
+#
+#
+# # yaml csv 文件解析
+# def yaml_csv(file_path, file_tag):
+#     file_suffix = Path(file_path).suffix
+#     if file_suffix == suffix_list[0]:
+#         # 模型名称
+#         file_names = [i[0] for i in list(csv.reader(open(file_path)))]  # csv版
+#     elif file_suffix == suffix_list[1]:
+#         # 模型名称
+#         file_names = yaml_parse(file_path).get(file_tag)  # yaml版
+#     else:
+#         print(f"{file_path}格式不正确！程序退出！")
+#         sys.exit()
+#
+#     return file_names
 
 
 def main(args):
@@ -223,7 +292,7 @@ def main(args):
 
     # Interface
     gr.Interface(
-        fn=yolo_det,
+        fn=run_live,
         inputs=inputs,
         outputs=[outputs, outputs02],
         title=title,

config/base.yaml

@@ -5,10 +5,10 @@ default:
     type: circle
     radius: 5
   save:
-    init: true
-    image: true
+    init: false
+    image: false
     output: true
-    video: true
+    video: false
     loss: false
   trainable: 
     bg: False
@@ -66,3 +66,19 @@ experiment_1357:
     type: list
     schedule: [1, 3, 5, 7]
 
+
+experiment_exp2_256:
+  path_schedule:
+    type: exp
+    base: 2
+    max_path: 256
+    max_path_per_iter: 32
+
+
+experiment_exp2_128:
+  path_schedule:
+    type: exp
+    base: 2
+    max_path: 128
+    max_path_per_iter: 32
+

main.py

@@ -344,6 +344,345 @@ class linear_decay_lrlambda_f(object):
         lr = lr_s * (1-r) + lr_e * r
         return lr
 
+def main_func(target, experiment):
+    cfg_arg = parse_args()
+    with open(cfg_arg.config, 'r') as f:
+        cfg = yaml.load(f, Loader=yaml.FullLoader)
+    cfg_default = edict(cfg['default'])
+    cfg = edict(cfg[cfg_arg.experiment])
+    cfg.update(cfg_default)
+    cfg.update(cfg_arg)
+    cfg.exid = get_experiment_id(cfg.debug)
+
+    cfg.experiment_dir = \
+        osp.join(cfg.log_dir, '{}_{}'.format(cfg.exid, '_'.join(cfg.signature)))
+    cfg.target = target
+    cfg.experiment = experiment
+
+    configfile = osp.join(cfg.experiment_dir, 'config.yaml')
+    check_and_create_dir(configfile)
+    with open(osp.join(configfile), 'w') as f:
+        yaml.dump(edict_2_dict(cfg), f)
+
+    # Use GPU if available
+    pydiffvg.set_use_gpu(torch.cuda.is_available())
+    device = pydiffvg.get_device()
+
+    gt = np.array(PIL.Image.open(cfg.target))
+    print(f"Input image shape is: {gt.shape}")
+    if len(gt.shape) == 2:
+        print("Converting the gray-scale image to RGB.")
+        gt = gt.unsqueeze(dim=-1).repeat(1,1,3)
+    if gt.shape[2] == 4:
+        print("Input image includes alpha channel, simply dropout alpha channel.")
+        gt = gt[:, :, :3]
+    gt = (gt/255).astype(np.float32)
+    gt = torch.FloatTensor(gt).permute(2, 0, 1)[None].to(device)
+    if cfg.use_ycrcb:
+        gt = ycrcb_conversion(gt)
+    h, w = gt.shape[2:]
+
+    path_schedule = get_path_schedule(**cfg.path_schedule)
+
+    if cfg.seed is not None:
+        random.seed(cfg.seed)
+        npr.seed(cfg.seed)
+        torch.manual_seed(cfg.seed)
+    render = pydiffvg.RenderFunction.apply
+
+    shapes_record, shape_groups_record = [], []
+
+    region_loss = None
+    loss_matrix = []
+
+    para_point, para_color = {}, {}
+    if cfg.trainable.stroke:
+        para_stroke_width, para_stroke_color = {}, {}
+
+    pathn_record = []
+    # Background
+    if cfg.trainable.bg:
+        # meancolor = gt.mean([2, 3])[0]
+        para_bg = torch.tensor([1., 1., 1.], requires_grad=True, device=device)
+    else:
+        if cfg.use_ycrcb:
+            para_bg = torch.tensor([219/255, 0, 0], requires_grad=False, device=device)
+        else:
+            para_bg = torch.tensor([1., 1., 1.], requires_grad=False, device=device)
+
+    ##################
+    # start_training #
+    ##################
+
+    loss_weight = None
+    loss_weight_keep = 0
+    if cfg.coord_init.type == 'naive':
+        pos_init_method = naive_coord_init(
+            para_bg.view(1, -1, 1, 1).repeat(1, 1, h, w), gt)
+    elif cfg.coord_init.type == 'sparse':
+        pos_init_method = sparse_coord_init(
+            para_bg.view(1, -1, 1, 1).repeat(1, 1, h, w), gt)
+    elif cfg.coord_init.type == 'random':
+        pos_init_method = random_coord_init([h, w])
+    else:
+        raise ValueError
+
+    lrlambda_f = linear_decay_lrlambda_f(cfg.num_iter, 0.4)
+    optim_schedular_dict = {}
+
+    for path_idx, pathn in enumerate(path_schedule):
+        loss_list = []
+        print("=> Adding [{}] paths, [{}] ...".format(pathn, cfg.seginit.type))
+        pathn_record.append(pathn)
+        pathn_record_str = '-'.join([str(i) for i in pathn_record])
+
+        # initialize new shapes related stuffs.
+        if cfg.trainable.stroke:
+            shapes, shape_groups, point_var, color_var, stroke_width_var, stroke_color_var = init_shapes(
+                pathn, cfg.num_segments, (h, w),
+                cfg.seginit, len(shapes_record),
+                pos_init_method,
+                trainable_stroke=True,
+                gt=gt, )
+            para_stroke_width[path_idx] = stroke_width_var
+            para_stroke_color[path_idx] = stroke_color_var
+        else:
+            shapes, shape_groups, point_var, color_var = init_shapes(
+                pathn, cfg.num_segments, (h, w),
+                cfg.seginit, len(shapes_record),
+                pos_init_method,
+                trainable_stroke=False,
+                gt=gt, )
+
+        shapes_record += shapes
+        shape_groups_record += shape_groups
+
+        if cfg.save.init:
+            filename = os.path.join(
+                cfg.experiment_dir, "svg-init",
+                "{}-init.svg".format(pathn_record_str))
+            check_and_create_dir(filename)
+            pydiffvg.save_svg(
+                filename, w, h,
+                shapes_record, shape_groups_record)
+
+        para = {}
+        if (cfg.trainable.bg) and (path_idx == 0):
+            para['bg'] = [para_bg]
+        para['point'] = point_var
+        para['color'] = color_var
+        if cfg.trainable.stroke:
+            para['stroke_width'] = stroke_width_var
+            para['stroke_color'] = stroke_color_var
+
+        pg = [{'params' : para[ki], 'lr' : cfg.lr_base[ki]} for ki in sorted(para.keys())]
+        optim = torch.optim.Adam(pg)
+
+        if cfg.trainable.record:
+            scheduler = LambdaLR(
+                optim, lr_lambda=lrlambda_f, last_epoch=-1)
+        else:
+            scheduler = LambdaLR(
+                optim, lr_lambda=lrlambda_f, last_epoch=cfg.num_iter)
+        optim_schedular_dict[path_idx] = (optim, scheduler)
+
+        # Inner loop training
+        t_range = tqdm(range(cfg.num_iter))
+        for t in t_range:
+
+            for _, (optim, _) in optim_schedular_dict.items():
+                optim.zero_grad()
+
+            # Forward pass: render the image.
+            scene_args = pydiffvg.RenderFunction.serialize_scene(
+                w, h, shapes_record, shape_groups_record)
+            img = render(w, h, 2, 2, t, None, *scene_args)
+
+            # Compose img with white background
+            img = img[:, :, 3:4] * img[:, :, :3] + \
+                para_bg * (1 - img[:, :, 3:4])
+
+            if cfg.save.video:
+                filename = os.path.join(
+                    cfg.experiment_dir, "video-png",
+                    "{}-iter{}.png".format(pathn_record_str, t))
+                check_and_create_dir(filename)
+                if cfg.use_ycrcb:
+                    imshow = ycrcb_conversion(
+                        img, format='[2D x 3]', reverse=True).detach().cpu()
+                else:
+                    imshow = img.detach().cpu()
+                pydiffvg.imwrite(imshow, filename, gamma=gamma)
+
+            x = img.unsqueeze(0).permute(0, 3, 1, 2) # HWC -> NCHW
+
+            if cfg.use_ycrcb:
+                color_reweight = torch.FloatTensor([255/219, 255/224, 255/255]).to(device)
+                loss = ((x-gt)*(color_reweight.view(1, -1, 1, 1)))**2
+            else:
+                loss = ((x-gt)**2)
+
+            if cfg.loss.use_l1_loss:
+                loss = abs(x-gt)
+
+            if cfg.loss.use_distance_weighted_loss:
+                if cfg.use_ycrcb:
+                    raise ValueError
+                shapes_forsdf = copy.deepcopy(shapes)
+                shape_groups_forsdf = copy.deepcopy(shape_groups)
+                for si in shapes_forsdf:
+                    si.stroke_width = torch.FloatTensor([0]).to(device)
+                for sg_idx, sgi in enumerate(shape_groups_forsdf):
+                    sgi.fill_color = torch.FloatTensor([1, 1, 1, 1]).to(device)
+                    sgi.shape_ids = torch.LongTensor([sg_idx]).to(device)
+
+                sargs_forsdf = pydiffvg.RenderFunction.serialize_scene(
+                    w, h, shapes_forsdf, shape_groups_forsdf)
+                with torch.no_grad():
+                    im_forsdf = render(w, h, 2, 2, 0, None, *sargs_forsdf)
+                # use alpha channel is a trick to get 0-1 image
+                im_forsdf = (im_forsdf[:, :, 3]).detach().cpu().numpy()
+                loss_weight = get_sdf(im_forsdf, normalize='to1')
+                loss_weight += loss_weight_keep
+                loss_weight = np.clip(loss_weight, 0, 1)
+                loss_weight = torch.FloatTensor(loss_weight).to(device)
+
+            if cfg.save.loss:
+                save_loss = loss.squeeze(dim=0).mean(dim=0,keepdim=False).cpu().detach().numpy()
+                save_weight = loss_weight.cpu().detach().numpy()
+                save_weighted_loss = save_loss*save_weight
+                # normalize to [0,1]
+                save_loss = (save_loss - np.min(save_loss))/np.ptp(save_loss)
+                save_weight = (save_weight - np.min(save_weight))/np.ptp(save_weight)
+                save_weighted_loss = (save_weighted_loss - np.min(save_weighted_loss))/np.ptp(save_weighted_loss)
+
+                # save
+                plt.imshow(save_loss, cmap='Reds')
+                plt.axis('off')
+                # plt.colorbar()
+                filename = os.path.join(cfg.experiment_dir, "loss", "{}-iter{}-mseloss.png".format(pathn_record_str, t))
+                check_and_create_dir(filename)
+                plt.savefig(filename, dpi=800)
+                plt.close()
+
+                plt.imshow(save_weight, cmap='Greys')
+                plt.axis('off')
+                # plt.colorbar()
+                filename = os.path.join(cfg.experiment_dir, "loss", "{}-iter{}-sdfweight.png".format(pathn_record_str, t))
+                plt.savefig(filename, dpi=800)
+                plt.close()
+
+                plt.imshow(save_weighted_loss, cmap='Reds')
+                plt.axis('off')
+                # plt.colorbar()
+                filename = os.path.join(cfg.experiment_dir, "loss", "{}-iter{}-weightedloss.png".format(pathn_record_str, t))
+                plt.savefig(filename, dpi=800)
+                plt.close()
+
+
+
+
+
+            if loss_weight is None:
+                loss = loss.sum(1).mean()
+            else:
+                loss = (loss.sum(1)*loss_weight).mean()
+
+            # if (cfg.loss.bis_loss_weight is not None)  and (cfg.loss.bis_loss_weight > 0):
+            #     loss_bis = bezier_intersection_loss(point_var[0]) * cfg.loss.bis_loss_weight
+            #     loss = loss + loss_bis
+            if (cfg.loss.xing_loss_weight is not None) \
+                    and (cfg.loss.xing_loss_weight > 0):
+                loss_xing = xing_loss(point_var) * cfg.loss.xing_loss_weight
+                loss = loss + loss_xing
+
+
+            loss_list.append(loss.item())
+            t_range.set_postfix({'loss': loss.item()})
+            loss.backward()
+
+            # step
+            for _, (optim, scheduler) in optim_schedular_dict.items():
+                optim.step()
+                scheduler.step()
+
+            for group in shape_groups_record:
+                group.fill_color.data.clamp_(0.0, 1.0)
+
+        if cfg.loss.use_distance_weighted_loss:
+            loss_weight_keep = loss_weight.detach().cpu().numpy() * 1
+
+        if not cfg.trainable.record:
+            for _, pi in pg.items():
+                for ppi in pi:
+                    pi.require_grad = False
+            optim_schedular_dict = {}
+
+        if cfg.save.image:
+            filename = os.path.join(
+                cfg.experiment_dir, "demo-png", "{}.png".format(pathn_record_str))
+            check_and_create_dir(filename)
+            if cfg.use_ycrcb:
+                imshow = ycrcb_conversion(
+                    img, format='[2D x 3]', reverse=True).detach().cpu()
+            else:
+                imshow = img.detach().cpu()
+            pydiffvg.imwrite(imshow, filename, gamma=gamma)
+
+        if cfg.save.output:
+            filename = os.path.join(
+                cfg.experiment_dir, "output-svg", "{}.svg".format(pathn_record_str))
+            check_and_create_dir(filename)
+            pydiffvg.save_svg(filename, w, h, shapes_record, shape_groups_record)
+
+        loss_matrix.append(loss_list)
+
+        # calculate the pixel loss
+        # pixel_loss = ((x-gt)**2).sum(dim=1, keepdim=True).sqrt_() # [N,1,H, W]
+        # region_loss = adaptive_avg_pool2d(pixel_loss, cfg.region_loss_pool_size)
+        # loss_weight = torch.softmax(region_loss.reshape(1, 1, -1), dim=-1)\
+        #     .reshape_as(region_loss)
+
+        pos_init_method = naive_coord_init(x, gt)
+
+        if cfg.coord_init.type == 'naive':
+            pos_init_method = naive_coord_init(x, gt)
+        elif cfg.coord_init.type == 'sparse':
+            pos_init_method = sparse_coord_init(x, gt)
+        elif cfg.coord_init.type == 'random':
+            pos_init_method = random_coord_init([h, w])
+        else:
+            raise ValueError
+
+        if cfg.save.video:
+            print("saving iteration video...")
+            img_array = []
+            for ii in range(0, cfg.num_iter):
+                filename = os.path.join(
+                    cfg.experiment_dir, "video-png",
+                    "{}-iter{}.png".format(pathn_record_str, ii))
+                img = cv2.imread(filename)
+                # cv2.putText(
+                #     img, "Path:{} \nIteration:{}".format(pathn_record_str, ii),
+                #     (10, 10), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 0, 0), 1)
+                img_array.append(img)
+
+            videoname = os.path.join(
+                cfg.experiment_dir, "video-avi",
+                "{}.avi".format(pathn_record_str))
+            check_and_create_dir(videoname)
+            out = cv2.VideoWriter(
+                videoname,
+                # cv2.VideoWriter_fourcc(*'mp4v'),
+                cv2.VideoWriter_fourcc(*'FFV1'),
+                20.0, (w, h))
+            for iii in range(len(img_array)):
+                out.write(img_array[iii])
+            out.release()
+            # shutil.rmtree(os.path.join(cfg.experiment_dir, "video-png"))
+
+    print("The last loss is: {}".format(loss.item()))
+
 
 if __name__ == "__main__":