save

This reverts commit ac27319860.

aaa_helpers.txt

@@ -1,7 +1,13 @@
 nohup python cvae.py --name="lhunor_weights_test_6" > nohup/iccv/weights_test_6.out 2>&1 &
 nohup python evaluate_ae.py --name iccv_weights_test_6 > nohup/iccv/evaluate_iccv_weights_test_6.out 2>&1 &
 nohup python calculate_error.py --name iccv_weights_test_6 > nohup/iccv/error_iccv_weights_test_6.out 2>&1 &
+nohup python auto_encoder_static.py --name="lhunor_ae_static_iccv_resnet_2" > nohup/iccv/encoders/ae_static_iccv_resnet_2.out 2>&1 &
+nohup python auto_encoder_curv.py --name="lhunor_ae_curv_iccv_resnet_2" > nohup/iccv/encoders/ae_curv_iccv_resnet_2.out 2>&1 &
+nohup python auto_encoder_body.py --name="lhunor_ae_body_iccv_resnet_2" > nohup/iccv/encoders/ae_body_iccv_resnet_2.out 2>&1 &
 
+nohup python cvae_pyramid.py --name="lhunor_iccv_pyr_32_res_skirt" > nohup/iccv/pyr/iccv_pyr_32_res_skirt.out 2>&1 &
+nohup python evaluate_ae_pyramid.py --name evaluate_iccv_pyr_32_res > nohup/iccv/evaluate/iccv_pyr_32_res.out 2>&1 &
+nohup python evaluate_ae_pyramid.py --name evaluate_iccv_pyr_32_res_skirt > nohup/iccv/evaluate/iccv_pyr_32_res_skirt.out 2>&1 &
 
 one final convolutional layer for smoothing, on the final coordinates
 
@@ -74,6 +80,7 @@ nohup python cvae.py --name="lhunor_abl_skin_var_4" > nohup/ablation/abl_skin_va
 nohup python cvae_curv.py --name="lhunor_cvae_curv" > nohup/ablation/cvae_curv.out 2>&1 &
 nohup python cvae_curv.py --name="lhunor_cvae_curv_2" > nohup/ablation/cvae_curv_2.out 2>&1 &
 
+nohup python cvae_pyramid.py --name="lhunor_iccv_pyr_32_res" > nohup/iccv/pyr/iccv_pyr_32_res.out 2>&1 &
 
 abl_2_pyr_32_64_128
 abl_2_pyr_64_cape_f_03223_SS
@@ -136,7 +143,7 @@ nohup python evaluate_ae_pyramid.py --name evaluate_ae_abl_pyr_32_skirt > nohup/
 nohup python evaluate_ae.py --name abl_norm_skirt_70k > nohup/evaluate/abl_norm_skirt_70k.out 2>&1 &
 nohup python calculate_error.py --name error_abl_2_pyr_32_64_128_skirt > nohup/error_ae_abl_skin_skirt_70k.out 2>&1 &
 
-nohup python evaluate_ae_pyramid.py --name abl_2_pyr_32_64_100k > nohup/evaluate/abl_2_pyr_32_64_100k.out 2>&1 &
+nohup python evaluate_ae_pyramid.py --name pyr_32_res_skirt > nohup/evaluate/pyr_32_res_skirt.out 2>&1 &
 nohup python evaluate_ae_pyramid.py --name abl_2_pyr_32_64_128_80k > nohup/evaluate/abl_2_pyr_32_64_128_80k.out 2>&1 &
 nohup python evaluate_ae_pyramid.py --name abl_2_pyr_32_64_128_256_512_skirt_50k > nohup/evaluate/abl_2_pyr_32_64_128_256_512_skirt_50k.out 2>&1 &
 

auto_encoder_body.py

@@ -1,6 +1,6 @@
 import os
 import sys
-from configs.config_ae_body_post import config
+from configs.iccv.config_ae_body import config
 os.environ["CUDA_VISIBLE_DEVICES"] = config['gpu']
 
 import tensorflow as tf
@@ -31,10 +31,11 @@ from losses import edge_loss, uv_mask_loss
 from dataset import DatasetFactory, StaticDataset
 from custom_utils.custom_utils import batch_to_dict, plot_3d
 from models.cond_encoder import AutoEncoderNew as AutoEncoder
+from custom_utils.custom_utils import Accumulator
 
 
 def init_wandb():
-    run = wandb.init(project='ae', name=config['name'], notes=config['notes'], dir='/home/workspace/local-data/temp')
+    run = wandb.init(project='ae', name=config['name'], notes=config['notes'], dir='/tmp', tags=config['tags'])
     artifact = wandb.Artifact('code', type='code')
     artifact.add_file('auto_encoder_body.py')
     artifact.add_file('losses.py')
@@ -44,7 +45,9 @@ def init_wandb():
     artifact.add_file('convnext/models/convnext_tf.py')
     config_file_names = [key for key in sys.modules.keys()  if key.startswith('configs.')]
     for config_file_name in config_file_names:
-        artifact.add_file('/'.join(config_file_name.split('.')) + '.py')
+        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_smpl_orig=config['is_cape'], is_skirt=config['is_skirt'])
@@ -60,9 +63,10 @@ def train_step(batch):
 
         e_loss = 1e-2 * tf.reduce_mean(edge_loss(mesh_pred, mesh_orig, tf.ones((pred.shape[0], 3638 if config['is_cape'] else 14475))))
         l1_loss = tf.reduce_mean(tf.reduce_sum(((tf.math.abs(batch['uv_body_posed' + resolution_modifier] - pred))), axis=1))
-        ms_ssim = tf.reduce_mean(tf.image.ssim_multiscale(pred + 1, batch['uv_body_posed' + resolution_modifier] + 1, max_val=2, power_factors=(0.5, 0.2, 0.1, 0.1, 0.1)))
+        # ms_ssim = tf.reduce_mean(tf.image.ssim_multiscale(pred + 1, batch['uv_body_posed' + resolution_modifier] + 1, max_val=3, power_factors=(0.5, 0.2, 0.1, 0.1, 0.1)))
+        ms_ssim = tf.reduce_mean(tf.image.ssim(pred + 1, batch['uv_body_posed' + resolution_modifier] + 1, max_val=3))
 
-        loss = 1e3 * (1 - ms_ssim)
+        loss = l1_loss
 
     metric = tf.reduce_mean(tf.math.sqrt(tf.reduce_sum((mesh_orig - mesh_pred) ** 2, axis=-1)))
     gradients = tape.gradient(loss, model.trainable_variables)
@@ -80,9 +84,10 @@ def valid_step(batch):
 
     e_loss = 1e-2 * tf.reduce_mean(edge_loss(mesh_pred, mesh_orig, tf.ones((pred.shape[0], 3638 if config['is_cape'] else 14475))))
     l1_loss = tf.reduce_mean(tf.reduce_sum(((tf.math.abs(batch['uv_body_posed' + resolution_modifier] - pred))), axis=1))
-    ms_ssim = tf.reduce_mean(tf.image.ssim_multiscale(pred + 1, batch['uv_body_posed' + resolution_modifier] + 1, max_val=2, power_factors=(0.5, 0.2, 0.1, 0.1, 0.1)))
+    # ms_ssim = tf.reduce_mean(tf.image.ssim_multiscale(pred + 1, batch['uv_body_posed' + resolution_modifier] + 1, max_val=3, power_factors=(0.5, 0.2, 0.1, 0.1, 0.1)))
+    ms_ssim = tf.reduce_mean(tf.image.ssim(pred + 1, batch['uv_body_posed' + resolution_modifier] + 1, max_val=3))
 
-    loss = 1e3 * (1 - ms_ssim)
+    loss = l1_loss
 
     metric = tf.reduce_mean(tf.math.sqrt(tf.reduce_sum((mesh_orig - mesh_pred) ** 2, axis=-1)))
     return { 'valid/loss': loss, 'valid/edge_loss': e_loss, 'valid/l1_loss': l1_loss, 'valid/euclid_error': metric, 'valid/ms_ssim': ms_ssim, }
@@ -124,13 +129,17 @@ def train():
     for batch in dataset_train:
         batch = static_dataset_train.expand_batch(batch_to_dict(batch, config['signature_dynamic']))
         train_loss = train_step(batch)
+        train_accumulator.update(train_loss)
 
+        if step % 50 == 0:
             data_valid = valid_iterator.get_next()
             data_valid = static_dataset_valid.expand_batch(batch_to_dict(data_valid, config['signature_dynamic']))
             valid_loss = valid_step(data_valid)
+            valid_accumulator.update(valid_loss)
 
-        to_log = { **train_loss, **valid_loss, **{ 'current_step': step} }
+        if step % 1000 == 0 or (step < 1000 and step % 100 == 0):
-        if step % 5000 == 0 or (step < 5000 and step % 500 == 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 }
@@ -138,6 +147,8 @@ def train():
                 to_log = { **to_log, **{ 'model/summary': wandb.Html(get_summary_html(model)) } }
                 
             wandb.log(to_log, step=step)
+            train_accumulator.reset()
+            valid_accumulator.reset()
 
         if step % 10000 == 0:
             manager_enc.save(checkpoint_number=step)
@@ -204,5 +215,7 @@ if __name__ == '__main__':
     manager_enc = tf.train.CheckpointManager(ckpt_enc, 'checkpoints/post/' + config['name'] + '_enc', max_to_keep=20)
     ckpt_dec = tf.train.Checkpoint(model=model.decoder)
     manager_dec = tf.train.CheckpointManager(ckpt_dec, 'checkpoints/post/' + config['name'] + '_dec', max_to_keep=20)
+    train_accumulator = Accumulator()
+    valid_accumulator = Accumulator()
 
     train()

auto_encoder_curv.py

@@ -1,6 +1,6 @@
 import os
 import sys
-from configs.config_ae_curv_post import config
+from configs.iccv.config_ae_curv import config
 os.environ["CUDA_VISIBLE_DEVICES"] = config['gpu']
 
 import tensorflow as tf
@@ -32,12 +32,13 @@ from tf_utils import check_tf_version, allow_memory_growth
 from dataset import DatasetFactory, StaticDataset
 from custom_utils.custom_utils import batch_to_dict
 from models.cond_encoder import AutoEncoderNew as AutoEncoder
+from custom_utils.custom_utils import Accumulator
 
 
 testing = False
 def init_wandb():
     if not testing:
-        run = wandb.init(project='ae', name=config['name'], notes=config['notes'], dir='/home/workspace/local-data/temp/')
+        run = wandb.init(project='ae', name=config['name'], notes=config['notes'], dir='/tmp', tags=config['tags'])
         artifact = wandb.Artifact('code', type='code')
         artifact.add_file('auto_encoder_curv.py')
         artifact.add_file('losses.py')
@@ -47,7 +48,9 @@ def init_wandb():
         artifact.add_file('convnext/models/convnext_tf.py')
         config_file_names = [key for key in sys.modules.keys()  if key.startswith('configs.')]
         for config_file_name in config_file_names:
-            artifact.add_file('/'.join(config_file_name.split('.')) + '.py')
+            file_name = '/'.join(config_file_name.split('.')) + '.py'
+            if os.path.exists(file_name):
+                artifact.add_file(file_name)
         run.log_artifact(artifact)
 
 uv2mesh = UV2MeshLabel(res=256, is_skirt=config['is_skirt'], is_smpl_orig=config['is_cape'])
@@ -164,13 +167,17 @@ def train():
         batch = static_dataset_train.expand_batch(batch_to_dict(batch, config['signature_dynamic']))
 
         train_loss = train_step(batch)
+        train_accumulator.update(train_loss)
 
+        if step % 50 == 0:
             data_valid = valid_iterator.get_next()
             data_valid = static_dataset_valid.expand_batch(batch_to_dict(data_valid, config['signature_dynamic']))
             valid_loss = valid_step(data_valid)
+            valid_accumulator.update(valid_loss)
 
-        to_log = { **train_loss, **valid_loss }
+        if step % 1000 == 0 or (step < 1000 and step % 100 == 0):
-        if step % 5000 == 0 or (step < 5000 and step % 500 == 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 }
@@ -178,7 +185,8 @@ def train():
                 to_log = { **to_log, **{ 'model/summary': wandb.Html(get_summary_html(model)) } }
                 
             wandb.log(to_log, step=step)
-        print(step)
+            train_accumulator.reset()
+            valid_accumulator.reset()
 
         if step % 10000 == 0:
             manager_enc.save(checkpoint_number=step)
@@ -206,7 +214,7 @@ def test():
 
 if __name__ == '__main__':
     init_wandb()
-    allow_memory_growth()
+    # allow_memory_growth()
     parser = argparse.ArgumentParser(description='')
     parser.add_argument('--name', type=str)
     args = vars(parser.parse_args())
@@ -254,6 +262,8 @@ if __name__ == '__main__':
     manager_enc = tf.train.CheckpointManager(ckpt_enc, 'checkpoints/post/' + config['name'] + '_enc', max_to_keep=20)
     ckpt_dec = tf.train.Checkpoint(model=model.decoder)
     manager_dec = tf.train.CheckpointManager(ckpt_dec, 'checkpoints/post/' + config['name'] + '_dec', max_to_keep=20)
+    train_accumulator = Accumulator()
+    valid_accumulator = Accumulator()
 
     if testing:
         test()

auto_encoder_static.py

@@ -1,6 +1,6 @@
 import os
 import sys
-from configs.config_ae_static import config
+from configs.iccv.config_ae_static import config
 os.environ["CUDA_VISIBLE_DEVICES"] = config['gpu']
 
 import tensorflow as tf
@@ -34,20 +34,24 @@ from tf_utils import check_tf_version, allow_memory_growth
 from dataset import DatasetFactory, StaticDataset
 from custom_utils.custom_utils import batch_to_dict, plot_3d
 from models.cond_encoder import AutoEncoderNew as AutoEncoder
+from custom_utils.custom_utils import Accumulator
 
 
 def init_wandb():
-    run = wandb.init(project='ae', name=config['name'], notes=config['notes'], dir='/home/workspace/local-data/temp')
+    run = wandb.init(project='ae', name=config['name'], notes=config['notes'], dir='/tmp', tags=config['tags'])
     artifact = wandb.Artifact('code', type='code')
     artifact.add_file('auto_encoder_static.py')
     artifact.add_file('losses.py')
     artifact.add_file('models/base.py')
+    artifact.add_file('models/resnet.py')
     artifact.add_file('models/cond_encoder.py')
     artifact.add_file('dataset.py')
     artifact.add_file('convnext/models/convnext_tf.py')
     config_file_names = [key for key in sys.modules.keys()  if key.startswith('configs.')]
     for config_file_name in config_file_names:
-        artifact.add_file('/'.join(config_file_name.split('.')) + '.py')
+        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'])
@@ -64,11 +68,14 @@ def train_step(batch):
 
         e_loss = 1e-2 * tf.reduce_mean(edge_loss(mesh_pred, mesh_orig, batch['mesh_mask']))
         l1_loss = tf.reduce_mean(tf.reduce_sum((tf.math.abs(batch['uv_static'] - pred)), axis=1))
-        ms_ssim = tf.reduce_mean(tf.image.ssim_multiscale(pred + 1, batch['uv_static'] + 1, max_val=2, power_factors=(0.5, 0.2, 0.1, 0.1, 0.1)))
+        # ms_ssim = tf.reduce_mean(tf.image.ssim_multiscale(pred + 1, batch['uv_static'] + 1, max_val=3, power_factors=(0.5, 0.2, 0.1, 0.1, 0.1)))
-        loss = 1e3 * (1 - ms_ssim)
+        ms_ssim = tf.reduce_mean(tf.image.ssim(pred + 1, batch['uv_static'] + 1, max_val=3))
+        # loss = 1e3 * (1 - ms_ssim)
+        loss = l1_loss
 
     metric = tf.reduce_sum(tf.math.sqrt(tf.reduce_sum(batch['mesh_mask'][:,:,tf.newaxis] * (mesh_orig - mesh_pred) ** 2, axis=-1))) / tf.reduce_sum(batch['mesh_mask'])
     gradients = tape.gradient(loss, model.trainable_variables)
+    gradients = [(tf.clip_by_norm(grad, clip_norm=2.0)) for grad in gradients]
     optimizer.apply_gradients(zip(gradients, model.trainable_variables))
     return { 'train/loss': loss, 'train/edge_loss': e_loss, 'train/l1_loss': l1_loss, 'train/euclid_error': metric, 'train/ms_ssim': ms_ssim, }
         
@@ -83,8 +90,10 @@ def valid_step(batch):
 
     e_loss = 1e-2 * tf.reduce_mean(edge_loss(mesh_pred, mesh_orig, batch['mesh_mask']))
     l1_loss = tf.reduce_mean(tf.reduce_sum((tf.math.abs(batch['uv_static'] - pred)), axis=1))
-    ms_ssim = tf.reduce_mean(tf.image.ssim_multiscale(pred + 1, batch['uv_static'] + 1, max_val=2, power_factors=(0.5, 0.2, 0.1, 0.1, 0.1)))
+    # ms_ssim = tf.reduce_mean(tf.image.ssim_multiscale(pred + 1, batch['uv_static'] + 1, max_val=3, power_factors=(0.5, 0.2, 0.1, 0.1, 0.1)))
-    loss = 1e3 * (1 - ms_ssim)
+    ms_ssim = tf.reduce_mean(tf.image.ssim(pred + 1, batch['uv_static'] + 1, max_val=3))
+    # loss = 1e3 * (1 - ms_ssim) 
+    loss = l1_loss
 
     metric = tf.reduce_sum(tf.math.sqrt(tf.reduce_sum(batch['mesh_mask'][:,:,tf.newaxis] * (mesh_orig - mesh_pred) ** 2, axis=-1))) / tf.reduce_sum(batch['mesh_mask'])
     return { 'valid/loss': loss, 'valid/edge_loss': e_loss, 'valid/l1_loss': l1_loss, 'valid/euclid_error': metric, 'valid/ms_ssim': ms_ssim, }
@@ -125,21 +134,26 @@ def train():
     for batch in dataset_train:
         batch = static_dataset_train.expand_batch(batch_to_dict(batch, config['signature_dynamic']))
         train_loss = train_step(batch)
+        train_accumulator.update(train_loss)
 
+        if step % 50 == 0:
             data_valid = valid_iterator.get_next()
             data_valid = static_dataset_valid.expand_batch(batch_to_dict(data_valid, config['signature_dynamic']))
             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 % 500 == 0):
+            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)) } }
                 
-            
             wandb.log(to_log, step=step)
+            train_accumulator.reset()
+            valid_accumulator.reset()
 
         if step % 10000 == 0:
             manager_enc.save(checkpoint_number=step)
@@ -184,9 +198,9 @@ def test():
     print()
 
   
+
 if __name__ == '__main__':
     init_wandb()
-    # allow_memory_growth()
     parser = argparse.ArgumentParser(description='')
     parser.add_argument('--name', type=str)
     args = vars(parser.parse_args())
@@ -230,6 +244,8 @@ if __name__ == '__main__':
 
     model : AutoEncoder = AutoEncoder(config['cond_ae'])
     optimizer = tf.optimizers.Adam(learning_rate=config['lr'])
+    train_accumulator = Accumulator()
+    valid_accumulator = Accumulator()
 
     if config['pretrained_model'] != '':
         load_model(model.encoder, config['pretrained_model'] + '_enc')

calculate_error.py

@@ -1,6 +1,6 @@
 import os
 import sys
-from configs.config_abl_all_post import config
+from configs.iccv.config_abl_pyr_32_res import config
 
 os.environ["CUDA_VISIBLE_DEVICES"] = config['gpu']
 # import tensorflow as tf
@@ -59,21 +59,21 @@ if __name__ == '__main__':
     folder = config['test_dir']
 
     checkpoint_name = config['name']
-    iteration = ''
+    iteration = '195000'
 
     F = np.load("custom_utils/smpl_faces" + skirt_modifier + ".npy").astype(np.int32)
     garment_type_table = np.load('custom_data/garment_type_table_test.npy', allow_pickle=True).item()
 
 
-    output_folder = '/home/workspace/data/results/post/' + checkpoint_name + '-' + iteration
+    output_folder = '/home/workspace/data/results/iccv/' + checkpoint_name + '-' + iteration
 
 
-    faces_folder = '/home/workspace/data/results/support/faces' + ('_skirt' if config['is_skirt'] else '')
+    # faces_folder = '/home/workspace/data/results/support/faces' + ('_skirt' if config['is_skirt'] else '')
-    ids = os.listdir(faces_folder)
+    # ids = os.listdir(faces_folder)
-    ids = [id.split('.')[0] for id in ids]
+    # ids = [id.split('.')[0] for id in ids]
-    faces = {id : np.load(faces_folder + '/' + id + '.npy') for id in ids }
+    # faces = {id : np.load(faces_folder + '/' + id + '.npy') for id in ids }
 
-    masks_folder = '/home/workspace/data/dataset/test' + ('_skirt' if config['is_skirt'] else '') + '_ready' + ('_2' if config['is_skirt'] else '') + '/mesh_mask'
+    masks_folder = '/home/workspace/local-data/test' + ('_skirt' if config['is_skirt'] else '') + '_ready' + ('_2' if config['is_skirt'] else '') + '/mesh_mask'
     ids = os.listdir(masks_folder)
     ids = [id.split('.')[0] for id in ids]
     masks = {id : np.load(masks_folder + '/' + id + '.npy') for id in ids }
@@ -86,7 +86,7 @@ if __name__ == '__main__':
     else:
         gt_name = 'mesh_posed'
 
-    orig_folder = '/home/workspace/data/dataset/test' + ('_skirt' if config['is_skirt'] else '') + '_ready' + ('_2' if config['is_skirt'] else '') + '/' + gt_name
+    orig_folder = '/home/workspace/local-data/test' + ('_skirt' if config['is_skirt'] else '') + '_ready' + ('_2' if config['is_skirt'] else '') + '/' + gt_name
 
     errors = dict()
     if config['is_skirt']:
@@ -107,7 +107,7 @@ if __name__ == '__main__':
     for key in per_garment_errors.keys():
         print(key + ': ' + str(np.mean(per_garment_errors[key])))
 
-    with open('/home/workspace/data/results/errors/post/' + checkpoint_name + '-' + iteration + '.csv', mode='w') as f:
+    with open('/home/workspace/data/results/errors/iccv/' + checkpoint_name + '-' + iteration + '.csv', mode='w') as f:
         file_writer = csv.writer(f, delimiter=',', quotechar='"', quoting=csv.QUOTE_MINIMAL)
 
         for key in sorted(errors.keys()):

configs/config_abl_all_post.py

@@ -19,9 +19,9 @@ config['only_curvatures'] =           False
 ablation_count = [config['use_skinning'], config['remove_global_orientation'], config['use_curvature'], config['use_extra_losses'], config['use_offsets']].count(False)
 assert ablation_count == 1 or ablation_count == 0
 
-config['gpu'] = '5'
+config['gpu'] = '4'
-config['name'] = 'iccv_weights_test_8'
+config['name'] = 'iccv_weights_test_6'
-config['notes'] = 'smaller weight loss coeff, 1e-6, convolutional weight learning, changed convnext reverse'
+config['notes'] = 'smaller weight loss coeff, 1e-6, convolutional weight learning, continued from _5'
 
 config['avg_garment_path'] = 'custom_data/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']:
@@ -53,7 +53,7 @@ if config['is_cape']:
   config['smpl_res'] = 3638
 
 
-config['pretrained_model'] = ''
+config['pretrained_model'] = 'checkpoints/post/iccv_weights_test_5'
 
 ###############    
 config['lr'] = 0.0001#                 0.0001
@@ -91,9 +91,9 @@ config['cvae']['noise_amount'] = 0.00001
 config['cvae']['kernel_size'] = 7
 config['cvae']['encoder_depths'] = [3, 3, 3, 9, 3]
 config['cvae']['encoder_dims'] = [32, 64, 128, 256, 64]
-config['cvae']['decoder_depths'] = [3, 9, 3, 3, 3, 3]
+config['cvae']['decoder_depths'] = config['cvae']['encoder_depths']
-config['cvae']['decoder_dims'] = [3, 32, 128, 128, 256, 512]
+config['cvae']['decoder_dims'] = config['cvae']['encoder_dims']
-config['cvae']['decoder_weights_depths'] = [3, 9, 3, 3, 3]
+config['cvae']['decoder_weights_depths'] = [3, 3, 3, 5, 3]
 config['cvae']['decoder_weights_dims'] = [24, 32, 64, 128, 256]
 
 config['cond_ae_static'] = dict()

configs/config_ae_static.py

@@ -31,7 +31,7 @@ config['cond_ae']['decoder_dims'] = config['cond_ae']['encoder_dims']
 config['cond_ae']['activation'] = 'linear'
 
 
-config['gpu'] = '5'
+config['gpu'] = '0'
 config['lr'] = 0.0005
 config['name'] = 'static_post_4'
 config['notes'] = 'convnext + convnext, | \

configs/iccv/config_abl_all.py

@@ -0,0 +1,119 @@
+config = dict()
+
+# DON'T FORGET TO RESET SSIM LOSS USAGE
+# DON'T FORGET TO CHECK MODEL LOADING
+# DON'T FORGET TO CHECK IF STORE IN MEMORY
+# DON'T FORGET TO CHECK REG LOSS COEFF
+# DON'T FORGET TO LOAD FINAL UPSCALER UNLESS HAVE LEVEL 512
+# DON'T FORGET TO CHECK AVG GARMENT USED
+
+config['use_skinning'] =              False # and deshaping
+config['remove_global_orientation'] = True
+config['use_curvature'] =             True
+config['use_extra_losses'] =          True # edge, collision, 3d mesh
+config['use_offsets'] =               True
+
+config['use_norm_loss'] =             True
+config['only_curvatures'] =           False
+
+ablation_count = [config['use_skinning'], config['remove_global_orientation'], config['use_curvature'], config['use_extra_losses'], config['use_offsets']].count(False)
+assert ablation_count == 1 or ablation_count == 0
+
+config['gpu'] = '4'
+config['name'] = 'all_iccv_1'
+config['notes'] = ''
+
+config['avg_garment_path'] = 'custom_data/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['train_dir'] = '/home/workspace/local-data/train'
+config['valid_dir'] = '/home/workspace/local-data/valid'
+config['test_dir'] = '/home/workspace/data/dataset/test_ready'
+
+# config['frames_file'] = 'frames_dress_30k.txt'
+# config['frames_file_valid'] = 'frames_dress_30k.txt'
+# config['frames_file_test'] = 'frames_dress_30k.txt'
+
+config['static_model'] = 'checkpoints/post/static_r7_3'
+config['body_model'] = 'checkpoints/post/body_r7_3'
+config['curvature_model'] = 'checkpoints/post/curv_r7_3'
+
+
+config['smpl_res'] = 14475
+if config['is_cape']:
+  config['smpl_res'] = 3638
+
+
+config['pretrained_model'] = ''
+
+###############    
+config['lr'] = 0.0001#                 0.0001
+###############
+config['starting_balancing_coeff'] = 0.001
+
+config['signature_dynamic'] = { 'id': (), 'frame_nr': (),
+                          'pose_shape': (72 + 11,),
+                          'uv_body_posed': (512, 256, 3),
+                          'mesh_body_posed': (config['smpl_res'], 3,),
+                          'mesh_posed': (config['smpl_res'], 3,),
+                          'uv_curvature': (512, 256, 7),
+                        }
+config['signature_static'] = { 'uv_static': (512, 256, 3),
+                              'mesh_mask': (config['smpl_res'],),
+                              'uv_mask': (512, 256,),
+                              }
+
+if config['use_skinning']:
+  config['signature_dynamic']['uv_unposed'] = (512, 256, 3)
+  config['signature_dynamic']['mesh_unposed'] = (config['smpl_res'], 3,)
+else:
+  config['signature_dynamic']['uv_posed'] = (512, 256, 3)
+
+
+config['upscale_enhancer'] = ''
+config['freeze_encoders'] = True
+config['use_one_hot'] = False
+
+config['cvae'] = dict()
+config['cvae']['is_label'] = False
+config['cvae']['add_noise'] = True
+config['cvae']['noise_amount'] = 0.001
+
+config['cvae']['kernel_size'] = 7
+config['cvae']['features'] = 64*4 # 8*4
+config['cvae']['layer_params'] = [3, 4, 5, 4, 3]
+# config['cond_ae']['layer_params'] = [3, 4, 23, 3, 3]
+
+
+config['cond_ae_static'] = dict()
+config['cond_ae_static']['is_label'] = False
+config['cond_ae_static']['kernel_size'] = 7
+config['cond_ae_static']['bottleneck_size'] = 8*4
+config['cond_ae_static']['layer_params'] = [3, 4, 5, 4, 3]
+# config['cond_ae_static']['layer_params'] = [3, 4, 23, 3, 3]
+config['cond_ae_static']['activation'] = 'tanh'
+
+config['cond_ae_curv'] = dict()
+config['cond_ae_curv']['is_label'] = True
+config['cond_ae_curv']['kernel_size'] = 7
+config['cond_ae_curv']['bottleneck_size'] = 40*4
+config['cond_ae_curv']['layer_params'] = [3, 4, 5, 4, 3]
+# config['cond_ae_curv']['layer_params'] = [3, 4, 23, 3, 3]]
+config['cond_ae_curv']['activation'] = 'tanh'
+
+config['cond_ae_body'] = dict()
+config['cond_ae_body']['is_label'] = False
+config['cond_ae_body']['kernel_size'] = 7
+config['cond_ae_body']['bottleneck_size'] = 16*4
+config['cond_ae_body']['layer_params'] = [3, 4, 5, 4, 3]
+# config['cond_ae_body']['layer_params'] = [3, 4, 23, 3, 3]]
+config['cond_ae_body']['activation'] = 'tanh'

configs/iccv/config_abl_pyr_32_res.py

@@ -0,0 +1,178 @@
+config = dict()
+
+config['gpu'] = '0'
+config['name'] = 'iccv_pyr_32_res'
+config['notes'] = ''
+config['tags'] = ['pyr', 'iccv', 'resnet']
+
+# DON'T FORGET TO RESET SSIM LOSS USAGE
+# DON'T FORGET TO CHECK MODEL LOADING
+# DON'T FORGET TO CHECK IF STORE IN MEMORY
+# DON'T FORGET TO CHECK REG LOSS COEFF
+# DON'T FORGET TO LOAD FINAL UPSCALER UNLESS HAVE LEVEL 512
+# DON'T FORGET TO CHECK IF SKIRT
+# DON'T FORGET TO CHECK IF CAPE
+# DON'T FORGET TO CHECK IF USING DOWNSCALE NONE OR _2
+# DON'T FORGET TO CHECK UPSCALING and ENCODER CHECKPOINTS
+
+config['use_skinning'] =              True # and deshaping
+config['remove_global_orientation'] = True
+config['use_extra_losses'] =          True # edge, collision, 3d mesh
+config['use_offsets'] =               False
+config['use_norm_loss'] =             True
+config['use_curvature'] =             True
+
+config['pretrained_model'] = ''
+config['pretrained_model_iteration'] = ''
+
+config['pyramid'] = dict()
+config['pyramid']['resolutions'] = [32]
+config['pyramid']['pretrained_pyramid'] = ''
+config['pyramid']['final_upscale_enhancer'] = ''
+
+config['train_dir'] = '/home/workspace/local-data_127/train'
+config['valid_dir'] = '/home/workspace/local-data_127/valid'
+config['test_dir'] = '/home/workspace/local-data/test_ready'
+config['batch_size'] = 4
+config['is_skirt'] = False
+config['is_cape'] = False
+
+config['dataset_in_memory'] = False
+config['resolution'] = None
+
+config['smpl_res'] = 14475
+if config['is_cape']:
+  config['smpl_res'] = 3638
+
+config['lr'] = 0.0001
+config['starting_balancing_coeff'] = 0.001
+config['reg_loss_coeff'] = 0.1 # set to 0 if don't want to use edge+collision
+config['avg_garment_path'] = ''
+config['bottleneck_scale'] = 2
+
+config['signature_dynamic'] = { 'id': (), 'frame_nr': (),
+                          'pose_shape': (72 + 11,),
+                          'uv_body_posed': (512, 256, 3),
+                          'mesh_body_posed': (config['smpl_res'], 3,),
+                          'mesh_posed': (config['smpl_res'], 3,),
+                          'mesh_unposed': (config['smpl_res'], 3,),
+                          'uv_unposed': (512, 256, 3),
+                          'uv_curvature': (512, 256, 7),
+                        }
+config['signature_static'] = { 'uv_static': (512, 256, 3),
+                              'mesh_mask': (config['smpl_res'],),
+                              'uv_mask': (512, 256,),
+                              }
+
+config['pyramid']['is_label'] = False
+config['pyramid']['add_noise'] = False
+config['pyramid']['noise_amount'] = 0.0
+
+config['pyramid']['loss_weights'] = [1,1,1,1,1]
+
+for res in config['pyramid']['resolutions']:
+  if res != 512:
+      res_modifier = '_' + str(res)
+      config['signature_dynamic']['uv_body_posed' + res_modifier] = (res, res//2, 3)
+      config['signature_dynamic']['uv_unposed' + res_modifier] = (res, res//2, 3)
+      config['signature_dynamic']['uv_curvature' + res_modifier] = (res, res//2, 7)
+      config['signature_static']['uv_static' + res_modifier] = (res, res//2, 3)
+      config['signature_static']['uv_mask' + res_modifier] = (res, res//2)
+
+
+config['pyramid']['static_model'] = 'checkpoints/post/static_resnet_3'
+config['pyramid']['body_model'] = 'checkpoints/post/body_resnet_3'
+config['pyramid']['curvature_model'] = 'checkpoints/post/curv_resnet_2'
+config['pyramid']['freeze_encoders'] = True
+
+
+config['pyramid']['levels'] = []
+for res in config['pyramid']['resolutions']:
+  if res == 512:
+    level = dict()
+    level['resolution'] = 512
+    level['latent_dim'] = 64 * config['bottleneck_scale']
+    level['kernel_size'] = 7
+    level['encoder_depths'] = [3, 3, 9, 3]
+    level['encoder_dims'] = [32, 64, 128, level['latent_dim']]
+    level['decoder_input'] = (16, 8, 80)
+    level['decoder_depths'] = [3, 3, 9, 3]
+    level['decoder_dims'] = [256, 128, 64, 16]
+    level['avg_garment_path'] = ''
+    level['upscale_enhancer'] = ''
+    config['pyramid']['levels'].append(level)
+  elif res == 256:
+    level = dict()
+    level['resolution'] = 256
+    level['latent_dim'] = 64 * config['bottleneck_scale']
+    level['kernel_size'] = 5
+    level['encoder_depths'] = [9, 9, 9, 9]
+    level['encoder_dims'] = [32, 64, 128, level['latent_dim']]
+    level['decoder_input'] = (8, 4, 128)
+    level['decoder_depths'] = [9, 9, 9, 9]
+    level['decoder_dims'] = [256, 128, 64, 16]
+    level['avg_garment_path'] = ''
+    level['upscale_enhancer'] = 'checkpoints/iccv/iccv_'#'checkpoints/up_3_d256_512_2'
+    level['upscale_enhancer_freeze'] = True
+    config['pyramid']['levels'].append(level)
+  elif res == 128:
+    level = dict()
+    level['resolution'] = 128
+    level['latent_dim'] = 64 * config['bottleneck_scale']
+    level['kernel_size'] = 5
+    level['encoder_depths'] = [16, 9, 9, 9]
+    level['encoder_dims'] = [64, 128, 128, 64]
+    level['decoder_input'] = (4, 2, 128)
+    level['decoder_depths'] = [16, 9, 9, 9]
+    level['decoder_dims'] = [256, 128, 128, level['latent_dim']]
+    level['avg_garment_path'] = ''
+    level['upscale_enhancer'] = 'checkpoints/iccv/iccv_'#'checkpoints/up_3_d128_256_2'
+    level['upscale_enhancer_freeze'] = True
+    config['pyramid']['levels'].append(level)
+  elif res == 64:
+    level = dict()
+    level['resolution'] = 64
+    level['latent_dim'] = 64 * config['bottleneck_scale']
+    level['kernel_size'] = 3
+    level['encoder_depths'] = [9, 9]
+    level['encoder_dims'] = [64, level['latent_dim']]
+    level['decoder_depths'] = level['encoder_depths']
+    level['decoder_dims'] = level['encoder_dims']
+    level['avg_garment_path'] = ''
+    level['upscale_enhancer'] = 'checkpoints/iccv/iccv_'#checkpoints/up_3_d64_128_2'
+    level['upscale_enhancer_freeze'] = True
+    config['pyramid']['levels'].append(level)
+  elif res == 32:
+    level = dict()
+    level['resolution'] = 32
+    level['latent_dim'] = 64 * config['bottleneck_scale']
+    level['bottleneck_size'] = 64 * 2
+    level['layer_params'] = [7]
+    level['avg_garment_path'] = ''
+    level['upscale_enhancer'] = 'checkpoints/iccv/iccv_32_2'#'checkpoints/up_3_d32_64_2'
+    level['upscale_enhancer_freeze'] = True
+    config['pyramid']['levels'].append(level)
+  else:
+    raise NotImplementedError
+
+config['cond_ae_static'] = dict()
+config['cond_ae_static']['is_label'] = False
+config['cond_ae_static']['kernel_size'] = 7
+config['cond_ae_static']['bottleneck_size'] = 8 * config['bottleneck_scale']
+config['cond_ae_static']['activation'] = 'tanh'
+# config['cond_ae']['layer_params'] = [3, 4, 23, 4, 3]
+config['cond_ae_static']['layer_params'] = [3, 7, 15, 7, 3]
+
+config['cond_ae_curv'] = dict()
+config['cond_ae_curv']['is_label'] = True
+config['cond_ae_curv']['kernel_size'] = 7
+config['cond_ae_curv']['bottleneck_size'] = 40 * config['bottleneck_scale']
+config['cond_ae_curv']['activation'] = 'tanh'
+config['cond_ae_curv']['layer_params'] = [3, 7, 15, 7, 3]
+
+config['cond_ae_body'] = dict()
+config['cond_ae_body']['is_label'] = False
+config['cond_ae_body']['kernel_size'] = 7
+config['cond_ae_body']['bottleneck_size'] = 16 * config['bottleneck_scale']
+config['cond_ae_body']['activation'] = 'tanh'
+config['cond_ae_body']['layer_params'] = [3, 7, 15, 7, 3]

configs/iccv/config_abl_pyr_32_res_skirt.py

@@ -0,0 +1,178 @@
+config = dict()
+
+config['gpu'] = '0'
+config['name'] = 'iccv_pyr_32_res_skirt'
+config['notes'] = ''
+config['tags'] = ['pyr', 'iccv', 'resnet']
+
+# DON'T FORGET TO RESET SSIM LOSS USAGE
+# DON'T FORGET TO CHECK MODEL LOADING
+# DON'T FORGET TO CHECK IF STORE IN MEMORY
+# DON'T FORGET TO CHECK REG LOSS COEFF
+# DON'T FORGET TO LOAD FINAL UPSCALER UNLESS HAVE LEVEL 512
+# DON'T FORGET TO CHECK IF SKIRT
+# DON'T FORGET TO CHECK IF CAPE
+# DON'T FORGET TO CHECK IF USING DOWNSCALE NONE OR _2
+# DON'T FORGET TO CHECK UPSCALING and ENCODER CHECKPOINTS
+
+config['use_skinning'] =              True # and deshaping
+config['remove_global_orientation'] = True
+config['use_extra_losses'] =          True # edge, collision, 3d mesh
+config['use_offsets'] =               False
+config['use_norm_loss'] =             True
+config['use_curvature'] =             True
+
+config['pretrained_model'] = ''
+config['pretrained_model_iteration'] = ''
+
+config['pyramid'] = dict()
+config['pyramid']['resolutions'] = [32]
+config['pyramid']['pretrained_pyramid'] = ''
+config['pyramid']['final_upscale_enhancer'] = ''
+
+config['train_dir'] = '/home/workspace/local-data_128/train_skirt'
+config['valid_dir'] = '/home/workspace/local-data_127/valid_skirt'
+config['test_dir'] = '/home/workspace/local-data/test_skirt_ready_2'
+config['batch_size'] = 4
+config['is_skirt'] = True
+config['is_cape'] = False
+
+config['dataset_in_memory'] = False
+config['resolution'] = None
+
+config['smpl_res'] = 14475
+if config['is_cape']:
+  config['smpl_res'] = 3638
+
+config['lr'] = 0.0001
+config['starting_balancing_coeff'] = 0.001
+config['reg_loss_coeff'] = 0.1 # set to 0 if don't want to use edge+collision
+config['avg_garment_path'] = ''
+config['bottleneck_scale'] = 2
+
+config['signature_dynamic'] = { 'id': (), 'frame_nr': (),
+                          'pose_shape': (72 + 11,),
+                          'uv_body_posed': (512, 256, 3),
+                          'mesh_body_posed': (config['smpl_res'], 3,),
+                          'mesh_posed': (config['smpl_res'], 3,),
+                          'mesh_unposed': (config['smpl_res'], 3,),
+                          'uv_unposed': (512, 256, 3),
+                          'uv_curvature': (512, 256, 7),
+                        }
+config['signature_static'] = { 'uv_static': (512, 256, 3),
+                              'mesh_mask': (config['smpl_res'],),
+                              'uv_mask': (512, 256,),
+                              }
+
+config['pyramid']['is_label'] = False
+config['pyramid']['add_noise'] = False
+config['pyramid']['noise_amount'] = 0.0
+
+config['pyramid']['loss_weights'] = [1,1,1,1,1]
+
+for res in config['pyramid']['resolutions']:
+  if res != 512:
+      res_modifier = '_' + str(res)
+      config['signature_dynamic']['uv_body_posed' + res_modifier] = (res, res//2, 3)
+      config['signature_dynamic']['uv_unposed' + res_modifier] = (res, res//2, 3)
+      config['signature_dynamic']['uv_curvature' + res_modifier] = (res, res//2, 7)
+      config['signature_static']['uv_static' + res_modifier] = (res, res//2, 3)
+      config['signature_static']['uv_mask' + res_modifier] = (res, res//2)
+
+
+config['pyramid']['static_model'] = 'checkpoints/post/static_resnet_3'
+config['pyramid']['body_model'] = 'checkpoints/post/body_resnet_3'
+config['pyramid']['curvature_model'] = 'checkpoints/post/curv_resnet_2'
+config['pyramid']['freeze_encoders'] = True
+
+
+config['pyramid']['levels'] = []
+for res in config['pyramid']['resolutions']:
+  if res == 512:
+    level = dict()
+    level['resolution'] = 512
+    level['latent_dim'] = 64 * config['bottleneck_scale']
+    level['kernel_size'] = 7
+    level['encoder_depths'] = [3, 3, 9, 3]
+    level['encoder_dims'] = [32, 64, 128, level['latent_dim']]
+    level['decoder_input'] = (16, 8, 80)
+    level['decoder_depths'] = [3, 3, 9, 3]
+    level['decoder_dims'] = [256, 128, 64, 16]
+    level['avg_garment_path'] = ''
+    level['upscale_enhancer'] = ''
+    config['pyramid']['levels'].append(level)
+  elif res == 256:
+    level = dict()
+    level['resolution'] = 256
+    level['latent_dim'] = 64 * config['bottleneck_scale']
+    level['kernel_size'] = 5
+    level['encoder_depths'] = [9, 9, 9, 9]
+    level['encoder_dims'] = [32, 64, 128, level['latent_dim']]
+    level['decoder_input'] = (8, 4, 128)
+    level['decoder_depths'] = [9, 9, 9, 9]
+    level['decoder_dims'] = [256, 128, 64, 16]
+    level['avg_garment_path'] = ''
+    level['upscale_enhancer'] = 'checkpoints/iccv/iccv_'#'checkpoints/up_3_d256_512_2'
+    level['upscale_enhancer_freeze'] = True
+    config['pyramid']['levels'].append(level)
+  elif res == 128:
+    level = dict()
+    level['resolution'] = 128
+    level['latent_dim'] = 64 * config['bottleneck_scale']
+    level['kernel_size'] = 5
+    level['encoder_depths'] = [16, 9, 9, 9]
+    level['encoder_dims'] = [64, 128, 128, 64]
+    level['decoder_input'] = (4, 2, 128)
+    level['decoder_depths'] = [16, 9, 9, 9]
+    level['decoder_dims'] = [256, 128, 128, level['latent_dim']]
+    level['avg_garment_path'] = ''
+    level['upscale_enhancer'] = 'checkpoints/iccv/iccv_'#'checkpoints/up_3_d128_256_2'
+    level['upscale_enhancer_freeze'] = True
+    config['pyramid']['levels'].append(level)
+  elif res == 64:
+    level = dict()
+    level['resolution'] = 64
+    level['latent_dim'] = 64 * config['bottleneck_scale']
+    level['kernel_size'] = 3
+    level['encoder_depths'] = [9, 9]
+    level['encoder_dims'] = [64, level['latent_dim']]
+    level['decoder_depths'] = level['encoder_depths']
+    level['decoder_dims'] = level['encoder_dims']
+    level['avg_garment_path'] = ''
+    level['upscale_enhancer'] = 'checkpoints/iccv/iccv_'#checkpoints/up_3_d64_128_2'
+    level['upscale_enhancer_freeze'] = True
+    config['pyramid']['levels'].append(level)
+  elif res == 32:
+    level = dict()
+    level['resolution'] = 32
+    level['latent_dim'] = 64 * config['bottleneck_scale']
+    level['bottleneck_size'] = 64 * 2
+    level['layer_params'] = [7]
+    level['avg_garment_path'] = ''
+    level['upscale_enhancer'] = 'checkpoints/iccv/iccv_32_2_skirt'#'checkpoints/up_3_d32_64_2'
+    level['upscale_enhancer_freeze'] = True
+    config['pyramid']['levels'].append(level)
+  else:
+    raise NotImplementedError
+
+config['cond_ae_static'] = dict()
+config['cond_ae_static']['is_label'] = False
+config['cond_ae_static']['kernel_size'] = 7
+config['cond_ae_static']['bottleneck_size'] = 8 * config['bottleneck_scale']
+config['cond_ae_static']['activation'] = 'tanh'
+# config['cond_ae']['layer_params'] = [3, 4, 23, 4, 3]
+config['cond_ae_static']['layer_params'] = [3, 7, 15, 7, 3]
+
+config['cond_ae_curv'] = dict()
+config['cond_ae_curv']['is_label'] = True
+config['cond_ae_curv']['kernel_size'] = 7
+config['cond_ae_curv']['bottleneck_size'] = 40 * config['bottleneck_scale']
+config['cond_ae_curv']['activation'] = 'tanh'
+config['cond_ae_curv']['layer_params'] = [3, 7, 15, 7, 3]
+
+config['cond_ae_body'] = dict()
+config['cond_ae_body']['is_label'] = False
+config['cond_ae_body']['kernel_size'] = 7
+config['cond_ae_body']['bottleneck_size'] = 16 * config['bottleneck_scale']
+config['cond_ae_body']['activation'] = 'tanh'
+config['cond_ae_body']['layer_params'] = [3, 7, 15, 7, 3]

configs/iccv/config_ae_body.py

@@ -0,0 +1,48 @@
+config = dict()
+
+
+config['batch_size'] = 4
+config['train_dir'] = '/home/workspace/local-data/train'
+config['valid_dir'] = '/home/workspace/local-data/valid'
+config['test_dir'] = '/home/workspace/data/dataset/test_ready'
+config['use_filled'] = False
+config['resolution'] = 512
+config['is_skirt'] = False
+config['dataset_in_memory'] = False
+config['is_cape'] = False
+config['remove_global_orientation'] = True
+
+config['smpl_res'] = 14475
+if config['is_cape']:
+  config['smpl_res'] = 3638
+
+config['latent_dim'] = 128
+
+config['cond_ae'] = dict()
+config['cond_ae']['is_label'] = False
+config['cond_ae']['upscale_output'] = False
+config['cond_ae']['latent_dim'] = config['latent_dim']
+config['cond_ae']['kernel_size'] = 7
+config['cond_ae']['bottleneck_size'] = 16 * 2
+config['cond_ae']['layer_params'] = [3, 7, 15, 7, 3]
+config['cond_ae']['activation'] = 'tanh'
+
+
+config['gpu'] = '3'
+config['lr'] = 0.0001
+config['name'] = 'body_resnet_3'
+config['notes'] = '' 
+config['tags'] = ['iccv', 'resnet']
+
+config['cond_ae']['upscale_output'] = False
+config['pretrained_model'] = ''
+
+
+config['signature_dynamic'] = { 'id': (), 'frame_nr': (),
+                          'pose_shape': (72 + 11,),
+                          'uv_body_posed': (3, 512, 256,),
+                          'mesh_body_posed': (config['smpl_res'], 3,),
+                        }
+config['signature_static'] = { 
+                         'mesh_mask': (config['smpl_res'],),
+                        }

configs/iccv/config_ae_curv.py

@@ -0,0 +1,48 @@
+config = dict()
+
+
+config['batch_size'] = 4
+config['train_dir'] = '/home/workspace/local-data/train'
+config['valid_dir'] = '/home/workspace/local-data/valid'
+config['test_dir'] = '/home/workspace/data/dataset/test_ready'
+config['use_filled'] = False
+config['resolution'] = 512
+config['is_skirt'] = False
+config['dataset_in_memory'] = False
+config['is_cape'] = False
+config['remove_global_orientation'] = True
+
+config['smpl_res'] = 14475
+if config['is_cape']:
+  config['smpl_res'] = 3638
+
+config['latent_dim'] = 128
+
+config['cond_ae'] = dict()
+config['cond_ae']['is_label'] = True
+config['cond_ae']['upscale_output'] = False
+config['cond_ae']['latent_dim'] = config['latent_dim']
+config['cond_ae']['kernel_size'] = 7
+config['cond_ae']['bottleneck_size'] = 40 * 2
+config['cond_ae']['layer_params'] = [3, 7, 15, 7, 3]
+config['cond_ae']['activation'] = 'tanh'
+
+
+
+config['gpu'] = '2'
+config['lr'] = 0.001
+config['name'] = 'curv_resnet_3'
+config['notes'] = '' 
+config['tags'] = ['iccv', 'resnet']
+
+config['cond_ae']['upscale_output'] = False
+config['pretrained_model'] = ''
+
+
+config['signature_dynamic'] = { 'id': (), 'frame_nr': (),
+                          'uv_curvature': (512, 256, 7),
+                          'mesh_curvature':  (config['smpl_res'])
+                        }
+config['signature_static'] = { 'mesh_mask': (config['smpl_res'],),
+                         'uv_mask': (512, 256,),
+                        }

configs/iccv/config_ae_static.py

@@ -0,0 +1,49 @@
+config = dict()
+
+
+config['batch_size'] = 4 ##################################### CHANGE CHANGE CHANGE CHANGE CHANGE CHANGE CHANGE
+config['train_dir'] = '/home/workspace/local-data/train'
+config['valid_dir'] = '/home/workspace/local-data/valid'
+config['test_dir'] = '/home/workspace/data/dataset/test_ready'
+config['use_filled'] = False
+config['resolution'] = 512
+config['is_skirt'] = False
+config['dataset_in_memory'] = True
+config['is_cape'] = False
+config['remove_global_orientation'] = True
+
+config['smpl_res'] = 14475
+if config['is_cape']:
+  config['smpl_res'] = 3638
+
+config['latent_dim'] = 128
+
+config['cond_ae'] = dict()
+config['cond_ae']['is_label'] = False
+config['cond_ae']['upscale_output'] = False
+config['cond_ae']['latent_dim'] = config['latent_dim']
+config['cond_ae']['kernel_size'] = 7
+config['cond_ae']['bottleneck_size'] = 8*2 # 8*4
+# config['cond_ae']['layer_params'] = [3, 4, 23, 4, 3]
+config['cond_ae']['layer_params'] = [3, 7, 15, 7, 3]
+config['cond_ae']['activation'] = 'tanh'
+
+
+config['gpu'] = '1'
+config['lr'] = 3e-4
+config['name'] = 'static_resnet_3'
+config['notes'] = ''
+config['tags'] = ['iccv', 'resnet', 'static']
+
+    
+
+config['cond_ae']['upscale_output'] = False
+config['pretrained_model'] = ''
+
+
+config['signature_dynamic'] = { 'id': (), 'frame_nr': (), }
+config['signature_static'] = { 'uv_static': (512, 256, 3),
+                         'mesh_static': (config['smpl_res'], 3,),
+                         'mesh_mask': (config['smpl_res'],),
+                         'uv_mask': (512, 256,),
+                        }

configs/review/config_abl_all.py

@@ -0,0 +1,126 @@
+config = dict()
+
+# DON'T FORGET TO RESET SSIM LOSS USAGE
+# DON'T FORGET TO CHECK MODEL LOADING
+# DON'T FORGET TO CHECK IF STORE IN MEMORY
+# DON'T FORGET TO CHECK REG LOSS COEFF
+# DON'T FORGET TO LOAD FINAL UPSCALER UNLESS HAVE LEVEL 512
+# DON'T FORGET TO CHECK AVG GARMENT USED
+
+config['use_skinning'] =              True # and deshaping
+config['remove_global_orientation'] = True
+config['use_curvature'] =             True
+config['use_extra_losses'] =          True # edge, collision, 3d mesh
+config['use_offsets'] =               True
+
+config['use_norm_loss'] =             True
+config['only_curvatures'] =           False
+
+ablation_count = [config['use_skinning'], config['remove_global_orientation'], config['use_curvature'], config['use_extra_losses'], config['use_offsets']].count(False)
+assert ablation_count == 1 or ablation_count == 0
+
+config['gpu'] = '4'
+config['name'] = 'abl_all_resnet_r7'
+config['notes'] = ''
+
+config['avg_garment_path'] = 'custom_data/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['train_dir'] = '/home/workspace/local-data/train'
+config['valid_dir'] = '/home/workspace/local-data/valid'
+config['test_dir'] = '/home/workspace/data/dataset/test_ready'
+
+# config['frames_file'] = 'frames_dress_30k.txt'
+# config['frames_file_valid'] = 'frames_dress_30k.txt'
+# config['frames_file_test'] = 'frames_dress_30k.txt'
+
+config['static_model'] = 'checkpoints/post/static_r7_3'
+config['body_model'] = 'checkpoints/post/body_r7_3'
+config['curvature_model'] = 'checkpoints/post/curv_r7_3'
+
+
+config['smpl_res'] = 14475
+if config['is_cape']:
+  config['smpl_res'] = 3638
+
+
+config['pretrained_model'] = ''
+
+###############    
+config['lr'] = 0.0001#                 0.0001
+###############
+config['starting_balancing_coeff'] = 0.001
+
+config['signature_dynamic'] = { 'id': (), 'frame_nr': (),
+                          'pose_shape': (72 + 11,),
+                          'uv_body_posed': (512, 256, 3),
+                          'mesh_body_posed': (config['smpl_res'], 3,),
+                          'mesh_posed': (config['smpl_res'], 3,),
+                          'uv_curvature': (512, 256, 7),
+                        }
+config['signature_static'] = { 'uv_static': (512, 256, 3),
+                              'mesh_mask': (config['smpl_res'],),
+                              'uv_mask': (512, 256,),
+                              }
+
+if config['use_skinning']:
+  config['signature_dynamic']['uv_unposed'] = (512, 256, 3)
+  config['signature_dynamic']['mesh_unposed'] = (config['smpl_res'], 3,)
+else:
+  config['signature_dynamic']['uv_posed'] = (512, 256, 3)
+
+
+config['upscale_enhancer'] = ''
+config['freeze_encoders'] = True
+config['use_one_hot'] = False
+
+config['cvae'] = dict()
+config['cvae']['is_label'] = False
+config['cvae']['add_noise'] = True
+config['cvae']['noise_amount'] = 0.001
+
+config['cvae']['kernel_size'] = 7
+config['cvae']['encoder_depths'] = [3, 3, 3, 9, 3]
+config['cvae']['encoder_dims'] = [32, 64, 128, 256, 64]
+config['cvae']['decoder_depths'] = config['cvae']['encoder_depths']
+config['cvae']['decoder_dims'] = config['cvae']['encoder_dims']
+
+
+config['cond_ae_static'] = dict()
+config['cond_ae_static']['is_label'] = False
+config['cond_ae_static']['kernel_size'] = 7
+config['cond_ae_static']['bottleneck_size'] = 8
+config['cond_ae_static']['encoder_depths'] = [3, 3, 3, 9, 3]
+config['cond_ae_static']['encoder_dims'] = [16, 32, 64, 64, config['cond_ae_static']['bottleneck_size']]
+config['cond_ae_static']['decoder_depths'] = config['cond_ae_static']['encoder_depths']
+config['cond_ae_static']['decoder_dims'] = config['cond_ae_static']['encoder_dims']
+config['cond_ae_static']['activation'] = 'tanh'
+
+config['cond_ae_curv'] = dict()
+config['cond_ae_curv']['is_label'] = True
+config['cond_ae_curv']['kernel_size'] = 7
+config['cond_ae_curv']['bottleneck_size'] = 40
+config['cond_ae_curv']['encoder_depths'] = [3, 3, 9, 9, 3]
+config['cond_ae_curv']['encoder_dims'] = [16, 32, 64, 128, config['cond_ae_curv']['bottleneck_size']]
+config['cond_ae_curv']['decoder_depths'] = config['cond_ae_curv']['encoder_depths']
+config['cond_ae_curv']['decoder_dims'] = config['cond_ae_curv']['encoder_dims']
+config['cond_ae_curv']['activation'] = 'tanh'
+
+config['cond_ae_body'] = dict()
+config['cond_ae_body']['is_label'] = False
+config['cond_ae_body']['kernel_size'] = 7
+config['cond_ae_body']['bottleneck_size'] = 16
+config['cond_ae_body']['encoder_depths'] = [3, 3, 9, 9, 3]
+config['cond_ae_body']['encoder_dims'] = [16, 32, 64, 128, config['cond_ae_body']['bottleneck_size']]
+config['cond_ae_body']['decoder_depths'] = config['cond_ae_body']['encoder_depths']
+config['cond_ae_body']['decoder_dims'] = config['cond_ae_body']['encoder_dims']
+config['cond_ae_body']['activation'] = 'tanh'

configs/review/config_ae_body.py

@@ -0,0 +1,51 @@
+config = dict()
+
+
+config['batch_size'] = 4
+config['train_dir'] = '/home/workspace/local-data/train'
+config['valid_dir'] = '/home/workspace/local-data/valid'
+config['test_dir'] = '/home/workspace/data/dataset/test_ready'
+config['use_filled'] = False
+config['resolution'] = 512
+config['is_skirt'] = False
+config['dataset_in_memory'] = False
+config['is_cape'] = False
+config['remove_global_orientation'] = True
+
+config['smpl_res'] = 14475
+if config['is_cape']:
+  config['smpl_res'] = 3638
+
+config['latent_dim'] = 128
+
+config['cond_ae'] = dict()
+config['cond_ae']['is_label'] = False
+config['cond_ae']['upscale_output'] = False
+config['cond_ae']['latent_dim'] = config['latent_dim']
+config['cond_ae']['kernel_size'] = 7
+config['cond_ae']['bottleneck_size'] = 16
+config['cond_ae']['encoder_depths'] = [3, 3, 9, 9, 3]
+config['cond_ae']['encoder_dims'] = [16, 32, 64, 128, config['cond_ae']['bottleneck_size']]
+config['cond_ae']['decoder_depths'] = config['cond_ae']['encoder_depths']
+config['cond_ae']['decoder_dims'] = config['cond_ae']['encoder_dims']
+config['cond_ae']['activation'] = 'tanh'
+
+
+config['gpu'] = '4'
+config['lr'] = 0.0001
+config['name'] = 'body_r7_3'
+config['notes'] = 'resnet18' 
+config['tags'] = ['review_7']
+
+config['cond_ae']['upscale_output'] = False
+config['pretrained_model'] = ''
+
+
+config['signature_dynamic'] = { 'id': (), 'frame_nr': (),
+                          'pose_shape': (72 + 11,),
+                          'uv_body_posed': (3, 512, 256,),
+                          'mesh_body_posed': (config['smpl_res'], 3,),
+                        }
+config['signature_static'] = { 
+                         'mesh_mask': (config['smpl_res'],),
+                        }

configs/review/config_ae_curv.py

@@ -0,0 +1,50 @@
+config = dict()
+
+
+config['batch_size'] = 4
+config['train_dir'] = '/home/workspace/local-data/train'
+config['valid_dir'] = '/home/workspace/local-data/valid'
+config['test_dir'] = '/home/workspace/data/dataset/test_ready'
+config['use_filled'] = False
+config['resolution'] = 512
+config['is_skirt'] = False
+config['dataset_in_memory'] = False
+config['is_cape'] = False
+config['remove_global_orientation'] = True
+
+config['smpl_res'] = 14475
+if config['is_cape']:
+  config['smpl_res'] = 3638
+
+config['latent_dim'] = 128
+
+config['cond_ae'] = dict()
+config['cond_ae']['is_label'] = True
+config['cond_ae']['upscale_output'] = False
+config['cond_ae']['latent_dim'] = config['latent_dim']
+config['cond_ae']['kernel_size'] = 7
+config['cond_ae']['bottleneck_size'] = 40
+config['cond_ae']['encoder_depths'] = [3, 3, 9, 9, 3]
+config['cond_ae']['encoder_dims'] = [16, 32, 64, 128, config['cond_ae']['bottleneck_size']]
+config['cond_ae']['decoder_depths'] = config['cond_ae']['encoder_depths']
+config['cond_ae']['decoder_dims'] = config['cond_ae']['encoder_dims']
+config['cond_ae']['activation'] = 'tanh'
+
+
+config['gpu'] = '3'
+config['lr'] = 0.001
+config['name'] = 'curv_r7_3'
+config['notes'] = 'resnet18' 
+config['tags'] = ['review_7']
+
+config['cond_ae']['upscale_output'] = False
+config['pretrained_model'] = ''
+
+
+config['signature_dynamic'] = { 'id': (), 'frame_nr': (),
+                          'uv_curvature': (512, 256, 7),
+                          'mesh_curvature':  (config['smpl_res'])
+                        }
+config['signature_static'] = { 'mesh_mask': (config['smpl_res'],),
+                         'uv_mask': (512, 256,),
+                        }

configs/review/config_ae_static.py

@@ -0,0 +1,51 @@
+config = dict()
+
+
+config['batch_size'] = 4
+config['train_dir'] = '/home/workspace/local-data/train'
+config['valid_dir'] = '/home/workspace/local-data/valid'
+config['test_dir'] = '/home/workspace/data/dataset/test_ready'
+config['use_filled'] = False
+config['resolution'] = 512
+config['is_skirt'] = False
+config['dataset_in_memory'] = True
+config['is_cape'] = False
+config['remove_global_orientation'] = True
+
+config['smpl_res'] = 14475
+if config['is_cape']:
+  config['smpl_res'] = 3638
+
+config['latent_dim'] = 128
+
+config['cond_ae'] = dict()
+config['cond_ae']['is_label'] = False
+config['cond_ae']['upscale_output'] = False
+config['cond_ae']['latent_dim'] = config['latent_dim']
+config['cond_ae']['kernel_size'] = 7
+config['cond_ae']['bottleneck_size'] = 8
+config['cond_ae']['encoder_depths'] = [3, 3, 3, 27, 3]
+config['cond_ae']['encoder_dims'] = [8, 16, 32, 32, config['cond_ae']['bottleneck_size']]
+config['cond_ae']['decoder_depths'] = config['cond_ae']['encoder_depths']
+config['cond_ae']['decoder_dims'] = config['cond_ae']['encoder_dims']
+config['cond_ae']['activation'] = 'linear'
+
+
+config['gpu'] = '6'
+config['lr'] = 0.0005
+config['name'] = 'static_r7_3'
+config['notes'] = 'resnet18 based, one more block'
+config['tags'] = ['review_7']
+
+    
+
+config['cond_ae']['upscale_output'] = False
+config['pretrained_model'] = ''
+
+
+config['signature_dynamic'] = { 'id': (), 'frame_nr': (), }
+config['signature_static'] = { 'uv_static': (512, 256, 3),
+                         'mesh_static': (config['smpl_res'], 3,),
+                         'mesh_mask': (config['smpl_res'],),
+                         'uv_mask': (512, 256,),
+                        }

convnext/models/convnext_tf.py

@@ -225,28 +225,26 @@ class ConvNeXtReverse(tf.keras.Model):
                  drop_path_rate=0., layer_scale_init_value=1e-6, head_init_scale=1., learn_weights=False,
                  ):
         super().__init__()
-        self.upsample_layers = [] 
+        self.upsample_layers = []  # stem and 3 intermediate downsampling conv layers
-
         stem = tf.keras.Sequential([
-            LayerNormalization(epsilon=1e-6),
+            Conv2DTranspose(dims[0], kernel_size=4, strides=4, padding='same'),
-            Conv2DTranspose(dims[0], kernel_size=2, strides=2, padding='same'),
+            # UpSampling2D((4, 4), interpolation='nearest'),
-        ])
+            # Conv2D(dims[0], kernel_size=4, strides=1, padding='same'),
+            # Dense(dims[0]),
+            LayerNormalization(epsilon=1e-6)]
+        )
         self.upsample_layers.append(stem)
-
+        for i in range(len(depths) - 1):
-        for i in range(len(depths) - 2):
             downsample_layer = tf.keras.Sequential([
                 LayerNormalization(epsilon=1e-6),
-                Conv2DTranspose(dims[i+1], kernel_size=2, strides=2, padding='same'),
+                Conv2DTranspose(dims[i+1], kernel_size=2, strides=2, padding='same')
+                # UpSampling2D((2,2), interpolation='nearest'),
+                # Conv2D(dims[i+1], kernel_size=2, strides=1, padding='same'),
+                # Dense(dims[i+1]),
             ])
             self.upsample_layers.append(downsample_layer)
 
-        downsample_layer = tf.keras.Sequential([
+        self.stages = []  # 4 feature resolution stages, each consisting of multiple residual blocks
-            Conv2DTranspose(dims[i+2], kernel_size=2, strides=2, padding='same'),
-            LayerNormalization(epsilon=1e-6),
-        ])
-        self.upsample_layers.append(downsample_layer)
-
-        self.stages = []  
         dp_rates = [x for x in np.linspace(0, drop_path_rate, sum(depths))]
         cur = 0
         for i in range(len(depths)):
@@ -259,7 +257,6 @@ class ConvNeXtReverse(tf.keras.Model):
 
         if not learn_weights:
             self.last = Dense(3, activation='tanh')
-            # self.last = Activation('tanh')
         else:
             self.last = Activation('softmax')
             # self.last = Dense(24, activation='softmax')

custom_utils/custom_utils.py

@@ -433,3 +433,27 @@ def group_inputs_for_levels(batch, config):
         levels_input.append([uv_orig, batch['uv_static' + res_modifier], batch['uv_body_posed' + res_modifier], batch['uv_curvature' + res_modifier], batch['uv_mask' + res_modifier], batch['uv_mask']])
     conds = [batch['uv_static'], batch['uv_body_posed'], batch['uv_curvature']]
     return levels_input, conds
+
+
+
+
+
+class Accumulator():
+    def __init__(self):
+        self.dict = dict()
+
+    def update(self, dict):
+        for key in dict.keys():
+            if key in self.dict.keys():
+                self.dict[key].append(dict[key])
+            else:
+                self.dict[key] = [dict[key]]
+
+    def get(self):
+        result = dict()
+        for key in self.dict.keys():
+            result[key] = np.mean(self.dict[key])
+        return result
+
+    def reset(self):
+        self.dict = dict()

cvae.py

@@ -1,6 +1,6 @@
 import os
 import sys
-from configs.config_abl_all_post import config
+from configs.iccv.config_abl_all import config
 
 os.environ["CUDA_VISIBLE_DEVICES"] = config['gpu']
 import tensorflow as tf
@@ -58,7 +58,9 @@ def init_wandb():
     artifact.add_file('convnext/models/convnext_tf.py')
     config_file_names = [key for key in sys.modules.keys()  if key.startswith('configs.')]
     for config_file_name in config_file_names:
-        artifact.add_file('/'.join(config_file_name.split('.')) + '.py')
+        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_adaptive=False, is_smpl_orig=config['is_cape'])
@@ -455,8 +457,6 @@ def sample(folder):
 
 
 
-
-
 def test():
     str_split = config['name'].split('_')
     test_idx = str_split.index('test')

cvae_pyramid.py

@@ -1,6 +1,6 @@
 import os
 import sys
-from configs.post.config_abl_pyr_64_128_5 import config
+from configs.iccv.config_abl_pyr_32_res_skirt import config
 
 os.environ["CUDA_VISIBLE_DEVICES"] = config['gpu']
 import tensorflow as tf
@@ -43,10 +43,11 @@ from dataset import DatasetFactory, StaticDataset
 from custom_utils.smpl import SMPL
 from models.pyramid_model_optimized import PyramidNew as Pyramid
 from postprocessing import fix_collision
+from custom_utils.custom_utils import Accumulator
 
 
 def init_wandb():
-    run = wandb.init(project='ablation', name=config['name'], notes=config['notes'], dir='/wandb', 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('cvae_pyramid.py')
@@ -59,9 +60,11 @@ def init_wandb():
     artifact.add_file('models/cond_encoder.py')
     artifact.add_file('dataset.py')
     artifact.add_file('convnext/models/convnext_tf.py')
-    config_file_names = [key for key in sys.modules.keys()  if key.startswith('configs.post.')]
+    config_file_names = [key for key in sys.modules.keys()  if key.startswith('configs.')]
     for config_file_name in config_file_names:
-        artifact.add_file('/'.join(config_file_name.split('.')) + '.py')
+        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'])
@@ -790,7 +793,9 @@ if __name__ == '__main__':
     # generate_results()
 
     ckpt = tf.train.Checkpoint(model=model)
-    manager = tf.train.CheckpointManager(ckpt, 'checkpoints/post/' + config['name'], max_to_keep=20)
+    manager = tf.train.CheckpointManager(ckpt, 'checkpoints/iccv/' + config['name'], max_to_keep=20)
+    train_accumulator = Accumulator()
+    valid_accumulator = Accumulator()
 
     # load_model(model, 'checkpoints/pyr_abl_32_skirt', iteration='180000')
 
@@ -846,31 +851,32 @@ if __name__ == '__main__':
 
 
         train_loss = train_step(batch)
+        train_accumulator.update(train_loss)
 
+        if step % 25 == 0:
             data_valid = valid_iterator.get_next()
             data_valid = static_dataset_valid.expand_batch(batch_to_dict(data_valid, config['signature_dynamic']))
             valid_loss = valid_step(data_valid)
+            valid_accumulator.update(valid_loss)
 
-        to_log = { **train_loss, **valid_loss, **{ 'current_step': step} }
+
-        if step % 5000 == 0 or (step < 5000 and step % 500 == 0):
+        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 % 5000 == 0:
-            manager.save(checkpoint_number=step)
             if step == 0:
                 to_log = { **to_log, **{ 'model/summary': wandb.Html(get_summary_html(model)) } }
 
-        if train_loss['train/euclid_error'] < 0.004:
-            if balancing_activated_step == 0:
-                balancing_activated_step = step
-            balancing_coeff = balancing_coeff + 1 / 20000
-
-
             to_log = { **to_log, **{ 'train/balancing_coeff': balancing_coeff, 'train/gamma': gamma } }
                 
-        wandb.log(to_log, step = step)
+            wandb.log(to_log, step=step)
+            train_accumulator.reset()
+            valid_accumulator.reset()
+
+        if step % 5000 == 0:
+            manager.save(checkpoint_number=step)
 
         print(step)
 

evaluate_ae.py

@@ -1,6 +1,6 @@
 import os
 import sys
-from configs.config_abl_all_post import config
+from configs.review.config_abl_all import config
 
 os.environ["CUDA_VISIBLE_DEVICES"] = config['gpu']
 import tensorflow as tf

evaluate_ae_pyramid.py

@@ -1,6 +1,6 @@
 import os
 import sys
-from configs.config_abl_2_pyr_32_64_128_256_512 import config
+from configs.iccv.config_abl_pyr_32_res_skirt import config
 
 os.environ["CUDA_VISIBLE_DEVICES"] = config['gpu']
 import tensorflow as tf
@@ -27,7 +27,7 @@ import numpy as np
 import plotly.graph_objects as go
 import plotly.express as ex
 from PIL import Image
-from models.pyramid_model_optimized import Pyramid
+from models.pyramid_model_optimized import PyramidNew as Pyramid
 from postprocessing import fix_collision
 
 if config['is_skirt']:
@@ -97,12 +97,12 @@ if __name__ == '__main__':
     ids = [id.split('_')[0] for id in ids]
     ids = set(ids)
 
-    iteration = '50000'
+    iteration = '170000'
 
-    load_model(model, 'checkpoints/' + checkpoint_name, iteration=iteration)
+    load_model(model, 'checkpoints/iccv/' + checkpoint_name, iteration=iteration)
     # load_model(model, 'checkpoints/' + 'abl_all_120k')
 
-    output_folder = '/home/workspace/data/results/' + checkpoint_name + '-' + iteration
+    output_folder = '/home/workspace/data/results/iccv/' + checkpoint_name + '-' + iteration
 
 
     os.makedirs(output_folder, exist_ok=True)

models/base.py

@@ -1,5 +1,7 @@
 import tensorflow as tf
 from convnext.models.convnext_tf import ConvNeXt, ConvNeXtReverse, Block, ConvNeXtReverseLabels
+from models.resnet import resnet_18, make_basic_block_layer, resnet_34, resnet_50, resnet_101, resnet_152
+
 
 class Bottleneck(tf.keras.Model):
     
@@ -111,20 +113,34 @@ class Decoder(tf.keras.Model):
 
 class VariationalEncoderNew(tf.keras.Model):
     
-    def __init__(self, depths, dims, kernel_size=7):
+    def __init__(self, layer_params, features):
         super(VariationalEncoderNew, self).__init__()
 
-        self.encoder = ConvNeXt(depths=depths, dims=dims, include_top=False, kernel_size=kernel_size)
+        self.encoder = resnet_18(layer_params, features)
 
-        self.mean_branch = tf.keras.Sequential(
+        self.mean_branch = tf.keras.Sequential([
-                [Block(dim=64, drop_path=0, kernel_size=kernel_size,
+            tf.keras.layers.Conv2D(filters=features,
-                       layer_scale_init_value=1e-6, prefix=f'bottleneck{j}') for j in range(5)]
+                                            kernel_size=(3, 3),
-            )
+                                            strides=1,
+                                            padding="same"),
+            tf.keras.layers.BatchNormalization(),
+            tf.keras.layers.Conv2D(filters=features,
+                                            kernel_size=(3, 3),
+                                            strides=1,
+                                            padding="same")
+        ])
 
-        self.var_branch = tf.keras.Sequential(
+        self.var_branch = tf.keras.Sequential([
-                [Block(dim=64, drop_path=0, kernel_size=kernel_size,
+            tf.keras.layers.Conv2D(filters=features,
-                       layer_scale_init_value=1e-6, prefix=f'bottleneck{j}') for j in range(5)]
+                                            kernel_size=(3, 3),
-            )
+                                            strides=1,
+                                            padding="same"),
+            tf.keras.layers.BatchNormalization(),
+            tf.keras.layers.Conv2D(filters=features,
+                                            kernel_size=(3, 3),
+                                            strides=1,
+                                            padding="same")
+        ])
 
         self.flatten_mean = tf.keras.layers.Flatten()
         self.flatten_var = tf.keras.layers.Flatten()
@@ -147,10 +163,10 @@ class VariationalEncoderNew(tf.keras.Model):
 
 class AEEncoderNew(tf.keras.Model):
     
-    def __init__(self, depths, dims, kernel_size=7, activation='tanh'):
+    def __init__(self, layer_params, features, activation='tanh'):
         super(AEEncoderNew, self).__init__()
 
-        self.encoder = ConvNeXt(depths=depths, dims=dims, include_top=False, kernel_size=kernel_size)
+        self.encoder = resnet_18(layer_params, features)
         self.act = tf.keras.layers.Activation(activation)
 
 
@@ -171,15 +187,15 @@ class AEEncoderNew(tf.keras.Model):
 
 class DecoderNew(tf.keras.Model):
     
-    def __init__(self, depths, dims, kernel_size=7, is_label=False, learn_weights=False):
+    def __init__(self, layer_params, features, is_label=False, is_cvae=False, learn_weights=False):
         super(DecoderNew, self).__init__()
 
         self.is_label = is_label
 
         if not is_label:
-            self.decoder = ConvNeXtReverse(depths=depths, dims=dims, kernel_size=kernel_size, learn_weights=learn_weights)
+            self.decoder = resnet_18(layer_params, features, reversed=True, is_cvae=is_cvae)
         else:
-            self.decoder = ConvNeXtReverseLabels(depths=depths, dims=dims, nr_of_classes=7)
+            self.decoder = resnet_18(layer_params, features, reversed=True, labels=6, is_cvae=is_cvae)
             
 
     def call(self, inputs, training):

models/cond_encoder.py

@@ -25,8 +25,8 @@ class AutoEncoderNew(tf.keras.Model):
     def __init__(self, config):
         super(AutoEncoderNew, self).__init__()
 
-        self.encoder : AEEncoderNew = AEEncoderNew(config['encoder_depths'], config['encoder_dims'], config['kernel_size'], config['activation'])
+        self.encoder : AEEncoderNew = AEEncoderNew(config['layer_params'], config['bottleneck_size'], config['activation'])
-        self.decoder : DecoderNew = DecoderNew(config['decoder_depths'], config['decoder_dims'], kernel_size=config['kernel_size'], is_label=config['is_label'])
+        self.decoder : DecoderNew = DecoderNew(config['layer_params'], config['bottleneck_size'], is_label=config['is_label'])
 
 
     def call(self, inputs, training):

models/cvae_model.py

@@ -159,16 +159,16 @@ class CVAENew(tf.keras.Model):
         self.size = config['resolution']
 
         if not('only_curvatures' in config.keys() and config['only_curvatures'] == True):
-            self.static_enc : AEEncoderNew = AEEncoderNew(config['cond_ae_static']['encoder_depths'], config['cond_ae_static']['encoder_dims'], config['cond_ae_static']['kernel_size'], config['cond_ae_static']['activation'])
+            self.static_enc : AEEncoderNew = AEEncoderNew(config['cond_ae_static']['bottleneck_size'], config['cond_ae_static']['activation'])
             if config['static_model'] != '':
                 load_model(self.static_enc, config['static_model'] + '_enc')
 
-            self.body_enc : AEEncoderNew = AEEncoderNew(config['cond_ae_body']['encoder_depths'], config['cond_ae_body']['encoder_dims'], config['cond_ae_body']['kernel_size'])
+            self.body_enc : AEEncoderNew = AEEncoderNew(config['cond_ae_body']['bottleneck_size'])
             if config['body_model'] != '':
                 load_model(self.body_enc, config['body_model'] + '_enc')
 
         if config['use_curvature']:
-            self.curv_enc : AEEncoderNew = AEEncoderNew(config['cond_ae_curv']['encoder_depths'], config['cond_ae_curv']['encoder_dims'], config['cond_ae_curv']['kernel_size'], config['cond_ae_curv']['activation'])
+            self.curv_enc : AEEncoderNew = AEEncoderNew(config['cond_ae_curv']['bottleneck_size'], config['cond_ae_curv']['activation'])
             if config['curvature_model'] != '':
                 load_model(self.curv_enc, config['curvature_model'] + '_enc')
 
@@ -182,8 +182,10 @@ class CVAENew(tf.keras.Model):
         self.encoder = VariationalEncoderNew(config['cvae']['encoder_depths'], config['cvae']['encoder_dims'], kernel_size=config['cvae']['kernel_size'])
         self.decoder = DecoderNew(config['cvae']['decoder_depths'], config['cvae']['decoder_dims'], config['cvae']['kernel_size'])
         self.decoder_weights = DecoderNew(config['cvae']['decoder_weights_depths'], config['cvae']['decoder_weights_dims'], config['cvae']['kernel_size'], learn_weights=True)
+        self.encoder = VariationalEncoderNew(config['cvae']['encoder_dims'][-1])
+        self.decoder = DecoderNew(config['cvae']['decoder_dims'][-1], is_cvae=True)
 
-        self.reshape = tf.keras.layers.Reshape((8, 4, 64))
+        self.reshape = tf.keras.layers.Reshape((8, 4, config['cvae']['decoder_dims'][-1]))
 
         if config['avg_garment_path'] != '':
             self.avg_garment = np.load(config['avg_garment_path'])

models/pyramid_level.py

@@ -102,8 +102,8 @@ class PyramidLevelNew(tf.keras.Model):
         super(PyramidLevelNew, self).__init__()
         self.size = config['resolution']
 
-        self.encoder = VariationalEncoderNew(config['encoder_depths'], config['encoder_dims'], kernel_size=config['kernel_size'])
+        self.encoder = VariationalEncoderNew(config['layer_params'], config['bottleneck_size'])
-        self.decoder = DecoderNew(config['decoder_depths'], config['decoder_dims'], config['kernel_size'])
+        self.decoder = DecoderNew(config['layer_params'], config['bottleneck_size'])
 
         self.upscale_enhancer = None
         if config['upscale_enhancer'] != '':
@@ -117,7 +117,7 @@ class PyramidLevelNew(tf.keras.Model):
         else:
             self.avg_garment = None
 
-        self.reshape = tf.keras.layers.Reshape((8, 4, 64))
+        self.reshape = tf.keras.layers.Reshape((8, 4, config['bottleneck_size']))
 
 
     def enhance(self, low, mask, training=None):

models/pyramid_model_optimized.py

@@ -256,15 +256,15 @@ class PyramidNew(tf.keras.Model):
     def __init__(self, config):
         super(PyramidNew, self).__init__()
 
-        self.static_enc : AEEncoderNew = AEEncoderNew(config['cond_ae_static']['encoder_depths'], config['cond_ae_static']['encoder_dims'], config['cond_ae_static']['kernel_size'], config['cond_ae_static']['activation'])
+        self.static_enc : AEEncoderNew = AEEncoderNew(config['cond_ae_static']['layer_params'], config['cond_ae_static']['bottleneck_size'], config['cond_ae_static']['activation'])
         if config['pyramid']['static_model'] != '':
             load_model(self.static_enc, config['pyramid']['static_model'] + '_enc')
 
-        self.body_enc : AEEncoderNew = AEEncoderNew(config['cond_ae_body']['encoder_depths'], config['cond_ae_body']['encoder_dims'], config['cond_ae_body']['kernel_size'])
+        self.body_enc : AEEncoderNew = AEEncoderNew(config['cond_ae_body']['layer_params'], config['cond_ae_body']['bottleneck_size'], config['cond_ae_static']['activation'])
         if config['pyramid']['body_model'] != '':
             load_model(self.body_enc, config['pyramid']['body_model'] + '_enc')
 
-        self.curv_enc : AEEncoderNew = AEEncoderNew(config['cond_ae_curv']['encoder_depths'], config['cond_ae_curv']['encoder_dims'], config['cond_ae_curv']['kernel_size'], config['cond_ae_curv']['activation'])
+        self.curv_enc : AEEncoderNew = AEEncoderNew(config['cond_ae_curv']['layer_params'], config['cond_ae_curv']['bottleneck_size'], config['cond_ae_curv']['activation'])
         if config['pyramid']['curvature_model'] != '':
             load_model(self.curv_enc, config['pyramid']['curvature_model'] + '_enc')
 

models/resnet.py

@@ -0,0 +1,307 @@
+# taken from https://github.com/calmisential/TensorFlow2.0_ResNet/blob/master/models/resnet.py
+
+import tensorflow as tf
+
+
+class BasicBlock(tf.keras.layers.Layer):
+
+    def __init__(self, filter_num, stride=1, upsample=False):
+        super(BasicBlock, self).__init__()
+        if not upsample:
+            self.conv1 = tf.keras.layers.Conv2D(filters=filter_num,
+                                                kernel_size=(3, 3),
+                                                strides=stride,
+                                                padding="same")
+        else:
+            self.conv1 = tf.keras.layers.Conv2DTranspose(filters=filter_num,
+                                                kernel_size=(3, 3),
+                                                strides=stride,
+                                                padding="same")
+        self.bn1 = tf.keras.layers.BatchNormalization()
+        self.conv2 = tf.keras.layers.Conv2D(filters=filter_num,
+                                            kernel_size=(3, 3),
+                                            strides=1,
+                                            padding="same")
+        self.bn2 = tf.keras.layers.BatchNormalization()
+        if stride != 1:
+            if not upsample:
+                self.updownsample = tf.keras.Sequential()
+                self.updownsample.add(tf.keras.layers.Conv2D(filters=filter_num,
+                                                        kernel_size=(1, 1),
+                                                        strides=stride))
+                self.updownsample.add(tf.keras.layers.BatchNormalization())
+            else:
+                self.updownsample = tf.keras.Sequential()
+                self.updownsample.add(tf.keras.layers.Conv2DTranspose(filters=filter_num,
+                                                        kernel_size=(1, 1),
+                                                        strides=stride))
+                self.updownsample.add(tf.keras.layers.BatchNormalization())
+        else:
+            self.updownsample = lambda x: x
+
+    def call(self, inputs, training=None, **kwargs):
+        residual = self.updownsample(inputs)
+
+        x = self.conv1(inputs)
+        x = self.bn1(x, training=training)
+        x = tf.nn.relu(x)
+        x = self.conv2(x)
+        x = self.bn2(x, training=training)
+
+        output = tf.nn.relu(tf.keras.layers.add([residual, x]))
+
+        return output
+
+
+class BottleNeck(tf.keras.layers.Layer):
+    def __init__(self, filter_num, stride=1, upsample=False):
+        super(BottleNeck, self).__init__()
+        self.conv1 = tf.keras.layers.Conv2D(filters=filter_num,
+                                            kernel_size=(1, 1),
+                                            strides=1,
+                                            padding='same')
+        self.bn1 = tf.keras.layers.BatchNormalization()
+        if not upsample:
+            self.conv2 = tf.keras.layers.Conv2D(filters=filter_num,
+                                                kernel_size=(3, 3),
+                                                strides=stride,
+                                                padding='same')
+        else:
+            self.conv2 = tf.keras.layers.Conv2DTranspose(filters=filter_num,
+                                                kernel_size=(3, 3),
+                                                strides=stride,
+                                                padding='same')
+        self.bn2 = tf.keras.layers.BatchNormalization()
+        self.conv3 = tf.keras.layers.Conv2D(filters=filter_num * 4,
+                                            kernel_size=(1, 1),
+                                            strides=1,
+                                            padding='same')
+        self.bn3 = tf.keras.layers.BatchNormalization()
+
+        self.updownsample = tf.keras.Sequential()
+        if not upsample:
+            self.updownsample.add(tf.keras.layers.Conv2D(filters=filter_num * 4,
+                                                    kernel_size=(1, 1),
+                                                    strides=stride))
+        else:
+            self.updownsample.add(tf.keras.layers.Conv2DTranspose(filters=filter_num * 4,
+                                                    kernel_size=(1, 1),
+                                                    strides=stride))
+        self.updownsample.add(tf.keras.layers.BatchNormalization())
+
+    def call(self, inputs, training=None, **kwargs):
+        residual = self.updownsample(inputs)
+
+        x = self.conv1(inputs)
+        x = self.bn1(x, training=training)
+        x = tf.nn.relu(x)
+        x = self.conv2(x)
+        x = self.bn2(x, training=training)
+        x = tf.nn.relu(x)
+        x = self.conv3(x)
+        x = self.bn3(x, training=training)
+
+        output = tf.nn.relu(tf.keras.layers.add([residual, x]))
+
+        return output
+
+
+def make_basic_block_layer(filter_num, blocks, stride=1, upsample=False):
+    res_block = tf.keras.Sequential()
+    res_block.add(BasicBlock(filter_num, stride=stride, upsample=upsample))
+
+    for _ in range(1, blocks):
+        res_block.add(BasicBlock(filter_num, stride=1))
+
+    return res_block
+
+
+def make_bottleneck_layer(filter_num, blocks, stride=1, upsample=False):
+    res_block = tf.keras.Sequential()
+    res_block.add(BottleNeck(filter_num, stride=stride, upsample=upsample))
+
+    for _ in range(1, blocks):
+        res_block.add(BottleNeck(filter_num, stride=1))
+
+    return res_block
+
+
+class ResNetTypeI(tf.keras.Model):
+    def __init__(self, layer_params, features, reversed=False, labels=None, is_cvae=False):
+        super(ResNetTypeI, self).__init__()
+        self.reversed = reversed
+        self.labels = labels
+        self.layer_params = layer_params
+
+        if not reversed:
+            self.conv1 = tf.keras.layers.Conv2D(filters=32 if len(layer_params) > 1 else features,
+                                                kernel_size=(7, 7),
+                                                strides=2,
+                                                padding="same")
+            self.bn1 = tf.keras.layers.BatchNormalization()
+            self.pool1 = tf.keras.layers.MaxPool2D(pool_size=(3, 3),
+                                                strides=2,
+                                                padding="same")
+        else:
+            self.conv1 = tf.keras.layers.Conv2DTranspose(filters=3 if labels is None else labels,
+                                                kernel_size=(7, 7),
+                                                strides=2 if len(layer_params) > 1 else 1,
+                                                padding="same")
+            self.bn1 = tf.keras.layers.BatchNormalization()
+            self.pool1 = tf.keras.layers.UpSampling2D()
+
+        self.layer1 = make_basic_block_layer(filter_num=32 if len(layer_params) > 1 else (features if not is_cvae else features*2),
+                                             blocks=layer_params[0],
+                                             stride=1 if not reversed else 2,
+                                             upsample=reversed)
+        if len(layer_params) >= 2:
+            self.layer2 = make_basic_block_layer(filter_num=32,
+                                                blocks=layer_params[1],
+                                                stride=2,
+                                                upsample=reversed)
+        if len(layer_params) >= 3:
+            self.layer3 = make_basic_block_layer(filter_num=32,
+                                                blocks=layer_params[2],
+                                                stride=2,
+                                                upsample=reversed)
+        if len(layer_params) >= 4:
+            self.layer4 = make_basic_block_layer(filter_num=64,
+                                                blocks=layer_params[3],
+                                                stride=2,
+                                                upsample=reversed)
+            
+        if len(layer_params) >= 5:
+            self.layer5 = make_basic_block_layer(filter_num=features if not is_cvae else features*2,
+                                                blocks=layer_params[4],
+                                                stride=2 if not reversed else 1,
+                                                upsample=reversed)
+
+    def call(self, inputs, training=None, mask=None):
+        if not self.reversed:
+            x = self.conv1(inputs)
+            x = self.bn1(x, training=training)
+            x = tf.nn.relu(x)
+            x = self.pool1(x)
+            x = self.layer1(x, training=training)
+            if len(self.layer_params) >= 2:
+                x = self.layer2(x, training=training)
+            if len(self.layer_params) >= 3:
+                x = self.layer3(x, training=training)
+            if len(self.layer_params) >= 4:
+                x = self.layer4(x, training=training)
+            if len(self.layer_params) >= 5:
+                x = self.layer5(x, training=training)
+        else:
+            x = inputs
+            if len(self.layer_params) >= 5:
+                x = self.layer5(x, training=training)
+            if len(self.layer_params) >= 4:
+                x = self.layer4(x, training=training)
+            if len(self.layer_params) >= 2:
+                x = self.layer3(x, training=training)
+            if len(self.layer_params) >= 3:
+                x = self.layer2(x, training=training)
+            x = self.layer1(x, training=training)
+
+            x = self.pool1(x)
+            x = self.bn1(x, training=training)
+            # x = tf.nn.relu(x)
+            x = self.conv1(x)
+            if self.labels is None:
+                x = tf.nn.tanh(x)
+            # else:
+            #     x = tf.nn.softmax(x)
+
+        return x
+
+
+class ResNetTypeII(tf.keras.Model):
+    def __init__(self, layer_params, features, reversed=False, labels=None, is_cvae=False):
+        super(ResNetTypeII, self).__init__()
+        self.reversed = reversed
+        self.labels = labels
+
+        if not reversed:
+            self.conv1 = tf.keras.layers.Conv2D(filters=32,
+                                                kernel_size=(7, 7),
+                                                strides=2,
+                                                padding="same")
+            self.bn1 = tf.keras.layers.BatchNormalization()
+            self.pool1 = tf.keras.layers.MaxPool2D(pool_size=(3, 3),
+                                                strides=2,
+                                                padding="same")
+        else:
+            self.conv1 = tf.keras.layers.Conv2DTranspose(filters=3 if labels is None else labels,
+                                                kernel_size=(7, 7),
+                                                strides=2,
+                                                padding="same")
+            self.bn1 = tf.keras.layers.BatchNormalization()
+            self.pool1 = tf.keras.layers.UpSampling2D()
+
+        self.layer1 = make_bottleneck_layer(filter_num=32,
+                                            blocks=layer_params[0],
+                                            stride=1 if not reversed else 2,
+                                            upsample=reversed)
+        self.layer2 = make_bottleneck_layer(filter_num=64,
+                                            blocks=layer_params[1],
+                                            stride=2,
+                                            upsample=reversed)
+        self.layer3 = make_bottleneck_layer(filter_num=64,
+                                            blocks=layer_params[2],
+                                            stride=2,
+                                            upsample=reversed)
+        self.layer4 = make_bottleneck_layer(filter_num=128,
+                                            blocks=layer_params[3],
+                                            stride=2,
+                                            upsample=reversed)
+        self.layer5 = make_bottleneck_layer(filter_num=features if not is_cvae else features*2,
+                                            blocks=layer_params[4],
+                                            stride=2 if not reversed else 1,
+                                            upsample=reversed)
+        
+
+    def call(self, inputs, training=None, mask=None):
+        if not self.reversed:
+            x = self.conv1(inputs)
+            x = self.bn1(x, training=training)
+            x = tf.nn.relu(x)
+            x = self.pool1(x)
+            x = self.layer1(x, training=training)
+            x = self.layer2(x, training=training)
+            x = self.layer3(x, training=training)
+            x = self.layer4(x, training=training)
+            x = self.layer5(x, training=training)
+        else:
+            x = self.layer5(inputs, training=training)
+            x = self.layer4(x, training=training)
+            x = self.layer3(x, training=training)
+            x = self.layer2(x, training=training)
+            x = self.layer1(x, training=training)
+
+            x = self.pool1(x)
+            x = self.bn1(x, training=training)
+            x = self.conv1(x)
+            if self.labels is None:
+                x = tf.nn.tanh(x)
+
+        return x
+
+
+def resnet_18(layer_params, features, reversed=False, labels=None, is_cvae=False):
+    return ResNetTypeI(layer_params=layer_params, features=features, reversed=reversed, labels=labels, is_cvae=is_cvae)
+
+
+def resnet_34():
+    return ResNetTypeI(layer_params=[3, 4, 6, 3])
+
+
+def resnet_50():
+    return ResNetTypeII(layer_params=[3, 4, 6, 3])
+
+
+def resnet_101(layer_params, features, reversed=False, labels=None, is_cvae=False):
+    return ResNetTypeII(layer_params=layer_params, features=features, reversed=reversed, labels=labels, is_cvae=is_cvae)
+
+
+def resnet_152():
+    return ResNetTypeII(layer_params=[3, 8, 36, 3])

models/upscaler.py

@@ -131,13 +131,13 @@ class UpscalerBasicConv(tf.keras.Model):
         self.low_res = low_res
 
         self.seq = tf.keras.Sequential([
-                    tf.keras.layers.Conv2D(256, kernel_size=kernel_size, padding='same', activation='relu', name='upscale_enhancer_conv_1'),
+                    tf.keras.layers.Conv2D(64, kernel_size=kernel_size, padding='same', activation='relu', name='upscale_enhancer_conv_1'),
                     tf.keras.layers.BatchNormalization(name='upscale_enhancer_batch_norm_1'),
-                    tf.keras.layers.Conv2D(128, kernel_size=kernel_size, padding='same', activation='relu', name='upscale_enhancer_conv_2'),
+                    tf.keras.layers.Conv2D(64, kernel_size=kernel_size, padding='same', activation='relu', name='upscale_enhancer_conv_2'),
                     tf.keras.layers.BatchNormalization(name='upscale_enhancer_batch_norm_2'),
-                    tf.keras.layers.Conv2D(64, kernel_size=kernel_size, padding='same', activation='relu', name='upscale_enhancer_conv_3'),
+                    tf.keras.layers.Conv2D(16, kernel_size=kernel_size, padding='same', activation='relu', name='upscale_enhancer_conv_3'),
                     tf.keras.layers.BatchNormalization(name='upscale_enhancer_batch_norm_3'),
-                    tf.keras.layers.Conv2D(32, kernel_size=kernel_size, padding='same', activation='relu', name='upscale_enhancer_conv_4'),
+                    tf.keras.layers.Conv2D(16, kernel_size=kernel_size, padding='same', activation='relu', name='upscale_enhancer_conv_4'),
                     tf.keras.layers.BatchNormalization(name='upscale_enhancer_batch_norm_4'),
                     tf.keras.layers.Dense(3, activation='tanh', name='upscale_enhancer_dense_final'),
                     ])