| import torch |
| from torch import nn |
| from timm.layers import trunc_normal_ |
| import logging |
| import math |
| from .jepa_vit import vit_predictor |
| from .jepa_vit_add import vit_predictor_conditioned |
| from .jepa import JEPA |
| from .jepa_add import * |
| from .finetune import FineTuner |
| from .models_vit import load_pretrained as load_pretrained_vit |
| from .unet_adapter_conv import UNetAdapter_4LayersConv, UNetAdapterConv |
|
|
| def mae_init_weights(model): |
| |
| if hasattr(model, 'patch_embed'): |
| w = model.patch_embed.proj.weight.data |
| torch.nn.init.xavier_uniform_(w.view([w.shape[0], -1])) |
|
|
| |
| if hasattr(model, 'cls_token'): |
| torch.nn.init.normal_(model.cls_token, std=.02) |
| if hasattr(model, 'mask_token'): |
| torch.nn.init.normal_(model.mask_token, std=.02) |
|
|
| def _init_weights(m): |
| if isinstance(m, nn.Linear): |
| |
| torch.nn.init.xavier_uniform_(m.weight) |
| if isinstance(m, nn.Linear) and m.bias is not None: |
| nn.init.constant_(m.bias, 0) |
| elif isinstance(m, nn.LayerNorm): |
| nn.init.constant_(m.bias, 0) |
| nn.init.constant_(m.weight, 1.0) |
|
|
| |
| model.apply(_init_weights) |
|
|
|
|
|
|
| def init_jepa_model(args, device, ssl_type): |
| encoder = jepa_vit.__dict__[args.model]( |
| img_size=args.input_size, |
| patch_size=args.patch_size, |
| drop_path_rate=args.drop_path, |
| ) |
| if args.drop_path > 0: |
| logging.info('Warning: JEPA with encoder drop path!') |
| if args.stop_grad_conv1: |
| logging.info('Stop Grad Conv1!!!') |
| encoder.patch_embed.proj.weight.requires_grad = False |
| encoder.patch_embed.proj.bias.requires_grad = False |
| if args.stop_grad_norm1: |
| logging.info('Stop Grad Norm1!!!') |
| encoder.blocks[0].norm1.weight.requires_grad = False |
| encoder.blocks[0].norm1.bias.requires_grad = False |
| args.extra = ('extra' in ssl_type) or ('dual' in ssl_type) |
| if args.extra: |
| logging.info('Model Extra Activated!!!!!') |
| common_args = dict( |
| num_patches=encoder.patch_embed.num_patches, |
| embed_dim=encoder.embed_dim, |
| predictor_embed_dim=args.pred_emb_dim, |
| depth=args.pred_depth, |
| num_heads=encoder.num_heads, |
| ) |
| if 'iwm' in ssl_type: |
| predictor = vit_predictor_conditioned(policy_dim=args.policy_dim if not args.iwm_disable else 0,policy_net_layers=3,**common_args, extra=args.extra, ssl_type=ssl_type, unify_embed=args.unify_embed, cond_type=args.cond_type) |
| else: |
| predictor = vit_predictor(extra=args.extra, ssl_type=ssl_type,**common_args) |
| logging.info(f'Predictor: {predictor}') |
| def init_weights(m): |
| if isinstance(m, torch.nn.Linear): |
| trunc_normal_(m.weight, std=0.02) |
| if m.bias is not None: |
| torch.nn.init.constant_(m.bias, 0) |
| elif isinstance(m, torch.nn.LayerNorm): |
| torch.nn.init.constant_(m.bias, 0) |
| torch.nn.init.constant_(m.weight, 1.0) |
|
|
| if args.mae_init_weights: |
| mae_init_weights(encoder) |
| mae_init_weights(predictor) |
| logging.info('Use MAE Init') |
| else: |
| for m in encoder.modules(): |
| init_weights(m) |
| for m in predictor.modules(): |
| init_weights(m) |
| logging.info('Use JEPA Init') |
|
|
| logging.info(f'Mask Type: {args.mask_type}') |
| |
| |
| |
| list_mask = ('list' in args.mask_type) |
| if list_mask: |
| logging.info('Use List Style Mask!!') |
| model_cls = { |
| 'iwm': IWM, |
| 'jepa': JEPA, |
| 'iwm_dual': IWM_Dual, |
| 'iwm_dual_easy': IWM_Dual, |
| }[ssl_type] |
| logging.info(f'SSL Model Type: {ssl_type}') |
| if ssl_type == 'iwm' and args.iwm_disable: |
| logging.info(f'IWM Disable Condition!!!') |
| model = model_cls( |
| encoder, predictor, |
| list_mask=list_mask |
| ) |
| if args.pretrained: |
| logging.info(f'Use dBOT-style teacher from {args.pretrained}') |
| sd = torch.load(args.pretrained, map_location='cpu')['model'] |
| encoder_sd = {k.replace('target_encoder.', ''): v for k, v in sd.items() if k.startswith('target_encoder.')} |
| model.target_encoder.load_state_dict(encoder_sd) |
| model.to(device) |
| return model |
|
|
|
|
| def build_transfer_model(args, seg=False): |
| if args.with_cls_token: |
| encoder = models_vit.__dict__[args.model]( |
| num_classes=0, |
| drop_path_rate=args.drop_path, |
| drop_rate=args.drop, |
| global_pool=args.global_pool, |
| img_size=args.input_size, |
| |
| ) |
| if args.pretrained: |
| load_pretrained_vit(args.pretrained, encoder) |
| else: |
| encoder = jepa_vit.__dict__[args.model]( |
| img_size=args.input_size, |
| patch_size=args.patch_size, |
| drop_path_rate=args.drop_path, |
| drop_path_uniform=args.drop_path_uniform |
| ) |
| if args.pretrained: |
| ckpt = torch.load(args.pretrained, map_location='cpu') |
| sd = ckpt['model'] |
| if args.use_target: |
| logging.info('Use Teacher') |
| encoder_sd = {k.replace('target_encoder.', ''): v for k, v in sd.items() if k.startswith('target_encoder.')} |
| else: |
| logging.info('Use Student') |
| encoder_sd = {k.replace('encoder.', ''): v for k, v in sd.items() if k.startswith('encoder.')} |
| if args.input_size // args.patch_size != 14: |
| pos_embed = encoder_sd['pos_embed'] |
| N, D = pos_embed.shape[1], pos_embed.shape[-1] |
| pos_embed = nn.functional.interpolate( |
| pos_embed.reshape(1, int(math.sqrt(N)), int(math.sqrt(N)), D).permute(0, 3, 1, 2), |
| scale_factor=math.sqrt((args.input_size // args.patch_size) ** 2 / N), |
| mode='bicubic', align_corners=False |
| ) |
| pos_embed = pos_embed.permute(0, 2, 3, 1).view(1, -1, D) |
| encoder_sd['pos_embed'] = pos_embed |
| if args.patch_size != 16: |
| |
| patch_embed = encoder_sd['patch_embed.proj.weight'] |
| patch_embed = torch.nn.functional.interpolate(patch_embed.float(), size=(args.patch_size, args.patch_size), mode='bicubic', align_corners=False) |
| encoder_sd['patch_embed.proj.weight'] = patch_embed |
| msg = encoder.load_state_dict(encoder_sd, strict=False) |
| print('Missing:', msg.missing_keys) |
| if seg: |
| if args.patch_size == 8: |
| model = UNetAdapter_4LayersConv(feature_model=encoder, num_classes=args.num_classes, base_channels=args.unet_base_channels) |
| else: |
| model = UNetAdapterConv(feature_model=encoder, num_classes=args.num_classes, base_channels=args.unet_base_channels) |
| logging.info(f'Out indices: {args.seg_out_indices}') |
| logging.info(f'Seg Model: {type(model)}') |
| else: |
| feature_dim = jepa_vit.VIT_EMBED_DIMS.get(args.model, 768) |
| model = FineTuner(encoder, feature_dim=feature_dim, num_classes=args.num_classes, tune_type=args.tune_type, with_cls_token=args.with_cls_token) |
| return model |
|
|
|
|
