Add files using upload-large-folder tool

external/Metric3D/training/mono/configs/test_configs_vit/ddad.vit.dpt.raft.py

@@ -0,0 +1,94 @@
+_base_=['../_base_/losses/all_losses.py',
+       '../_base_/models/encoder_decoder/dino_vit_large_reg.dpt_raft.py',
+
+       '../_base_/datasets/ddad.py',
+       '../_base_/datasets/_data_base_.py',
+
+       '../_base_/default_runtime.py',
+       '../_base_/schedules/schedule_1m.py'
+       ]
+
+import numpy as np
+
+model = dict(
+    decode_head=dict(
+        type='RAFTDepthNormalDPT5',
+        iters=8,
+        n_downsample=2,
+        detach=False,
+    )
+)
+
+# model settings
+find_unused_parameters = True
+
+
+
+# data configs, some similar data are merged together
+data_array = [
+    # group 1
+    [
+        dict(DDAD='DDAD_dataset'),
+    ],
+]
+data_basic=dict(
+    canonical_space = dict(
+        # img_size=(540, 960),
+        focal_length=1000.0,
+    ),
+    depth_range=(0,1),
+    depth_normalize=(0.1, 200),
+    crop_size = (1120, 2016),
+    clip_depth_range=(0.1, 200),
+    vit_size=(616,1064),
+) 
+
+
+test_metrics = ['abs_rel', 'rmse', 'silog', 'delta1', 'delta2', 'delta3']
+DDAD_dataset=dict(
+    data = dict(
+    test=dict(
+        anno_path='DDAD/annotations/test_annotations.json',
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='ResizeKeepRatio', 
+                    #    resize_size=(1216, 1952), #(544, 992), #
+                    #    resize_size=(560, 1008),
+                    #    resize_size=(840, 1512),
+                         resize_size=(616,1064),
+                       ignore_label=-1, 
+                       padding=[0,0,0]),
+                #   dict(type='ResizeKeepRatio',
+                #        resize_size=(1120, 2016),
+                #        ignore_label=-1, 
+                #        padding=[0,0,0],
+                #        keep_gt=True),
+                #   dict(type='RandomCrop',
+                #        crop_size=(0,0),
+                #        crop_type='center',
+                #        ignore_label=-1,
+                #        padding=[0,0,0]),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        sample_ratio = 1.0,
+        sample_size = 500,
+     ),
+    ))
+
+# DDAD_dataset=dict(
+#     data = dict(
+#     test=dict(
+#         anno_path='DDAD/annotations/test_annotations.json',
+#         pipeline=[dict(type='BGR2RGB'),
+#                   dict(type='KeepResizeCanoSize', 
+#                        resize_size=(640, 1088), #(1216, 1952), #(512, 960), #
+#                        ignore_label=-1, 
+#                        padding=[0, 0, 0]),
+#                   dict(type='ToTensor'),
+#                   dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+#                  ],
+#         sample_ratio = 1.0,
+#         sample_size = 80,
+#      ),
+#     ))

external/Metric3D/training/mono/configs/test_configs_vit/diode.vit.dpt.raft.py

@@ -0,0 +1,66 @@
+_base_=['../_base_/losses/all_losses.py',
+       '../_base_/models/encoder_decoder/dino_vit_large_reg.dpt_raft.py',
+
+       '../_base_/datasets/diode.py',
+       '../_base_/datasets/_data_base_.py',
+
+       '../_base_/default_runtime.py',
+       '../_base_/schedules/schedule_1m.py'
+       ]
+
+import numpy as np
+
+model=dict(
+    decode_head=dict(
+        type='RAFTDepthNormalDPT5',
+        iters=8,
+        n_downsample=2,
+        detach=False,
+    )
+)
+
+# model settings
+find_unused_parameters = True
+
+
+
+# data configs, some similar data are merged together
+data_array = [
+    # group 1
+    [
+        dict(DIODE='DIODE_dataset'),
+        #dict(DIODE_indoor='DIODE_dataset')
+        #dict(DIODE_outdoor='DIODE_dataset')
+    ],
+]
+data_basic=dict(
+    canonical_space = dict(
+        img_size=(540, 960),
+        focal_length=1000.0,
+    ),
+    depth_range=(0, 1),
+    depth_normalize=(0.1, 200),# (0.3, 160),
+    # crop_size = (512, 960),
+    clip_depth_range=(0.1, 150),
+) 
+
+
+
+# indoor (544, 928), outdoor: (768, 1088)
+test_metrics = ['abs_rel', 'rmse', 'silog', 'delta1', 'delta2', 'delta3',  'normal_median' , 'normal_mean', 'normal_rmse', 'normal_a1', 'normal_a2', 'normal_a3', 'normal_a4', 'normal_a5']
+DIODE_dataset=dict(
+    data = dict(
+    test=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='ResizeKeepRatio', 
+                       resize_size=(616, 1064), #(544, 992), #(768, 1088), #(768, 1120), # (768, 1216), #(768, 1024), # (768, 1216),  #(768, 1312), # 
+                       ignore_label=-1, 
+                       padding=[0,0,0]),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        sample_ratio = 1.0,
+        sample_size = -1,
+     ),
+    ))

external/Metric3D/training/mono/configs/test_configs_vit/eth3d.vit.dpt.raft.py

@@ -0,0 +1,70 @@
+_base_=['../_base_/losses/all_losses.py',
+       '../_base_/models/encoder_decoder/dino_vit_large_reg.dpt_raft.py',
+
+       '../_base_/datasets/eth3d.py',
+       '../_base_/datasets/_data_base_.py',
+
+       '../_base_/default_runtime.py',
+       '../_base_/schedules/schedule_1m.py'
+       ]
+
+import numpy as np
+
+model = dict(
+    decode_head=dict(
+        type='RAFTDepthNormalDPT5',
+        iters=8,
+        n_downsample=2,
+        detach=False,
+    )
+)
+
+# model settings
+find_unused_parameters = True
+
+
+
+# data configs, some similar data are merged together
+data_array = [
+    # group 1
+    [
+        dict(ETH3D='ETH3D_dataset'), #447.2w
+    ],
+]
+data_basic=dict(
+    canonical_space = dict(
+        # img_size=(540, 960),
+        focal_length=1000.0,
+    ),
+    depth_range=(0, 1),
+    depth_normalize=(0.1, 200),# (0.3, 160),
+    crop_size = (1120, 2016),
+    clip_depth_range=(0.1, 200),
+    vit_size=(616,1064),
+) 
+
+# indoor (544, 928), outdoor: (768, 1088)
+test_metrics = ['abs_rel', 'rmse', 'silog', 'delta1', 'delta2', 'delta3', 'normal_mean', 'normal_rmse', 'normal_a1']
+ETH3D_dataset=dict(
+    data = dict(
+    test=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='ResizeKeepRatio', 
+                    #    resize_size=(512, 512), #(768, 1088), #(768, 1120), # (768, 1216), #(768, 1024), # (768, 1216),  #(768, 1312), # (512, 512)
+                       resize_size=(616,1064),
+                    #    resize_size=(1120, 2016),
+                       ignore_label=-1, 
+                       padding=[0,0,0]),
+                #   dict(type='RandomCrop',
+                #        crop_size=(0,0),
+                #        crop_type='center',
+                #        ignore_label=-1,
+                #        padding=[0,0,0]),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        sample_ratio = 1.0,
+        sample_size = -1,
+     ),
+    ))

external/Metric3D/training/mono/configs/test_configs_vit/ibims.vit.dpt.raft.py

@@ -0,0 +1,71 @@
+_base_=['../_base_/losses/all_losses.py',
+       '../_base_/models/encoder_decoder/dino_vit_large_reg.dpt_raft.py',
+
+       '../_base_/datasets/ibims.py',
+       '../_base_/datasets/_data_base_.py',
+
+       '../_base_/default_runtime.py',
+       '../_base_/schedules/schedule_1m.py'
+       ]
+
+import numpy as np
+
+model = dict(
+    decode_head=dict(
+        type='RAFTDepthNormalDPT5',
+        iters=8,
+        n_downsample=2,
+        detach=False,
+    )
+)
+
+# model settings
+find_unused_parameters = True
+
+
+
+# data configs, some similar data are merged together
+data_array = [
+    # group 1
+    [
+        dict(IBIMS='IBIMS_dataset'), #447.2w
+    ],
+]
+data_basic=dict(
+    canonical_space = dict(
+        # img_size=(540, 960),
+        focal_length=1000.0,
+    ),
+    depth_range=(0, 1),
+    depth_normalize=(0.1, 200),# (0.3, 160),
+    crop_size = (1120, 2016),
+    clip_depth_range=(0.1, 10),
+    vit_size=(616,1064),
+) 
+clip_depth = True
+
+# indoor (544, 928), outdoor: (768, 1088)
+test_metrics = ['abs_rel', 'rmse', 'silog', 'delta1', 'delta2', 'delta3', 'normal_mean', 'normal_rmse', 'normal_a3', 'normal_a4', 'normal_a5', 'normal_median']
+IBIMS_dataset=dict(
+    data = dict(
+    test=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='ResizeKeepRatio', 
+                    #    resize_size=(512, 512), #(768, 1088), #(768, 1120), # (768, 1216), #(768, 1024), # (768, 1216),  #(768, 1312), # (512, 512)
+                       resize_size=(616,1064),
+                    #    resize_size=(1120, 2016),
+                       ignore_label=-1, 
+                       padding=[0,0,0]),
+                #   dict(type='RandomCrop',
+                #        crop_size=(0,0),
+                #        crop_type='center',
+                #        ignore_label=-1,
+                #        padding=[0,0,0]),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        sample_ratio = 1.0,
+        sample_size = -1,
+     ),
+    ))

external/Metric3D/training/mono/configs/test_configs_vit/kitti.vit.dpt.raft.py

@@ -0,0 +1,82 @@
+_base_=['../_base_/losses/all_losses.py',
+       '../_base_/models/encoder_decoder/dino_vit_large_reg.dpt_raft.py',
+
+       '../_base_/datasets/kitti.py',
+       '../_base_/datasets/_data_base_.py',
+
+       '../_base_/default_runtime.py',
+       '../_base_/schedules/schedule_1m.py'
+       ]
+
+import numpy as np
+
+model = dict(
+    decode_head=dict(
+        type='RAFTDepthNormalDPT5',
+        iters=8,
+        n_downsample=2,
+        detach=False,
+    )
+)
+
+# model settings
+find_unused_parameters = True
+
+
+
+# data configs, some similar data are merged together
+data_array = [
+    # group 1
+    [
+        dict(KITTI='KITTI_dataset'),
+    ],
+]
+data_basic=dict(
+    canonical_space = dict(
+        # img_size=(540, 960),
+        focal_length=1000.0,
+    ),
+    depth_range=(0,1),
+    depth_normalize=(0.1, 200),
+    crop_size = (1120, 2016),
+    clip_depth_range=(0.1, 80),
+    vit_size=(616,1064),
+) 
+
+clip_depth = True
+
+test_metrics = ['abs_rel', 'rmse', 'silog', 'delta1', 'delta2', 'delta3', 'rmse_log',
+    'log10']
+KITTI_dataset=dict(
+    data = dict(
+    test=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='ResizeKeepRatio', 
+                       resize_size=(616, 1064), #(416, 1248), #(480, 1216), #(512, 1088), #(512, 1312), #(480, 1248), # #
+                       ignore_label=-1, 
+                       padding=[0,0,0]),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        sample_ratio = 1.0,
+        sample_size = -1,
+     ),
+    ))
+
+# DDAD_dataset=dict(
+#     data = dict(
+#     test=dict(
+#         anno_path='DDAD/annotations/test_annotations.json',
+#         pipeline=[dict(type='BGR2RGB'),
+#                   dict(type='KeepResizeCanoSize', 
+#                        resize_size=(640, 1088), #(1216, 1952), #(512, 960), #
+#                        ignore_label=-1, 
+#                        padding=[0, 0, 0]),
+#                   dict(type='ToTensor'),
+#                   dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+#                  ],
+#         sample_ratio = 1.0,
+#         sample_size = 80,
+#      ),
+#     ))

external/Metric3D/training/mono/configs/test_configs_vit/nuscenes.vit.dpt.raft.py

@@ -0,0 +1,93 @@
+_base_=['../_base_/losses/all_losses.py',
+       '../_base_/models/encoder_decoder/dino_vit_large_reg.dpt_raft.py',
+
+       '../_base_/datasets/nuscenes.py',
+       '../_base_/datasets/_data_base_.py',
+
+       '../_base_/default_runtime.py',
+       '../_base_/schedules/schedule_1m.py'
+       ]
+
+import numpy as np
+
+model = dict(
+    decode_head=dict(
+        type='RAFTDepthNormalDPT5',
+        iters=8,
+        n_downsample=2,
+        detach=False,
+    )
+)
+
+# model settings
+find_unused_parameters = True
+
+
+
+# data configs, some similar data are merged together
+data_array = [
+    # group 1
+    [
+        dict(NuScenes='NuScenes_dataset'),
+    ],
+]
+data_basic=dict(
+    canonical_space = dict(
+        # img_size=(540, 960),
+        focal_length=1000.0,
+    ),
+    depth_range=(0,1),
+    depth_normalize=(0.1, 200),
+    crop_size = (1120, 2016),
+    clip_depth_range=(0.1, 200),
+    vit_size=(616,1064),
+) 
+
+
+test_metrics = ['abs_rel', 'rmse', 'silog', 'delta1', 'delta2', 'delta3']
+NuScenes_dataset=dict(
+    data = dict(
+    test=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='ResizeKeepRatio', 
+                    #    resize_size=(1216, 1952), #(544, 992), #
+                    #    resize_size=(560, 1008),
+                    #    resize_size=(840, 1512),
+                         resize_size=(616,1064),
+                       ignore_label=-1, 
+                       padding=[0,0,0]),
+                #   dict(type='ResizeKeepRatio',
+                #        resize_size=(1120, 2016),
+                #        ignore_label=-1, 
+                #        padding=[0,0,0],
+                #        keep_gt=True),
+                #   dict(type='RandomCrop',
+                #        crop_size=(0,0),
+                #        crop_type='center',
+                #        ignore_label=-1,
+                #        padding=[0,0,0]),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        sample_ratio = 1.0,
+        sample_size = 500,
+     ),
+    ))
+
+# DDAD_dataset=dict(
+#     data = dict(
+#     test=dict(
+#         anno_path='DDAD/annotations/test_annotations.json',
+#         pipeline=[dict(type='BGR2RGB'),
+#                   dict(type='KeepResizeCanoSize', 
+#                        resize_size=(640, 1088), #(1216, 1952), #(512, 960), #
+#                        ignore_label=-1, 
+#                        padding=[0, 0, 0]),
+#                   dict(type='ToTensor'),
+#                   dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+#                  ],
+#         sample_ratio = 1.0,
+#         sample_size = 80,
+#      ),
+#     ))

external/Metric3D/training/mono/configs/test_configs_vit/nyu.vit.dpt.raft.py

@@ -0,0 +1,64 @@
+_base_=['../_base_/losses/all_losses.py',
+       '../_base_/models/encoder_decoder/dino_vit_large_reg.dpt_raft.py',
+
+       '../_base_/datasets/nyu.py',
+       '../_base_/datasets/_data_base_.py',
+
+       '../_base_/default_runtime.py',
+       '../_base_/schedules/schedule_1m.py'
+       ]
+
+import numpy as np
+
+model = dict(
+    decode_head=dict(
+        type='RAFTDepthNormalDPT5',
+        iters=8,
+        n_downsample=2,
+        detach=False,
+    )
+)
+
+# model settings
+find_unused_parameters = True
+
+
+
+# data configs, some similar data are merged together
+data_array = [
+    # group 1
+    [
+        dict(NYU='NYU_dataset'),
+    ],
+]
+data_basic=dict(
+    canonical_space = dict(
+        # img_size=(540, 960),
+        focal_length=1000.0,
+    ),
+    depth_range=(0,1),
+    depth_normalize=(0.1, 200),
+    crop_size = (1120, 2016),
+    clip_depth_range=(0.1, 10),
+    vit_size=(616,1064),
+) 
+clip_depth = True
+
+
+test_metrics = ['abs_rel', 'rmse', 'silog', 'delta1', 'delta2', 'delta3', 'rmse_log', 'log10', 'normal_mean', 'normal_rmse', 'normal_median', 'normal_a3', 'normal_a4', 'normal_a5']
+NYU_dataset=dict(
+    data = dict(
+    test=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='ResizeKeepRatio', 
+                       resize_size=(616, 1064), #(544, 992), #(480, 1216), #(480, 640), #
+                       ignore_label=-1, 
+                       padding=[0,0,0]),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        sample_ratio = 1.0,
+        sample_size = -1, 
+     ),
+    ))

external/Metric3D/training/mono/configs/test_configs_vit/replica.vit.dpt.raft.py

@@ -0,0 +1,64 @@
+_base_=['../_base_/losses/all_losses.py',
+       '../_base_/models/encoder_decoder/dino_vit_large_reg.dpt_raft.py',
+
+       '../_base_/datasets/replica.py',
+       '../_base_/datasets/_data_base_.py',
+
+       '../_base_/default_runtime.py',
+       '../_base_/schedules/schedule_1m.py'
+       ]
+
+import numpy as np
+
+model=dict(
+    decode_head=dict(
+        type='RAFTDepthNormalDPT5',
+        iters=8,
+        n_downsample=2,
+        detach=False,
+    )
+)
+
+# model settings
+find_unused_parameters = True
+
+
+
+# data configs, some similar data are merged together
+data_array = [
+    # group 1
+    [
+         dict(Replica='Replica_dataset'), # 5.6w
+    ],
+]
+data_basic=dict(
+    canonical_space = dict(
+        img_size=(540, 960),
+        focal_length=1000.0,
+    ),
+    depth_range=(0, 1),
+    depth_normalize=(0.1, 200),# (0.3, 160),
+    # crop_size = (512, 960),
+    clip_depth_range=(0.1, 200),
+) 
+
+
+
+# indoor (544, 928), outdoor: (768, 1088)
+test_metrics = ['abs_rel', 'rmse', 'silog', 'delta1', 'delta2', 'delta3',  'normal_median' , 'normal_mean', 'normal_rmse', 'normal_a1', 'normal_a2', 'normal_a3', 'normal_a4', 'normal_a5']
+Replica_dataset=dict(
+    data = dict(
+    test=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='ResizeKeepRatio', 
+                       resize_size=(616, 1064), #(544, 992), #(768, 1088), #(768, 1120), # (768, 1216), #(768, 1024), # (768, 1216),  #(768, 1312), # 
+                       ignore_label=-1, 
+                       padding=[0,0,0]),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        sample_ratio = 1.0,
+        sample_size = -1,
+     ),
+    ))

external/Metric3D/training/mono/configs/test_configs_vit/scannet.vit.dpt.raft.py

@@ -0,0 +1,66 @@
+_base_=['../_base_/losses/all_losses.py',
+       '../_base_/models/encoder_decoder/dino_vit_large_reg.dpt_raft.py',
+
+        '../_base_/datasets/scannet.py',
+       '../_base_/datasets/scannet_all.py',
+       #'../_base_/datasets/_data_base_.py',
+
+       '../_base_/default_runtime.py',
+       '../_base_/schedules/schedule_1m.py'
+       ]
+
+import numpy as np
+
+model = dict(
+    decode_head=dict(
+        type='RAFTDepthNormalDPT5',
+        iters=8,
+        n_downsample=2,
+        detach=False,
+    )
+)
+
+# model settings
+find_unused_parameters = True
+
+
+
+# data configs, some similar data are merged together
+data_array = [
+    # group 1
+    [
+        #dict(ScanNet='ScanNet_dataset'),
+        dict(ScanNetAll='ScanNetAll_dataset')
+    ],
+]
+data_basic=dict(
+    canonical_space = dict(
+        # img_size=(540, 960),
+        focal_length=1000.0,
+    ),
+    depth_range=(0,1),
+    depth_normalize=(0.1, 200),
+    crop_size = (1120, 2016),
+    clip_depth_range=(0.1, 200),
+    vit_size=(616,1064),
+) 
+
+
+test_metrics = ['abs_rel', 'rmse', 'silog', 'delta1', 'delta2', 'delta3', 'rmse_log', 'log10', 'normal_mean', 'normal_rmse', 'normal_median', 'normal_a3', 'normal_a4', 'normal_a5']
+ScanNetAll_dataset=dict(
+#ScanNet_dataset=dict(
+    data = dict(
+    test=dict(
+        pipeline=[dict(type='BGR2RGB'),
+                  dict(type='LabelScaleCononical'),
+                  dict(type='ResizeKeepRatio', 
+                       resize_size=(616, 1064), #(544, 992), #(480, 1216), #(480, 640), #
+                       ignore_label=-1, 
+                       padding=[0,0,0]),
+                  dict(type='ToTensor'),
+                  dict(type='Normalize', mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]),
+                 ],
+        sample_ratio = 1.0,
+        sample_size = 500, 
+     ),
+    ))

external/Metric3D/training/mono/model/__base_model__.py

@@ -0,0 +1,288 @@
+import torch
+import torch.nn as nn
+from mono.utils.comm import get_func
+import numpy as np
+import torch.nn.functional as F
+
+
+class BaseDepthModel(nn.Module):
+    def __init__(self, cfg, criterions, **kwards):
+        super(BaseDepthModel, self).__init__()   
+        model_type = cfg.model.type
+        self.depth_model = get_func('mono.model.model_pipelines.' + model_type)(cfg)
+
+        self.criterions_main = criterions['decoder_losses'] if criterions and 'decoder_losses' in criterions else None
+        self.criterions_auxi = criterions['auxi_losses'] if criterions and 'auxi_losses' in criterions else None
+        self.criterions_pose = criterions['pose_losses'] if criterions and 'pose_losses' in criterions else None
+        self.criterions_gru = criterions['gru_losses'] if criterions and 'gru_losses' in criterions else None
+        try:
+            self.downsample = cfg.prediction_downsample
+        except:
+            self.downsample = None
+
+        self.training = True
+
+    def forward(self, data):
+        if self.downsample != None:
+            self.label_downsample(self.downsample, data)
+        
+        output = self.depth_model(**data)
+
+        losses_dict = {}
+        if self.training:
+            output.update(data)
+            losses_dict = self.get_loss(output)
+
+        if self.downsample != None:
+            self.pred_upsample(self.downsample, output)
+
+        return output['prediction'], losses_dict, output['confidence']
+    
+    def inference(self, data):
+        with torch.no_grad():
+            output = self.depth_model(**data)
+            output.update(data)
+
+        if self.downsample != None:
+            self.pred_upsample(self.downsample, output)
+
+            output['dataset'] = 'wild'
+        return output
+
+    def get_loss(self, paras):
+        losses_dict = {}
+        # Losses for training
+        if self.training:
+            # decode branch
+            losses_dict.update(self.compute_decoder_loss(paras))
+            # auxilary branch
+            losses_dict.update(self.compute_auxi_loss(paras))
+            # pose branch
+            losses_dict.update(self.compute_pose_loss(paras))
+            # GRU sequence branch
+            losses_dict.update(self.compute_gru_loss(paras))
+
+            total_loss = sum(losses_dict.values())
+            losses_dict['total_loss'] = total_loss
+        return losses_dict
+    
+    def compute_gru_loss(self, paras_):
+        losses_dict = {}
+        if self.criterions_gru is None or len(self.criterions_gru) == 0:
+            return losses_dict
+        paras = {k:v for k,v in paras_.items() if k!='prediction' and k!='prediction_normal'}
+        n_predictions = len(paras['predictions_list'])
+        for i, pre in enumerate(paras['predictions_list']):
+            if i == n_predictions-1:
+                break
+            #if i % 3 != 0:
+                #continue
+            if 'normal_out_list' in paras.keys():
+                pre_normal = paras['normal_out_list'][i]
+            else:
+                pre_normal = None
+            iter_dict = self.branch_loss(
+                prediction=pre,
+                prediction_normal=pre_normal,
+                criterions=self.criterions_gru,
+                branch=f'gru_{i}',
+                **paras
+            )
+            # We adjust the loss_gamma so it is consistent for any number of RAFT-Stereo iterations
+            adjusted_loss_gamma = 0.9**(15/(n_predictions - 1))
+            i_weight = adjusted_loss_gamma**(n_predictions - i - 1)
+            iter_dict = {k:v*i_weight for k,v in iter_dict.items()}
+            losses_dict.update(iter_dict)
+        return losses_dict
+
+    def compute_decoder_loss(self, paras):
+        losses_dict = {}
+        decode_losses_dict = self.branch_loss(
+            criterions=self.criterions_main, 
+            branch='decode',
+            **paras
+            )
+        return decode_losses_dict
+    
+    def compute_auxi_loss(self, paras):
+        losses_dict = {}
+        if len(self.criterions_auxi) == 0:
+            return losses_dict
+        args = dict(
+            target=paras['target'],
+            data_type=paras['data_type'],
+            sem_mask=paras['sem_mask'],
+        )
+        for i, auxi_logit in enumerate(paras['auxi_logit_list']): 
+            auxi_losses_dict = self.branch_loss(
+                prediction=paras['auxi_pred'][i],
+                criterions=self.criterions_auxi,
+                pred_logit=auxi_logit,     
+                branch=f'auxi_{i}',
+                **args
+                )
+            losses_dict.update(auxi_losses_dict)
+        return losses_dict
+    
+    def compute_pose_loss(self, paras):
+        losses_dict = {}
+        if self.criterions_pose is None or len(self.criterions_pose) == 0:
+            return losses_dict
+        # valid_flg = paras['tmpl_flg']
+        # if torch.sum(valid_flg) == 0:
+        #     return losses_dict
+        # else:
+        #     # sample valid batch
+        #     samples = {}
+        #     for k, v in paras.items():
+        #         if isinstance(v, torch.Tensor):
+        #             samples.update({k: v[valid_flg]})
+        #         elif isinstance(v, list) and isinstance(v[0], torch.Tensor):
+        #             samples.update({k: [i[valid_flg] for i in v]})
+        for loss_method in self.criterions_pose:
+            loss_tmp = loss_method(**paras)
+            losses_dict['pose_' + loss_method._get_name()] = loss_tmp
+        return losses_dict
+
+    def branch_loss(self, prediction, pred_logit, criterions, branch='decode', **kwargs):   
+        B, _, _, _ = prediction.shape
+        losses_dict = {}
+        args = dict(pred_logit=pred_logit)
+        
+        target = kwargs.pop('target')
+        args.update(kwargs)
+
+        # data type for each batch
+        batches_data_type = np.array(kwargs['data_type']) 
+        # batches_data_names = np.array(kwargs['dataset']) 
+
+        # resize the target
+        # if target.shape[2] != prediction.shape[2] and target.shape[3] != prediction.shape[3]:
+        #     _, _, H, W = prediction.shape
+        #     target = nn.functional.interpolate(target, (H,W), mode='nearest')
+
+        mask = target > 1e-8
+        for loss_method in criterions:
+            # sample batches, which satisfy the loss requirement for data types
+            new_mask = self.create_mask_as_loss(loss_method, mask, batches_data_type)
+
+            loss_tmp = loss_method(
+                prediction=prediction, 
+                target=target, 
+                mask=new_mask, 
+                **args)                
+            losses_dict[branch + '_' + loss_method._get_name()] = loss_tmp
+        return losses_dict
+    
+    def create_mask_as_loss(self, loss_method, mask, batches_data_type):
+        data_type_req = np.array(loss_method.data_type)[:, None]
+        batch_mask = torch.tensor(np.any(data_type_req == batches_data_type, axis=0), device="cuda") #torch.from_numpy(np.any(data_type_req == batches_data_type, axis=0)).cuda()
+        new_mask = mask * batch_mask[:, None, None, None]
+        return new_mask
+    
+    def label_downsample(self, downsample_factor, data_dict):
+        scale_factor = float(1.0 / downsample_factor)
+        downsample_target = F.interpolate(data_dict['target'], scale_factor=scale_factor)
+        downsample_stereo_depth = F.interpolate(data_dict['stereo_depth'], scale_factor=scale_factor)
+
+        data_dict['target'] = downsample_target
+        data_dict['stereo_depth'] = downsample_stereo_depth
+
+        return data_dict
+
+    def pred_upsample(self, downsample_factor, data_dict):
+        scale_factor = float(downsample_factor)
+        upsample_prediction = F.interpolate(data_dict['prediction'], scale_factor=scale_factor).detach()
+        upsample_confidence = F.interpolate(data_dict['confidence'], scale_factor=scale_factor).detach()
+
+        data_dict['prediction'] = upsample_prediction
+        data_dict['confidence'] = upsample_confidence
+
+        return data_dict
+
+
+
+
+    # def mask_batches(self, prediction, target, mask, batches_data_names, data_type_req):
+    #     """
+    #     Mask the data samples that satify the loss requirement.
+    #     Args:
+    #         data_type_req (str): the data type required by a loss. 
+    #         batches_data_names (list): the list of data types in a batch. 
+    #     """
+    #     batch_mask = np.any(data_type_req == batches_data_names, axis=0)
+    #     prediction = prediction[batch_mask]
+    #     target = target[batch_mask]
+    #     mask = mask[batch_mask]
+    #     return prediction, target, mask, batch_mask
+
+    # def update_mask_g8(self, target, mask,  prediction, batches_data_names, absRel=0.5):
+    #     data_type_req=np.array(['Golf8_others'])[:, None]
+        
+    #     pred, target, mask_sample, batch_mask = self.mask_batches(prediction, target, mask, batches_data_names, data_type_req)
+    #     if pred.numel() == 0:
+    #         return mask
+    #     scale_batch = []
+    #     for i in range(mask_sample.shape[0]):
+    #         scale = torch.median(target[mask_sample]) / (torch.median(pred[mask_sample]) + 1e-8)
+    #         abs_rel = torch.abs(pred[i:i+1, ...] * scale - target[i:i+1, ...]) / (pred[i:i+1, ...] * scale + 1e-6)
+    #         if target[i, ...][target[i, ...]>0].min() < 0.041:
+    #             mask_valid_i = ((abs_rel < absRel) | ((target[i:i+1, ...]<0.02) & (target[i:i+1, ...]>1e-6)))  & mask_sample[i:i+1, ...]
+    #         else:
+    #             mask_valid_i = mask_sample[i:i+1, ...]
+    #         mask_sample[i:i+1, ...] = mask_valid_i
+    #         # print(target.max(), target[target>0].min())
+    #         # self.visual_g8(target, mask_valid_i)
+    #     mask[batch_mask] = mask_sample
+    #     return mask
+    
+    # def update_mask_g8_v2(self, target, mask,  prediction, batches_data_names,):
+    #     data_type_req=np.array(['Golf8_others'])[:, None]
+        
+    #     pred, target, mask_sample, batch_mask = self.mask_batches(prediction, target, mask, batches_data_names, data_type_req)
+    #     if pred.numel() == 0:
+    #         return mask
+        
+    #     raw_invalid_mask = target < 1e-8
+    #     target[raw_invalid_mask] = 1e8
+    #     kernal = 31
+    #     pool = min_pool2d(target, kernal)
+    #     diff = target- pool
+    #     valid_mask = (diff < 0.02)  &  mask_sample & (target<0.3)
+    #     target_min = target.view(target.shape[0], -1).min(dim=1)[0]
+    #     w_close = target_min < 0.04
+    #     valid_mask[~w_close] = mask_sample[~w_close]
+    #     mask[batch_mask]= valid_mask
+
+    #     target[raw_invalid_mask] = -1
+    #     #self.visual_g8(target, mask[batch_mask])
+    #     return mask
+        
+    # def visual_g8(self, gt, mask):
+    #     import matplotlib.pyplot as plt
+    #     from mono.utils.transform import gray_to_colormap
+    #     gt = gt.cpu().numpy().squeeze()
+    #     mask = mask.cpu().numpy().squeeze()
+    #     if gt.ndim >2:
+    #         gt = gt[0, ...]
+    #         mask = mask[0, ...]
+    #     name = np.random.randint(1000000)
+    #     print(gt.max(), gt[gt>0].min(), name)
+    #     gt_filter = gt.copy()
+    #     gt_filter[~mask] = 0
+    #     out = np.concatenate([gt, gt_filter], axis=0)
+    #     out[out<0] = 0
+    #     o = gray_to_colormap(out)
+    #     o[out<1e-8]=0
+        
+    #     plt.imsave(f'./tmp/{name}.png', o)     
+        
+        
+        
+
+
+def min_pool2d(tensor, kernel, stride=1):
+    tensor = tensor * -1.0
+    tensor = F.max_pool2d(tensor, kernel, padding=kernel//2, stride=stride)
+    tensor = -1.0 * tensor
+    return tensor

external/Metric3D/training/mono/model/__init__.py

@@ -0,0 +1,6 @@
+from .monodepth_model import DepthModel
+from .criterion import build_criterions
+from .__base_model__ import BaseDepthModel
+
+
+__all__ = ['DepthModel', 'BaseDepthModel']

external/Metric3D/training/mono/model/backbones/ConvNeXt.py

@@ -0,0 +1,271 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from timm.models.layers import trunc_normal_, DropPath
+from timm.models.registry import register_model
+
+class Block(nn.Module):
+    r""" ConvNeXt Block. There are two equivalent implementations:
+    (1) DwConv -> LayerNorm (channels_first) -> 1x1 Conv -> GELU -> 1x1 Conv; all in (N, C, H, W)
+    (2) DwConv -> Permute to (N, H, W, C); LayerNorm (channels_last) -> Linear -> GELU -> Linear; Permute back
+    We use (2) as we find it slightly faster in PyTorch
+    
+    Args:
+        dim (int): Number of input channels.
+        drop_path (float): Stochastic depth rate. Default: 0.0
+        layer_scale_init_value (float): Init value for Layer Scale. Default: 1e-6.
+    """
+    def __init__(self, dim, drop_path=0., layer_scale_init_value=1e-6):
+        super().__init__()
+        self.dwconv = nn.Conv2d(dim, dim, kernel_size=7, padding=3, groups=dim) # depthwise conv
+        self.norm = LayerNorm(dim, eps=1e-6)
+        self.pwconv1 = nn.Linear(dim, 4 * dim) # pointwise/1x1 convs, implemented with linear layers
+        self.act = nn.GELU()
+        self.pwconv2 = nn.Linear(4 * dim, dim)
+        self.gamma = nn.Parameter(layer_scale_init_value * torch.ones((dim)), 
+                                    requires_grad=True) if layer_scale_init_value > 0 else None
+        self.drop_path = DropPath(drop_path) if drop_path > 0. else nn.Identity()
+
+    def forward(self, x):
+        input = x
+        x = self.dwconv(x)
+        x = x.permute(0, 2, 3, 1) # (N, C, H, W) -> (N, H, W, C)
+        x = self.norm(x)
+        x = self.pwconv1(x)
+        x = self.act(x)
+        x = self.pwconv2(x)
+        if self.gamma is not None:
+            x = self.gamma * x
+        x = x.permute(0, 3, 1, 2) # (N, H, W, C) -> (N, C, H, W)
+
+        x = input + self.drop_path(x)
+        return x
+
+class ConvNeXt(nn.Module):
+    r""" ConvNeXt
+        A PyTorch impl of : `A ConvNet for the 2020s`  -
+          https://arxiv.org/pdf/2201.03545.pdf
+    Args:
+        in_chans (int): Number of input image channels. Default: 3
+        num_classes (int): Number of classes for classification head. Default: 1000
+        depths (tuple(int)): Number of blocks at each stage. Default: [3, 3, 9, 3]
+        dims (int): Feature dimension at each stage. Default: [96, 192, 384, 768]
+        drop_path_rate (float): Stochastic depth rate. Default: 0.
+        layer_scale_init_value (float): Init value for Layer Scale. Default: 1e-6.
+        head_init_scale (float): Init scaling value for classifier weights and biases. Default: 1.
+    """
+    def __init__(self, in_chans=3, num_classes=1000, 
+                 depths=[3, 3, 9, 3], dims=[96, 192, 384, 768], drop_path_rate=0., 
+                 layer_scale_init_value=1e-6, head_init_scale=1.,
+                 **kwargs,):
+        super().__init__()
+
+        self.downsample_layers = nn.ModuleList() # stem and 3 intermediate downsampling conv layers
+        stem = nn.Sequential(
+            nn.Conv2d(in_chans, dims[0], kernel_size=4, stride=4),
+            LayerNorm(dims[0], eps=1e-6, data_format="channels_first")
+        )
+        self.downsample_layers.append(stem)
+        for i in range(3):
+            downsample_layer = nn.Sequential(
+                    LayerNorm(dims[i], eps=1e-6, data_format="channels_first"),
+                    nn.Conv2d(dims[i], dims[i+1], kernel_size=2, stride=2),
+            )
+            self.downsample_layers.append(downsample_layer)
+
+        self.stages = nn.ModuleList() # 4 feature resolution stages, each consisting of multiple residual blocks
+        dp_rates=[x.item() for x in torch.linspace(0, drop_path_rate, sum(depths))] 
+        cur = 0
+        for i in range(4):
+            stage = nn.Sequential(
+                *[Block(dim=dims[i], drop_path=dp_rates[cur + j], 
+                layer_scale_init_value=layer_scale_init_value) for j in range(depths[i])]
+            )
+            self.stages.append(stage)
+            cur += depths[i]
+
+        #self.norm = nn.LayerNorm(dims[-1], eps=1e-6) # final norm layer
+        #self.head = nn.Linear(dims[-1], num_classes)
+
+        self.apply(self._init_weights)
+        #self.head.weight.data.mul_(head_init_scale)
+        #self.head.bias.data.mul_(head_init_scale)
+
+    def _init_weights(self, m):
+        if isinstance(m, (nn.Conv2d, nn.Linear)):
+            trunc_normal_(m.weight, std=.02)
+            nn.init.constant_(m.bias, 0)
+
+    def forward_features(self, x):
+        features = []
+        for i in range(4):
+            x = self.downsample_layers[i](x)
+            x = self.stages[i](x)
+            features.append(x)
+        return features # global average pooling, (N, C, H, W) -> (N, C)
+
+    def forward(self, x):
+        #x = self.forward_features(x)
+        #x = self.head(x)
+        features = self.forward_features(x)
+        return features
+
+class LayerNorm(nn.Module):
+    r""" LayerNorm that supports two data formats: channels_last (default) or channels_first. 
+    The ordering of the dimensions in the inputs. channels_last corresponds to inputs with 
+    shape (batch_size, height, width, channels) while channels_first corresponds to inputs 
+    with shape (batch_size, channels, height, width).
+    """
+    def __init__(self, normalized_shape, eps=1e-6, data_format="channels_last"):
+        super().__init__()
+        self.weight = nn.Parameter(torch.ones(normalized_shape))
+        self.bias = nn.Parameter(torch.zeros(normalized_shape))
+        self.eps = eps
+        self.data_format = data_format
+        if self.data_format not in ["channels_last", "channels_first"]:
+            raise NotImplementedError 
+        self.normalized_shape = (normalized_shape, )
+    
+    def forward(self, x):
+        if self.data_format == "channels_last":
+            return F.layer_norm(x, self.normalized_shape, self.weight, self.bias, self.eps)
+        elif self.data_format == "channels_first":
+            u = x.mean(1, keepdim=True)
+            s = (x - u).pow(2).mean(1, keepdim=True)
+            x = (x - u) / torch.sqrt(s + self.eps)
+            x = self.weight[:, None, None] * x + self.bias[:, None, None]
+            return x
+
+
+model_urls = {
+    "convnext_tiny_1k": "https://dl.fbaipublicfiles.com/convnext/convnext_tiny_1k_224_ema.pth",
+    "convnext_small_1k": "https://dl.fbaipublicfiles.com/convnext/convnext_small_1k_224_ema.pth",
+    "convnext_base_1k": "https://dl.fbaipublicfiles.com/convnext/convnext_base_1k_224_ema.pth",
+    "convnext_large_1k": "https://dl.fbaipublicfiles.com/convnext/convnext_large_1k_224_ema.pth",
+    "convnext_tiny_22k": "https://dl.fbaipublicfiles.com/convnext/convnext_tiny_22k_224.pth",
+    "convnext_small_22k": "https://dl.fbaipublicfiles.com/convnext/convnext_small_22k_224.pth",
+    "convnext_base_22k": "https://dl.fbaipublicfiles.com/convnext/convnext_base_22k_224.pth",
+    "convnext_large_22k": "https://dl.fbaipublicfiles.com/convnext/convnext_large_22k_224.pth",
+    "convnext_xlarge_22k": "https://dl.fbaipublicfiles.com/convnext/convnext_xlarge_22k_224.pth",
+}
+
+def convnext_tiny(pretrained=True,in_22k=False, **kwargs):
+    model = ConvNeXt(depths=[3, 3, 9, 3], dims=[96, 192, 384, 768], **kwargs)
+    if pretrained:
+        checkpoint = torch.load(kwargs['checkpoint'], map_location="cpu")
+        #url = model_urls['convnext_tiny_22k'] if in_22k else model_urls['convnext_tiny_1k']
+        #checkpoint = torch.hub.load_state_dict_from_url(url=url, map_location="cpu", check_hash=True)
+        model_dict = model.state_dict()
+        pretrained_dict = {}
+        unmatched_pretrained_dict = {}
+        for k, v in checkpoint['model'].items():
+            if k in model_dict:
+                pretrained_dict[k] = v
+            else:
+                unmatched_pretrained_dict[k] = v
+        model_dict.update(pretrained_dict)
+        model.load_state_dict(model_dict)
+        print(
+            'Successfully loaded pretrained %d paras, and %d paras are unmatched.' 
+            %(len(pretrained_dict.keys()), len(unmatched_pretrained_dict.keys())))
+        print('Unmatched pretrained paras are:', unmatched_pretrained_dict.keys())
+    return model
+
+def convnext_small(pretrained=True,in_22k=False, **kwargs):
+    model = ConvNeXt(depths=[3, 3, 27, 3], dims=[96, 192, 384, 768], **kwargs)
+    if pretrained:
+        checkpoint = torch.load(kwargs['checkpoint'], map_location="cpu")
+        #url = model_urls['convnext_small_22k'] if in_22k else model_urls['convnext_small_1k']
+        #checkpoint = torch.hub.load_state_dict_from_url(url=url, map_location="cpu")
+        model_dict = model.state_dict()        
+        pretrained_dict = {}
+        unmatched_pretrained_dict = {}
+        for k, v in checkpoint['model'].items():
+            if k in model_dict:
+                pretrained_dict[k] = v
+            else:
+                unmatched_pretrained_dict[k] = v
+        model_dict.update(pretrained_dict)
+        model.load_state_dict(model_dict)
+        print(
+            'Successfully loaded pretrained %d paras, and %d paras are unmatched.' 
+            %(len(pretrained_dict.keys()), len(unmatched_pretrained_dict.keys())))
+        print('Unmatched pretrained paras are:', unmatched_pretrained_dict.keys())
+    return model
+
+def convnext_base(pretrained=True, in_22k=False, **kwargs):
+    model = ConvNeXt(depths=[3, 3, 27, 3], dims=[128, 256, 512, 1024], **kwargs)
+    if pretrained:
+        checkpoint = torch.load(kwargs['checkpoint'], map_location="cpu")
+        #url = model_urls['convnext_base_22k'] if in_22k else model_urls['convnext_base_1k']
+        #checkpoint = torch.hub.load_state_dict_from_url(url=url, map_location="cpu")
+        model_dict = model.state_dict()
+        pretrained_dict = {}
+        unmatched_pretrained_dict = {}
+        for k, v in checkpoint['model'].items():
+            if k in model_dict:
+                pretrained_dict[k] = v
+            else:
+                unmatched_pretrained_dict[k] = v
+        model_dict.update(pretrained_dict)
+        model.load_state_dict(model_dict)
+        print(
+            'Successfully loaded pretrained %d paras, and %d paras are unmatched.' 
+            %(len(pretrained_dict.keys()), len(unmatched_pretrained_dict.keys())))
+        print('Unmatched pretrained paras are:', unmatched_pretrained_dict.keys())
+    return model
+
+def convnext_large(pretrained=True, in_22k=False, **kwargs):
+    model = ConvNeXt(depths=[3, 3, 27, 3], dims=[192, 384, 768, 1536], **kwargs)
+    if pretrained:
+        checkpoint = torch.load(kwargs['checkpoint'], map_location="cpu")
+        #url = model_urls['convnext_large_22k'] if in_22k else model_urls['convnext_large_1k']
+        #checkpoint = torch.hub.load_state_dict_from_url(url=url, map_location="cpu")
+        model_dict = model.state_dict()
+        pretrained_dict = {}
+        unmatched_pretrained_dict = {}
+        for k, v in checkpoint['model'].items():
+            if k in model_dict:
+                pretrained_dict[k] = v
+            else:
+                unmatched_pretrained_dict[k] = v
+        model_dict.update(pretrained_dict)
+        model.load_state_dict(model_dict)
+        print(
+            'Successfully loaded pretrained %d paras, and %d paras are unmatched.' 
+            %(len(pretrained_dict.keys()), len(unmatched_pretrained_dict.keys())))
+        print('Unmatched pretrained paras are:', unmatched_pretrained_dict.keys())
+    return model
+
+def convnext_xlarge(pretrained=True, in_22k=False, **kwargs):
+    model = ConvNeXt(depths=[3, 3, 27, 3], dims=[256, 512, 1024, 2048], **kwargs)
+    if pretrained:
+        assert in_22k, "only ImageNet-22K pre-trained ConvNeXt-XL is available; please set in_22k=True"
+        checkpoint = torch.load(kwargs['checkpoint'], map_location="cpu")
+        #url = model_urls['convnext_xlarge_22k']
+        #checkpoint = torch.hub.load_state_dict_from_url(url=url, map_location="cpu")
+        model_dict = model.state_dict()
+        pretrained_dict = {}
+        unmatched_pretrained_dict = {}
+        for k, v in checkpoint['model'].items():
+            if k in model_dict:
+                pretrained_dict[k] = v
+            else:
+                unmatched_pretrained_dict[k] = v
+        model_dict.update(pretrained_dict)
+        model.load_state_dict(model_dict)
+        print(
+            'Successfully loaded pretrained %d paras, and %d paras are unmatched.' 
+            %(len(pretrained_dict.keys()), len(unmatched_pretrained_dict.keys())))
+        print('Unmatched pretrained paras are:', unmatched_pretrained_dict.keys())
+    return model
+
+if __name__ == '__main__':
+    import torch
+    model = convnext_base(True, in_22k=False).cuda()
+
+    rgb = torch.rand((2, 3, 256, 256)).cuda()
+    out = model(rgb)
+    print(len(out))
+    for i, ft in enumerate(out):
+        print(i, ft.shape)

external/Metric3D/training/mono/model/backbones/ViT_DINO.py

@@ -0,0 +1,1504 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the license found in the
+# LICENSE file in the root directory of this source tree.
+
+# References:
+#   https://github.com/facebookresearch/dino/blob/main/vision_transformer.py
+#   https://github.com/rwightman/pytorch-image-models/tree/master/timm/models/vision_transformer.py
+
+from functools import partial
+import math
+import logging
+from typing import Sequence, Tuple, Union, Callable, Optional, Dict, Any, List
+
+import torch
+import torch.nn as nn
+from torch import Tensor
+import torch.utils.checkpoint
+from torch.nn.init import trunc_normal_
+
+#from dinov2.layers import Mlp, PatchEmbed, SwiGLUFFNFused, MemEffAttention, NestedTensorBlock as Block
+
+logger = logging.getLogger("dinov2")
+
+class ConvBlock(nn.Module):
+    def __init__(self, channels):
+        super(ConvBlock, self).__init__()
+
+        self.act = nn.ReLU(inplace=True)
+        self.conv1 = nn.Conv2d(
+            channels,
+            channels,
+            kernel_size=3,
+            stride=1,
+            padding=1
+        )
+        self.norm1 = nn.BatchNorm2d(channels)
+        self.conv2 = nn.Conv2d(
+            channels,
+            channels,
+            kernel_size=3,
+            stride=1,
+            padding=1
+        )
+        self.norm2 = nn.BatchNorm2d(channels)
+
+    def forward(self, x):
+
+        out = self.norm1(x)
+        out = self.act(out)
+        out = self.conv1(out)
+        out = self.norm2(out)
+        out = self.act(out)
+        out = self.conv2(out)
+        return x + out
+
+def make_2tuple(x):
+    if isinstance(x, tuple):
+        assert len(x) == 2
+        return x
+
+    assert isinstance(x, int)
+    return (x, x)
+
+def drop_path(x, drop_prob: float = 0.0, training: bool = False):
+    if drop_prob == 0.0 or not training:
+        return x
+    keep_prob = 1 - drop_prob
+    shape = (x.shape[0],) + (1,) * (x.ndim - 1)  # work with diff dim tensors, not just 2D ConvNets
+    random_tensor = x.new_empty(shape).bernoulli_(keep_prob)
+    if keep_prob > 0.0:
+        random_tensor.div_(keep_prob)
+    output = x * random_tensor
+    return output
+
+class DropPath(nn.Module):
+    """Drop paths (Stochastic Depth) per sample (when applied in main path of residual blocks)."""
+
+    def __init__(self, drop_prob=None):
+        super(DropPath, self).__init__()
+        self.drop_prob = drop_prob
+
+    def forward(self, x):
+        return drop_path(x, self.drop_prob, self.training)
+
+class LayerScale(nn.Module):
+    def __init__(
+        self,
+        dim: int,
+        init_values: Union[float, Tensor] = 1e-5,
+        inplace: bool = False,
+    ) -> None:
+        super().__init__()
+        self.inplace = inplace
+        self.gamma = nn.Parameter(init_values * torch.ones(dim))
+
+    def forward(self, x: Tensor) -> Tensor:
+        return x.mul_(self.gamma) if self.inplace else x * self.gamma
+
+
+class PatchEmbed(nn.Module):
+    """
+    2D image to patch embedding: (B,C,H,W) -> (B,N,D)
+
+    Args:
+        img_size: Image size.
+        patch_size: Patch token size.
+        in_chans: Number of input image channels.
+        embed_dim: Number of linear projection output channels.
+        norm_layer: Normalization layer.
+    """
+
+    def __init__(
+        self,
+        img_size: Union[int, Tuple[int, int]] = 224,
+        patch_size: Union[int, Tuple[int, int]] = 16,
+        in_chans: int = 3,
+        embed_dim: int = 768,
+        norm_layer: Optional[Callable] = None,
+        flatten_embedding: bool = True,
+    ) -> None:
+        super().__init__()
+
+        image_HW = make_2tuple(img_size)
+        patch_HW = make_2tuple(patch_size)
+        patch_grid_size = (
+            image_HW[0] // patch_HW[0],
+            image_HW[1] // patch_HW[1],
+        )
+
+        self.img_size = image_HW
+        self.patch_size = patch_HW
+        self.patches_resolution = patch_grid_size
+        self.num_patches = patch_grid_size[0] * patch_grid_size[1]
+
+        self.in_chans = in_chans
+        self.embed_dim = embed_dim
+
+        self.flatten_embedding = flatten_embedding
+
+        self.proj = nn.Conv2d(in_chans, embed_dim, kernel_size=patch_HW, stride=patch_HW)
+        self.norm = norm_layer(embed_dim) if norm_layer else nn.Identity()
+
+    def forward(self, x: Tensor) -> Tensor:
+        _, _, H, W = x.shape
+        patch_H, patch_W = self.patch_size
+
+        assert H % patch_H == 0, f"Input image height {H} is not a multiple of patch height {patch_H}"
+        assert W % patch_W == 0, f"Input image width {W} is not a multiple of patch width: {patch_W}"
+
+        x = self.proj(x)  # B C H W
+        H, W = x.size(2), x.size(3)
+        x = x.flatten(2).transpose(1, 2)  # B HW C
+        x = self.norm(x)
+        if not self.flatten_embedding:
+            x = x.reshape(-1, H, W, self.embed_dim)  # B H W C
+        return x
+
+    def flops(self) -> float:
+        Ho, Wo = self.patches_resolution
+        flops = Ho * Wo * self.embed_dim * self.in_chans * (self.patch_size[0] * self.patch_size[1])
+        if self.norm is not None:
+            flops += Ho * Wo * self.embed_dim
+        return flops
+
+class Mlp(nn.Module):
+    def __init__(
+        self,
+        in_features: int,
+        hidden_features: Optional[int] = None,
+        out_features: Optional[int] = None,
+        act_layer: Callable[..., nn.Module] = nn.GELU,
+        drop: float = 0.0,
+        bias: bool = True,
+    ) -> None:
+        super().__init__()
+        out_features = out_features or in_features
+        hidden_features = hidden_features or in_features
+        self.fc1 = nn.Linear(in_features, hidden_features, bias=bias)
+        self.act = act_layer()
+        self.fc2 = nn.Linear(hidden_features, out_features, bias=bias)
+        self.drop = nn.Dropout(drop)
+
+    def forward(self, x: Tensor) -> Tensor:
+        x = self.fc1(x)
+        x = self.act(x)
+        x = self.drop(x)
+        x = self.fc2(x)
+        x = self.drop(x)
+        return x
+
+
+class SwiGLUFFN(nn.Module):
+    def __init__(
+        self,
+        in_features: int,
+        hidden_features: Optional[int] = None,
+        out_features: Optional[int] = None,
+        act_layer: Callable[..., nn.Module] = None,
+        drop: float = 0.0,
+        bias: bool = True,
+    ) -> None:
+        super().__init__()
+        out_features = out_features or in_features
+        hidden_features = hidden_features or in_features
+        self.w12 = nn.Linear(in_features, 2 * hidden_features, bias=bias)
+        self.w3 = nn.Linear(hidden_features, out_features, bias=bias)
+
+    def forward(self, x: Tensor) -> Tensor:
+        x12 = self.w12(x)
+        x1, x2 = x12.chunk(2, dim=-1)
+        hidden = F.silu(x1) * x2
+        return self.w3(hidden)
+
+
+try:
+    from xformers.ops import SwiGLU
+    #import numpy.bool
+    XFORMERS_AVAILABLE = True
+except ImportError:
+    SwiGLU = SwiGLUFFN
+    XFORMERS_AVAILABLE = False
+
+class SwiGLUFFNFused(SwiGLU):
+    def __init__(
+        self,
+        in_features: int,
+        hidden_features: Optional[int] = None,
+        out_features: Optional[int] = None,
+        act_layer: Callable[..., nn.Module] = None,
+        drop: float = 0.0,
+        bias: bool = True,
+    ) -> None:
+        out_features = out_features or in_features
+        hidden_features = hidden_features or in_features
+        hidden_features = (int(hidden_features * 2 / 3) + 7) // 8 * 8
+        super().__init__(
+            in_features=in_features,
+            hidden_features=hidden_features,
+            out_features=out_features,
+            bias=bias,
+        )
+
+
+try:
+    from xformers.ops import memory_efficient_attention, unbind, fmha
+    from xformers.components.attention import ScaledDotProduct
+    from xformers.components import MultiHeadDispatch
+    #import numpy.bool
+    XFORMERS_AVAILABLE = True
+except ImportError:
+    logger.warning("xFormers not available")
+    XFORMERS_AVAILABLE = False
+
+
+class Attention(nn.Module):
+    def __init__(
+        self,
+        dim: int,
+        num_heads: int = 8,
+        qkv_bias: bool = False,
+        proj_bias: bool = True,
+        attn_drop: float = 0.0,
+        proj_drop: float = 0.0,
+        window_size: int = 0,
+    ) -> None:
+        super().__init__()
+        self.num_heads = num_heads
+        head_dim = dim // num_heads
+        self.scale = head_dim**-0.5
+
+        self.qkv = nn.Linear(dim, dim * 3, bias=qkv_bias)
+        self.attn_drop = nn.Dropout(attn_drop)
+        self.proj = nn.Linear(dim, dim, bias=proj_bias)
+        self.proj_drop = nn.Dropout(proj_drop)
+        
+        #if not self.training:
+        #
+        # self.attn = ScaledDotProduct()
+            #self.attn = MultiHeadDispatch(dim_model=EMB, residual_dropout=DROPOUT, num_heads=HEADS, attention=attn)
+
+    def forward(self, x: Tensor, attn_bias=None) -> Tensor:
+        B, N, C = x.shape
+        qkv = self.qkv(x).reshape(B, N, 3, self.num_heads, C // self.num_heads).permute(2, 0, 3, 1, 4)
+
+        q, k, v = qkv[0] * self.scale, qkv[1], qkv[2]
+        attn = q @ k.transpose(-2, -1)
+
+        if attn_bias is not None:
+            attn = attn + attn_bias[:, :, :N]
+
+        attn = attn.softmax(dim=-1)
+        attn = self.attn_drop(attn)
+
+        x = (attn @ v).transpose(1, 2).reshape(B, N, C)
+        x = self.proj(x)
+        x = self.proj_drop(x)
+        return x
+
+
+class MemEffAttention(Attention):
+    def forward(self, x: Tensor, attn_bias=None) -> Tensor:
+        if not XFORMERS_AVAILABLE:
+        #if True:
+            assert attn_bias is None, "xFormers is required for nested tensors usage"
+            return super().forward(x, attn_bias)
+
+        B, N, C = x.shape
+        qkv = self.qkv(x).reshape(B, N, 3, self.num_heads, C // self.num_heads)
+
+        q, k, v = unbind(qkv, 2)
+        if attn_bias is not None:
+            x = memory_efficient_attention(q, k, v, attn_bias=attn_bias[:, :, :N])
+        else:
+            x = memory_efficient_attention(q, k, v)
+        x = x.reshape([B, N, C])
+
+        x = self.proj(x)
+        x = self.proj_drop(x)
+        return x
+
+try:
+    from xformers.ops import fmha
+    from xformers.ops import scaled_index_add, index_select_cat
+    #import numpy.bool
+    XFORMERS_AVAILABLE = True
+except ImportError:
+    logger.warning("xFormers not available")
+    XFORMERS_AVAILABLE = False
+
+class Block(nn.Module):
+    def __init__(
+        self,
+        dim: int,
+        num_heads: int,
+        mlp_ratio: float = 4.0,
+        qkv_bias: bool = False,
+        proj_bias: bool = True,
+        ffn_bias: bool = True,
+        drop: float = 0.0,
+        attn_drop: float = 0.0,
+        init_values = None,
+        drop_path: float = 0.0,
+        act_layer: Callable[..., nn.Module] = nn.GELU,
+        norm_layer: Callable[..., nn.Module] = nn.LayerNorm,
+        attn_class: Callable[..., nn.Module] = Attention,
+        ffn_layer: Callable[..., nn.Module] = Mlp,
+    ) -> None:
+        super().__init__()
+        # print(f"biases: qkv: {qkv_bias}, proj: {proj_bias}, ffn: {ffn_bias}")
+        self.norm1 = norm_layer(dim)
+        self.attn = attn_class(
+            dim,
+            num_heads=num_heads,
+            qkv_bias=qkv_bias,
+            proj_bias=proj_bias,
+            attn_drop=attn_drop,
+            proj_drop=drop,
+        )
+        self.ls1 = LayerScale(dim, init_values=init_values) if init_values else nn.Identity()
+        self.drop_path1 = DropPath(drop_path) if drop_path > 0.0 else nn.Identity()
+
+        self.norm2 = norm_layer(dim)
+        mlp_hidden_dim = int(dim * mlp_ratio)
+        self.mlp = ffn_layer(
+            in_features=dim,
+            hidden_features=mlp_hidden_dim,
+            act_layer=act_layer,
+            drop=drop,
+            bias=ffn_bias,
+        )
+        self.ls2 = LayerScale(dim, init_values=init_values) if init_values else nn.Identity()
+        self.drop_path2 = DropPath(drop_path) if drop_path > 0.0 else nn.Identity()
+
+        self.sample_drop_ratio = drop_path
+
+    def forward(self, x: Tensor, attn_bias=None) -> Tensor:
+        def attn_residual_func(x: Tensor, attn_bias) -> Tensor:
+            return self.ls1(self.attn(self.norm1(x), attn_bias))
+
+        def ffn_residual_func(x: Tensor) -> Tensor:
+            return self.ls2(self.mlp(self.norm2(x)))
+
+        if self.training and self.sample_drop_ratio > 0.1:
+            # the overhead is compensated only for a drop path rate larger than 0.1
+            x = drop_add_residual_stochastic_depth(
+                x,
+                residual_func=attn_residual_func,
+                sample_drop_ratio=self.sample_drop_ratio,
+                attn_bias=attn_bias
+            )
+            x = drop_add_residual_stochastic_depth(
+                x,
+                residual_func=ffn_residual_func,
+                sample_drop_ratio=self.sample_drop_ratio,
+            )
+        elif self.training and self.sample_drop_ratio > 0.0:
+            x = x + self.drop_path1(attn_residual_func(x, attn_bias))
+            x = x + self.drop_path1(ffn_residual_func(x))  # FIXME: drop_path2
+        else:
+            x = x + attn_residual_func(x, attn_bias)
+            x = x + ffn_residual_func(x)
+        return x
+
+
+def drop_add_residual_stochastic_depth(
+    x: Tensor,
+    residual_func: Callable[[Tensor], Tensor],
+    sample_drop_ratio: float = 0.0, attn_bias=None
+) -> Tensor:
+    # 1) extract subset using permutation
+    b, n, d = x.shape
+    sample_subset_size = max(int(b * (1 - sample_drop_ratio)), 1)
+    brange = (torch.randperm(b, device=x.device))[:sample_subset_size]
+    x_subset = x[brange]
+
+    # 2) apply residual_func to get residual
+    residual = residual_func(x_subset, attn_bias)
+
+    x_flat = x.flatten(1)
+    residual = residual.flatten(1)
+
+    residual_scale_factor = b / sample_subset_size
+
+    # 3) add the residual
+    x_plus_residual = torch.index_add(x_flat, 0, brange, residual.to(dtype=x.dtype), alpha=residual_scale_factor)
+    return x_plus_residual.view_as(x)
+
+
+def get_branges_scales(x, sample_drop_ratio=0.0):
+    b, n, d = x.shape
+    sample_subset_size = max(int(b * (1 - sample_drop_ratio)), 1)
+    brange = (torch.randperm(b, device=x.device))[:sample_subset_size]
+    residual_scale_factor = b / sample_subset_size
+    return brange, residual_scale_factor
+
+
+def add_residual(x, brange, residual, residual_scale_factor, scaling_vector=None):
+    if scaling_vector is None:
+        x_flat = x.flatten(1)
+        residual = residual.flatten(1)
+        x_plus_residual = torch.index_add(x_flat, 0, brange, residual.to(dtype=x.dtype), alpha=residual_scale_factor)
+    else:
+        x_plus_residual = scaled_index_add(
+            x, brange, residual.to(dtype=x.dtype), scaling=scaling_vector, alpha=residual_scale_factor
+        )
+    return x_plus_residual
+
+
+attn_bias_cache: Dict[Tuple, Any] = {}
+
+
+def get_attn_bias_and_cat(x_list, branges=None):
+    """
+    this will perform the index select, cat the tensors, and provide the attn_bias from cache
+    """
+    batch_sizes = [b.shape[0] for b in branges] if branges is not None else [x.shape[0] for x in x_list]
+    all_shapes = tuple((b, x.shape[1]) for b, x in zip(batch_sizes, x_list))
+    if all_shapes not in attn_bias_cache.keys():
+        seqlens = []
+        for b, x in zip(batch_sizes, x_list):
+            for _ in range(b):
+                seqlens.append(x.shape[1])
+        attn_bias = fmha.BlockDiagonalMask.from_seqlens(seqlens)
+        attn_bias._batch_sizes = batch_sizes
+        attn_bias_cache[all_shapes] = attn_bias
+
+    if branges is not None:
+        cat_tensors = index_select_cat([x.flatten(1) for x in x_list], branges).view(1, -1, x_list[0].shape[-1])
+    else:
+        tensors_bs1 = tuple(x.reshape([1, -1, *x.shape[2:]]) for x in x_list)
+        cat_tensors = torch.cat(tensors_bs1, dim=1)
+
+    return attn_bias_cache[all_shapes], cat_tensors
+
+
+def drop_add_residual_stochastic_depth_list(
+    x_list: List[Tensor],
+    residual_func: Callable[[Tensor, Any], Tensor],
+    sample_drop_ratio: float = 0.0,
+    scaling_vector=None,
+) -> Tensor:
+    # 1) generate random set of indices for dropping samples in the batch
+    branges_scales = [get_branges_scales(x, sample_drop_ratio=sample_drop_ratio) for x in x_list]
+    branges = [s[0] for s in branges_scales]
+    residual_scale_factors = [s[1] for s in branges_scales]
+
+    # 2) get attention bias and index+concat the tensors
+    attn_bias, x_cat = get_attn_bias_and_cat(x_list, branges)
+
+    # 3) apply residual_func to get residual, and split the result
+    residual_list = attn_bias.split(residual_func(x_cat, attn_bias=attn_bias))  # type: ignore
+
+    outputs = []
+    for x, brange, residual, residual_scale_factor in zip(x_list, branges, residual_list, residual_scale_factors):
+        outputs.append(add_residual(x, brange, residual, residual_scale_factor, scaling_vector).view_as(x))
+    return outputs
+
+
+class NestedTensorBlock(Block):
+    def forward_nested(self, x_list: List[Tensor]) -> List[Tensor]:
+        """
+        x_list contains a list of tensors to nest together and run
+        """
+        assert isinstance(self.attn, MemEffAttention)
+
+        if self.training and self.sample_drop_ratio > 0.0:
+
+            def attn_residual_func(x: Tensor, attn_bias=None) -> Tensor:
+                return self.attn(self.norm1(x), attn_bias=attn_bias)
+
+            def ffn_residual_func(x: Tensor, attn_bias=None) -> Tensor:
+                return self.mlp(self.norm2(x))
+
+            x_list = drop_add_residual_stochastic_depth_list(
+                x_list,
+                residual_func=attn_residual_func,
+                sample_drop_ratio=self.sample_drop_ratio,
+                scaling_vector=self.ls1.gamma if isinstance(self.ls1, LayerScale) else None,
+            )
+            x_list = drop_add_residual_stochastic_depth_list(
+                x_list,
+                residual_func=ffn_residual_func,
+                sample_drop_ratio=self.sample_drop_ratio,
+                scaling_vector=self.ls2.gamma if isinstance(self.ls1, LayerScale) else None,
+            )
+            return x_list
+        else:
+
+            def attn_residual_func(x: Tensor, attn_bias=None) -> Tensor:
+                return self.ls1(self.attn(self.norm1(x), attn_bias=attn_bias))
+
+            def ffn_residual_func(x: Tensor, attn_bias=None) -> Tensor:
+                return self.ls2(self.mlp(self.norm2(x)))
+
+            attn_bias, x = get_attn_bias_and_cat(x_list)
+            x = x + attn_residual_func(x, attn_bias=attn_bias)
+            x = x + ffn_residual_func(x)
+            return attn_bias.split(x)
+
+    def forward(self, x_or_x_list, attn_bias=None):
+        if isinstance(x_or_x_list, Tensor):
+            return super().forward(x_or_x_list, attn_bias)
+        elif isinstance(x_or_x_list, list):
+            assert XFORMERS_AVAILABLE, "Please install xFormers for nested tensors usage"
+            return self.forward_nested(x_or_x_list)
+        else:
+            raise AssertionError
+
+
+def named_apply(fn: Callable, module: nn.Module, name="", depth_first=True, include_root=False) -> nn.Module:
+    if not depth_first and include_root:
+        fn(module=module, name=name)
+    for child_name, child_module in module.named_children():
+        child_name = ".".join((name, child_name)) if name else child_name
+        named_apply(fn=fn, module=child_module, name=child_name, depth_first=depth_first, include_root=True)
+    if depth_first and include_root:
+        fn(module=module, name=name)
+    return module
+
+
+class BlockChunk(nn.ModuleList):
+    def forward(self, x, others=None):
+        for b in self:
+            if others == None:
+                x = b(x)
+            else:
+                x = b(x, others)
+        return x
+
+
+class DinoVisionTransformer(nn.Module):
+    def __init__(
+        self,
+        img_size=224,
+        patch_size=16,
+        in_chans=3,
+        embed_dim=768,
+        depth=12,
+        num_heads=12,
+        mlp_ratio=4.0,
+        qkv_bias=True,
+        ffn_bias=True,
+        proj_bias=True,
+        drop_path_rate=0.0,
+        drop_path_uniform=False,
+        #init_values=None,  # for layerscale: None or 0 => no layerscale
+        init_values=1e-5,  # for layerscale: None or 0 => no layerscale
+        embed_layer=PatchEmbed,
+        act_layer=nn.GELU,
+        block_fn=NestedTensorBlock,
+        ffn_layer="mlp",
+        block_chunks=1,
+        window_size=37,
+        **kwargs
+    ):
+        """
+        Args:
+            img_size (int, tuple): input image size
+            patch_size (int, tuple): patch size
+            in_chans (int): number of input channels
+            embed_dim (int): embedding dimension
+            depth (int): depth of transformer
+            num_heads (int): number of attention heads
+            mlp_ratio (int): ratio of mlp hidden dim to embedding dim
+            qkv_bias (bool): enable bias for qkv if True
+            proj_bias (bool): enable bias for proj in attn if True
+            ffn_bias (bool): enable bias for ffn if True
+            drop_path_rate (float): stochastic depth rate
+            drop_path_uniform (bool): apply uniform drop rate across blocks
+            weight_init (str): weight init scheme
+            init_values (float): layer-scale init values
+            embed_layer (nn.Module): patch embedding layer
+            act_layer (nn.Module): MLP activation layer
+            block_fn (nn.Module): transformer block class
+            ffn_layer (str): "mlp", "swiglu", "swiglufused" or "identity"
+            block_chunks: (int) split block sequence into block_chunks units for FSDP wrap
+        """
+        super().__init__()
+        norm_layer = partial(nn.LayerNorm, eps=1e-6)
+
+        self.num_features = self.embed_dim = embed_dim  # num_features for consistency with other models
+        self.num_tokens = 1
+        self.n_blocks = depth
+        self.num_heads = num_heads
+        self.patch_size = patch_size
+        self.window_size = window_size
+
+        self.patch_embed = embed_layer(img_size=img_size, patch_size=patch_size, in_chans=in_chans, embed_dim=embed_dim)
+        num_patches = self.patch_embed.num_patches
+
+        self.cls_token = nn.Parameter(torch.zeros(1, 1, embed_dim))
+        self.pos_embed = nn.Parameter(torch.zeros(1, num_patches + self.num_tokens, embed_dim))
+
+        if drop_path_uniform is True:
+            dpr = [drop_path_rate] * depth
+        else:
+            dpr = [x.item() for x in torch.linspace(0, drop_path_rate, depth)]  # stochastic depth decay rule
+
+        if ffn_layer == "mlp":
+            logger.info("using MLP layer as FFN")
+            ffn_layer = Mlp
+        elif ffn_layer == "swiglufused" or ffn_layer == "swiglu":
+            logger.info("using SwiGLU layer as FFN")
+            ffn_layer = SwiGLUFFNFused
+        elif ffn_layer == "identity":
+            logger.info("using Identity layer as FFN")
+
+            def f(*args, **kwargs):
+                return nn.Identity()
+
+            ffn_layer = f
+        else:
+            raise NotImplementedError
+
+        blocks_list = [
+            block_fn(
+                dim=embed_dim,
+                num_heads=num_heads,
+                mlp_ratio=mlp_ratio,
+                qkv_bias=qkv_bias,
+                proj_bias=proj_bias,
+                ffn_bias=ffn_bias,
+                drop_path=dpr[i],
+                norm_layer=norm_layer,
+                act_layer=act_layer,
+                ffn_layer=ffn_layer,
+                init_values=init_values,
+            )
+            for i in range(depth)
+        ]
+        if block_chunks > 0:
+            self.chunked_blocks = True
+            chunked_blocks = []
+            chunksize = depth // block_chunks
+            for i in range(0, depth, chunksize):
+                # this is to keep the block index consistent if we chunk the block list
+                chunked_blocks.append([nn.Identity()] * i + blocks_list[i : i + chunksize])
+            self.blocks = nn.ModuleList([BlockChunk(p) for p in chunked_blocks])
+        else:
+            self.chunked_blocks = False
+            self.blocks = nn.ModuleList(blocks_list)
+
+        self.norm = norm_layer(embed_dim)
+        self.head = nn.Identity()
+
+        self.mask_token = nn.Parameter(torch.zeros(1, embed_dim))
+
+        self.init_weights()
+
+    def init_weights(self):
+        trunc_normal_(self.pos_embed, std=0.02)
+        nn.init.normal_(self.cls_token, std=1e-6)
+        named_apply(init_weights_vit_timm, self)
+
+    def interpolate_pos_encoding(self, x, w, h):
+        previous_dtype = x.dtype
+        npatch = x.shape[1] - 1
+        N = self.pos_embed.shape[1] - 1
+        if npatch == N and w == h:
+            return self.pos_embed
+        pos_embed = self.pos_embed.float()
+        class_pos_embed = pos_embed[:, 0]
+        patch_pos_embed = pos_embed[:, 1:]
+        dim = x.shape[-1]
+        w0 = w // self.patch_size
+        h0 = h // self.patch_size
+        # we add a small number to avoid floating point error in the interpolation
+        # see discussion at https://github.com/facebookresearch/dino/issues/8
+        w0, h0 = w0 + 0.1, h0 + 0.1
+
+        patch_pos_embed = nn.functional.interpolate(
+            patch_pos_embed.reshape(1, int(math.sqrt(N)), int(math.sqrt(N)), dim).permute(0, 3, 1, 2),
+            scale_factor=(w0 / math.sqrt(N), h0 / math.sqrt(N)),
+            mode="bicubic",
+        )
+
+        assert int(w0) == patch_pos_embed.shape[-2] and int(h0) == patch_pos_embed.shape[-1]
+        patch_pos_embed = patch_pos_embed.permute(0, 2, 3, 1).view(1, -1, dim)
+        return torch.cat((class_pos_embed.unsqueeze(0), patch_pos_embed), dim=1).to(previous_dtype)
+
+    def prepare_tokens_with_masks(self, x, masks=None):
+        B, nc, w, h = x.shape
+        x = self.patch_embed(x)
+        if masks is not None:
+            x = torch.where(masks.unsqueeze(-1), self.mask_token.to(x.dtype).unsqueeze(0), x)
+
+        x = torch.cat((self.cls_token.expand(x.shape[0], -1, -1), x), dim=1)
+        x = x + self.interpolate_pos_encoding(x, w, h)
+
+        return x
+
+    def forward_features_list(self, x_list, masks_list):
+        x = [self.prepare_tokens_with_masks(x, masks) for x, masks in zip(x_list, masks_list)]
+        for blk in self.blocks:
+            x = blk(x)
+
+        all_x = x
+        output = []
+        for x, masks in zip(all_x, masks_list):
+            x_norm = self.norm(x)
+            output.append(
+                {
+                    "x_norm_clstoken": x_norm[:, 0],
+                    "x_norm_patchtokens": x_norm[:, 1:],
+                    "x_prenorm": x,
+                    "masks": masks,
+                }
+            )
+        return output
+
+    def forward_features(self, x, masks=None):
+        if isinstance(x, list):
+            return self.forward_features_list(x, masks)
+
+        B, C, H, W = x.size()
+        pad_h = (self.patch_size - H % self.patch_size)
+        pad_w = (self.patch_size - W % self.patch_size)
+        if pad_h == self.patch_size:
+            pad_h = 0
+        if pad_w == self.patch_size:
+            pad_w = 0     
+        #x = nn.functional.pad(x, (pad_h//2, pad_h-pad_h//2, pad_w//2, pad_w-pad_w//2))
+        if pad_h + pad_w > 0:
+            x = torch.nn.functional.interpolate(x, (H+pad_h, W+pad_w), mode='bilinear')
+
+        x = self.prepare_tokens_with_masks(x, masks)
+
+        features = []
+        for blk in self.blocks:
+            x = blk(x)
+        # for idx in range(len(self.blocks[0])):
+        #     x = self.blocks[0][idx](x)
+        #     if (idx + 1) % (len(self.blocks[0]) // 4) == 0:
+        #         features.append(x)
+
+        #return [features, (B, (H+pad_h)//self.patch_size, (W+pad_w)//self.patch_size, H, W)]
+
+        x_norm = self.norm(x)
+        # return {
+        #     "x_norm_clstoken": x_norm[:, 0],
+        #     "x_norm_patchtokens": x_norm[:, 1:],
+        #     "x_prenorm": x,
+        #     "masks": masks,
+        # }
+        features = []
+        features.append(x_norm)
+        features.append(x_norm)
+        features.append(x_norm)
+        features.append(x_norm)
+        return [features, (B, (H+pad_h)//self.patch_size, (W+pad_w)//self.patch_size, H, W)]
+
+    def _get_intermediate_layers_not_chunked(self, x, n=1):
+        x = self.prepare_tokens_with_masks(x)
+        # If n is an int, take the n last blocks. If it's a list, take them
+        output, total_block_len = [], len(self.blocks)
+        blocks_to_take = range(total_block_len - n, total_block_len) if isinstance(n, int) else n
+        for i, blk in enumerate(self.blocks):
+            x = blk(x)
+            if i in blocks_to_take:
+                output.append(x)
+        assert len(output) == len(blocks_to_take), f"only {len(output)} / {len(blocks_to_take)} blocks found"
+        return output
+
+    def _get_intermediate_layers_chunked(self, x, n=1):
+        x = self.prepare_tokens_with_masks(x)
+        output, i, total_block_len = [], 0, len(self.blocks[-1])
+        # If n is an int, take the n last blocks. If it's a list, take them
+        blocks_to_take = range(total_block_len - n, total_block_len) if isinstance(n, int) else n
+        for block_chunk in self.blocks:
+            for blk in block_chunk[i:]:  # Passing the nn.Identity()
+                x = blk(x)
+                if i in blocks_to_take:
+                    output.append(x)
+                i += 1
+        assert len(output) == len(blocks_to_take), f"only {len(output)} / {len(blocks_to_take)} blocks found"
+        return output
+
+    def get_intermediate_layers(
+        self,
+        x: torch.Tensor,
+        n: Union[int, Sequence] = 1,  # Layers or n last layers to take
+        reshape: bool = False,
+        return_class_token: bool = False,
+        norm=True,
+    ) -> Tuple[Union[torch.Tensor, Tuple[torch.Tensor]]]:
+        if self.chunked_blocks:
+            outputs = self._get_intermediate_layers_chunked(x, n)
+        else:
+            outputs = self._get_intermediate_layers_not_chunked(x, n)
+        if norm:
+            outputs = [self.norm(out) for out in outputs]
+        class_tokens = [out[:, 0] for out in outputs]
+        outputs = [out[:, 1:] for out in outputs]
+        if reshape:
+            B, _, w, h = x.shape
+            outputs = [
+                out.reshape(B, w // self.patch_size, h // self.patch_size, -1).permute(0, 3, 1, 2).contiguous()
+                for out in outputs
+            ]
+        if return_class_token:
+            return tuple(zip(outputs, class_tokens))
+        return tuple(outputs)
+
+    def forward(self, *args, is_training=False, **kwargs):
+        ret = self.forward_features(*args, **kwargs)
+        return ret
+        # if is_training:
+        #     return ret
+        # else:
+        #     return self.head(ret["x_norm_clstoken"])
+
+
+class PosConv(nn.Module):
+    # PEG  from https://arxiv.org/abs/2102.10882
+    def __init__(self, in_chans, embed_dim=768, stride=1):
+        super(PosConv, self).__init__()
+        self.proj = nn.Sequential(
+            nn.Conv2d(in_chans, embed_dim, 37, stride, 18, bias=True, groups=embed_dim),
+        )
+        self.stride = stride
+
+    def forward(self, x, size):
+        B, N, C = x.shape
+        cnn_feat_token = x.transpose(1, 2).view(B, C, *size)
+        x = self.proj(cnn_feat_token)
+        if self.stride == 1:
+            x += cnn_feat_token
+        x = x.flatten(2).transpose(1, 2)
+        return x
+
+    #def no_weight_decay(self):
+        #return ['proj.%d.weight' % i for i in range(4)]
+
+class DinoWindowVisionTransformer(nn.Module):
+    def __init__(
+        self,
+        img_size=224,
+        patch_size=16,
+        in_chans=3,
+        embed_dim=768,
+        depth=12,
+        num_heads=12,
+        mlp_ratio=4.0,
+        qkv_bias=True,
+        ffn_bias=True,
+        proj_bias=True,
+        drop_path_rate=0.0,
+        drop_path_uniform=False,
+        #init_values=None,  # for layerscale: None or 0 => no layerscale
+        init_values=1e-5,  # for layerscale: None or 0 => no layerscale
+        embed_layer=PatchEmbed,
+        act_layer=nn.GELU,
+        block_fn=NestedTensorBlock,
+        ffn_layer="mlp",
+        block_chunks=1,
+        window_size=7,
+        **kwargs
+    ):
+        """
+        Args:
+            img_size (int, tuple): input image size
+            patch_size (int, tuple): patch size
+            in_chans (int): number of input channels
+            embed_dim (int): embedding dimension
+            depth (int): depth of transformer
+            num_heads (int): number of attention heads
+            mlp_ratio (int): ratio of mlp hidden dim to embedding dim
+            qkv_bias (bool): enable bias for qkv if True
+            proj_bias (bool): enable bias for proj in attn if True
+            ffn_bias (bool): enable bias for ffn if True
+            drop_path_rate (float): stochastic depth rate
+            drop_path_uniform (bool): apply uniform drop rate across blocks
+            weight_init (str): weight init scheme
+            init_values (float): layer-scale init values
+            embed_layer (nn.Module): patch embedding layer
+            act_layer (nn.Module): MLP activation layer
+            block_fn (nn.Module): transformer block class
+            ffn_layer (str): "mlp", "swiglu", "swiglufused" or "identity"
+            block_chunks: (int) split block sequence into block_chunks units for FSDP wrap
+        """
+        super().__init__()
+        norm_layer = partial(nn.LayerNorm, eps=1e-6)
+
+        self.num_features = self.embed_dim = embed_dim  # num_features for consistency with other models
+        self.num_tokens = 1
+        self.n_blocks = depth
+        self.num_heads = num_heads
+        self.patch_size = patch_size
+
+        self.patch_embed = embed_layer(img_size=img_size, patch_size=patch_size, in_chans=in_chans, embed_dim=embed_dim)
+        num_patches = self.patch_embed.num_patches
+
+        #self.cls_token = nn.Parameter(torch.zeros(1, 1, embed_dim))
+        #self.pos_embed = nn.Parameter(torch.zeros(1, num_patches + self.num_tokens, embed_dim))
+        self.pos_embed = nn.Parameter(torch.zeros(1, num_patches, embed_dim))
+        
+        self.pos_conv = PosConv(self.embed_dim, self.embed_dim)
+
+        self.window_size = window_size
+        #self.conv_block = nn.ModuleList([ConvBlock(embed_dim) for i in range(4)])
+        #self.conv_block = nn.ModuleList([nn.Identity() for i in range(4)])
+
+        if drop_path_uniform is True:
+            dpr = [drop_path_rate] * depth
+        else:
+            dpr = [x.item() for x in torch.linspace(0, drop_path_rate, depth)]  # stochastic depth decay rule
+
+        if ffn_layer == "mlp":
+            logger.info("using MLP layer as FFN")
+            ffn_layer = Mlp
+        elif ffn_layer == "swiglufused" or ffn_layer == "swiglu":
+            logger.info("using SwiGLU layer as FFN")
+            ffn_layer = SwiGLUFFNFused
+        elif ffn_layer == "identity":
+            logger.info("using Identity layer as FFN")
+
+            def f(*args, **kwargs):
+                return nn.Identity()
+
+            ffn_layer = f
+        else:
+            raise NotImplementedError
+
+        blocks_list = [
+            block_fn(
+                dim=embed_dim,
+                num_heads=num_heads,
+                mlp_ratio=mlp_ratio,
+                qkv_bias=qkv_bias,
+                proj_bias=proj_bias,
+                ffn_bias=ffn_bias,
+                drop_path=dpr[i],
+                norm_layer=norm_layer,
+                act_layer=act_layer,
+                ffn_layer=ffn_layer,
+                init_values=init_values,
+            )
+            for i in range(depth)
+        ]
+        if block_chunks > 0:
+            self.chunked_blocks = True
+            chunked_blocks = []
+            chunksize = depth // block_chunks
+            for i in range(0, depth, chunksize):
+                # this is to keep the block index consistent if we chunk the block list
+                chunked_blocks.append([nn.Identity()] * i + blocks_list[i : i + chunksize])
+            self.blocks = nn.ModuleList([BlockChunk(p) for p in chunked_blocks])
+        else:
+            self.chunked_blocks = False
+            self.blocks = nn.ModuleList(blocks_list)
+
+        self.norm = norm_layer(embed_dim)
+        self.head = nn.Identity()
+
+        self.mask_token = nn.Parameter(torch.zeros(1, embed_dim))
+
+        self.nh = -1
+        self.nw = -1
+        try:
+            H = cfg.data_basic['crop_size'][0] 
+            W = cfg.data_basic['crop_size'][1] 
+            pad_h = (self.patch_size - H % self.patch_size)
+            pad_w = (self.patch_size - W % self.patch_size)
+            if pad_h == self.patch_size:
+                pad_h = 0
+            if pad_w == self.patch_size:
+                pad_w = 0   
+            self.nh = (H + pad_h) // self.patch_size
+            self.nw = (W + pad_w) // self.patch_size
+            self.prepare_attn_bias((self.nh, self.nw))
+        except:
+            pass
+        self.init_weights()
+
+        self.total_step = 10000 # For PE -> GPE transfer
+        self.start_step = 2000
+        self.current_step = 20000
+
+    def init_weights(self):
+        #trunc_normal_(self.pos_embed, std=0.02)
+        #nn.init.normal_(self.cls_token, std=1e-6)
+        named_apply(init_weights_vit_timm, self)
+        for i in range(4):
+            try:
+                nn.init.constant_(self.conv_block[i].conv2.weight, 0.0)
+            except:
+                pass
+
+    def interpolate_pos_encoding(self, x, w, h):
+        previous_dtype = x.dtype
+        #npatch = x.shape[1] - 1
+        #N = self.pos_embed.shape[1] - 1
+        npatch = x.shape[1]
+        N = self.pos_embed.shape[1]
+        if npatch == N and w == h:
+            return self.pos_embed
+        pos_embed = self.pos_embed.float()
+        #class_pos_embed = pos_embed[:, 0]
+        #patch_pos_embed = pos_embed[:, 1:]
+        patch_pos_embed = pos_embed
+        dim = x.shape[-1]
+        w0 = w // self.patch_size
+        h0 = h // self.patch_size
+        # we add a small number to avoid floating point error in the interpolation
+        # see discussion at https://github.com/facebookresearch/dino/issues/8
+        w0, h0 = w0 + 0.1, h0 + 0.1
+
+        patch_pos_embed = nn.functional.interpolate(
+            patch_pos_embed.reshape(1, int(math.sqrt(N)), int(math.sqrt(N)), dim).permute(0, 3, 1, 2),
+            scale_factor=(w0 / math.sqrt(N), h0 / math.sqrt(N)),
+            mode="bicubic",
+        )
+
+        assert int(w0) == patch_pos_embed.shape[-2] and int(h0) == patch_pos_embed.shape[-1]
+        patch_pos_embed = patch_pos_embed.permute(0, 2, 3, 1).view(1, -1, dim)
+        return patch_pos_embed.to(previous_dtype)
+        #return torch.cat((class_pos_embed.unsqueeze(0), patch_pos_embed), dim=1).to(previous_dtype)
+
+    def window_partition(self, x: torch.Tensor, window_size: int, hw: Tuple[int, int], conv_feature=False) -> Tuple[torch.Tensor, Tuple[int, int]]:
+        """
+        Partition into non-overlapping windows with padding if needed.
+        Args:
+            x (tensor): input tokens with [B, H, W, C].
+            window_size (int): window size.
+
+        Returns:
+            windows: windows after partition with [B * num_windows, window_size, window_size, C].
+            (Hp, Wp): padded height and width before partition
+        """
+        if conv_feature == False:
+            B, N, C = x.shape
+            H, W = hw[0], hw[1]
+
+            x = x.view(B, H // window_size, window_size, W // window_size, window_size, C)
+
+            windows = x.permute(0, 1, 3, 2, 4, 5).contiguous().view(-1, window_size * window_size, C)
+        else:
+            B, C, H, W = x.shape
+
+            x = x.view(B, C, H // window_size, window_size, W // window_size, window_size)
+
+            windows = x.permute(0, 2, 4, 3, 5, 1).contiguous().view(-1, window_size * window_size, C)            
+
+        #y = torch.cat((x_cls, windows), dim=1)
+        return windows   #, (Hp, Wp)
+
+
+    def window_unpartition(self, 
+        windows: torch.Tensor, window_size: int, hw: Tuple[int, int], conv_feature=False
+    ) -> torch.Tensor:
+        """
+        Window unpartition into original sequences and removing padding.
+        Args:
+            windows (tensor): input tokens with [B * num_windows, window_size, window_size, C].
+            window_size (int): window size.
+            pad_hw (Tuple): padded height and width (Hp, Wp).
+            hw (Tuple): original height and width (H, W) before padding.
+
+        Returns:
+            x: unpartitioned sequences with [B, H, W, C].
+        """
+        H, W = hw
+
+        B = windows.shape[0] // (H * W // window_size // window_size)
+        x = windows.view(B, H // window_size, W // window_size, window_size, window_size, -1)
+
+        if conv_feature == False:
+            x = x.permute(0, 1, 3, 2, 4, 5).contiguous().view(B, Hp * Wp, -1)
+        else:
+            C = windows.shape[-1]
+            x = x.permute(0, 5, 1, 3, 2, 4).contiguous().view(B, C, H, W)
+
+        # if Hp > H or Wp > W:
+        #     x = x[:, :H, :W, :].contiguous()
+        return x
+
+    def prepare_tokens_with_masks(self, x, masks=None, step=-1):
+        B, nc, w, h = x.shape
+        x = self.patch_embed(x)
+        if masks is not None:
+            x = torch.where(masks.unsqueeze(-1), self.mask_token.to(x.dtype).unsqueeze(0), x)
+
+        #x = torch.cat((self.cls_token.expand(x.shape[0], -1, -1), x), dim=1)
+        if step == -1:
+            step = self.current_step
+        else:
+            self.current_step = step
+        
+        if step < self.start_step:
+            coef = 0.0
+        elif step < self.total_step:
+            coef = (step - self.start_step) / (self.total_step - self.start_step) 
+        else:
+            coef = 1.0
+        
+        x = x + (1 - coef) * self.interpolate_pos_encoding(x, w, h) + coef * self.pos_conv(x, (self.nh, self.nw))
+
+        return x
+
+    def prepare_attn_bias(self, shape):
+        window_size = self.window_size
+        if window_size <= 0:
+            return
+        
+        import xformers.components.attention.attention_patterns as AP
+        
+        nh, nw = shape
+        radius = (window_size-1)//2 
+        mask_ori = AP.local_2d_pattern(nh, nw, distance = radius + 0.1, p=torch.inf).cuda()
+        
+        pad = (8 - (nh * nw) % 8)
+        if pad == 8:
+            pad = 0
+        mask_pad = nn.functional.pad(mask_ori, (0, pad)).contiguous()
+        if pad > 0:
+            mask = mask_pad[:, :-pad].view(nh, nw, nh, nw)
+        else:
+            mask = mask_pad[:, :].view(nh, nw, nh, nw)
+        
+        # angle
+        mask[:radius+1,  :radius+1,  :window_size,  :window_size] = True
+        mask[:radius+1,  -radius-1:, :window_size,  -window_size:] = True
+        mask[-radius-1:, :radius+1,  -window_size:, :window_size] = True
+        mask[-radius-1:, -radius-1:, -window_size:, -window_size:] = True
+
+        # edge
+        mask[radius+1:-radius-1,  :radius+1,  :,  :] = mask[radius+1:-radius-1,  radius:radius+1,    :,  :]
+        mask[radius+1:-radius-1,  -radius-1:, :,  :] = mask[radius+1:-radius-1,  -radius-1:-radius,  :,  :]
+        mask[:radius+1,   radius+1:-radius-1, :,  :] = mask[radius:radius+1,   radius+1:-radius-1,   :,  :]
+        mask[-radius-1:,  radius+1:-radius-1, :,  :] = mask[-radius-1:-radius, radius+1:-radius-1,   :,  :]
+
+        mask = mask.view(nh*nw, nh*nw)
+        bias_pad = torch.log(mask_pad)
+        #bias = bias_pad[:, :-pad]
+        self.register_buffer('attn_bias', bias_pad)
+
+        return bias_pad
+
+    def forward_features_list(self, x_list, masks_list):
+        x = [self.prepare_tokens_with_masks(x, masks) for x, masks in zip(x_list, masks_list)]
+        for blk in self.blocks:
+            x = blk(x)
+
+        all_x = x
+        output = []
+        for x, masks in zip(all_x, masks_list):
+            x_norm = self.norm(x)
+            output.append(
+                {
+                    "x_norm_clstoken": x_norm[:, 0],
+                    "x_norm_patchtokens": x_norm[:, 1:],
+                    "x_prenorm": x,
+                    "masks": masks,
+                }
+            )
+        return output
+
+    def forward_features(self, x, masks=None, **kwargs):
+        if isinstance(x, list):
+            return self.forward_features_list(x, masks)
+
+        B, C, H, W = x.size()
+        pad_h = (self.patch_size - H % self.patch_size)
+        pad_w = (self.patch_size - W % self.patch_size)
+        if pad_h == self.patch_size:
+            pad_h = 0
+        if pad_w == self.patch_size:
+            pad_w = 0     
+        #x = nn.functional.pad(x, (pad_h//2, pad_h-pad_h//2, pad_w//2, pad_w-pad_w//2))
+        if pad_h + pad_w > 0:
+            x = torch.nn.functional.interpolate(x, (H+pad_h, W+pad_w), mode='bilinear')
+        
+        nh = (H+pad_h)//self.patch_size
+        nw = (W+pad_w)//self.patch_size
+
+        if self.window_size > 0:
+            if nh == self.nh and nw == self.nw:
+                attn_bias = self.attn_bias
+            else:
+                attn_bias = self.prepare_attn_bias(((H+pad_h)//self.patch_size, (W+pad_w)//self.patch_size))   
+                self.nh = nh
+                self.nw = nw 
+            attn_bias = attn_bias.unsqueeze(0).repeat(B * self.num_heads, 1, 1)
+        else:
+            attn_bias = None
+
+        x = self.prepare_tokens_with_masks(x, masks)
+        #x = self.patch_embed(x)
+
+        features = []
+        #x = self.window_partition(x, self.window_size, (H // self.patch_size, W // self.patch_size))
+        for blk in self.blocks:
+            x = blk(x, attn_bias)
+        #x = self.window_unpartition(x, self.window_size, (H // self.patch_size, W // self.patch_size))
+
+        # for idx in range(len(self.blocks[0])):
+        #     x = self.blocks[0][idx](x, attn_bias)
+
+        #     if (idx + 1) % (len(self.blocks[0]) // 4) == 0:
+        #         x = self.window_unpartition(x, self.window_size, (H // self.patch_size, W // self.patch_size), conv_feature=True)
+        #         x = self.conv_block[idx // (len(self.blocks[0]) // 4)](x)
+        #         if idx + 1 != len(self.blocks[0]):
+        #             x = self.window_partition(x, self.window_size, (H // self.patch_size, W // self.patch_size), conv_feature=True)
+        #         else:
+        #             b, c, h, w = x.size()
+        #             x = x.permute(0, 2, 3, 1).contiguous().view(b, h, w, c)
+                #features.append(x)
+
+        #return [features, (B, (H+pad_h)//self.patch_size, (W+pad_w)//self.patch_size, H, W)]
+
+        x_norm = self.norm(x)
+        # return {
+        #     "x_norm_clstoken": x_norm[:, 0],
+        #     "x_norm_patchtokens": x_norm[:, 1:],
+        #     "x_prenorm": x,
+        #     "masks": masks,
+        # }
+        features = []
+        features.append(x_norm)
+        features.append(x_norm)
+        features.append(x_norm)
+        features.append(x_norm)
+        return [features, (B, (H+pad_h)//self.patch_size, (W+pad_w)//self.patch_size, H, W)]
+
+    def _get_intermediate_layers_not_chunked(self, x, n=1):
+        x = self.prepare_tokens_with_masks(x)
+        # If n is an int, take the n last blocks. If it's a list, take them
+        output, total_block_len = [], len(self.blocks)
+        blocks_to_take = range(total_block_len - n, total_block_len) if isinstance(n, int) else n
+        for i, blk in enumerate(self.blocks):
+            x = blk(x)
+            if i in blocks_to_take:
+                output.append(x)
+        assert len(output) == len(blocks_to_take), f"only {len(output)} / {len(blocks_to_take)} blocks found"
+        return output
+
+    def _get_intermediate_layers_chunked(self, x, n=1):
+        x = self.prepare_tokens_with_masks(x)
+        output, i, total_block_len = [], 0, len(self.blocks[-1])
+        # If n is an int, take the n last blocks. If it's a list, take them
+        blocks_to_take = range(total_block_len - n, total_block_len) if isinstance(n, int) else n
+        for block_chunk in self.blocks:
+            for blk in block_chunk[i:]:  # Passing the nn.Identity()
+                x = blk(x)
+                if i in blocks_to_take:
+                    output.append(x)
+                i += 1
+        assert len(output) == len(blocks_to_take), f"only {len(output)} / {len(blocks_to_take)} blocks found"
+        return output
+
+    def get_intermediate_layers(
+        self,
+        x: torch.Tensor,
+        n: Union[int, Sequence] = 1,  # Layers or n last layers to take
+        reshape: bool = False,
+        return_class_token: bool = False,
+        norm=True,
+    ) -> Tuple[Union[torch.Tensor, Tuple[torch.Tensor]]]:
+        if self.chunked_blocks:
+            outputs = self._get_intermediate_layers_chunked(x, n)
+        else:
+            outputs = self._get_intermediate_layers_not_chunked(x, n)
+        if norm:
+            outputs = [self.norm(out) for out in outputs]
+        class_tokens = [out[:, 0] for out in outputs]
+        outputs = [out[:, 1:] for out in outputs]
+        if reshape:
+            B, _, w, h = x.shape
+            outputs = [
+                out.reshape(B, w // self.patch_size, h // self.patch_size, -1).permute(0, 3, 1, 2).contiguous()
+                for out in outputs
+            ]
+        if return_class_token:
+            return tuple(zip(outputs, class_tokens))
+        return tuple(outputs)
+
+    def forward(self, *args, is_training=False, **kwargs):
+        ret = self.forward_features(*args, **kwargs)
+        return ret
+        # if is_training:
+        #     return ret
+        # else:
+        #     return self.head(ret["x_norm_clstoken"])
+
+
+
+
+def init_weights_vit_timm(module: nn.Module, name: str = ""):
+    """ViT weight initialization, original timm impl (for reproducibility)"""
+    if isinstance(module, nn.Linear):
+        trunc_normal_(module.weight, std=0.02)
+        if module.bias is not None:
+            nn.init.zeros_(module.bias)
+
+
+def vit_small(patch_size=14, **kwargs):
+    model = DinoVisionTransformer(
+        patch_size=patch_size,
+        embed_dim=384,
+        depth=12,
+        num_heads=6,
+        mlp_ratio=4,
+        block_fn=partial(NestedTensorBlock, attn_class=MemEffAttention),
+        **kwargs,
+    )
+    return model
+
+
+def vit_base(patch_size=14, **kwargs):
+    model = DinoWindowVisionTransformer(
+        patch_size=patch_size,
+        embed_dim=768,
+        depth=12,
+        num_heads=12,
+        mlp_ratio=4,
+        block_fn=partial(NestedTensorBlock, attn_class=MemEffAttention),
+        **kwargs,
+    )
+    return model
+
+
+def vit_large(patch_size=14, checkpoint=None, **kwargs):
+    model = DinoVisionTransformer(
+        img_size = 518,
+        patch_size=patch_size,
+        embed_dim=1024,
+        depth=24,
+        num_heads=16,
+        mlp_ratio=4,
+        block_fn=partial(NestedTensorBlock, attn_class=MemEffAttention),
+        **kwargs,
+    )
+
+    if checkpoint is not None:
+        with open(checkpoint, "rb") as f:
+            state_dict = torch.load(f)
+        try:
+            model.load_state_dict(state_dict, strict=True)
+        except:
+            new_state_dict = {}
+            for key, value in state_dict.items():
+                if 'blocks' in key:
+                    key_new = 'blocks.0' + key[len('blocks'):]
+                else:
+                    key_new = key
+                new_state_dict[key_new] = value
+
+            model.load_state_dict(new_state_dict, strict=True)
+        #del model.norm
+        del model.mask_token
+    return model
+
+    # model = DinoWindowVisionTransformer(
+    #     img_size = 518,
+    #     patch_size=patch_size,
+    #     embed_dim=1024,
+    #     depth=24,
+    #     num_heads=16,
+    #     mlp_ratio=4,
+    #     block_fn=partial(NestedTensorBlock, attn_class=MemEffAttention),
+    #     window_size=37,
+    #     **kwargs,
+    # )
+    
+    # if checkpoint is not None:
+    #     with open(checkpoint, "rb") as f:
+    #         state_dict = torch.load(f)
+    #     try:
+    #         model.load_state_dict(state_dict, strict=True)
+    #     except:
+    #         new_state_dict = {}
+    #         for key, value in state_dict.items():
+    #             if 'blocks' in key:
+    #                 key_new = 'blocks.0' + key[len('blocks'):]
+    #             else:
+    #                 key_new = key
+    #             if 'pos_embed' in key:
+    #                 value = value[:, 1:, :]
+    #             new_state_dict[key_new] = value
+
+    #         model.load_state_dict(new_state_dict, strict=False)
+    #     #del model.norm
+    #     del model.mask_token
+    return model
+
+
+def vit_giant2(patch_size=16, **kwargs):
+    """
+    Close to ViT-giant, with embed-dim 1536 and 24 heads => embed-dim per head 64
+    """
+    model = DinoVisionTransformer(
+        patch_size=patch_size,
+        embed_dim=1536,
+        depth=40,
+        num_heads=24,
+        mlp_ratio=4,
+        block_fn=partial(Block, attn_class=MemEffAttention),
+        **kwargs,
+    )
+    return model
+
+if __name__ == '__main__':
+    try:
+        from mmcv.utils import Config
+    except:
+        from mmengine import Config    
+    
+    #rgb = torch.rand((2, 3, 518, 518)).cuda()
+
+    #cfg.data_basic['crop_size']['0'] 
+    #cfg.data_basic['crop_size']['1'] 
+    cfg = Config.fromfile('mu.hu/monodepth/mono/configs/HourglassDecoder/pub12.convlarge.0.3_150.py')
+
+    #rgb = torch.arange(0, 2*3*1036*1036, 1).cuda().float().view(2, 3, 1036, 1036)
+    rgb = torch.zeros(1, 3, 1400, 1680).cuda()
+    model = vit_large(checkpoint="pretrained_weight_repo/vit/dinov2_vitl14_pretrain.pth", kwarg=cfg).cuda()
+
+    #import timm
+    #model2 = timm.models.vision_transformer.vit_large_patch14_dinov2().cuda()
+    #timm.models.load_checkpoint(model2, '/cpfs02/shared/public/yvan/pretrained_weight_repo/vit/dinov2_vitl14_pretrain.pth', filter_fn=timm.models.vision_transformer.checkpoint_filter_fn)
+
+    out1 = model(rgb)
+    #out2 = model2(rgb)
+    temp = 0
+
+
+
+# import time
+# window_size = 37
+# def prepare_window_masks(shape):
+#     if window_size <= 0:
+#         return None
+#     import xformers.components.attention.attention_patterns as AP
+    
+#     B, nh, nw, _, _ = shape
+#     radius = (window_size-1)//2 
+#     #time0 = time.time()
+#     d = AP.local_nd_distance(nh, nw, distance = radius + 0.1, p=torch.inf).cuda()
+#     #mask = AP.local_2d_pattern(nh, nw, distance = radius + 0.1, p=torch.inf).cuda()
+#     # mask = mask.view(nh, nw, nh, nw)
+#     # #time1 = time.time() - time0
+    
+#     # # angle
+#     # mask[:radius+1,  :radius+1,  :window_size,  :window_size] = True
+#     # mask[:radius+1,  -radius-1:, :window_size,  -window_size:] = True
+#     # mask[-radius-1:, :radius+1,  -window_size:, :window_size] = True
+#     # mask[-radius-1:, -radius-1:, -window_size:, -window_size:] = True
+#     # time2 = time.time() - time0 - time1
+
+#     # # edge
+#     # mask[radius+1:-radius-1,  :radius+1,  :,  :] = mask[radius+1:-radius-1,  radius:radius+1,    :,  :]
+#     # mask[radius+1:-radius-1,  -radius-1:, :,  :] = mask[radius+1:-radius-1,  -radius-1:-radius,  :,  :]
+#     # mask[:radius+1,   radius+1:-radius-1, :,  :] = mask[radius:radius+1,   radius+1:-radius-1,   :,  :]
+#     # mask[-radius-1:,  radius+1:-radius-1, :,  :] = mask[-radius-1:-radius, radius+1:-radius-1,   :,  :]
+#     # time3 = time.time() - time0 - time2
+#     # print(time1, time2, time3)
+
+# #     return mask.view(nw*nw, nh*nw).unsqueeze(0).repeat(B, 1)   
+
+# shape = (1, 55, 55, None, None)
+# mask = prepare_window_masks(shape)
+# # temp = 1

external/Metric3D/training/mono/model/backbones/ViT_DINO_reg.py

@@ -0,0 +1,1099 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the license found in the
+# LICENSE file in the root directory of this source tree.
+
+# References:
+#   https://github.com/facebookresearch/dino/blob/main/vision_transformer.py
+#   https://github.com/rwightman/pytorch-image-models/tree/master/timm/models/vision_transformer.py
+
+from functools import partial
+import math
+import logging
+from typing import Sequence, Tuple, Union, Callable, Optional, Dict, Any, List
+
+import torch
+import torch.nn as nn
+from torch import Tensor
+import torch.utils.checkpoint
+from torch.nn.init import trunc_normal_
+
+#from dinov2.layers import Mlp, PatchEmbed, SwiGLUFFNFused, MemEffAttention, NestedTensorBlock as Block
+
+logger = logging.getLogger("dinov2")
+
+class ConvBlock(nn.Module):
+    def __init__(self, channels):
+        super(ConvBlock, self).__init__()
+
+        self.act = nn.ReLU(inplace=True)
+        self.conv1 = nn.Conv2d(
+            channels,
+            channels,
+            kernel_size=3,
+            stride=1,
+            padding=1
+        )
+        self.norm1 = nn.BatchNorm2d(channels)
+        self.conv2 = nn.Conv2d(
+            channels,
+            channels,
+            kernel_size=3,
+            stride=1,
+            padding=1
+        )
+        self.norm2 = nn.BatchNorm2d(channels)
+
+    def forward(self, x):
+
+        out = self.norm1(x)
+        out = self.act(out)
+        out = self.conv1(out)
+        out = self.norm2(out)
+        out = self.act(out)
+        out = self.conv2(out)
+        return x + out
+
+def make_2tuple(x):
+    if isinstance(x, tuple):
+        assert len(x) == 2
+        return x
+
+    assert isinstance(x, int)
+    return (x, x)
+
+def drop_path(x, drop_prob: float = 0.0, training: bool = False):
+    if drop_prob == 0.0 or not training:
+        return x
+    keep_prob = 1 - drop_prob
+    shape = (x.shape[0],) + (1,) * (x.ndim - 1)  # work with diff dim tensors, not just 2D ConvNets
+    random_tensor = x.new_empty(shape).bernoulli_(keep_prob)
+    if keep_prob > 0.0:
+        random_tensor.div_(keep_prob)
+    output = x * random_tensor
+    return output
+
+class DropPath(nn.Module):
+    """Drop paths (Stochastic Depth) per sample (when applied in main path of residual blocks)."""
+
+    def __init__(self, drop_prob=None):
+        super(DropPath, self).__init__()
+        self.drop_prob = drop_prob
+
+    def forward(self, x):
+        return drop_path(x, self.drop_prob, self.training)
+
+class LayerScale(nn.Module):
+    def __init__(
+        self,
+        dim: int,
+        init_values: Union[float, Tensor] = 1e-5,
+        inplace: bool = False,
+    ) -> None:
+        super().__init__()
+        self.inplace = inplace
+        self.gamma = nn.Parameter(init_values * torch.ones(dim))
+
+    def forward(self, x: Tensor) -> Tensor:
+        return x.mul_(self.gamma) if self.inplace else x * self.gamma
+
+
+class PatchEmbed(nn.Module):
+    """
+    2D image to patch embedding: (B,C,H,W) -> (B,N,D)
+
+    Args:
+        img_size: Image size.
+        patch_size: Patch token size.
+        in_chans: Number of input image channels.
+        embed_dim: Number of linear projection output channels.
+        norm_layer: Normalization layer.
+    """
+
+    def __init__(
+        self,
+        img_size: Union[int, Tuple[int, int]] = 224,
+        patch_size: Union[int, Tuple[int, int]] = 16,
+        in_chans: int = 3,
+        embed_dim: int = 768,
+        norm_layer: Optional[Callable] = None,
+        flatten_embedding: bool = True,
+    ) -> None:
+        super().__init__()
+
+        image_HW = make_2tuple(img_size)
+        patch_HW = make_2tuple(patch_size)
+        patch_grid_size = (
+            image_HW[0] // patch_HW[0],
+            image_HW[1] // patch_HW[1],
+        )
+
+        self.img_size = image_HW
+        self.patch_size = patch_HW
+        self.patches_resolution = patch_grid_size
+        self.num_patches = patch_grid_size[0] * patch_grid_size[1]
+
+        self.in_chans = in_chans
+        self.embed_dim = embed_dim
+
+        self.flatten_embedding = flatten_embedding
+
+        self.proj = nn.Conv2d(in_chans, embed_dim, kernel_size=patch_HW, stride=patch_HW)
+        self.norm = norm_layer(embed_dim) if norm_layer else nn.Identity()
+
+    def forward(self, x: Tensor) -> Tensor:
+        _, _, H, W = x.shape
+        patch_H, patch_W = self.patch_size
+
+        assert H % patch_H == 0, f"Input image height {H} is not a multiple of patch height {patch_H}"
+        assert W % patch_W == 0, f"Input image width {W} is not a multiple of patch width: {patch_W}"
+
+        x = self.proj(x)  # B C H W
+        H, W = x.size(2), x.size(3)
+        x = x.flatten(2).transpose(1, 2)  # B HW C
+        x = self.norm(x)
+        if not self.flatten_embedding:
+            x = x.reshape(-1, H, W, self.embed_dim)  # B H W C
+        return x
+
+    def flops(self) -> float:
+        Ho, Wo = self.patches_resolution
+        flops = Ho * Wo * self.embed_dim * self.in_chans * (self.patch_size[0] * self.patch_size[1])
+        if self.norm is not None:
+            flops += Ho * Wo * self.embed_dim
+        return flops
+
+class Mlp(nn.Module):
+    def __init__(
+        self,
+        in_features: int,
+        hidden_features: Optional[int] = None,
+        out_features: Optional[int] = None,
+        act_layer: Callable[..., nn.Module] = nn.GELU,
+        drop: float = 0.0,
+        bias: bool = True,
+    ) -> None:
+        super().__init__()
+        out_features = out_features or in_features
+        hidden_features = hidden_features or in_features
+        self.fc1 = nn.Linear(in_features, hidden_features, bias=bias)
+        self.act = act_layer()
+        self.fc2 = nn.Linear(hidden_features, out_features, bias=bias)
+        self.drop = nn.Dropout(drop)
+
+    def forward(self, x: Tensor) -> Tensor:
+        x = self.fc1(x)
+        x = self.act(x)
+        x = self.drop(x)
+        x = self.fc2(x)
+        x = self.drop(x)
+        return x
+
+
+class SwiGLUFFN(nn.Module):
+    def __init__(
+        self,
+        in_features: int,
+        hidden_features: Optional[int] = None,
+        out_features: Optional[int] = None,
+        act_layer: Callable[..., nn.Module] = None,
+        drop: float = 0.0,
+        bias: bool = True,
+    ) -> None:
+        super().__init__()
+        out_features = out_features or in_features
+        hidden_features = hidden_features or in_features
+        self.w12 = nn.Linear(in_features, 2 * hidden_features, bias=bias)
+        self.w3 = nn.Linear(hidden_features, out_features, bias=bias)
+
+    def forward(self, x: Tensor) -> Tensor:
+        x12 = self.w12(x)
+        x1, x2 = x12.chunk(2, dim=-1)
+        hidden = F.silu(x1) * x2
+        return self.w3(hidden)
+
+
+try:
+    from xformers.ops import SwiGLU
+    #import numpy.bool
+    XFORMERS_AVAILABLE = True
+except ImportError:
+    SwiGLU = SwiGLUFFN
+    XFORMERS_AVAILABLE = False
+
+class SwiGLUFFNFused(SwiGLU):
+    def __init__(
+        self,
+        in_features: int,
+        hidden_features: Optional[int] = None,
+        out_features: Optional[int] = None,
+        act_layer: Callable[..., nn.Module] = None,
+        drop: float = 0.0,
+        bias: bool = True,
+    ) -> None:
+        out_features = out_features or in_features
+        hidden_features = hidden_features or in_features
+        hidden_features = (int(hidden_features * 2 / 3) + 7) // 8 * 8
+        super().__init__(
+            in_features=in_features,
+            hidden_features=hidden_features,
+            out_features=out_features,
+            bias=bias,
+        )
+
+
+try:
+    from xformers.ops import memory_efficient_attention, unbind, fmha
+    from xformers.components.attention import ScaledDotProduct
+    from xformers.components import MultiHeadDispatch
+    #import numpy.bool
+    XFORMERS_AVAILABLE = True
+except ImportError:
+    logger.warning("xFormers not available")
+    XFORMERS_AVAILABLE = False
+
+
+class Attention(nn.Module):
+    def __init__(
+        self,
+        dim: int,
+        num_heads: int = 8,
+        qkv_bias: bool = False,
+        proj_bias: bool = True,
+        attn_drop: float = 0.0,
+        proj_drop: float = 0.0,
+        window_size: int = 0,
+    ) -> None:
+        super().__init__()
+        self.num_heads = num_heads
+        head_dim = dim // num_heads
+        self.scale = head_dim**-0.5
+
+        self.qkv = nn.Linear(dim, dim * 3, bias=qkv_bias)
+        self.attn_drop = nn.Dropout(attn_drop)
+        self.proj = nn.Linear(dim, dim, bias=proj_bias)
+        self.proj_drop = nn.Dropout(proj_drop)
+        
+        #if not self.training:
+        #
+        # self.attn = ScaledDotProduct()
+            #self.attn = MultiHeadDispatch(dim_model=EMB, residual_dropout=DROPOUT, num_heads=HEADS, attention=attn)
+
+    def forward(self, x: Tensor, attn_bias=None) -> Tensor:
+        B, N, C = x.shape
+        qkv = self.qkv(x).reshape(B, N, 3, self.num_heads, C // self.num_heads).permute(2, 0, 3, 1, 4)
+
+        q, k, v = qkv[0] * self.scale, qkv[1], qkv[2]
+        attn = q @ k.transpose(-2, -1)
+
+        if attn_bias is not None:
+            attn = attn + attn_bias[:, :, :N]
+
+        attn = attn.softmax(dim=-1)
+        attn = self.attn_drop(attn)
+
+        x = (attn @ v).transpose(1, 2).reshape(B, N, C)
+        x = self.proj(x)
+        x = self.proj_drop(x)
+        return x
+
+
+class MemEffAttention(Attention):
+    def forward(self, x: Tensor, attn_bias=None) -> Tensor:
+        if not XFORMERS_AVAILABLE:
+        #if True:
+            assert attn_bias is None, "xFormers is required for nested tensors usage"
+            return super().forward(x, attn_bias)
+
+        B, N, C = x.shape
+        qkv = self.qkv(x).reshape(B, N, 3, self.num_heads, C // self.num_heads)
+
+        q, k, v = unbind(qkv, 2)
+        if attn_bias is not None:
+            x = memory_efficient_attention(q, k, v, attn_bias=attn_bias[:, :, :N])
+        else:
+            x = memory_efficient_attention(q, k, v)
+        x = x.reshape([B, N, C])
+
+        x = self.proj(x)
+        x = self.proj_drop(x)
+        return x
+
+try:
+    from xformers.ops import fmha
+    from xformers.ops import scaled_index_add, index_select_cat
+    #import numpy.bool
+    XFORMERS_AVAILABLE = True
+except ImportError:
+    logger.warning("xFormers not available")
+    XFORMERS_AVAILABLE = False
+
+class Block(nn.Module):
+    def __init__(
+        self,
+        dim: int,
+        num_heads: int,
+        mlp_ratio: float = 4.0,
+        qkv_bias: bool = False,
+        proj_bias: bool = True,
+        ffn_bias: bool = True,
+        drop: float = 0.0,
+        attn_drop: float = 0.0,
+        init_values = None,
+        drop_path: float = 0.0,
+        act_layer: Callable[..., nn.Module] = nn.GELU,
+        norm_layer: Callable[..., nn.Module] = nn.LayerNorm,
+        attn_class: Callable[..., nn.Module] = Attention,
+        ffn_layer: Callable[..., nn.Module] = Mlp,
+    ) -> None:
+        super().__init__()
+        # print(f"biases: qkv: {qkv_bias}, proj: {proj_bias}, ffn: {ffn_bias}")
+        self.norm1 = norm_layer(dim)
+        self.attn = attn_class(
+            dim,
+            num_heads=num_heads,
+            qkv_bias=qkv_bias,
+            proj_bias=proj_bias,
+            attn_drop=attn_drop,
+            proj_drop=drop,
+        )
+        self.ls1 = LayerScale(dim, init_values=init_values) if init_values else nn.Identity()
+        self.drop_path1 = DropPath(drop_path) if drop_path > 0.0 else nn.Identity()
+
+        self.norm2 = norm_layer(dim)
+        mlp_hidden_dim = int(dim * mlp_ratio)
+        self.mlp = ffn_layer(
+            in_features=dim,
+            hidden_features=mlp_hidden_dim,
+            act_layer=act_layer,
+            drop=drop,
+            bias=ffn_bias,
+        )
+        self.ls2 = LayerScale(dim, init_values=init_values) if init_values else nn.Identity()
+        self.drop_path2 = DropPath(drop_path) if drop_path > 0.0 else nn.Identity()
+
+        self.sample_drop_ratio = drop_path
+
+    def forward(self, x: Tensor, attn_bias=None) -> Tensor:
+        def attn_residual_func(x: Tensor, attn_bias) -> Tensor:
+            return self.ls1(self.attn(self.norm1(x), attn_bias))
+
+        def ffn_residual_func(x: Tensor) -> Tensor:
+            return self.ls2(self.mlp(self.norm2(x)))
+
+        if self.training and self.sample_drop_ratio > 0.1:
+            # the overhead is compensated only for a drop path rate larger than 0.1
+            x = drop_add_residual_stochastic_depth(
+                x,
+                residual_func=attn_residual_func,
+                sample_drop_ratio=self.sample_drop_ratio,
+                attn_bias=attn_bias
+            )
+            x = drop_add_residual_stochastic_depth(
+                x,
+                residual_func=ffn_residual_func,
+                sample_drop_ratio=self.sample_drop_ratio,
+            )
+        elif self.training and self.sample_drop_ratio > 0.0:
+            x = x + self.drop_path1(attn_residual_func(x, attn_bias))
+            x = x + self.drop_path1(ffn_residual_func(x))  # FIXME: drop_path2
+        else:
+            x = x + attn_residual_func(x, attn_bias)
+            x = x + ffn_residual_func(x)
+        return x
+
+
+def drop_add_residual_stochastic_depth(
+    x: Tensor,
+    residual_func: Callable[[Tensor], Tensor],
+    sample_drop_ratio: float = 0.0, attn_bias=None
+) -> Tensor:
+    # 1) extract subset using permutation
+    b, n, d = x.shape
+    sample_subset_size = max(int(b * (1 - sample_drop_ratio)), 1)
+    brange = (torch.randperm(b, device=x.device))[:sample_subset_size]
+    x_subset = x[brange]
+
+    # 2) apply residual_func to get residual
+    residual = residual_func(x_subset, attn_bias)
+
+    x_flat = x.flatten(1)
+    residual = residual.flatten(1)
+
+    residual_scale_factor = b / sample_subset_size
+
+    # 3) add the residual
+    x_plus_residual = torch.index_add(x_flat, 0, brange, residual.to(dtype=x.dtype), alpha=residual_scale_factor)
+    return x_plus_residual.view_as(x)
+
+
+def get_branges_scales(x, sample_drop_ratio=0.0):
+    b, n, d = x.shape
+    sample_subset_size = max(int(b * (1 - sample_drop_ratio)), 1)
+    brange = (torch.randperm(b, device=x.device))[:sample_subset_size]
+    residual_scale_factor = b / sample_subset_size
+    return brange, residual_scale_factor
+
+
+def add_residual(x, brange, residual, residual_scale_factor, scaling_vector=None):
+    if scaling_vector is None:
+        x_flat = x.flatten(1)
+        residual = residual.flatten(1)
+        x_plus_residual = torch.index_add(x_flat, 0, brange, residual.to(dtype=x.dtype), alpha=residual_scale_factor)
+    else:
+        x_plus_residual = scaled_index_add(
+            x, brange, residual.to(dtype=x.dtype), scaling=scaling_vector, alpha=residual_scale_factor
+        )
+    return x_plus_residual
+
+
+attn_bias_cache: Dict[Tuple, Any] = {}
+
+
+def get_attn_bias_and_cat(x_list, branges=None):
+    """
+    this will perform the index select, cat the tensors, and provide the attn_bias from cache
+    """
+    batch_sizes = [b.shape[0] for b in branges] if branges is not None else [x.shape[0] for x in x_list]
+    all_shapes = tuple((b, x.shape[1]) for b, x in zip(batch_sizes, x_list))
+    if all_shapes not in attn_bias_cache.keys():
+        seqlens = []
+        for b, x in zip(batch_sizes, x_list):
+            for _ in range(b):
+                seqlens.append(x.shape[1])
+        attn_bias = fmha.BlockDiagonalMask.from_seqlens(seqlens)
+        attn_bias._batch_sizes = batch_sizes
+        attn_bias_cache[all_shapes] = attn_bias
+
+    if branges is not None:
+        cat_tensors = index_select_cat([x.flatten(1) for x in x_list], branges).view(1, -1, x_list[0].shape[-1])
+    else:
+        tensors_bs1 = tuple(x.reshape([1, -1, *x.shape[2:]]) for x in x_list)
+        cat_tensors = torch.cat(tensors_bs1, dim=1)
+
+    return attn_bias_cache[all_shapes], cat_tensors
+
+
+def drop_add_residual_stochastic_depth_list(
+    x_list: List[Tensor],
+    residual_func: Callable[[Tensor, Any], Tensor],
+    sample_drop_ratio: float = 0.0,
+    scaling_vector=None,
+) -> Tensor:
+    # 1) generate random set of indices for dropping samples in the batch
+    branges_scales = [get_branges_scales(x, sample_drop_ratio=sample_drop_ratio) for x in x_list]
+    branges = [s[0] for s in branges_scales]
+    residual_scale_factors = [s[1] for s in branges_scales]
+
+    # 2) get attention bias and index+concat the tensors
+    attn_bias, x_cat = get_attn_bias_and_cat(x_list, branges)
+
+    # 3) apply residual_func to get residual, and split the result
+    residual_list = attn_bias.split(residual_func(x_cat, attn_bias=attn_bias))  # type: ignore
+
+    outputs = []
+    for x, brange, residual, residual_scale_factor in zip(x_list, branges, residual_list, residual_scale_factors):
+        outputs.append(add_residual(x, brange, residual, residual_scale_factor, scaling_vector).view_as(x))
+    return outputs
+
+
+class NestedTensorBlock(Block):
+    def forward_nested(self, x_list: List[Tensor]) -> List[Tensor]:
+        """
+        x_list contains a list of tensors to nest together and run
+        """
+        assert isinstance(self.attn, MemEffAttention)
+
+        if self.training and self.sample_drop_ratio > 0.0:
+
+            def attn_residual_func(x: Tensor, attn_bias=None) -> Tensor:
+                return self.attn(self.norm1(x), attn_bias=attn_bias)
+
+            def ffn_residual_func(x: Tensor, attn_bias=None) -> Tensor:
+                return self.mlp(self.norm2(x))
+
+            x_list = drop_add_residual_stochastic_depth_list(
+                x_list,
+                residual_func=attn_residual_func,
+                sample_drop_ratio=self.sample_drop_ratio,
+                scaling_vector=self.ls1.gamma if isinstance(self.ls1, LayerScale) else None,
+            )
+            x_list = drop_add_residual_stochastic_depth_list(
+                x_list,
+                residual_func=ffn_residual_func,
+                sample_drop_ratio=self.sample_drop_ratio,
+                scaling_vector=self.ls2.gamma if isinstance(self.ls1, LayerScale) else None,
+            )
+            return x_list
+        else:
+
+            def attn_residual_func(x: Tensor, attn_bias=None) -> Tensor:
+                return self.ls1(self.attn(self.norm1(x), attn_bias=attn_bias))
+
+            def ffn_residual_func(x: Tensor, attn_bias=None) -> Tensor:
+                return self.ls2(self.mlp(self.norm2(x)))
+
+            attn_bias, x = get_attn_bias_and_cat(x_list)
+            x = x + attn_residual_func(x, attn_bias=attn_bias)
+            x = x + ffn_residual_func(x)
+            return attn_bias.split(x)
+
+    def forward(self, x_or_x_list, attn_bias=None):
+        if isinstance(x_or_x_list, Tensor):
+            return super().forward(x_or_x_list, attn_bias)
+        elif isinstance(x_or_x_list, list):
+            assert XFORMERS_AVAILABLE, "Please install xFormers for nested tensors usage"
+            return self.forward_nested(x_or_x_list)
+        else:
+            raise AssertionError
+
+
+def named_apply(fn: Callable, module: nn.Module, name="", depth_first=True, include_root=False) -> nn.Module:
+    if not depth_first and include_root:
+        fn(module=module, name=name)
+    for child_name, child_module in module.named_children():
+        child_name = ".".join((name, child_name)) if name else child_name
+        named_apply(fn=fn, module=child_module, name=child_name, depth_first=depth_first, include_root=True)
+    if depth_first and include_root:
+        fn(module=module, name=name)
+    return module
+
+
+class BlockChunk(nn.ModuleList):
+    def forward(self, x, others=None):
+        for b in self:
+            if others == None:
+                x = b(x)
+            else:
+                x = b(x, others)
+        return x
+
+
+class DinoVisionTransformer(nn.Module):
+    def __init__(
+        self,
+        img_size=518,
+        patch_size=16,
+        in_chans=3,
+        embed_dim=768,
+        depth=12,
+        num_heads=12,
+        mlp_ratio=4.0,
+        qkv_bias=True,
+        ffn_bias=True,
+        proj_bias=True,
+        drop_path_rate=0.0,
+        drop_path_uniform=False,
+        init_values=1e-5,  # for layerscale: None or 0 => no layerscale
+        embed_layer=PatchEmbed,
+        act_layer=nn.GELU,
+        block_fn=Block,
+        ffn_layer="mlp",
+        block_chunks=1,
+        num_register_tokens=0,
+        interpolate_antialias=False,
+        interpolate_offset=0.1,
+        multi_output=False,
+        **kwargs
+    ):
+        """
+        Args:
+            img_size (int, tuple): input image size
+            patch_size (int, tuple): patch size
+            in_chans (int): number of input channels
+            embed_dim (int): embedding dimension
+            depth (int): depth of transformer
+            num_heads (int): number of attention heads
+            mlp_ratio (int): ratio of mlp hidden dim to embedding dim
+            qkv_bias (bool): enable bias for qkv if True
+            proj_bias (bool): enable bias for proj in attn if True
+            ffn_bias (bool): enable bias for ffn if True
+            drop_path_rate (float): stochastic depth rate
+            drop_path_uniform (bool): apply uniform drop rate across blocks
+            weight_init (str): weight init scheme
+            init_values (float): layer-scale init values
+            embed_layer (nn.Module): patch embedding layer
+            act_layer (nn.Module): MLP activation layer
+            block_fn (nn.Module): transformer block class
+            ffn_layer (str): "mlp", "swiglu", "swiglufused" or "identity"
+            block_chunks: (int) split block sequence into block_chunks units for FSDP wrap
+            num_register_tokens: (int) number of extra cls tokens (so-called "registers")
+            interpolate_antialias: (str) flag to apply anti-aliasing when interpolating positional embeddings
+            interpolate_offset: (float) work-around offset to apply when interpolating positional embeddings
+        """
+        super().__init__()
+        norm_layer = partial(nn.LayerNorm, eps=1e-6)
+
+        self.num_features = self.embed_dim = embed_dim  # num_features for consistency with other models
+        self.num_tokens = 1
+        self.n_blocks = depth
+        self.num_heads = num_heads
+        self.patch_size = patch_size
+        self.num_register_tokens = num_register_tokens
+        self.interpolate_antialias = interpolate_antialias
+        self.interpolate_offset = interpolate_offset
+
+        self.patch_embed = embed_layer(img_size=img_size, patch_size=patch_size, in_chans=in_chans, embed_dim=embed_dim)
+        num_patches = self.patch_embed.num_patches
+
+        self.cls_token = nn.Parameter(torch.zeros(1, 1, embed_dim))
+        self.pos_embed = nn.Parameter(torch.zeros(1, num_patches + self.num_tokens, embed_dim))
+        self.multi_output = multi_output
+        assert num_register_tokens >= 0
+        self.register_tokens = (
+            nn.Parameter(torch.zeros(1, num_register_tokens, embed_dim)) if num_register_tokens else None
+        )
+
+        if drop_path_uniform is True:
+            dpr = [drop_path_rate] * depth
+        else:
+            dpr = [x.item() for x in torch.linspace(0, drop_path_rate, depth)]  # stochastic depth decay rule
+
+        if ffn_layer == "mlp":
+            logger.info("using MLP layer as FFN")
+            ffn_layer = Mlp
+        elif ffn_layer == "swiglufused" or ffn_layer == "swiglu":
+            logger.info("using SwiGLU layer as FFN")
+            ffn_layer = SwiGLUFFNFused
+        elif ffn_layer == "identity":
+            logger.info("using Identity layer as FFN")
+
+            def f(*args, **kwargs):
+                return nn.Identity()
+
+            ffn_layer = f
+        else:
+            raise NotImplementedError
+
+        blocks_list = [
+            block_fn(
+                dim=embed_dim,
+                num_heads=num_heads,
+                mlp_ratio=mlp_ratio,
+                qkv_bias=qkv_bias,
+                proj_bias=proj_bias,
+                ffn_bias=ffn_bias,
+                drop_path=dpr[i],
+                norm_layer=norm_layer,
+                act_layer=act_layer,
+                ffn_layer=ffn_layer,
+                init_values=init_values,
+            )
+            for i in range(depth)
+        ]
+        if block_chunks > 0:
+            self.chunked_blocks = True
+            chunked_blocks = []
+            chunksize = depth // block_chunks
+            for i in range(0, depth, chunksize):
+                # this is to keep the block index consistent if we chunk the block list
+                chunked_blocks.append([nn.Identity()] * i + blocks_list[i : i + chunksize])
+            self.blocks = nn.ModuleList([BlockChunk(p) for p in chunked_blocks])
+        else:
+            self.chunked_blocks = False
+            self.blocks = nn.ModuleList(blocks_list)
+
+        self.norm = norm_layer(embed_dim)
+        self.head = nn.Identity()
+
+        self.mask_token = nn.Parameter(torch.zeros(1, embed_dim))
+
+        self.init_weights()
+
+    def init_weights(self):
+        trunc_normal_(self.pos_embed, std=0.02)
+        nn.init.normal_(self.cls_token, std=1e-6)
+        if self.register_tokens is not None:
+            nn.init.normal_(self.register_tokens, std=1e-6)
+        named_apply(init_weights_vit_timm, self)
+
+    def interpolate_pos_encoding(self, x, w, h):
+        previous_dtype = x.dtype
+        npatch = x.shape[1] - 1
+        N = self.pos_embed.shape[1] - 1
+        if npatch == N and w == h:
+            return self.pos_embed
+        pos_embed = self.pos_embed.float()
+        class_pos_embed = pos_embed[:, 0]
+        patch_pos_embed = pos_embed[:, 1:]
+        dim = x.shape[-1]
+        w0 = w // self.patch_size
+        h0 = h // self.patch_size
+        # we add a small number to avoid floating point error in the interpolation
+        # see discussion at https://github.com/facebookresearch/dino/issues/8
+        w0, h0 = w0 + self.interpolate_offset, h0 + self.interpolate_offset
+
+        sqrt_N = math.sqrt(N)
+        sx, sy = float(w0) / sqrt_N, float(h0) / sqrt_N
+        patch_pos_embed = nn.functional.interpolate(
+            patch_pos_embed.reshape(1, int(sqrt_N), int(sqrt_N), dim).permute(0, 3, 1, 2),
+            scale_factor=(sx, sy),
+            mode="bicubic",
+            antialias=self.interpolate_antialias,
+        )
+
+        assert int(w0) == patch_pos_embed.shape[-2]
+        assert int(h0) == patch_pos_embed.shape[-1]
+        patch_pos_embed = patch_pos_embed.permute(0, 2, 3, 1).view(1, -1, dim)
+        return torch.cat((class_pos_embed.unsqueeze(0), patch_pos_embed), dim=1).to(previous_dtype)
+
+    def prepare_tokens_with_masks(self, x, masks=None):
+        B, nc, w, h = x.shape
+        x = self.patch_embed(x)
+        if masks is not None:
+            x = torch.where(masks.unsqueeze(-1), self.mask_token.to(x.dtype).unsqueeze(0), x)
+
+        x = torch.cat((self.cls_token.expand(x.shape[0], -1, -1), x), dim=1)
+        x = x + self.interpolate_pos_encoding(x, w, h)
+
+        if self.register_tokens is not None:
+            x = torch.cat(
+                (
+                    x[:, :1],
+                    self.register_tokens.expand(x.shape[0], -1, -1),
+                    x[:, 1:],
+                ),
+                dim=1,
+            )
+
+        return x
+
+    def forward_features_list(self, x_list, masks_list):
+        x = [self.prepare_tokens_with_masks(x, masks) for x, masks in zip(x_list, masks_list)]
+        for blk in self.blocks:
+            x = blk(x)
+
+        all_x = x
+        output = []
+        for x, masks in zip(all_x, masks_list):
+            x_norm = self.norm(x)
+            output.append(
+                {
+                    "x_norm_clstoken": x_norm[:, 0],
+                    "x_norm_regtokens": x_norm[:, 1 : self.num_register_tokens + 1],
+                    "x_norm_patchtokens": x_norm[:, self.num_register_tokens + 1 :],
+                    "x_prenorm": x,
+                    "masks": masks,
+                }
+            )
+        return output
+
+    def forward_features(self, x, masks=None):
+        if isinstance(x, list):
+            return self.forward_features_list(x, masks)
+
+        B, C, H, W = x.size()
+        pad_h = (self.patch_size - H % self.patch_size)
+        pad_w = (self.patch_size - W % self.patch_size)
+        if pad_h == self.patch_size:
+            pad_h = 0
+        if pad_w == self.patch_size:
+            pad_w = 0     
+        #x = nn.functional.pad(x, (pad_h//2, pad_h-pad_h//2, pad_w//2, pad_w-pad_w//2))
+        if pad_h + pad_w > 0:
+            x = torch.nn.functional.interpolate(x, (H+pad_h, W+pad_w), mode='bilinear')
+
+        x = self.prepare_tokens_with_masks(x, masks)
+
+        # return {
+        #     "x_norm_clstoken": x_norm[:, 0],
+        #     "x_norm_regtokens": x_norm[:, 1 : self.num_register_tokens + 1],
+        #     "x_norm_patchtokens": x_norm[:, self.num_register_tokens + 1 :],
+        #     "x_prenorm": x,
+        #     "masks": masks,
+        # }
+        if self.multi_output == False:
+            for blk in self.blocks:
+                x = blk(x)
+            x_norm = self.norm(x)
+            features = []
+            features.append(x_norm)
+            features.append(x_norm)
+            features.append(x_norm)
+            features.append(x_norm)
+            return [features, (B, (H+pad_h)//self.patch_size, (W+pad_w)//self.patch_size, H, W, self.num_register_tokens)]
+        else:
+            features = []
+            for blk in self.blocks:
+                for idx, sub_blk in enumerate(blk):
+                    x = sub_blk(x)
+                    if (idx + 1) % (len(blk) // 4) == 0:
+                        features.append(x)
+
+            return [features, (B, (H+pad_h)//self.patch_size, (W+pad_w)//self.patch_size, H, W, self.num_register_tokens)]            
+        
+
+    def _get_intermediate_layers_not_chunked(self, x, n=1):
+        x = self.prepare_tokens_with_masks(x)
+        # If n is an int, take the n last blocks. If it's a list, take them
+        output, total_block_len = [], len(self.blocks)
+        blocks_to_take = range(total_block_len - n, total_block_len) if isinstance(n, int) else n
+        for i, blk in enumerate(self.blocks):
+            x = blk(x)
+            if i in blocks_to_take:
+                output.append(x)
+        assert len(output) == len(blocks_to_take), f"only {len(output)} / {len(blocks_to_take)} blocks found"
+        return output
+
+    def _get_intermediate_layers_chunked(self, x, n=1):
+        x = self.prepare_tokens_with_masks(x)
+        output, i, total_block_len = [], 0, len(self.blocks[-1])
+        # If n is an int, take the n last blocks. If it's a list, take them
+        blocks_to_take = range(total_block_len - n, total_block_len) if isinstance(n, int) else n
+        for block_chunk in self.blocks:
+            for blk in block_chunk[i:]:  # Passing the nn.Identity()
+                x = blk(x)
+                if i in blocks_to_take:
+                    output.append(x)
+                i += 1
+        assert len(output) == len(blocks_to_take), f"only {len(output)} / {len(blocks_to_take)} blocks found"
+        return output
+
+    def get_intermediate_layers(
+        self,
+        x: torch.Tensor,
+        n: Union[int, Sequence] = 1,  # Layers or n last layers to take
+        reshape: bool = False,
+        return_class_token: bool = False,
+        norm=True,
+    ) -> Tuple[Union[torch.Tensor, Tuple[torch.Tensor]]]:
+        if self.chunked_blocks:
+            outputs = self._get_intermediate_layers_chunked(x, n)
+        else:
+            outputs = self._get_intermediate_layers_not_chunked(x, n)
+        if norm:
+            outputs = [self.norm(out) for out in outputs]
+        class_tokens = [out[:, 0] for out in outputs]
+        outputs = [out[:, 1:] for out in outputs]
+        if reshape:
+            B, _, w, h = x.shape
+            outputs = [
+                out.reshape(B, w // self.patch_size, h // self.patch_size, -1).permute(0, 3, 1, 2).contiguous()
+                for out in outputs
+            ]
+        if return_class_token:
+            return tuple(zip(outputs, class_tokens))
+        return tuple(outputs)
+
+    def forward(self, *args, is_training=False, **kwargs):
+        ret = self.forward_features(*args, **kwargs)
+        return ret
+        # if is_training:
+        #     return ret
+        # else:
+        #     return self.head(ret["x_norm_clstoken"])
+
+
+def init_weights_vit_timm(module: nn.Module, name: str = ""):
+    """ViT weight initialization, original timm impl (for reproducibility)"""
+    if isinstance(module, nn.Linear):
+        trunc_normal_(module.weight, std=0.02)
+        if module.bias is not None:
+            nn.init.zeros_(module.bias)
+
+
+def load_ckpt_dino(checkpoint, model, reserve_norm=True):
+    if checkpoint is not None:
+        with open(checkpoint, "rb") as f:
+            state_dict = torch.load(f)
+        try:
+            model.load_state_dict(state_dict, strict=True)
+        except:
+            new_state_dict = {}
+            for key, value in state_dict.items():
+                if 'blocks' in key:
+                    key_new = 'blocks.0' + key[len('blocks'):]
+                else:
+                    key_new = key
+                new_state_dict[key_new] = value
+
+            model.load_state_dict(new_state_dict, strict=True)
+        del model.mask_token
+        if reserve_norm == False:
+            del model.norm
+        return
+    else:
+        return
+
+
+def vit_small(patch_size=14, num_register_tokens=0, checkpoint=None, **kwargs):
+    model = DinoVisionTransformer(
+        patch_size=patch_size,
+        embed_dim=384,
+        depth=12,
+        num_heads=6,
+        mlp_ratio=4,
+        block_fn=partial(Block, attn_class=MemEffAttention),
+        num_register_tokens=num_register_tokens,
+        **kwargs,
+    )
+
+    load_ckpt_dino(checkpoint, model)
+
+    return model
+
+
+def vit_base(patch_size=14, num_register_tokens=0, checkpoint=None, **kwargs):
+    model = DinoVisionTransformer(
+        patch_size=patch_size,
+        embed_dim=768,
+        depth=12,
+        num_heads=12,
+        mlp_ratio=4,
+        block_fn=partial(Block, attn_class=MemEffAttention),
+        num_register_tokens=num_register_tokens,
+        **kwargs,
+    )
+    return model
+
+
+def vit_large(patch_size=14, num_register_tokens=0, checkpoint=None, **kwargs):
+    model = DinoVisionTransformer(
+        patch_size=patch_size,
+        embed_dim=1024,
+        depth=24,
+        num_heads=16,
+        mlp_ratio=4,
+        block_fn=partial(Block, attn_class=MemEffAttention),
+        num_register_tokens=num_register_tokens,
+        **kwargs,
+    )
+
+    if checkpoint is not None:
+        with open(checkpoint, "rb") as f:
+            state_dict = torch.load(f)
+        try:
+            model.load_state_dict(state_dict, strict=True)
+        except:
+            new_state_dict = {}
+            for key, value in state_dict.items():
+                if 'blocks' in key:
+                    key_new = 'blocks.0' + key[len('blocks'):]
+                else:
+                    key_new = key
+                new_state_dict[key_new] = value
+
+            model.load_state_dict(new_state_dict, strict=True)
+        del model.mask_token
+    return model
+
+
+def vit_giant2(patch_size=14, num_register_tokens=0, checkpoint=None, **kwargs):
+    """
+    Close to ViT-giant, with embed-dim 1536 and 24 heads => embed-dim per head 64
+    """
+    model = DinoVisionTransformer(
+        patch_size=patch_size,
+        embed_dim=1536,
+        depth=40,
+        num_heads=24,
+        mlp_ratio=4,
+        block_fn=partial(Block, attn_class=MemEffAttention),
+        num_register_tokens=num_register_tokens,
+        ffn_layer='swiglu',
+        **kwargs,
+    )
+    return model
+
+
+
+def vit_small_reg(patch_size=14, num_register_tokens=4, checkpoint=None, **kwargs):
+    model = DinoVisionTransformer(
+        patch_size=patch_size,
+        embed_dim=384,
+        depth=12,
+        num_heads=6,
+        mlp_ratio=4,
+        block_fn=partial(Block, attn_class=MemEffAttention),
+        num_register_tokens=num_register_tokens,
+        **kwargs,
+    )
+
+    load_ckpt_dino(checkpoint, model)
+
+    return model
+
+
+def vit_base_reg(patch_size=14, num_register_tokens=4, checkpoint=None, **kwargs):
+    model = DinoVisionTransformer(
+        patch_size=patch_size,
+        embed_dim=768,
+        depth=12,
+        num_heads=12,
+        mlp_ratio=4,
+        block_fn=partial(Block, attn_class=MemEffAttention),
+        num_register_tokens=num_register_tokens,
+        **kwargs,
+    )
+
+    load_ckpt_dino(checkpoint, model)
+
+    return model
+
+
+def vit_large_reg(patch_size=14, num_register_tokens=4, checkpoint=None, **kwargs):
+    model = DinoVisionTransformer(
+        img_size = 518,
+        patch_size=patch_size,
+        embed_dim=1024,
+        depth=24,
+        num_heads=16,
+        mlp_ratio=4,
+        block_fn=partial(Block, attn_class=MemEffAttention),
+        num_register_tokens=num_register_tokens,
+        **kwargs,
+    )
+
+    load_ckpt_dino(checkpoint, model)
+
+    return model
+
+
+def vit_giant2_reg(patch_size=14, num_register_tokens=4, checkpoint=None, **kwargs):
+    """
+    Close to ViT-giant, with embed-dim 1536 and 24 heads => embed-dim per head 64
+    """
+    model = DinoVisionTransformer(
+        patch_size=patch_size,
+        embed_dim=1536,
+        depth=40,
+        num_heads=24,
+        mlp_ratio=4,
+        block_fn=partial(Block, attn_class=MemEffAttention),
+        num_register_tokens=num_register_tokens,
+        ffn_layer='swiglu',
+        multi_output=True,
+        **kwargs,
+    )
+
+    load_ckpt_dino(checkpoint, model, reserve_norm=False)
+
+    return model
+
+if __name__ == '__main__':
+    try:
+        from mmcv.utils import Config
+    except:
+        from mmengine import Config    
+    
+    #rgb = torch.rand((2, 3, 518, 518)).cuda()
+
+    #cfg.data_basic['crop_size']['0'] 
+    #cfg.data_basic['crop_size']['1'] 
+    cfg = Config.fromfile('mu.hu/monodepth/mono/configs/RAFTDecoder/vit.raft.full2t.py')
+
+    #rgb = torch.arange(0, 2*3*1036*1036, 1).cuda().float().view(2, 3, 1036, 1036)
+    rgb = torch.zeros(1, 3, 616, 1064).cuda()
+    #model = vit_large_reg(checkpoint="/cpfs02/shared/public/groups/local_map/yvan/pretrained_weight_repo/vit/dinov2_vitl14_reg4_pretrain.pth", kwarg=cfg).cuda()
+    model = vit_giant2_reg(checkpoint="pretrained_weight_repo/vit/dinov2_vitg14_reg4_pretrain.pth", kwarg=cfg).cuda()
+
+    #import timm
+    #model2 = timm.models.vision_transformer.vit_large_patch14_dinov2().cuda()
+    #timm.models.load_checkpoint(model2, '/cpfs02/shared/public/yvan/pretrained_weight_repo/vit/dinov2_vitl14_pretrain.pth', filter_fn=timm.models.vision_transformer.checkpoint_filter_fn)
+
+    out1 = model(rgb)
+    #out2 = model2(rgb)
+    temp = 0
+
+

external/Metric3D/training/mono/model/backbones/__init__.py

@@ -0,0 +1,8 @@
+from .ViT_DINO import vit_large
+from .ViT_DINO_reg import vit_small_reg, vit_large_reg, vit_giant2_reg 
+
+__all__ = [
+    "vit_small_reg",
+    "vit_large_reg", 
+    "vit_giant2_reg",
+]

external/Metric3D/training/mono/model/criterion.py

@@ -0,0 +1,62 @@
+from .losses import *
+from mono.utils.comm import get_func
+import os
+
+def build_from_cfg(cfg, default_args=None):
+    """Build a module from config dict.
+    Args:
+        cfg (dict): Config dict. It should at least contain the key "type".
+        default_args (dict, optional): Default initialization arguments.
+    Returns:
+        object: The constructed object.
+    """
+    if not isinstance(cfg, dict):
+        raise TypeError(f'cfg must be a dict, but got {type(cfg)}')
+    if 'type' not in cfg:
+        raise RuntimeError('should contain the loss name')
+    args = cfg.copy()
+    
+    obj_name = args.pop('type')
+    obj_path = os.path.dirname(__file__).split(os.getcwd() + '/')[-1].replace('/', '.') + '.losses.' + obj_name 
+    
+    obj_cls = get_func(obj_path)(**args)
+    
+    if obj_cls is None:
+        raise KeyError(f'cannot find {obj_name}.')
+    return obj_cls
+
+
+        
+        
+def build_criterions(cfg):
+    if 'losses' not in cfg:
+        raise RuntimeError('Losses have not been configured.')
+    cfg_data_basic = cfg.data_basic
+
+    criterions = dict()
+    losses = cfg.losses
+    if not isinstance(losses, dict):
+        raise RuntimeError(f'Cannot initial losses with the type {type(losses)}')
+    for key, loss_list in losses.items():
+        criterions[key] = []
+        for loss_cfg_i in loss_list:
+            # update the canonical_space configs to the current loss cfg
+            loss_cfg_i.update(cfg_data_basic)
+            if 'out_channel' in loss_cfg_i:
+                loss_cfg_i.update(out_channel=cfg.out_channel)  # classification loss need to update the channels
+            obj_cls = build_from_cfg(loss_cfg_i)
+            criterions[key].append(obj_cls)
+    return criterions
+            
+
+            
+        
+            
+            
+            
+            
+            
+            
+        
+    
+  

external/Metric3D/training/mono/model/decode_heads/RAFTDepthNormalDPTDecoder5.py

@@ -0,0 +1,818 @@
+import torch
+import torch.nn as nn
+import numpy as np
+import math
+import torch.nn.functional as F
+
+def compute_depth_expectation(prob, depth_values):
+    depth_values = depth_values.view(*depth_values.shape, 1, 1)
+    depth = torch.sum(prob * depth_values, 1)
+    return depth
+
+def interpolate_float32(x, size=None, scale_factor=None, mode='nearest', align_corners=None):
+    with torch.autocast(device_type='cuda', dtype=torch.bfloat16, enabled=False):
+        return F.interpolate(x.float(), size=size, scale_factor=scale_factor, mode=mode, align_corners=align_corners)
+
+# def upflow8(flow, mode='bilinear'):
+#     new_size = (8 * flow.shape[2], 8 * flow.shape[3])
+#     return  8 * F.interpolate(flow, size=new_size, mode=mode, align_corners=True)
+
+def upflow4(flow, mode='bilinear'):
+    new_size = (4 * flow.shape[2], 4 * flow.shape[3])
+    with torch.autocast(device_type='cuda', dtype=torch.bfloat16, enabled=False):
+        return  F.interpolate(flow, size=new_size, mode=mode, align_corners=True)
+
+def coords_grid(batch, ht, wd):
+    # coords = torch.meshgrid(torch.arange(ht), torch.arange(wd))
+    coords = (torch.zeros((ht, wd)), torch.zeros((ht, wd)), torch.zeros((ht, wd)), torch.zeros((ht, wd)), torch.zeros((ht, wd)), torch.zeros((ht, wd)))
+    coords = torch.stack(coords[::-1], dim=0).float()
+    return coords[None].repeat(batch, 1, 1, 1)
+
+def norm_normalize(norm_out):
+    min_kappa = 0.01
+    norm_x, norm_y, norm_z, kappa = torch.split(norm_out, 1, dim=1)
+    norm = torch.sqrt(norm_x ** 2.0 + norm_y ** 2.0 + norm_z ** 2.0) + 1e-10
+    kappa = F.elu(kappa) + 1.0 + min_kappa
+    final_out = torch.cat([norm_x / norm, norm_y / norm, norm_z / norm, kappa], dim=1)
+    return final_out
+
+# uncertainty-guided sampling (only used during training)
+@torch.no_grad()
+def sample_points(init_normal, gt_norm_mask, sampling_ratio, beta):
+    device = init_normal.device
+    B, _, H, W = init_normal.shape
+    N = int(sampling_ratio * H * W)
+    beta = beta
+
+    # uncertainty map
+    uncertainty_map = -1 * init_normal[:, -1, :, :]  # B, H, W
+
+    # gt_invalid_mask (B, H, W)
+    if gt_norm_mask is not None:
+        gt_invalid_mask = F.interpolate(gt_norm_mask.float(), size=[H, W], mode='nearest')
+        gt_invalid_mask = gt_invalid_mask[:, 0, :, :] < 0.5
+        uncertainty_map[gt_invalid_mask] = -1e4
+
+    # (B, H*W)
+    _, idx = uncertainty_map.view(B, -1).sort(1, descending=True)
+
+    # importance sampling
+    if int(beta * N) > 0:
+        importance = idx[:, :int(beta * N)]    # B, beta*N
+
+        # remaining
+        remaining = idx[:, int(beta * N):]     # B, H*W - beta*N
+
+        # coverage
+        num_coverage = N - int(beta * N)
+
+        if num_coverage <= 0:
+            samples = importance
+        else:
+            coverage_list = []
+            for i in range(B):
+                idx_c = torch.randperm(remaining.size()[1])    # shuffles "H*W - beta*N"
+                coverage_list.append(remaining[i, :][idx_c[:num_coverage]].view(1, -1))     # 1, N-beta*N
+            coverage = torch.cat(coverage_list, dim=0)                                      # B, N-beta*N
+            samples = torch.cat((importance, coverage), dim=1)                              # B, N
+
+    else:
+        # remaining
+        remaining = idx[:, :]  # B, H*W
+
+        # coverage
+        num_coverage = N
+
+        coverage_list = []
+        for i in range(B):
+            idx_c = torch.randperm(remaining.size()[1])  # shuffles "H*W - beta*N"
+            coverage_list.append(remaining[i, :][idx_c[:num_coverage]].view(1, -1))  # 1, N-beta*N
+        coverage = torch.cat(coverage_list, dim=0)  # B, N-beta*N
+        samples = coverage
+
+    # point coordinates
+    rows_int = samples // W         # 0 for first row, H-1 for last row
+    rows_float = rows_int / float(H-1)         # 0 to 1.0
+    rows_float = (rows_float * 2.0) - 1.0       # -1.0 to 1.0
+
+    cols_int = samples % W          # 0 for first column, W-1 for last column
+    cols_float = cols_int / float(W-1)         # 0 to 1.0
+    cols_float = (cols_float * 2.0) - 1.0       # -1.0 to 1.0
+
+    point_coords = torch.zeros(B, 1, N, 2)
+    point_coords[:, 0, :, 0] = cols_float             # x coord
+    point_coords[:, 0, :, 1] = rows_float             # y coord
+    point_coords = point_coords.to(device)
+    return point_coords, rows_int, cols_int
+    
+class FlowHead(nn.Module):
+    def __init__(self, input_dim=128, hidden_dim=256, output_dim_depth=2, output_dim_norm=4):
+        super(FlowHead, self).__init__()
+        self.conv1d = nn.Conv2d(input_dim, hidden_dim // 2, 3, padding=1)
+        self.conv2d = nn.Conv2d(hidden_dim // 2, output_dim_depth, 3, padding=1)
+
+        self.conv1n = nn.Conv2d(input_dim, hidden_dim // 2, 3, padding=1)
+        self.conv2n = nn.Conv2d(hidden_dim // 2, output_dim_norm, 3, padding=1)
+        self.relu = nn.ReLU(inplace=True)
+
+    def forward(self, x):
+        depth = self.conv2d(self.relu(self.conv1d(x)))
+        normal = self.conv2n(self.relu(self.conv1n(x)))
+        return torch.cat((depth, normal), dim=1)
+        
+
+class ConvGRU(nn.Module):
+    def __init__(self, hidden_dim, input_dim, kernel_size=3):
+        super(ConvGRU, self).__init__()
+        self.convz = nn.Conv2d(hidden_dim+input_dim, hidden_dim, kernel_size, padding=kernel_size//2)
+        self.convr = nn.Conv2d(hidden_dim+input_dim, hidden_dim, kernel_size, padding=kernel_size//2)
+        self.convq = nn.Conv2d(hidden_dim+input_dim, hidden_dim, kernel_size, padding=kernel_size//2)
+
+    def forward(self, h, cz, cr, cq, *x_list):
+        x = torch.cat(x_list, dim=1)
+        hx = torch.cat([h, x], dim=1)
+
+        z = torch.sigmoid((self.convz(hx) + cz))
+        r = torch.sigmoid((self.convr(hx) + cr))
+        q = torch.tanh((self.convq(torch.cat([r*h, x], dim=1)) + cq))
+
+        # z = torch.sigmoid((self.convz(hx) + cz).float())
+        # r = torch.sigmoid((self.convr(hx) + cr).float())
+        # q = torch.tanh((self.convq(torch.cat([r*h, x], dim=1)) + cq).float())
+
+        h = (1-z) * h + z * q
+        return h
+
+def pool2x(x):
+    return F.avg_pool2d(x, 3, stride=2, padding=1)
+
+def pool4x(x):
+    return F.avg_pool2d(x, 5, stride=4, padding=1)
+
+def interp(x, dest):
+    interp_args = {'mode': 'bilinear', 'align_corners': True}
+    return interpolate_float32(x, dest.shape[2:], **interp_args)
+
+class BasicMultiUpdateBlock(nn.Module):
+    def __init__(self, args, hidden_dims=[], out_dims=2):
+        super().__init__()
+        self.args = args
+        self.n_gru_layers = args.model.decode_head.n_gru_layers # 3
+        self.n_downsample = args.model.decode_head.n_downsample # 3, resolution of the disparity field (1/2^K)
+        
+        # self.encoder = BasicMotionEncoder(args)
+        # encoder_output_dim = 128 # if there is corr volume
+        encoder_output_dim = 6 # no corr volume
+
+        self.gru08 = ConvGRU(hidden_dims[2], encoder_output_dim + hidden_dims[1] * (self.n_gru_layers > 1))
+        self.gru16 = ConvGRU(hidden_dims[1], hidden_dims[0] * (self.n_gru_layers == 3) + hidden_dims[2])
+        self.gru32 = ConvGRU(hidden_dims[0], hidden_dims[1])
+        self.flow_head = FlowHead(hidden_dims[2], hidden_dim=2*hidden_dims[2])
+        factor = 2**self.n_downsample
+
+        self.mask = nn.Sequential(
+            nn.Conv2d(hidden_dims[2], hidden_dims[2], 3, padding=1),
+            nn.ReLU(inplace=True),
+            nn.Conv2d(hidden_dims[2], (factor**2)*9, 1, padding=0))
+
+    def forward(self, net, inp, corr=None, flow=None, iter08=True, iter16=True, iter32=True, update=True):
+
+        if iter32:
+            net[2] = self.gru32(net[2], *(inp[2]), pool2x(net[1]))
+        if iter16:
+            if self.n_gru_layers > 2:
+                net[1] = self.gru16(net[1], *(inp[1]), interp(pool2x(net[0]), net[1]), interp(net[2], net[1]))
+            else:
+                net[1] = self.gru16(net[1], *(inp[1]), interp(pool2x(net[0]), net[1]))
+        if iter08:
+            if corr is not None:
+                motion_features = self.encoder(flow, corr)
+            else:
+                motion_features = flow
+            if self.n_gru_layers > 1:
+                net[0] = self.gru08(net[0], *(inp[0]), motion_features, interp(net[1], net[0]))
+            else:
+                net[0] = self.gru08(net[0], *(inp[0]), motion_features)
+
+        if not update:
+            return net
+
+        delta_flow = self.flow_head(net[0])
+
+        # scale mask to balence gradients
+        mask = .25 * self.mask(net[0])
+        return net, mask, delta_flow
+
+class LayerNorm2d(nn.LayerNorm):
+    def __init__(self, dim):
+        super(LayerNorm2d, self).__init__(dim)
+
+    def forward(self, x):
+        x = x.permute(0, 2, 3, 1).contiguous()
+        x = super(LayerNorm2d, self).forward(x)
+        x = x.permute(0, 3, 1, 2).contiguous()
+        return x
+
+class ResidualBlock(nn.Module):
+    def __init__(self, in_planes, planes, norm_fn='group', stride=1):
+        super(ResidualBlock, self).__init__()
+  
+        self.conv1 = nn.Conv2d(in_planes, planes, kernel_size=3, padding=1, stride=stride)
+        self.conv2 = nn.Conv2d(planes, planes, kernel_size=3, padding=1)
+        self.relu = nn.ReLU(inplace=True)
+
+        num_groups = planes // 8
+
+        if norm_fn == 'group':
+            self.norm1 = nn.GroupNorm(num_groups=num_groups, num_channels=planes)
+            self.norm2 = nn.GroupNorm(num_groups=num_groups, num_channels=planes)
+            if not (stride == 1 and in_planes == planes):
+                self.norm3 = nn.GroupNorm(num_groups=num_groups, num_channels=planes)
+        
+        elif norm_fn == 'batch':
+            self.norm1 = nn.BatchNorm2d(planes)
+            self.norm2 = nn.BatchNorm2d(planes)
+            if not (stride == 1 and in_planes == planes):
+                self.norm3 = nn.BatchNorm2d(planes)
+        
+        elif norm_fn == 'instance':
+            self.norm1 = nn.InstanceNorm2d(planes)
+            self.norm2 = nn.InstanceNorm2d(planes)
+            if not (stride == 1 and in_planes == planes):
+                self.norm3 = nn.InstanceNorm2d(planes)
+
+        elif norm_fn == 'layer':
+            self.norm1 = LayerNorm2d(planes)
+            self.norm2 = LayerNorm2d(planes)
+            if not (stride == 1 and in_planes == planes):
+                self.norm3 = LayerNorm2d(planes)
+
+        elif norm_fn == 'none':
+            self.norm1 = nn.Sequential()
+            self.norm2 = nn.Sequential()
+            if not (stride == 1 and in_planes == planes):
+                self.norm3 = nn.Sequential()
+
+        if stride == 1 and in_planes == planes:
+            self.downsample = None
+        
+        else:    
+            self.downsample = nn.Sequential(
+                nn.Conv2d(in_planes, planes, kernel_size=1, stride=stride), self.norm3)
+            
+    def forward(self, x):
+        y = x
+        y = self.conv1(y)
+        y = self.norm1(y)
+        y = self.relu(y)
+        y = self.conv2(y)
+        y = self.norm2(y)
+        y = self.relu(y)
+
+        if self.downsample is not None:
+            x = self.downsample(x)
+
+        return self.relu(x+y)
+
+
+class ContextFeatureEncoder(nn.Module):
+    '''
+    Encoder features are used to:
+        1. initialize the hidden state of the update operator 
+        2. and also injected into the GRU during each iteration of the update operator
+    '''
+    def __init__(self, in_dim, output_dim):
+        '''
+        in_dim     = [x4, x8, x16, x32]
+        output_dim = [hindden_dims,   context_dims]
+                    [[x4,x8,x16,x32],[x4,x8,x16,x32]]
+        '''
+        super().__init__()
+
+        output_list = []
+        for dim in output_dim:
+            conv_out = nn.Sequential(
+                ResidualBlock(in_dim[0], dim[0], 'layer', stride=1),
+                nn.Conv2d(dim[0], dim[0], 3, padding=1))
+            output_list.append(conv_out)
+
+        self.outputs04 = nn.ModuleList(output_list)
+
+        output_list = []
+        for dim in output_dim:
+            conv_out = nn.Sequential(
+                ResidualBlock(in_dim[1], dim[1], 'layer', stride=1),
+                nn.Conv2d(dim[1], dim[1], 3, padding=1))
+            output_list.append(conv_out)
+
+        self.outputs08 = nn.ModuleList(output_list)
+
+        output_list = []
+        for dim in output_dim:
+            conv_out = nn.Sequential(
+                ResidualBlock(in_dim[2], dim[2], 'layer', stride=1),
+                nn.Conv2d(dim[2], dim[2], 3, padding=1))
+            output_list.append(conv_out)
+
+        self.outputs16 = nn.ModuleList(output_list)
+
+        # output_list = []
+        # for dim in output_dim:
+        #     conv_out = nn.Conv2d(in_dim[3], dim[3], 3, padding=1)
+        #     output_list.append(conv_out)
+
+        # self.outputs32 = nn.ModuleList(output_list)
+
+    def forward(self, encoder_features):
+        x_4, x_8, x_16, x_32 = encoder_features
+
+        outputs04 = [f(x_4) for f in self.outputs04]
+        outputs08 = [f(x_8) for f in self.outputs08]
+        outputs16 = [f(x_16)for f in self.outputs16]
+        # outputs32 = [f(x_32) for f in self.outputs32]
+
+        return (outputs04, outputs08, outputs16)
+
+class ConvBlock(nn.Module):
+    # reimplementation of DPT
+    def __init__(self, channels):
+        super(ConvBlock, self).__init__()
+
+        self.act = nn.ReLU(inplace=True)
+        self.conv1 = nn.Conv2d(
+            channels,
+            channels,
+            kernel_size=3,
+            stride=1,
+            padding=1
+        )
+        self.conv2 = nn.Conv2d(
+            channels,
+            channels,
+            kernel_size=3,
+            stride=1,
+            padding=1
+        )
+
+    def forward(self, x):
+        out = self.act(x)
+        out = self.conv1(out)
+        out = self.act(out)
+        out = self.conv2(out)
+        return x + out
+
+class FuseBlock(nn.Module):
+    # reimplementation of DPT
+    def __init__(self, in_channels, out_channels, fuse=True, upsample=True, scale_factor=2):
+        super(FuseBlock, self).__init__()
+
+        self.fuse = fuse
+        self.scale_factor = scale_factor
+        self.way_trunk = ConvBlock(in_channels)
+        if self.fuse:
+            self.way_branch = ConvBlock(in_channels)
+        
+        self.out_conv = nn.Conv2d(
+            in_channels,
+            out_channels,
+            kernel_size=1,
+            stride=1,
+            padding=0,
+        )
+        self.upsample = upsample
+
+    def forward(self, x1, x2=None):
+        if x2 is not None:
+            x2 = self.way_branch(x2)
+            x1 = x1 + x2
+
+        out = self.way_trunk(x1)
+
+        if self.upsample:
+            out = interpolate_float32(
+                out, scale_factor=self.scale_factor, mode="bilinear", align_corners=True
+            )
+        out = self.out_conv(out)
+        return out
+
+class Readout(nn.Module):  
+    # From DPT
+    def __init__(self, in_features, use_cls_token=True, num_register_tokens=0):
+        super(Readout, self).__init__()
+        self.use_cls_token = use_cls_token
+        if self.use_cls_token == True:
+            self.project_patch = nn.Linear(in_features, in_features)
+            self.project_learn = nn.Linear((1 + num_register_tokens) * in_features, in_features, bias=False) 
+            self.act = nn.GELU()
+        else:
+            self.project = nn.Identity()
+
+    def forward(self, x):
+
+        if self.use_cls_token == True:
+            x_patch = self.project_patch(x[0])
+            x_learn = self.project_learn(x[1])
+            x_learn = x_learn.expand_as(x_patch).contiguous()
+            features = x_patch + x_learn
+            return self.act(features)
+        else:
+            return self.project(x)
+
+class Token2Feature(nn.Module):
+    # From DPT
+    def __init__(self, vit_channel, feature_channel, scale_factor, use_cls_token=True, num_register_tokens=0):
+        super(Token2Feature, self).__init__()
+        self.scale_factor = scale_factor
+        self.readoper = Readout(in_features=vit_channel, use_cls_token=use_cls_token, num_register_tokens=num_register_tokens)
+        if scale_factor > 1 and isinstance(scale_factor, int):
+            self.sample = nn.ConvTranspose2d(
+                in_channels=vit_channel,
+                out_channels=feature_channel,
+                kernel_size=scale_factor,
+                stride=scale_factor,
+                padding=0,
+            )
+        
+        elif scale_factor > 1:
+            self.sample = nn.Sequential(
+                # Upsample2(upscale=scale_factor),
+                # nn.Upsample(scale_factor=scale_factor),
+                nn.Conv2d(
+                    in_channels=vit_channel,
+                    out_channels=feature_channel,
+                    kernel_size=1,
+                    stride=1,
+                    padding=0,
+                ),
+            )
+            
+
+        elif scale_factor < 1:
+            scale_factor = int(1.0 / scale_factor)
+            self.sample = nn.Conv2d(
+                in_channels=vit_channel,
+                out_channels=feature_channel,
+                kernel_size=scale_factor+1,
+                stride=scale_factor,
+                padding=1,
+            )
+
+        else:
+            self.sample = nn.Identity()
+
+    def forward(self, x):
+        x = self.readoper(x)
+        #if use_cls_token == True:
+        x = x.permute(0, 3, 1, 2).contiguous()
+        if isinstance(self.scale_factor, float):
+            x = interpolate_float32(x.float(), scale_factor=self.scale_factor, mode='nearest')
+        x = self.sample(x)
+        return x
+
+class EncoderFeature(nn.Module):
+    def __init__(self, vit_channel, num_ch_dec=[256, 512, 1024, 1024], use_cls_token=True, num_register_tokens=0):
+        super(EncoderFeature, self).__init__()
+        self.vit_channel = vit_channel
+        self.num_ch_dec = num_ch_dec
+
+        self.read_3 = Token2Feature(self.vit_channel, self.num_ch_dec[3], scale_factor=1, use_cls_token=use_cls_token, num_register_tokens=num_register_tokens)
+        self.read_2 = Token2Feature(self.vit_channel, self.num_ch_dec[2], scale_factor=1, use_cls_token=use_cls_token, num_register_tokens=num_register_tokens)
+        self.read_1 = Token2Feature(self.vit_channel, self.num_ch_dec[1], scale_factor=2, use_cls_token=use_cls_token, num_register_tokens=num_register_tokens)
+        self.read_0 = Token2Feature(self.vit_channel, self.num_ch_dec[0], scale_factor=7/2, use_cls_token=use_cls_token, num_register_tokens=num_register_tokens)
+
+    def forward(self, ref_feature):
+        x = self.read_3(ref_feature[3])  # 1/14
+        x2 = self.read_2(ref_feature[2]) # 1/14
+        x1 = self.read_1(ref_feature[1]) # 1/7
+        x0 = self.read_0(ref_feature[0]) # 1/4
+
+        return x, x2, x1, x0
+
+class DecoderFeature(nn.Module):
+    def __init__(self, vit_channel, num_ch_dec=[128, 256, 512, 1024, 1024], use_cls_token=True):
+        super(DecoderFeature, self).__init__()
+        self.vit_channel = vit_channel
+        self.num_ch_dec = num_ch_dec
+
+        self.upconv_3 = FuseBlock(
+            self.num_ch_dec[4], 
+            self.num_ch_dec[3], 
+        fuse=False, upsample=False)
+        
+        self.upconv_2 = FuseBlock(
+            self.num_ch_dec[3], 
+            self.num_ch_dec[2],
+        )
+        
+        self.upconv_1 = FuseBlock(
+            self.num_ch_dec[2], 
+            self.num_ch_dec[1] + 2,
+            scale_factor=7/4
+        )
+
+        # self.upconv_0 = FuseBlock(
+        #     self.num_ch_dec[1], 
+        #     self.num_ch_dec[0] + 1,
+        # )
+    
+    def forward(self, ref_feature):
+        x, x2, x1, x0 = ref_feature # 1/14 1/14 1/7 1/4
+     
+        x = self.upconv_3(x)     # 1/14
+        x = self.upconv_2(x, x2) # 1/7
+        x = self.upconv_1(x, x1) # 1/4
+        # x = self.upconv_0(x, x0) # 4/7
+        return x
+
+class RAFTDepthNormalDPT5(nn.Module):
+    def __init__(self, cfg):
+        super().__init__()
+        self.in_channels = cfg.model.decode_head.in_channels # [1024, 1024, 1024, 1024]
+        self.feature_channels = cfg.model.decode_head.feature_channels # [256, 512, 1024, 1024] [2/7, 1/7, 1/14, 1/14]
+        self.decoder_channels = cfg.model.decode_head.decoder_channels # [128, 256, 512, 1024, 1024] [-, 1/4, 1/7, 1/14, 1/14]
+        self.use_cls_token = cfg.model.decode_head.use_cls_token
+        self.up_scale = cfg.model.decode_head.up_scale
+        self.num_register_tokens = cfg.model.decode_head.num_register_tokens
+        self.min_val = cfg.data_basic.depth_normalize[0]
+        self.max_val = cfg.data_basic.depth_normalize[1]
+        self.regress_scale = 100.0
+
+        self.hidden_dims = self.context_dims = cfg.model.decode_head.hidden_channels # [128, 128, 128, 128]
+        self.n_gru_layers = cfg.model.decode_head.n_gru_layers # 3
+        self.n_downsample = cfg.model.decode_head.n_downsample # 3, resolution of the disparity field (1/2^K)
+        self.iters = cfg.model.decode_head.iters # 22
+        self.slow_fast_gru = cfg.model.decode_head.slow_fast_gru # True
+
+        self.num_depth_regressor_anchor = 256 # 512
+        self.used_res_channel = self.decoder_channels[1] # now, use 2/7 res
+        self.token2feature = EncoderFeature(self.in_channels[0], self.feature_channels, self.use_cls_token, self.num_register_tokens)
+        self.decoder_mono = DecoderFeature(self.in_channels, self.decoder_channels)
+        self.depth_regressor = nn.Sequential(
+            nn.Conv2d(self.used_res_channel,
+                      self.num_depth_regressor_anchor,
+                      kernel_size=3,
+                      padding=1),
+            # nn.BatchNorm2d(self.num_depth_regressor_anchor),
+            nn.ReLU(inplace=True),
+            nn.Conv2d(self.num_depth_regressor_anchor,
+                      self.num_depth_regressor_anchor,
+                      kernel_size=1),
+        )
+        self.normal_predictor = nn.Sequential(
+            nn.Conv2d(self.used_res_channel,
+                      128,
+                      kernel_size=3,
+                      padding=1),
+            # nn.BatchNorm2d(128),
+            nn.ReLU(inplace=True),
+            nn.Conv2d(128, 128, kernel_size=1), nn.ReLU(inplace=True),
+            nn.Conv2d(128, 128, kernel_size=1), nn.ReLU(inplace=True),
+            nn.Conv2d(128, 3, kernel_size=1),
+        )
+
+        self.context_feature_encoder = ContextFeatureEncoder(self.feature_channels, [self.hidden_dims, self.context_dims])
+        self.context_zqr_convs = nn.ModuleList([nn.Conv2d(self.context_dims[i], self.hidden_dims[i]*3, 3, padding=3//2) for i in range(self.n_gru_layers)])
+        self.update_block = BasicMultiUpdateBlock(cfg, hidden_dims=self.hidden_dims, out_dims=6)
+
+        self.relu = nn.ReLU(inplace=True)
+    
+    def get_bins(self, bins_num):
+        depth_bins_vec = torch.linspace(math.log(self.min_val), math.log(self.max_val), bins_num, device="cuda")
+        depth_bins_vec = torch.exp(depth_bins_vec)
+        return depth_bins_vec
+    
+    def register_depth_expectation_anchor(self, bins_num, B):
+        depth_bins_vec = self.get_bins(bins_num)
+        depth_bins_vec = depth_bins_vec.unsqueeze(0).repeat(B, 1)        
+        self.register_buffer('depth_expectation_anchor', depth_bins_vec, persistent=False)
+    
+    def clamp(self, x):
+        y = self.relu(x - self.min_val) + self.min_val
+        y = self.max_val - self.relu(self.max_val - y)
+        return y
+    
+    def regress_depth(self, feature_map_d):
+        prob_feature = self.depth_regressor(feature_map_d)
+        prob = prob_feature.softmax(dim=1)
+        #prob = prob_feature.float().softmax(dim=1)
+
+        ## Error logging
+        if torch.isnan(prob).any():
+            print('prob_feat_nan!!!')
+        if torch.isinf(prob).any():
+            print('prob_feat_inf!!!')
+
+        # h = prob[0,:,0,0].cpu().numpy().reshape(-1)
+        # import matplotlib.pyplot as plt 
+        # plt.bar(range(len(h)), h)
+        B = prob.shape[0]
+        if "depth_expectation_anchor" not in self._buffers:
+            self.register_depth_expectation_anchor(self.num_depth_regressor_anchor, B)
+        d = compute_depth_expectation(
+            prob,
+            self.depth_expectation_anchor[:B, ...]).unsqueeze(1)
+
+        ## Error logging
+        if torch.isnan(d ).any():
+            print('d_nan!!!')
+        if torch.isinf(d ).any():
+            print('d_inf!!!')
+
+        return (self.clamp(d) - self.max_val)/ self.regress_scale, prob_feature
+
+    def pred_normal(self, feature_map, confidence):
+        normal_out = self.normal_predictor(feature_map)
+
+        ## Error logging
+        if torch.isnan(normal_out).any():
+            print('norm_nan!!!')
+        if torch.isinf(normal_out).any():
+            print('norm_feat_inf!!!')
+
+        return norm_normalize(torch.cat([normal_out, confidence], dim=1))
+        #return norm_normalize(torch.cat([normal_out, confidence], dim=1).float())
+    
+    def create_mesh_grid(self, height, width, batch, device="cuda", set_buffer=True):
+        y, x = torch.meshgrid([torch.arange(0, height, dtype=torch.float32, device=device),
+                               torch.arange(0, width, dtype=torch.float32, device=device)], indexing='ij')
+        meshgrid = torch.stack((x, y))
+        meshgrid = meshgrid.unsqueeze(0).repeat(batch, 1, 1, 1)
+        #self.register_buffer('meshgrid', meshgrid, persistent=False)
+        return meshgrid
+
+    def upsample_flow(self, flow, mask):
+        """ Upsample flow field [H/8, W/8, 2] -> [H, W, 2] using convex combination """
+        N, D, H, W = flow.shape
+        factor = 2 ** self.n_downsample
+        mask = mask.view(N, 1, 9, factor, factor, H, W)
+        mask = torch.softmax(mask, dim=2)
+        #mask = torch.softmax(mask.float(), dim=2)
+
+        #up_flow = F.unfold(factor * flow, [3,3], padding=1)
+        up_flow = F.unfold(flow, [3,3], padding=1)
+        up_flow = up_flow.view(N, D, 9, 1, 1, H, W)
+
+        up_flow = torch.sum(mask * up_flow, dim=2)
+        up_flow = up_flow.permute(0, 1, 4, 2, 5, 3)
+        return up_flow.reshape(N, D, factor*H, factor*W)
+
+    def initialize_flow(self, img):
+        """ Flow is represented as difference between two coordinate grids flow = coords1 - coords0"""
+        N, _, H, W = img.shape
+
+        coords0 = coords_grid(N, H, W).to(img.device)
+        coords1 = coords_grid(N, H, W).to(img.device)
+
+        return coords0, coords1
+    
+    def upsample(self, x, scale_factor=2):
+        """Upsample input tensor by a factor of 2
+        """
+        return interpolate_float32(x, scale_factor=scale_factor*self.up_scale/8, mode="nearest")
+
+    def forward(self, vit_features, **kwargs):
+        ## read vit token to multi-scale features
+        B, H, W, _, _, num_register_tokens = vit_features[1]
+        vit_features = vit_features[0]
+
+        ## Error logging
+        if torch.isnan(vit_features[0]).any():
+            print('vit_feature_nan!!!')
+        if torch.isinf(vit_features[0]).any():
+            print('vit_feature_inf!!!')
+
+        if self.use_cls_token == True:
+            vit_features = [[ft[:, 1+num_register_tokens:, :].view(B, H, W, self.in_channels[0]), \
+                ft[:, 0:1+num_register_tokens, :].view(B, 1, 1, self.in_channels[0] * (1+num_register_tokens))] for ft in vit_features]
+        else:
+            vit_features = [ft.view(B, H, W, self.in_channels[0]) for ft in vit_features]
+        encoder_features = self.token2feature(vit_features) # 1/14, 1/14, 1/7, 1/4
+
+        ## Error logging
+        for en_ft in encoder_features:
+            if torch.isnan(en_ft).any():
+                print('decoder_feature_nan!!!')
+                print(en_ft.shape)
+            if torch.isinf(en_ft).any():
+                print('decoder_feature_inf!!!')
+                print(en_ft.shape)
+
+        ## decode features to init-depth (and confidence)
+        ref_feat= self.decoder_mono(encoder_features) # now, 1/4 for depth
+
+        ## Error logging
+        if torch.isnan(ref_feat).any():
+            print('ref_feat_nan!!!')
+        if torch.isinf(ref_feat).any():
+            print('ref_feat_inf!!!')
+
+        feature_map = ref_feat[:, :-2, :, :] # feature map share of depth and normal prediction
+        depth_confidence_map = ref_feat[:, -2:-1, :, :]
+        normal_confidence_map = ref_feat[:, -1:, :, :]
+        depth_pred, binmap = self.regress_depth(feature_map) # regress bin for depth
+        normal_pred = self.pred_normal(feature_map, normal_confidence_map) # mlp for normal
+
+        depth_init = torch.cat((depth_pred, depth_confidence_map, normal_pred), dim=1) # (N, 1+1+4, H, W)
+
+        ## encoder features to context-feature for init-hidden-state and contex-features
+        cnet_list = self.context_feature_encoder(encoder_features[::-1])
+        net_list = [torch.tanh(x[0]) for x in cnet_list] # x_4, x_8, x_16 of hidden state
+        inp_list = [torch.relu(x[1]) for x in cnet_list] # x_4, x_8, x_16 context features
+
+        # Rather than running the GRU's conv layers on the context features multiple times, we do it once at the beginning 
+        inp_list = [list(conv(i).split(split_size=conv.out_channels//3, dim=1)) for i,conv in zip(inp_list, self.context_zqr_convs)]
+
+        coords0, coords1 = self.initialize_flow(net_list[0])
+        if depth_init is not None:
+            coords1 = coords1 + depth_init
+
+        if self.training:
+            low_resolution_init = [self.clamp(depth_init[:,:1] * self.regress_scale + self.max_val), depth_init[:,1:2], norm_normalize(depth_init[:,2:].clone())]
+            init_depth = upflow4(depth_init)
+            flow_predictions = [self.clamp(init_depth[:,:1] * self.regress_scale + self.max_val)]
+            conf_predictions = [init_depth[:,1:2]]
+            normal_outs = [norm_normalize(init_depth[:,2:].clone())]
+
+        else:
+            flow_predictions = []
+            conf_predictions = []
+            samples_pred_list = []
+            coord_list = []
+            normal_outs = []
+            low_resolution_init = []
+
+        for itr in range(self.iters):
+            # coords1 = coords1.detach()
+            flow = coords1 - coords0
+            if self.n_gru_layers == 3 and self.slow_fast_gru: # Update low-res GRU
+                net_list = self.update_block(net_list, inp_list, iter32=True, iter16=False, iter08=False, update=False)
+            if self.n_gru_layers >= 2 and self.slow_fast_gru:# Update low-res GRU and mid-res GRU
+                net_list = self.update_block(net_list, inp_list, iter32=self.n_gru_layers==3, iter16=True, iter08=False, update=False)
+            net_list, up_mask, delta_flow = self.update_block(net_list, inp_list, None, flow, iter32=self.n_gru_layers==3, iter16=self.n_gru_layers>=2)
+
+            # F(t+1) = F(t) + \Delta(t)
+            coords1 = coords1 + delta_flow
+
+            # We do not need to upsample or output intermediate results in test_mode
+            #if (not self.training) and itr < self.iters-1:
+                #continue
+
+            # upsample predictions
+            if up_mask is None:
+                flow_up = self.upsample(coords1-coords0, 4)
+            else:
+                flow_up = self.upsample_flow(coords1 - coords0, up_mask)
+                # flow_up = self.upsample(coords1-coords0, 4)
+
+            flow_predictions.append(self.clamp(flow_up[:,:1] * self.regress_scale + self.max_val))
+            conf_predictions.append(flow_up[:,1:2])
+            normal_outs.append(norm_normalize(flow_up[:,2:].clone()))
+
+        outputs=dict(
+            prediction=flow_predictions[-1],
+            predictions_list=flow_predictions,
+            confidence=conf_predictions[-1],
+            confidence_list=conf_predictions,
+            pred_logit=None,
+            # samples_pred_list=samples_pred_list,
+            # coord_list=coord_list,
+            prediction_normal=normal_outs[-1],
+            normal_out_list=normal_outs,
+            low_resolution_init=low_resolution_init,
+        )
+
+        return outputs
+
+
+if __name__ == "__main__":
+    try:
+        from mmcv.utils import Config
+    except:
+        from mmengine import Config
+    cfg = Config.fromfile('/mu.hu/monodepth/mono/configs/RAFTDecoder/vit.raft.full2t.py')
+    cfg.model.decode_head.in_channels = [384, 384, 384, 384]
+    cfg.model.decode_head.feature_channels = [96, 192, 384, 768]
+    cfg.model.decode_head.decoder_channels = [48, 96, 192, 384, 384]
+    cfg.model.decode_head.hidden_channels = [48, 48, 48, 48, 48]
+    cfg.model.decode_head.up_scale = 7
+    
+    # cfg.model.decode_head.use_cls_token = True
+    # vit_feature = [[torch.rand((2, 20, 60, 384)).cuda(), torch.rand(2, 384).cuda()], \
+    #         [torch.rand((2, 20, 60, 384)).cuda(), torch.rand(2, 384).cuda()], \
+    #         [torch.rand((2, 20, 60, 384)).cuda(), torch.rand(2, 384).cuda()], \
+    #         [torch.rand((2, 20, 60, 384)).cuda(), torch.rand(2, 384).cuda()]]
+    
+    cfg.model.decode_head.use_cls_token = True
+    cfg.model.decode_head.num_register_tokens = 4
+    vit_feature = [[torch.rand((2, (74 * 74) + 5, 384)).cuda(),\
+                    torch.rand((2, (74 * 74) + 5, 384)).cuda(), \
+                    torch.rand((2, (74 * 74) + 5, 384)).cuda(), \
+                    torch.rand((2, (74 * 74) + 5, 384)).cuda()], (2, 74, 74, 1036, 1036, 4)]
+
+    decoder = RAFTDepthNormalDPT5(cfg).cuda()
+    output = decoder(vit_feature)
+    temp = 1
+
+
+
+

external/Metric3D/training/mono/model/decode_heads/__init__.py

@@ -0,0 +1,4 @@
+from .RAFTDepthNormalDPTDecoder5 import RAFTDepthNormalDPT5
+
+__all__=['RAFTDepthNormalDPT5'
+]

external/Metric3D/training/mono/model/losses/AdabinsLoss.py

@@ -0,0 +1,101 @@
+import numpy as np
+import torch
+import torch.nn as nn
+from torch.nn.utils.rnn import pad_sequence
+#from pytorch3d.loss import chamfer_distance
+
+class AdabinsLoss(nn.Module):
+    """
+    Losses employed in Adabins.
+    """
+    def __init__(self, depth_normalize, variance_focus=0.85, loss_weight=1, out_channel=100, data_type=['stereo', 'lidar'],  w_ce=False, w_chamber=False, **kwargs):
+        super(AdabinsLoss, self).__init__()
+        self.variance_focus = variance_focus
+        self.loss_weight = loss_weight
+        self.data_type = data_type
+        #self.bins_num = out_channel
+        #self.cel = nn.CrossEntropyLoss(ignore_index=self.bins_num + 1)
+        self.depth_min = depth_normalize[0]
+        self.depth_max = depth_normalize[1]
+        self.w_ce = w_ce
+        self.eps = 1e-6
+    
+    def silog_loss(self, prediction, target, mask):
+        d = torch.log(prediction[mask]) - torch.log(target[mask])
+        d_square_mean = torch.sum(d ** 2) / (d.numel() + self.eps)
+        d_mean = torch.sum(d) / (d.numel() + self.eps)
+        loss = torch.sqrt(d_square_mean - self.variance_focus * (d_mean ** 2))
+        return loss
+    
+    def chamfer_distance_loss(self, bins, target_depth_maps, mask):
+        bin_centers = 0.5 * (bins[:, 1:] + bins[:, :-1])
+        n, p = bin_centers.shape
+        input_points = bin_centers.view(n, p, 1)  # .shape = n, p, 1
+        # n, c, h, w = target_depth_maps.shape
+
+        target_points = target_depth_maps.flatten(1)  # n, hwc
+        #mask = target_points.ge(1e-3)  # only valid ground truth points
+        target_points = [p[m] for p, m in zip(target_depth_maps, mask)]
+        target_lengths = torch.Tensor([len(t) for t in target_points], dtype=torch.long, device="cuda")
+        target_points = pad_sequence(target_points, batch_first=True).unsqueeze(2)  # .shape = n, T, 1
+
+        loss, _ = chamfer_distance(x=input_points, y=target_points, y_lengths=target_lengths)
+        return loss
+    
+    # def depth_to_bins(self, depth, mask, depth_edges, size_limite=(512, 960)):
+    #     """
+    #     Discretize depth into depth bins. Predefined bins edges are provided.
+    #     Mark invalid padding area as bins_num + 1
+    #     Args:
+    #         @depth: 1-channel depth, [B, 1, h, w]
+    #     return: depth bins [B, C, h, w]
+    #     """ 
+    #     def _depth_to_bins_block_(depth, mask, depth_edges):
+    #         bins_id = torch.sum(depth_edges[:, None, None, None, :] < torch.abs(depth)[:, :, :, :, None], dim=-1)
+    #         bins_id = bins_id - 1
+    #         invalid_mask = ~mask
+    #         mask_lower = (depth <= self.depth_min) 
+    #         mask_higher = (depth >= self.depth_max)
+            
+    #         bins_id[mask_lower] = 0
+    #         bins_id[mask_higher] = self.bins_num - 1
+    #         bins_id[bins_id == self.bins_num] = self.bins_num - 1
+
+    #         bins_id[invalid_mask] = self.bins_num + 1
+    #         return bins_id
+    #     # _, _, H, W = depth.shape
+    #     # bins = mask.clone().long()
+    #     # h_blocks = np.ceil(H / size_limite[0]).astype(np.int)
+    #     # w_blocks = np.ceil(W/ size_limite[1]).astype(np.int)
+    #     # for i in range(h_blocks):
+    #     #     for j in range(w_blocks):
+    #     #         h_start = i*size_limite[0]
+    #     #         h_end_proposal = (i + 1) * size_limite[0]
+    #     #         h_end = h_end_proposal if h_end_proposal < H else H
+    #     #         w_start = j*size_limite[1]
+    #     #         w_end_proposal = (j + 1) * size_limite[1]
+    #     #         w_end = w_end_proposal if w_end_proposal < W else W
+    #     #         bins_ij = _depth_to_bins_block_(
+    #     #             depth[:, :, h_start:h_end, w_start:w_end], 
+    #     #             mask[:, :, h_start:h_end, w_start:w_end],
+    #     #             depth_edges
+    #     #             )
+    #     #         bins[:, :, h_start:h_end, w_start:w_end] = bins_ij        
+    #     bins = _depth_to_bins_block_(depth, mask, depth_edges)
+    #     return bins
+    
+    # def ce_loss(self, pred_logit, target, mask, bins_edges):
+    #     target_depth_bins = self.depth_to_bins(target, mask, bins_edges)
+    #     loss = self.cel(pred_logit, target_depth_bins.squeeze().long())
+    #     return loss
+
+
+    def forward(self, prediction, target, bins_edges, mask=None, **kwargs):
+        silog_loss = self.silog_loss(prediction=prediction, target=target, mask=mask)
+        #cf_loss = self.chamfer_distance_loss(bins=bins_edges, target_depth_maps=target, mask=mask)
+        loss = silog_loss * 10 #+ 0.1 * cf_loss
+        # if self.w_ce:
+        #     loss = loss + self.ce_loss(kwargs['pred_logit'], target, mask, bins_edges)
+        if torch.isnan(loss).item() | torch.isinf(loss).item():
+            raise RuntimeError(f'Adabins loss error, {loss}')
+        return loss * self.loss_weight

external/Metric3D/training/mono/model/losses/ConfidenceGuideLoss.py

@@ -0,0 +1,54 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+class ConfidenceGuideLoss(nn.Module):
+    """
+    confidence guide depth loss.
+    """
+    def __init__(self, loss_weight=1, data_type=['stereo', 'lidar', 'denselidar'], loss_gamma=0.9, conf_loss=True, **kwargs):
+        super(ConfidenceGuideLoss, self).__init__()
+        self.loss_weight = loss_weight
+        self.data_type = data_type
+        self.eps = 1e-6
+        self.loss_gamma = loss_gamma
+        self.conf_loss = conf_loss
+
+    def forward(self, samples_pred_list, target, coord_list, mask=None, **kwargs):
+        loss = 0.0
+        n_predictions = len(samples_pred_list)
+        for i, (pred, coord) in enumerate(zip(samples_pred_list, coord_list)):
+            # coord: B, 1, N, 2
+            # pred: B, 2, N
+            gt_depth_ = F.grid_sample(target, coord, mode='nearest', align_corners=True) # (B, 1, 1, N)
+            gt_depth_mask_ = F.grid_sample(mask.float(), coord, mode='nearest', align_corners=True) # (B, 1, 1, N)
+            gt_depth_ = gt_depth_[:, :, 0, :]
+            gt_depth_mask_ = gt_depth_mask_[:, :, 0, :] > 0.5
+
+            pred_depth, pred_conf = pred[:, :1, :], pred[:, 1:, :]
+
+            # We adjust the loss_gamma so it is consistent for any number of RAFT-Stereo iterations
+            adjusted_loss_gamma = self.loss_gamma**(15/(n_predictions - 1))
+            i_weight = adjusted_loss_gamma**(n_predictions - i - 1)
+
+            # depth L1 loss
+            diff = torch.abs(pred_depth - gt_depth_) * gt_depth_mask_
+            curr_loss = torch.sum(diff) / (torch.sum(gt_depth_mask_) + self.eps)
+            if torch.isnan(curr_loss).item() | torch.isinf(curr_loss).item():
+                curr_loss = 0 * torch.sum(pred_depth)
+                print(f'GRUSequenceLoss-depth NAN error, {loss}')
+
+            # confidence L1 loss
+            conf_loss = 0.0
+            if self.conf_loss:
+                conf_mask = torch.abs(gt_depth_ - pred_depth) < gt_depth_
+                conf_mask = conf_mask & gt_depth_mask_
+                gt_confidence = (1 - torch.abs((pred_depth - gt_depth_) / gt_depth_)) * conf_mask
+                conf_loss = torch.sum(torch.abs(pred_conf - gt_confidence) * conf_mask) / (torch.sum(conf_mask) + self.eps)
+                if torch.isnan(conf_loss).item() | torch.isinf(conf_loss).item():
+                    conf_loss = 0 * torch.sum(pred_conf)
+                    print(f'GRUSequenceLoss-confidence NAN error, {conf_loss}')
+
+            loss += (conf_loss + curr_loss) * i_weight
+
+        return loss * self.loss_weight

external/Metric3D/training/mono/model/losses/ConfidenceLoss.py

@@ -0,0 +1,22 @@
+import torch
+import torch.nn as nn
+
+class ConfidenceLoss(nn.Module):
+    """
+    confidence loss.
+    """
+    def __init__(self, loss_weight=1, data_type=['stereo', 'lidar', 'denselidar'], **kwargs):
+        super(ConfidenceLoss, self).__init__()
+        self.loss_weight = loss_weight
+        self.data_type = data_type
+        self.eps = 1e-6
+
+    def forward(self, prediction, target, confidence, mask=None, **kwargs):
+        conf_mask = torch.abs(target - prediction) < target
+        conf_mask = conf_mask & mask        
+        gt_confidence = (1 - torch.abs((prediction - target) / target)) * conf_mask
+        loss = torch.sum(torch.abs(confidence - gt_confidence) * conf_mask) / (torch.sum(conf_mask) + self.eps)
+        if torch.isnan(loss).item() | torch.isinf(loss).item():
+            loss = 0 * torch.sum(confidence) 
+            print(f'ConfidenceLoss NAN error, {loss}')
+        return loss * self.loss_weight

external/Metric3D/training/mono/model/losses/GRUSequenceLoss.py

@@ -0,0 +1,181 @@
+import torch
+import torch.nn as nn
+
+class GRUSequenceLoss(nn.Module):
+    """
+    Loss function defined over sequence of depth predictions
+    """
+    def __init__(self, loss_weight=1, data_type=['lidar', 'denselidar', 'stereo', 'denselidar_syn'], loss_gamma=0.9, silog=False, stereo_sup=0.001, stereo_dataset=['KITTI', 'NYU'], **kwargs):
+        super(GRUSequenceLoss, self).__init__()
+        self.loss_weight = loss_weight
+        self.data_type = data_type
+        self.eps = 1e-6
+        self.loss_gamma = loss_gamma
+        self.silog = silog
+        self.variance_focus = 0.5
+        self.stereo_sup = stereo_sup
+        self.stereo_dataset = stereo_dataset
+
+        # assert stereo_mode in ['stereo', 'self_sup']
+        # self.stereo_mode = stereo_mode
+        # self.stereo_max = stereo_max
+
+    def silog_loss(self, prediction, target, mask):
+        mask = mask & (prediction > 0.01) & (target > 0.01)
+        d = torch.log(prediction[mask]) - torch.log(target[mask])
+        # d_square_mean = torch.sum(d ** 2) / (d.numel() + self.eps)
+        # d_mean = torch.sum(d) / (d.numel() + self.eps)
+        # loss = d_square_mean - self.variance_focus * (d_mean ** 2)
+        loss = torch.sum(torch.abs(d)) / (d.numel() + self.eps)
+        print("new log l1 loss")
+        return loss 
+    
+    def conf_loss(self, confidence, prediction, target, mask):
+        conf_mask = torch.abs(target - prediction) < target
+        conf_mask = conf_mask & mask
+        gt_confidence = (1 - torch.abs((prediction - target) / target)) * conf_mask
+        loss = torch.sum(torch.abs(confidence - gt_confidence) * conf_mask) / (torch.sum(conf_mask) + self.eps)
+        if torch.isnan(loss).item() | torch.isinf(loss).item():
+            print(f'GRUSequenceLoss-confidence NAN error, {loss}')
+            loss = 0 * torch.sum(confidence)
+        return loss
+
+    def forward(self, predictions_list, target, stereo_depth, confidence_list=None, mask=None, **kwargs):
+        device = target.device
+
+        batches_dataset = kwargs['dataset']
+        self.batch_with_stereo = torch.tensor([1 if batch_dataset in self.stereo_dataset else 0 \
+                                              for batch_dataset in batches_dataset], device=device)[:,None,None,None]
+        
+        n_predictions = len(predictions_list)
+        assert n_predictions >= 1
+        loss = 0.0
+
+        for i, prediction in enumerate(predictions_list):
+            # if self.stereo_mode == 'self_sup' and self.stereo_sup > 1e-8:
+            #     B, C, H, W = target.shape
+            #     prediction_nan = prediction.clone().detach()
+            #     target_nan = target.clone()
+            #     prediction_nan[~mask] = float('nan')
+            #     target_nan[~mask] = float('nan')
+            #     gt_median = target_nan.reshape((B, C,-1)).nanmedian(2)[0][:, :, None, None]
+                
+            #     pred_median = prediction_nan.reshape((B, C,-1)).nanmedian(2)[0][:, :, None, None]
+            #     scale = gt_median / (pred_median + 1e-8)
+
+            #     stereo_depth = (0.0 * stereo_depth + scale * prediction * (prediction < (self.stereo_max - 1)) + \
+            #         prediction * (prediction > (self.stereo_max - 1))).detach()
+            
+            # We adjust the loss_gamma so it is consistent for any number of RAFT-Stereo iterations
+            adjusted_loss_gamma = self.loss_gamma**(15/(n_predictions - 1))
+            i_weight = adjusted_loss_gamma**(n_predictions - i - 1)
+
+            # depth L1 loss
+            if self.silog and mask.sum() > 0:
+                curr_loss = self.silog_loss(prediction, target, mask)
+            else:
+                diff = torch.abs(prediction - target) * mask
+                #diff = diff + diff * diff * 1.0
+                curr_loss = torch.sum(diff) / (torch.sum(mask) + self.eps)
+            if torch.isnan(curr_loss).item() | torch.isinf(curr_loss).item():
+                print(f'GRUSequenceLoss-depth NAN error, {curr_loss}')
+                curr_loss = 0 * torch.sum(prediction)
+
+            # confidence L1 loss
+            conf_loss = 0
+            if confidence_list is not None:
+                conf_loss = self.conf_loss(confidence_list[i], prediction, target, mask)
+
+            # stereo depth loss
+            mask_stereo = 1 + torch.nn.functional.max_pool2d(\
+                - torch.nn.functional.max_pool2d(mask * 1.0, 3, stride=1, padding=1, dilation=1), 3, stride=1, padding=1, dilation=1)
+
+            stereo_diff = torch.abs(prediction - stereo_depth) * mask_stereo
+            #stereo_diff = stereo_diff + stereo_diff * stereo_diff * 1.0
+            stereo_depth_loss = torch.sum(self.batch_with_stereo * stereo_diff * mask_stereo) / (torch.sum(mask_stereo) + self.eps)
+            stereo_depth_loss = self.stereo_sup * stereo_depth_loss
+
+            loss += (conf_loss + curr_loss + stereo_depth_loss) * i_weight
+            #raise RuntimeError(f'Silog error, {loss}, d_square_mean: {d_square_mean}, d_mean: {d_mean}')
+        return loss * self.loss_weight
+
+# import torch
+# import torch.nn as nn
+
+# class GRUSequenceLoss(nn.Module):
+#     """
+#     Loss function defined over sequence of depth predictions
+#     """
+#     def __init__(self, loss_weight=1, data_type=['lidar', 'denselidar', 'stereo', 'denselidar_syn'], loss_gamma=0.9, silog=False, stereo_sup=0.001, stereo_dataset=['BigData'], **kwargs):
+#         super(GRUSequenceLoss, self).__init__()
+#         self.loss_weight = loss_weight
+#         self.data_type = data_type
+#         self.eps = 1e-6
+#         self.loss_gamma = loss_gamma
+#         self.silog = silog
+#         self.variance_focus = 0.5
+#         self.stereo_sup = stereo_sup
+#         self.stereo_dataset = stereo_dataset
+
+#     def silog_loss(self, prediction, target, mask):
+#         mask = mask & (prediction > 0.01) & (target > 0.01)
+#         d = torch.log(prediction[mask]) - torch.log(target[mask])
+#         # d_square_mean = torch.sum(d ** 2) / (d.numel() + self.eps)
+#         # d_mean = torch.sum(d) / (d.numel() + self.eps)
+#         # loss = d_square_mean - self.variance_focus * (d_mean ** 2)
+#         loss = torch.sum(torch.abs(d)) / (d.numel() + self.eps)
+#         print("new log l1 loss")
+#         return loss 
+    
+#     def conf_loss(self, confidence, prediction, target, mask):
+#         conf_mask = torch.abs(target - prediction) < target
+#         conf_mask = conf_mask & mask
+#         gt_confidence = (1 - torch.abs((prediction - target) / target)) * conf_mask
+#         loss = torch.sum(torch.abs(confidence - gt_confidence) * conf_mask) / (torch.sum(conf_mask) + self.eps)
+#         if torch.isnan(loss).item() | torch.isinf(loss).item():
+#             print(f'GRUSequenceLoss-confidence NAN error, {loss}')
+#             loss = 0 * torch.sum(confidence)
+#         return loss
+
+#     def forward(self, predictions_list, target, stereo_depth, confidence_list=None, mask=None, **kwargs):
+#         device = target.device
+
+#         batches_dataset = kwargs['dataset']
+#         self.batch_with_stereo = torch.tensor([1 if batch_dataset in self.stereo_dataset else 0 \
+#                                               for batch_dataset in batches_dataset], device=device)[:,None,None,None]
+        
+#         n_predictions = len(predictions_list)
+#         assert n_predictions >= 1
+#         loss = 0.0
+
+#         for i, prediction in enumerate(predictions_list):
+#             # We adjust the loss_gamma so it is consistent for any number of RAFT-Stereo iterations
+#             adjusted_loss_gamma = self.loss_gamma**(15/(n_predictions - 1))
+#             i_weight = adjusted_loss_gamma**(n_predictions - i - 1)
+
+#             # depth L1 loss
+#             if self.silog and mask.sum() > 0:
+#                 curr_loss = self.silog_loss(prediction, target, mask)
+#             else:
+#                 diff = torch.abs(prediction - target) * mask
+#                 curr_loss = torch.sum(diff) / (torch.sum(mask) + self.eps)
+#             if torch.isnan(curr_loss).item() | torch.isinf(curr_loss).item():
+#                 print(f'GRUSequenceLoss-depth NAN error, {curr_loss}')
+#                 curr_loss = 0 * torch.sum(prediction)
+
+#             # confidence L1 loss
+#             conf_loss = 0
+#             if confidence_list is not None:
+#                 conf_loss = self.conf_loss(confidence_list[i], prediction, target, mask)
+
+#             # stereo depth loss
+#             mask_stereo = 1 + torch.nn.functional.max_pool2d(\
+#                 - torch.nn.functional.max_pool2d(mask * 1.0, 5, stride=1, padding=2, dilation=1), 5, stride=1, padding=2, dilation=1)
+
+#             stereo_diff = torch.abs(prediction - stereo_depth) * mask_stereo
+#             stereo_depth_loss = torch.sum(self.batch_with_stereo * stereo_diff * mask_stereo) / (torch.sum(mask_stereo) + self.eps)
+#             stereo_depth_loss = self.stereo_sup * stereo_depth_loss
+
+#             loss += (conf_loss + curr_loss + stereo_depth_loss) * i_weight
+#             #raise RuntimeError(f'Silog error, {loss}, d_square_mean: {d_square_mean}, d_mean: {d_mean}')
+#         return loss * self.loss_weight

external/Metric3D/training/mono/model/losses/Gradient.py

@@ -0,0 +1,121 @@
+import torch
+import torch.nn as nn
+
+EPSILON = 1e-6
+"""
+  # @Zhengqi Li version.  
+  def GradientLoss(self, log_prediction_d, mask, log_gt):
+        log_d_diff = log_prediction_d - log_gt
+
+        v_gradient = torch.abs(log_d_diff[:, :-2, :] - log_d_diff[:, 2:, :])
+        v_mask = torch.mul(mask[:, :-2, :], mask[:, 2:, :])
+        v_gradient = torch.mul(v_gradient, v_mask)
+
+        h_gradient = torch.abs(log_d_diff[:, :, :-2] - log_d_diff[:, :, 2:])
+        h_mask = torch.mul(mask[:, :, :-2], mask[:, :, 2:])
+        h_gradient = torch.mul(h_gradient, h_mask)
+
+        N = torch.sum(h_mask) + torch.sum(v_mask) + EPSILON
+
+        gradient_loss = torch.sum(h_gradient) + torch.sum(v_gradient)
+        gradient_loss = gradient_loss / N
+
+        return gradient_loss
+"""
+def gradient_log_loss(log_prediction_d, log_gt, mask):
+    log_d_diff = log_prediction_d - log_gt
+
+    v_gradient = torch.abs(log_d_diff[:, :, :-2, :] - log_d_diff[:, :, 2:, :])
+    v_mask = torch.mul(mask[:, :, :-2, :], mask[:, :, 2:, :])
+    v_gradient = torch.mul(v_gradient, v_mask)
+
+    h_gradient = torch.abs(log_d_diff[:, :, :, :-2] - log_d_diff[:, :, :, 2:])
+    h_mask = torch.mul(mask[:, :, :, :-2], mask[:, :, :, 2:])
+    h_gradient = torch.mul(h_gradient, h_mask)
+
+    N = torch.sum(h_mask) + torch.sum(v_mask) + EPSILON
+
+    gradient_loss = torch.sum(h_gradient) + torch.sum(v_gradient)
+    gradient_loss = gradient_loss / N
+
+    return gradient_loss
+
+class GradientLoss_Li(nn.Module):
+    def __init__(self, scale_num=1, loss_weight=1, data_type = ['lidar', 'stereo'], **kwargs):
+        super(GradientLoss_Li, self).__init__()
+        self.__scales = scale_num
+        self.loss_weight = loss_weight
+        self.data_type = data_type
+        self.eps = 1e-6
+
+    def forward(self, prediction, target, mask, **kwargs):
+        total = 0
+        target_trans = target + (~mask) * 100
+        pred_log = torch.log(prediction)
+        gt_log = torch.log(target_trans)
+        for scale in range(self.__scales):
+            step = pow(2, scale)
+            
+            total += gradient_log_loss(pred_log[:, ::step, ::step], gt_log[:, ::step, ::step], mask[:, ::step, ::step])
+        loss = total / self.__scales
+        if torch.isnan(loss).item() | torch.isinf(loss).item():
+            raise RuntimeError(f'VNL error, {loss}')
+        return loss * self.loss_weight
+  
+######################################################
+# Multi-scale gradient matching loss, @Ke Xian implementation.
+#####################################################
+def gradient_loss(prediction, target, mask):
+    M = torch.sum(mask, (1, 2))
+
+    diff = prediction - target
+    diff = torch.mul(mask, diff)
+
+    grad_x = torch.abs(diff[:, :, 1:] - diff[:, :, :-1])
+    mask_x = torch.mul(mask[:, :, 1:], mask[:, :, :-1])
+    grad_x = torch.mul(mask_x, grad_x)
+
+    grad_y = torch.abs(diff[:, 1:, :] - diff[:, :-1, :])
+    mask_y = torch.mul(mask[:, 1:, :], mask[:, :-1, :])
+    grad_y = torch.mul(mask_y, grad_y)
+
+    image_loss = torch.sum(grad_x, (1, 2)) + torch.sum(grad_y, (1, 2))
+    valid = M.nonzero()
+    if image_loss[valid].numel() > 0:
+        image_loss[valid] = image_loss[valid] / M[valid]
+        loss = torch.mean(image_loss)
+    else:
+        loss = 0 * torch.sum(prediction)
+
+    return loss
+
+
+class GradientLoss(nn.Module):
+    def __init__(self, scale_num=4, loss_weight=1, **kwargs):
+        super(GradientLoss, self).__init__()
+        self.__scales = scale_num
+        self.loss_weight = loss_weight
+    def forward(self, prediction, target, mask, **kwargs):
+        total = 0
+        for scale in range(self.__scales):
+            step = pow(2, scale)
+            total += gradient_loss(prediction[:, ::step, ::step], target[:, ::step, ::step], mask[:, ::step, ::step])
+         
+        return total * self.loss_weight
+
+
+if __name__ == '__main__':
+    import numpy as np
+    gradient = GradientLoss_Li(4)
+
+    pred_depth = np.random.random([2, 1, 480, 640])
+    gt_depth = np.ones_like(pred_depth) * (-1) #np.random.random([2, 1, 480, 640]) - 0.5 #
+    #gt_depth = np.abs(gt_depth)
+    intrinsic = [[100, 100, 200, 200], [200, 200, 300, 300]]
+
+    pred = torch.from_numpy(pred_depth).cuda()
+    gt = torch.from_numpy(gt_depth).cuda()
+    mask = gt > 0
+
+    loss = gradient(gt, gt, mask)
+    print(loss)

external/Metric3D/training/mono/model/losses/HDNL.py

@@ -0,0 +1,95 @@
+import torch
+import torch.nn as nn
+
+class HDNLoss(nn.Module):
+    """
+    Hieratical depth normalization loss.
+    loss = MAE((d-median(d)/s - (d'-median(d'))/s'), s = mean(d- median(d))
+    """
+    def __init__(self, loss_weight=1, grid=3, data_type=['sfm', 'stereo', 'lidar'], **kwargs):
+        super(HDNLoss, self).__init__()
+        self.loss_weight = loss_weight
+        self.grid = grid
+        self.data_type = data_type
+    
+    def get_hierachy_masks(self, grid, depth_gt, mask_valid):
+
+        batch_map_grid = []
+        for mask_index in range(depth_gt.shape[0]):
+            depth_map = depth_gt[mask_index]
+            valid_map = mask_valid[mask_index]
+
+            # print (depth_map[valid_map].view(-1).shape)
+            if depth_map[valid_map].numel() == 0:
+                map_grid_list = [valid_map for _ in range(2 ** (grid) - 1)]
+            else:
+                valid_values = depth_map[valid_map]
+
+                max_d = valid_values.max()
+                min_d = valid_values.min()
+
+                anchor_power = [(1 / 2) ** (i) for i in range(grid)]
+                anchor_power.reverse()
+
+                map_grid_list = []
+                for anchor in anchor_power:
+                    # range
+                    for i in range(int(1 / anchor)):
+                        mask_new = (depth_map >= min_d + (max_d - min_d) * i * anchor) & (
+                                    depth_map < min_d + (max_d - min_d) * (i + 1) * anchor+1e-30)
+                        # print (f'[{i*anchor},{(i+1)*anchor}]')
+                        mask_new = mask_new & valid_map
+                        map_grid_list.append(mask_new)
+            map_grid_list = torch.stack(map_grid_list, dim=0)
+            batch_map_grid.append(map_grid_list)
+        batch_map_grid = torch.stack(batch_map_grid, dim=1)
+        return batch_map_grid
+    
+    def ssi_mae(self, prediction, target, mask_valid):
+        B, C, H, W = target.shape
+        prediction_nan = prediction.clone()
+        target_nan = target.clone()
+        prediction_nan[~mask_valid] = float('nan')
+        target_nan[~mask_valid] = float('nan')
+
+        valid_pixs = mask_valid.reshape((B, C,-1)).sum(dim=2, keepdims=True) + 1e-10
+        valid_pixs = valid_pixs[:, :, :, None]
+
+        gt_median = target_nan.reshape((B, C,-1)).nanmedian(2, keepdims=True)[0].unsqueeze(-1) # [b,c,h,w]
+        gt_median[torch.isnan(gt_median)] = 0
+        gt_diff = (torch.abs(target - gt_median) * mask_valid).reshape((B, C, -1))
+        gt_s = gt_diff.sum(dim=2)[:, :, None, None] / valid_pixs
+        gt_trans = (target - gt_median) / (gt_s + 1e-8)
+
+        pred_median = prediction_nan.reshape((B, C,-1)).nanmedian(2, keepdims=True)[0].unsqueeze(-1) # [b,c,h,w]
+        pred_median[torch.isnan(pred_median)] = 0
+        pred_diff = (torch.abs(prediction - pred_median) * mask_valid).reshape((B, C, -1))
+        pred_s = pred_diff.sum(dim=2)[:, :, None, None] / valid_pixs
+        pred_trans = (prediction - pred_median) / (pred_s + 1e-8)
+
+        loss = torch.sum(torch.abs(gt_trans - pred_trans)*mask_valid) / (torch.sum(mask_valid) + 1e-8)
+        return pred_trans, gt_trans, loss
+
+    def forward(self, prediction, target, mask=None, **kwargs):
+        """
+        Calculate loss.
+        """
+        B, C, H, W = target.shape
+        hierachy_masks = self.get_hierachy_masks(self.grid, target, mask)
+        hierachy_masks_shape = hierachy_masks.reshape(-1, C, H, W)    
+        prediction_hie = prediction.unsqueeze(0).repeat(hierachy_masks.shape[0], 1, 1, 1, 1).reshape(-1, C, H, W)     
+
+        target_hie = target.unsqueeze(0).repeat(hierachy_masks.shape[0], 1, 1, 1, 1).reshape(-1, C, H, W)
+
+        #_, _, loss = self.ssi_mae(prediction, target, mask)
+        _, _, loss = self.ssi_mae(prediction_hie, target_hie, hierachy_masks_shape)
+        return loss * self.loss_weight
+    
+if __name__ == '__main__':
+    ssil = HDNLoss()
+    pred = torch.rand((2, 1, 256, 256)).cuda()
+    gt = torch.rand((2, 1, 256, 256)).cuda()#torch.zeros_like(pred).cuda() #
+    gt[:, :, 100:256, 0:100] = -1
+    mask = gt > 0
+    out = ssil(pred, gt, mask)
+    print(out)

external/Metric3D/training/mono/model/losses/HDNL_random.py

@@ -0,0 +1,104 @@
+import torch
+import torch.nn as nn
+import numpy as np
+
+class HDNRandomLoss(nn.Module):
+    """
+    Hieratical depth normalization loss. Replace the original hieratical depth ranges with randomly sampled ranges.
+    loss = MAE((d-median(d)/s - (d'-median(d'))/s'), s = mean(d- median(d))
+    """
+    def __init__(self, loss_weight=1, random_num=32, data_type=['sfm', 'stereo', 'lidar', 'denselidar', 'denselidar_nometric', 'denselidar_syn'], norm_dataset=['Taskonomy', 'Matterport3D', 'Replica', 'Hypersim'], disable_dataset=['MapillaryPSD'], **kwargs):
+        super(HDNRandomLoss, self).__init__()
+        self.loss_weight = loss_weight
+        self.random_num = random_num
+        self.eps = 1e-6
+        self.data_type = data_type
+        self.disable_dataset = disable_dataset
+    
+    def get_random_masks_for_batch(self, depth_gt: torch.Tensor, mask_valid: torch.Tensor)-> torch.Tensor:
+        valid_values = depth_gt[mask_valid]
+        max_d = valid_values.max().item() if valid_values.numel() > 0 else 0.0 
+        min_d = valid_values.min().item() if valid_values.numel() > 0 else 0.0
+
+        sample_min_d = np.random.uniform(0, 0.75, self.random_num) * (max_d - min_d) + min_d
+        sample_max_d = np.random.uniform(sample_min_d + 0.1, 1-self.eps, self.random_num) * (max_d - min_d) + min_d
+
+        mask_new = [(depth_gt >= sample_min_d[i]) & (depth_gt < sample_max_d[i] + 1e-30) & mask_valid for i in range(self.random_num)]
+        mask_new = torch.stack(mask_new, dim=0).cuda() #[N, 1, H, W]
+        return mask_new
+
+    def ssi_mae(self, prediction, target, mask_valid):
+        B, C, H, W = target.shape
+        prediction_nan = prediction.clone().detach()
+        target_nan = target.clone()
+        prediction_nan[~mask_valid] = float('nan')
+        target_nan[~mask_valid] = float('nan')
+
+        valid_pixs = mask_valid.reshape((B, C,-1)).sum(dim=2, keepdims=True) + self.eps
+        valid_pixs = valid_pixs[:, :, :, None]
+
+        gt_median = target_nan.reshape((B, C,-1)).nanmedian(2, keepdims=True)[0].unsqueeze(-1) # [b,c,h,w]
+        gt_median[torch.isnan(gt_median)] = 0
+        gt_diff = (torch.abs(target - gt_median) * mask_valid).reshape((B, C, -1))
+        gt_s = gt_diff.sum(dim=2)[:, :, None, None] / valid_pixs
+        gt_trans = (target - gt_median) / (gt_s + self.eps)
+
+        pred_median = prediction_nan.reshape((B, C,-1)).nanmedian(2, keepdims=True)[0].unsqueeze(-1) # [b,c,h,w]
+        pred_median[torch.isnan(pred_median)] = 0
+        pred_diff = (torch.abs(prediction - pred_median) * mask_valid).reshape((B, C, -1))
+        pred_s = pred_diff.sum(dim=2)[:, :, None, None] / valid_pixs
+        pred_trans = (prediction - pred_median) / (pred_s + self.eps)
+
+        loss_sum = torch.sum(torch.abs(gt_trans - pred_trans)*mask_valid)
+        return  loss_sum
+
+    def forward(self, prediction, target, mask=None, **kwargs):
+        """
+        Calculate loss.
+        """
+        B, C, H, W = target.shape
+        
+        loss = 0.0
+        valid_pix = 0.0
+        
+        device = target.device
+        
+        batches_dataset = kwargs['dataset']
+        self.batch_valid = torch.tensor([1 if batch_dataset not in self.disable_dataset else 0 \
+            for batch_dataset in batches_dataset], device=device)[:,None,None,None]
+        
+        batch_limit = 4
+        loops = int(np.ceil(self.random_num / batch_limit))
+        for i in range(B):                
+            mask_i = mask[i, ...] #[1, H, W]
+
+            if self.batch_valid[i, ...] < 0.5:
+                loss += 0 * torch.sum(prediction[i, ...])
+                valid_pix += 0 * torch.sum(mask_i)
+                continue
+
+            pred_i = prediction[i, ...].unsqueeze(0).repeat(batch_limit, 1, 1, 1)
+            target_i = target[i, ...].unsqueeze(0).repeat(batch_limit, 1, 1, 1)
+            mask_random_drange = self.get_random_masks_for_batch(target[i, ...], mask_i) # [N, 1, H, W]
+            for j in range(loops):
+                mask_random_loopi = mask_random_drange[j*batch_limit:(j+1)*batch_limit, ...]
+                loss += self.ssi_mae(
+                    prediction=pred_i[:mask_random_loopi.shape[0], ...], 
+                    target=target_i[:mask_random_loopi.shape[0], ...], 
+                    mask_valid=mask_random_loopi)
+                valid_pix += torch.sum(mask_random_loopi)
+
+        loss = loss / (valid_pix + self.eps)
+        if torch.isnan(loss).item() | torch.isinf(loss).item():
+            loss = 0 * torch.sum(prediction)
+            print(f'HDNL NAN error, {loss}, valid pix: {valid_pix}')
+        return loss * self.loss_weight
+    
+if __name__ == '__main__':
+    ssil = HDNRandomLoss()
+    pred = torch.rand((2, 1, 256, 256)).cuda()
+    gt =  - torch.rand((2, 1, 256, 256)).cuda()#torch.zeros_like(pred).cuda() #
+    gt[:, :, 100:256, 0:100] = -1
+    mask = gt > 0
+    out = ssil(pred, gt, mask)
+    print(out)

external/Metric3D/training/mono/model/losses/HDSNL.py

@@ -0,0 +1,82 @@
+import torch
+import torch.nn as nn
+
+class HDSNLoss(nn.Module):
+    """
+    Hieratical depth spatial normalization loss.
+    loss = MAE((d-median(d)/s - (d'-median(d'))/s'), s = mean(d- median(d))
+    """
+    def __init__(self, loss_weight=1.0, grid=3, data_type=['sfm', 'stereo', 'lidar'], **kwargs):
+        super(HDSNLoss, self).__init__()
+        self.loss_weight = loss_weight
+        self.grid = grid
+        self.data_type = data_type
+
+    def get_hierachy_masks(self, batch, image_size, mask):
+        height, width = image_size
+        anchor_power = [(1 / 2) ** (i) for i in range(self.grid)]
+        anchor_power.reverse()
+
+        map_grid_list = []
+        for anchor in anchor_power:  # e.g. 1/8
+            for h in range(int(1 / anchor)):
+                for w in range(int(1 / anchor)):
+                    mask_new = torch.zeros((batch,  1, height, width), dtype=torch.bool).cuda()
+                    mask_new[:, :, int(h * anchor * height):int((h + 1) * anchor * height),
+                        int(w * anchor * width):int((w + 1) * anchor * width)] = True
+                    mask_new = mask & mask_new
+                    map_grid_list.append(mask_new)
+        batch_map_grid=torch.stack(map_grid_list,dim=0) # [N, B, 1, H, W]
+
+        return batch_map_grid
+    
+    def ssi_mae(self, prediction, target, mask_valid):
+        B, C, H, W = target.shape
+        prediction_nan = prediction.clone()
+        target_nan = target.clone()
+        prediction_nan[~mask_valid] = float('nan')
+        target_nan[~mask_valid] = float('nan')
+
+        valid_pixs = mask_valid.reshape((B, C,-1)).sum(dim=2, keepdims=True) + 1e-10
+        valid_pixs = valid_pixs[:, :, :, None]
+
+        gt_median = target_nan.reshape((B, C,-1)).nanmedian(2, keepdims=True)[0].unsqueeze(-1) # [b,c,h,w]
+        gt_median[torch.isnan(gt_median)] = 0
+        gt_diff = (torch.abs(target - gt_median) * mask_valid).reshape((B, C, -1))
+        gt_s = gt_diff.sum(dim=2)[:, :, None, None] / valid_pixs
+        gt_trans = (target - gt_median) / (gt_s + 1e-8)
+
+        pred_median = prediction_nan.reshape((B, C,-1)).nanmedian(2, keepdims=True)[0].unsqueeze(-1) # [b,c,h,w]
+        pred_median[torch.isnan(pred_median)] = 0
+        pred_diff = (torch.abs(prediction - pred_median) * mask_valid).reshape((B, C, -1))
+        pred_s = pred_diff.sum(dim=2)[:, :, None, None] / valid_pixs
+        pred_trans = (prediction - pred_median) / (pred_s + 1e-8)
+
+        loss = torch.sum(torch.abs(gt_trans - pred_trans)*mask_valid) / (torch.sum(mask_valid) + 1e-8)
+        return pred_trans, gt_trans, loss
+
+    def forward(self, prediction, target, mask=None, **kwargs):
+        """
+        Calculate loss.
+        """
+        B, C, H, W = target.shape
+        hierachy_masks = self.get_hierachy_masks(B, (H, W), mask) # [N, B, 1, H, W]
+        hierachy_masks_shape = hierachy_masks.reshape(-1, C, H, W)    
+        prediction_hie = prediction.unsqueeze(0).repeat(hierachy_masks.shape[0], 1, 1, 1, 1).reshape(-1, C, H, W)     
+
+        target_hie = target.unsqueeze(0).repeat(hierachy_masks.shape[0], 1, 1, 1, 1).reshape(-1, C, H, W)
+
+        #_, _, loss = self.ssi_mae(prediction, target, mask)
+        _, _, loss = self.ssi_mae(prediction_hie, target_hie, hierachy_masks_shape)
+        return loss * self.loss_weight
+    
+if __name__ == '__main__':
+    torch.manual_seed(1)
+    torch.cuda.manual_seed_all(1)
+    ssil = HDSNLoss()
+    pred = torch.rand((2, 1, 256, 256)).cuda()
+    gt = torch.rand((2, 1, 256, 256)).cuda()#torch.zeros_like(pred).cuda() #
+    gt[:, :, 100:256, 0:100] = -1
+    mask = gt > 0
+    out = ssil(pred, gt, mask)
+    print(out)

external/Metric3D/training/mono/model/losses/HDSNL_random.py

@@ -0,0 +1,230 @@
+import torch
+import torch.nn as nn
+import numpy as np
+#from numba import jit
+
+class HDSNRandomLoss(nn.Module):
+    """
+    Hieratical depth spatial normalization loss.
+    Replace the original grid masks with the random created masks.
+    loss = MAE((d-median(d)/s - (d'-median(d'))/s'), s = mean(d- median(d))
+    """
+    def __init__(self, loss_weight=1.0, random_num=32, data_type=['sfm', 'stereo', 'lidar', 'denselidar', 'denselidar_nometric','denselidar_syn'], disable_dataset=['MapillaryPSD'], sky_id=142, batch_limit=8, **kwargs):
+        super(HDSNRandomLoss, self).__init__()
+        self.loss_weight = loss_weight
+        self.random_num = random_num
+        self.data_type = data_type
+        self.sky_id = sky_id
+        self.batch_limit = batch_limit
+        self.eps = 1e-6
+        self.disable_dataset = disable_dataset
+
+    def get_random_masks_for_batch(self, image_size: list)-> torch.Tensor:
+        height, width = image_size
+        crop_h_min = int(0.125 * height)
+        crop_h_max = int(0.5 * height)
+        crop_w_min = int(0.125 * width)
+        crop_w_max = int(0.5 * width)
+        h_max = height - crop_h_min
+        w_max = width - crop_w_min
+        crop_height = np.random.choice(np.arange(crop_h_min, crop_h_max), self.random_num, replace=False)
+        crop_width = np.random.choice(np.arange(crop_w_min, crop_w_max), self.random_num, replace=False)
+        crop_y = np.random.choice(h_max, self.random_num, replace=False)
+        crop_x = np.random.choice(w_max, self.random_num, replace=False)
+        crop_y_end = crop_height + crop_y
+        crop_y_end[crop_y_end>=height] = height
+        crop_x_end = crop_width + crop_x
+        crop_x_end[crop_x_end>=width] = width
+
+        mask_new = torch.zeros((self.random_num,  height, width), dtype=torch.bool, device="cuda") #.cuda() #[N, H, W]
+        for i in range(self.random_num):
+           mask_new[i, crop_y[i]:crop_y_end[i], crop_x[i]:crop_x_end[i]] = True
+
+        return mask_new
+        #return crop_y, crop_y_end, crop_x, crop_x_end
+    
+    def reorder_sem_masks(self, sem_label):
+        # reorder the semantic mask of a batch
+        assert sem_label.ndim == 3
+        semantic_ids = torch.unique(sem_label[(sem_label>0) & (sem_label != self.sky_id)])
+        sem_masks = [sem_label == id for id in semantic_ids]
+        if len(sem_masks) == 0:
+            # no valid semantic labels
+            out = sem_label > 0
+            return out
+
+        sem_masks = torch.cat(sem_masks, dim=0)
+        mask_batch = torch.sum(sem_masks.reshape(sem_masks.shape[0], -1), dim=1) > 500
+        sem_masks = sem_masks[mask_batch]
+        if sem_masks.shape[0] > self.random_num:
+            balance_samples = np.random.choice(sem_masks.shape[0], self.random_num, replace=False)
+            sem_masks = sem_masks[balance_samples, ...]
+        
+        if sem_masks.shape[0] == 0:
+            # no valid semantic labels
+            out = sem_label > 0
+            return out
+
+        if sem_masks.ndim == 2:
+            sem_masks = sem_masks[None, :, :]
+        return sem_masks
+  
+    def ssi_mae(self, prediction, target, mask_valid):
+        B, C, H, W = target.shape
+        prediction_nan = prediction.clone().detach()
+        target_nan = target.clone()
+        prediction_nan[~mask_valid] = float('nan')
+        target_nan[~mask_valid] = float('nan')
+
+        valid_pixs = mask_valid.reshape((B, C,-1)).sum(dim=2, keepdims=True) + 1e-10
+        valid_pixs = valid_pixs[:, :, :, None]
+
+        gt_median = target_nan.reshape((B, C,-1)).nanmedian(2, keepdims=True)[0].unsqueeze(-1) # [b,c,h,w]
+        gt_median[torch.isnan(gt_median)] = 0
+        gt_diff = (torch.abs(target - gt_median) ).reshape((B, C, -1))
+        gt_s = gt_diff.sum(dim=2)[:, :, None, None] / valid_pixs
+        gt_trans = (target - gt_median) / (gt_s + self.eps)
+
+        pred_median = prediction_nan.reshape((B, C,-1)).nanmedian(2, keepdims=True)[0].unsqueeze(-1) # [b,c,h,w]
+        pred_median[torch.isnan(pred_median)] = 0
+        pred_diff = (torch.abs(prediction - pred_median)).reshape((B, C, -1))
+        pred_s = pred_diff.sum(dim=2)[:, :, None, None] / valid_pixs
+        pred_trans = (prediction - pred_median) / (pred_s + self.eps)
+
+        loss_sum = torch.sum(torch.abs(gt_trans - pred_trans)*mask_valid)
+        return loss_sum
+    
+    def conditional_ssi_mae(self, prediction, target, mask_valid):
+        B, C, H, W = target.shape
+        conditional_rank_ids = np.random.choice(B, B, replace=False)
+
+        prediction_nan = prediction.clone()
+        target_nan = target.clone()
+        prediction_nan[~mask_valid] = float('nan')
+        target_nan[~mask_valid] = float('nan')
+
+        valid_pixs = mask_valid.reshape((B, C,-1)).sum(dim=2, keepdims=True) + self.eps
+        valid_pixs = valid_pixs[:, :, :, None].contiguous()
+
+        gt_median = target_nan.reshape((B, C,-1)).nanmedian(2, keepdims=True)[0].unsqueeze(-1) # [b,c,h,w]
+        gt_median[torch.isnan(gt_median)] = 0
+        gt_diff = (torch.abs(target - gt_median) * mask_valid).reshape((B, C,-1))
+        gt_s = gt_diff.sum(dim=2)[:, :, None, None].contiguous() / valid_pixs
+
+        # in case some batches have no valid pixels
+        gt_s_small_mask = gt_s < (torch.mean(gt_s)*0.1)
+        gt_s[gt_s_small_mask] = torch.mean(gt_s)
+        gt_trans = (target - gt_median[conditional_rank_ids]) / (gt_s[conditional_rank_ids] + self.eps)
+
+        pred_median = prediction_nan.reshape((B, C,-1)).nanmedian(2, keepdims=True)[0].unsqueeze(-1) # [b,c,h,w]
+        pred_median[torch.isnan(pred_median)] = 0
+        pred_diff = (torch.abs(prediction - pred_median) * mask_valid).reshape((B, C,-1))
+        pred_s = pred_diff.sum(dim=2)[:, :, None, None].contiguous() / valid_pixs
+        pred_s[gt_s_small_mask] = torch.mean(pred_s)
+        pred_trans = (prediction - pred_median[conditional_rank_ids]) / (pred_s[conditional_rank_ids] + self.eps)
+
+        loss_sum = torch.sum(torch.abs(gt_trans - pred_trans)*mask_valid)
+        # print(torch.abs(gt_trans - pred_trans)[mask_valid])
+        return loss_sum
+
+
+    def forward(self, prediction, target, mask=None, sem_mask=None, **kwargs):
+        """
+        Calculate loss.
+        """
+        B, C, H, W = target.shape
+        
+        loss = 0.0
+        valid_pix = 0.0
+
+        device = target.device
+        
+        batches_dataset = kwargs['dataset']
+        self.batch_valid = torch.tensor([1 if batch_dataset not in self.disable_dataset else 0 \
+            for batch_dataset in batches_dataset], device=device)[:,None,None,None]
+
+        batch_limit = self.batch_limit
+        
+        random_sample_masks = self.get_random_masks_for_batch((H, W)) # [N, H, W]
+        for i in range(B):
+            # each batch
+            mask_i = mask[i, ...] #[1, H, W]
+            if self.batch_valid[i, ...] < 0.5:
+                loss += 0 * torch.sum(prediction[i, ...])
+                valid_pix += 0 * torch.sum(mask_i)
+                continue
+
+            pred_i = prediction[i, ...].unsqueeze(0).repeat(batch_limit, 1, 1, 1)
+            target_i = target[i, ...].unsqueeze(0).repeat(batch_limit, 1, 1, 1)
+
+            # get semantic masks
+            sem_label_i = sem_mask[i, ...] if sem_mask is not None else None
+            if sem_label_i is not None:
+                sem_masks = self.reorder_sem_masks(sem_label_i) # [N, H, W]
+                random_sem_masks = torch.cat([random_sample_masks, sem_masks], dim=0)
+            else:
+                random_sem_masks = random_sample_masks
+            #random_sem_masks = random_sample_masks
+
+
+            sampled_masks_num = random_sem_masks.shape[0]
+            loops = int(np.ceil(sampled_masks_num / batch_limit))
+            conditional_rank_ids = np.random.choice(sampled_masks_num, sampled_masks_num, replace=False)
+
+            for j in range(loops):
+                mask_random_sem_loopi = random_sem_masks[j*batch_limit:(j+1)*batch_limit, ...]
+                mask_sample = (mask_i & mask_random_sem_loopi).unsqueeze(1) # [N, 1, H, W]
+                loss += self.ssi_mae(
+                    prediction=pred_i[:mask_sample.shape[0], ...], 
+                    target=target_i[:mask_sample.shape[0], ...], 
+                    mask_valid=mask_sample)
+                valid_pix += torch.sum(mask_sample)
+
+                # conditional ssi loss
+                # rerank_mask_random_sem_loopi = random_sem_masks[conditional_rank_ids, ...][j*batch_limit:(j+1)*batch_limit, ...]
+                # rerank_mask_sample = (mask_i & rerank_mask_random_sem_loopi).unsqueeze(1) # [N, 1, H, W]
+                # loss_cond = self.conditional_ssi_mae(
+                #     prediction=pred_i[:rerank_mask_sample.shape[0], ...], 
+                #     target=target_i[:rerank_mask_sample.shape[0], ...], 
+                #     mask_valid=rerank_mask_sample)
+                # print(loss_cond / (torch.sum(rerank_mask_sample) + 1e-10), loss_cond, torch.sum(rerank_mask_sample))
+                # loss += loss_cond
+                # valid_pix += torch.sum(rerank_mask_sample)
+
+        # crop_y, crop_y_end, crop_x, crop_x_end = self.get_random_masks_for_batch((H, W)) # [N,]
+        # for j in range(B):
+        #     for i in range(self.random_num):
+        #         mask_crop = mask[j, :, crop_y[i]:crop_y_end[i], crop_x[i]:crop_x_end[i]][None, ...] #[1, 1, crop_h, crop_w]
+        #         target_crop = target[j, :, crop_y[i]:crop_y_end[i], crop_x[i]:crop_x_end[i]][None, ...]
+        #         pred_crop = prediction[j, :, crop_y[i]:crop_y_end[i], crop_x[i]:crop_x_end[i]][None, ...]
+        #         loss += self.ssi_mae(prediction=pred_crop, target=target_crop, mask_valid=mask_crop)
+        #         valid_pix += torch.sum(mask_crop)
+        
+        # the whole image
+        mask = mask * self.batch_valid.bool()
+        loss += self.ssi_mae(
+                    prediction=prediction, 
+                    target=target, 
+                    mask_valid=mask)
+        valid_pix += torch.sum(mask)
+        loss = loss / (valid_pix + self.eps)
+        if torch.isnan(loss).item() | torch.isinf(loss).item():
+            loss = 0 * torch.sum(prediction)
+            print(f'HDSNL NAN error, {loss}, valid pix: {valid_pix}')
+        return loss * self.loss_weight
+    
+if __name__ == '__main__':
+    torch.manual_seed(1)
+    torch.cuda.manual_seed_all(1)
+    ssil = HDSNRandomLoss()
+    pred = torch.rand((8, 1, 256, 512)).cuda()
+    gt = torch.rand((8, 1, 256, 512)).cuda()#torch.zeros_like(pred).cuda() #
+    gt[1:, :, 100:256, 100:350] = -1
+    gt[:2, ...] = -1
+    mask = gt > 0
+    sem_mask = np.random.randint(-1, 200, (8, 1, 256, 512))
+    sem_mask[sem_mask>0] = -1
+    sem_mask_torch = torch.from_numpy(sem_mask).cuda()
+
+    out = ssil(pred, gt, mask, sem_mask_torch)
+    print(out)

external/Metric3D/training/mono/model/losses/L1.py

@@ -0,0 +1,63 @@
+import torch
+import torch.nn as nn
+
+class L1Loss(nn.Module):
+    """
+    Compute L1 loss.
+    """
+    def __init__(self, loss_weight=1, data_type=['lidar', 'denselidar', 'stereo', 'denselidar_syn'], **kwargs):
+        super(L1Loss, self).__init__()
+        self.loss_weight = loss_weight
+        self.data_type = data_type
+        self.eps = 1e-6
+
+    def forward(self, prediction, target, mask=None, **kwargs):
+        diff = torch.abs(prediction - target)* mask
+        loss = torch.sum(diff) / (torch.sum(mask) + self.eps)
+        if torch.isnan(loss).item() | torch.isinf(loss).item():
+            loss = 0 * torch.sum(prediction)
+            print(f'L1 NAN error, {loss}')
+            #raise RuntimeError(f'Silog error, {loss}, d_square_mean: {d_square_mean}, d_mean: {d_mean}')
+        return loss * self.loss_weight
+
+class L1DispLoss(nn.Module):
+    """
+    Compute L1 disparity loss of disparity.
+    """
+    def __init__(self, loss_weight=1, data_type=['lidar', 'denselidar', 'stereo', 'denselidar_syn'], **kwargs):
+        super(L1DispLoss, self).__init__()
+        self.loss_weight = loss_weight
+        self.data_type = data_type
+        self.eps = 1e-6
+
+    def forward(self, prediction_disp, inv_depth, mask=None, **kwargs):
+        # gt_disp_mask = ~torch.all(inv_depth == 0, dim=1, keepdim=True)
+        # if mask is None:
+        #     mask = gt_disp_mask
+        diff = torch.abs(prediction_disp - inv_depth)* mask
+        loss = torch.sum(diff) / (torch.sum(mask) + self.eps)
+        if torch.isnan(loss).item() | torch.isinf(loss).item():
+            loss = 0 * torch.sum(prediction_disp)
+            #raise RuntimeError(f'Silog error, {loss}, d_square_mean: {d_square_mean}, d_mean: {d_mean}')
+        return loss * self.loss_weight
+    
+class L1InverseLoss(nn.Module):
+    """
+    Compute L1 disparity loss of disparity.
+    """
+    def __init__(self, loss_weight=1, data_type=['lidar', 'denselidar', 'stereo'], **kwargs):
+        super(L1InverseLoss, self).__init__()
+        self.loss_weight = loss_weight
+        self.data_type = data_type
+        self.eps = 1e-6
+
+    def forward(self, prediction, inv_depth, mask=None, **kwargs):
+        mask = torch.logical_and(mask, inv_depth>0)
+        inv_pred = 1.0 / prediction * 10.0
+        inv_pred[~mask] = -1
+        diff = torch.abs(inv_pred - inv_depth)* mask
+        loss = torch.sum(diff) / (torch.sum(mask) + self.eps)
+        if torch.isnan(loss).item() | torch.isinf(loss).item():
+            loss = 0 * torch.sum(inv_pred)
+            #raise RuntimeError(f'Silog error, {loss}, d_square_mean: {d_square_mean}, d_mean: {d_mean}')
+        return loss * self.loss_weight

external/Metric3D/training/mono/model/losses/NormalBranchLoss.py

@@ -0,0 +1,732 @@
+import torch
+import torch.nn as nn
+import numpy as np
+import torch.nn.functional as F
+from .depth_to_normal import Depth2Normal
+
+# compute loss
+class NormalBranchLoss(nn.Module):
+    def __init__(self, loss_weight=1.0, data_type=['sfm', 'stereo', 'denselidar', 'denselidar_syn'], d2n_dataset=['ScanNetAll'], loss_fn='UG_NLL_ours', **kwargs):
+        """loss_fn can be one of following:
+            - L1            - L1 loss (no uncertainty)
+            - L2            - L2 loss (no uncertainty)
+            - AL            - Angular loss (no uncertainty)
+            - NLL_vMF       - NLL of vonMF distribution
+            - NLL_ours      - NLL of Angular vonMF distribution
+            - UG_NLL_vMF    - NLL of vonMF distribution (+ pixel-wise MLP + uncertainty-guided sampling)
+            - UG_NLL_ours   - NLL of Angular vonMF distribution (+ pixel-wise MLP + uncertainty-guided sampling)
+            - NLL_ours_GRU  - NLL of Angular vonMF distribution for GRU sequence
+        """
+        super(NormalBranchLoss, self).__init__()
+        self.loss_type = loss_fn
+        if self.loss_type in ['L1', 'L2', 'AL', 'NLL_vMF', 'NLL_ours']:
+            # self.loss_fn = self.forward_R
+            raise NotImplementedError
+        elif self.loss_type in ['UG_NLL_vMF']:
+            # self.loss_fn = self.forward_UG
+            raise NotImplementedError
+        elif self.loss_type in ['UG_NLL_ours']:
+            self.loss_fn = self.forward_UG
+        elif self.loss_type in ['NLL_ours_GRU', 'NLL_ours_GRU_auxi']:
+            self.loss_type = 'NLL_ours'
+            self.loss_fn = self.forward_GRU
+            self.loss_gamma = 0.9
+            try:
+                self.loss_weight_auxi = kwargs['loss_weight_auxi']
+            except:
+                self.loss_weight_auxi = 0.0
+        else:
+            raise Exception('invalid loss type')
+        
+        self.loss_weight = loss_weight
+        self.data_type = data_type
+        
+        #self.d2n_dataset = d2n_dataset
+        #self.depth2normal = Depth2Normal()
+
+        
+    
+    def forward(self, **kwargs):
+        # device = kwargs['mask'].device
+        # B, _, H, W = kwargs['mask'].shape
+        # pad_mask = torch.zeros_like(kwargs['mask'], device=device)
+        # for b in range(B):
+        #     pad = kwargs['pad'][b].squeeze()
+        #     pad_mask[b, :, pad[0]:H-pad[1], pad[2]:W-pad[3]] = True
+
+        # loss  = self.loss_fn(pad_mask=pad_mask, **kwargs)
+        loss  = self.loss_fn(**kwargs)
+
+        return loss * self.loss_weight
+
+
+    def forward_GRU(self, normal_out_list, normal, target, mask, intrinsic, pad_mask=None, auxi_normal=None, **kwargs):
+        n_predictions = len(normal_out_list)
+        assert n_predictions >= 1
+        loss = 0.0
+
+        # device = pad_mask.device
+        # batches_dataset = kwargs['dataset']
+        # self.batch_with_d2n = torch.tensor([0 if batch_dataset not in self.d2n_dataset else 1 \
+        #                                       for batch_dataset in batches_dataset], device=device)[:,None,None,None]
+
+        # scale = kwargs['scale'][:, None, None].float()
+        # normal_d2n, new_mask_d2n = self.depth2normal(target, intrinsic, pad_mask, scale)
+
+        gt_normal_mask = ~torch.all(normal == 0, dim=1, keepdim=True) & mask
+
+        if auxi_normal != None:
+            auxi_normal_mask = ~gt_normal_mask
+
+        #normal = normal * (1 -  self.batch_with_d2n) + normal_d2n * self.batch_with_d2n
+        # gt_normal_mask = gt_normal_mask * (1 -  self.batch_with_d2n) + mask * new_mask_d2n * self.batch_with_d2n
+
+        if gt_normal_mask.sum() < 10:
+            if auxi_normal == None:
+                for norm_out in normal_out_list:
+                    loss += norm_out.sum() * 0
+                return loss
+
+        for i, norm_out in enumerate(normal_out_list):
+            # We adjust the loss_gamma so it is consistent for any number of RAFT-Stereo iterations
+            adjusted_loss_gamma = self.loss_gamma**(15/(n_predictions - 1))
+            i_weight = adjusted_loss_gamma**(n_predictions - i - 1)
+
+            curr_loss = self.forward_R(norm_out.clone(), normal, gt_normal_mask)
+            if auxi_normal != None:
+                auxi_loss = self.forward_R(norm_out.clone(), auxi_normal[:, :3], auxi_normal_mask)
+                curr_loss = curr_loss + self.loss_weight_auxi * auxi_loss
+
+            if torch.isnan(curr_loss).item() | torch.isinf(curr_loss).item():
+                curr_loss = 0 * torch.sum(norm_out)
+                print(f'NormalBranchLoss forward_GRU NAN error, {curr_loss}')
+            
+            loss += curr_loss * i_weight
+
+        return loss
+
+    def forward_R(self, norm_out, gt_norm, gt_norm_mask):
+        pred_norm, pred_kappa = norm_out[:, 0:3, :, :], norm_out[:, 3:, :, :]
+
+        if self.loss_type == 'L1':
+            l1 = torch.sum(torch.abs(gt_norm - pred_norm), dim=1, keepdim=True)
+            loss = torch.mean(l1[gt_norm_mask])
+
+        elif self.loss_type == 'L2':
+            l2 = torch.sum(torch.square(gt_norm - pred_norm), dim=1, keepdim=True)
+            loss = torch.mean(l2[gt_norm_mask])
+
+        elif self.loss_type == 'AL':
+            dot = torch.cosine_similarity(pred_norm, gt_norm, dim=1)
+
+            valid_mask = gt_norm_mask[:, 0, :, :].float() \
+                         * (dot.detach() < 0.999).float() \
+                         * (dot.detach() > -0.999).float()
+            valid_mask = valid_mask > 0.0
+
+            al = torch.acos(dot[valid_mask])
+            loss = torch.mean(al)
+
+        elif self.loss_type == 'NLL_vMF':
+            dot = torch.cosine_similarity(pred_norm, gt_norm, dim=1)
+
+            valid_mask = gt_norm_mask[:, 0, :, :].float() \
+                         * (dot.detach() < 0.999).float() \
+                         * (dot.detach() > -0.999).float()
+            valid_mask = valid_mask > 0.0
+
+            dot = dot[valid_mask]
+            kappa = pred_kappa[:, 0, :, :][valid_mask]
+
+            loss_pixelwise = - torch.log(kappa) \
+                             - (kappa * (dot - 1)) \
+                             + torch.log(1 - torch.exp(- 2 * kappa))
+            loss = torch.mean(loss_pixelwise)
+
+        elif self.loss_type == 'NLL_ours':
+            dot = torch.cosine_similarity(pred_norm, gt_norm, dim=1)
+
+            valid_mask = gt_norm_mask[:, 0, :, :].float() \
+                         * (dot.detach() < 0.999).float() \
+                         * (dot.detach() > -0.999).float()
+            valid_mask = valid_mask > 0.5
+
+            dot = dot[valid_mask]
+            kappa = pred_kappa[:, 0, :, :][valid_mask]
+
+            loss_pixelwise = - torch.log(torch.square(kappa) + 1) \
+                             + kappa * torch.acos(dot) \
+                             + torch.log(1 + torch.exp(-kappa * np.pi))
+            loss = torch.mean(loss_pixelwise)
+
+        else:
+            raise Exception('invalid loss type')
+
+        return loss
+
+
+    def forward_UG(self, normal_pred_list, normal_coord_list, normal, mask, **kwargs):
+        gt_normal_mask = ~torch.all(normal == 0, dim=1, keepdim=True) & mask
+
+        # gt_norm = norms[0]
+        # gt_normal_mask = (gt_norm[:, 0:1, :, :] == 0) & (gt_norm[:, 1:2, :, :] == 0) & (gt_norm[:, 2:3, :, :] == 0)
+        # gt_normal_mask = ~gt_normal_mask
+        loss = 0.0
+
+        if gt_normal_mask[gt_normal_mask].numel() < 10:
+            for (pred, coord) in zip(normal_pred_list, normal_coord_list):
+                if pred is not None:
+                    loss += pred.sum() * 0.
+                if coord is not None:
+                    loss += coord.sum() * 0.
+            return loss
+
+        
+        for (pred, coord) in zip(normal_pred_list, normal_coord_list):
+            if coord is None:
+                pred = F.interpolate(pred, size=[normal.size(2), normal.size(3)], mode='bilinear', align_corners=True)
+                pred_norm, pred_kappa = pred[:, 0:3, :, :], pred[:, 3:, :, :]
+
+                # if self.loss_type == 'UG_NLL_vMF':
+                #     dot = torch.cosine_similarity(pred_norm, normal, dim=1)
+
+                #     valid_mask = normal_mask[:, 0, :, :].float() \
+                #                 * (dot.detach() < 0.999).float() \
+                #                 * (dot.detach() > -0.999).float()
+                #     valid_mask = valid_mask > 0.5
+
+                #     # mask
+                #     dot = dot[valid_mask]
+                #     kappa = pred_kappa[:, 0, :, :][valid_mask]
+
+                #     loss_pixelwise = - torch.log(kappa) \
+                #                      - (kappa * (dot - 1)) \
+                #                      + torch.log(1 - torch.exp(- 2 * kappa))
+                #     loss = loss + torch.mean(loss_pixelwise)
+
+                if self.loss_type == 'UG_NLL_ours':
+                    dot = torch.cosine_similarity(pred_norm, normal, dim=1)
+
+                    valid_mask = gt_normal_mask[:, 0, :, :].float() \
+                                * (dot.detach() < 0.999).float() \
+                                * (dot.detach() > -0.999).float()
+                    valid_mask = valid_mask > 0.5
+
+                    dot = dot[valid_mask]
+                    kappa = pred_kappa[:, 0, :, :][valid_mask]
+
+                    loss_pixelwise = - torch.log(torch.square(kappa) + 1) \
+                                     + kappa * torch.acos(dot) \
+                                     + torch.log(1 + torch.exp(-kappa * np.pi))
+                    loss = loss + torch.mean(loss_pixelwise)
+
+                else:
+                    raise Exception
+
+            else:
+                # coord: B, 1, N, 2
+                # pred: B, 4, N
+                gt_norm_ = F.grid_sample(normal, coord, mode='nearest', align_corners=True)  # (B, 3, 1, N)
+                gt_norm_mask_ = F.grid_sample(gt_normal_mask.float(), coord, mode='nearest', align_corners=True)  # (B, 1, 1, N)
+                gt_norm_ = gt_norm_[:, :, 0, :]  # (B, 3, N)
+                gt_norm_mask_ = gt_norm_mask_[:, :, 0, :] > 0.5  # (B, 1, N)
+
+                pred_norm, pred_kappa = pred[:, 0:3, :], pred[:, 3:, :]
+
+                # if self.loss_type == 'UG_NLL_vMF':
+                #     dot = torch.cosine_similarity(pred_norm, gt_norm_, dim=1)  # (B, N)
+
+                #     valid_mask = gt_norm_mask_[:, 0, :].float() \
+                #                  * (dot.detach() < 0.999).float() \
+                #                  * (dot.detach() > -0.999).float()
+                #     valid_mask = valid_mask > 0.5
+
+                #     dot = dot[valid_mask]
+                #     kappa = pred_kappa[:, 0, :][valid_mask]
+
+                #     loss_pixelwise = - torch.log(kappa) \
+                #                      - (kappa * (dot - 1)) \
+                #                      + torch.log(1 - torch.exp(- 2 * kappa))
+                #     loss = loss + torch.mean(loss_pixelwise)
+
+                if self.loss_type == 'UG_NLL_ours':
+                    dot = torch.cosine_similarity(pred_norm, gt_norm_, dim=1)  # (B, N)
+
+                    valid_mask = gt_norm_mask_[:, 0, :].float() \
+                                 * (dot.detach() < 0.999).float() \
+                                 * (dot.detach() > -0.999).float()
+                    valid_mask = valid_mask > 0.5
+
+                    dot = dot[valid_mask]
+                    kappa = pred_kappa[:, 0, :][valid_mask]
+
+                    loss_pixelwise = - torch.log(torch.square(kappa) + 1) \
+                                     + kappa * torch.acos(dot) \
+                                     + torch.log(1 + torch.exp(-kappa * np.pi))
+                    loss = loss + torch.mean(loss_pixelwise)
+
+                else:
+                    raise Exception
+        return loss
+
+
+
+
+# confidence-guided sampling
+@torch.no_grad()
+def sample_points(init_normal, confidence_map, gt_norm_mask, sampling_ratio, beta=1):
+    device = init_normal.device
+    B, _, H, W = init_normal.shape
+    N = int(sampling_ratio * H * W)
+    beta = beta
+
+    # confidence map
+    # confidence_map = init_normal[:, 3, :, :]  # B, H, W
+
+    # gt_invalid_mask (B, H, W)
+    if gt_norm_mask is not None:
+        gt_invalid_mask = F.interpolate(gt_norm_mask.float(), size=[H, W], mode='nearest')
+        gt_invalid_mask = gt_invalid_mask < 0.5
+        confidence_map[gt_invalid_mask] = -1e4
+
+    # (B, H*W)
+    _, idx = confidence_map.view(B, -1).sort(1, descending=True)
+
+    # confidence sampling
+    if int(beta * N) > 0:
+        importance = idx[:, :int(beta * N)]    # B, beta*N
+
+        # remaining
+        remaining = idx[:, int(beta * N):]     # B, H*W - beta*N
+
+        # coverage
+        num_coverage = N - int(beta * N)
+
+        if num_coverage <= 0:
+            samples = importance
+        else:
+            coverage_list = []
+            for i in range(B):
+                idx_c = torch.randperm(remaining.size()[1])    # shuffles "H*W - beta*N"
+                coverage_list.append(remaining[i, :][idx_c[:num_coverage]].view(1, -1))     # 1, N-beta*N
+            coverage = torch.cat(coverage_list, dim=0)                                      # B, N-beta*N
+            samples = torch.cat((importance, coverage), dim=1)                              # B, N
+
+    else:
+        # remaining
+        remaining = idx[:, :]  # B, H*W
+
+        # coverage
+        num_coverage = N
+
+        coverage_list = []
+        for i in range(B):
+            idx_c = torch.randperm(remaining.size()[1])  # shuffles "H*W - beta*N"
+            coverage_list.append(remaining[i, :][idx_c[:num_coverage]].view(1, -1))  # 1, N-beta*N
+        coverage = torch.cat(coverage_list, dim=0)  # B, N-beta*N
+        samples = coverage
+
+    # point coordinates
+    rows_int = samples // W         # 0 for first row, H-1 for last row
+    # rows_float = rows_int / float(H-1)         # 0 to 1.0
+    # rows_float = (rows_float * 2.0) - 1.0       # -1.0 to 1.0
+
+    cols_int = samples % W          # 0 for first column, W-1 for last column
+    # cols_float = cols_int / float(W-1)         # 0 to 1.0
+    # cols_float = (cols_float * 2.0) - 1.0       # -1.0 to 1.0
+
+    # point_coords = torch.zeros(B, 1, N, 2)
+    # point_coords[:, 0, :, 0] = cols_float             # x coord
+    # point_coords[:, 0, :, 1] = rows_float             # y coord
+    # point_coords = point_coords.to(device)
+    # return point_coords, rows_int, cols_int
+
+    sample_mask = torch.zeros((B,1,H,W), dtype=torch.bool, device=device)
+    for i in range(B):
+        sample_mask[i, :, rows_int[i,:], cols_int[i,:]] = True
+    return sample_mask
+
+# depth-normal consistency loss
+class DeNoConsistencyLoss(nn.Module):
+    def __init__(self, loss_weight=1.0, data_type=['stereo', 'lidar', 'denselidar', 'denselidar_nometric', 'denselidar_syn'], loss_fn='NLL_ours', \
+                 sky_id=142, scale=1, norm_dataset=['Taskonomy', 'Matterport3D', 'Replica', 'Hypersim', 'NYU'], no_sky_dataset=['BigData', 'DIODE', 'Completion', 'Matterport3D'], disable_dataset=[], depth_detach=False, **kwargs):
+        """loss_fn can be one of following:
+            - L1            - L1 loss (no uncertainty)
+            - L2            - L2 loss (no uncertainty)
+            - AL            - Angular loss (no uncertainty)
+            - NLL_vMF       - NLL of vonMF distribution
+            - NLL_ours      - NLL of Angular vonMF distribution
+            - UG_NLL_vMF    - NLL of vonMF distribution (+ pixel-wise MLP + uncertainty-guided sampling)
+            - UG_NLL_ours   - NLL of Angular vonMF distribution (+ pixel-wise MLP + uncertainty-guided sampling)
+            - NLL_ours_GRU  - NLL of Angular vonMF distribution for GRU sequence
+            - CEL           - cosine embedding loss
+            - CEL_GRU
+        """
+        super(DeNoConsistencyLoss, self).__init__()
+        self.loss_type = loss_fn
+        if self.loss_type in ['L1', 'L2', 'NLL_vMF']:
+            # self.loss_fn = self.forward_R
+            raise NotImplementedError
+        elif self.loss_type in ['UG_NLL_vMF']:
+            # self.loss_fn = self.forward_UG
+            raise NotImplementedError
+        elif self.loss_type in ['UG_NLL_ours']:
+            # self.loss_fn = self.forward_UG
+            raise NotImplementedError
+        elif self.loss_type in ['NLL_ours']:
+            self.loss_fn = self.forward_J # confidence Joint optimization
+            self.loss_gamma = 0.9
+        elif self.loss_type in ['AL', 'CEL', 'CEL_L2']:
+            self.loss_fn = self.forward_S # confidence Sample
+        elif self.loss_type in ['CEL_GRU']:
+            self.loss_fn = self.forward_S_GRU # gru
+            self.loss_gamma = 0.9
+        elif 'Search' in self.loss_type:
+            self.loss_fn = self.forward_S_Search
+        else:
+            raise Exception('invalid loss type')
+        
+        self.loss_weight = loss_weight
+        self.data_type = data_type
+        self.sky_id = sky_id
+
+        # For datasets without surface normal gt, enhance its weight (decrease the weight of the dataset with gt).
+        self.nonorm_data_scale = scale 
+        self.norm_dataset = norm_dataset
+        self.no_sky_dataset = no_sky_dataset
+        self.disable_dataset = disable_dataset
+
+        self.depth_detach = depth_detach
+        self.depth2normal = Depth2Normal()
+    
+    def forward(self, **kwargs):
+        device = kwargs['mask'].device
+
+        batches_dataset = kwargs['dataset']
+        self.batch_with_norm = torch.tensor([self.nonorm_data_scale if batch_dataset not in self.norm_dataset else 1 \
+                                              for batch_dataset in batches_dataset], device=device)[:,None,None,None]
+
+        self.batch_enabled= torch.tensor([1 if batch_dataset not in  self.disable_dataset  else 0 \
+                                              for batch_dataset in batches_dataset], device=device, dtype=torch.bool)[:,None,None,None]
+        self.batch_with_norm = self.batch_with_norm * self.batch_enabled
+
+
+        self.batch_with_norm_sky = torch.tensor([1 if batch_dataset not in  self.no_sky_dataset  else 0 \
+                                              for batch_dataset in batches_dataset], device=device, dtype=torch.bool)[:,None,None,None]
+
+        B, _, H, W = kwargs['mask'].shape
+        pad_mask = torch.zeros_like(kwargs['mask'], device=device)
+        for b in range(B):
+            pad = kwargs['pad'][b].squeeze()
+            pad_mask[b, :, pad[0]:H-pad[1], pad[2]:W-pad[3]] = True
+
+        loss  = self.loss_fn(pad_mask=pad_mask, **kwargs)
+        return loss * self.loss_weight
+
+
+    def forward_J(self, prediction, confidence, normal_out_list, intrinsic, pad_mask, sem_mask=None, **kwargs):
+        prediction_normal = normal_out_list[-1].clone()
+
+        # get normal from depth-prediction 
+        normal, new_mask = self.depth2normal(prediction.detach() if self.depth_detach else prediction, intrinsic, pad_mask)
+        # mask sky
+        sky_mask = sem_mask != self.sky_id
+        new_mask = new_mask & sky_mask
+        # normal = normal * (~sky_mask)
+        # normal[:,1:2,:,:][sky_mask] = 1
+        # confidence sampling (sample good depth -> good normal -> to )
+        sample_mask_d = sample_points(prediction, confidence, new_mask, sampling_ratio=0.7)
+
+        # all mask
+        normal_mask = ~torch.all(normal == 0, dim=1, keepdim=True) & new_mask & sample_mask_d
+        if normal_mask.sum() < 10:
+            return 0 * prediction_normal.sum()
+
+        loss = self.forward_R(prediction_normal, normal, normal_mask)
+        if torch.isnan(loss).item() | torch.isinf(loss).item():
+            loss = 0 * torch.sum(prediction_normal)
+            print(f'NormalBranchLoss forward_GRU NAN error, {loss}')
+
+        return loss
+
+    #def forward_S(self, prediction, confidence, normal_out_list, intrinsic, pad_mask, sem_mask=None, **kwargs):
+    def forward_S(self, prediction, confidence, intrinsic, pad_mask, normal_pred=None, sem_mask=None, target=None, is_initial_pair=False, **kwargs):
+        
+        if normal_pred is None:
+            prediction_normal = kwargs['normal_out_list'][-1]
+        else:
+            prediction_normal = normal_pred
+
+        # get normal from depth-prediction 
+        #try:
+        scale = kwargs['scale'][:, None, None].float()
+        #except:
+            #scale = 1.0
+        normal, new_mask = self.depth2normal(prediction.detach() if self.depth_detach else prediction, intrinsic, pad_mask, scale)
+
+        sky_mask = sem_mask != self.sky_id
+        if target != None:
+            sampling_ratio = 0.7
+            target_mask = (target > 0) 
+            if is_initial_pair == False:
+                pass
+            # mask sky
+            else:
+                sky_mask = torch.nn.functional.interpolate(sky_mask.float(), scale_factor=0.25).bool()
+                target_mask = torch.nn.functional.interpolate(target_mask.float(), scale_factor=0.25).bool()
+                new_mask = new_mask & ((sky_mask & self.batch_with_norm_sky) | target_mask)
+        else:
+            new_mask =  torch.ones_like(prediction).bool()
+            sampling_ratio = 0.5
+
+        # normal = normal * (~sky_mask)
+        # normal[:,1:2,:,:][sky_mask] = 1
+
+        # dual sampling
+        confidence_normal = prediction_normal[:, 3:, :, :]
+        sample_mask_n = sample_points(prediction_normal, confidence_normal, new_mask, sampling_ratio=sampling_ratio)
+        sample_mask_d = sample_points(prediction, confidence, new_mask, sampling_ratio=sampling_ratio)
+        conf_mask = confidence > 0.5
+
+        # all mask
+        normal_mask = ~torch.all(normal == 0, dim=1, keepdim=True) & new_mask & sample_mask_n & sample_mask_d & conf_mask
+        if normal_mask.sum() < 10:
+            return 0 * prediction_normal.sum() 
+
+        loss = self.forward_R(prediction_normal, normal, normal_mask)
+        if torch.isnan(loss).item() | torch.isinf(loss).item():
+            loss = 0 * torch.sum(prediction_normal)
+            print(f'NormalBranchLoss forward_GRU NAN error, {loss}')
+
+        return loss
+
+    def forward_S_GRU(self, predictions_list, confidence_list, normal_out_list, intrinsic, pad_mask, sem_mask, target, low_resolution_init, **kwargs):
+        n_predictions = len(normal_out_list)
+        assert n_predictions >= 1
+        loss = 0.0
+
+        for i, (norm, conf, depth) in enumerate(zip(normal_out_list, confidence_list, predictions_list)):
+            # We adjust the loss_gamma so it is consistent for any number of RAFT-Stereo iterations
+            adjusted_loss_gamma = self.loss_gamma**(15/(n_predictions - 1))
+            i_weight = adjusted_loss_gamma**(n_predictions - i - 1)
+
+            if i == 0:
+                is_initial_pair = True
+                new_intrinsic =  torch.cat((intrinsic[:, :2, :]/4, intrinsic[:, 2:3, :]), dim=1)
+                curr_loss = self.forward_S(low_resolution_init[0], low_resolution_init[1], new_intrinsic, torch.nn.functional.interpolate(pad_mask.float(), scale_factor=0.25).bool(), low_resolution_init[2], sem_mask, target, is_initial_pair, scale=kwargs['scale'])
+            else:
+                is_initial_pair = False
+                curr_loss = self.forward_S(depth, conf, intrinsic, pad_mask, norm, sem_mask, target, is_initial_pair, scale=kwargs['scale'])
+            
+            if torch.isnan(curr_loss).item() | torch.isinf(curr_loss).item():
+                curr_loss = 0 * torch.sum(norm)
+                print(f'NormalBranchLoss forward_GRU NAN error, {curr_loss}')
+            
+            loss += curr_loss * i_weight
+
+        return loss
+
+
+    def forward_R(self, norm_out, gt_norm, gt_norm_mask, pred_kappa=None):
+        pred_norm = norm_out[:, 0:3, :, :]
+        if pred_kappa is None:
+            pred_kappa = norm_out[:, 3:, :, :]
+
+        if self.loss_type == 'L1':
+            l1 = torch.sum(torch.abs(gt_norm - pred_norm), dim=1, keepdim=True)
+            loss = torch.mean(l1[gt_norm_mask])
+
+        elif self.loss_type == 'L2' or self.loss_type == 'CEL_L2':
+            l2 = torch.sum(torch.square(gt_norm - pred_norm), dim=1, keepdim=True)
+            loss = torch.mean(l2[gt_norm_mask])
+
+        elif self.loss_type == 'AL':
+            dot = torch.cosine_similarity(pred_norm, gt_norm, dim=1)
+
+            valid_mask = gt_norm_mask[:, 0, :, :].float() \
+                         * (dot.detach() < 0.999).float() \
+                         * (dot.detach() > -0.999).float()
+            valid_mask = valid_mask > 0.0
+
+            al = torch.acos(dot * valid_mask)
+            al = al * self.batch_with_norm[:, 0, :, :]
+            loss = torch.mean(al)
+        
+        elif self.loss_type == 'CEL' or self.loss_type == 'CEL_GRU':
+            dot = torch.cosine_similarity(pred_norm, gt_norm, dim=1)
+
+            valid_mask = gt_norm_mask[:, 0, :, :].float() \
+                         * (dot.detach() < 0.999).float() \
+                         * (dot.detach() > -0.999).float()
+            valid_mask = valid_mask > 0.0
+
+            al = 1 - dot * valid_mask
+            al = al * self.batch_with_norm[:, 0, :, :]
+            loss = torch.mean(al)
+
+        elif self.loss_type == 'NLL_vMF':
+            dot = torch.cosine_similarity(pred_norm, gt_norm, dim=1)
+
+            valid_mask = gt_norm_mask[:, 0, :, :].float() \
+                         * (dot.detach() < 0.999).float() \
+                         * (dot.detach() > -0.999).float()
+            valid_mask = valid_mask > 0.0
+
+            dot = dot[valid_mask]
+            kappa = pred_kappa[:, 0, :, :][valid_mask]
+
+            loss_pixelwise = - torch.log(kappa) \
+                             - (kappa * (dot - 1)) \
+                             + torch.log(1 - torch.exp(- 2 * kappa))
+            loss = torch.mean(loss_pixelwise)
+
+        elif self.loss_type == 'NLL_ours':
+            dot = torch.cosine_similarity(pred_norm, gt_norm, dim=1)
+
+            valid_mask = gt_norm_mask[:, 0, :, :].float() \
+                         * (dot.detach() < 0.999).float() \
+                         * (dot.detach() > -0.999).float()
+            valid_mask = valid_mask > 0.5
+
+            dot = dot * valid_mask
+            kappa = pred_kappa[:, 0, :, :] * valid_mask
+
+            loss_pixelwise = - torch.log(torch.square(kappa) + 1) \
+                             + kappa * torch.acos(dot) \
+                             + torch.log(1 + torch.exp(-kappa * np.pi))
+            loss_pixelwise = loss_pixelwise * self.batch_with_norm[:, 0, :, :]
+            loss = torch.mean(loss_pixelwise)
+
+        else:
+            raise Exception('invalid loss type')
+
+        return loss
+
+    def forward_S_Search(self, prediction, confidence, intrinsic, pad_mask, normal_pred=None, sem_mask=None, target=None, is_initial_pair=False, **kwargs):
+        
+        if normal_pred is None:
+            prediction_normal = kwargs['normal_out_list'][-1]
+        else:
+            prediction_normal = normal_pred
+
+        # get normal from depth-prediction 
+        scale = kwargs['scale'][:, None, None].float()
+        candidate_scale = kwargs['candidate_scale'][:, None, None, None].float() 
+        normal, new_mask = self.depth2normal(prediction.detach() if self.depth_detach else prediction, intrinsic, pad_mask, scale)
+
+        sky_mask = sem_mask != self.sky_id
+        if target != None:
+            sampling_ratio = 0.7
+            target_mask = (target > 0) 
+            if is_initial_pair == False:
+                pass
+            # mask sky
+            else:
+                sky_mask = torch.nn.functional.interpolate(sky_mask.float(), scale_factor=0.25).bool()
+                target_mask = torch.nn.functional.interpolate(target_mask.float(), scale_factor=0.25).bool()
+                new_mask = new_mask & ((sky_mask & self.batch_with_norm_sky) | target_mask)
+        else:
+            new_mask =  torch.ones_like(prediction).bool()
+            sampling_ratio = 0.5
+
+        # normal = normal * (~sky_mask)
+        # normal[:,1:2,:,:][sky_mask] = 1
+
+        # dual sampling
+        confidence_normal = prediction_normal[:, 3:, :, :]
+        sample_mask_n = sample_points(prediction_normal, confidence_normal, new_mask, sampling_ratio=sampling_ratio)
+        sample_mask_d = sample_points(prediction, confidence, new_mask, sampling_ratio=sampling_ratio)
+        conf_mask = confidence > 0.5
+
+        # all mask
+        normal_mask = ~torch.all(normal == 0, dim=1, keepdim=True) & new_mask & sample_mask_n & sample_mask_d & conf_mask
+        if normal_mask.sum() < 10:
+            return 0 * prediction_normal.sum() 
+
+        prediction_normal = torch.cat((prediction_normal[:,:2]*torch.ones_like(candidate_scale), prediction_normal[:,2:3]*candidate_scale, prediction_normal[:,3:4]*torch.ones_like(candidate_scale)), dim=1)
+        
+        norm_x = prediction_normal[:,0:1]
+        norm_y = prediction_normal[:,1:2]
+        norm_z = prediction_normal[:,2:3]
+        
+        prediction_normal[:,:3] = prediction_normal[:,:3] / (torch.sqrt(norm_x ** 2.0 + norm_y ** 2.0 + norm_z ** 2.0) + 1e-10)
+        
+        loss = self.forward_R_Search(prediction_normal, normal, normal_mask)
+        #if torch.isnan(loss).item() | torch.isinf(loss).item():
+            #loss = 0 * torch.sum(prediction_normal)
+            #print(f'NormalBranchLoss forward_GRU NAN error, {loss}')
+
+        return loss
+
+
+    def forward_R_Search(self, norm_out, gt_norm, gt_norm_mask, pred_kappa=None):
+        pred_norm = norm_out[:, 0:3, :, :]
+        if pred_kappa is None:
+            pred_kappa = norm_out[:, 3:, :, :]
+
+        if 'L1' in self.loss_type:
+            l1 = torch.sum(torch.abs(gt_norm - pred_norm), dim=1, keepdim=True)
+            loss = torch.mean(l1*gt_norm_mask, dim=[1, 2, 3])
+
+        elif 'L2' in self.loss_type:
+            l2 = torch.sum(torch.square(gt_norm - pred_norm), dim=1, keepdim=True)
+            loss = torch.mean(l2*gt_norm_mask, dim=[1, 2, 3])
+
+        elif 'AL' in self.loss_type:
+            dot = torch.cosine_similarity(pred_norm, gt_norm, dim=1)
+
+            valid_mask = gt_norm_mask[:, 0, :, :].float() \
+                         * (dot.detach() < 0.999).float() \
+                         * (dot.detach() > -0.999).float()
+            valid_mask = valid_mask > 0.0
+
+            al = torch.acos(dot * valid_mask)
+            loss = torch.mean(al, dim=[1, 2])
+
+        elif 'CEL' in self.loss_type:
+            dot = torch.cosine_similarity(pred_norm, gt_norm, dim=1)
+
+            valid_mask = gt_norm_mask[:, 0, :, :].float() \
+                         * (dot.detach() < 0.999).float() \
+                         * (dot.detach() > -0.999).float()
+            valid_mask = valid_mask > 0.0
+
+            al = 1 - dot * valid_mask
+            loss = torch.mean(al, dim=[1, 2])
+
+        elif 'NLL_vMF' in self.loss_type:
+            dot = torch.cosine_similarity(pred_norm, gt_norm, dim=1)
+
+            valid_mask = gt_norm_mask[:, 0, :, :].float() \
+                         * (dot.detach() < 0.999).float() \
+                         * (dot.detach() > -0.999).float()
+            valid_mask = valid_mask > 0.0
+
+            dot = dot[valid_mask]
+            kappa = pred_kappa[:, 0, :, :][valid_mask]
+
+            loss_pixelwise = - torch.log(kappa) \
+                             - (kappa * (dot - 1)) \
+                             + torch.log(1 - torch.exp(- 2 * kappa))
+            loss = torch.mean(loss_pixelwise, dim=[1, 2])
+
+        elif 'NLL_ours' in self.loss_type:
+            dot = torch.cosine_similarity(pred_norm, gt_norm, dim=1)
+
+            valid_mask = gt_norm_mask[:, 0, :, :].float() \
+                         * (dot.detach() < 0.999).float() \
+                         * (dot.detach() > -0.999).float()
+            valid_mask = valid_mask > 0.5
+
+            dot = dot * valid_mask
+            kappa = pred_kappa[:, 0, :, :] * valid_mask
+
+            loss_pixelwise = - torch.log(torch.square(kappa) + 1) \
+                             + kappa * torch.acos(dot) \
+                             + torch.log(1 + torch.exp(-kappa * np.pi))
+            loss = torch.mean(loss_pixelwise, dim=[1, 2])
+
+        else:
+            raise Exception('invalid loss type')
+
+        return loss

external/Metric3D/training/mono/model/losses/NormalRegression.py

@@ -0,0 +1,418 @@
+import torch
+from torch import nn
+import numpy as np
+import torch.nn.functional as F
+from .depth_to_normal import Depth2Normal
+"""
+Sampling strategies: RS (Random Sampling), EGS (Edge-Guided Sampling), and IGS (Instance-Guided Sampling)
+"""
+###########
+# RANDOM SAMPLING
+# input:
+# inputs[i,:], targets[i, :], masks[i, :], self.mask_value, self.point_pairs
+# return:
+# inputs_A, inputs_B, targets_A, targets_B, consistent_masks_A, consistent_masks_B
+###########
+def randomSamplingNormal(inputs, targets, masks, sample_num):
+
+    # find A-B point pairs from prediction
+    num_effect_pixels = torch.sum(masks)
+    shuffle_effect_pixels = torch.randperm(num_effect_pixels, device="cuda")
+    valid_inputs = inputs[:, masks]
+    valid_targes = targets[:, masks]
+    inputs_A = valid_inputs[:, shuffle_effect_pixels[0 : sample_num * 2 : 2]]
+    inputs_B = valid_inputs[:, shuffle_effect_pixels[1 : sample_num * 2 : 2]]
+    # find corresponding pairs from GT
+    targets_A = valid_targes[:, shuffle_effect_pixels[0 : sample_num * 2 : 2]]
+    targets_B = valid_targes[:, shuffle_effect_pixels[1 : sample_num * 2 : 2]]
+    if inputs_A.shape[1] != inputs_B.shape[1]:
+        num_min = min(targets_A.shape[1], targets_B.shape[1])
+        inputs_A = inputs_A[:, :num_min]
+        inputs_B = inputs_B[:, :num_min]
+        targets_A = targets_A[:, :num_min]
+        targets_B = targets_B[:, :num_min]
+    return inputs_A, inputs_B, targets_A, targets_B
+
+
+###########
+# EDGE-GUIDED SAMPLING
+# input:
+# inputs[i,:], targets[i, :], masks[i, :], edges_img[i], thetas_img[i], masks[i, :], h, w
+# return:
+# inputs_A, inputs_B, targets_A, targets_B, masks_A, masks_B
+###########
+def ind2sub(idx, cols):
+    r = torch.div(idx, cols, rounding_mode='floor')
+    c = idx - r * cols
+    return r, c
+
+
+def sub2ind(r, c, cols):
+    idx = r * cols + c
+    return idx
+
+
+def edgeGuidedSampling(inputs, targets, edges_img, thetas_img, masks, h, w):
+    # find edges
+    edges_max = edges_img.max()
+    edges_min = edges_img.min()
+    edges_mask = edges_img.ge(edges_max * 0.1)
+    edges_loc = edges_mask.nonzero(as_tuple=False)
+
+    thetas_edge = torch.masked_select(thetas_img, edges_mask)
+    minlen = thetas_edge.size()[0]
+
+    # find anchor points (i.e, edge points)
+    sample_num = minlen
+    index_anchors = torch.randint(0, minlen, (sample_num,), dtype=torch.long, device="cuda")
+    theta_anchors = torch.gather(thetas_edge, 0, index_anchors)
+    row_anchors, col_anchors = ind2sub(edges_loc[index_anchors].squeeze(1), w)
+    ## compute the coordinates of 4-points,  distances are from [2, 30]
+    distance_matrix = torch.randint(3, 20, (4, sample_num), device="cuda")
+    pos_or_neg = torch.ones(4, sample_num, device="cuda")
+    pos_or_neg[:2, :] = -pos_or_neg[:2, :]
+    distance_matrix = distance_matrix.float() * pos_or_neg
+    col = (
+        col_anchors.unsqueeze(0).expand(4, sample_num).long()
+        + torch.round(
+            distance_matrix.float() * torch.abs(torch.cos(theta_anchors)).unsqueeze(0)
+        ).long()
+    )
+    row = (
+        row_anchors.unsqueeze(0).expand(4, sample_num).long()
+        + torch.round(
+            distance_matrix.float() * torch.abs(torch.sin(theta_anchors)).unsqueeze(0)
+        ).long()
+    )
+
+    # constrain 0=<c<=w, 0<=r<=h
+    # Note: index should minus 1
+    col[col < 0] = 0
+    col[col > w - 1] = w - 1
+    row[row < 0] = 0
+    row[row > h - 1] = h - 1
+
+    # a-b, b-c, c-d
+    a = sub2ind(row[0, :], col[0, :], w)
+    b = sub2ind(row[1, :], col[1, :], w)
+    c = sub2ind(row[2, :], col[2, :], w)
+    d = sub2ind(row[3, :], col[3, :], w)
+    A = torch.cat((a, b, c), 0)
+    B = torch.cat((b, c, d), 0)
+
+    
+
+    inputs_A = inputs[:, A]
+    inputs_B = inputs[:, B]
+    targets_A = targets[:, A]
+    targets_B = targets[:, B]
+    masks_A = torch.gather(masks, 0, A.long())
+    masks_B = torch.gather(masks, 0, B.long())
+
+    # create A, B, C, D mask for visualization
+    # vis_mask = masks.reshape(h, w).cpu().numpy()
+    # vis_row = row.cpu()
+    # vis_col = col.cpu()
+    # visual_A = np.zeros((h, w)).astype(np.bool)
+    # visual_B = np.zeros_like(visual_A)
+    # visual_C = np.zeros_like(visual_A)
+    # visual_D = np.zeros_like(visual_A)
+    # visual_A[vis_row[0, :], vis_col[0, :]] = True
+    # visual_B[vis_row[1, :], vis_col[1, :]] = True
+    # visual_C[vis_row[2, :], vis_col[2, :]] = True
+    # visual_D[vis_row[3, :], vis_col[3, :]] = True
+    # visual_ABCD = [visual_A & vis_mask, visual_B & vis_mask, 
+    # visual_C& vis_mask, visual_D& vis_mask]
+    return (
+        inputs_A,
+        inputs_B,
+        targets_A,
+        targets_B,
+        masks_A,
+        masks_B,
+        sample_num,
+        row,
+        col,
+    )
+
+
+######################################################
+# EdgeguidedNormalRankingLoss
+#####################################################
+class EdgeguidedNormalLoss(nn.Module):
+    def __init__(
+        self,
+        point_pairs=10000,
+        cos_theta1=0.25,
+        cos_theta2=0.98,
+        cos_theta3=0.5,
+        cos_theta4=0.86,
+        mask_value=1e-8,
+        loss_weight=1.0, 
+        data_type=['stereo', 'denselidar', 'denselidar_nometric','denselidar_syn'],
+        **kwargs
+    ):
+        super(EdgeguidedNormalLoss, self).__init__()
+        self.point_pairs = point_pairs  # number of point pairs
+        self.mask_value = mask_value
+        self.cos_theta1 = cos_theta1  # 75 degree
+        self.cos_theta2 = cos_theta2  # 10 degree
+        self.cos_theta3 = cos_theta3  # 60 degree
+        self.cos_theta4 = cos_theta4  # 30 degree
+        # self.kernel = torch.tensor(
+        #     np.array([[1, 1, 1], [1, 1, 1], [1, 1, 1]], dtype=np.float32),
+        #     requires_grad=False,
+        # )[None, None, :, :].cuda()
+        self.depth2normal = Depth2Normal()
+        self.loss_weight = loss_weight
+        self.data_type = data_type
+        self.eps = 1e-6
+
+
+    def getEdge(self, images):
+        n, c, h, w = images.size()
+        a = (
+            torch.tensor([[-1, 0, 1], [-2, 0, 2], [-1, 0, 1]], dtype=torch.float32, device="cuda")
+            .contiguous()
+            .view((1, 1, 3, 3))
+            .repeat(1, 1, 1, 1)
+        )
+        b = (
+            torch.tensor([[1, 2, 1], [0, 0, 0], [-1, -2, -1]], dtype=torch.float32, device="cuda")
+            .contiguous()
+            .view((1, 1, 3, 3))
+            .repeat(1, 1, 1, 1)
+        )
+        if c == 3:
+            gradient_x = F.conv2d(images[:, 0, :, :].unsqueeze(1), a)
+            gradient_y = F.conv2d(images[:, 0, :, :].unsqueeze(1), b)
+        else:
+            gradient_x = F.conv2d(images, a)
+            gradient_y = F.conv2d(images, b)
+        edges = torch.sqrt(torch.pow(gradient_x, 2) + torch.pow(gradient_y, 2))
+        edges = F.pad(edges, (1, 1, 1, 1), "constant", 0)
+        thetas = torch.atan2(gradient_y, gradient_x)
+        thetas = F.pad(thetas, (1, 1, 1, 1), "constant", 0)
+        return edges, thetas
+
+    def getNormalEdge(self, normals):
+        n, c, h, w = normals.size()
+        a = (
+            torch.Tensor([[-1, 0, 1], [-2, 0, 2], [-1, 0, 1]], dtype=torch.float32, device="cuda")
+            .contiguous()
+            .view((1, 1, 3, 3))
+            .repeat(3, 1, 1, 1)
+        )
+        b = (
+            torch.Tensor([[1, 2, 1], [0, 0, 0], [-1, -2, -1]], dtype=torch.float32, device="cuda")
+            .contiguous()
+            .view((1, 1, 3, 3))
+            .repeat(3, 1, 1, 1)
+        )
+        gradient_x = torch.abs(F.conv2d(normals, a, groups=c))
+        gradient_y = torch.abs(F.conv2d(normals, b, groups=c))
+        gradient_x = gradient_x.mean(dim=1, keepdim=True)
+        gradient_y = gradient_y.mean(dim=1, keepdim=True)
+        edges = torch.sqrt(torch.pow(gradient_x, 2) + torch.pow(gradient_y, 2))
+        edges = F.pad(edges, (1, 1, 1, 1), "constant", 0)
+        thetas = torch.atan2(gradient_y, gradient_x)
+        thetas = F.pad(thetas, (1, 1, 1, 1), "constant", 0)
+        return edges, thetas
+
+    def visual_check(self, rgb, samples):
+        import os
+        import matplotlib.pyplot as plt
+        rgb = rgb.cpu().squeeze().numpy()
+
+        mean = np.array([123.675, 116.28, 103.53])[:, np.newaxis, np.newaxis]
+        std= np.array([58.395, 57.12, 57.375])[:, np.newaxis, np.newaxis]
+        
+        rgb = ((rgb * std) + mean).astype(np.uint8).transpose((1, 2, 0))
+        mask_A, mask_B, mask_C, mask_D = samples
+        rgb[mask_A.astype(np.bool)] = [255, 0, 0]
+        rgb[mask_B.astype(np.bool)] = [0, 255, 0]
+        rgb[mask_C.astype(np.bool)] = [0, 0, 255]
+        rgb[mask_D.astype(np.bool)] = [255, 255, 0]
+        
+        filename = str(np.random.randint(10000))
+        save_path = os.path.join('test_ranking', filename + '.png')
+        os.makedirs(os.path.dirname(save_path), exist_ok=True)
+        plt.imsave(save_path, rgb)
+
+    def forward(self, prediction, target, mask, input, intrinsic, **kwargs):
+        loss  = self.get_loss(prediction, target, mask, input, intrinsic, **kwargs)
+        return loss
+
+    def get_loss(self, prediction, target, mask, input, intrinsic, **kwargs):
+        """
+        input and target: surface normal input
+        input: rgb images
+        """
+        gt_depths = target
+
+        if 'predictions_normals' not in kwargs:
+            predictions_normals, _ = self.depth2normal(prediction, intrinsic, mask)
+            targets_normals, targets_normals_masks = self.depth2normal(target, intrinsic, mask)
+        else:
+            predictions_normals = kwargs['predictions_normals']
+            targets_normals = kwargs['targets_normals']
+            targets_normals_masks = kwargs['targets_normals_masks']
+        masks_normals = mask & targets_normals_masks
+        
+        # find edges from RGB
+        edges_img, thetas_img = self.getEdge(input)
+
+        # find edges from normals
+        # edges_normal, thetas_normal = self.getNormalEdge(targets_normals)
+        #mask_img_border = torch.ones_like(edges_normal)  # normals on the borders
+        #mask_img_border[:, :, 5:-5, 5:-5] = 0
+        # edges_normal[~targets_normals_masks] = 0
+
+        # find edges from depth
+        edges_depth, thetas_depth = self.getEdge(gt_depths)
+        # edges_depth_mask = edges_depth.ge(edges_depth.max() * 0.1)
+        # edges_mask_dilate = torch.clamp(
+        #     torch.nn.functional.conv2d(
+        #         edges_depth_mask.float(), self.kernel, padding=(1, 1)
+        #     ),
+        #     0,
+        #     1,
+        # ).bool()
+        # edges_normal[edges_mask_dilate] = 0
+        # edges_img[edges_mask_dilate] = 0
+
+        # =============================
+        n, c, h, w = targets_normals.size()
+
+        predictions_normals = predictions_normals.contiguous().view(n, c, -1)
+        targets_normals = targets_normals.contiguous().view(n, c, -1)
+        masks_normals = masks_normals.contiguous().view(n, -1)
+        edges_img = edges_img.contiguous().view(n, -1)
+        thetas_img = thetas_img.contiguous().view(n, -1)
+        # edges_normal = edges_normal.view(n, -1)
+        # thetas_normal = thetas_normal.view(n, -1)
+        edges_depth = edges_depth.contiguous().view(n, -1)
+        thetas_depth = thetas_depth.contiguous().view(n, -1)
+
+        # # initialization
+        losses = 0.0
+        valid_samples = 0.0
+        for i in range(n):
+            # Edge-Guided sampling
+            (
+                inputs_A,
+                inputs_B,
+                targets_A,
+                targets_B,
+                masks_A,
+                masks_B,
+                sample_num,
+                row_img,
+                col_img,
+            ) = edgeGuidedSampling(
+                predictions_normals[i, :],
+                targets_normals[i, :],
+                edges_img[i],
+                thetas_img[i],
+                masks_normals[i, :],
+                h,
+                w,
+            )
+            # Depth-Guided sampling
+            # (
+            #     depth_inputs_A,
+            #     depth_inputs_B,
+            #     depth_targets_A,
+            #     depth_targets_B,
+            #     depth_masks_A,
+            #     depth_masks_B,
+            #     depth_sample_num,
+            #     row_img,
+            #     col_img,
+            # ) = edgeGuidedSampling(
+            #     predictions_normals[i, :],
+            #     targets_normals[i, :],
+            #     edges_depth[i],
+            #     thetas_depth[i],
+            #     masks_normals[i, :],
+            #     h,
+            #     w,
+            # )
+            # Normal-Guided sampling
+            # (
+            #     normal_inputs_A,
+            #     normal_inputs_B,
+            #     normal_targets_A,
+            #     normal_targets_B,
+            #     normal_masks_A,
+            #     normal_masks_B,
+            #     normal_sample_num,
+            #     row_normal,
+            #     col_normal,
+            # ) = edgeGuidedSampling(
+            #     predictions_normals[i, :],
+            #     targets_normals[i, :],
+            #     edges_normal[i],
+            #     thetas_normal[i],
+            #     masks_normals[i, :],
+            #     h,
+            #     w,
+            # )
+
+            # Combine EGS + DEGS
+            # inputs_A = torch.cat((inputs_A, depth_inputs_A), 1) #normal_inputs_A
+            # inputs_B = torch.cat((inputs_B, depth_inputs_B), 1) # normal_inputs_B
+            # targets_A = torch.cat((targets_A, depth_targets_A), 1) #normal_targets_A
+            # targets_B = torch.cat((targets_B, depth_targets_B), 1) #normal_targets_B
+            # masks_A = torch.cat((masks_A, depth_masks_A), 0) #normal_masks_A
+            # masks_B = torch.cat((masks_B, depth_masks_B), 0) #normal_masks_B
+
+            # consider forward-backward consistency checking, i.e, only compute losses of point pairs with valid GT
+            consistency_mask = masks_A & masks_B
+
+            # GT ordinal relationship
+            target_cos = torch.sum(targets_A * targets_B, dim=0)
+            input_cos = torch.sum(inputs_A * inputs_B, dim=0)
+
+            losses += torch.sum(torch.abs(torch.ones_like(target_cos)-input_cos) * consistency_mask.float())
+            valid_samples += torch.sum(consistency_mask.float())
+
+        loss = (losses / (valid_samples + self.eps)) * self.loss_weight
+        if torch.isnan(loss).item() | torch.isinf(loss).item():
+            loss = 0 * torch.sum(prediction)
+            print(f'Pair-wise Normal Regression Loss NAN error, {loss}, valid pix: {valid_samples}')
+        return loss
+
+def tmp_check_normal(normals, masks, depth):
+    import matplotlib.pyplot as plt
+    import os
+    import cv2
+    from mono.utils.visualization import vis_surface_normal
+    vis_normal1 = vis_surface_normal(normals[0, ...].permute(1, 2, 0).detach(), masks[0,...].detach().squeeze())
+    vis_normal2 = vis_surface_normal(normals[1, ...].permute(1, 2, 0).detach(), masks[1,...].detach().squeeze())
+    vis_depth1 = depth[0, ...].detach().cpu().squeeze().numpy()
+    vis_depth2 = depth[1, ...].detach().cpu().squeeze().numpy()
+
+    name = np.random.randint(100000)
+    os.makedirs('test_normal', exist_ok=True)
+    cv2.imwrite(f'test_normal/{name}.png', vis_normal1)
+    cv2.imwrite(f'test_normal/{name + 1}.png', vis_normal2)
+    plt.imsave(f'test_normal/{name}_d.png', vis_depth1)
+    plt.imsave(f'test_normal/{name + 1}_d.png', vis_depth2)
+
+if __name__ == '__main__':
+    ENL = EdgeguidedNormalLoss()
+    depth = np.random.randn(2, 1, 20, 22)
+    intrin = np.array([[300, 0, 10], [0, 300, 10], [0,0,1]])
+    prediction = np.random.randn(2, 1, 20, 22)
+    imgs = np.random.randn(2, 3, 20, 22)
+    intrinsics = np.stack([intrin, intrin], axis=0)
+
+    depth_t = torch.from_numpy(depth).cuda().float()
+    prediction = torch.from_numpy(prediction).cuda().float()
+    intrinsics = torch.from_numpy(intrinsics).cuda().float()
+    imgs = torch.from_numpy(imgs).cuda().float()
+    depth_t = -1 * torch.abs(depth_t)
+
+    loss = ENL(prediction, depth_t, masks=depth_t>0, images=imgs, intrinsic=intrinsics)
+    print(loss)

external/Metric3D/training/mono/model/losses/PWN_Planes.py

@@ -0,0 +1,291 @@
+import torch
+import torch.nn as nn
+import numpy as np
+
+
+class PWNPlanesLoss(nn.Module):
+    """
+    Virtual Normal Loss Function.
+    """
+    def __init__(self, delta_cos=0.867, delta_diff_x=0.007,
+                 delta_diff_y=0.007, sample_groups=5000, loss_weight=1.0, data_type=['lidar', 'denselidar'], **kwargs):
+        """
+        Virtual normal planes loss, which constrain points to be on the same 3D plane.
+        :para focal_x: folcal length fx
+        :para focal_y: folcal length fy
+        :para input_size: input image size
+        :para delta_cos: a threshold for the angle among three point, three points should not be on the same plane
+        :para  delta_diff_x: a threshold for the distance among three points along the x axis
+        :para delta_diff_y: a threshold for the distance among three points along the y axis
+        :para sample_groups: sample groups number, each group with 3 points can construct a plane
+        """
+        super(PWNPlanesLoss, self).__init__()
+        self.delta_cos = delta_cos
+        self.delta_diff_x = delta_diff_x
+        self.delta_diff_y = delta_diff_y
+        self.sample_groups = sample_groups
+        self.loss_weight = loss_weight
+        self.data_type = data_type
+    
+    def init_image_coor(self, B, H, W):
+        u = torch.arange(0, H, dtype=torch.float32, device="cuda").contiguous().view(1, H, 1).expand(1, H, W) # [1, H, W]
+        v = torch.arange(0, W, dtype=torch.float32, device="cuda").contiguous().view(1, 1, W).expand(1, H, W)  # [1, H, W]
+        ones = torch.ones((1, H, W), dtype=torch.float32, device="cuda")
+        pixel_coords = torch.stack((u, v, ones), dim=1).expand(B, 3, H, W)  # [B, 3, H, W]
+        # self.register_buffer('uv', pixel_coords, persistent=False)
+        self.uv = pixel_coords
+
+    def upproj_pcd(self, depth, intrinsics_inv):
+        """Transform coordinates in the pixel frame to the camera frame.
+        Args:
+            depth: depth maps -- [B, 1, H, W]
+            intrinsics_inv: intrinsics_inv matrix for each element of batch -- [B, 3, 3]
+        Returns:
+            array of (u,v,1) cam coordinates -- [B, 3, H, W]
+        """
+        b, _, h, w = depth.size()
+        assert self.uv.shape[0] == b
+        current_pixel_coords = self.uv.reshape(b, 3, -1)  # [B, 3, H*W]
+        cam_coords = (intrinsics_inv @ current_pixel_coords)
+        cam_coords = cam_coords.reshape(b, 3, h, w)
+        out = depth * cam_coords
+        return  out
+
+    # def transfer_xyz(self, depth):
+    #     x = self.u_u0 * torch.abs(depth) / self.focal_length
+    #     y = self.v_v0 * torch.abs(depth) / self.focal_length
+    #     z = depth
+    #     pw = torch.cat([x, y, z], 1).permute(0, 2, 3, 1).contiguous() # [b, h, w, c]
+    #     return pw
+    
+    # def transfer_uvz(self, depth):
+    #     max_uv = self.u_u0.max()
+    #     u = self.u_u0.repeat((depth.shape[0], 1, 1, 1)) / max_uv
+    #     v = self.v_v0.repeat((depth.shape[0], 1, 1, 1)) / max_uv
+    #     z = depth
+    #     pw = torch.cat([u, v, z], 1).permute(0, 2, 3, 1).contiguous() # [b, h, w, c]
+    #     return pw
+
+    def select_index(self, mask_kp):
+        x, _, h, w = mask_kp.shape
+
+        select_size = int(3 * self.sample_groups)
+        p1_x = []
+        p1_y = []
+        p2_x = []
+        p2_y = []
+        p3_x = []
+        p3_y = []
+        valid_batch = torch.ones((x, 1), dtype=torch.bool, device="cuda")
+        for i in range(x):
+            mask_kp_i = mask_kp[i, 0, :, :]
+            valid_points = torch.nonzero(mask_kp_i)
+
+            if valid_points.shape[0] < select_size * 0.6:
+                valid_points = torch.nonzero(~mask_kp_i.to(torch.uint8))
+                valid_batch[i, :] = False
+            elif valid_points.shape[0] < select_size:
+                repeat_idx = torch.randperm(valid_points.shape[0], device="cuda")[:select_size - valid_points.shape[0]]
+                valid_repeat = valid_points[repeat_idx]
+                valid_points = torch.cat((valid_points, valid_repeat), 0)
+            else:
+                valid_points = valid_points
+            """
+            
+            if valid_points.shape[0] <= select_size:
+                valid_points = torch.nonzero(~mask_kp_i.to(torch.uint8))
+                valid_batch[i, :] = False
+            """
+            select_indx = torch.randperm(valid_points.size(0), device="cuda")
+
+            p1 = valid_points[select_indx[0:select_size:3]]
+            p2 = valid_points[select_indx[1:select_size:3]]
+            p3 = valid_points[select_indx[2:select_size:3]]
+
+            p1_x.append(p1[:, 1])
+            p1_y.append(p1[:, 0])
+
+            p2_x.append(p2[:, 1])
+            p2_y.append(p2[:, 0])
+
+            p3_x.append(p3[:, 1])
+            p3_y.append(p3[:, 0])
+        p123 = {'p1_x': torch.stack(p1_x), 'p1_y': torch.stack(p1_y),
+                'p2_x': torch.stack(p2_x), 'p2_y': torch.stack(p2_y),
+                'p3_x': torch.stack(p3_x), 'p3_y': torch.stack(p3_y),
+                'valid_batch': valid_batch}
+        return p123
+
+    def form_pw_groups(self, p123, pw):
+        """
+        Form 3D points groups, with 3 points in each grouup.
+        :param p123: points index
+        :param pw: 3D points, # [1, h, w, c]
+        :return:
+        """
+        p1_x = p123['p1_x']
+        p1_y = p123['p1_y']
+        p2_x = p123['p2_x']
+        p2_y = p123['p2_y']
+        p3_x = p123['p3_x']
+        p3_y = p123['p3_y']
+        batch_list = torch.arange(0, p1_x.shape[0], device="cuda")[:, None]
+        pw = pw.repeat((p1_x.shape[0], 1, 1, 1))
+        pw1 = pw[batch_list, p1_y, p1_x, :]
+        pw2 = pw[batch_list, p2_y, p2_x, :]
+        pw3 = pw[batch_list, p3_y, p3_x, :]
+        
+        # [B, N, 3(x,y,z), 3(p1,p2,p3)]
+        pw_groups = torch.cat([pw1[:, :, :, None], pw2[:, :, :, None], pw3[:, :, :, None]], 3)
+        return pw_groups
+
+    def filter_mask(self, pw_pred):
+        """
+        :param pw_pred: constructed 3d vector (x, y, disp), [B, N, 3(x,y,z), 3(p1,p2,p3)]
+        """
+        xy12 = pw_pred[:, :, 0:2, 1] - pw_pred[:, :, 0:2, 0]
+        xy13 = pw_pred[:, :, 0:2, 2] - pw_pred[:, :, 0:2, 0]
+        xy23 = pw_pred[:, :, 0:2, 2] - pw_pred[:, :, 0:2, 1]
+        # Ignore linear
+        xy_diff = torch.cat([xy12[:, :, :, np.newaxis], xy13[:, :, :, np.newaxis], xy23[:, :, :, np.newaxis]],
+                            3)  # [b, n, 2(xy), 3]
+        m_batchsize, groups, coords, index = xy_diff.shape
+        proj_query = xy_diff.contiguous().view(m_batchsize * groups, -1, index).permute(0, 2, 1).contiguous()  # [bn, 3(p123), 2(xy)]
+        proj_key = xy_diff.contiguous().view(m_batchsize * groups, -1, index)  # [bn, 2(xy), 3(p123)]
+        q_norm = proj_query.norm(2, dim=2)  # [bn, 3(p123)]
+        nm = torch.bmm(q_norm.contiguous().view(m_batchsize * groups, index, 1), q_norm.contiguous().view(m_batchsize * groups, 1, index))  # []
+        energy = torch.bmm(proj_query, proj_key)  # transpose check [bn, 3(p123), 3(p123)]
+        norm_energy = energy / (nm + 1e-8)
+        norm_energy = norm_energy.contiguous().view(m_batchsize * groups, -1) # [bn, 9(p123)]
+        mask_cos = torch.sum((norm_energy > self.delta_cos) + (norm_energy < -self.delta_cos), 1) > 3  # igonre
+        mask_cos = mask_cos.contiguous().view(m_batchsize, groups)  # [b, n]  # igonre
+
+        #ignore near
+        mask_x = torch.sum(torch.abs(xy_diff[:, :, 0, :]) < self.delta_diff_x, 2) > 0
+        mask_y = torch.sum(torch.abs(xy_diff[:, :, 1, :]) < self.delta_diff_y, 2) > 0
+        mask_near = mask_x & mask_y
+        mask_valid_pts = ~(mask_cos | mask_near)
+        return mask_valid_pts
+    
+    def select_points_groups(self, pcd_bi, mask_kp):
+        p123 = self.select_index(mask_kp) # p1_x: [x, n]
+        pcd_bi = pcd_bi.permute((0, 2, 3, 1)).contiguous() #[1, h, w, 3(xyz)]
+        groups_pred = self.form_pw_groups(p123, pcd_bi) # [x, N, 3(x,y,z), 3(p1,p2,p3)]
+        
+        # mask:[x, n]
+        mask_valid_pts = (self.filter_mask(groups_pred)).to(torch.bool)  # [x, n]
+        mask_valid_batch = p123['valid_batch'].repeat(1, mask_valid_pts.shape[1])  # [x, n]
+        mask_valid = mask_valid_pts & mask_valid_batch # [x, n]
+        return groups_pred, mask_valid
+
+    def constrain_a_plane_loss(self, pw_groups_pre_i, mask_valid_i):
+        """
+        pw_groups_pre: selected points groups for the i-th plane, [N, 3(x,y,z), 3(p1,p2,p3)]
+        """
+        if torch.sum(mask_valid_i) < 2:
+            return 0.0 * torch.sum(pw_groups_pre_i), 0
+        pw_groups_pred_i = pw_groups_pre_i[mask_valid_i]  # [n, 3, 3]
+        p12 = pw_groups_pred_i[:, :, 1] - pw_groups_pred_i[:, :, 0]
+        p13 = pw_groups_pred_i[:, :, 2] - pw_groups_pred_i[:, :, 0]
+        virtual_normal = torch.cross(p12, p13, dim=1)  # [n, 3]
+        norm = torch.norm(virtual_normal, 2, dim=1, keepdim=True)
+        virtual_normal = virtual_normal / (norm + 1e-8)
+
+        # re-orient normals consistently
+        orient_mask = torch.sum(torch.squeeze(virtual_normal) * torch.squeeze(pw_groups_pred_i[:, :, 0]), dim=1) > 0
+        virtual_normal[orient_mask] *= -1
+        #direct = virtual_normal[:, 2] / torch.abs(virtual_normal[:, 2])
+        #virtual_normal = virtual_normal / direct[:, None]  # [n, 3]
+
+        aver_normal = torch.sum(virtual_normal, dim=0)
+        aver_norm = torch.norm(aver_normal, 2, dim=0, keepdim=True)
+        aver_normal = aver_normal / (aver_norm + 1e-5)  # [3]
+
+        cos_diff = 1.0 - torch.sum(virtual_normal * aver_normal, dim=1)
+        loss_sum = torch.sum(cos_diff, dim=0)
+        valid_num = cos_diff.numel()
+        return loss_sum, valid_num
+
+    def get_loss(self, pred_depth, gt_depth, ins_planes_mask, intrinsic=None):
+        """
+        Co-plane loss. Enforce points residing on the same instance plane to be co-plane.
+        :param pred_depth: predicted depth map, [B,C,H,W]
+        :param mask: mask for planes, each plane is noted with a value, [B, C, H, W]
+        :param focal_length: focal length
+        """
+        if pred_depth.ndim==3:
+            pred_depth = pred_depth[None, ...]
+        if gt_depth.ndim == 3:
+            gt_depth = gt_depth[None, ...]
+        if ins_planes_mask.ndim == 3:
+            ins_planes_mask = ins_planes_mask[None, ...]
+        
+        B, _, H, W = pred_depth.shape
+        loss_sum = torch.tensor(0.0, device="cuda")
+        valid_planes_num = 0
+
+        #if 'uv' not in self._buffers or ('uv' in self._buffers and self.uv.shape[0] != B):
+        self.init_image_coor(B, H, W)
+        pcd = self.upproj_pcd(pred_depth, intrinsic.inverse())
+
+        for i in range(B):
+            mask_i = ins_planes_mask[i, :][None, :, :]
+            unique_planes = torch.unique(mask_i)
+            planes = [mask_i == m for m in unique_planes if m != 0] #[x, 1, h, w] x is the planes number
+            if len(planes) == 0:
+                continue
+            mask_planes = torch.cat(planes, dim=0) #torch.stack(planes, dim=0) #
+            pcd_grops_pred, mask_valid = self.select_points_groups(pcd[i, ...][None, :, :, :], mask_planes) # [x, N, 3(x,y,z), 3(p1,p2,p3)]
+
+            for j in range(unique_planes.numel()-1):
+                mask_valid_j = mask_valid[j, :]
+                pcd_grops_pred_j = pcd_grops_pred[j, :]
+                loss_tmp, valid_angles = self.constrain_a_plane_loss(pcd_grops_pred_j, mask_valid_j)
+                valid_planes_num += valid_angles
+                loss_sum += loss_tmp
+
+        loss = loss_sum / (valid_planes_num + 1e-6) * self.loss_weight
+        if torch.isnan(loss).item() | torch.isinf(loss).item():
+            loss = torch.sum(pred_depth) * 0
+            print(f'PWNPlane NAN error, {loss}')    
+        return loss
+    
+    def forward(self, prediction, target, mask, intrinsic, **kwargs): #gt_depth, pred_depth, select=True):
+        """
+        Virtual normal loss.
+        :param prediction: predicted depth map, [B,W,H,C]
+        :param data: target label, ground truth depth, [B, W, H, C], padding region [padding_up, padding_down]
+        :return:
+        """
+        dataset = kwargs['dataset']
+        batch_mask = np.array(dataset) == 'Taskonomy'
+        if np.sum(batch_mask) == 0:
+            return torch.sum(prediction) * 0.0
+        ins_planes_mask = kwargs['sem_mask'] # 
+        assert ins_planes_mask.ndim == 4
+        loss  = self.get_loss(
+            prediction[batch_mask], 
+            target[batch_mask], 
+            ins_planes_mask[batch_mask], 
+            intrinsic[batch_mask], 
+            )
+        return loss
+
+
+if __name__ == '__main__':
+    import cv2
+    vnl_loss = PWNPlanesLoss()
+    pred_depth = torch.rand([2, 1, 385, 513]).cuda()
+    gt_depth = torch.rand([2, 1, 385, 513]).cuda()
+    gt_depth[:, :, 3:20, 40:60] = 0
+    mask_kp1 = pred_depth > 0.9
+    mask_kp2 = pred_depth < 0.5
+    mask = torch.zeros_like(gt_depth, dtype=torch.uint8)
+    mask = 1*mask_kp1 + 2* mask_kp2
+    mask[1,...] = 0
+
+
+    intrinsic = torch.tensor([[100, 0, 50], [0, 100, 50,], [0,0,1]]).cuda().float()
+    intrins = torch.stack([intrinsic, intrinsic], dim=0)
+    loss = vnl_loss(gt_depth, gt_depth, mask, intrins, dataset=np.array(['Taskonomy', 'Taskonomy']))
+    print(loss)

external/Metric3D/training/mono/model/losses/Ranking.py

@@ -0,0 +1,342 @@
+import torch
+from torch import nn
+import numpy as np
+import torch.nn.functional as F
+import matplotlib.pyplot as plt
+import os
+
+"""
+Sampling strategies: RS (Random Sampling), EGS (Edge-Guided Sampling), and IGS (Instance-Guided Sampling)
+"""
+###########
+# RANDOM SAMPLING
+# input:
+# predictions[i,:], targets[i, :], masks[i, :], self.mask_value, self.point_pairs
+# return:
+# inputs_A, inputs_B, targets_A, targets_B, consistent_masks_A, consistent_masks_B
+###########
+def randomSampling(predictions, targets, masks, threshold, sample_num):
+
+    # find A-B point pairs from predictions
+    inputs_index = torch.masked_select(predictions, targets.gt(threshold))
+    num_effect_pixels = len(inputs_index)
+    shuffle_effect_pixels = torch.randperm(num_effect_pixels, device="cuda")
+    inputs_A = inputs_index[shuffle_effect_pixels[0:sample_num*2:2]]
+    inputs_B = inputs_index[shuffle_effect_pixels[1:sample_num*2:2]]
+    # find corresponding pairs from GT
+    target_index = torch.masked_select(targets, targets.gt(threshold))
+    targets_A = target_index[shuffle_effect_pixels[0:sample_num*2:2]]
+    targets_B = target_index[shuffle_effect_pixels[1:sample_num*2:2]]
+    # only compute the losses of point pairs with valid GT
+    consistent_masks_index = torch.masked_select(masks, targets.gt(threshold))
+    consistent_masks_A = consistent_masks_index[shuffle_effect_pixels[0:sample_num*2:2]]
+    consistent_masks_B = consistent_masks_index[shuffle_effect_pixels[1:sample_num*2:2]]
+
+    # The amount of A and B should be the same!!
+    if len(targets_A) > len(targets_B):
+        targets_A = targets_A[:-1]
+        inputs_A = inputs_A[:-1]
+        consistent_masks_A = consistent_masks_A[:-1]
+
+    return inputs_A, inputs_B, targets_A, targets_B, consistent_masks_A, consistent_masks_B
+
+###########
+# EDGE-GUIDED SAMPLING
+# input:
+# predictions[i,:], targets[i, :], masks[i, :], edges_img[i], thetas_img[i], masks[i, :], h, w
+# return:
+# inputs_A, inputs_B, targets_A, targets_B, masks_A, masks_B
+###########
+def ind2sub(idx, cols):
+    r = torch.div(idx, cols, rounding_mode='floor') #idx // cols
+    c = idx % cols
+    return r, c
+
+def sub2ind(r, c, cols):
+    idx = (r * cols + c).int()
+    return idx
+
+def edgeGuidedSampling(predictions, targets, edges_img, thetas_img, masks, h, w):
+
+    # find edges
+    edges_max = edges_img.max()
+    edges_mask = edges_img.ge(edges_max*0.1)
+    edges_loc = edges_mask.nonzero()
+
+    inputs_edge = torch.masked_select(predictions, edges_mask)
+    targets_edge = torch.masked_select(targets, edges_mask)
+    thetas_edge = torch.masked_select(thetas_img, edges_mask)
+    minlen = inputs_edge.size()[0]
+
+    # find anchor points (i.e, edge points)
+    sample_num = minlen
+    index_anchors = torch.randint(0, minlen, (sample_num,), dtype=torch.long, device="cuda")
+    anchors = torch.gather(inputs_edge, 0, index_anchors)
+    theta_anchors = torch.gather(thetas_edge, 0, index_anchors)
+    row_anchors, col_anchors = ind2sub(edges_loc[index_anchors].squeeze(1), w)
+    ## compute the coordinates of 4-points,  distances are from [2, 30]
+    distance_matrix = torch.randint(2, 40, (4,sample_num), device="cuda")
+    pos_or_neg = torch.ones(4, sample_num, device="cuda")
+    pos_or_neg[:2,:] = -pos_or_neg[:2,:]
+    distance_matrix = distance_matrix.float() * pos_or_neg
+    col = col_anchors.unsqueeze(0).expand(4, sample_num).long() + torch.round(distance_matrix.float() * torch.abs(torch.cos(theta_anchors)).unsqueeze(0)).long()
+    row = row_anchors.unsqueeze(0).expand(4, sample_num).long() + torch.round(distance_matrix.float() * torch.abs(torch.sin(theta_anchors)).unsqueeze(0)).long()
+
+    # constrain 0=<c<=w, 0<=r<=h
+    # Note: index should minus 1
+    col[col<0] = 0
+    col[col>w-1] = w-1
+    row[row<0] = 0
+    row[row>h-1] = h-1
+
+    # a-b, b-c, c-d
+    a = sub2ind(row[0,:], col[0,:], w)
+    b = sub2ind(row[1,:], col[1,:], w)
+    c = sub2ind(row[2,:], col[2,:], w)
+    d = sub2ind(row[3,:], col[3,:], w)
+    A = torch.cat((a,b,c), 0)
+    B = torch.cat((b,c,d), 0)
+
+    inputs_A = torch.gather(predictions, 0, A.long())
+    inputs_B = torch.gather(predictions, 0, B.long())
+    targets_A = torch.gather(targets, 0, A.long())
+    targets_B = torch.gather(targets, 0, B.long())
+    masks_A = torch.gather(masks, 0, A.long())
+    masks_B = torch.gather(masks, 0, B.long())
+
+    # create A, B, C, D mask for visualization
+    # vis_mask = masks.reshape(h, w).cpu().numpy()
+    # vis_row = row.cpu()
+    # vis_col = col.cpu()
+    # visual_A = np.zeros((h, w)).astype(np.bool)
+    # visual_B = np.zeros_like(visual_A)
+    # visual_C = np.zeros_like(visual_A)
+    # visual_D = np.zeros_like(visual_A)
+    # visual_A[vis_row[0, :], vis_col[0, :]] = True
+    # visual_B[vis_row[1, :], vis_col[1, :]] = True
+    # visual_C[vis_row[2, :], vis_col[2, :]] = True
+    # visual_D[vis_row[3, :], vis_col[3, :]] = True
+    # visual_ABCD = [visual_A & vis_mask, visual_B & vis_mask, 
+    # visual_C& vis_mask, visual_D& vis_mask]
+    return inputs_A, inputs_B, targets_A, targets_B, masks_A, masks_B, sample_num
+
+
+######################################################
+# Ranking loss (Random sampling)
+#####################################################
+class RankingLoss(nn.Module):
+    def __init__(self, point_pairs=5000, sigma=0.03, alpha=1.0, mask_value=-1e-8, loss_weight=1, **kwargs):
+        super(RankingLoss, self).__init__()
+        self.point_pairs = point_pairs # number of point pairs
+        self.sigma = sigma # used for determining the ordinal relationship between a selected pair
+        self.alpha = alpha  # used for balancing the effect of = and (<,>)
+        self.mask_value = mask_value
+        self.loss_weight = loss_weight
+        self.eps = 1e-6
+
+    def forward(self, prediction, target, mask=None, **kwargs):
+        n,c,h,w = target.size()
+        if mask == None:
+            mask = target > self.mask_value
+        if n != 1:
+            prediction = prediction.view(n, -1)#.double()
+            target = target.view(n, -1)#.double()
+            mask = mask.view(n, -1)#.double()
+        else:
+            prediction = prediction.contiguous().view(1, -1)#.double()
+            target = target.contiguous().view(1, -1)#.double()
+            mask = mask.contiguous().view(1, -1)#.double()
+
+        loss = 0.0 #torch.tensor([0.0]).cuda()
+        valid_samples = 0
+        for i in range(n):
+            # find A-B point pairs
+            inputs_A, inputs_B, targets_A, targets_B, consistent_masks_A, consistent_masks_B = randomSampling(prediction[i,:], target[i, :], mask[i, :], self.mask_value, self.point_pairs)
+
+            #GT ordinal relationship
+            target_ratio = torch.div(targets_A, targets_B+self.eps)
+            mask_eq = target_ratio.lt(1.0 + self.sigma) * target_ratio.gt(1.0/(1.0+self.sigma))
+            labels = torch.zeros_like(target_ratio)
+            labels[target_ratio.ge(1.0 + self.sigma)] = 1
+            labels[target_ratio.le(1.0/(1.0+self.sigma))] = -1
+
+            # consider forward-backward consistency checking, only compute the losses of point pairs with valid GT
+            consistency_mask = consistent_masks_A & consistent_masks_B
+
+            # compute loss
+            equal_loss = (inputs_A - inputs_B).pow(2)[mask_eq & consistency_mask]
+            unequal_loss = torch.log(1 + torch.exp((-inputs_A + inputs_B) * labels))[(~mask_eq) & consistency_mask]
+
+            loss = loss + self.alpha * equal_loss.sum() + unequal_loss.sum()
+            valid_samples = valid_samples + unequal_loss.numel() + equal_loss.numel()
+        loss = loss / (valid_samples + self.eps)
+        if torch.isnan(loss).item() | torch.isinf(loss).item():
+            raise RuntimeError(f'VNL error, {loss}')
+        return loss * self.loss_weight
+
+
+
+
+
+######################################################
+# EdgeguidedRankingLoss (with regularization term)
+# Please comment regularization_loss if you don't want to use multi-scale gradient matching term
+#####################################################
+class EdgeguidedRankingLoss(nn.Module):
+    def __init__(self, point_pairs=5000, sigma=0.03, alpha=1.0, mask_value=1e-6, loss_weight=1.0, data_type=['rel', 'sfm', 'stereo', 'lidar'], **kwargs):
+        super(EdgeguidedRankingLoss, self).__init__()
+        self.point_pairs = point_pairs # number of point pairs
+        self.sigma = sigma # used for determining the ordinal relationship between a selected pair
+        self.alpha = alpha # used for balancing the effect of = and (<,>)
+        self.mask_value = mask_value
+        self.loss_weight = loss_weight
+        self.data_type = data_type
+        self.eps = 1e-6
+
+    def getEdge(self, images):
+        n,c,h,w = images.size()
+        a = torch.tensor([[-1, 0, 1], [-2, 0, 2], [-1, 0, 1]], dtype=torch.float32, device="cuda").view((1,1,3,3)).repeat(1, 1, 1, 1)
+        b = torch.tensor([[1, 2, 1], [0, 0, 0], [-1, -2, -1]], dtype=torch.float32, device="cuda").view((1,1,3,3)).repeat(1, 1, 1, 1)
+        if c == 3:
+            gradient_x = F.conv2d(images[:,0,:,:].unsqueeze(1), a)
+            gradient_y = F.conv2d(images[:,0,:,:].unsqueeze(1), b)
+        else:
+            gradient_x = F.conv2d(images, a)
+            gradient_y = F.conv2d(images, b)
+        edges = torch.sqrt(torch.pow(gradient_x,2)+ torch.pow(gradient_y,2))
+        edges = F.pad(edges, (1,1,1,1), "constant", 0)
+        thetas = torch.atan2(gradient_y, gradient_x)
+        thetas = F.pad(thetas, (1,1,1,1), "constant", 0)
+
+        return edges, thetas
+    
+    def visual_check(self, rgb, samples):
+        rgb = rgb.cpu().squeeze().numpy()
+
+        mean = np.array([123.675, 116.28, 103.53])[:, np.newaxis, np.newaxis]
+        std= np.array([58.395, 57.12, 57.375])[:, np.newaxis, np.newaxis]
+        
+        rgb = ((rgb * std) + mean).astype(np.uint8).transpose((1, 2, 0))
+        mask_A, mask_B, mask_C, mask_D = samples
+        rgb[mask_A.astype(np.bool)] = [255, 0, 0]
+        rgb[mask_B.astype(np.bool)] = [0, 255, 0]
+        rgb[mask_C.astype(np.bool)] = [0, 0, 255]
+        rgb[mask_D.astype(np.bool)] = [255, 255, 0]
+        
+        filename = str(np.random.randint(10000))
+        save_path = os.path.join('test_ranking', filename + '.png')
+        os.makedirs(os.path.dirname(save_path), exist_ok=True)
+        plt.imsave(save_path, rgb)
+
+    def forward(self, prediction, target, mask=None, input=None, **kwargs):
+        loss  = self.get_loss(prediction, target, mask, input, **kwargs)
+        return loss
+    
+    def get_loss(self, prediction, target, mask=None, input=None, **kwargs):
+        if mask == None:
+            mask = target > self.mask_value
+        # find edges from RGB
+        edges_img, thetas_img = self.getEdge(input)
+        # find edges from target depths
+        edges_depth, thetas_depth = self.getEdge(target)
+
+        #=============================
+        n,c,h,w = target.size()
+        if n != 1:
+            prediction = prediction.view(n, -1)#.double()
+            target = target.view(n, -1)#.double()
+            mask = mask.view(n, -1)#.double()
+            edges_img = edges_img.view(n, -1)#.double()
+            thetas_img = thetas_img.view(n, -1)#.double()
+            edges_depth = edges_depth.view(n, -1)#.double()
+            thetas_depth = thetas_depth.view(n, -1)#.double()
+        else:
+            prediction = prediction.contiguous().view(1, -1)#.double()
+            target = target.contiguous().view(1, -1)#.double()
+            mask = mask.contiguous().view(1, -1)#.double()
+            edges_img = edges_img.contiguous().view(1, -1)#.double()
+            thetas_img = thetas_img.contiguous().view(1, -1)#.double()
+            edges_depth = edges_depth.view(1, -1)#.double()
+            thetas_depth = thetas_depth.view(1, -1)#.double()
+
+        # initialization
+        loss = 0.0 #torch.tensor([0.0]).cuda()
+        valid_samples = 0
+
+        for i in range(n):
+            # Edge-Guided sampling from RGB predictions, targets, edges_img, thetas_img, masks, h, w
+            inputs_A, inputs_B, targets_A, targets_B, masks_A, masks_B, sample_num = edgeGuidedSampling(
+                prediction[i,:], 
+                target[i, :], 
+                edges_img[i], 
+                thetas_img[i], 
+                mask[i, :], 
+                h, 
+                w
+                )
+            # # Edge-Guided sampling from depth
+            # inputs_A_depth, inputs_B_depth, targets_A_depth, targets_B_depth, masks_A_depth, masks_B_depth, sample_num_depth = edgeGuidedSampling(
+            #     prediction[i,:], 
+            #     target[i, :], 
+            #     edges_depth[i], 
+            #     thetas_depth[i], 
+            #     mask[i, :], 
+            #     h, 
+            #     w
+            #     )
+
+            # Random Sampling predictions, targets, masks, threshold, sample_num
+            random_sample_num = sample_num
+            random_inputs_A, random_inputs_B, random_targets_A, random_targets_B, random_masks_A, random_masks_B = randomSampling(
+                prediction[i,:], 
+                target[i, :], 
+                mask[i, :], 
+                self.mask_value, 
+                random_sample_num
+                )
+
+            # Combine EGS + RS + EGS_depth
+            inputs_A_merge = torch.cat((inputs_A, random_inputs_A,), 0)
+            inputs_B_merge = torch.cat((inputs_B, random_inputs_B,), 0)
+            targets_A_merge = torch.cat((targets_A, random_targets_A,), 0)
+            targets_B_merge = torch.cat((targets_B, random_targets_B,), 0)
+            masks_A_merge = torch.cat((masks_A, random_masks_A,), 0)
+            masks_B_merge = torch.cat((masks_B, random_masks_B,), 0)
+
+            #GT ordinal relationship
+            target_ratio = torch.div(targets_A_merge + 1e-6, targets_B_merge + 1e-6)
+            mask_eq = target_ratio.lt(1.0 + self.sigma) & target_ratio.gt(1.0/(1.0+self.sigma))
+            labels = torch.zeros_like(target_ratio)
+            labels[target_ratio.ge(1.0 + self.sigma)] = 1
+            labels[target_ratio.le(1.0/(1.0+self.sigma))] = -1
+
+            # consider forward-backward consistency checking, i.e, only compute losses of point pairs with valid GT
+            consistency_mask = masks_A_merge & masks_B_merge
+
+            equal_loss = (inputs_A_merge - inputs_B_merge).pow(2)[mask_eq & consistency_mask]
+            unequal_loss = torch.log(1 + torch.exp((-inputs_A_merge + inputs_B_merge) * labels))[(~mask_eq) & consistency_mask]
+
+            loss = loss + self.alpha * torch.sum(equal_loss) + torch.sum(unequal_loss)
+            valid_samples = valid_samples + equal_loss.numel()
+            valid_samples = valid_samples + unequal_loss.numel()
+        loss = loss / (valid_samples + self.eps)
+        if torch.isnan(loss).item() | torch.isinf(loss).item():
+            raise RuntimeError(f'VNL error, {loss}')
+        return loss * self.loss_weight
+
+
+if __name__ == '__main__':
+    import cv2
+
+    rank_loss = EdgeguidedRankingLoss()
+    pred_depth = np.random.randn(2, 1, 480, 640)
+    gt_depth = np.ones((2, 1, 480, 640)) #np.random.randn(2, 1, 480, 640)
+    # gt_depth = cv2.imread('/hardware/yifanliu/SUNRGBD/sunrgbd-meta-data/sunrgbd_test_depth/2.png', -1)
+    # gt_depth = gt_depth[None, :, :, None]
+    # pred_depth = gt_depth[:, :, ::-1, :]
+    gt_depth = torch.tensor(np.asarray(gt_depth, np.float32)).cuda()
+    pred_depth = torch.tensor(np.asarray(pred_depth, np.float32)).cuda()
+    input = np.random.randn(2, 3, 480, 640)
+    input_torch = torch.tensor(np.asarray(input, np.float32)).cuda()
+    loss = rank_loss(gt_depth, gt_depth, gt_depth>0, input=input_torch)
+    print(loss)

external/Metric3D/training/mono/model/losses/Regularization.py

@@ -0,0 +1,18 @@
+import torch
+import torch.nn as nn
+
+class RegularizationLoss(nn.Module):
+    """
+    Enforce losses on pixels without any gts.
+    """
+    def __init__(self, loss_weight=0.1, data_type=['sfm', 'stereo', 'lidar'], **kwargs):
+        super(RegularizationLoss, self).__init__()
+        self.loss_weight = loss_weight
+        self.data_type = data_type
+        self.eps = 1e-6
+
+    def forward(self, prediction, target, mask=None, **kwargs):
+        pred_wo_gt = prediction[~mask]
+        #loss = - torch.sum(pred_wo_gt) / (pred_wo_gt.numel() + 1e-8)
+        loss = 1/ (torch.sum(pred_wo_gt) / (pred_wo_gt.numel() + self.eps))
+        return loss * self.loss_weight

external/Metric3D/training/mono/model/losses/SSIL.py

@@ -0,0 +1,56 @@
+import torch
+import torch.nn as nn
+
+class SSILoss(nn.Module):
+    """
+    Scale shift invariant MAE loss.
+    loss = MAE((d-median(d)/s - (d'-median(d'))/s'), s = mean(d- median(d))
+    """
+    def __init__(self, loss_weight=1, data_type=['sfm', 'stereo', 'lidar'], **kwargs):
+        super(SSILoss, self).__init__()
+        self.loss_weight = loss_weight
+        self.data_type = data_type
+        self.eps = 1e-6
+    
+    def ssi_mae(self, target, prediction, mask):
+        valid_pixes = torch.sum(mask) + self.eps
+
+        gt_median = torch.median(target) if target.numel() else 0
+        gt_s = torch.abs(target - gt_median).sum() / valid_pixes
+        gt_trans = (target - gt_median) / (gt_s + self.eps)
+
+        pred_median = torch.median(prediction) if prediction.numel() else 0
+        pred_s = torch.abs(prediction - pred_median).sum() / valid_pixes
+        pred_trans = (prediction - pred_median) / (pred_s + self.eps)
+        
+        ssi_mae_sum = torch.sum(torch.abs(gt_trans - pred_trans))
+        return ssi_mae_sum, valid_pixes
+
+    def forward(self, prediction, target, mask=None, **kwargs):
+        """
+        Calculate loss.
+        """
+        B, C, H, W = prediction.shape
+        loss = 0
+        valid_pix = 0
+        for i in range(B):
+            mask_i = mask[i, ...]
+            gt_depth_i = target[i, ...][mask_i]
+            pred_depth_i = prediction[i, ...][mask_i]
+            ssi_sum, valid_pix_i = self.ssi_mae(pred_depth_i, gt_depth_i, mask_i) 
+            loss += ssi_sum
+            valid_pix += valid_pix_i
+        loss /= (valid_pix + self.eps)
+        return loss * self.loss_weight
+    
+if __name__ == '__main__':
+    torch.manual_seed(1)
+    torch.cuda.manual_seed_all(1)
+
+    ssil = SSILoss()
+    pred = torch.rand((2, 1, 256, 256)).cuda()
+    gt = torch.rand((2, 1, 256, 256)).cuda()#torch.zeros_like(pred).cuda() #
+    gt[:, :, 100:256, 0:100] = -1
+    mask = gt > 0
+    out = ssil(pred, gt, mask)
+    print(out)

external/Metric3D/training/mono/model/losses/ScaleAlignLoss.py

@@ -0,0 +1,57 @@
+import torch
+import torch.nn as nn
+
+class ScaleAlignLoss(nn.Module):
+    """
+    Loss function defined over sequence of depth predictions
+    """
+    def __init__(self, data_type=['lidar', 'denselidar', 'stereo', 'denselidar_syn'], loss_weight=1.0, disable_dataset=['MapillaryPSD'], **kwargs):
+        super(ScaleAlignLoss, self).__init__()
+        self.loss_weight = loss_weight
+        self.data_type = data_type
+        self.disable_dataset = disable_dataset
+
+    def forward(self, prediction, target, mask, scale, **kwargs):
+        device = target.device
+
+        B, C, H, W = prediction.shape
+
+
+        # median_pred, _ = torch.median(prediction.view(B, C*H*W), 1)
+        # median_pred = median_pred.detach()
+
+        # scale_factor = torch.zeros_like(scale).squeeze(3).squeeze(2).squeeze(1)
+        # for i in range(B):
+        #     mask_i = mask[i, ...]
+        #     if torch.sum(mask_i) > 10:
+        #         scale_factor[i] = torch.median(target[i, ...][mask_i]) / (torch.median(prediction[i, ...][mask_i]) + 1e-8)
+        #     else:
+        #         scale_factor[i] = 0
+        
+        # target_scale = (median_pred * scale_factor)
+
+        # batches_dataset = kwargs['dataset']
+        # self.batch_valid = torch.tensor([1 if batch_dataset not in self.disable_dataset else 0 \
+        #     for batch_dataset in batches_dataset], device=device)
+
+        # batch_valid = self.batch_valid * (scale_factor > 1e-8)
+
+        # scale_diff = torch.abs(scale.squeeze(3).squeeze(2).squeeze(1) - scale_factor * median_pred)
+
+        batches_dataset = kwargs['dataset']
+        self.batch_valid = torch.tensor([1 if batch_dataset not in self.disable_dataset else 0 \
+            for batch_dataset in batches_dataset], device=device)
+
+        scale_tgt = torch.zeros_like(scale).squeeze(3).squeeze(2).squeeze(1)
+        for i in range(B):
+            mask_i = mask[i, ...]
+            if torch.sum(mask_i) > 10:
+                scale_tgt[i] = torch.median(target[i, ...][mask_i])
+            else:
+                scale_tgt[i] = 0
+        
+        batch_valid = self.batch_valid * (scale_tgt > 1e-8)
+        scale_diff = torch.abs(scale.squeeze(3).squeeze(2).squeeze(1) - scale_tgt)
+        loss = torch.sum(scale_diff * batch_valid) / (torch.sum(batch_valid) + 1e-8)
+
+        return loss * self.loss_weight

external/Metric3D/training/mono/model/losses/ScaleInvL1.py

@@ -0,0 +1,35 @@
+import torch
+import torch.nn as nn
+
+class ScaleInvL1Loss(nn.Module):
+    """
+    Compute scale-invariant L1 loss.
+    """
+    def __init__(self, loss_weight=1, data_type=['sfm', 'denselidar_nometric', 'denselidar_syn'], **kwargs):
+        super(ScaleInvL1Loss, self).__init__()
+        self.loss_weight = loss_weight
+        self.data_type = data_type
+        self.eps = 1e-6
+
+    def forward(self, prediction, target, mask=None, **kwargs):    
+        B, _, _, _ = target.shape
+        target_nan = target.clone()
+        target_nan[~mask] = torch.nan
+        median_target = torch.nanmedian(target_nan.view(B, -1), dim=1)[0]
+        prediction_nan = prediction.clone().detach()
+        prediction_nan[~mask] = torch.nan
+        median_prediction = torch.nanmedian(prediction_nan.view(B, -1), dim=1)[0]
+        scale = median_target / median_prediction
+        scale[torch.isnan(scale)] = 0
+        pred_scale = prediction * scale[:, None, None, None]
+        
+        target_valid = target * mask
+        pred_valid = pred_scale * mask
+        diff = torch.abs(pred_valid - target_valid)
+        # disp_diff = diff / (target_valid + self.eps)
+        loss = torch.sum(diff) / (torch.sum(mask) + self.eps)
+        if torch.isnan(loss).item() | torch.isinf(loss).item():
+            loss = 0 * torch.sum(prediction)
+            print(f'Scale-invariant L1 NAN error, {loss}')
+            #raise RuntimeError(f'Silog error, {loss}, d_square_mean: {d_square_mean}, d_mean: {d_mean}')
+        return loss * self.loss_weight

external/Metric3D/training/mono/model/losses/SiLog.py

@@ -0,0 +1,38 @@
+import torch
+import torch.nn as nn
+
+class SilogLoss(nn.Module):
+    """
+    Compute SILog loss. See https://papers.nips.cc/paper/2014/file/7bccfde7714a1ebadf06c5f4cea752c1-Paper.pdf for
+    more information about scale-invariant loss.
+    """
+    def __init__(self, variance_focus=0.5, loss_weight=1, data_type=['stereo', 'lidar'], **kwargs):
+        super(SilogLoss, self).__init__()
+        self.variance_focus = variance_focus
+        self.loss_weight = loss_weight
+        self.data_type = data_type
+        self.eps = 1e-6
+    
+    def silog_loss(self, prediction, target, mask):
+        d = torch.log(prediction[mask]) - torch.log(target[mask])
+        d_square_mean = torch.sum(d ** 2) / (d.numel() + self.eps)
+        d_mean = torch.sum(d) / (d.numel() + self.eps)
+        loss = d_square_mean - self.variance_focus * (d_mean ** 2)
+        return loss
+
+    def forward(self, prediction, target, mask=None, **kwargs):
+        if target[mask].numel() > 0:
+            loss = self.silog_loss(prediction, target, mask)
+        else:
+            loss = 0 * torch.sum(prediction)
+        if torch.isnan(loss).item() | torch.isinf(loss).item():
+            raise RuntimeError(f'Silog error, {loss}, d_square_mean: {d_square_mean}, d_mean: {d_mean}')
+        return loss * self.loss_weight
+      
+if __name__ == '__main__':
+    silog = SilogLoss()
+    pred = torch.rand((2, 3, 256, 256)).cuda()
+    gt =  torch.zeros_like(pred) #torch.rand((2, 3, 256, 256)).cuda()
+    mask = gt > 0
+    out = silog(pred, gt, mask)
+    print(out)

external/Metric3D/training/mono/model/losses/SkyRegularization.py

@@ -0,0 +1,79 @@
+import numpy as np
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+class SkyRegularizationLoss(nn.Module):
+    """
+    Enforce losses on pixels without any gts.
+    """
+    def __init__(self, loss_weight=0.1, data_type=['sfm', 'stereo', 'lidar', 'denselidar', 'denselidar_nometric', 'denselidar_syn'], sky_id=142, sample_ratio=0.4, regress_value=1.8, normal_regress=None, normal_weight=1.0, **kwargs):
+        super(SkyRegularizationLoss, self).__init__()
+        self.loss_weight = loss_weight
+        self.data_type = data_type
+        self.sky_id = sky_id
+        self.sample_ratio = sample_ratio
+        self.eps = 1e-6
+        self.regress_value = regress_value
+        self.normal_regress = normal_regress
+        self.normal_weight = normal_weight
+    
+    def loss1(self, pred_sky):
+        loss = 1/ torch.exp((torch.sum(pred_sky) / (pred_sky.numel() + self.eps)))
+        return loss
+
+    def loss2(self, pred_sky):
+        loss = torch.sum(torch.abs(pred_sky - self.regress_value)) / (pred_sky.numel() + self.eps)
+        return loss
+
+    def loss_norm(self, pred_norm, sky_mask):
+        sky_norm = torch.FloatTensor(self.normal_regress).cuda()
+        sky_norm = sky_norm.unsqueeze(0).unsqueeze(2).unsqueeze(3)
+        dot = torch.cosine_similarity(pred_norm[:, :3, :, :].clone(), sky_norm, dim=1)
+
+        sky_mask_float = sky_mask.float().squeeze()
+        valid_mask = sky_mask_float \
+                        * (dot.detach() < 0.999).float() \
+                        * (dot.detach() > -0.999).float() 
+
+        al = (1 - dot) * valid_mask
+        loss = torch.sum(al) / (torch.sum(sky_mask_float) + self.eps)
+        return loss
+
+    def forward(self, prediction, target, prediction_normal=None, mask=None, sem_mask=None,  **kwargs):
+        sky_mask = sem_mask == self.sky_id
+        pred_sky = prediction[sky_mask]
+        pred_sky_numel = pred_sky.numel()
+
+        if pred_sky.numel() > 50:
+            samples = np.random.choice(pred_sky_numel, int(pred_sky_numel*self.sample_ratio), replace=False)
+        
+        if pred_sky.numel() > 0:
+            #loss = - torch.sum(pred_wo_gt) / (pred_wo_gt.numel() + 1e-8)
+            loss = self.loss2(pred_sky)
+
+            if (prediction_normal != None) and (self.normal_regress != None):
+                loss_normal = self.loss_norm(prediction_normal, sky_mask)
+                loss = loss + loss_normal * self.normal_weight
+
+        else:
+            loss = torch.sum(prediction) * 0
+        if torch.isnan(loss).item() | torch.isinf(loss).item():
+            loss = torch.sum(prediction) * 0
+            print(f'SkyRegularization NAN error, {loss}')    
+        #    raise RuntimeError(f'Sky Loss error, {loss}')    
+        
+        return loss * self.loss_weight
+
+if __name__ == '__main__':
+    import cv2
+    sky = SkyRegularizationLoss()
+    pred_depth = np.random.random([2, 1, 480, 640])
+    gt_depth = np.zeros_like(pred_depth) #np.random.random([2, 1, 480, 640])
+    intrinsic = [[[100, 0, 200], [0, 100, 200], [0, 0, 1]], [[100, 0, 200], [0, 100, 200], [0, 0, 1]],]
+    gt_depth = torch.tensor(np.array(gt_depth, np.float32)).cuda()
+    pred_depth = torch.tensor(np.array(pred_depth, np.float32)).cuda()
+    intrinsic = torch.tensor(np.array(intrinsic, np.float32)).cuda()
+    mask = gt_depth > 0
+    loss1 = sky(pred_depth, gt_depth, mask, mask, intrinsic)
+    print(loss1)

external/Metric3D/training/mono/model/losses/VNL.py

@@ -0,0 +1,260 @@
+import torch
+import torch.nn as nn
+import numpy as np
+
+
+class VNLoss(nn.Module):
+    """
+    Virtual Normal Loss.
+    """
+    def __init__(self,
+                 delta_cos=0.867, delta_diff_x=0.01,
+                 delta_diff_y=0.01, delta_diff_z=0.01,
+                 delta_z=1e-5, sample_ratio=0.15,
+                 loss_weight=1.0, data_type=['sfm', 'stereo', 'lidar', 'denselidar', 'denselidar_nometric', 'denselidar_syn'], **kwargs):
+        super(VNLoss, self).__init__()
+        self.delta_cos = delta_cos
+        self.delta_diff_x = delta_diff_x
+        self.delta_diff_y = delta_diff_y
+        self.delta_diff_z = delta_diff_z
+        self.delta_z = delta_z
+        self.sample_ratio = sample_ratio
+        self.loss_weight = loss_weight
+        self.data_type = data_type
+        self.eps = 1e-6
+
+
+    def init_image_coor(self, intrinsic, height, width):
+        # x_row = torch.arange(0, W, device="cuda")
+        # x = torch.tile(x_row, (H, 1))
+        # x = x.to(torch.float32)
+        # u_m_u0 = x[None, None, :, :] - u0
+        # self.register_buffer('u_m_u0', u_m_u0, persistent=False)
+
+        # y_col = torch.arange(0, H, device="cuda")  # y_col = np.arange(0, height)
+        # y = torch.transpose(torch.tile(y_col, (W, 1)), 1, 0)
+        # y = y.to(torch.float32)
+        # v_m_v0 = y[None, None, :, :] - v0
+        # self.register_buffer('v_m_v0', v_m_v0, persistent=False)
+
+        # pix_idx_mat = torch.arange(H*W, device="cuda").reshape((H, W))
+        # self.register_buffer('pix_idx_mat', pix_idx_mat, persistent=False)
+        #self.pix_idx_mat = torch.arange(height*width, device="cuda").reshape((height, width))
+        
+        u0 = intrinsic[:, 0, 2][:, None, None, None]
+        v0 = intrinsic[:, 1, 2][:, None, None, None]
+        y, x = torch.meshgrid([torch.arange(0, height, dtype=torch.float32, device="cuda"),
+                               torch.arange(0, width, dtype=torch.float32, device="cuda")], indexing='ij')
+        u_m_u0 = x[None, None, :, :] - u0
+        v_m_v0 = y[None, None, :, :] - v0
+        # return u_m_u0, v_m_v0
+        self.register_buffer('v_m_v0', v_m_v0, persistent=False)
+        self.register_buffer('u_m_u0', u_m_u0, persistent=False)
+
+    def transfer_xyz(self, depth, focal_length, u_m_u0, v_m_v0):
+        x = u_m_u0 * depth / focal_length
+        y = v_m_v0 * depth / focal_length
+        z = depth
+        pw = torch.cat([x, y, z], 1).permute(0, 2, 3, 1).contiguous() # [b, h, w, c]
+        return pw
+
+    def select_index(self, B, H, W, mask):
+        """
+        
+        """
+        p1 = []
+        p2 = []
+        p3 = []
+        pix_idx_mat = torch.arange(H*W, device="cuda").reshape((H, W))
+        for i in range(B):
+            inputs_index = torch.masked_select(pix_idx_mat, mask[i, ...].gt(self.eps))
+            num_effect_pixels = len(inputs_index)
+
+            intend_sample_num = int(H * W * self.sample_ratio)
+            sample_num = intend_sample_num if num_effect_pixels >= intend_sample_num else num_effect_pixels
+
+            shuffle_effect_pixels = torch.randperm(num_effect_pixels, device="cuda")
+            p1i = inputs_index[shuffle_effect_pixels[:sample_num]]
+            shuffle_effect_pixels = torch.randperm(num_effect_pixels, device="cuda")
+            p2i = inputs_index[shuffle_effect_pixels[:sample_num]]
+            shuffle_effect_pixels = torch.randperm(num_effect_pixels, device="cuda")
+            p3i = inputs_index[shuffle_effect_pixels[:sample_num]]
+
+            cat_null = torch.tensor(([0,] * (intend_sample_num - sample_num)), dtype=torch.long, device="cuda")
+            p1i = torch.cat([p1i, cat_null])
+            p2i = torch.cat([p2i, cat_null])
+            p3i = torch.cat([p3i, cat_null])
+
+            p1.append(p1i)
+            p2.append(p2i)
+            p3.append(p3i)
+        
+        p1 = torch.stack(p1, dim=0)
+        p2 = torch.stack(p2, dim=0)
+        p3 = torch.stack(p3, dim=0)
+
+        p1_x = p1 % W
+        p1_y = torch.div(p1, W, rounding_mode='trunc').long() # p1 // W
+
+        p2_x = p2 % W
+        p2_y = torch.div(p2, W, rounding_mode='trunc').long() # p2 // W
+
+        p3_x = p3 % W
+        p3_y = torch.div(p3, W, rounding_mode='trunc').long() # p3 // W
+        p123 = {'p1_x': p1_x, 'p1_y': p1_y, 'p2_x': p2_x, 'p2_y': p2_y, 'p3_x': p3_x, 'p3_y': p3_y}
+        return p123
+
+    def form_pw_groups(self, p123, pw):
+        """
+        Form 3D points groups, with 3 points in each grouup.
+        :param p123: points index
+        :param pw: 3D points
+        :return:
+        """
+        B, _, _, _ = pw.shape
+        p1_x = p123['p1_x']
+        p1_y = p123['p1_y']
+        p2_x = p123['p2_x']
+        p2_y = p123['p2_y']
+        p3_x = p123['p3_x']
+        p3_y = p123['p3_y']
+        
+        pw_groups = []
+        for i in range(B):
+            pw1 = pw[i, p1_y[i], p1_x[i], :]
+            pw2 = pw[i, p2_y[i], p2_x[i], :]
+            pw3 = pw[i, p3_y[i], p3_x[i], :]
+            pw_bi = torch.stack([pw1, pw2, pw3], dim=2)
+            pw_groups.append(pw_bi)
+        # [B, N, 3(x,y,z), 3(p1,p2,p3)]
+        pw_groups = torch.stack(pw_groups, dim=0)
+        return pw_groups
+
+    def filter_mask(self, p123, gt_xyz, delta_cos=0.867,
+                    delta_diff_x=0.005,
+                    delta_diff_y=0.005,
+                    delta_diff_z=0.005):
+        pw = self.form_pw_groups(p123, gt_xyz)
+        pw12 = pw[:, :, :, 1] - pw[:, :, :, 0]
+        pw13 = pw[:, :, :, 2] - pw[:, :, :, 0]
+        pw23 = pw[:, :, :, 2] - pw[:, :, :, 1]
+        ###ignore linear
+        pw_diff = torch.cat([pw12[:, :, :, np.newaxis], pw13[:, :, :, np.newaxis], pw23[:, :, :, np.newaxis]],
+                            3)  # [b, n, 3, 3]
+        m_batchsize, groups, coords, index = pw_diff.shape
+        proj_query = pw_diff.view(m_batchsize * groups, -1, index).permute(0, 2, 1).contiguous()  # (B* X CX(3)) [bn, 3(p123), 3(xyz)]
+        proj_key = pw_diff.contiguous().view(m_batchsize * groups, -1, index)  # B X  (3)*C [bn, 3(xyz), 3(p123)]
+        q_norm = proj_query.norm(2, dim=2)
+        nm = torch.bmm(q_norm.contiguous().view(m_batchsize * groups, index, 1), q_norm.view(m_batchsize * groups, 1, index)) #[]
+        energy = torch.bmm(proj_query, proj_key)  # transpose check [bn, 3(p123), 3(p123)]
+        norm_energy = energy / (nm + self.eps)
+        norm_energy = norm_energy.contiguous().view(m_batchsize * groups, -1)
+        mask_cos = torch.sum((norm_energy > delta_cos) + (norm_energy < -delta_cos), 1) > 3  # igonre
+        mask_cos = mask_cos.contiguous().view(m_batchsize, groups)
+        ##ignore padding and invilid depth
+        mask_pad = torch.sum(pw[:, :, 2, :] > self.delta_z, 2) == 3
+
+        ###ignore near
+        mask_x = torch.sum(torch.abs(pw_diff[:, :, 0, :]) < delta_diff_x, 2) > 0
+        mask_y = torch.sum(torch.abs(pw_diff[:, :, 1, :]) < delta_diff_y, 2) > 0
+        mask_z = torch.sum(torch.abs(pw_diff[:, :, 2, :]) < delta_diff_z, 2) > 0
+
+        mask_ignore = (mask_x & mask_y & mask_z) | mask_cos
+        mask_near = ~mask_ignore
+        mask = mask_pad & mask_near
+
+        return mask, pw
+
+    def select_points_groups(self, gt_depth, pred_depth, intrinsic, mask):
+        B, C, H, W = gt_depth.shape
+        focal_length = intrinsic[:, 0, 0][:, None, None, None]
+        u_m_u0, v_m_v0 = self.u_m_u0, self.v_m_v0 # self.init_image_coor(intrinsic, height=H, width=W)
+        
+        pw_gt = self.transfer_xyz(gt_depth, focal_length, u_m_u0, v_m_v0)
+        pw_pred = self.transfer_xyz(pred_depth, focal_length, u_m_u0, v_m_v0)
+        
+        p123 = self.select_index(B, H, W, mask)
+        # mask:[b, n], pw_groups_gt: [b, n, 3(x,y,z), 3(p1,p2,p3)]
+        mask, pw_groups_gt = self.filter_mask(p123, pw_gt,
+                                              delta_cos=0.867,
+                                              delta_diff_x=0.005,
+                                              delta_diff_y=0.005,
+                                              delta_diff_z=0.005)
+
+        # [b, n, 3, 3]
+        pw_groups_pred = self.form_pw_groups(p123, pw_pred)
+        pw_groups_pred[pw_groups_pred[:, :, 2, :] == 0] = 0.0001
+        mask_broadcast = mask.repeat(1, 9).reshape(B, 3, 3, -1).permute(0, 3, 1, 2).contiguous()
+        pw_groups_pred_not_ignore = pw_groups_pred[mask_broadcast].reshape(1, -1, 3, 3)
+        pw_groups_gt_not_ignore = pw_groups_gt[mask_broadcast].reshape(1, -1, 3, 3)
+
+        return pw_groups_gt_not_ignore, pw_groups_pred_not_ignore
+
+    def forward(self, prediction, target, mask, intrinsic, select=True, **kwargs): #gt_depth, pred_depth, select=True):
+        """
+        Virtual normal loss.
+        :param prediction: predicted depth map, [B,W,H,C]
+        :param data: target label, ground truth depth, [B, W, H, C], padding region [padding_up, padding_down]
+        :return:
+        """
+        loss  = self.get_loss(prediction, target, mask, intrinsic, select, **kwargs)
+        return loss
+ 
+    
+    def get_loss(self, prediction, target, mask, intrinsic, select=True, **kwargs):
+        # configs for the cameras
+        # focal_length = intrinsic[:, 0, 0][:, None, None, None]
+        # u0 = intrinsic[:, 0, 2][:, None, None, None]
+        # v0 = intrinsic[:, 1, 2][:, None, None, None]
+        B, _, H, W = target.shape
+        if 'u_m_u0' not in self._buffers or 'v_m_v0' not in self._buffers \
+            or self.u_m_u0.shape != torch.Size([B,1,H,W]) or self.v_m_v0.shape != torch.Size([B,1,H,W]):
+            self.init_image_coor(intrinsic, H, W)
+
+
+        gt_points, pred_points = self.select_points_groups(target, prediction, intrinsic, mask)
+
+        gt_p12 = gt_points[:, :, :, 1] - gt_points[:, :, :, 0]
+        gt_p13 = gt_points[:, :, :, 2] - gt_points[:, :, :, 0]
+        pred_p12 = pred_points[:, :, :, 1] - pred_points[:, :, :, 0]
+        pred_p13 = pred_points[:, :, :, 2] - pred_points[:, :, :, 0]
+
+        gt_normal = torch.cross(gt_p12, gt_p13, dim=2)
+        pred_normal = torch.cross(pred_p12, pred_p13, dim=2)
+        pred_norm = torch.norm(pred_normal, 2, dim=2, keepdim=True)
+        gt_norm = torch.norm(gt_normal, 2, dim=2, keepdim=True)
+        pred_mask = pred_norm == 0.0
+        gt_mask = gt_norm == 0.0
+        pred_mask = pred_mask.to(torch.float32)
+        gt_mask = gt_mask.to(torch.float32)
+        pred_mask *= self.eps
+        gt_mask *= self.eps
+        gt_norm = gt_norm + gt_mask
+        pred_norm = pred_norm + pred_mask
+        gt_normal = gt_normal / gt_norm
+        pred_normal = pred_normal / pred_norm
+        loss = torch.abs(gt_normal - pred_normal)
+        loss = torch.sum(torch.sum(loss, dim=2), dim=0)
+        if select:
+            loss, indices = torch.sort(loss, dim=0, descending=False)
+            loss = loss[int(loss.size(0) * 0.25):]
+        loss = torch.sum(loss) / (loss.numel() + self.eps)
+        if torch.isnan(loss).item() | torch.isinf(loss).item():
+            loss = 0 * torch.sum(prediction)
+            print(f'VNL NAN error, {loss}')        
+        return loss * self.loss_weight
+
+
+if __name__ == '__main__':
+    import cv2
+    vnl_loss = VNLoss()
+    pred_depth = np.random.random([2, 1, 480, 640])
+    gt_depth = np.zeros_like(pred_depth) #np.random.random([2, 1, 480, 640])
+    intrinsic = [[[100, 0, 200], [0, 100, 200], [0, 0, 1]], [[100, 0, 200], [0, 100, 200], [0, 0, 1]],]
+    gt_depth = torch.tensor(np.array(gt_depth, np.float32)).cuda()
+    pred_depth = torch.tensor(np.array(pred_depth, np.float32)).cuda()
+    intrinsic = torch.tensor(np.array(intrinsic, np.float32)).cuda()
+    mask = gt_depth > 0
+    loss1 = vnl_loss(pred_depth, gt_depth, mask, intrinsic)
+    loss2 = vnl_loss(pred_depth, gt_depth, mask, intrinsic)
+    print(loss1, loss2)

external/Metric3D/training/mono/model/losses/WCEL.py

@@ -0,0 +1,157 @@
+import torch
+import torch.nn as nn
+import numpy as np
+
+
+class WCELoss(nn.Module):
+    """
+    Weighted Cross-entropy Loss Function.
+    """
+    def __init__(self, depth_normalize, out_channel=200, loss_weight=1.0, data_type=['stereo', 'lidar'], **kwargs):
+        super(WCELoss, self).__init__()
+        self.loss_weight = loss_weight
+        self.depth_min = depth_normalize[0]
+        self.depth_max = depth_normalize[1]
+        self.bins_num = out_channel
+        self.depth_min_log = torch.log10(torch.tensor(self.depth_min))
+        
+        self.alpha = 2 #0.2
+        self.config_bins()
+        self.noise_sample_ratio = 0.9 #kwargs['noise_sample_ratio'] if 'noise_sample_ratio' in kwargs else 1.0
+        self.data_type = data_type
+        self.eps = 1e-6
+    
+    def config_bins(self):
+        # Modify some configs
+        self.depth_bins_interval = (torch.log10(torch.tensor(self.depth_max)) - 
+                                   self.depth_min_log) / self.bins_num
+        bins_edges_in_log = self.depth_min_log +  self.depth_bins_interval * torch.tensor(list(range(self.bins_num)) + [self.bins_num,])
+        #bins_edges_in_log = torch.from_numpy(bins_edges_in_log)
+        # The boundary of each bin
+        # bins_edges_in_log = np.array([self.depth_min_log + self.depth_bins_interval * (i + 0.5)
+        #                         for i in range(self.bins_num)])
+        bins_weight = torch.tensor([[np.exp(-self.alpha * (i - j) ** 2) for i in range(self.bins_num )]
+                            for j in np.arange(self.bins_num )]).cuda()
+        self.register_buffer("bins_weight", bins_weight.float(), persistent=False)
+        self.register_buffer("bins_edges_in_log", bins_edges_in_log.float(), persistent=False)
+
+    def depth_to_bins_in_log(self, depth, mask):
+        """
+        Discretize depth into depth bins. Predefined bins edges are in log space.
+        Mark invalid padding area as bins_num + 1
+        Args:
+            @depth: 1-channel depth, [B, 1, h, w]
+        return: depth bins [B, C, h, w]
+        """
+        invalid_mask = ~mask
+        #depth[depth < self.depth_min] = self.depth_min
+        #depth[depth > self.depth_max] = self.depth_max
+        mask_lower = (depth <= self.depth_min) 
+        mask_higher = (depth >= self.depth_max)
+        depth_bins_log = ((torch.log10(torch.abs(depth)) - self.depth_min_log) / self.depth_bins_interval).to(torch.int)
+        
+        depth_bins_log[mask_lower] = 0
+        depth_bins_log[mask_higher] = self.bins_num - 1
+        depth_bins_log[depth_bins_log == self.bins_num] = self.bins_num - 1
+
+        depth_bins_log[invalid_mask] = self.bins_num + 1
+        return depth_bins_log
+    
+    def depth_to_bins(self, depth, mask, depth_edges, size_limite=(300, 300)):
+        """
+        Discretize depth into depth bins. Predefined bins edges are provided.
+        Mark invalid padding area as bins_num + 1
+        Args:
+            @depth: 1-channel depth, [B, 1, h, w]
+        return: depth bins [B, C, h, w]
+        """ 
+        def _depth_to_bins_block_(depth, mask, depth_edges):
+            bins_id = torch.sum(depth_edges[:, None, None, None, :] < torch.abs(depth)[:, :, :, :, None], dim=-1)
+            bins_id = bins_id - 1
+            invalid_mask = ~mask
+            mask_lower = (depth <= self.depth_min) 
+            mask_higher = (depth >= self.depth_max)
+            
+            bins_id[mask_lower] = 0
+            bins_id[mask_higher] = self.bins_num - 1
+            bins_id[bins_id == self.bins_num] = self.bins_num - 1
+
+            bins_id[invalid_mask] = self.bins_num + 1
+            return bins_id
+        _, _, H, W = depth.shape
+        bins = mask.clone().long()
+        h_blocks = np.ceil(H / size_limite[0]).astype(np.int)
+        w_blocks = np.ceil(W/ size_limite[1]).astype(np.int)
+        for i in range(h_blocks):
+            for j in range(w_blocks):
+                h_start = i*size_limite[0]
+                h_end_proposal = (i + 1) * size_limite[0]
+                h_end = h_end_proposal if h_end_proposal < H else H
+                w_start = j*size_limite[1]
+                w_end_proposal = (j + 1) * size_limite[1]
+                w_end = w_end_proposal if w_end_proposal < W else W
+                bins_ij = _depth_to_bins_block_(
+                    depth[:, :, h_start:h_end, w_start:w_end], 
+                    mask[:, :, h_start:h_end, w_start:w_end],
+                    depth_edges
+                    )
+                bins[:, :, h_start:h_end, w_start:w_end] = bins_ij        
+        return bins
+
+    
+    # def mask_maximum_loss(self, loss_pixels, mask):
+    #     mask = mask.reshape(mask.size(0), -1)
+    #     valid_pix_bt = torch.sum(mask, dim=1)
+    #     mask_noise_num = (valid_pix_bt * self.noise_sample_ratio).int()
+        
+    #     loss_sample = []
+    #     for i in range(loss_pixels.size(0)):
+    #         sorted_losses, _ = torch.sort(loss_pixels[i, :][mask[i, ...]])
+    #         loss_sample.append(torch.sum(sorted_losses[:mask_noise_num[i]]))
+            
+    #     return torch.tensor(loss_sample), mask_noise_num
+
+
+    def forward(self, prediction, target, mask=None, pred_logit=None, **kwargs): #pred_logit, gt_bins, gt):
+        B, _, H, W = target.shape
+        if 'bins_edges' not in kwargs or kwargs['bins_edges'] is None:
+            # predefined depth bins in log space
+            gt_bins = self.depth_to_bins_in_log(target, mask) 
+        else:
+            bins_edges = kwargs['bins_edges']
+            gt_bins = self.depth_to_bins(target, mask, bins_edges)
+
+        classes_range = torch.arange(self.bins_num, device=gt_bins.device, dtype=gt_bins.dtype)
+        log_pred = torch.nn.functional.log_softmax(pred_logit, 1)
+        log_pred = log_pred.reshape(B, log_pred.size(1), -1).permute((0, 2, 1))
+        gt_reshape = gt_bins.reshape((B, -1))[:, :, None]
+        one_hot = (gt_reshape == classes_range).to(dtype=torch.float, device=pred_logit.device)
+        weight = torch.matmul(one_hot, self.bins_weight)
+        weight_log_pred = weight * log_pred
+        loss_pixeles = - torch.sum(weight_log_pred, dim=2)
+
+        valid_pixels = torch.sum(mask).to(dtype=torch.float, device=pred_logit.device)
+        loss = torch.sum(loss_pixeles) / (valid_pixels + self.eps)
+        if torch.isnan(loss).item() | torch.isinf(loss).item():
+            raise RuntimeError(f'WCEL error, {loss}')
+        return loss * self.loss_weight
+
+
+
+if __name__ == '__main__':
+    import cv2
+    wcel = WCELoss((0.0004, 1))
+    pred_depth = np.abs(np.random.random([2, 1, 480, 640]))
+    pred_logit = np.random.random([2, 200, 480, 640])
+    gt_depth = np.random.random([2, 1, 480, 640]) - 0.5 #np.zeros_like(pred_depth) #
+    intrinsic = [[100, 100, 200, 200], [200, 200, 300, 300]]
+    gt_depth = torch.tensor(np.array(gt_depth, np.float32)).cuda()
+    pred_depth = torch.tensor(np.array(pred_depth, np.float32)).cuda()
+    intrinsic = torch.tensor(np.array(intrinsic, np.float32)).cuda()
+    pred_logit = torch.tensor(np.array(pred_logit, np.float32)).cuda()
+
+
+    mask = gt_depth > 0
+    loss1 = wcel(gt_depth, gt_depth, mask, intrinsic=intrinsic, pred_logit=pred_logit)
+    loss2 = wcel(gt_depth, gt_depth, mask, intrinsic=intrinsic, pred_logit=pred_logit)
+    print(loss1, loss2)

external/Metric3D/training/mono/model/losses/__init__.py

@@ -0,0 +1,32 @@
+from .SiLog import SilogLoss
+from .WCEL import  WCELoss
+from .VNL import VNLoss
+from .Gradient import GradientLoss_Li, GradientLoss
+from .Ranking import EdgeguidedRankingLoss, RankingLoss
+from .Regularization import RegularizationLoss
+from .SSIL import SSILoss
+from .HDNL import HDNLoss
+from .HDSNL import HDSNLoss
+from .NormalRegression import EdgeguidedNormalLoss
+from .depth_to_normal import Depth2Normal
+from .photometric_loss_functions import PhotometricGeometricLoss
+from .HDSNL_random import HDSNRandomLoss
+from .HDNL_random import HDNRandomLoss
+from .AdabinsLoss import AdabinsLoss
+from .SkyRegularization import SkyRegularizationLoss
+from .PWN_Planes import PWNPlanesLoss
+from .L1 import L1Loss, L1DispLoss, L1InverseLoss
+from .ConfidenceLoss import ConfidenceLoss
+from .ScaleInvL1 import ScaleInvL1Loss
+from .NormalBranchLoss import NormalBranchLoss, DeNoConsistencyLoss
+from .GRUSequenceLoss import GRUSequenceLoss
+from .ConfidenceGuideLoss import ConfidenceGuideLoss
+from .ScaleAlignLoss import ScaleAlignLoss
+
+__all__ = [
+    'SilogLoss', 'WCELoss', 'VNLoss', 'GradientLoss_Li', 'GradientLoss', 'EdgeguidedRankingLoss',
+    'RankingLoss', 'RegularizationLoss', 'SSILoss', 'HDNLoss', 'HDSNLoss', 'EdgeguidedNormalLoss', 'Depth2Normal',
+    'PhotometricGeometricLoss', 'HDSNRandomLoss', 'HDNRandomLoss', 'AdabinsLoss', 'SkyRegularizationLoss',
+    'PWNPlanesLoss', 'L1Loss',
+    'ConfidenceLoss', 'ScaleInvL1Loss', 'L1DispLoss', 'NormalBranchLoss', 'L1InverseLoss', 'GRUSequenceLoss', 'ConfidenceGuideLoss', 'DeNoConsistencyLoss', 'ScaleAlignLoss'
+]

external/Metric3D/training/mono/model/losses/depth_to_normal.py

@@ -0,0 +1,302 @@
+import numpy as np
+import torch
+import torch.nn as nn
+
+class Backprojection(nn.Module):
+    """Layer to backproject a depth image given the camera intrinsics
+    Attributes
+        xy (Nx3x(HxW)): homogeneous pixel coordinates on regular grid
+    """
+    def __init__(self, height, width):
+        """
+        Args:
+            height (int): image height
+            width (int): image width
+        """
+        super(Backprojection, self).__init__()
+
+        self.height = height
+        self.width = width
+
+        # generate regular grid
+        meshgrid = np.meshgrid(range(self.width), range(self.height), indexing='xy')
+        id_coords = np.stack(meshgrid, axis=0).astype(np.float32)
+        id_coords = torch.tensor(id_coords, device="cuda")
+
+        # generate homogeneous pixel coordinates
+        # self.ones = nn.Parameter(torch.ones(1, 1, self.height * self.width),
+        #                          requires_grad=False)
+        ones = torch.ones(1, 1, self.height * self.width, device="cuda")
+        xy = torch.unsqueeze(
+            torch.stack([id_coords[0].view(-1), id_coords[1].view(-1)], 0),
+            0
+            )
+        xy = torch.cat([xy, ones], 1)
+        #self.xy = nn.Parameter(self.xy, requires_grad=False)
+        self.register_buffer('xy', xy, persistent=False)
+        self.register_buffer('ones', ones, persistent=False)
+
+        # for virtual camera only
+        horizontal_angle_range=[195.0, -15.0]
+        vertical_angle_range=[150.0, 0.0]
+        
+        horizontal_sample_num=641
+        vertical_sample_num=481
+
+        self.horizontal_angle_range = horizontal_angle_range
+        self.vertical_angle_range = vertical_angle_range
+        self.horizontal_sample_num = horizontal_sample_num
+        self.vertical_sample_num = vertical_sample_num
+
+        self.horizontal_step = (self.horizontal_angle_range[1] - self.horizontal_angle_range[0]) / (
+            self.horizontal_sample_num - 1)
+        self.vertical_step = (self.vertical_angle_range[1] - self.vertical_angle_range[0]) / (
+            self.vertical_sample_num - 1)
+
+        self.horizontal_samples = np.arange(self.horizontal_angle_range[0], self.horizontal_angle_range[1],
+                                            self.horizontal_step)
+        self.vertical_samples = np.arange(self.vertical_angle_range[0], self.vertical_angle_range[1],
+                                          self.vertical_step)
+
+        horizontal_samples_in_rad = self.horizontal_samples / 180.0 * np.pi
+        vertical_samples_in_rad = self.vertical_samples / 180.0 * np.pi
+
+        virt_H = len(self.vertical_samples)
+        virt_W = len(self.horizontal_samples)
+
+        self.virt_H, self.virt_W = virt_H, virt_W
+
+        cos_theta = np.tile(np.cos(vertical_samples_in_rad).reshape(-1, 1), (1, virt_W))
+        sin_theta = np.tile(np.sin(vertical_samples_in_rad).reshape(-1, 1), (1, virt_W))
+        cos_phi = np.tile(np.cos(horizontal_samples_in_rad).reshape(1, -1), (virt_H, 1))
+        sin_phi = np.tile(np.sin(horizontal_samples_in_rad).reshape(1, -1), (virt_H, 1))
+
+        x = (sin_theta * cos_phi).reshape(1, virt_H, virt_W)
+        y = cos_theta.reshape(1, virt_H, virt_W)
+        z = (sin_theta * sin_phi).reshape(1, virt_H, virt_W)
+
+        self.dir_in_virt_cam = np.concatenate((x, y, z), axis=0)
+        self.dir_in_virt_cam = self.dir_in_virt_cam.reshape(3, self.virt_H * self.virt_W)
+
+
+    def forward(self, depth, inv_K, img_like_out=False):
+        """
+        Args:
+            depth (Nx1xHxW): depth map
+            inv_K (Nx4x4): inverse camera intrinsics
+            img_like_out (bool): if True, the output shape is Nx4xHxW; else Nx4x(HxW)
+        Returns:
+            points (Nx4x(HxW)): 3D points in homogeneous coordinates
+        """
+        depth = depth.contiguous()
+
+        xy = self.xy.repeat(depth.shape[0], 1, 1)
+        ones = self.ones.repeat(depth.shape[0],1,1)
+        
+        points = torch.matmul(inv_K[:, :3, :3], xy)
+        points = depth.view(depth.shape[0], 1, -1) * points
+        points = torch.cat([points, ones], 1)
+
+        if img_like_out:
+            points = points.reshape(depth.shape[0], 4, self.height, self.width)
+        return points
+
+
+def get_surface_normalv2(xyz, patch_size=5, mask_valid=None):
+    """
+    xyz: xyz coordinates, in [b, h, w, c]
+    patch: [p1, p2, p3,
+            p4, p5, p6,
+            p7, p8, p9]
+    surface_normal = [(p9-p1) x (p3-p7)] + [(p6-p4) - (p8-p2)]
+    return: normal [h, w, 3, b]
+    """
+    b, h, w, c = xyz.shape
+    half_patch = patch_size // 2
+
+    if mask_valid == None:
+        mask_valid = xyz[:, :, :, 2] > 0 # [b, h, w]
+    mask_pad = torch.zeros((b, h + patch_size - 1, w + patch_size - 1), device=mask_valid.device).bool()
+    mask_pad[:, half_patch:-half_patch, half_patch:-half_patch] = mask_valid
+    
+    xyz_pad = torch.zeros((b, h + patch_size - 1, w + patch_size - 1, c), dtype=xyz.dtype, device=xyz.device)
+    xyz_pad[:, half_patch:-half_patch, half_patch:-half_patch, :] = xyz
+
+    xyz_left = xyz_pad[:, half_patch:half_patch + h, :w, :]  # p4
+    xyz_right = xyz_pad[:, half_patch:half_patch + h, -w:, :]  # p6
+    xyz_top = xyz_pad[:, :h, half_patch:half_patch + w, :]  # p2
+    xyz_bottom = xyz_pad[:, -h:, half_patch:half_patch + w, :]  # p8
+    xyz_horizon = xyz_left - xyz_right  # p4p6
+    xyz_vertical = xyz_top - xyz_bottom  # p2p8
+
+    xyz_left_in = xyz_pad[:, half_patch:half_patch + h, 1:w+1, :]  # p4
+    xyz_right_in = xyz_pad[:, half_patch:half_patch + h, patch_size-1:patch_size-1+w, :]  # p6
+    xyz_top_in = xyz_pad[:, 1:h+1, half_patch:half_patch + w, :]  # p2
+    xyz_bottom_in = xyz_pad[:, patch_size-1:patch_size-1+h, half_patch:half_patch + w, :]  # p8
+    xyz_horizon_in = xyz_left_in - xyz_right_in  # p4p6
+    xyz_vertical_in = xyz_top_in - xyz_bottom_in  # p2p8
+
+    n_img_1 = torch.cross(xyz_horizon_in, xyz_vertical_in, dim=3)
+    n_img_2 = torch.cross(xyz_horizon, xyz_vertical, dim=3)
+
+    # re-orient normals consistently
+    orient_mask = torch.sum(n_img_1 * xyz, dim=3) > 0
+    n_img_1[orient_mask] *= -1
+    orient_mask = torch.sum(n_img_2 * xyz, dim=3) > 0
+    n_img_2[orient_mask] *= -1
+
+    n_img1_L2 = torch.sqrt(torch.sum(n_img_1 ** 2, dim=3, keepdim=True)  + 1e-4)
+    n_img1_norm = n_img_1 / (n_img1_L2 + 1e-8)
+
+    n_img2_L2 = torch.sqrt(torch.sum(n_img_2 ** 2, dim=3, keepdim=True)  + 1e-4)
+    n_img2_norm = n_img_2 / (n_img2_L2 + 1e-8)
+
+    # average 2 norms
+    n_img_aver = n_img1_norm + n_img2_norm
+    n_img_aver_L2 = torch.sqrt(torch.sum(n_img_aver ** 2, dim=3, keepdim=True) + 1e-4)
+    n_img_aver_norm = n_img_aver / (n_img_aver_L2 + 1e-8)
+    # re-orient normals consistently
+    orient_mask = torch.sum(n_img_aver_norm * xyz, dim=3) > 0
+    n_img_aver_norm[orient_mask] *= -1
+    #n_img_aver_norm_out = n_img_aver_norm.permute((1, 2, 3, 0))  # [h, w, c, b]
+
+    # get mask for normals
+    mask_p4p6 = mask_pad[:, half_patch:half_patch + h, :w] & mask_pad[:, half_patch:half_patch + h, -w:]
+    mask_p2p8 = mask_pad[:, :h, half_patch:half_patch + w] & mask_pad[:, -h:, half_patch:half_patch + w]
+    mask_normal = mask_p2p8 & mask_p4p6
+    n_img_aver_norm[~mask_normal] = 0
+
+    # a = torch.sum(n_img1_norm_out*n_img2_norm_out, dim=2).cpu().numpy().squeeze()
+    # plt.imshow(np.abs(a), cmap='rainbow')
+    # plt.show()
+    return n_img_aver_norm.permute(0, 3, 1, 2).contiguous(), mask_normal[:, None, :, :] # [b, h, w, 3]
+
+class Depth2Normal(nn.Module):
+    """Layer to compute surface normal from depth map
+    """
+    def __init__(self,):
+        """
+        Args:
+            height (int): image height
+            width (int): image width
+        """
+        super(Depth2Normal, self).__init__()
+    
+    def init_img_coor(self, height, width):
+        """
+        Args:
+            height (int): image height
+            width (int): image width
+        """
+        y, x = torch.meshgrid([torch.arange(0, height, dtype=torch.float32, device="cuda"),
+                               torch.arange(0, width, dtype=torch.float32, device="cuda")], indexing='ij')
+        meshgrid = torch.stack((x, y))
+        
+        # # generate regular grid
+        # meshgrid = np.meshgrid(range(width), range(height), indexing='xy')
+        # id_coords = np.stack(meshgrid, axis=0).astype(np.float32)
+        # id_coords = torch.tensor(id_coords)
+
+        # generate homogeneous pixel coordinates
+        ones = torch.ones((1, 1, height * width), device="cuda")
+        # xy = torch.unsqueeze(
+        #     torch.stack([x.reshape(-1), y.reshape(-1)], 0),
+        #     0
+        #     )
+        xy = meshgrid.reshape(2, -1).unsqueeze(0)
+        xy = torch.cat([xy, ones], 1)
+        
+        self.register_buffer('xy', xy, persistent=False)
+
+    def back_projection(self, depth, inv_K, img_like_out=False, scale=1.0):
+        """
+        Args:
+            depth (Nx1xHxW): depth map
+            inv_K (Nx4x4): inverse camera intrinsics
+            img_like_out (bool): if True, the output shape is Nx4xHxW; else Nx4x(HxW)
+        Returns:
+            points (Nx4x(HxW)): 3D points in homogeneous coordinates
+        """
+        B, C, H, W = depth.shape
+        depth = depth.contiguous()
+        # xy = self.init_img_coor(height=H, width=W)
+        xy = self.xy # xy.repeat(depth.shape[0], 1, 1)
+        #ones = self.ones.repeat(depth.shape[0],1,1)
+        
+        points = torch.matmul(inv_K[:, :3, :3], xy)
+        points = depth.view(depth.shape[0], 1, -1) * points
+        depth_descale = points[:, 2:3, :] / scale
+        points = torch.cat((points[:, 0:2, :], depth_descale), dim=1)
+        #points = torch.cat([points, ones], 1)
+
+        if img_like_out:
+            points = points.reshape(depth.shape[0], 3, H, W)
+        return points
+    
+    # def transfer_xyz(self, u0, v0, H, W, depth, focal_length):
+    #     x_row = np.arange(0, W)
+    #     x = np.tile(x_row, (H, 1))
+    #     x = x.astype(np.float32)
+    #     x = torch.from_numpy(x.copy()).cuda()
+    #     u_m_u0 = x[None, None, :, :] - u0
+    #     self.register_buffer('u_m_u0', u_m_u0, persistent=False)
+
+    #     y_col = np.arange(0, H)  # y_col = np.arange(0, height)
+    #     y = np.tile(y_col, (W, 1)).T
+    #     y = y.astype(np.float32)
+    #     y = torch.from_numpy(y.copy()).cuda()
+    #     v_m_v0 = y[None, None, :, :] - v0
+    #     self.register_buffer('v_m_v0', v_m_v0, persistent=False)
+
+    #     pix_idx_mat = torch.arange(H*W).reshape((H, W)).cuda()
+    #     self.register_buffer('pix_idx_mat', pix_idx_mat, persistent=False)
+
+    #     x = self.u_m_u0 * depth / focal_length
+    #     y = self.v_m_v0 * depth / focal_length
+    #     z = depth
+    #     pw = torch.cat([x, y, z], 1).permute(0, 2, 3, 1) # [b, h, w, c]
+    #     return pw
+
+    def forward(self, depth, intrinsics, masks, scale):
+        """
+        Args:
+            depth (Nx1xHxW): depth map
+            #inv_K (Nx4x4): inverse camera intrinsics
+            intrinsics (Nx4): camera intrinsics
+        Returns:
+            normal (Nx3xHxW): normalized surface normal
+            mask (Nx1xHxW): valid mask for surface normal
+        """
+        B, C, H, W = depth.shape
+        if 'xy' not in self._buffers or self.xy.shape[-1] != H*W:
+            self.init_img_coor(height=H, width=W)
+        # Compute 3D point cloud
+        inv_K = intrinsics.inverse()
+        
+        xyz = self.back_projection(depth, inv_K, scale=scale) # [N, 4, HxW]
+
+        xyz = xyz.view(depth.shape[0], 3, H, W)
+        xyz = xyz[:,:3].permute(0, 2, 3, 1).contiguous() # [b, h, w, c]
+
+        # focal_length = intrinsics[:, 0, 0][:, None, None, None]
+        # u0 = intrinsics[:, 0, 2][:, None, None, None]
+        # v0 = intrinsics[:, 1, 2][:, None, None, None]        
+        # xyz2 = self.transfer_xyz(u0, v0, H, W, depth, focal_length)
+
+        normals, normal_masks = get_surface_normalv2(xyz, mask_valid=masks.squeeze())
+        normal_masks = normal_masks & masks
+        return normals, normal_masks
+
+
+
+if __name__ == '__main__':
+    d2n = Depth2Normal()
+    depth = np.random.randn(2, 1, 20, 22)
+    intrin = np.array([[300, 0, 10], [0, 300, 10], [0,0,1]])
+    intrinsics = np.stack([intrin, intrin], axis=0)
+
+    depth_t = torch.from_numpy(depth).cuda().float()
+    intrinsics = torch.from_numpy(intrinsics).cuda().float()
+    normal = d2n(depth_t, intrinsics)
+    normal2 = d2n(depth_t, intrinsics)
+    print(normal)

external/Metric3D/training/mono/model/losses/photometric_loss_functions.py

@@ -0,0 +1,300 @@
+import torch
+from torch import nn
+import torch.nn.functional as F
+import numpy as np
+
+from mono.utils.inverse_warp import inverse_warp2
+
+#device = torch.device("cuda") if torch.cuda.is_available() else torch.device("cpu")
+
+
+class SSIM(nn.Module):
+    """Layer to compute the SSIM loss between a pair of images
+    """
+    def __init__(self):
+        super(SSIM, self).__init__()
+        k = 7
+        self.mu_x_pool = nn.AvgPool2d(k, 1)
+        self.mu_y_pool = nn.AvgPool2d(k, 1)
+        self.sig_x_pool = nn.AvgPool2d(k, 1)
+        self.sig_y_pool = nn.AvgPool2d(k, 1)
+        self.sig_xy_pool = nn.AvgPool2d(k, 1)
+
+        self.refl = nn.ReflectionPad2d(k//2)
+
+        self.C1 = 0.01 ** 2
+        self.C2 = 0.03 ** 2
+
+    def forward(self, x, y):
+        x = self.refl(x)
+        y = self.refl(y)
+
+        mu_x = self.mu_x_pool(x)
+        mu_y = self.mu_y_pool(y)
+
+        sigma_x = self.sig_x_pool(x ** 2) - mu_x ** 2
+        sigma_y = self.sig_y_pool(y ** 2) - mu_y ** 2
+        sigma_xy = self.sig_xy_pool(x * y) - mu_x * mu_y
+
+        SSIM_n = (2 * mu_x * mu_y + self.C1) * (2 * sigma_xy + self.C2)
+        SSIM_d = (mu_x ** 2 + mu_y ** 2 + self.C1) * (sigma_x + sigma_y + self.C2)
+
+        return torch.clamp((1 - SSIM_n / SSIM_d) / 2, 0, 1)
+
+
+class PhotometricGeometricLoss(nn.Module):
+    """The photometric and geometric loss between target and reference frames."""
+    def __init__(self, loss_weight=1.0, data_type=['sfm', 'stereo', 'lidar'], **kwargs):
+        super(PhotometricGeometricLoss, self).__init__()
+        self.no_min_optimize = False
+        self.no_auto_mask = False
+        self.return_dynamic_mask = True
+        self.ssim_loss = SSIM()
+        self.no_ssim = False
+        self.no_dynamic_mask = False
+        self.loss_weight_photo = 1.0
+        self.loss_weight_geometry = 0.5
+        self.total_loss_weight = loss_weight
+        self.data_type = data_type
+
+    
+    def photo_and_geometry_loss(self, tgt_img, ref_imgs, tgt_depth, ref_depths, intrinsics, poses, poses_inv):
+
+        diff_img_list = []
+        diff_color_list = []
+        diff_depth_list = []
+        valid_mask_list = []
+        auto_mask_list = []
+
+        for ref_img, ref_depth, pose, pose_inv in zip(ref_imgs, ref_depths, poses, poses_inv):
+            (
+                diff_img_tmp1, 
+                diff_color_tmp1, 
+                diff_depth_tmp1, 
+                valid_mask_tmp1,
+                auto_mask_tmp1
+            ) = self.compute_pairwise_loss(
+                tgt_img, 
+                ref_img, 
+                tgt_depth,
+                ref_depth, 
+                pose, 
+                intrinsics,
+                )
+
+            (
+                diff_img_tmp2, 
+                diff_color_tmp2, 
+                diff_depth_tmp2, 
+                valid_mask_tmp2,
+                auto_mask_tmp2
+            ) = self.compute_pairwise_loss(
+                ref_img, 
+                tgt_img, 
+                ref_depth, 
+                tgt_depth, 
+                pose_inv, 
+                intrinsics, 
+                )
+
+            diff_img_list += [diff_img_tmp1, diff_img_tmp2]
+            diff_color_list += [diff_color_tmp1, diff_color_tmp2]
+            diff_depth_list += [diff_depth_tmp1, diff_depth_tmp2]
+            valid_mask_list += [valid_mask_tmp1, valid_mask_tmp2]
+            auto_mask_list += [auto_mask_tmp1, auto_mask_tmp2]
+
+        diff_img = torch.cat(diff_img_list, dim=1)
+        diff_color = torch.cat(diff_color_list, dim=1)
+        diff_depth = torch.cat(diff_depth_list, dim=1)
+        valid_mask = torch.cat(valid_mask_list, dim=1)
+        auto_mask = torch.cat(auto_mask_list, dim=1)
+
+        # using photo loss to select best match in multiple views
+        if not self.no_min_optimize:
+            indices = torch.argmin(diff_color, dim=1, keepdim=True)
+        
+            diff_img = torch.gather(diff_img, 1, indices)
+            diff_depth = torch.gather(diff_depth, 1, indices)
+            valid_mask = torch.gather(valid_mask, 1, indices)
+            auto_mask = torch.gather(auto_mask, 1, indices)
+        
+        if not self.no_auto_mask:
+            photo_loss = self.mean_on_mask(diff_img, valid_mask * auto_mask)
+            geometry_loss = self.mean_on_mask(diff_depth, valid_mask * auto_mask)
+        else:
+            photo_loss = self.mean_on_mask(diff_img, valid_mask)
+            geometry_loss = self.mean_on_mask(diff_depth, valid_mask)
+        
+        dynamic_mask = None
+        if self.return_dynamic_mask:
+            # get dynamic mask for tgt image       
+            dynamic_mask_list = []
+            for i in range(0, len(diff_depth_list), 2):
+                tmp = diff_depth_list[i]
+                tmp[valid_mask_list[1]<1] = 0
+                dynamic_mask_list += [1-tmp]
+            
+            dynamic_mask = torch.cat(dynamic_mask_list, dim=1).mean(dim=1, keepdim=True)
+
+        return photo_loss, geometry_loss, dynamic_mask
+
+
+    def compute_pairwise_loss(self, tgt_img, ref_img, tgt_depth, ref_depth, pose, intrinsic):
+
+        ref_img_warped, projected_depth, computed_depth = inverse_warp2(ref_img, tgt_depth, ref_depth, pose, intrinsic, padding_mode='zeros')
+
+        
+        diff_depth = (computed_depth-projected_depth).abs()/(computed_depth+projected_depth)
+
+        # masking zero values
+        valid_mask_ref = (ref_img_warped.abs().mean(dim=1, keepdim=True) > 1e-3).float()
+        valid_mask_tgt = (tgt_img.abs().mean(dim=1, keepdim=True) > 1e-3).float()
+        valid_mask =  valid_mask_tgt * valid_mask_ref
+
+        diff_color = (tgt_img-ref_img_warped).abs().mean(dim=1, keepdim=True)
+        identity_warp_err = (tgt_img-ref_img).abs().mean(dim=1, keepdim=True)
+        auto_mask = (diff_color<identity_warp_err).float()
+    
+        diff_img = (tgt_img-ref_img_warped).abs().clamp(0,1)
+        if not self.no_ssim:
+            ssim_map = self.ssim_loss(tgt_img, ref_img_warped)
+            diff_img = (0.15 * diff_img + 0.85 * ssim_map)
+        diff_img = torch.mean(diff_img, dim=1, keepdim=True)
+
+        # reduce photometric loss weight for dynamic regions
+        if not self.no_dynamic_mask:
+            weight_mask = (1-diff_depth)
+            diff_img = diff_img * weight_mask
+
+        return diff_img, diff_color, diff_depth, valid_mask, auto_mask
+
+    # compute mean value on a binary mask
+    def mean_on_mask(self, diff, valid_mask):
+        mask = valid_mask.expand_as(diff)
+        # if mask.sum() > 100:
+        #     mean_value = (diff * mask).sum() / mask.sum()
+        # else:
+        #     mean_value = torch.tensor(0).float().to(device)
+        mean_value = (diff * mask).sum() / (mask.sum() + 1e-6)
+        return mean_value
+
+    
+    def forward(self, input, ref_input, prediction, ref_prediction, intrinsic, **kwargs):
+        photo_loss, geometry_loss, dynamic_mask = self.photo_and_geometry_loss(
+            tgt_img=input, 
+            ref_imgs=ref_input, 
+            tgt_depth=prediction, 
+            ref_depths=ref_prediction,
+            intrinsics=intrinsic, 
+            poses=kwargs['pose'], 
+            poses_inv=kwargs['inv_pose'])
+        loss = self.loss_weight_geometry * geometry_loss + self.loss_weight_photo * photo_loss
+        if torch.isnan(loss).item() | torch.isinf(loss).item():
+            raise RuntimeError(f'VNL error, {loss}')
+        return loss * self.total_loss_weight
+
+
+
+
+
+
+
+
+# def compute_smooth_loss(tgt_depth, tgt_img):
+#     def get_smooth_loss(disp, img):
+#         """
+#         Computes the smoothness loss for a disparity image
+#         The color image is used for edge-aware smoothness
+#         """
+
+#         # normalize
+#         mean_disp = disp.mean(2, True).mean(3, True)
+#         norm_disp = disp / (mean_disp + 1e-7)
+#         disp = norm_disp
+
+#         grad_disp_x = torch.abs(disp[:, :, :, :-1] - disp[:, :, :, 1:])
+#         grad_disp_y = torch.abs(disp[:, :, :-1, :] - disp[:, :, 1:, :])
+
+#         grad_img_x = torch.mean(torch.abs(img[:, :, :, :-1] - img[:, :, :, 1:]), 1, keepdim=True)
+#         grad_img_y = torch.mean(torch.abs(img[:, :, :-1, :] - img[:, :, 1:, :]), 1, keepdim=True)
+
+#         grad_disp_x *= torch.exp(-grad_img_x)
+#         grad_disp_y *= torch.exp(-grad_img_y)
+
+#         return grad_disp_x.mean() + grad_disp_y.mean()
+
+#     loss = get_smooth_loss(tgt_depth, tgt_img)
+
+#     return loss
+
+
+# @torch.no_grad()
+# def compute_errors(gt, pred, dataset):
+#     # pred : b c h w
+#     # gt: b h w
+
+#     abs_diff = abs_rel = sq_rel = log10 = rmse = rmse_log = a1 = a2 = a3 = 0.0
+
+#     batch_size, h, w = gt.size()
+    
+#     if pred.nelement() != gt.nelement():
+#         pred = F.interpolate(pred, [h,w], mode='bilinear', align_corners=False)
+#         # pred = F.interpolate(pred, [h,w], mode='nearest')
+
+#     pred = pred.view(batch_size, h, w)
+
+#     if dataset == 'kitti':
+#         crop_mask = gt[0] != gt[0]
+#         y1, y2 = int(0.40810811 * gt.size(1)), int(0.99189189 * gt.size(1))
+#         x1, x2 = int(0.03594771 * gt.size(2)), int(0.96405229 * gt.size(2))
+#         crop_mask[y1:y2, x1:x2] = 1
+#         max_depth = 80
+
+#     if dataset == 'cs':
+#         crop_mask = gt[0] != gt[0]
+#         crop_mask[256:, 192:1856] = 1
+#         max_depth = 80
+
+#     if dataset == 'nyu':
+#         crop_mask = gt[0] != gt[0]
+#         crop = np.array([45, 471, 41, 601]).astype(np.int32)
+#         crop_mask[crop[0]:crop[1], crop[2]:crop[3]] = 1
+#         max_depth = 10
+
+#     if dataset == 'bonn':
+#         crop_mask = gt[0] != gt[0]
+#         crop_mask[:,:] = 1
+#         max_depth = 10
+
+#     if dataset == 'ddad':
+#         crop_mask = gt[0] != gt[0]
+#         crop_mask[:,:] = 1
+#         max_depth = 200
+
+#     min_depth = 1e-3
+#     for current_gt, current_pred in zip(gt, pred):
+#         valid = (current_gt > min_depth) & (current_gt < max_depth)
+#         valid = valid & crop_mask
+
+#         valid_gt = current_gt[valid]
+#         valid_pred = current_pred[valid]
+
+#         # align scale
+#         valid_pred = valid_pred * torch.median(valid_gt)/torch.median(valid_pred)
+
+#         valid_pred = valid_pred.clamp(min_depth, max_depth)
+
+#         thresh = torch.max((valid_gt / valid_pred), (valid_pred / valid_gt))
+#         a1 += (thresh < 1.25).float().mean()
+#         a2 += (thresh < 1.25 ** 2).float().mean()
+#         a3 += (thresh < 1.25 ** 3).float().mean()
+
+#         diff_i = valid_gt - valid_pred
+#         abs_diff += torch.mean(torch.abs(diff_i))
+#         abs_rel += torch.mean(torch.abs(diff_i) / valid_gt)
+#         sq_rel += torch.mean(((diff_i)**2) / valid_gt)
+#         rmse += torch.sqrt(torch.mean(diff_i ** 2))
+#         rmse_log += torch.sqrt(torch.mean((torch.log(valid_gt) - torch.log(valid_pred)) ** 2))
+#         log10 += torch.mean(torch.abs((torch.log10(valid_gt) - torch.log10(valid_pred))))
+
+#     return [metric.item() / batch_size for metric in [abs_diff, abs_rel, sq_rel, log10, rmse, rmse_log, a1, a2, a3]]

external/Metric3D/training/mono/model/model_pipelines/__init__.py

@@ -0,0 +1,6 @@
+from .model_pipeline import EncoderDecoder
+from .dense_pipeline import DensePredModel
+
+__all__ = [
+    'EncoderDecoder', 'DensePredModel'
+]

external/Metric3D/training/mono/model/model_pipelines/dense_pipeline.py

@@ -0,0 +1,27 @@
+import torch
+import torch.nn as nn
+from mono.utils.comm import get_func
+
+
+class DensePredModel(nn.Module):
+    def __init__(self, cfg):
+        super(DensePredModel, self).__init__()
+
+        self.encoder = get_func('mono.model.' + cfg.model.backbone.prefix + cfg.model.backbone.type)(**cfg.model.backbone)
+        self.decoder = get_func('mono.model.' + cfg.model.decode_head.prefix + cfg.model.decode_head.type)(cfg)
+        # try:
+        #     decoder_compiled = torch.compile(decoder, mode='max-autotune')
+        #     "Decoder compile finished"
+        #     self.decoder = decoder_compiled
+        # except:
+        #     "Decoder compile failed, use default setting"
+        #     self.decoder = decoder
+
+        self.training = True
+    
+    def forward(self, input, **kwargs):
+        # [f_32, f_16, f_8, f_4]
+        features = self.encoder(input)
+        # [x_32, x_16, x_8, x_4, x, ...]
+        out = self.decoder(features, **kwargs)
+        return out

external/Metric3D/training/mono/model/model_pipelines/model_pipeline.py

@@ -0,0 +1,34 @@
+import torch
+import torch.nn as nn
+from mono.utils.comm import get_func
+
+
+class EncoderDecoder(nn.Module):
+    def __init__(self, cfg):
+        super(EncoderDecoder, self).__init__()
+
+        self.encoder = get_func('mono.model.' + cfg.model.backbone.prefix + cfg.model.backbone.type)(**cfg.model.backbone)
+        self.decoder = get_func('mono.model.' + cfg.model.decode_head.prefix + cfg.model.decode_head.type)(cfg)
+
+        self.depth_out_head = DepthOutHead(method=cfg.model.depth_out_head.method, **cfg)
+        self.training = True
+    
+    def forward(self, input, **kwargs):
+        # [f_32, f_16, f_8, f_4]
+        features = self.encoder(input)
+        # [x_32, x_16, x_8, x_4, x, ...]
+        decode_list = self.decoder(features)
+
+        pred, conf, logit, bins_edges = self.depth_out_head([decode_list[4], ])
+
+        auxi_preds = None
+        auxi_logits = None
+        out = dict(
+            prediction=pred[0], 
+            confidence=conf[0], 
+            pred_logit=logit[0],
+            auxi_pred=auxi_preds, 
+            auxi_logit_list=auxi_logits,
+            bins_edges=bins_edges[0],
+        )
+        return out

external/Metric3D/training/mono/model/monodepth_model.py

@@ -0,0 +1,45 @@
+import torch
+import torch.nn as nn
+from mono.utils.comm import get_func
+from .__base_model__ import BaseDepthModel
+
+class DepthModel(BaseDepthModel):
+    def __init__(self, cfg, criterions, **kwards):
+        super(DepthModel, self).__init__(cfg, criterions)   
+        model_type = cfg.model.type
+        self.training = True
+        
+    # def inference(self, data):
+    #     with torch.no_grad():
+    #         pred_depth, _, confidence = self.inference(data)       
+    #     return pred_depth, confidence
+
+          
+def get_monodepth_model(
+    cfg : dict,
+    criterions: dict,
+    **kwargs
+    ) -> nn.Module:
+    # config depth  model
+    model = DepthModel(cfg, criterions, **kwargs)
+    #model.init_weights(load_imagenet_model, imagenet_ckpt_fpath)
+    assert isinstance(model, nn.Module)
+    return model
+
+
+def get_configured_monodepth_model(
+    cfg: dict,
+    criterions: dict,
+    ) -> nn.Module:
+    """
+        Args:
+        @ configs: configures for the network.
+        @ load_imagenet_model: whether to initialize from ImageNet-pretrained model.
+        @ imagenet_ckpt_fpath: string representing path to file with weights to initialize model with.
+        Returns:
+        # model: depth model.
+    """
+    model = get_monodepth_model(cfg, criterions)
+    return model
+
+

external/Metric3D/training/mono/scripts/test_scripts/test_vit.sh

@@ -0,0 +1,5 @@
+cd ../../../
+
+python  mono/tools/test.py \
+        mono/configs/test_configs_vit_small/ibims.vit.dpt.raft.py \
+        --load-from vit_small_step00800000.pth

external/Metric3D/training/mono/scripts/train_scripts/train.sh

@@ -0,0 +1,7 @@
+cd ../../../
+
+python  mono/tools/train.py \
+        mono/configs/RAFTDecoder/vit.raft5.small.sanity_check.py \
+        --use-tensorboard \
+        --launcher slurm \
+        --experiment_name set1

external/Metric3D/training/mono/scripts/train_scripts/train_kitti.sh

@@ -0,0 +1,8 @@
+cd ../../../
+
+python  mono/tools/train.py \
+        mono/configs/RAFTDecoder/vit.raft5.large.kitti.py \
+        --use-tensorboard \
+        --launcher slurm \
+        --load-from Path_to_Checkpoint.pth \
+        --experiment_name set1