在# # 将 4输入分开，构建新的相同模态结合的2输入，2分支
# import math
# import logging
# from functools import partial
# from collections import OrderedDict
# from copy import deepcopy

# import torch
# import torch.nn as nn
# import torch.nn.functional as F

# from timm.models.layers import to_2tuple

# from lib.models.layers.patch_embed import PatchEmbed, PatchEmbed_event, xcorr_depthwise
# from .utils import combine_tokens, recover_tokens
# from .vit import VisionTransformer
# from ..layers.attn_blocks import CEBlock
# from .new_counter_guide import Counter_Guide
# from .model import ST_Transformer_block
# _logger = logging.getLogger(__name__)
                            

# class VisionTransformerCE(VisionTransformer):
#     """ Vision Transformer with candidate elimination (CE) module

#     A PyTorch impl of : `An Image is Worth 16x16 Words: Transformers for Image Recognition at Scale`
#         - https://arxiv.org/abs/2010.11929

#     Includes distillation token & head support for `DeiT: Data-efficient Image Transformers`
#         - https://arxiv.org/abs/2012.12877
#     """
#     def __init__(self, img_size=224, patch_size=16, in_chans=3, num_classes=1000, embed_dim=768, depth=12,
#                  num_heads=12, mlp_ratio=4., qkv_bias=True, representation_size=None, distilled=False,
#                  drop_rate=0., attn_drop_rate=0., drop_path_rate=0., embed_layer=PatchEmbed, norm_layer=None,
#                  act_layer=None, weight_init='',
#                  ce_loc=None, ce_keep_ratio=None):
#         super().__init__()
#         if isinstance(img_size, tuple):
#             self.img_size = img_size
#         else:
#             self.img_size = to_2tuple(img_size)
#         self.patch_size = patch_size
#         self.in_chans = in_chans

#         self.num_classes = num_classes
#         self.num_features = self.embed_dim = embed_dim  # num_features for consistency with other models
#         self.num_tokens = 2 if distilled else 1
#         norm_layer = norm_layer or partial(nn.LayerNorm, eps=1e-6)
#         act_layer = act_layer or nn.GELU

#         self.patch_embed = embed_layer(
#             img_size=img_size, patch_size=patch_size, in_chans=in_chans, embed_dim=embed_dim)
#         num_patches = self.patch_embed.num_patches

#         self.cls_token = nn.Parameter(torch.zeros(1, 1, embed_dim))
#         self.dist_token = nn.Parameter(torch.zeros(1, 1, embed_dim)) if distilled else None
#         self.pos_embed = nn.Parameter(torch.zeros(1, num_patches + self.num_tokens, embed_dim))
#         self.pos_drop = nn.Dropout(p=drop_rate)
#         self.pos_embed_event = PatchEmbed_event(in_chans=32, embed_dim=768, kernel_size=4, stride=4)
#         dpr = [x.item() for x in torch.linspace(0, drop_path_rate, depth)]  # stochastic depth decay rule
#         blocks = []
#         ce_index = 0
#         self.ce_loc = ce_loc
#         for i in range(depth):
#             ce_keep_ratio_i = 1.0
#             if ce_loc is not None and i in ce_loc:
#                 ce_keep_ratio_i = ce_keep_ratio[ce_index]
#                 ce_index += 1

#             blocks.append(
#                 CEBlock(
#                     dim=embed_dim, num_heads=num_heads, mlp_ratio=mlp_ratio, qkv_bias=qkv_bias, drop=drop_rate,
#                     attn_drop=attn_drop_rate, drop_path=dpr[i], norm_layer=norm_layer, act_layer=act_layer,
#                     keep_ratio_search=ce_keep_ratio_i)
#             )

#         self.blocks = nn.Sequential(*blocks)
#         self.norm = norm_layer(embed_dim)

#         self.init_weights(weight_init)
    
#         # 添加交互模块counter_guide
#         self.counter_guide = Counter_Guide(768, 768)
#         self.st_transformer_blocks_event = nn.ModuleList([
#             ST_Transformer_block(dim=768, num_heads=8, mlp_ratio=4) for _ in range(depth)
#         ])
    
#     def forward_features(self, z, x, event_z, event_x,
#                          mask_z=None, mask_x=None,
#                          ce_template_mask=None, ce_keep_rate=None,
#                          return_last_attn=False
#                          ):
#         # 分支1 处理流程
#         B, H, W = x.shape[0], x.shape[2], x.shape[3]

#         x = self.patch_embed(x)
#         z = self.patch_embed(z)
#         z += self.pos_embed_z
#         x += self.pos_embed_x        

#         if mask_z is not None and mask_x is not None:
#             mask_z = F.interpolate(mask_z[None].float(), scale_factor=1. / self.patch_size).to(torch.bool)[0]
#             mask_z = mask_z.flatten(1).unsqueeze(-1)

#             mask_x = F.interpolate(mask_x[None].float(), scale_factor=1. / self.patch_size).to(torch.bool)[0]
#             mask_x = mask_x.flatten(1).unsqueeze(-1)

#             mask_x = combine_tokens(mask_z, mask_x, mode=self.cat_mode)
#             mask_x = mask_x.squeeze(-1)

#         if self.add_cls_token:
#             cls_tokens = self.cls_token.expand(B, -1, -1)
#             cls_tokens = cls_tokens + self.cls_pos_embed
#         if self.add_sep_seg:
#             x += self.search_segment_pos_embed
#             z += self.template_segment_pos_embed
#         x = combine_tokens(z, x, mode=self.cat_mode)
#         if self.add_cls_token:
#             x = torch.cat([cls_tokens, x], dim=1)
#         x = self.pos_drop(x)

#         lens_z = self.pos_embed_z.shape[1]
#         lens_x = self.pos_embed_x.shape[1]
#         global_index_t = torch.linspace(0, lens_z - 1, lens_z).to(x.device)
#         global_index_t = global_index_t.repeat(B, 1)
#         global_index_s = torch.linspace(0, lens_x - 1, lens_x).to(x.device)
#         global_index_s = global_index_s.repeat(B, 1)
#         removed_indexes_s = []
#         # # 分支2 处理流程
#         event_x = self.patch_embed(event_x)
#         event_z = self.patch_embed(event_z)
#         event_x += self.pos_embed_x
#         event_z += self.pos_embed_z

#         event_x = combine_tokens(event_z, event_x, mode=self.cat_mode)

#         if self.add_cls_token:
#             event_x = torch.cat([cls_tokens, event_x], dim=1)

#         lens_z = self.pos_embed_z.shape[1]
#         lens_x = self.pos_embed_x.shape[1]

#         global_index_t1 = torch.linspace(0, lens_z - 1, lens_z).to(event_x.device)
#         global_index_t1 = global_index_t1.repeat(B, 1)
#         global_index_s1 = torch.linspace(0, lens_x - 1, lens_x).to(event_x.device)
#         global_index_s1 = global_index_s1.repeat(B, 1)

#         removed_indexes_s1 = []

#         for i, blk in enumerate(self.blocks):
#             # 第一个分支处理
#             x, global_index_t, global_index_s, removed_index_s, attn = \
#                 blk(x, global_index_t, global_index_s, mask_x, ce_template_mask, ce_keep_rate)
#             # 第二个分支处理
#             # event_x, global_index_t1, global_index_s1, removed_index_s1, attn = \
#             #     blk(event_x, global_index_t1, global_index_s1, mask_x, ce_template_mask, ce_keep_rate)


#             if self.ce_loc is not None and i in self.ce_loc:
#                 removed_indexes_s.append(removed_index_s)
#                 # removed_indexes_s1.append(removed_index_s1)
#             # 仅仅在第1层应用Counter_guide
#             # if i == 0:
#             #     enhanced_x, enhanced_event_x = self.counter_guide(x, event_x)
#             #     # 将增强后的特征与原特征相加
#             #     x = x + enhanced_x
#             #     event_x = event_x + enhanced_event_x
#         # 应用LayerNorm归一化处理
#         for block in self.st_transformer_blocks_event:
#             event_x = block(event_x)
#             # event_z = block(event_z)

#         x = self.norm(x) 
#         event_x = self.norm(event_x)

#         # x_cat = torch.cat([x,event_x], dim=1)
#         x = event_x 
#         aux_dict = {
#             "attn": attn,
#             "removed_indexes_s": removed_indexes_s,  # used for visualization
#         }
        
#         return x, aux_dict 

#     def forward(self, z, x, event_z, event_x,
#                 ce_template_mask=None, ce_keep_rate=None,
#                 tnc_keep_rate=None,
#                 return_last_attn=False):

#         x, aux_dict = self.forward_features(z, x, event_z, event_x, ce_template_mask=ce_template_mask, ce_keep_rate=ce_keep_rate,)

#         return x, aux_dict


# def _create_vision_transformer(pretrained=False, **kwargs):
#     model = VisionTransformerCE(**kwargs)
    
#     if pretrained:
#         if 'npz' in pretrained:
#             model.load_pretrained(pretrained, prefix='')
#         else:
#             checkpoint = torch.load(pretrained, map_location="cpu")
#             missing_keys, unexpected_keys = model.load_state_dict(checkpoint["model"], strict=False)
#             print('Load pretrained model from: ' + pretrained)

#     return model


# def vit_base_patch16_224_ce(pretrained=False, **kwargs):
#     """ ViT-Base model (ViT-B/16) from original paper (https://arxiv.org/abs/2010.11929).
#     """
#     model_kwargs = dict(
#         patch_size=16, embed_dim=768, depth=12, num_heads=12, **kwargs)
#     model = _create_vision_transformer(pretrained=pretrained, **model_kwargs)
#     return model


# def vit_large_patch16_224_ce(pretrained=False, **kwargs):
#     """ ViT-Large model (ViT-L/16) from original paper (https://arxiv.org/abs/2010.11929).
#     """
#     model_kwargs = dict(
#         patch_size=16, embed_dim=1024, depth=24, num_heads=16, **kwargs)
#     model = _create_vision_transformer(pretrained=pretrained, **model_kwargs)
#     return model


# 将 4输入分开，构建新的相同模态结合的2输入，2分支
import math
import logging
from functools import partial
from collections import OrderedDict
from copy import deepcopy

import torch
import torch.nn as nn
import torch.nn.functional as F

from timm.models.layers import to_2tuple

from lib.models.layers.patch_embed import PatchEmbed, PatchEmbed_event, xcorr_depthwise
from .utils import combine_tokens, recover_tokens
from .vit import VisionTransformer
from ..layers.attn_blocks import CEBlock, CEBlock_new
# from .new_counter_guide import Counter_Guide
from .ad_counter_guide import Counter_Guide_Enhanced
_logger = logging.getLogger(__name__)
                            

class VisionTransformerCE(VisionTransformer):
    """ Vision Transformer with candidate elimination (CE) module

    A PyTorch impl of : `An Image is Worth 16x16 Words: Transformers for Image Recognition at Scale`
        - https://arxiv.org/abs/2010.11929

    Includes distillation token & head support for `DeiT: Data-efficient Image Transformers`
        - https://arxiv.org/abs/2012.12877
    """
    def __init__(self, img_size=224, patch_size=16, in_chans=3, num_classes=1000, embed_dim=768, depth=12,
                 num_heads=12, mlp_ratio=4., qkv_bias=True, representation_size=None, distilled=False,
                 drop_rate=0., attn_drop_rate=0., drop_path_rate=0., embed_layer=PatchEmbed, norm_layer=None,
                 act_layer=None, weight_init='',
                 ce_loc=None, ce_keep_ratio=None):
        super().__init__()
        if isinstance(img_size, tuple):
            self.img_size = img_size
        else:
            self.img_size = to_2tuple(img_size)
        self.patch_size = patch_size
        self.in_chans = in_chans

        self.num_classes = num_classes
        self.num_features = self.embed_dim = embed_dim  # num_features for consistency with other models
        self.num_tokens = 2 if distilled else 1
        norm_layer = norm_layer or partial(nn.LayerNorm, eps=1e-6)
        act_layer = act_layer or nn.GELU

        self.patch_embed = embed_layer(
            img_size=img_size, patch_size=patch_size, in_chans=in_chans, embed_dim=embed_dim)
        num_patches = self.patch_embed.num_patches

        self.cls_token = nn.Parameter(torch.zeros(1, 1, embed_dim))
        self.dist_token = nn.Parameter(torch.zeros(1, 1, embed_dim)) if distilled else None
        self.pos_embed = nn.Parameter(torch.zeros(1, num_patches + self.num_tokens, embed_dim))
        self.pos_drop = nn.Dropout(p=drop_rate)
        self.pos_embed_event = PatchEmbed_event(in_chans=32, embed_dim=768, kernel_size=4, stride=4)
        dpr = [x.item() for x in torch.linspace(0, drop_path_rate, depth)]  # stochastic depth decay rule
        blocks = []
        ce_index = 0
        self.ce_loc = ce_loc
        for i in range(depth):
            ce_keep_ratio_i = 1.0
            if ce_loc is not None and i in ce_loc:
                ce_keep_ratio_i = ce_keep_ratio[ce_index]
                ce_index += 1
            blocks.append(
                CEBlock(
                    dim=embed_dim, num_heads=num_heads, mlp_ratio=mlp_ratio, qkv_bias=qkv_bias, drop=drop_rate,
                    attn_drop=attn_drop_rate, drop_path=dpr[i], norm_layer=norm_layer, act_layer=act_layer,
                    keep_ratio_search=ce_keep_ratio_i)
            )
        self.blocks = nn.Sequential(*blocks)
        self.norm = norm_layer(embed_dim)

        self.init_weights(weight_init)
    
        # 添加交互模块counter_guide
        self.counter_guide = Counter_Guide_Enhanced(768, 768)
        # 新增随机掩码
    def masking_fea(self,z, event_z, x, event_x, ratio=0.8):
        b,nz,c = z.shape
        b,nez,c = event_z.shape
        b,nx,c = x.shape
        b,nex,c = event_x.shape

        assert(nz == nez)
        assert(nx == nex)
        lenz_out = int(nz*ratio)
        lenx_out = int(nx*ratio)

        mask_nz = torch.rand(b,nz).float()
        mask_ez = torch.rand(b,nez).float()
        mask_nx = torch.rand(b,nx).float()
        mask_ex = torch.rand(b,nex).float()
        mask_nz = mask_nz>0.4
        mask_ez = mask_ez>0.4
        mask_ez = ~mask_nz + mask_ez
        mask_nz_idx = mask_nz.float().sort(1,descending=True)[-1].to(device = z.device)
        mask_ez_idx = mask_ez.float().sort(1,descending=True)[-1].to(device = z.device)
        mask_nx = mask_nx>0.4
        mask_ex = mask_ex>0.4
        mask_ex = ~mask_nx + mask_ex
        mask_nx_idx = mask_nx.float().sort(1,descending=True)[-1].to(device = z.device)
        mask_ex_idx = mask_ex.float().sort(1,descending=True)[-1].to(device = z.device)

        masked_z = torch.gather(z, 1, mask_nz_idx[:,:lenz_out,None].repeat([1,1,c]))
        masked_ez = torch.gather(event_z, 1, mask_ez_idx[:,:lenz_out,None].repeat([1,1,c]))
        masked_x = torch.gather(x, 1, mask_nx_idx[:,:lenx_out,None].repeat([1,1,c]))
        masked_ex = torch.gather(event_x, 1, mask_ex_idx[:,:lenx_out,None].repeat([1,1,c]))
        return masked_z, masked_ez, masked_x, masked_ex,{'x1':mask_nx_idx[:,:lenx_out],'x0':mask_nx_idx[:,lenx_out:],
                                                        'ex1':mask_ex_idx[:,:lenx_out],'ex0':mask_ex_idx[:,lenx_out:], }
    def forward_features(self, z, x, event_z, event_x,
                         mask_z=None, mask_x=None,
                         ce_template_mask=None, ce_keep_rate=None,
                         return_last_attn=False, Track=False
                         ):
        # 分支1 处理流程
        B, H, W = x.shape[0], x.shape[2], x.shape[3]

        x = self.patch_embed(x)
        z = self.patch_embed(z)
        z += self.pos_embed_z
        x += self.pos_embed_x        

        event_x = self.pos_embed_event(event_x)  
        event_z = self.pos_embed_event(event_z) 
        event_x += self.pos_embed_x
        event_z += self.pos_embed_z

        if Track == False:
            masked_z, masked_event_z, masked_x, masked_event_x, token_idx = self.masking_fea(z, event_z, x, event_x, ratio=0.9)
        # 此处相当于仅仅对x进行掩码
        z = masked_z
        x = masked_x
        event_z = event_z
        event_x = event_x
        if mask_z is not None and mask_x is not None:
            mask_z = F.interpolate(mask_z[None].float(), scale_factor=1. / self.patch_size).to(torch.bool)[0]
            mask_z = mask_z.flatten(1).unsqueeze(-1)

            mask_x = F.interpolate(mask_x[None].float(), scale_factor=1. / self.patch_size).to(torch.bool)[0]
            mask_x = mask_x.flatten(1).unsqueeze(-1)

            mask_x = combine_tokens(mask_z, mask_x, mode=self.cat_mode)
            mask_x = mask_x.squeeze(-1)

        if self.add_cls_token:
            cls_tokens = self.cls_token.expand(B, -1, -1)
            cls_tokens = cls_tokens + self.cls_pos_embed
        if self.add_sep_seg:
            x += self.search_segment_pos_embed
            z += self.template_segment_pos_embed
        x = combine_tokens(z, x, mode=self.cat_mode)
        if self.add_cls_token:
            x = torch.cat([cls_tokens, x], dim=1)
        x = self.pos_drop(x)

        lens_z = self.pos_embed_z.shape[1]
        lens_x = self.pos_embed_x.shape[1]
        global_index_t = torch.linspace(0, lens_z - 1, lens_z).to(x.device)
        global_index_t = global_index_t.repeat(B, 1)
        global_index_s = torch.linspace(0, lens_x - 1, lens_x).to(x.device)
        global_index_s = global_index_s.repeat(B, 1)
        removed_indexes_s = []
        # # 分支2 处理流程
        # event_x = self.pos_embed_event(event_x)
        # event_z = self.pos_embed_event(event_z)
        # event_x += self.pos_embed_x
        # event_z += self.pos_embed_z

        event_x = combine_tokens(event_z, event_x, mode=self.cat_mode)

        if self.add_cls_token:
            event_x = torch.cat([cls_tokens, event_x], dim=1)

        lens_z = self.pos_embed_z.shape[1]
        lens_x = self.pos_embed_x.shape[1]

        global_index_t1 = torch.linspace(0, lens_z - 1, lens_z).to(event_x.device)
        global_index_t1 = global_index_t1.repeat(B, 1)
        global_index_s1 = torch.linspace(0, lens_x - 1, lens_x).to(event_x.device)
        global_index_s1 = global_index_s1.repeat(B, 1)

        removed_indexes_s1 = []

        for i, blk in enumerate(self.blocks):
            # 第一个分支处理
            x, global_index_t, global_index_s, removed_index_s, attn = \
                blk(x, global_index_t, global_index_s, mask_x, ce_template_mask, ce_keep_rate)
            # 第二个分支处理
            event_x, global_index_t1, global_index_s1, removed_index_s1, attn1 = \
                blk(event_x, global_index_t1, global_index_s1, mask_x, ce_template_mask, ce_keep_rate)


            if self.ce_loc is not None and i in self.ce_loc:
                removed_indexes_s.append(removed_index_s)
                removed_indexes_s1.append(removed_index_s1)

            # 在第1层增加counter_guide模块,验证早期融合效果
            if i == 0 :
                A_original_x = x.clone() # 保存原始x特征 （RGB）
                A_original_event_x = event_x.clone() # 保存原始event特征 （event）
                # 引入counter_guide进行特征增强
                enhanced_x, enhanced_event_x = self.counter_guide(x, event_x)
                # 保存经过counter_guide增强的特征
                A_enhanced_x = enhanced_x  # 保存增强后的特征
                A_enhanced_event_x = enhanced_event_x  # 保存增强后的特征
                # 将增强后的特征与原特征相加
                x = x + enhanced_x
                event_x = event_x + enhanced_event_x
        # 应用LayerNorm归一化处理
        x = self.norm(x) 
        event_x = self.norm(event_x)

        x_cat = torch.cat([event_x,x], dim=1)
        x = x_cat
        aux_dict = {
            "attn": attn,
            'attn1': attn1,
            "removed_indexes_s": removed_indexes_s,  # used for visualization
            'removed_indexes_s1': removed_indexes_s1,
            # 在aux_dict中返回原始特征和增强特征
            'A_original_x': A_original_x,
            'A_original_event_x': A_original_event_x,
            'A_enhanced_x': A_enhanced_x,
            'A_enhanced_event_x': A_enhanced_event_x,
        }
        return x, aux_dict 

    def forward(self, z, x, event_z, event_x,
                ce_template_mask=None, ce_keep_rate=None,
                tnc_keep_rate=None,
                return_last_attn=False, Track=False):

        x, aux_dict = self.forward_features(z, x, event_z, event_x, ce_template_mask=ce_template_mask, ce_keep_rate=ce_keep_rate,Track=Track)

        return x, aux_dict


def _create_vision_transformer(pretrained=False, **kwargs):
    model = VisionTransformerCE(**kwargs)
    
    if pretrained:
        if 'npz' in pretrained:
            model.load_pretrained(pretrained, prefix='')
        else:
            checkpoint = torch.load(pretrained, map_location="cpu")
            missing_keys, unexpected_keys = model.load_state_dict(checkpoint["model"], strict=False)
            print('Load pretrained model from: ' + pretrained)

    return model


def vit_base_patch16_224_ce(pretrained=False, **kwargs):
    """ ViT-Base model (ViT-B/16) from original paper (https://arxiv.org/abs/2010.11929).
    """
    model_kwargs = dict(
        patch_size=16, embed_dim=768, depth=12, num_heads=12, **kwargs)
    model = _create_vision_transformer(pretrained=pretrained, **model_kwargs)
    return model


def vit_large_patch16_224_ce(pretrained=False, **kwargs):
    """ ViT-Large model (ViT-L/16) from original paper (https://arxiv.org/abs/2010.11929).
    """
    model_kwargs = dict(
        patch_size=16, embed_dim=1024, depth=24, num_heads=16, **kwargs)
    model = _create_vision_transformer(pretrained=pretrained, **model_kwargs)
    return model中masking_fea中的0.4阈值改为1表示什么？