Failed to load a model

[sbinnee]

Desc

Follow up of #21. It looks like either I got a wrong model weight or I have to use a model other than unet? Thank you for your help in advance!

What I did

Config is the same as #21. I checked that cfg merged specified settings from the given config file.

config

PROBLEM:
    TYPE: DETECTION
    NDIM: 3D

DATA:
    PATCH_SIZE: (256, 256, 20, 3)
    REFLECT_TO_COMPLETE_SHAPE: True
    CHECK_GENERATORS: False
    EXTRACT_RANDOM_PATCH: False
    PROBABILITY_MAP: False
    TRAIN:
        PATH: 'path_to_train_data'
        MASK_PATH: 'path_to_train_data_gt'
        IN_MEMORY: True
        PADDING: (0,0,0)
        OVERLAP: (0,0,0)
    VAL:
        FROM_TRAIN: True
        SPLIT_TRAIN: 0.1
        IN_MEMORY: True
        PADDING: (0,0,0)
        OVERLAP: (0,0,0)
    TEST:
        PATH: './ChroMS/2021-03-24 P14 6520-2 Mcol cortex/test/x'
        MASK_PATH: ''
        IN_MEMORY: True
        LOAD_GT: False
        PADDING: (16,16,0)
        OVERLAP: (0,0,0)

AUGMENTOR:
    ENABLE: True
    AUG_SAMPLES: True
    DRAW_GRID: True
    DA_PROB: 1.0
    CHANNEL_SHUFFLE: False
    MISALIGNMENT: False
    CUTOUT: False
    GRIDMASK: False
    CUTNOISE: False
    CNOISE_SCALE: (0.05, 0.1)
    CUTBLUR: False
    RANDOM_ROT: False
    ROT90: False
    VFLIP: False
    HFLIP: False
    CONTRAST: False
    CONTRAST_FACTOR: (-0.3, 0.3)
    BRIGHTNESS: False
    BRIGHTNESS_FACTOR: (0.1, 0.3)
    GAMMA_CONTRAST: False
    GC_GAMMA: (0.5, 1.5)
    ELASTIC: False
    GRAYSCALE: True
    AFFINE_MODE: 'reflect'

MODEL:
    ARCHITECTURE: unet
    FEATURE_MAPS: [36, 48, 64]
    DROPOUT_VALUES: [0.1, 0.2, 0.3]
    Z_DOWN: 1
    LOAD_CHECKPOINT: False

LOSS:
  TYPE: CE

TRAIN:
    ENABLE: False
    OPTIMIZER: ADAM
    LR: 1.E-4
    BATCH_SIZE: 1
    EPOCHS: 500
    PATIENCE: 20

TEST:
    ENABLE: True
    AUGMENTATION: False

    DET_LOCAL_MAX_COORDS: True
    DET_MIN_TH_TO_BE_PEAK: [0.1]
    DET_VOXEL_SIZE: (0.4,0.4,2)
    DET_TOLERANCE: [10]
    DET_MIN_DISTANCE: [10]

    STATS:
        PER_PATCH: True
        MERGE_PATCHES: True
        FULL_IMG: False

PATHS:
    CHECKPOINT_FILE: './brainbow_3d_detection/model_weights_unet_3d_detection_P14_big_1.h5'

Script

from config.config import Config
from engine.engine import Engine

job_identifier = '1'
dataroot = './'
jobdir = './'

cfg = Config(jobdir,
             job_identifier=job_identifier,
             dataroot=dataroot)

cfg._C.merge_from_file('./brainbow_3d_detection/brainbow_3d_detection.yaml')
cfg.update_dependencies()
cfg = cfg.get_cfg_defaults()

engine = Engine(cfg, job_identifier)  # had an error. see issue #21 
engine.test()

Check loaded cfg

from pprint import pprint
>>> pprint(cfg)

{'AUGMENTOR': {'AFFINE_MODE': 'reflect',
               'AUG_NUM_SAMPLES': 10,
               'AUG_SAMPLES': True,
               'BRIGHTNESS': False,
               'BRIGHTNESS_EM': False,
               'BRIGHTNESS_EM_FACTOR': (0.1, 0.3),
               'BRIGHTNESS_EM_MODE': '3D',
               'BRIGHTNESS_FACTOR': (0.1, 0.3),
               'BRIGHTNESS_MODE': '3D',
               'CBLUR_DOWN_RANGE': (2, 8),
               'CBLUR_INSIDE': True,
               'CBLUR_SIZE': (0.2, 0.4),
               'CHANNEL_SHUFFLE': False,
               'CMIX_SIZE': (0.2, 0.4),
               'CNOISE_NB_ITERATIONS': (1, 3),
               'CNOISE_SCALE': (0.05, 0.1),
               'CNOISE_SIZE': (0.2, 0.4),
               'CONTRAST': False,
               'CONTRAST_EM': False,
               'CONTRAST_EM_FACTOR': (0.1, 0.3),
               'CONTRAST_EM_MODE': '3D',
               'CONTRAST_FACTOR': (-0.3, 0.3),
               'CONTRAST_MODE': '3D',
               'COUT_APPLY_TO_MASK': False,
               'COUT_CVAL': 0,
               'COUT_NB_ITERATIONS': (1, 3),
               'COUT_SIZE': (0.05, 0.3),
               'CUTBLUR': False,
               'CUTMIX': False,
               'CUTNOISE': False,
               'CUTOUT': False,
               'DA_PROB': 1.0,
               'DRAW_GRID': True,
               'DROPOUT': False,
               'DROP_RANGE': (0, 0.2),
               'ELASTIC': False,
               'ENABLE': True,
               'E_ALPHA': (12, 16),
               'E_MODE': 'constant',
               'E_SIGMA': 4,
               'GAMMA_CONTRAST': False,
               'GC_GAMMA': (0.5, 1.5),
               'GRAYSCALE': True,
               'GRIDMASK': False,
               'GRID_D_RANGE': (0.4, 1),
               'GRID_INVERT': False,
               'GRID_RATIO': 0.6,
               'GRID_ROTATE': 1,
               'G_BLUR': False,
               'G_SIGMA': (1.0, 2.0),
               'HFLIP': False,
               'MB_KERNEL': (3, 7),
               'MEDIAN_BLUR': False,
               'MISALIGNMENT': False,
               'MISSING_PARTS': False,
               'MISSP_ITERATIONS': (10, 30),
               'MOTB_K_RANGE': (8, 12),
               'MOTION_BLUR': False,
               'MS_DISPLACEMENT': 16,
               'MS_ROTATE_RATIO': 0.5,
               'RANDOM_CROP_SCALE': 1,
               'RANDOM_ROT': False,
               'RANDOM_ROT_RANGE': (-180, 180),
               'ROT90': False,
               'SHEAR': False,
               'SHEAR_RANGE': (-20, 20),
               'SHIFT': False,
               'SHIFT_RANGE': (0.1, 0.2),
               'SHUFFLE_TRAIN_DATA_EACH_EPOCH': True,
               'SHUFFLE_VAL_DATA_EACH_EPOCH': False,
               'VFLIP': False,
               'ZFLIP': False,
               'ZOOM': False,
               'ZOOM_RANGE': (0.8, 1.2)},
 'DATA': {'CHANNELS': 'B',
          'CHANNEL_WEIGHTS': (1, 0.2),
          'CHECK_GENERATORS': False,
          'CHECK_MW': True,
          'CONTOUR_MODE': 'thick',
          'EXTRACT_RANDOM_PATCH': False,
          'MW_OPTIMIZE_THS': False,
          'MW_TH1': 0.2,
          'MW_TH2': 0.1,
          'MW_TH3': 0.3,
          'MW_TH4': 1.2,
          'MW_TH5': 1.5,
          'PATCH_SIZE': (256, 256, 20, 3),
          'PROBABILITY_MAP': False,
          'REFLECT_TO_COMPLETE_SHAPE': True,
          'REMOVE_BEFORE_MW': True,
          'REMOVE_SMALL_OBJ': 30,
          'ROOT_DIR': './',
          'TEST': {'ARGMAX_TO_OUTPUT': False,
                   'BINARY_MASKS': './ChroMS/2021-03-24 P14 6520-2 Mcol '
                                   'cortex/test/x/../bin_mask',
                   'CHECK_DATA': True,
                   'INSTANCE_CHANNELS_DIR': './ChroMS/2021-03-24 P14 6520-2 '
                                            'Mcol cortex/test/x_B_thick',
                   'INSTANCE_CHANNELS_MASK_DIR': '_B_thick',
                   'IN_MEMORY': True,
                   'LOAD_GT': False,
                   'MASK_PATH': '',
                   'MEDIAN_PADDING': False,
                   'OVERLAP': (0, 0, 0),
                   'PADDING': (16, 16, 0),
                   'PATH': './ChroMS/2021-03-24 P14 6520-2 Mcol cortex/test/x',
                   'RESOLUTION': (-1,),
                   'USE_VAL_AS_TEST': False},
          'TRAIN': {'CHECK_CROP': False,
                    'CHECK_DATA': True,
                    'INSTANCE_CHANNELS_DIR': 'path_to_train_data_B_thick',
                    'INSTANCE_CHANNELS_MASK_DIR': 'path_to_train_data_gt_B_thick',
                    'IN_MEMORY': True,
                    'MASK_PATH': 'path_to_train_data_gt',
                    'OVERLAP': (0, 0, 0),
                    'PADDING': (0, 0, 0),
                    'PATH': 'path_to_train_data',
                    'REPLICATE': 0,
                    'RESOLUTION': (-1,)},
          'VAL': {'BINARY_MASKS': './val/x/../bin_mask',
                  'CROSS_VAL': False,
                  'CROSS_VAL_FOLD': 1,
                  'CROSS_VAL_NFOLD': 5,
                  'FROM_TRAIN': True,
                  'INSTANCE_CHANNELS_DIR': './val/x_B_thick',
                  'INSTANCE_CHANNELS_MASK_DIR': './val/y_B_thick',
                  'IN_MEMORY': True,
                  'MASK_PATH': './val/y',
                  'MEDIAN_PADDING': False,
                  'OVERLAP': (0, 0, 0),
                  'PADDING': (0, 0, 0),
                  'PATH': './val/x',
                  'RANDOM': True,
                  'RESOLUTION': (-1,),
                  'SPLIT_TRAIN': 0.1},
          'W_BACKGROUND': 0.06,
          'W_FOREGROUND': 0.94},
 'LOSS': CfgNode({'TYPE': 'CE'}),
 'MODEL': {'ACTIVATION': 'elu',
           'ARCHITECTURE': 'unet',
           'BATCH_NORMALIZATION': False,
           'DEPTH': 12,
           'DROPOUT_VALUES': [0.1, 0.2, 0.3],
           'EMBED_DIM': 768,
           'FEATURE_MAPS': [36, 48, 64],
           'KERNEL_INIT': 'he_normal',
           'LAST_ACTIVATION': 'sigmoid',
           'LOAD_CHECKPOINT': False,
           'MLP_HIDDEN_UNITS': [2048, 1024],
           'NUM_HEADS': 6,
           'N_CLASSES': 1,
           'OUT_DIM': 1,
           'SPATIAL_DROPOUT': False,
           'TOKEN_SIZE': 16,
           'Z_DOWN': 1},
 'PATHS': {'CHARTS': './results/1/charts',
           'CHECKPOINT': './h5_files',
           'CHECKPOINT_FILE': './brainbow_3d_detection/model_weights_unet_3d_detection_P14_big_1.h5',
           'CROP_CHECKS': './results/1/check_crop',
           'DA_SAMPLES': './results/1/aug',
           'GEN_CHECKS': './results/1/gen_check',
           'GEN_MASK_CHECKS': './results/1/gen_mask_check',
           'LOSS_WEIGHTS': './results/1/loss_weights',
           'MAP_CODE_DIR': '',
           'MAP_H5_DIR': './results/1/mAP_h5_files',
           'PROB_MAP_DIR': './prob_map',
           'PROB_MAP_FILENAME': 'prob_map.npy',
           'RESULT_DIR': {'DET_LOCAL_MAX_COORDS_CHECK': './results/1/per_image_local_max_check',
                          'FULL_IMAGE': './results/1/full_image',
                          'FULL_POST_PROCESSING': './results/1/full_post_processing',
                          'PATH': './results/1',
                          'PER_IMAGE': './results/1/per_image',
                          'PER_IMAGE_INSTANCES': './results/1/per_image_instances',
                          'PER_IMAGE_INST_VORONOI': './results/1/per_image_instances_voronoi',
                          'PER_IMAGE_POST_PROCESSING': './results/1/per_image_post_processing'},
           'TEST_FULL_GT_H5': 'h5',
           'TEST_INSTANCE_CHANNELS_CHECK': './results/1/test_instance_channels',
           'TRAIN_INSTANCE_CHANNELS_CHECK': './results/1/train_instance_channels',
           'VAL_INSTANCE_CHANNELS_CHECK': './results/1/val_instance_channels',
           'WATERSHED_DIR': './results/1/watershed'},
 'PROBLEM': CfgNode({'TYPE': 'DETECTION', 'NDIM': '3D'}),
 'SYSTEM': CfgNode({'NUM_GPUS': 1, 'NUM_CPUS': 1, 'SEED': 0}),
 'TEST': {'APPLY_MASK': False,
          'AUGMENTATION': False,
          'DET_LOCAL_MAX_COORDS': True,
          'DET_MIN_DISTANCE': [10],
          'DET_MIN_TH_TO_BE_PEAK': [0.1],
          'DET_TOLERANCE': [10],
          'DET_VOXEL_SIZE': (0.4, 0.4, 2),
          'ENABLE': True,
          'EVALUATE': True,
          'MAP': False,
          'MATCHING_SEGCOMPARE': False,
          'MATCHING_STATS': False,
          'MATCHING_STATS_THS': [0.3, 0.5, 0.75],
          'POST_PROCESSING': {'BLENDING': False,
                              'YZ_FILTERING': False,
                              'YZ_FILTERING_SIZE': 5,
                              'Z_FILTERING': False,
                              'Z_FILTERING_SIZE': 5},
          'REDUCE_MEMORY': False,
          'STATS': {'FULL_IMG': False,
                    'MERGE_PATCHES': True,
                    'PER_PATCH': True},
          'VERBOSE': True,
          'VORONOI_ON_MASK': False},
 'TRAIN': {'BATCH_SIZE': 1,
           'CHECKPOINT_MONITOR': 'val_loss',
           'EARLYSTOPPING_MONITOR': 'val_loss',
           'ENABLE': False,
           'EPOCHS': 500,
           'LR': 0.0001,
           'LR_SCHEDULER': CfgNode({'ENABLE': False, 'NAME': ''}),
           'OPTIMIZER': 'ADAM',
           'PATIENCE': 20}}

Error msg

Loading model weights from h5_file: ./brainbow_3d_detection/model_weights_unet_3d_detection_P14_big_1.h5

---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
Input In [16], in <cell line: 1>()
----> 1 engine.test()

File ~/workspace/BiaPy/engine/engine.py:208, in Engine.test(self)
    205 def test(self):
    207     print("Loading model weights from h5_file: {}".format(self.cfg.PATHS.CHECKPOINT_FILE))
--> 208     self.model.load_weights(self.cfg.PATHS.CHECKPOINT_FILE)
    210     image_counter = 0
    211     if self.cfg.TEST.POST_PROCESSING.BLENDING or self.cfg.TEST.POST_PROCESSING.YZ_FILTERING or \
    212        self.cfg.TEST.POST_PROCESSING.Z_FILTERING:

File ~/miniconda3/envs/EM_tools/lib/python3.8/site-packages/tensorflow/python/keras/engine/training.py:2234, in Model.load_weights(self, filepath, by_name, skip_mismatch, options)
   2231   hdf5_format.load_weights_from_hdf5_group_by_name(
   2232       f, self.layers, skip_mismatch=skip_mismatch)
   2233 else:
-> 2234   hdf5_format.load_weights_from_hdf5_group(f, self.layers)

File ~/miniconda3/envs/EM_tools/lib/python3.8/site-packages/tensorflow/python/keras/saving/hdf5_format.py:685, in load_weights_from_hdf5_group(f, layers)
    683 layer_names = filtered_layer_names
    684 if len(layer_names) != len(filtered_layers):
--> 685   raise ValueError('You are trying to load a weight file '
    686                    'containing ' + str(len(layer_names)) +
    687                    ' layers into a model with ' + str(len(filtered_layers)) +
    688                    ' layers.')
    690 # We batch weight value assignments in a single backend call
    691 # which provides a speedup in TensorFlow.
    692 weight_value_tuples = []

ValueError: You are trying to load a weight file containing 18 layers into a model with 13 layers.