vto conversion, some progress, not working properl

configs/abl_norm.py

@@ -1,192 +0,0 @@
-from utils.convnext_utils import CNBlockConfig
-
-config = dict()
-
-config['gpu'] = '0'
-config['name'] = 'abl_torch_norm'
-config['notes'] = ''
-config['tags'] = ['iccv', 'abl_norm', 'torch']
-config['script'] = 'scripts/cvae.py'
-
-config['pretrained_model'] = ''
-
-config['use_skinning'] =              True # and deshaping
-config['remove_global_orientation'] = True
-config['use_normals'] =             True
-config['use_extra_losses'] =          True # edge, collision, 3d mesh
-config['use_offsets'] =               True
-
-config['use_norm_loss'] =             True
-
-ablation_count = [config['use_skinning'], config['remove_global_orientation'], config['use_normals'], config['use_extra_losses'], config['use_offsets']].count(False)
-assert ablation_count == 1 or ablation_count == 0
-
-config['avg_garment_path'] = 'custom_data/avg/train_no_shape_avg_uv.npy' #custom_data/train_no_shape_avg_uv.npy # train_no_shape_avg_uv  train_no_shape_one_hot_avg_uv
-if config['use_skinning']:
-  assert (config['use_offsets'] and config['avg_garment_path'] != '') or (not config['use_offsets'] and config['avg_garment_path'] == '')
-
-config['reg_loss_coeff'] = 0.1 # set to 0 if don't want to use edge+collision
-
-config['batch_size'] = 4
-config['resolution'] = 512
-config['is_skirt'] = False
-config['dataset_in_memory'] = False
-config['is_cape'] = False
-config['device'] = 'cuda'
-
-config['train_dir'] = '/data-local/127/train'
-config['valid_dir'] = '/data-local/127/valid'
-config['test_dir'] = '/data-net/dataset/test_ready'
-config['train_frames'] = None
-config['valid_frames'] = None
-
-config['static_model'] = 'checkpoints/iccv/static_torch_orig_2'
-config['body_model'] = 'checkpoints/iccv/body_torch_1'
-config['normals_model'] = 'checkpoints/iccv/torch/norm_torch_1'
-
-config['smpl_res'] = 14475
-if config['is_cape']:
-  config['smpl_res'] = 3638
-
-config['latent_dim'] = 128
-
-###############    
-config['lr'] = 0.0001#                 0.0001
-###############
-config['starting_balancing_coeff'] = 0.0001
-
-config['signature']: set = { 'id',
-                            'frame_nr',
-                            'pose_shape',
-                            'uv_body_posed',
-                            'mesh_body_posed',
-                            'mesh_posed',
-                            'uv_normals',
-                            'uv_static',
-                            'mesh_mask',
-                            'uv_mask',
-                        }
-
-if config['use_skinning']:
-  config['signature'].add('uv_unposed')
-  config['signature'].add('mesh_unposed')
-else:
-  config['signature'].add('uv_posed')
-
-config['upscale_enhancer'] = ''
-config['freeze_encoders'] = True
-config['use_one_hot'] = False
-config['bottleneck_scale'] = 2
-
-config['cvae'] = dict()
-config['cvae']['device'] = config['device']
-config['cvae']['is_label'] = False
-config['cvae']['input_features'] = 3+3+3+3 if config['use_normals'] else 3+3+3
-config['cvae']['kernel_size'] = 7
-config['cvae']['bottleneck_size'] = 64 * config['bottleneck_scale']
-config['cvae']['latent_dim'] = config['cvae']['bottleneck_size']
-
-block_setting = [
-    CNBlockConfig(32, 64, 3),
-    CNBlockConfig(64, 128, 3),
-    CNBlockConfig(128, 256, 3),
-    CNBlockConfig(256, config['cvae']['bottleneck_size'], 9),
-    CNBlockConfig(config['cvae']['bottleneck_size'], None, 3),
-]
-
-block_setting_reverse = [
-    CNBlockConfig(config['cvae']['bottleneck_size'] * 2, 256, 3),
-    CNBlockConfig(256, 128, 9),
-    CNBlockConfig(128, 64, 9),
-    CNBlockConfig(64, 32, 3),
-    CNBlockConfig(32, 3, 3),
-]
-
-config['cvae']['encoder_block_settings'] = block_setting
-config['cvae']['decoder_block_settings'] = block_setting_reverse
-
-
-
-####################### cond_ae_norm ############################
-config['cond_ae_norm'] = dict()
-config['cond_ae_norm']['device'] = config['device']
-config['cond_ae_norm']['is_label'] = True
-config['cond_ae_norm']['latent_dim'] = config['latent_dim']
-config['cond_ae_norm']['kernel_size'] = 7
-config['cond_ae_norm']['bottleneck_size'] = 40 * config['bottleneck_scale']
-
-block_setting = [
-    CNBlockConfig(16, 32, 3),
-    CNBlockConfig(32, 64, 3),
-    CNBlockConfig(64, 128, 9),
-    CNBlockConfig(128, config['cond_ae_norm']['bottleneck_size'], 9),
-    CNBlockConfig(config['cond_ae_norm']['bottleneck_size'], None, 3),
-]
-
-block_setting_reverse = [
-    CNBlockConfig(config['cond_ae_norm']['bottleneck_size'], 128, 3),
-    CNBlockConfig(128, 64, 9),
-    CNBlockConfig(64, 32, 9),
-    CNBlockConfig(32, 16, 3),
-    CNBlockConfig(16, 3, 3),
-]
-
-config['cond_ae_norm']['encoder_block_settings'] = block_setting
-config['cond_ae_norm']['decoder_block_settings'] = block_setting_reverse
-config['cond_ae_norm']['activation'] = 'tanh'
-
-####################### cond_ae_body ############################
-config['cond_ae_body'] = dict()
-config['cond_ae_body']['device'] = config['device']
-config['cond_ae_body']['is_label'] = False
-config['cond_ae_body']['latent_dim'] = config['latent_dim']
-config['cond_ae_body']['kernel_size'] = 7
-config['cond_ae_body']['bottleneck_size'] = 16 * config['bottleneck_scale']
-
-block_setting = [
-    CNBlockConfig(16, 32, 3),
-    CNBlockConfig(32, 64, 3),
-    CNBlockConfig(64, 128, 9),
-    CNBlockConfig(128, config['cond_ae_body']['bottleneck_size'], 9),
-    CNBlockConfig(config['cond_ae_body']['bottleneck_size'], None, 3),
-]
-
-block_setting_reverse = [
-    CNBlockConfig(config['cond_ae_body']['bottleneck_size'], 128, 3),
-    CNBlockConfig(128, 64, 9),
-    CNBlockConfig(64, 32, 9),
-    CNBlockConfig(32, 16, 3),
-    CNBlockConfig(16, 3, 3),
-]
-
-config['cond_ae_body']['encoder_block_settings'] = block_setting
-config['cond_ae_body']['decoder_block_settings'] = block_setting_reverse
-config['cond_ae_body']['activation'] = 'tanh'
-
-####################### cond_ae_static ############################
-config['cond_ae_static'] = dict()
-config['cond_ae_static']['device'] = config['device']
-config['cond_ae_static']['is_label'] = False
-config['cond_ae_static']['latent_dim'] = config['latent_dim']
-config['cond_ae_static']['kernel_size'] = 7
-config['cond_ae_static']['bottleneck_size'] = 8 * config['bottleneck_scale']
-
-block_setting = [
-    CNBlockConfig(8, 16, 3),
-    CNBlockConfig(16, 32, 3),
-    CNBlockConfig(32, 64, 3),
-    CNBlockConfig(64, config['cond_ae_static']['bottleneck_size'], 9),
-    CNBlockConfig(config['cond_ae_static']['bottleneck_size'], None, 3),
-]
-
-block_setting_reverse = [
-    CNBlockConfig(config['cond_ae_static']['bottleneck_size'], 64, 3),
-    CNBlockConfig(64, 32, 9),
-    CNBlockConfig(32, 16, 3),
-    CNBlockConfig(16, 8, 3),
-    CNBlockConfig(8, 3, 3),
-]
-
-config['cond_ae_static']['encoder_block_settings'] = block_setting
-config['cond_ae_static']['decoder_block_settings'] = block_setting_reverse
-config['cond_ae_static']['activation'] = 'tanh'

configs/ae_norm_1.py

@@ -1,73 +0,0 @@
-from utils.convnext_utils import CNBlockConfig
-
-config = dict()
-
-config['gpu'] = '0'
-config['name'] = 'norm_torch_2'
-config['notes'] = ' ' 
-config['tags'] = ['torch', 'norm'] 
-config['script'] = 'scripts/ae_norm_train.py'
-
-config['pretrained_model'] = ''
-
-config['batch_size'] = 4
-config['train_dir'] = '/data-local/127/train'
-config['valid_dir'] = '/data-local/127/valid'
-config['test_dir'] = '/data-net/dataset/test_ready'
-config['train_frames'] = None
-config['valid_frames'] = None
-
-config['resolution'] = 512
-config['is_skirt'] = False
-config['dataset_in_memory'] = False
-config['is_cape'] = False
-config['remove_global_orientation'] = True
-config['device'] = 'cuda'
-
-config['smpl_res'] = 14475
-if config['is_cape']:
-  config['smpl_res'] = 3638
-
-config['latent_dim'] = 128
-
-config['bottleneck_scale'] = 2
-
-config['cond_ae'] = dict()
-config['cond_ae']['device'] = config['device']
-config['cond_ae']['is_label'] = False
-config['cond_ae']['latent_dim'] = config['latent_dim']
-config['cond_ae']['kernel_size'] = 7
-config['cond_ae']['bottleneck_size'] = 40 * config['bottleneck_scale']
-
-block_setting = [
-    CNBlockConfig(16, 32, 3),
-    CNBlockConfig(32, 64, 3),
-    CNBlockConfig(64, 128, 9),
-    CNBlockConfig(128, config['cond_ae']['bottleneck_size'], 9),
-    CNBlockConfig(config['cond_ae']['bottleneck_size'], None, 3),
-]
-
-block_setting_reverse = [
-    CNBlockConfig(config['cond_ae']['bottleneck_size'], 128, 3),
-    CNBlockConfig(128, 64, 9),
-    CNBlockConfig(64, 32, 9),
-    CNBlockConfig(32, 16, 3),
-    CNBlockConfig(16, 3, 3),
-    # CNBlockConfig(3, 3, 3),
-]
-
-config['cond_ae']['encoder_block_settings'] = block_setting
-config['cond_ae']['decoder_block_settings'] = block_setting_reverse
-config['cond_ae']['activation'] = 'tanh'
-
-
-config['lr'] = 0.0001
-config['cond_ae']['upscale_output'] = False
-
-config['signature'] = { 'id',
-                        'frame_nr',
-                        'uv_mask',
-                        'uv_normals',
-                        'mesh_mask',
-                        'mesh_normals',
-                        }

configs/cvae_norm_1.py

@@ -1,172 +0,0 @@
-from utils.convnext_utils import CNBlockConfig
-
-config = dict()
-
-config['gpu'] = '0'
-config['name'] = 'cvae_norm_1'
-config['notes'] = ''
-config['tags'] = ['iccv', 'cvae_norm', 'torch']
-config['script'] = 'scripts/cvae_norm.py'
-
-config['pretrained_model'] = ''
-
-
-config['reg_loss_coeff'] = 0.1 # set to 0 if don't want to use edge+collision
-
-config['batch_size'] = 4
-config['resolution'] = 512
-config['is_skirt'] = False
-config['dataset_in_memory'] = False
-config['is_cape'] = False
-config['device'] = 'cuda'
-
-config['train_dir'] = '/data-local/127/train'
-config['valid_dir'] = '/data-local/127/valid'
-config['test_dir'] = '/data-net/dataset/test_ready'
-config['train_frames'] = None
-config['valid_frames'] = None
-
-config['static_model'] = 'checkpoints/iccv/static_torch_orig_2'
-config['body_model'] = 'checkpoints/iccv/body_torch_1'
-
-config['smpl_res'] = 14475
-if config['is_cape']:
-  config['smpl_res'] = 3638
-
-config['latent_dim'] = 128
-
-###############    
-config['lr'] = 0.0001#                 0.0001
-###############
-config['starting_balancing_coeff'] = 0.0001
-
-config['signature']: set = { 'id',
-                            'frame_nr',
-                            'pose_shape',
-                            'uv_body_posed',
-                            'uv_normals',
-                            'uv_static',
-                            'mesh_mask',
-                            'uv_mask',
-                            'mesh_normals',
-                        }
-
-
-
-config['upscale_enhancer'] = ''
-config['freeze_encoders'] = True
-config['use_one_hot'] = False
-config['bottleneck_scale'] = 2
-
-config['cvae'] = dict()
-config['cvae']['device'] = config['device']
-config['cvae']['is_label'] = False
-config['cvae']['input_features'] = 3+3+3
-config['cvae']['kernel_size'] = 7
-config['cvae']['bottleneck_size'] = 64 * config['bottleneck_scale']
-config['cvae']['latent_dim'] = config['cvae']['bottleneck_size']
-
-block_setting = [
-    CNBlockConfig(32, 64, 3),
-    CNBlockConfig(64, 128, 3),
-    CNBlockConfig(128, 256, 3),
-    CNBlockConfig(256, config['cvae']['bottleneck_size'], 9),
-    CNBlockConfig(config['cvae']['bottleneck_size'], None, 3),
-]
-
-block_setting_reverse = [
-    CNBlockConfig(176, 256, 3),
-    CNBlockConfig(256, 128, 9),
-    CNBlockConfig(128, 64, 9),
-    CNBlockConfig(64, 32, 3),
-    CNBlockConfig(32, 3, 3),
-]
-
-config['cvae']['encoder_block_settings'] = block_setting
-config['cvae']['decoder_block_settings'] = block_setting_reverse
-
-
-
-####################### cond_ae_curv ############################
-config['cond_ae_curv'] = dict()
-config['cond_ae_curv']['device'] = config['device']
-config['cond_ae_curv']['is_label'] = True
-config['cond_ae_curv']['latent_dim'] = config['latent_dim']
-config['cond_ae_curv']['kernel_size'] = 7
-config['cond_ae_curv']['bottleneck_size'] = 40 * config['bottleneck_scale']
-
-block_setting = [
-    CNBlockConfig(16, 32, 3),
-    CNBlockConfig(32, 64, 3),
-    CNBlockConfig(64, 128, 9),
-    CNBlockConfig(128, config['cond_ae_curv']['bottleneck_size'], 9),
-    CNBlockConfig(config['cond_ae_curv']['bottleneck_size'], None, 3),
-]
-
-block_setting_reverse = [
-    CNBlockConfig(config['cond_ae_curv']['bottleneck_size'], 128, 3),
-    CNBlockConfig(128, 64, 9),
-    CNBlockConfig(64, 32, 9),
-    CNBlockConfig(32, 16, 3),
-    CNBlockConfig(16, 3, 3),
-]
-
-config['cond_ae_curv']['encoder_block_settings'] = block_setting
-config['cond_ae_curv']['decoder_block_settings'] = block_setting_reverse
-config['cond_ae_curv']['activation'] = 'tanh'
-
-####################### cond_ae_body ############################
-config['cond_ae_body'] = dict()
-config['cond_ae_body']['device'] = config['device']
-config['cond_ae_body']['is_label'] = False
-config['cond_ae_body']['latent_dim'] = config['latent_dim']
-config['cond_ae_body']['kernel_size'] = 7
-config['cond_ae_body']['bottleneck_size'] = 16 * config['bottleneck_scale']
-
-block_setting = [
-    CNBlockConfig(16, 32, 3),
-    CNBlockConfig(32, 64, 3),
-    CNBlockConfig(64, 128, 9),
-    CNBlockConfig(128, config['cond_ae_body']['bottleneck_size'], 9),
-    CNBlockConfig(config['cond_ae_body']['bottleneck_size'], None, 3),
-]
-
-block_setting_reverse = [
-    CNBlockConfig(config['cond_ae_body']['bottleneck_size'], 128, 3),
-    CNBlockConfig(128, 64, 9),
-    CNBlockConfig(64, 32, 9),
-    CNBlockConfig(32, 16, 3),
-    CNBlockConfig(16, 3, 3),
-]
-
-config['cond_ae_body']['encoder_block_settings'] = block_setting
-config['cond_ae_body']['decoder_block_settings'] = block_setting_reverse
-config['cond_ae_body']['activation'] = 'tanh'
-
-####################### cond_ae_static ############################
-config['cond_ae_static'] = dict()
-config['cond_ae_static']['device'] = config['device']
-config['cond_ae_static']['is_label'] = False
-config['cond_ae_static']['latent_dim'] = config['latent_dim']
-config['cond_ae_static']['kernel_size'] = 7
-config['cond_ae_static']['bottleneck_size'] = 8 * config['bottleneck_scale']
-
-block_setting = [
-    CNBlockConfig(8, 16, 3),
-    CNBlockConfig(16, 32, 3),
-    CNBlockConfig(32, 64, 3),
-    CNBlockConfig(64, config['cond_ae_static']['bottleneck_size'], 9),
-    CNBlockConfig(config['cond_ae_static']['bottleneck_size'], None, 3),
-]
-
-block_setting_reverse = [
-    CNBlockConfig(config['cond_ae_static']['bottleneck_size'], 64, 3),
-    CNBlockConfig(64, 32, 9),
-    CNBlockConfig(32, 16, 3),
-    CNBlockConfig(16, 8, 3),
-    CNBlockConfig(8, 3, 3),
-]
-
-config['cond_ae_static']['encoder_block_settings'] = block_setting
-config['cond_ae_static']['decoder_block_settings'] = block_setting_reverse
-config['cond_ae_static']['activation'] = 'tanh'

configs/direct_1.py

@@ -0,0 +1,77 @@
+from utils.convnext_utils import CNBlockConfig
+
+config = dict()
+
+config['gpu'] = '5'
+config['name'] = 'direct_1'
+config['notes'] = ' ' 
+config['tags'] = ['torch', 'direct'] 
+config['script'] = 'scripts/direct_train.py'
+
+config['pretrained_model'] = ''
+config['use_curvature'] = False
+
+config['batch_size'] = 4
+config['train_dir'] = '/data-local/127/train'
+config['valid_dir'] = '/data-local/127/valid'
+config['test_dir'] = '/data-net/dataset/test_ready'
+config['train_frames'] = None
+config['valid_frames'] = None
+
+config['resolution'] = 512
+config['is_skirt'] = False
+config['dataset_in_memory'] = False
+config['is_cape'] = False
+config['remove_global_orientation'] = True
+config['device'] = 'cuda'
+config['input_features'] = 6
+
+config['smpl_res'] = 14475
+if config['is_cape']:
+  config['smpl_res'] = 3638
+
+config['latent_dim'] = 128
+
+config['bottleneck_scale'] = 2
+
+config['is_label'] = False
+config['kernel_size'] = 7
+config['bottleneck_size'] = 64 * config['bottleneck_scale']
+
+block_setting = [
+    CNBlockConfig(16, 32, 3),
+    CNBlockConfig(32, 128, 3),
+    CNBlockConfig(128, 256, 9),
+    CNBlockConfig(256, config['bottleneck_size'], 9),
+    CNBlockConfig(config['bottleneck_size'], None, 3),
+]
+
+block_setting_reverse = [
+    CNBlockConfig(config['bottleneck_size'], 256, 3),
+    CNBlockConfig(256, 128, 9),
+    CNBlockConfig(128, 32, 9),
+    CNBlockConfig(32, 16, 3),
+    CNBlockConfig(16, 3, 3),
+    # CNBlockConfig(3, 3, 3),
+]
+
+config['encoder_block_settings'] = block_setting
+config['decoder_block_settings'] = block_setting_reverse
+config['activation'] = 'tanh'
+
+
+config['lr'] = 0.0001
+config['reg_loss_coeff'] = 0.1
+
+config['signature'] = { 'id',
+                        'frame_nr',
+                        'pose_shape',
+                        'uv_body_posed',
+                        'mesh_mask',
+                        'mesh_body_posed',
+                        'mesh_posed',
+                        'uv_unposed',
+                        'mesh_unposed',
+                        'uv_static',
+                        'uv_mask',
+                        }

configs/direct_2.py

@@ -0,0 +1,78 @@
+from utils.convnext_utils import CNBlockConfig
+
+config = dict()
+
+config['gpu'] = '0'
+config['name'] = 'direct_2'
+config['notes'] = 'with curvature input' 
+config['tags'] = ['torch', 'direct'] 
+config['script'] = 'scripts/direct_train.py'
+
+config['pretrained_model'] = ''
+config['use_curvature'] = True
+
+config['batch_size'] = 4
+config['train_dir'] = '/data-local/127/train'
+config['valid_dir'] = '/data-local/127/valid'
+config['test_dir'] = '/data-net/dataset/test_ready'
+config['train_frames'] = None
+config['valid_frames'] = None
+
+config['resolution'] = 512
+config['is_skirt'] = False
+config['dataset_in_memory'] = False
+config['is_cape'] = False
+config['remove_global_orientation'] = True
+config['device'] = 'cuda'
+config['input_features'] = 10
+
+config['smpl_res'] = 14475
+if config['is_cape']:
+  config['smpl_res'] = 3638
+
+config['latent_dim'] = 128
+
+config['bottleneck_scale'] = 2
+
+config['is_label'] = False
+config['kernel_size'] = 7
+config['bottleneck_size'] = 64 * config['bottleneck_scale']
+
+block_setting = [
+    CNBlockConfig(16, 32, 3),
+    CNBlockConfig(32, 128, 3),
+    CNBlockConfig(128, 256, 9),
+    CNBlockConfig(256, config['bottleneck_size'], 9),
+    CNBlockConfig(config['bottleneck_size'], None, 3),
+]
+
+block_setting_reverse = [
+    CNBlockConfig(config['bottleneck_size'], 256, 3),
+    CNBlockConfig(256, 128, 9),
+    CNBlockConfig(128, 32, 9),
+    CNBlockConfig(32, 16, 3),
+    CNBlockConfig(16, 3, 3),
+    # CNBlockConfig(3, 3, 3),
+]
+
+config['encoder_block_settings'] = block_setting
+config['decoder_block_settings'] = block_setting_reverse
+config['activation'] = 'tanh'
+
+
+config['lr'] = 0.0001
+config['reg_loss_coeff'] = 0.1
+
+config['signature'] = { 'id',
+                        'frame_nr',
+                        'pose_shape',
+                        'uv_curvature',
+                        'mesh_mask',
+                        'mesh_body_posed',
+                        'mesh_posed',
+                        'uv_unposed',
+                        'mesh_unposed',
+                        'uv_static',
+                        'uv_mask',
+                        'uv_body_posed',
+                        }

custom_utils/custom_utils.py

@@ -43,6 +43,7 @@ class UV2Mesh(nn.Module):
         if uv.shape[1] == 3 or uv.shape[1] == 7:
             uv = torch.permute(uv, [0,2,3,1])
         if uv.shape[1] != 512:
+            raise NotImplementedError
             uv = Resize(uv[:,:,None], size=(512, 256), interpolation=InterpolationMode.BILINEAR)
             
         # batch_size = uv.shape[0]

data/calculate_normals.py

@@ -1,112 +0,0 @@
-import os
-import sys
-import numpy as np
-import trimesh as tm
-import scipy.io as sio
-import plotly.graph_objects as go
-import plotly.express as px
-from tqdm import tqdm
-import torch
-from scipy.spatial.transform import Rotation as R
-import argparse
-
-sys.path.append(os.path.dirname(os.path.abspath(__file__)) + '/..')
-
-from data.cloth3d_io import readOBJ, readPC2
-from data.utils import Frame
-from smpl.smpl_torch import SMPL
-
-
-def calculate_normals(vertices, mesh_file, poses):
-    _, faces, _, _ = readOBJ(mesh_file)
-    rodr = smpl.rodrigues(torch.tensor(poses.T.reshape(-1, 1, 3), dtype=torch.float32)).numpy().reshape(vertices.shape[0], -1, 3, 3)
-
-    normals = []
-    for i in range(vertices.shape[0]):
-        r = R.from_matrix(rodr[i, 0, :, :])
-        # assert r.as_matrix() == rodr[frame, 0, :, :]
-        out = r.apply(vertices[i], inverse=True)
-
-        # create a plotly mesh plot of out and vertices [i]
-        # fig = go.Figure(data=[
-        #     go.Mesh3d(
-        #         x=out[:, 0], y=out[:, 2], z=out[:, 1],
-        #         # i, j and k give the vertices of triangles
-        #         i=faces[:, 0], j=faces[:, 1], k=faces[:, 2],
-        #         name='y',
-        #         showscale=False
-        #     ),
-        #     go.Mesh3d(
-        #         x=vertices[i][:, 0], y=vertices[i][:, 1], z=vertices[i][:, 2],
-        #         # i, j and k give the vertices of triangles
-        #         i=faces[:, 0], j=faces[:, 1], k=faces[:, 2],
-        #         name='x',
-        #         showscale=False
-        #     )
-        # ])
-        # fig.show()
-    
-        mesh = tm.Trimesh(vertices=out, faces=faces, process=False, validate=False)
-        normals.append(mesh.vertex_normals)
-    return np.stack(normals)
-
-
-def get_frames(folder):
-    uv_static_folder = os.path.join(folder, 'pose_shape') 
-    frames = sorted(os.listdir(uv_static_folder))
-
-    frames = [frame.split('.')[0] for frame in frames] # .split('_')[0]
-    frames = [Frame(frame.split('_')[0], frame.split('_')[1]) for frame in frames]
-    return frames
-
-
-if __name__ == '__main__':
-    parser = argparse.ArgumentParser()
-    parser.add_argument("-f", "--folder", help = "end of range", default='/data-net/dataset/00761')
-    parser.add_argument("-f_obj", "--folder_object", help = "end of range", default='/data-net/dataset/cloth3d/train')
-    parser.add_argument("-s", "--start", help = "start of range", default=0)
-    parser.add_argument("-e", "--end", help = "end of range", default=10)
-    parser.add_argument("-n", "--name", help = "end of range", default='lhunor')
-    args = parser.parse_args()
-
-    obj_folder = args.folder_object # '/data-net/dataset/cloth3d/train'
-    folder = args.folder #'/data-local/127/train'
-
-    os.makedirs(os.path.join(folder, 'mesh_normals'), exist_ok=True)
-    frames = get_frames(folder)
-    smpl = SMPL('cpu', 'smpl')
-
-    ids = {frame.id for frame in frames}
-    ids = sorted(list(ids))[int(args.start):int(args.end)]
-
-    for id in tqdm(ids):
-        # find obj files in the folder
-        garment_obj_folder = os.path.join(obj_folder, id[:5])
-        garments = [file.split('.')[0] for file in os.listdir(garment_obj_folder) if file.endswith('.obj')]
-
-        if len(id) == 5:
-            garment = garments[0]
-        elif len(id) == 6:
-            garment = garments[1]
-        else:
-            raise ValueError('Invalid frame id')
-
-        mesh_file = os.path.join(garment_obj_folder, f'{garment}.obj')
-        vertices =readPC2(os.path.join(garment_obj_folder, f'{garment}.pc16'), True)['V']
-        poses = sio.loadmat(os.path.join(garment_obj_folder, f'info.mat'))['poses']
-        normals = calculate_normals(vertices, mesh_file, poses)
-
-        map = sio.loadmat(os.path.join(garment_obj_folder, f'{garment}_map.mat'))['map'][0]
-        mask = np.load(os.path.join(folder, 'mesh_mask', f'{id}.npy'))
-
-        mesh_normals = normals[:,map,:]
-        mesh_normals = mesh_normals * mask[None,:, None]
-
-        for i in range(vertices.shape[0]):
-            # np.savez(os.path.join(folder, 'mesh_normals', f'{id}_{i}.npz'), mesh_normals=mesh_normals)
-            np.savez_compressed(os.path.join(folder, 'mesh_normals', f'{id}_{i}.npz'), mesh_normals=mesh_normals[i])
-
-        # pass
-
-        # print(frame.id, frame.frame_nr)
-

data/cloth3d_io.py

@@ -342,6 +342,7 @@ import sys
 sys.path.append(os.path.dirname(os.path.abspath(__file__)) + '/..')
 
 import plotly.graph_objects as go
+from custom_utils.custom_utils import _maskFaces
 
 def plot_3d(mesh, faces):
     fig = go.Figure()
@@ -369,19 +370,7 @@ def plot_3d(mesh, faces):
     return fig
 
 
-def quads2tris(F):
-    out = []
-    for f in F:
-        if len(f) == 3: out += [f]
-        elif len(f) == 4: out += [[f[0],f[1],f[2]],
-                                [f[0],f[2],f[3]]]
-        else: print("This should not happen...")
-    return np.array(out, np.int32)
-
-
-
 if __name__ == '__main__':
-    from custom_utils.custom_utils import _maskFaces
 
     folder = '/home/workspace/data/dataset/cloth3d/train'
     F = np.load("custom_utils/smpl_faces.npy")#.astype(np.int32)

data/convert_vto.py

@@ -0,0 +1,259 @@
+import numpy as np
+import os
+import sys
+import pickle
+import plotly.express as ex
+import plotly.graph_objects as go
+import torch
+import open3d as o3d
+import trimesh
+# from vedo import trimesh as trimesh_plot
+from scipy.spatial import KDTree
+from scipy.sparse import lil_matrix
+from scipy.optimize import minimize
+
+sys.path.append(os.path.dirname(os.path.abspath(__file__)) + '/..')
+
+from smpl.smpl_torch import SMPL
+
+# import mask faces
+from custom_utils.custom_utils import _maskFaces
+
+smpl = SMPL(path='smpl')
+
+def energy_function(params, source_points, target_points, indices):
+    num_points = source_points.shape[0]
+    num_dims = source_points.shape[1]
+    
+    # Reshape the parameters
+    weights = params[:num_points * num_dims].reshape((num_points, num_dims))
+    translation = params[num_points * num_dims:num_points * num_dims + num_dims]
+    control_points = params[num_points * num_dims + num_dims:].reshape((-1, num_dims))
+    
+    # Compute the transformed source points
+    transformed_points = source_points + np.dot(weights, control_points.T)
+    
+    # Compute the TPS energy
+    tps_energy = 0.5 * np.sum(np.square(target_points[indices] - transformed_points))
+    
+    return tps_energy
+
+def non_rigid(source_points, target_points):
+    tree = KDTree(target_points)
+    distances, indices = tree.query(source_points)
+
+    # Initialize the optimization parameters
+    num_points = source_points.shape[0]
+    num_dims = source_points.shape[1]
+    initial_params = np.zeros(num_points * num_dims + num_dims + num_points)
+
+    # Define the optimization bounds
+    bounds = [(None, None)] * (num_points * num_dims)
+    bounds += [(None, None)] * num_dims
+    bounds += [(None, None)] * (num_points * num_dims)
+
+    # Perform the optimization
+    result = minimize(energy_function, initial_params, method='L-BFGS-B',
+                    args=(source_points, target_points, indices), bounds=bounds)
+
+    # Get the optimized parameters
+    optimized_params = result.x
+
+    # Reshape the parameters
+    optimized_weights = optimized_params[:num_points * num_dims].reshape((num_points, num_dims))
+    optimized_translation = optimized_params[num_points * num_dims:num_points * num_dims + num_dims]
+    optimized_control_points = optimized_params[num_points * num_dims + num_dims:].reshape((-1, num_dims))
+
+    transformed_points = source_points + np.dot(optimized_weights, optimized_control_points.T)
+    return transformed_points
+
+
+def register_smpl():
+    # generate body with zero pose and shape
+    pose = torch.zeros((1, 72))
+    shape = torch.zeros((1, 11))
+    smpl_out = smpl(pose, shape)[0][0]
+
+    with open('/data-net/code/vto-dataset/tshirt/simulations/tshirt_shape00_55_27.pkl', "rb") as f:
+        data = pickle.load(f)
+        garment = data['vertices'][100]
+        faces = data['faces']
+
+    # rotate garment x degrees along y axis
+    # convert degrees to radians
+    degrees = 107
+    theta = degrees * np.pi / 180
+    rot = np.array([[np.cos(theta), 0, np.sin(theta)],
+                    [0, 1, 0],
+                    [-np.sin(theta), 0, np.cos(theta)]])
+    garment = np.dot(rot, garment.T).T
+
+    # rotate garment x degrees along x axis
+    # convert degrees to radians
+    degrees = 5
+    theta = degrees * np.pi / 180
+    rot = np.array([[1, 0, 0],
+                    [0, np.cos(theta), -np.sin(theta)],
+                    [0, np.sin(theta), np.cos(theta)]])
+    garment = np.dot(rot, garment.T).T
+
+    # rotate garment x degrees along z axis
+    # convert degrees to radians
+    degrees = -5
+    theta = degrees * np.pi / 180
+    rot = np.array([[np.cos(theta), -np.sin(theta), 0],
+                    [np.sin(theta), np.cos(theta), 0],
+                    [0, 0, 1]])
+    garment = np.dot(rot, garment.T).T
+
+
+    garment[:,0] -= 0.06
+    garment[:,1] -= 0.03
+    garment[:,2] -= 0.015
+    
+    # visualize the body and garment
+    # fig = go.Figure(data=[go.Mesh3d(x=smpl_out[:,0], y=smpl_out[:,1], z=smpl_out[:,2], i=smpl.f[:,0], j=smpl.f[:,1], k=smpl.f[:,2])])
+    # fig.add_trace(go.Mesh3d(x=garment[:,0], y=garment[:,1], z=garment[:,2], i=faces[:,0], j=faces[:,1], k=faces[:,2]))
+    # fig.update_layout(scene=dict(xaxis=dict(range=[-1,1],), yaxis=dict(range=[-1,1],), zaxis=dict(range=[-1,1],),),)
+    # fig.show()
+
+    # non_rigid(garment, smpl_out.numpy())
+
+    # Load the source and target meshes
+    source_mesh = o3d.geometry.TriangleMesh(o3d.utility.Vector3dVector(garment), o3d.utility.Vector3iVector(faces))
+    target_mesh = o3d.geometry.TriangleMesh(o3d.utility.Vector3dVector(smpl_out), o3d.utility.Vector3iVector(smpl.f))
+    # flip source and target mesh
+    source_mesh, target_mesh = target_mesh, source_mesh
+
+    source_mesh.compute_vertex_normals()
+    source_mesh = source_mesh.filter_smooth_laplacian(number_of_iterations=10)
+    # plot the smoothed mesh with plotly
+    # fig = go.Figure(data=[go.Mesh3d(x=np.asarray(source_mesh.vertices)[:,0], y=np.asarray(source_mesh.vertices)[:,1], z=np.asarray(source_mesh.vertices)[:,2], i=np.asarray(source_mesh.triangles)[:,0], j=np.asarray(source_mesh.triangles)[:,1], k=np.asarray(source_mesh.triangles)[:,2])])
+    # fig.show()
+
+    # Perform initial alignment (translation and/or scaling)
+    # You can modify this step based on your specific needs
+    # For example, you can manually set an initial transformation
+    init_transformation = [[1.0, 0.0, 0.0, 0.0],
+                        [0.0, 1.0, 0.0, 0.0],
+                        [0.0, 0.0, 1.0, 0.0],
+                        [0.0, 0.0, 0.0, 1.0]]
+
+    # Create the ICP object and set the parameters
+    icp = o3d.pipelines.registration.TransformationEstimationPointToPoint()
+    criteria = o3d.pipelines.registration.ICPConvergenceCriteria(max_iteration=2000)
+        
+    # Perform ICP registration
+    reg_result = o3d.pipelines.registration.registration_icp(o3d.geometry.PointCloud(source_mesh.vertices),
+                                                             o3d.geometry.PointCloud(target_mesh.vertices),
+                                                             0.075,
+                                                             init_transformation, icp, criteria)
+
+    # Get the aligned source mesh after registration
+    aligned_mesh = source_mesh.transform(reg_result.transformation)
+
+    # Visualize the aligned mesh and target mesh with plotly
+    fig = go.Figure(data=[go.Mesh3d(x=np.asarray(aligned_mesh.vertices)[:,0], y=np.asarray(aligned_mesh.vertices)[:,1], z=np.asarray(aligned_mesh.vertices)[:,2], i=np.asarray(aligned_mesh.triangles)[:,0], j=np.asarray(aligned_mesh.triangles)[:,1], k=np.asarray(aligned_mesh.triangles)[:,2])])
+    fig.add_trace(go.Mesh3d(x=np.asarray(target_mesh.vertices)[:,0], y=np.asarray(target_mesh.vertices)[:,1], z=np.asarray(target_mesh.vertices)[:,2], i=np.asarray(target_mesh.triangles)[:,0], j=np.asarray(target_mesh.triangles)[:,1], k=np.asarray(target_mesh.triangles)[:,2]))
+    fig.update_layout(scene=dict(xaxis=dict(range=[-1,1],), yaxis=dict(range=[-1,1],), zaxis=dict(range=[-1,1],),),)
+    fig.show()
+
+    # Get the vertices of the aligned source mesh and target mesh
+    aligned_source_vertices = np.asarray(aligned_mesh.vertices)
+    target_vertices = np.asarray(target_mesh.vertices)
+
+    # Perform nearest neighbor search to find corresponding vertex indices
+    kd_tree = o3d.geometry.KDTreeFlann(target_mesh)
+    correspondences = []
+    matched = set()
+    for i in range(len(aligned_source_vertices)):
+        k = 1
+        _, idx, _ = kd_tree.search_knn_vector_3d(aligned_source_vertices[i], k)
+        # while idx[-1] in matched:
+        #     k += 1
+        #     _, idx, _ = kd_tree.search_knn_vector_3d(aligned_source_vertices[i], k)
+        # matched.add(idx[-1])
+        correspondences.append((i, idx[-1]))
+
+    # correspondences is a list of tuples where each tuple contains the corresponding vertex indices
+    # For example, correspondences = [(0, 10), (1, 5), (2, 15), ...]
+
+    # Visualize the correspondences with plotly
+    # fig = go.Figure(data=[go.Scatter3d(x=aligned_source_vertices[:,0], y=aligned_source_vertices[:,1], z=aligned_source_vertices[:,2], mode='markers', marker=dict(color='red', size=1))])
+    # fig.add_trace(go.Scatter3d(x=target_vertices[:,0], y=target_vertices[:,1], z=target_vertices[:,2], mode='markers', marker=dict(color='blue', size=1)))
+    # for corr in correspondences:
+    #     fig.add_trace(go.Scatter3d(x=[aligned_source_vertices[corr[0],0], target_vertices[corr[1],0]], y=[aligned_source_vertices[corr[0],1], target_vertices[corr[1],1]], z=[aligned_source_vertices[corr[0],2], target_vertices[corr[1],2]], mode='lines', line=dict(color='green', width=1)))
+    # fig.update_layout(scene=dict(xaxis=dict(range=[-1,1],), yaxis=dict(range=[-1,1],), zaxis=dict(range=[-1,1],),),)
+    # fig.show()
+
+    registered = np.zeros((14475, 3))
+    mask = np.zeros((14475), dtype=bool)
+    for i in range(len(correspondences)):
+        registered[correspondences[i][1]] = aligned_source_vertices[correspondences[i][0]]
+        mask[correspondences[i][1]] = True
+
+    # F = np.load(f'smpl/smpl_faces.npy').astype(np.int32)
+
+    # registered_masked, masked_faces = _maskFaces(registered, np.asarray(target_mesh.triangles), mask)
+    registered_masked, masked_faces = registered, np.asarray(target_mesh.triangles)
+
+    # plot aligned source mesh with the target topology
+    fig = go.Figure(data=[go.Mesh3d(x=registered_masked[:,0], y=registered_masked[:,1], z=registered_masked[:,2], i=masked_faces[:,0], j=masked_faces[:,1], k=masked_faces[:,2])])
+    fig.update_layout(scene=dict(xaxis=dict(range=[-1,1],), yaxis=dict(range=[-1,1],), zaxis=dict(range=[-1,1],),),)
+    fig.show()
+
+    return smpl
+
+
+def convert_vto(folder, out_folder):
+    os.makedirs(out_folder, exist_ok=True)
+    os.makedirs(os.path.join(out_folder, 'mesh_posed_no_orient'), exist_ok=True)
+    os.makedirs(os.path.join(out_folder, 'mesh_posed_body_no_orient'), exist_ok=True)
+    os.makedirs(os.path.join(out_folder, 'mesh_mask'), exist_ok=True)
+    os.makedirs(os.path.join(out_folder, 'pose_shape'), exist_ok=True)
+    F = np.load(f'smpl/smpl_faces.npy').astype(np.int32)
+
+    files = os.listdir(folder)
+    # files = ['/data-net/code/vto-dataset/tshirt/simulations/tshirt_shape00_55_27.pkl']
+    for file in files:
+        # read pickle files and get vetices and faces from them
+        with open(os.path.join(folder, file), "rb") as f:
+            data = pickle.load(f)
+            vertices = data['vertices']
+            faces = data['faces']
+            pose = data['pose']
+            shape = data['shape']
+            trans = data['translation']
+            id = file.split('.')[0]
+            # pose[:, :3] = 0
+            id = id.replace('_', '-')
+            subject = id.split('-')[2]
+            sequence = '_'.join(id.split('-')[2:])
+            # cmu_data = np.load(f'/data-net/code/vto-garment-collisions/assets/CMU/{subject}/{sequence}_poses.npz')
+            # shape = np.tile(cmu_data['betas'], (shape.shape[0], 1))
+            # pose = cmu_data['poses']
+
+            body = smpl(torch.tensor(pose), torch.tensor(np.concatenate((shape, np.zeros((shape.shape[0],1),dtype=np.float32)),axis=1)))[0].numpy()
+            pose_shape = np.concatenate((pose, shape, np.zeros((shape.shape[0],1),dtype=np.float32)),axis=1)
+            
+            # for i in range(vertices.shape[0]):
+            #     np.savez_compressed(os.path.join(out_folder, 'mesh_posed_body_no_orient', f'{id}_{i}.npz'), mesh_posed_body_no_orient=body[i])
+            #     np.save(os.path.join(out_folder, 'pose_shape', f'{id}_{i}.npy'), pose_shape[i])
+
+
+            # plot mesh with plotly
+            frame = 0
+            fig = go.Figure(data=[go.Mesh3d(x=vertices[frame,:,0], y=vertices[frame,:,1], z=vertices[frame,:,2], i=faces[:,0], j=faces[:,1], k=faces[:,2])])
+            fig.add_trace(go.Mesh3d(x=body[frame,:,0], y=body[frame,:,1], z=body[frame,:,2], i=F[:,0], j=F[:,1], k=F[:,2]))
+            fig.update_layout(scene=dict(xaxis=dict(range=[-1,1],), yaxis=dict(range=[-1,1],), zaxis=dict(range=[-1,1],),),)
+            fig.show()
+
+            
+            pass
+    pass
+
+
+if __name__ == '__main__':
+    # register_smpl()
+    convert_vto('/data-net/code/vto-dataset/dress/simulations', '/data-net/code/vto-dataset/dress_converted')
+    pass

data/dataset.py

@@ -175,9 +175,6 @@ class Dataset(Dataset):
         if 'mesh_curvature' in self.signature:
             mesh_curvature = np.load(os.path.join(self.folder, 'mesh_curvature', frame.id + separator + frame.frame_nr + '.npz')); mesh_curvature = mesh_curvature['mesh_curvature']
             item['mesh_curvature'] = mesh_curvature.astype(np.int32)
-        if 'mesh_normals' in self.signature:
-            mesh_normals = np.load(os.path.join(self.folder, 'mesh_normals', frame.id + separator + frame.frame_nr + '.npz')); mesh_normals = mesh_normals['mesh_normals']
-            item['mesh_normals'] = mesh_normals
 
         for res in self.resolutions:
             res_string = ''
@@ -206,10 +203,6 @@ class Dataset(Dataset):
                 uv_posed = np.load(os.path.join(self.folder, 'uv_posed_no_orient' + res_string, frame.id + separator + frame.frame_nr + '.npz')); uv_posed = uv_posed['uv_posed_no_orient']
                 item['uv_posed' + res_string] = uv_posed
 
-            if 'uv_normals' + res_string in self.signature:
-                uv_normals = np.load(os.path.join(self.folder, 'uv_normals' + res_string, frame.id + separator + frame.frame_nr + '.npz')); uv_normals = uv_normals['uv_normals']
-                item['uv_normals' + res_string] = uv_normals
-
 
         data = { key: (torch.from_numpy(value) if not (type(value) == str or type(value) == torch.Tensor) else value) for key, value in item.items()}
 

data/dataset_vto.py

@@ -0,0 +1,40 @@
+import os
+import sys
+
+import argparse
+parser = argparse.ArgumentParser(description='')
+parser.add_argument('--debug', action='store_true')
+args = vars(parser.parse_args())
+
+if args['debug']:
+    os.environ["CUDA_VISIBLE_DEVICES"] = '0'
+
+import math
+import time
+import torch
+import random
+import pytorch3d
+import torchvision as tv
+import numpy as np
+import scipy.io as sio
+import plotly.express as ex
+from torch.utils.data import Dataset
+
+sys.path.append(os.path.dirname(os.path.abspath(__file__)) + '/..')
+
+from data.utils import Frame
+
+class Dataset(Dataset):
+    def __init__(self, folder):
+        pass
+
+    def __len__(self):
+        return len(self.frames)
+
+
+    def __getitem__(self, idx):
+        frame : Frame = self.frames[idx]
+
+
+if __name__ == '__main__':
+    from torch.utils.data import DataLoader

data/investigate.py

@@ -4,26 +4,11 @@ import random
 import numpy as np
 import plotly.graph_objects as go
 from pymeshfix import MeshFix
-import trimesh
 
 sys.path.append(os.path.dirname(os.path.abspath(__file__)) + '/..')
 from data.cloth3d_io import read_garment_mask, read_garment_template, read_posed_garment_frame, loadInfo, read_posed_body_frame, read_posed_body, read_posed_garment, read_curvatures, read_curvature_frame, writeOBJ
-# from custom_utils.custom_utils import _maskFaces
+from custom_utils.custom_utils import _maskFaces
 
-def _maskFaces(V, F, mask, return_unfixed=False):
-    V_mask = mask
-    F_mask = np.take(V_mask, F.reshape(-1), axis=0)
-    F_mask = F_mask.reshape((-1, 3)).sum(axis=1) == 3
-
-    V_ind = np.zeros(V_mask.shape)
-    V_ind[V_mask] = np.arange(V_mask.sum())
-    F_new = np.take(V_ind, F[F_mask, :].reshape(-1), axis=0).reshape((-1, 3))
-    V_new = V[V_mask, :]
-
-    if return_unfixed:
-        return V_new, F_new, F[F_mask, :]
-    else:
-        return V_new, F_new
 
 def get_frames(folder, frames_file):
     frames = []
@@ -148,7 +133,7 @@ def check(folder, frame):
     v = mesh_posed[mask,:]
     is_skirt = (garment == 'Dress' or garment == 'Skirt')
     skirt_mod = '_skirt' if is_skirt else ''
-    F = np.load(f'smpl/smpl_faces{skirt_mod}.npy').astype(np.int32)
+    F = np.load(f'custom_utils/smpl_faces{skirt_mod}.npy').astype(np.int32)
     _, faces, unfixed = _maskFaces(np.zeros((14475,3)), F, mask, True)
 
     meshfix = MeshFix(v, faces)
@@ -195,22 +180,7 @@ def check(folder, frame):
 
     faces_3 = mask_faces(F, mask_2, mask_2_raw, repeated, mesh_posed)
     # writeOBJ('temp/investigate_3.obj', v_2, faces_3)
-    # plot(v_2, faces_3)
+    plot(v_2, faces_3)
-
-    # save stl
-    # mesh = trimesh.Trimesh(vertices=v_2, faces=faces_3, process=False, validate=False)
-    # mesh.export('temp/investigate_00761.stl')
-
-    # # read stl file
-    # mesh = trimesh.load('temp/fixed_00761.stl', process=False, validate=False)
-    # mesh = trimesh.load('temp/fixed_00761.ply', process=False, validate=False)
-
-    # plotly plot of mesh with v_2 vertices and faces from trimesh mesh
-    # faces_4 = faces_3 #np.asarray(mesh.faces)
-    # go.Figure(data = [go.Mesh3d(x=v_2[:, 0], y=v_2[:, 1], z=v_2[:, 2], i=faces_4[:, 0], j=faces_4[:, 1], k=faces_4[:, 2],)
-    #                      ]).show()
-    
-    
 
 
     # plot repeated
@@ -219,9 +189,9 @@ def check(folder, frame):
         r.extend(rr)
     x = mesh_posed
     y = mesh_posed[r,:]
-    # go.Figure(data = [go.Scatter3d(x=x[:, 0], y=x[:, 1], z=x[:, 2], marker=dict(size=3, line=dict(width=0),), mode='markers'),
+    go.Figure(data = [go.Scatter3d(x=x[:, 0], y=x[:, 1], z=x[:, 2], marker=dict(size=3, line=dict(width=0),), mode='markers'),
-    #                   go.Scatter3d(x=y[:, 0], y=y[:, 1], z=y[:, 2], marker=dict(size=5, line=dict(width=0),), mode='markers'),
+                      go.Scatter3d(x=y[:, 0], y=y[:, 1], z=y[:, 2], marker=dict(size=5, line=dict(width=0),), mode='markers'),
-    #                  ]).show()
+                     ]).show()
 
 
     # unq, idx, count = np.unique(v, axis=0, return_counts=True, return_index=True)
@@ -237,49 +207,30 @@ def check(folder, frame):
     # faces_4 = mask_faces(faces.astype(np.int64), mask_3, mask_2_raw, repeated, v)
     # plot(v[mask_3,:], faces_4)
 
-    return mask_2_raw, faces_3
+
     pass
-
+    
-
-def remask(folder, frame, mask, out_folder):
-    id, frame_nr = frame.split('_')
-    frame_nr = int(frame_nr)
-
-    if frame_nr == 0:
-        mesh_static = np.load(os.path.join(folder, 'mesh_static', f'{id}.npz'))['mesh_static']
-        mesh_static_new = np.zeros((14475,3), dtype=np.float32)
-        mesh_static_new[mask,:] = mesh_static[mask,:]
-        np.savez_compressed(os.path.join(out_folder, 'mesh_static', f'{id}.npz'), mesh_static=mesh_static_new)
-
-    # mesh_posed = read_posed_garment_frame(folder, id, garment, frame_nr, mask=None, shape=None, pose=info['poses'][:,frame_nr], deorient=True, unshape=None)
-    mesh_posed = np.load(os.path.join(folder, 'mesh_posed_no_orient', f'{id}_{frame_nr}.npz'))['mesh_posed_no_orient']
-    mesh_posed_new = np.zeros((14475,3), dtype=np.float32)
-    mesh_posed_new[mask,:] = mesh_posed[mask,:]
-    np.savez_compressed(os.path.join(out_folder, 'mesh_posed_no_orient', f'{id}_{frame_nr}.npz'), mesh_posed_no_orient=mesh_posed)
-
 
 
 if __name__ == "__main__":
-    folder = '/data-local/127/train'
+    folder = '/home/workspace/data/dataset/cloth3d/train'
-    frames = [f'00761_{i}' for i in range(300)]
+    frames = get_frames(folder, 'frames_all.txt')
     root = '/'.join(folder.split('/')[:-1])
     type = folder.split('/')[-1]
 
     use_no_orient = False
     no_shape = False
-    is_skirt = False
+    is_skirt = True
 
     skirt_modifier = '_skirt' if is_skirt else ''
     orient_mod = '_no_orient' if use_no_orient else ''
     shape_mod = '_no_shape' if no_shape else ''
 
-    mask = np.load('/data-net/dataset/00761/mesh_mask/00761.npy')
-    faces = np.load('/data-net/dataset/00761/faces/00761.npy')
 
-    for frame in frames:
+    while True:
-        # frame = random.choice(frames)
+        frame = random.choice(frames)
-        # frame = '00761 0 Tshirt'
+        frame = '05936 0 Dress'
 
-        remask(folder, frame, mask, '/data-net/dataset/00761')
+        check(folder, frame)
 
         pass

data/registration.py

@@ -1,207 +0,0 @@
-import os
-import sys
-import random
-import numpy as np
-import plotly.graph_objects as go
-import torch
-from torch.nn.functional import mse_loss
-from pytorch3d.structures import Meshes
-from pytorch3d.loss import mesh_laplacian_smoothing, mesh_edge_loss, mesh_normal_consistency, chamfer_distance
-
-sys.path.append(os.path.dirname(os.path.abspath(__file__)) + '/..')
-from data.cloth3d_io import (
-    read_garment_mask,
-    read_garment_template,
-    read_posed_garment_frame,
-    loadInfo,
-    read_posed_body_frame,
-    read_posed_body,
-    read_posed_garment,
-    read_curvatures,
-    read_curvature_frame,
-    writeOBJ,
-    readOBJ,
-    quads2tris
-)
-from smpl.smpl_torch import SMPL
-# from custom_utils.custom_utils import _maskFaces
-
-smpl = SMPL('cuda', 'smpl')
-
-
-def _maskFaces(V, F, mask, return_unfixed=False):
-    V_mask = mask
-    F_mask = np.take(V_mask, F.reshape(-1), axis=0)
-    F_mask = F_mask.reshape((-1, 3)).sum(axis=1) == 3
-
-    V_ind = np.zeros(V_mask.shape)
-    V_ind[V_mask] = np.arange(V_mask.sum())
-    F_new = np.take(V_ind, F[F_mask, :].reshape(-1), axis=0).reshape((-1, 3))
-    V_new = V[V_mask, :]
-
-    if return_unfixed:
-        return V_new, F_new, F[F_mask, :]
-    else:
-        return V_new, F_new
-
-def get_frames(folder, frames_file):
-    frames = []
-    with open(os.path.join(folder, frames_file), 'r') as f:
-        for line in f:
-            frames.append(line.strip())
-    return frames
-
-
-def plot(mesh, faces):
-    fig = go.Figure()
-
-    fig.add_trace(go.Mesh3d(
-                x=mesh[:,0],
-                y=mesh[:,1],
-                z=mesh[:,2],
-                i = faces[:,0],
-                j = faces[:,1],
-                k = faces[:,2]
-            ),)
-    
-    fig.update_layout(scene_aspectmode='manual', scene_aspectratio=dict(x=1, y=1, z=1),
-                    )
-    helper = dict(xaxis = dict(nticks=4, range=[-1,1],),
-                yaxis = dict(nticks=4, range=[-1,1],),
-                zaxis = dict(nticks=4, range=[-1,1],),)
-    fig.update_layout(scene = helper,
-                        )
-
-    fig.show()
-
-
-def build_lookup_table(repeated):
-    # iterate through the list and create a dict from each sub array in the list where each dict has one element of the sub array as key and the other elements as value as a list and repeat for each element
-
-    lookup = {}
-    for i in range(len(repeated)):
-        for j in range(len(repeated[i])):
-            if len(repeated[i]) == 1:
-                continue
-            lookup[repeated[i][j]] = [repeated[i][k] for k in range(len(repeated[i]))] # if k != j
-    return lookup
-
-
-from data.cloth3d_io import readPC2Frame
-import scipy.io as sio
-import scipy
-def local_read_posed_garment_frame(folder, id, garment, frame, pose=None, deorient=False):
-    pc16_path = os.path.join(folder, id, garment + '.pc16')
-    verts = readPC2Frame(pc16_path, frame, True)
-
-    map = sio.loadmat(os.path.join(folder, id, garment + '_map.mat'))['map'].reshape((-1))
-
-    if deorient:
-        R = scipy.spatial.transform.Rotation.from_euler('xyz', pose[:3]).inv()
-        # R = scipy.spatial.transform.Rotation.from_euler([0,0,-zrot])
-        verts = R.apply(verts)
-
-    return verts, map
-
-def local_read_posed_body_frame(folder, id, frame, pose=None, deorient=False):
-    pc16_path = os.path.join(folder, id, 'Body_posed.pc16')
-    verts = readPC2Frame(pc16_path, frame, True)
-
-    if deorient:
-        R = scipy.spatial.transform.Rotation.from_euler('xyz', pose[:3]).inv()
-        # R = scipy.spatial.transform.Rotation.from_euler([0,0,-zrot])
-        verts = R.apply(verts)
-
-    return verts
-
-def register(folder, frame):
-    id, frame_nr, garment = frame.split()
-    frame_nr = int(frame_nr)
-    info = loadInfo(os.path.join(folder, id, 'info.mat'))
-    raw_mask = read_garment_mask(folder, id, garment, return_raw=True)
-    mask = raw_mask > 0
-    mesh_posed, map = local_read_posed_garment_frame(folder, id, garment, frame_nr, pose=info['poses'][:,frame_nr], deorient=True)
-    body_posed = local_read_posed_body_frame(folder, id, frame_nr, pose=info['poses'][:,frame_nr], deorient=True)
-    template, faces, _, _ = readOBJ(os.path.join(folder, id, garment + '.obj'))
-    faces = quads2tris(faces)
-    pose = torch.zeros(72)
-    shape = torch.zeros(11)
-    shape[-1] = 1
-    # for star pose
-    pose[:,5] = 3.1415/4
-    pose[:,8] = -3.1415/4
-    star_body = smpl(pose.unsqueeze(0), shape.unsqueeze(0))[0][0].cpu().numpy()
-
-    is_skirt = (garment == 'Dress' or garment == 'Skirt')
-    skirt_mod = '_skirt' if is_skirt else ''
-    F = np.load(f'smpl/smpl_faces{skirt_mod}.npy').astype(np.int32)
-
-    plot(template, faces)
-    # v = mesh_posed[mask,:]
-
-    # Define the meshes to optimize
-    mesh1 = Meshes(verts=template[None,:,:], faces=faces[None,:,:])
-    mesh2 = Meshes(verts=star_body, faces=F[None,:,:])
-
-    # Define the optimizer and learning rate
-    optimizer = torch.optim.Adam([mesh1.verts_packed()], lr=0.01)
-
-    # Define the loss functions
-    def laplacian_smoothing_loss(mesh):
-        return mesh_laplacian_smoothing(mesh, method="uniform")
-
-    def edge_loss(mesh1, mesh2):
-        return mesh_edge_loss(mesh1, mesh2)
-
-    def normal_consistency_loss(mesh1, mesh2):
-        return mesh_normal_consistency(mesh1, mesh2)
-
-    # Optimization loop
-    for i in range(100):
-        optimizer.zero_grad()
-
-        # Forward pass
-        mesh1_out = Meshes(verts=[mesh1.verts_packed()], faces=[mesh1.faces_packed()])
-        loss = chamfer_distance(mesh1_out, mesh2)
-        loss += laplacian_smoothing_loss(mesh1_out)
-        loss += edge_loss(mesh1_out)
-        loss += normal_consistency_loss(mesh1_out)
-
-        # Backward pass
-        loss.backward()
-        optimizer.step()
-
-        # Print the loss
-        print(f"Loss: {loss.item()}")
-
-    pass
-
-if __name__ == "__main__":
-    folder = '/data-net/dataset/cloth3d/train'
-    # folder = r'D:\Work\Dataset\cloth3d\train'
-    # frames = [f'00761_{i}' for i in range(300)]
-    # folder = r'Z:\Work\Huni\Barcelona\Dataset\cloth3d\train'
-    frames = get_frames(folder, 'frames_all.txt')
-    root = '/'.join(folder.split('/')[:-1])
-    type = folder.split('/')[-1]
-
-    use_no_orient = False
-    no_shape = False
-    is_skirt = False
-
-    skirt_modifier = '_skirt' if is_skirt else ''
-    orient_mod = '_no_orient' if use_no_orient else ''
-    shape_mod = '_no_shape' if no_shape else ''
-
-    # mask = np.load('/data-net/dataset/00761/mesh_mask/00761.npy')
-    # faces = np.load('/data-net/dataset/00761/faces/00761.npy')
-
-    for frame in frames:
-        frame = random.choice(frames)
-        # frame = '00761 0 Tshirt'
-        frame = '01893 256 Jumpsuit'
-        
-
-        register(folder, frame)
-
-        pass

docker/docker-compose.yml

@@ -34,7 +34,6 @@ services:
       - '/data-net/guest/lhunor/data:/data-net'
       - '/data-fast/126-data1/lhunor/data:/data-local/126'
       - '/data-fast/127-data1/lhunor/data:/data-local/127'
-      - '/data-fast/127-data2/lhunor/data:/data-local/127_2'
       - '/data-fast/128-data1/lhunor/data:/data-local/128'
     deploy:
       resources:

losses/losses.py

@@ -18,12 +18,12 @@ from torch_cluster import knn
 smpl_to_keep_orig = sio.loadmat('smpl/keep_remove.mat')['keep'].reshape(-1)
 smpl_to_keep_orig = smpl_to_keep_orig[smpl_to_keep_orig < 6890]
 
-# to_keep = sio.loadmat('smpl/keep_remove.mat')['keep'].reshape(-1)
+to_keep = sio.loadmat('smpl/keep_remove.mat')['keep'].reshape(-1)
-F_coll = torch.tensor(np.load("smpl/smpl_faces.npy"), device='cuda')
+F_coll = torch.tensor(np.load("smpl/smpl_faces.npy")[to_keep,:], device='cuda')
-F_coll_skirt = torch.tensor(np.load("smpl/smpl_faces_skirt.npy"), device='cuda')
+F_coll_skirt = torch.tensor(np.load("smpl/smpl_faces_skirt.npy")[to_keep,:], device='cuda')
 F_coll_orig = torch.tensor(np.load("smpl/smpl_faces_orig.npy")[:6890,:], device='cuda')
-F_norm = torch.tensor(np.tile(np.load("smpl/smpl_faces.npy")[None,:,:], [4,1,1]), device='cuda')
+F_norm = torch.tensor(np.tile(np.load("smpl/smpl_faces.npy")[to_keep,:][None,:,:], [4,1,1]), device='cuda')
-F_norm_skirt = torch.tensor(np.tile(np.load("smpl/smpl_faces_skirt.npy")[None,:,:], [4,1,1]), device='cuda')
+F_norm_skirt = torch.tensor(np.tile(np.load("smpl/smpl_faces_skirt.npy")[to_keep,:][None,:,:], [4,1,1]), device='cuda')
 F_norm_orig = torch.tensor(np.tile(np.load("smpl/smpl_faces_orig.npy")[:6890,:][None,:,:], [4,1,1]), device='cuda')
 F_norm_orig = F_norm_orig[:,smpl_to_keep_orig,:]
 

models/base.py

@@ -35,10 +35,10 @@ class VariationalEncoder(nn.Module):
 
 class AEEncoder(nn.Module):
     
-    def __init__(self, block_setting: CNBlockConfig, kernel_size: int = 7, activation='tanh', is_label=False, nr_of_labels=None, device='cuda'):
+    def __init__(self, block_setting: CNBlockConfig, kernel_size: int = 7, activation='tanh', is_label=False, nr_of_labels=None, device='cuda', input_features=3):
         super(AEEncoder, self).__init__()
 
-        self.encoder = ConvNeXt(block_setting=block_setting, kernel_size=kernel_size, is_label=is_label, nr_of_labels=nr_of_labels, device=device)
+        self.encoder = ConvNeXt(block_setting=block_setting, kernel_size=kernel_size, is_label=is_label, nr_of_labels=nr_of_labels, device=device, input_features=input_features)
         if activation == 'tanh':
             self.act = nn.Tanh()
         elif activation == 'sigmoid':

models/cond_encoder.py

@@ -8,7 +8,7 @@ class AutoEncoder(nn.Module):
     def __init__(self, config):
         super(AutoEncoder, self).__init__()
 
-        self.encoder : AEEncoder = AEEncoder(config['encoder_block_settings'], config['kernel_size'], config['activation'], is_label=config['is_label'], device=config['device'], nr_of_labels=7)
+        self.encoder : AEEncoder = AEEncoder(config['encoder_block_settings'], config['kernel_size'], config['activation'], is_label=config['is_label'], device=config['device'], nr_of_labels=7, input_features=config['input_features'])
         self.decoder : Decoder = Decoder(config['decoder_block_settings'], kernel_size=config['kernel_size'], is_label=config['is_label'], device=config['device'], nr_of_classes=6)
 
 

models/cvae_model.py

@@ -27,16 +27,16 @@ class CVAE(nn.Module):
             if config['body_model'] != '':
                 load_model(self.body_enc, config['body_model'] + '_enc')
 
-        if config['use_normals']:
+        if config['use_curvature']:
-            self.norm_enc : AEEncoder = AEEncoder(config['cond_ae_norm']['encoder_block_settings'], config['cond_ae_norm']['kernel_size'], config['cond_ae_norm']['activation'], device=config['device'])
+            self.curv_enc : AEEncoder = AEEncoder(config['cond_ae_curv']['encoder_block_settings'], config['cond_ae_curv']['kernel_size'], config['cond_ae_curv']['activation'], device=config['device'], is_label=True, nr_of_labels=7)
-            if config['normals_model'] != '':
+            if config['curvature_model'] != '':
-                load_model(self.norm_enc, config['normals_model'] + '_enc')
+                load_model(self.curv_enc, config['curvature_model'] + '_enc')
 
         if config['freeze_encoders']:
             for param in self.static_enc.parameters(): param.requires_grad = False
             for param in self.body_enc.parameters(): param.requires_grad = False
-            if config['use_normals']:
+            if config['use_curvature']:
-                for param in self.norm_enc.parameters(): param.requires_grad = False
+                for param in self.curv_enc.parameters(): param.requires_grad = False
 
         self.encoder = VariationalEncoder(config['cvae']['encoder_block_settings'], config['cvae']['kernel_size'], config['cvae']['input_features'], device=config['device'])
         self.decoder : Decoder = Decoder(config['cvae']['decoder_block_settings'], kernel_size=config['cvae']['kernel_size'], device=config['device'])
@@ -48,7 +48,7 @@ class CVAE(nn.Module):
         else:
             self.avg_garment = None
 
-        self.use_normals = config['use_normals']
+        self.use_curvature = config['use_curvature']
         self.use_offsets_over_body = not config['use_skinning']
 
         if self.use_offsets_over_body:
@@ -98,9 +98,9 @@ class CVAE(nn.Module):
     def encode_conds(self, uv_template, uv_body_posed, uv_curv):
         z_body = self.body_enc(uv_body_posed)
         z_static = self.static_enc(uv_template)
-        if self.use_normals:
+        if self.use_curvature:
-            z_norm = self.norm_enc(uv_curv)
+            z_curv = self.curv_enc(uv_curv)
-            z_cond = torch.concat([z_static, z_body, z_norm], dim=1)
+            z_cond = torch.concat([z_static, z_body, z_curv], dim=1)
         else:
             z_cond = torch.concat([z_static, z_body], dim=1)
 
@@ -108,13 +108,13 @@ class CVAE(nn.Module):
 
 
     def forward(self, inputs):
-        uv_unposed, uv_template, uv_body_posed, uv_norm, uv_mask = inputs
+        uv_unposed, uv_template, uv_body_posed, uv_curv, uv_mask = inputs
-        x = torch.concat([uv_unposed, uv_template, uv_body_posed, uv_norm], dim=1)
+        x = torch.concat([uv_unposed, uv_template, uv_body_posed, uv_curv], dim=1)
         
         mean, logvar = self.encoder(x)
         z: torch.Tensor = self.reparameterize(mean, logvar)
         z = z.view((mean.shape[0], *self.latent_shape))
-        z_cond = self.encode_conds(uv_template, uv_body_posed, uv_norm)
+        z_cond = self.encode_conds(uv_template, uv_body_posed, uv_curv)
 
         z = torch.concat([z, z_cond], dim=1)
         x = self.decoder(z)

models/cvae_norm_model.py

@@ -1,97 +0,0 @@
-import os
-import time
-import random
-import torch
-from torch import nn
-import numpy as np
-import scipy as sp
-# import plotly.graph_objects as go
-# import plotly.express as ex
-
-from utils.checkpoints import load_model
-from models.base import AEEncoder, VariationalEncoder, Decoder
-
-
-class CVAENorm(nn.Module):
-    
-    def __init__(self, config):
-        super(CVAENorm, self).__init__()
-        self.size = config['resolution']
-
-        self.static_enc : AEEncoder = AEEncoder(config['cond_ae_static']['encoder_block_settings'], config['cond_ae_static']['kernel_size'], config['cond_ae_static']['activation'], device=config['device'])
-        if config['static_model'] != '':
-            load_model(self.static_enc, config['static_model'] + '_enc')
-
-        self.body_enc : AEEncoder = AEEncoder(config['cond_ae_body']['encoder_block_settings'], config['cond_ae_body']['kernel_size'], config['cond_ae_body']['activation'], device=config['device'])
-        if config['body_model'] != '':
-            load_model(self.body_enc, config['body_model'] + '_enc')
-
-        if config['freeze_encoders']:
-            for param in self.static_enc.parameters(): param.requires_grad = False
-            for param in self.body_enc.parameters(): param.requires_grad = False
-
-        self.encoder = VariationalEncoder(config['cvae']['encoder_block_settings'], config['cvae']['kernel_size'], config['cvae']['input_features'], device=config['device'])
-        self.decoder : Decoder = Decoder(config['cvae']['decoder_block_settings'], kernel_size=config['cvae']['kernel_size'], device=config['device'])
-
-        self.latent_shape = (config['cvae']['latent_dim'], 8, 4)
-
-
-    def sample(self, uv_template, uv_body_posed, uv_curv, uv_mask, noise=None, add_noise=False):
-        if noise is None:
-            eps = tf.random.normal(shape=(uv_template.shape[0], 8, 4, self.latent_dim))
-        else:
-            eps = noise
-
-        z_cond = self.encode_conds(uv_template, uv_body_posed, uv_curv, training=False)
-        if add_noise:
-            z_cond = z_cond + (tf.random.uniform(z_cond.shape, maxval=self.noise_amount * 2) - self.noise_amount)
-        
-        z = tf.concat([eps, z_cond], axis=-1)
-
-        x = self.decoder(z, training=False)
-        
-        if self.avg_garment is not None:
-            x = x + self.avg_garment[tf.newaxis,:,:,:]
-        
-        if self.use_offsets_over_body:
-            x = x + uv_body_posed
-
-        x = x * uv_mask[:,:,:,tf.newaxis]
-
-        return x
-
-
-    def reparameterize(self, mean: torch.Tensor, logvar: torch.Tensor, training: bool = True, fix_noise: bool = False):
-        if training == True:
-            if not fix_noise:
-                eps = torch.randn(size=mean.shape).to(mean.device)
-            else:
-                eps = torch.randn(size=(1, mean.shape[1]))
-                eps = torch.tile(eps, [mean.shape[0],1])
-            out = eps * torch.exp(logvar * 0.5) + mean
-        else:
-            out = torch.exp(logvar * 0.5) + mean
-        return out
-
-
-    def encode_conds(self, uv_template, uv_body_posed):
-        z_body = self.body_enc(uv_body_posed)
-        z_static = self.static_enc(uv_template)
-        z_cond = torch.concat([z_static, z_body], dim=1)
-        return z_cond
-
-
-    def forward(self, inputs):
-        uv_unposed, uv_template, uv_body_posed, uv_mask = inputs
-        x = torch.concat([uv_unposed, uv_template, uv_body_posed], dim=1)
-        
-        mean, logvar = self.encoder(x)
-        z: torch.Tensor = self.reparameterize(mean, logvar)
-        z = z.view((mean.shape[0], *self.latent_shape))
-        z_cond = self.encode_conds(uv_template, uv_body_posed)
-
-        z = torch.concat([z, z_cond], dim=1)
-        x = self.decoder(z)
-        x = x * uv_mask[:,None,:,:]
-
-        return x, mean, logvar

models/direct.py

@@ -0,0 +1,29 @@
+import torch
+from torch import nn
+from models.convnext_orig import ConvNeXt, CNBlock, CNBlockConfig
+from typing import Any, Callable, List, Optional, Sequence
+
+
+class DirectModel(nn.Module):
+    
+    def __init__(self, block_setting: List[CNBlockConfig], kernel_size: int = 7, input_features: int = 16, device: str = 'cuda'):
+        super(DirectModel, self).__init__()
+
+        self.encoder = ConvNeXt(block_setting=block_setting, kernel_size=kernel_size, input_features=input_features, device=device)
+        self.decoder = ConvNeXt(block_setting=block_setting, kernel_size=kernel_size, device=device, reversed=True)
+
+        layers = [CNBlock(block_setting[-1].input_channels, kernel_size=kernel_size) for _ in range(5)]
+        self.mean_branch = nn.Sequential(*layers).to(device)
+        layers = [CNBlock(block_setting[-1].input_channels, kernel_size=kernel_size) for _ in range(5)]
+        self.var_branch = nn.Sequential(*layers).to(device)
+
+        self.flatten_mean = nn.Flatten()
+        self.flatten_var = nn.Flatten()
+
+
+    def forward(self, inputs):
+        body, template = inputs
+
+        x = self.encoder(x)
+
+        return mean

run.py

@@ -1,6 +1,6 @@
 import os
 import sys
-from configs.cvae_norm_1 import config
+from configs.direct_1 import config
 import argparse
 
 # parser = argparse.ArgumentParser(description='')

run_parallel.py

@@ -4,27 +4,24 @@ import os
 
 if __name__ == '__main__':
 
-    # folder = '/home/workspace/data/dataset/cloth3d/train'
+    folder = '/home/workspace/data/dataset/cloth3d/train'
     # folder = '/home/workspace/local-data/cape_processed/train/male'
     # folder = '/home/workspace/local-data/valid_skirt'
     # folder = '/home/workspace/local-data/valid'
     # ids = os.listdir(folder)
     # ids = os.listdir(folder + '/mesh_posed_no_orient')#[280000:]
     skirt = 0
-    obj_folder = '/data-net/dataset/cloth3d/train'
-    folder = '/data-local/127/train'
 
-    count = 0
+    count = int(500 * 1e3)
-    step = 100
+    step = 10000
 
     # !!!!!!! change skirt parameter in script
 
-    while count <1200:
+    while count < 510 * 1e3:
         # os.system('nohup python convert_to_uv_cape.py -f ' + folder + ' -s ' + str(count) + ' -e ' + str(count + step) + ' -n ' + 'to_uv_2_cape_train_male_' + str(count) + '_' + str(count+step) + ' > nohup/to_uv_2_cape_train_male_' + str(count) + '_' + str(count+step) + '.out' + ' 2>&1 &')
         # os.system('nohup python convert_to_uv.py -f ' + folder + ' -s ' + str(count) + ' -e ' + str(count + step) + ' -n ' + 'to_uv_train_unposed_onehot_' + str(count) + '_' + str(count+step) + ' > nohup/to_uv_train_unposed_onehot_' + str(count) + '_' + str(count+step) + '.out' + ' 2>&1 &')
         # os.system('nohup python convert_to_uv_local.py -f ' + folder + ' -s ' + str(count) + ' -e ' + str(count + step) + ' -n ' + 'to_uv_train_local_unposed_onehot_' + str(count) + '_' + str(count+step) + ' > nohup/to_uv_train_local_unposed_onehot_' + str(count) + '_' + str(count+step) + '.out' + ' 2>&1 &')
-        # os.system('nohup python data/convert_to_uv.py -f ' + folder + ' -s ' + str(count) + ' -e ' + str(count + step) + ' -n ' + 'to_uv_train_2_' + str(count) + '_' + str(count+step) + ' > nohup/to_uv/train_2_' + str(count) + '_' + str(count+step) + '_again.out' + ' 2>&1 &')
+        os.system('nohup python data/convert_to_uv.py -f ' + folder + ' -s ' + str(count) + ' -e ' + str(count + step) + ' -n ' + 'to_uv_train_2_' + str(count) + '_' + str(count+step) + ' > nohup/to_uv/train_2_' + str(count) + '_' + str(count+step) + '_again.out' + ' 2>&1 &')
-        os.system(f'nohup python data/calculate_normals.py -f {folder} -f_obj {obj_folder}  -s {count} -e {(count+step)} -n normals_train_calc_{count}_{(count+step)} > nohup/normals/normals_train_calc_{count}_{(count+step)}.out' + ' 2>&1 &')
         # os.system('nohup python convert_to_uv_local_single.py -f ' + folder + ' -s ' + str(count) + ' -e ' + str(count + step) + ' -n ' + 'to_uv_train_skirt_local_unposed_onehot_3_' + str(count) + '_' + str(count+step) + ' > nohup/to_uv_train_skirt_local_unposed_onehot_3_' + str(count) + '_' + str(count+step) + '.out' + ' 2>&1 &')
         # os.system('nohup python convert_to_uv_local_single.py -f ' + folder + ' -s ' + str(count) + ' -e ' + str(count + step) + ' -n ' + 'to_uv_valid_skirt_local_unposed_onehot_3_' + str(count) + '_' + str(count+step) + ' > nohup/to_uv_valid_skirt_local_unposed_onehot_' + str(count) + '_' + str(count+step) + '.out' + ' 2>&1 &')
         # os.system('nohup python downscale.py -f ' + folder + ' -s ' + str(count) + ' -e ' + str(count + step) + ' -n ' + 'downscale_valid_posed_no_orient_' + str(count) + '_' + str(count+step) + ' > nohup/downscale_valid_posed_no_orient_' + str(count) + '_' + str(count+step) + '.out' + ' 2>&1 &')

scripts/ae_norm_train.py

@@ -1,218 +0,0 @@
-import os
-import sys
-sys.path.append(os.path.dirname(os.path.abspath(__file__)) + '/..')
-
-import argparse
-import importlib
-
-parser = argparse.ArgumentParser(description='')
-parser.add_argument('--name', type=str)
-parser.add_argument('--config', type=str)
-parser.add_argument('--debug', action='store_true')
-args = vars(parser.parse_args())
-
-config_module = importlib.import_module(args['config'])
-config = config_module.config
-if args['debug']:
-    from configs.ae_norm_1 import config
-os.environ["CUDA_DEVICE_ORDER"]="PCI_BUS_ID"
-os.environ["CUDA_VISIBLE_DEVICES"] = config['gpu']
-if args['debug']:
-    os.environ["CUDA_LAUNCH_BLOCKING"] = '1'
-
-import time
-import wandb
-import random
-import numpy as np
-import torch
-from torch import nn
-# from torchmetrics import MultiScaleStructuralSimilarityIndexMeasure as MSSSIM
-from custom_utils.custom_utils import UV2Mesh, get_summary_html, maskFacesBatch, get_summary_str
-import plotly.graph_objects as go
-import plotly.express as ex
-import torch.optim as optim
-
-if config['is_skirt']:
-    from losses.losses import edge_loss_skirt as edge_loss
-else:
-    from losses.losses import edge_loss
-
-from data.dataset import Dataset
-# from torch.utils.data import DataLoader
-from custom_utils.custom_utils import plot_3d
-from models.cond_encoder import AutoEncoder
-from utils.checkpoints import CheckpointSaver, load_model
-from custom_utils.custom_utils import Accumulator
-from utils.utils import InfiniteDataLoader as DataLoader
-
-from pytorch_msssim import MS_SSIM
-
-
-def init_wandb():
-    run = wandb.init(project='ae', name=config['name'], notes=config['notes'], dir='/data-local/127_2/temp', tags=config['tags'])
-    artifact = wandb.Artifact('code', type='code')
-    artifact.add_file('scripts/ae_norm_train.py')
-    artifact.add_file('losses/losses.py')
-    artifact.add_file('models/base.py')
-    artifact.add_file('models/cond_encoder.py')
-    artifact.add_file('models/convnext.py')
-    artifact.add_file('data/dataset.py')
-    config_file_names = [key for key in sys.modules.keys()  if key.startswith('configs.')]
-    for config_file_name in config_file_names:
-        file_name = '/'.join(config_file_name.split('.')) + '.py'
-        if os.path.exists(file_name):
-            artifact.add_file(file_name)
-    run.log_artifact(artifact)
-
-uv2mesh = UV2Mesh(res=256, is_skirt=config['is_skirt'], is_smpl_orig=config['is_cape'])
-
-
-
-def train_step(batch):
-    model.train()
-    pred = model([batch['uv_normals'], batch['uv_mask']]) * 1.1
-
-    ms_ssim = torch.mean(_MSSSIM(pred + 1.1, batch['uv_normals'] + 1.1))
-    loss = 1e3 * (1 - ms_ssim)
-
-    optimizer.zero_grad()
-    loss.backward()
-    optimizer.step()
-
-    model.eval()
-    with torch.inference_mode():
-        mesh_pred = uv2mesh(pred)
-        mesh_orig = batch['mesh_normals']
-        l1_loss = torch.mean(torch.sum((torch.abs(batch['uv_normals'] - pred)), axis=1))
-        metric = torch.mean(torch.sqrt(torch.sum(batch['mesh_mask'][:,:,None] * (mesh_orig - mesh_pred) ** 2, axis=-1)))
-    
-    return { 'train/loss': loss, 'train/l1_loss': l1_loss, 'train/euclid_error': metric, 'train/ms_ssim': ms_ssim, }
-        
-
-def valid_step(batch):
-    model.eval()
-
-    with torch.inference_mode():
-        pred = model([batch['uv_normals'], batch['uv_mask']]) * 1.1
-
-        mesh_pred = uv2mesh(pred)
-        mesh_orig = batch['mesh_normals']
-
-        l1_loss = torch.mean(torch.sum((torch.abs(batch['uv_normals'] - pred)), axis=1))
-        ms_ssim = torch.mean(_MSSSIM(pred + 1.1, batch['uv_normals'] + 1.1))
-        loss = 1e3 * (1 - ms_ssim)
-
-        metric = torch.mean(torch.sqrt(torch.sum(batch['mesh_mask'][:,:,None] * (mesh_orig - mesh_pred) ** 2, axis=-1)))
-    
-    return { 'valid/loss': loss, 'valid/l1_loss': l1_loss, 'valid/euclid_error': metric, 'valid/ms_ssim': ms_ssim, }
-       
-
-def plot_everything(batch: dict, type: str):
-    model.eval()
-    pred = model([batch['uv_normals'], batch['uv_mask']]).detach() * 1.1
-    
-    # mesh_pred = uv2mesh(pred)
-    # mesh_orig = batch['mesh_normals']
-    
-    orig_img = torch.permute(batch['uv_normals'], [0,2,3,1])
-    pred_img = torch.permute(pred, [0,2,3,1])
-    img = torch.concat((orig_img, pred_img), axis=2)
-    imgs = [wandb.Image((img[i].cpu().numpy() + 1.1) / 2.2) for i in range(4)]
-
-    # F = np.load("smpl/smpl_faces" + skirt_modifier + ("_orig" if config['is_cape'] else "") + ".npy")
-    # garment_unposed, faces = mesh_pred.cpu().numpy(), F
-    # gt = [mesh_orig[i].cpu().numpy() for i in range(pred.shape[0])]
-    
-    # body = uv2mesh(batch['uv_body_posed']).cpu().numpy()
-    # garment_posed = garment_unposed
-    # collision = [np.concatenate((body[i], garment_posed[i]), axis=0) for i in range(len(garment_posed))]
-    # collision_faces = [np.concatenate((F, faces + (3638 if config['is_cape'] else 14475)), axis=0) for i in range(len(garment_posed))]
-    # collision_color = [np.concatenate((np.ones_like(body[i], dtype=np.int32)*100, np.ones_like(garment_posed[i], dtype=np.int32)*230), axis=0) for i in range(len(garment_posed))]
-
-    # figs = { type + "/garment_" + str(i): plot_3d(gt[i], garment_unposed[i], faces, collision[i], collision_faces[i], collision_color[i]) for i in range(4) }
-    figs = {}
-
-    return { **figs, **{ type + '/images': imgs } }
-
-
-def train():
-    valid_iterator = iter(valid_dataloader)
-
-    step = 0
-    for batch in train_dataloader:
-        train_loss = train_step(batch)
-        train_accumulator.update(train_loss)
-
-        if step % 25 == 0:
-            data_valid = next(valid_iterator)
-            valid_loss = valid_step(data_valid)
-            valid_accumulator.update(valid_loss)
-
-        if step % 1000 == 0 or (step < 1000 and step % 100 == 0):
-            to_log = dict({ **train_loss, **valid_loss, **{ 'current_step': step } })
-            if step % 5000 == 0 or (step < 5000 and step % 1000 == 0):
-                train_figs = plot_everything(batch, 'train')
-                valid_figs = plot_everything(data_valid, 'valid')
-                to_log = { **to_log, **train_figs, **valid_figs }
-            if step == 0:
-                to_log = { **to_log, **{ 'model/summary': wandb.Html(get_summary_html(model)) } }
-
-            if not args['debug']:
-                wandb.log(to_log, step=step)
-            train_accumulator.reset()
-            valid_accumulator.reset()
-            print(step)
-
-        if step % 10000 == 0:
-            ckpt_saver_enc(model.encoder, step, optimizer, scaler=None)
-            ckpt_saver_dec(model.decoder, step, optimizer, scaler=None)
-
-        step += 1
-
-
-class Scale(torch.nn.Module):
-    def __init__(self, scale_factor):
-        super().__init__()
-        self.scale_factor = scale_factor
-
-    def forward(self, x):
-        return x * self.scale_factor
-
-
-if __name__ == '__main__':
-    if not args['debug']:
-        init_wandb()
-
-    skirt_modifier = '_skirt' if config['is_skirt'] else ''
-
-    dataset_train = Dataset(config['train_dir'], config['signature'], device=config['device'], frames_file=config['train_frames'], use_cache=config['dataset_in_memory'], is_cape=config['is_cape'])
-    dataset_valid = Dataset(config['valid_dir'], config['signature'], device=config['device'], frames_file=config['valid_frames'], use_cache=config['dataset_in_memory'], is_cape=config['is_cape'])
-    train_dataloader = DataLoader(dataset_train, batch_size=4, drop_last=True, shuffle=True)
-    valid_dataloader = DataLoader(dataset_valid, batch_size=4, drop_last=True, shuffle=True)
-    train_accumulator = Accumulator()
-    valid_accumulator = Accumulator()
-
-    model : AutoEncoder = AutoEncoder(config['cond_ae'])
-    optimizer = optim.Adam(model.parameters(), lr=config['lr'])
-
-    # _MSSSIM = MSSSIM(data_range=2).to(config['device'])
-    _MSSSIM = MS_SSIM(data_range=2.2, size_average=True, channel=3)
-
-    if config['pretrained_model'] != '':
-        load_model(model.encoder, config['pretrained_model'] + '_enc')
-        load_model(model.decoder, config['pretrained_model'] + '_dec')
-
-    ckpt_saver_enc = CheckpointSaver('checkpoints/iccv/torch/' + config['name'] + '_enc', top_n=5)
-    ckpt_saver_dec = CheckpointSaver('checkpoints/iccv/torch/' + config['name'] + '_dec', top_n=5)
-
-    run_name = config['name']
-    print(f'started training: {run_name}')
-
-    if not args['debug']:
-        # model = torch.compile(model)
-        wandb.watch(model, log='all', log_freq=10000, log_graph=True)
-
-    train()
-
-
-

scripts/cvae.py

@@ -13,8 +13,7 @@ args = vars(parser.parse_args())
 config_module = importlib.import_module(args['config'])
 config = config_module.config
 if args['debug']:
-    from configs.abl_norm import config
+    pass
-
 os.environ["CUDA_DEVICE_ORDER"]="PCI_BUS_ID"
 os.environ["CUDA_VISIBLE_DEVICES"] = config['gpu']
 if args['debug']:
@@ -51,7 +50,7 @@ from custom_utils.custom_utils import UV2Mesh, Accumulator, plot_3d, get_summary
 
 
 def init_wandb():
-    run = wandb.init(project='iccv', name=config['name'], notes=config['notes'], dir='/data-local/127/temp', tags=config['tags'])
+    run = wandb.init(project='iccv', name=config['name'], notes=config['notes'], dir='/tmp', tags=config['tags'])
     artifact = wandb.Artifact('code', type='code')
     artifact.add_file('scripts/cvae.py')
     artifact.add_file('losses/losses.py')
@@ -84,7 +83,7 @@ def train_step(batch):
         mesh_orig, uv_orig = batch['mesh_posed'], batch['uv_posed']
 
     model.train()
-    pred, mean, logvar = model([uv_orig, batch['uv_static'], batch['uv_body_posed'], batch['uv_normals'], batch['uv_mask']])
+    pred, mean, logvar = model([uv_orig, batch['uv_static'], batch['uv_body_posed'], batch['uv_curvature'], batch['uv_mask']])
     mesh_pred = uv2mesh(pred)
 
     if config['use_skinning']:
@@ -140,7 +139,7 @@ def valid_step(batch):
 
     model.eval()
     with torch.inference_mode():
-        pred, mean, logvar = model([uv_orig, batch['uv_static'], batch['uv_body_posed'], batch['uv_normals'], batch['uv_mask']])
+        pred, mean, logvar = model([uv_orig, batch['uv_static'], batch['uv_body_posed'], batch['uv_curvature'], batch['uv_mask']])
         mesh_pred = uv2mesh(pred)
 
         if config['use_skinning']:
@@ -189,16 +188,15 @@ def plot_everything(batch: dict, type: str):
 
     model.eval()
     with torch.inference_mode():
-        pred, mean, logvar = model([uv_orig, batch['uv_static'], batch['uv_body_posed'], batch['uv_normals'], batch['uv_mask']])
+        pred, mean, logvar = model([uv_orig, batch['uv_static'], batch['uv_body_posed'], batch['uv_curvature'], batch['uv_mask']])
     
     mesh_pred = uv2mesh(pred).detach().cpu().numpy()
     
     orig_img = torch.permute(uv_orig, [0,2,3,1])
     uv_static_img = torch.permute(batch['uv_static'], [0,2,3,1])
     uv_body_posed_img = torch.permute(batch['uv_body_posed'], [0,2,3,1])
-    uv_normals_img = (torch.permute(batch['uv_normals'], [0,2,3,1]) + 1.1) / 2.2
     pred_img = torch.permute(pred, [0,2,3,1])
-    img = torch.concat((uv_static_img, uv_body_posed_img, uv_normals_img, orig_img, pred_img), axis=2)
+    img = torch.concat((uv_static_img, uv_body_posed_img, orig_img, pred_img), axis=2)
     imgs = [wandb.Image((img[i].cpu().numpy() + 1) / 2.0) for i in range(4)]
     
     F = np.load("smpl/smpl_faces" + skirt_modifier + ("_orig" if config['is_cape'] else "") + ".npy")
@@ -264,10 +262,10 @@ def sample(folder):
     count = 0
     for batch in dataset_train:
         batch = static_dataset_train.expand_batch(batch_to_dict(batch, config['signature_dynamic']))
-        uv_normals = tf.one_hot(batch['uv_normals'], 7)
+        uv_curvature = tf.one_hot(batch['uv_curvature'], 7)
         nr_of_samples=2
 
-        pred = model.sample_single(batch['uv_static'][0], batch['uv_body_posed'][0], uv_normals[0], batch['uv_mask'][0], nr_of_samples=nr_of_samples)
+        pred = model.sample_single(batch['uv_static'][0], batch['uv_body_posed'][0], uv_curvature[0], batch['uv_mask'][0], nr_of_samples=nr_of_samples)
         pose, shape = batch['pose_shape'][0, :72], batch['pose_shape'][0, 72:]
         pose, shape = tf.tile(pose[tf.newaxis,:], [nr_of_samples,1]), tf.tile(shape[tf.newaxis,:], [nr_of_samples,1])
 
@@ -283,7 +281,7 @@ def sample(folder):
         mask = batch['mesh_mask'].numpy().astype(bool)[0]
         _, faces = _maskFaces(np.ones((config['smpl_res'], 3)), F, mask)
 
-        pred_zero = model.sample_single(batch['uv_static'][0], batch['uv_body_posed'][0], uv_normals[0], batch['uv_mask'][0], nr_of_samples=nr_of_samples, zero_latent=True)
+        pred_zero = model.sample_single(batch['uv_static'][0], batch['uv_body_posed'][0], uv_curvature[0], batch['uv_mask'][0], nr_of_samples=nr_of_samples, zero_latent=True)
         mesh_pred_zero = uv2mesh(pred_zero)
         mesh_posed_zero = smpl.run_garment(pose, shape, mesh_pred_zero).numpy()
 
@@ -459,7 +457,7 @@ def train():
             g_balancing_coeff += 1 / 10000 
 
         if step % 10000 == 0:
-            ckpt_saver(model, step, optimizer, None)
+            ckpt_saver(model, step, optimizer)
 
         step += 1
 
@@ -493,6 +491,6 @@ if __name__ == '__main__':
 
     if not args['debug']:
         # model = torch.compile(model)
-        wandb.watch(model, log='all', log_freq=10000, log_graph=True)
+        wandb.watch(model, log='all', log_freq=1000, log_graph=True)
 
     train()

scripts/cvae_norm.py

@@ -1,400 +0,0 @@
-import os
-import sys
-sys.path.append(os.path.dirname(os.path.abspath(__file__)) + '/..')
-
-import importlib
-import argparse
-parser = argparse.ArgumentParser(description='')
-parser.add_argument('--name', type=str)
-parser.add_argument('--config', type=str)
-parser.add_argument('--debug', action='store_true')
-args = vars(parser.parse_args())
-
-config_module = importlib.import_module(args['config'])
-config = config_module.config
-if args['debug']:
-    from configs.cvae_norm_1 import config
-
-os.environ["CUDA_DEVICE_ORDER"]="PCI_BUS_ID"
-os.environ["CUDA_VISIBLE_DEVICES"] = config['gpu']
-if args['debug']:
-    os.environ["CUDA_LAUNCH_BLOCKING"] = '1'
-
-import time
-import argparse
-import wandb
-import tqdm
-import random
-import numpy as np
-import plotly.graph_objects as go
-import plotly.express as ex
-from PIL import Image
-
-if config['is_skirt']:
-    from losses.losses import edge_loss_skirt as edge_loss
-else:
-    from losses.losses import edge_loss
-
-import torch
-import torch.nn as nn
-import torch.optim as optim
-from data.dataset import Dataset
-from models.cond_encoder import AutoEncoder
-from utils.checkpoints import CheckpointSaver, load_model
-from utils.utils import InfiniteDataLoader as DataLoader
-from utils.postprocess import fix_collision
-from losses.losses import collision_loss, normal_loss
-from pytorch_msssim import MS_SSIM
-from models.cvae_norm_model import CVAENorm
-from smpl.smpl_torch import SMPL
-from custom_utils.custom_utils import UV2Mesh, Accumulator, plot_3d, get_summary_html, maskFacesBatch, get_summary_str, plot_3d_collision
-
-
-def init_wandb():
-    run = wandb.init(project='iccv', name=config['name'], notes=config['notes'], dir='/data-local/127/temp', tags=config['tags'])
-    artifact = wandb.Artifact('code', type='code')
-    artifact.add_file('scripts/cvae_norm.py')
-    artifact.add_file('losses/losses.py')
-    artifact.add_file('models/base.py')
-    artifact.add_file('models/cond_encoder.py')
-    artifact.add_file('models/convnext.py')
-    artifact.add_file('models/cvae_norm_model.py')
-    artifact.add_file('data/dataset.py')
-    config_file_names = [key for key in sys.modules.keys()  if key.startswith('configs.')]
-    for config_file_name in config_file_names:
-        file_name = '/'.join(config_file_name.split('.')) + '.py'
-        if os.path.exists(file_name):
-            artifact.add_file(file_name)
-    run.log_artifact(artifact)
-
-uv2mesh = UV2Mesh(res=256, is_skirt=config['is_skirt'], is_smpl_orig=config['is_cape'])
-
-
-def kl_loss(mean: torch.Tensor, logvar: torch.Tensor) -> torch.Tensor:
-    kl_loss = 1 + logvar - torch.square(mean) - torch.exp(logvar)
-    kl_loss = torch.mean(kl_loss)
-    kl_loss *= -0.5
-    return kl_loss
-
-
-def train_step(batch):
-    model.train()
-    pred, mean, logvar = model([batch['uv_normals'], batch['uv_static'], batch['uv_body_posed'], batch['uv_mask']])
-    pred = pred * 1.1
-    mesh_pred = uv2mesh(pred)
-
-
-    l2_loss = torch.mean(1e3 * torch.mean(torch.sum(((batch['uv_normals'] - pred) ** 2), axis=-1), axis=[1, 2]))
-    l2_mesh_loss = torch.mean(1e3 * torch.mean(torch.sum(batch['mesh_mask'][:,:,None] * (batch['mesh_normals'] - mesh_pred) ** 2, axis=-1), axis=-1))
-    ms_ssim = torch.mean(_MSSSIM(pred + 1.1, batch['uv_normals'] + 1.1))
-    kl = kl_loss(mean, logvar)
-
-    reconstr_loss = l2_loss + l2_mesh_loss + (1 - ms_ssim)
-    loss = reconstr_loss + g_balancing_coeff * kl
-
-    optimizer.zero_grad()
-    loss.backward()
-    optimizer.step()
-
-    model.eval()
-    with torch.inference_mode():
-        mean = torch.mean(mean)
-        logvar = torch.mean(logvar)
-        metric = torch.sum(torch.sqrt(torch.sum(batch['mesh_mask'][:,:,None] * (batch['mesh_normals'] - mesh_pred.detach()) ** 2, axis=-1))) / torch.sum(batch['mesh_mask'])
-    
-    return { 'train/loss': loss, 'train/euclid_error': metric,
-             'train/reconstr_loss': reconstr_loss,
-             'train/mean': mean, 'train/logvar': logvar, 'train/kl_loss': kl, 'train/var': np.e ** logvar,
-             'train/l2_loss': l2_loss, 'train/l2_mesh_loss': l2_mesh_loss,
-             'train/ms_ssim': ms_ssim, 
-            }
- 
-
-def valid_step(batch):
-    model.eval()
-    with torch.inference_mode():
-        pred, mean, logvar = model([batch['uv_normals'], batch['uv_static'], batch['uv_body_posed'], batch['uv_mask']])
-        pred = pred * 1.1
-        mesh_pred = uv2mesh(pred)
-
-        l2_loss = torch.mean(1e3 * torch.mean(torch.sum(((batch['uv_normals'] - pred) ** 2), axis=-1), axis=[1, 2]))
-        l2_mesh_loss = torch.mean(1e3 * torch.mean(torch.sum(batch['mesh_mask'][:,:,None] * (mesh_pred - batch['mesh_normals']) ** 2, axis=-1), axis=-1))
-        ms_ssim = torch.mean(_MSSSIM(pred + 1.1, batch['uv_static'] + 1.1))
-        kl = kl_loss(mean, logvar)
-
-        reconstr_loss = l2_loss + l2_mesh_loss + (1 - ms_ssim)
-        loss = reconstr_loss + g_balancing_coeff * kl
-
-        mean = torch.mean(mean)
-        logvar = torch.mean(logvar)
-        metric = torch.sum(torch.sqrt(torch.sum(batch['mesh_mask'][:,:,None] * (batch['mesh_normals'] - mesh_pred.detach()) ** 2, axis=-1))) / torch.sum(batch['mesh_mask'])
-    
-
-    return { 'valid/loss': loss, 'valid/euclid_error': metric, 
-             'valid/reconstr_loss': reconstr_loss, 'valid/l2_mesh_loss': l2_mesh_loss,
-             'valid/mean': mean, 'valid/logvar': logvar, 'valid/kl_loss': kl, 'valid/var': np.e ** logvar,
-             'valid/ms_ssim': ms_ssim, 
-              }
-
-
-def plot_everything(batch: dict, type: str):
-    model.eval()
-    with torch.inference_mode():
-        pred, mean, logvar = model([batch['uv_normals'], batch['uv_static'], batch['uv_body_posed'], batch['uv_mask']])
-    
-    pred = pred * 1.1
-    # mesh_pred = uv2mesh(pred).detach().cpu().numpy()
-    
-    uv_static_img = torch.permute(batch['uv_static'], [0,2,3,1])
-    uv_body_posed_img = torch.permute(batch['uv_body_posed'], [0,2,3,1])
-    orig_img = (torch.permute(batch['uv_normals'], [0,2,3,1]) + 1.1) / 2.2
-    pred_img = torch.permute(pred, [0,2,3,1])
-    img = torch.concat((uv_static_img, uv_body_posed_img, orig_img, pred_img), axis=2)
-    imgs = [wandb.Image((img[i].cpu().numpy() + 1) / 2.0) for i in range(4)]
-    
-    # F = np.load("smpl/smpl_faces" + skirt_modifier + ("_orig" if config['is_cape'] else "") + ".npy")
-    # mask = batch['mesh_mask'].cpu().numpy().astype(bool)
-
-    mean_hist = wandb.Histogram(sequence=mean.cpu().numpy().mean(axis=0))
-    logvar_hist = wandb.Histogram(sequence=logvar.cpu().numpy().mean(axis=0))
-
-    return { **{ type + '/images': imgs, type + '/mean_hist': mean_hist, type + '/logvar_hist': logvar_hist } }
-
-
-def sample(folder): 
-    # run = wandb.init(project='vae_plots', name=folder.split('/')[-1])
-    load_model(model,folder)
-    count = 0
-    for batch in dataset_train:
-        batch = static_dataset_train.expand_batch(batch_to_dict(batch, config['signature_dynamic']))
-        uv_normals = tf.one_hot(batch['uv_normals'], 7)
-        nr_of_samples=2
-
-        pred = model.sample_single(batch['uv_static'][0], batch['uv_body_posed'][0], uv_normals[0], batch['uv_mask'][0], nr_of_samples=nr_of_samples)
-        pose, shape = batch['pose_shape'][0, :72], batch['pose_shape'][0, 72:]
-        pose, shape = tf.tile(pose[tf.newaxis,:], [nr_of_samples,1]), tf.tile(shape[tf.newaxis,:], [nr_of_samples,1])
-
-        mesh_pred = uv2mesh(pred)
-        mesh_posed = smpl.run_garment(pose, shape, mesh_pred).numpy()
-        mesh_orig = batch['mesh_posed'][0].numpy()
-        mesh_orig_reposed = smpl.run_garment(pose[:1], shape[:1], batch['mesh_unposed'][:1]).numpy()[0]
-
-        body = batch['mesh_body_posed'][0].numpy()
-        body_color = np.ones_like(body, dtype=np.int32)*100
-
-        F = np.load("custom_utils/smpl_faces.npy")
-        mask = batch['mesh_mask'].numpy().astype(bool)[0]
-        _, faces = _maskFaces(np.ones((config['smpl_res'], 3)), F, mask)
-
-        pred_zero = model.sample_single(batch['uv_static'][0], batch['uv_body_posed'][0], uv_normals[0], batch['uv_mask'][0], nr_of_samples=nr_of_samples, zero_latent=True)
-        mesh_pred_zero = uv2mesh(pred_zero)
-        mesh_posed_zero = smpl.run_garment(pose, shape, mesh_pred_zero).numpy()
-
-
-        meshes = []
-        meshes.append(go.Mesh3d(
-                    # 8 vertices of a cube
-                    x=mesh_orig_reposed[mask,0],
-                    y=mesh_orig_reposed[mask,2],
-                    z=mesh_orig_reposed[mask,1],
-                    # i, j and k give the vertices of triangles
-                    i = faces[:,0],
-                    j = faces[:,1],
-                    k = faces[:,2]
-                    ))
-
-        for i in range(nr_of_samples):
-            x = mesh_posed[i][mask, :].copy()
-            # x[:, 2] += 1 * (i + 1)
-            x[:, 2] += 1
-            meshes.append(go.Mesh3d(
-                        # 8 vertices of a cube
-                        x=x[:,0],
-                        y=x[:,2],
-                        z=x[:,1],
-                        # i, j and k give the vertices of triangles
-                        i = faces[:,0],
-                        j = faces[:,1],
-                        k = faces[:,2]
-                        ))
-
-        
-        for i in range(nr_of_samples):
-            x = mesh_posed_zero[i][mask, :].copy()
-            # x[:, 2] += 1 * (i + 1)
-            x[:, 2] += 2
-            meshes.append(go.Mesh3d(
-                        # 8 vertices of a cube
-                        x=x[:,0],
-                        y=x[:,2],
-                        z=x[:,1],
-                        # i, j and k give the vertices of triangles
-                        i = faces[:,0],
-                        j = faces[:,1],
-                        k = faces[:,2]
-                        ))
-
-        # for i in range(5):
-        #     x = body.copy()
-        #     x[:, 2] += 1 * i
-        #     meshes.append(go.Mesh3d(
-        #                 # 8 vertices of a cube
-        #                 x=x[:,0],
-        #                 y=x[:,2],
-        #                 z=x[:,1],
-        #                 # i, j and k give the vertices of triangles
-        #                 i = F[:,0],
-        #                 j = F[:,1],
-        #                 k = F[:,2],
-        #                 vertexcolor=body_color
-        #                 ))
-
-
-        fig = go.Figure(data=meshes)
-
-        fig.update_layout(scene_aspectmode='manual', scene_aspectratio=dict(x=1, y=2, z=1))
-        # fig.update_layout(scene_aspectmode='manual', scene_aspectratio=dict(x=1, y=nr_of_samples-1, z=1))
-        fig.update_layout(
-            scene = dict(
-                xaxis = dict(nticks=4, range=[-1,1],),
-                            # yaxis = dict(nticks=4, range=[-1,nr_of_samples+1],),
-                            yaxis = dict(nticks=4, range=[-1,3],),
-                            zaxis = dict(nticks=4, range=[-1,1],),)
-                            )
-
-        # wandb.log({'plot_' + str(count): fig})
-        fig.show()
-
-        pred = pred.numpy()
-        frames = [Image.fromarray(((pred[i] + 1) * 128).astype(np.int8), mode='RGB') for i in range(pred.shape[0])]
-        frames[0].save("temp/garment_1.gif", format="GIF", append_images=frames[1:],
-               save_all=True, duration=500, loop=0)
-
-
-        if count > 10:
-            break
-
-        print(count)
-        count += 1
-
-        print()
-
-
-
-def test():
-    str_split = config['name'].split('_')
-    test_idx = str_split.index('test')
-    checkpoint_name = '_'.join(str_split[:test_idx])
-    load_model(model, 'checkpoints/' + checkpoint_name)
-
-    dataset_test = factory.get_dataset(folder=config['test_dir'], batch_size=config['batch_size'], signature=config['signature_dynamic'], use_filled=config['use_filled'], resolutions=[config['resolution']], in_memory=False, do_repeat=False)
-    static_dataset_test = StaticDataset(folder=config['test_dir'], signature=config['signature_static'], use_filled=config['use_filled'], resolutions=[config['resolution']], in_memory=False)
-   
-    step = 0
-    losses = []
-
-    for batch in tqdm.tqdm(dataset_test):
-        batch = static_dataset_test.expand_batch(batch_to_dict(batch, config['signature_dynamic']))
-
-        test_loss = test_step(batch)
-        losses.append(test_loss)
-
-        to_log = { **{ 'current_step': step }, **test_loss }
-        if step % 1000 == 0:
-            figs = plot_everything(batch, 'test')
-            to_log = { **to_log, **figs }
-
-        wandb.log(to_log, step = step)
-        
-        # print(step)
-        step += 1
-   
-    # averages = dict()
-    path_to_plotly_html = "temp/plotly_figure.html"
-
-    histograms = dict()
-    for key in test_loss.keys():
-        accumulated = [losses[i][key].numpy() for i in range(len(losses))]
-        fig = ex.histogram(accumulated, title='Average: ' + str(np.asarray(accumulated).mean()))
-        fig.write_html(path_to_plotly_html, auto_play = False)
-
-        histograms['all/' + key.split('/')[-1] + '_hist'] = wandb.Html(path_to_plotly_html)
-        # averages['all/' + key.split('/')[-1] + '_avg'] = np.asarray(accumulated).mean()
-
-    
-
-    wandb.log({ **histograms }, step = step)
-    wandb.finish()
-    pass
-
-
-
-def train():
-    global g_balancing_coeff
-    global step
-    valid_iterator = iter(valid_dataloader)
-
-    for batch in train_dataloader:
-        train_loss = train_step(batch)
-        train_accumulator.update(train_loss)
-
-        if step % 25 == 0:
-            data_valid = next(valid_iterator)
-            valid_loss = valid_step(data_valid)
-            valid_accumulator.update(valid_loss)
-
-        if step % 1000 == 0 or (step < 1000 and step % 100 == 0):
-            to_log = dict({ **train_loss, **valid_loss, **{ 'current_step': step } })
-            if step % 5000 == 0 or (step < 5000 and step % 1000 == 0):
-                train_figs = plot_everything(batch, 'train')
-                valid_figs = plot_everything(data_valid, 'valid')
-                to_log = { **to_log, **train_figs, **valid_figs }
-            if step == 0:
-                to_log = { **to_log, **{ 'model/summary': wandb.Html(get_summary_html(model)) } }
-
-            if not args['debug']:
-                wandb.log(to_log, step=step)
-            train_accumulator.reset()
-            valid_accumulator.reset()
-            print(step)
-
-        if train_loss['train/euclid_error'] < (config['balancing_activation_limit'] if 'balancing_activation_limit' in config.keys() else 0.017):
-            g_balancing_coeff += 1 / 10000 
-
-        if step % 10000 == 0:
-            ckpt_saver(model, step, optimizer, None)
-
-        step += 1
-
-
-if __name__ == '__main__':
-    if not args['debug']:
-        init_wandb()
-
-    smpl = SMPL(orig_smpl=config['is_cape'], path='smpl', device=config['device'])
-    skirt_modifier = '_skirt' if config['is_skirt'] else ''
-
-    dataset_train = Dataset(config['train_dir'], config['signature'], device=config['device'], frames_file=config['train_frames'], use_cache=config['dataset_in_memory'])
-    dataset_valid = Dataset(config['valid_dir'], config['signature'], device=config['device'], frames_file=config['valid_frames'], use_cache=config['dataset_in_memory'])
-    train_dataloader = DataLoader(dataset_train, batch_size=4, drop_last=True, shuffle=True, )
-    valid_dataloader = DataLoader(dataset_valid, batch_size=4, drop_last=True, shuffle=True)
-    train_accumulator = Accumulator()
-    valid_accumulator = Accumulator()
-
-    model = CVAENorm(config)
-
-    optimizer = optim.Adam(model.parameters(), lr=config['lr'])
-    _MSSSIM = MS_SSIM(data_range=2, size_average=True, channel=3)
-    g_balancing_coeff = config['starting_balancing_coeff']
-
-    ckpt_saver = CheckpointSaver('checkpoints/iccv/' + config['name'], top_n=5)
-
-    step = 0
-    if config['pretrained_model'] != '':
-        step = load_model(model, config['pretrained_model'])
-
-    if not args['debug']:
-        # model = torch.compile(model)
-        wandb.watch(model, log='all', log_freq=10000, log_graph=True)
-
-    train()

scripts/direct_train.py

@@ -0,0 +1,281 @@
+import os
+import sys
+sys.path.append(os.path.dirname(os.path.abspath(__file__)) + '/..')
+
+import importlib
+import argparse
+parser = argparse.ArgumentParser(description='')
+parser.add_argument('--name', type=str)
+parser.add_argument('--config', type=str)
+parser.add_argument('--debug', action='store_true')
+args = vars(parser.parse_args())
+
+config_module = importlib.import_module(args['config'])
+config = config_module.config
+if args['debug']:
+    from configs.direct_1 import config
+    # from configs.ae_static_orig_2 import config
+os.environ["CUDA_DEVICE_ORDER"]="PCI_BUS_ID"
+os.environ["CUDA_VISIBLE_DEVICES"] = config['gpu']
+if args['debug']:
+    os.environ["CUDA_LAUNCH_BLOCKING"] = '1'
+
+import time
+import argparse
+import wandb
+import random
+import numpy as np
+import torch
+# from torchmetrics import MultiScaleStructuralSimilarityIndexMeasure as MSSSIM
+from custom_utils.custom_utils import UV2Mesh, get_summary_html, maskFacesBatch, plot_3d_collision
+import plotly.graph_objects as go
+import plotly.express as ex
+import torch.optim as optim
+
+if config['is_skirt']:
+    from losses.losses import edge_loss_skirt as edge_loss
+else:
+    from losses.losses import edge_loss
+
+from data.dataset import Dataset
+# from torch.utils.data import DataLoader
+from losses.losses import collision_loss, normal_loss
+from utils.postprocess import fix_collision
+from custom_utils.custom_utils import plot_3d
+from utils.checkpoints import CheckpointSaver, load_model
+from custom_utils.custom_utils import Accumulator
+from utils.utils import InfiniteDataLoader as DataLoader
+from models.cond_encoder import AutoEncoder as Model
+from smpl.smpl_torch import SMPL
+
+from pytorch_msssim import MS_SSIM
+
+
+def init_wandb():
+    run = wandb.init(project='iccv', name=config['name'], notes=config['notes'], dir='/data-local/127/temp', tags=config['tags'])
+    artifact = wandb.Artifact('code', type='code')
+    artifact.add_file('scripts/direct_train.py')
+    artifact.add_file('losses/losses.py')
+    artifact.add_file('models/base.py')
+    artifact.add_file('models/cond_encoder.py')
+    artifact.add_file('models/convnext.py')
+    artifact.add_file('data/dataset.py')
+    config_file_names = [key for key in sys.modules.keys()  if key.startswith('configs.')]
+    for config_file_name in config_file_names:
+        file_name = '/'.join(config_file_name.split('.')) + '.py'
+        if os.path.exists(file_name):
+            artifact.add_file(file_name)
+    run.log_artifact(artifact)
+
+uv2mesh = UV2Mesh(res=256, is_skirt=config['is_skirt'], is_smpl_orig=config['is_cape'])
+
+
+
+def train_step(batch):
+    model.train()
+    # with torch.autocast(device_type='cuda', dtype=torch.float16, enabled=use_amp):
+    if config['use_curvature']:
+        input = torch.cat([batch['uv_curvature'], batch['uv_static']], axis=1)
+    else:
+        input = torch.cat([batch['uv_body_posed'], batch['uv_static']], axis=1)
+    pred = model([input, batch['uv_mask']])
+
+    mesh_pred = uv2mesh(pred)
+    mesh_orig = batch['mesh_unposed']
+    shape = batch['pose_shape'][:, 72:]
+    gender = torch.greater_equal(shape[:, 10] , 0.5).to(torch.long)
+    shape_offsets = torch.stack([torch.tensordot(shape[i,:10][None, :], smpl.shapedirs[gender[i]], dims=[[1], [2]])[0,smpl.to_keep,:] for i in range(shape.shape[0])])
+    mesh_pred_shaped = mesh_pred + shape_offsets * batch['mesh_mask'][:,:,None]
+    mesh_pred_posed = smpl(batch['pose_shape'][:, :72], batch['pose_shape'][:, 72:], mesh_pred_shaped)[0]
+ 
+    e_loss = torch.mean(edge_loss(mesh_pred, mesh_orig, batch['mesh_mask']))
+    c_loss, c_ratio = collision_loss(mesh_pred_posed, batch['mesh_body_posed'], batch['mesh_mask'])
+    c_loss, c_ratio = torch.mean(c_loss), torch.mean(c_ratio)
+    # l2_loss = torch.mean(1e3 * torch.mean(torch.sum(((batch['uv_unposed'] - pred) ** 2), axis=-1), axis=[1, 2]))
+    l2_mesh_loss = torch.mean(1e3 * torch.mean(torch.sum(batch['mesh_mask'][:,:,None] * (batch['mesh_posed'] - mesh_pred_posed) ** 2, axis=-1), axis=-1))
+    n_loss = normal_loss(mesh_pred_posed, batch['mesh_posed'], batch['mesh_mask'], is_skirt=config['is_skirt'], is_smpl_orig=config['is_cape'])
+
+    loss = l2_mesh_loss + (e_loss + c_loss + n_loss) * config['reg_loss_coeff']
+
+    optimizer.zero_grad()
+    loss.backward()
+    optimizer.step()
+    # scaler.scale(loss).backward()
+    # scaler.step(optimizer)
+    # scaler.update()
+    # optimizer.zero_grad()
+
+    model.eval()
+    with torch.inference_mode():
+        ms_ssim = torch.mean(_MSSSIM(pred + 1, batch['uv_unposed'] + 1))
+        metric = torch.sum(torch.sqrt(torch.sum(batch['mesh_mask'][:,:,None] * (mesh_orig - mesh_pred.detach()) ** 2, axis=-1))) / torch.sum(batch['mesh_mask'])
+    
+    return { 'train/loss': loss, 'train/edge_loss': e_loss, 'train/euclid_error': metric, 'train/collision_ratio': c_ratio,
+             'train/ms_ssim': ms_ssim, 'train/collision_loss': c_loss, 'train/l2_mesh_loss': l2_mesh_loss,
+             'train/normal_loss': n_loss }
+        
+
+def valid_step(batch):
+    model.eval()
+
+    with torch.inference_mode():
+        if config['use_curvature']:
+            input = torch.cat([batch['uv_curvature'], batch['uv_static']], axis=1)
+        else:
+            input = torch.cat([batch['uv_body_posed'], batch['uv_static']], axis=1)
+        pred = model([input, batch['uv_mask']])
+        mesh_pred = uv2mesh(pred)
+        mesh_orig = batch['mesh_unposed']
+        shape = batch['pose_shape'][:, 72:]
+        gender = torch.greater_equal(shape[:, 10] , 0.5).to(torch.long)
+        shape_offsets = torch.stack([torch.tensordot(shape[i,:10][None, :], smpl.shapedirs[gender[i]], dims=[[1], [2]])[0,smpl.to_keep,:] for i in range(shape.shape[0])])
+        mesh_pred_shaped = mesh_pred + shape_offsets * batch['mesh_mask'][:,:,None]
+        mesh_pred_posed = smpl(batch['pose_shape'][:, :72], batch['pose_shape'][:, 72:], mesh_pred_shaped)[0]
+    
+        e_loss = torch.mean(edge_loss(mesh_pred, mesh_orig, batch['mesh_mask']))
+        c_loss, c_ratio = collision_loss(mesh_pred_posed, batch['mesh_body_posed'], batch['mesh_mask'])
+        c_loss, c_ratio = torch.mean(c_loss), torch.mean(c_ratio)
+        # l2_loss = torch.mean(1e3 * torch.mean(torch.sum(((batch['uv_unposed'] - pred) ** 2), axis=-1), axis=[1, 2]))
+        l2_mesh_loss = torch.mean(1e3 * torch.mean(torch.sum(batch['mesh_mask'][:,:,None] * (batch['mesh_posed'] - mesh_pred_posed) ** 2, axis=-1), axis=-1))
+        n_loss = normal_loss(mesh_pred_posed, batch['mesh_posed'], batch['mesh_mask'], is_skirt=config['is_skirt'], is_smpl_orig=config['is_cape'])
+
+        ms_ssim = torch.mean(_MSSSIM(pred + 1, batch['uv_unposed'] + 1))
+        loss = l2_mesh_loss + (e_loss + c_loss + n_loss) * config['reg_loss_coeff']
+
+        metric = torch.sum(torch.sqrt(torch.sum(batch['mesh_mask'][:,:,None] * (mesh_orig - mesh_pred) ** 2, axis=-1))) / torch.sum(batch['mesh_mask'])
+    
+    return { 'valid/loss': loss, 'valid/edge_loss': e_loss, 'valid/euclid_error': metric, 'valid/collision_ratio': c_ratio,
+             'valid/ms_ssim': ms_ssim, 'valid/collision_loss': c_loss, 'valid/l2_mesh_loss': l2_mesh_loss,
+             'valid/normal_loss': n_loss }
+       
+
+def plot_everything(batch: dict, type: str):
+    model.eval()
+    with torch.inference_mode():
+        if config['use_curvature']:
+            input = torch.cat([batch['uv_curvature'], batch['uv_static']], axis=1)
+        else:
+            input = torch.cat([batch['uv_body_posed'], batch['uv_static']], axis=1)
+        pred = model([input, batch['uv_mask']]).detach()
+
+    mesh_pred = uv2mesh(pred).cpu().numpy()
+    mesh_orig = batch['mesh_unposed'].cpu().numpy()
+    
+    orig_img = torch.permute(batch['uv_unposed'], [0,2,3,1])
+    uv_static_img = torch.permute(batch['uv_static'], [0,2,3,1])
+    uv_body_posed_img = torch.permute(batch['uv_body_posed'], [0,2,3,1])
+    pred_img = torch.permute(pred, [0,2,3,1])
+    img = torch.concat((uv_static_img, uv_body_posed_img, orig_img, pred_img), axis=2)
+    imgs = [wandb.Image((img[i].cpu().numpy() + 1) / 2.0) for i in range(4)]
+    
+    F = np.load("smpl/smpl_faces" + skirt_modifier + ("_orig" if config['is_cape'] else "") + ".npy")
+    mask = batch['mesh_mask'].cpu().numpy().astype(bool)
+
+    shape = batch['pose_shape'][:, 72:]
+    gender = torch.greater_equal(shape[:, 10] , 0.5).to(torch.long)
+    shape_offsets = torch.stack([torch.tensordot(shape[i,:10][None, :], smpl.shapedirs[gender[i]], dims=[[1], [2]])[0,smpl.to_keep,:] for i in range(shape.shape[0])]).cpu().numpy()
+
+    garment_unposed, faces = maskFacesBatch(mesh_pred, F, mask)
+    garment_unposed = [garment_unposed[i] + shape_offsets[i, mask[i], :] for i in range(mask.shape[0])]
+    gt = [mesh_orig[i][mask[i], :] + shape_offsets[i, mask[i], :] for i in range(pred.shape[0])]
+
+    for i in range(mesh_orig.shape[0]):
+        mesh_pred[i, mask[i], :] += shape_offsets[i, mask[i], :]
+    mesh_posed = smpl(batch['pose_shape'][:, :72], batch['pose_shape'][:, 72:], torch.tensor(mesh_pred, device=config['device']))[0].cpu().numpy()
+
+    gt_posed = [batch['mesh_posed'].cpu().numpy()[i, mask[i], :] for i in range(mask.shape[0])]
+
+    mesh_posed_fixed = fix_collision(torch.tensor(mesh_posed, device=config['device']), batch['mesh_body_posed'], torch.tensor(mask, device=config['device'])).cpu().numpy()
+    body = batch['mesh_body_posed'].cpu().numpy()
+
+    garment_posed = [mesh_posed[i, mask[i], :] for i in range(body.shape[0])]
+    collision = [np.concatenate((body[i], garment_posed[i]), axis=0) for i in range(len(garment_posed))]
+    collision_faces = [np.concatenate((F, faces[i] + config['smpl_res']), axis=0) for i in range(len(garment_posed))]
+    collision_color = [np.concatenate((np.ones_like(body[i], dtype=np.int32)*100, np.ones_like(garment_posed[i], dtype=np.int32)*230), axis=0) for i in range(len(garment_posed))]
+
+    garment_posed_fixed = [mesh_posed_fixed[i, mask[i], :] for i in range(body.shape[0])]
+    collision_fixed = [np.concatenate((body[i], garment_posed_fixed[i]), axis=0) for i in range(len(garment_posed))]
+    collision_gt = [np.concatenate((body[i], gt_posed[i]), axis=0) for i in range(len(garment_posed))]
+
+    figs = { type + "/garment_" + str(i): plot_3d(gt[i], garment_unposed[i], faces[i], collision[i], collision_faces[i], collision_color[i]) for i in range(4) }
+    figs_coll = { type + "/garment_" + str(i) + '_collision': plot_3d_collision(collision_gt[i], collision[i], collision_fixed[i], collision_faces[i], collision_color[i]) for i in range(4) }
+
+    return { **figs, **figs_coll, **{ type + '/images': imgs, } }
+
+
+def train():
+    valid_iterator = iter(valid_dataloader)
+
+    step = 0
+    for batch in train_dataloader:
+        train_loss = train_step(batch)
+        train_accumulator.update(train_loss)
+
+        if step % 25 == 0:
+            data_valid = next(valid_iterator)
+            valid_loss = valid_step(data_valid)
+            valid_accumulator.update(valid_loss)
+
+        if step % 1000 == 0 or (step < 1000 and step % 100 == 0):
+            to_log = dict({ **train_loss, **valid_loss, **{ 'current_step': step } })
+            if step % 5000 == 0 or (step < 5000 and step % 1000 == 0):
+                train_figs = plot_everything(batch, 'train')
+                valid_figs = plot_everything(data_valid, 'valid')
+                to_log = { **to_log, **train_figs, **valid_figs }
+            if step == 0:
+                to_log = { **to_log, **{ 'model/summary': wandb.Html(get_summary_html(model)) } }
+
+            if not args['debug']:
+                wandb.log(to_log, step=step)
+            train_accumulator.reset()
+            valid_accumulator.reset()
+            print(step)
+
+        if step % 10000 == 0:
+            ckpt_saver_enc(model.encoder, step, optimizer, scaler)
+            ckpt_saver_dec(model.decoder, step, optimizer, scaler)
+
+        step += 1
+
+
+if __name__ == '__main__':
+    if not args['debug']:
+        init_wandb()
+    
+    use_amp = True
+    skirt_modifier = '_skirt' if config['is_skirt'] else ''
+
+    # dataset = Dataset('/data-local/127/train', config['signature'], resolutions=[512], device=device, frames_file='frames_jumpsuit.txt')
+    dataset_train = Dataset(config['train_dir'], config['signature'], device=config['device'], frames_file=config['train_frames'], use_cache=config['dataset_in_memory'], is_cape=config['is_cape'])
+    dataset_valid = Dataset(config['valid_dir'], config['signature'], device=config['device'], frames_file=config['valid_frames'], use_cache=config['dataset_in_memory'], is_cape=config['is_cape'])
+    train_dataloader = DataLoader(dataset_train, batch_size=4, drop_last=True, shuffle=True, )
+    valid_dataloader = DataLoader(dataset_valid, batch_size=4, drop_last=True, shuffle=True)
+    train_accumulator = Accumulator()
+    valid_accumulator = Accumulator()
+
+    model : Model = Model(config)
+    optimizer = optim.Adam(model.parameters(), lr=config['lr'])
+    scaler = torch.cuda.amp.GradScaler(enabled=use_amp)
+    smpl = SMPL(orig_smpl=config['is_cape'], path='smpl', device=config['device'])
+
+    # _MSSSIM = MSSSIM(data_range=2).to(config['device'])
+    _MSSSIM = MS_SSIM(data_range=2, size_average=True, channel=3)
+
+    if config['pretrained_model'] != '':
+        load_model(model.encoder, config['pretrained_model'] + '_enc')
+        load_model(model.decoder, config['pretrained_model'] + '_dec')
+
+    ckpt_saver_enc = CheckpointSaver('checkpoints/iccv/torch/' + config['name'] + '_enc', top_n=5)
+    ckpt_saver_dec = CheckpointSaver('checkpoints/iccv/torch/' + config['name'] + '_dec', top_n=5)
+
+    run_name = config['name']
+    print(f'started training: {run_name}')
+
+    if not args['debug']:
+        # model = torch.compile(model)
+        wandb.watch(model, log='all', log_freq=1000, log_graph=True)
+
+    train()
+
+
+

smpl/smpl_torch.py

@@ -206,9 +206,9 @@ class SMPL(Module):
         )
       )
     
-    joints = torch.matmul(results, torch.transpose(torch.concat([J, torch.ones((J.shape[0], 24, 1), dtype=torch.float32, device=J.get_device())], axis=-1)[:,:,None,:],2,3))[:,:,:3,0]
+    joints = torch.matmul(results, torch.transpose(torch.concat([J, torch.ones((J.shape[0], 24, 1), dtype=torch.float32, device=J.device)], axis=-1)[:,:,None,:],2,3))[:,:,:3,0]
             
-    T = torch.stack([torch.tensordot(results[i], self.weights[torch.greater(g, 0.5).to(torch.long)], dims=([0], [1])).permute(2, 0, 1) for i, g in enumerate(betas[:,-1])])
+    T = torch.stack([torch.tensordot(results[i], self.weights_all[torch.greater(g, 0.5).to(torch.long)], dims=([0], [1])).permute(2, 0, 1) for i, g in enumerate(betas[:,-1])])
     rest_shape_h = torch.cat(
       (v_posed, torch.ones((batch_num, v_posed.shape[1], 1), dtype=torch.float32).to(self.device)), dim=2
     )
@@ -230,4 +230,4 @@ class SMPL(Module):
     if remove and verts is None:
       result = result[:,self.to_keep,:]
 
-    return result, joints, v_shaped, v_posed
+    return result, joints

utils/postprocess.py

@@ -22,7 +22,7 @@ from losses.losses import _nearest_neighbour
 """ COLLISION FUNCTIONS START """
 # F = np.load("smpl/smpl_faces.npy")
 to_keep = sio.loadmat('smpl/keep_remove.mat')['keep'].reshape(-1)
-F_fix_coll = torch.tensor(np.tile(np.load("smpl/smpl_faces.npy")[None,:,:], [4,1,1]), device='cuda')
+F_fix_coll = torch.tensor(np.tile(np.load("smpl/smpl_faces.npy")[to_keep,:][None,:,:], [4,1,1]), device='cuda')
 smpl_to_keep_orig_post = sio.loadmat('smpl/keep_remove.mat')['keep'].reshape(-1)
 smpl_to_keep_orig_post = smpl_to_keep_orig_post[smpl_to_keep_orig_post < 6890]
 F_fix_coll_orig = torch.tensor(np.tile(np.load("smpl/smpl_faces_orig.npy")[:6890,:][None,:,:], [4,1,1]), device='cuda')[:,smpl_to_keep_orig_post,:]