Upload 253 files

.gitattributes

@@ -58,3 +58,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 # Video files - compressed
 *.mp4 filter=lfs diff=lfs merge=lfs -text
 *.webm filter=lfs diff=lfs merge=lfs -text
+FAITH/pytorch_wavelets/tests/cplx.mat filter=lfs diff=lfs merge=lfs -text

FAITH/BatchSampler.py

@@ -0,0 +1,261 @@
+from collections import defaultdict
+import pdb
+import random
+import numpy as np
+import itertools
+import torch
+from torch.utils.data import Sampler
+
+from datasets.dataset import SeqDeepFakeDataset
+from models.configuration import Config
+
+# class BalancedBatchSampler(Sampler):
+#     def __init__(self, dataset, batch_size):
+#         self.n_classes = 5
+#         self.batch_size = batch_size
+#         self.n_samples_per_class = self.batch_size // self.n_classes
+
+#         # 获取每个类别的样本索引
+#         self.class_indices = [[] for _ in range(self.n_classes)]
+
+#         for idx, (_, _, _, _, length) in enumerate(dataset):
+#             self.class_indices[length].append(idx)
+
+#         self.class_indices = [np.array(indices) for indices in self.class_indices]
+
+#         # 计算最大类别样本数确定epoch长度
+#         self.class_counts = [len(indices) for indices in self.class_indices]
+#         self.max_class_count = max(self.class_counts)
+#         self.num_batches = self.max_class_count // self.n_samples_per_class
+
+#         print(f"self.class_counts: {self.class_counts}")
+#         # print(self.max_class_count)
+#         print(f"self.num_batches: {self.num_batches}")
+
+#     def __iter__(self):
+#         # 每个epoch开始时打乱各类别样本顺序
+#         shuffled_indices = [indices.copy() for indices in self.class_indices]
+#         for arr in shuffled_indices:
+#             np.random.shuffle(arr)
+
+#         # 创建无限循环迭代器
+#         iterators = [itertools.cycle(arr) for arr in shuffled_indices]
+
+#         # 生成平衡批次
+#         for _ in range(self.num_batches):
+#             batch = []
+#             for class_idx in range(self.n_classes):
+#                 batch.extend(
+#                     [next(iterators[class_idx]) for _ in range(self.n_samples_per_class)]
+#                 )
+#             np.random.shuffle(batch)  # 打乱批次内顺序
+#             yield batch
+
+#     def __len__(self):
+#         return self.num_batches
+
+
+# Deprecated
+class EfficientBalancedBatchSampler(Sampler):
+    def __init__(self, dataset, batch_size, samples_per_class=None):
+        """
+        :param dataset: 包含targets属性的数据集
+        :param batch_size: 总批量大小，需能被类别数整除
+        :param samples_per_class: 每个类别的样本数, 自动计算如果为None
+        """
+        # self.labels = np.asarray(dataset.targets)
+        self.batch_size = batch_size
+        
+        # 按类别组织索引
+        self.class_indices = defaultdict(list)
+        # for idx, label in enumerate(self.labels):
+        #     self.class_indices[label].append(idx)
+        
+        for idx, (_, _, _, _, length) in enumerate(dataset):
+            self.class_indices[length].append(idx)
+
+        self.classes = list(self.class_indices.keys())
+        self.num_classes = len(self.classes)
+        
+        # 自动计算每个类别的样本数
+        if samples_per_class is None:
+            assert batch_size % self.num_classes == 0, "batch_size必须能被类别数整除"
+            self.samples_per_class = batch_size // self.num_classes
+        else:
+            self.samples_per_class = samples_per_class
+            assert batch_size == self.samples_per_class * self.num_classes
+        
+        # 预计算每个类别的循环次数
+        self.class_repeats = self._calculate_repeats()
+        
+        # 生成全局采样计划
+        self.sampling_plan = self._generate_sampling_plan()
+
+    def _calculate_repeats(self):
+        """计算每个类别需要的重复次数"""
+        repeats = {}
+        max_batches = 0
+        for cls in self.classes:
+            n_samples = len(self.class_indices[cls])
+            n_batches = (n_samples + self.samples_per_class - 1) // self.samples_per_class
+            max_batches = max(max_batches, n_batches)
+        
+        for cls in self.classes:
+            n_samples = len(self.class_indices[cls])
+            total_needed = max_batches * self.samples_per_class
+            repeats[cls] = (total_needed + n_samples - 1) // n_samples
+        return repeats
+
+    def _generate_sampling_plan(self):
+        """生成全局采样索引矩阵"""
+        # 预分配内存
+        sampling_matrix = np.zeros((self.num_classes, 
+                                  max(self.class_repeats.values()) * self.samples_per_class),
+                                  dtype=np.int64)
+        
+        for i, cls in enumerate(self.classes):
+            indices = np.array(self.class_indices[cls])
+            np.random.shuffle(indices)  # 初始打乱
+            
+            # 生成重复索引块
+            repeated = np.tile(indices, self.class_repeats[cls])
+            np.random.shuffle(repeated)  # 再次打乱保证随机性
+            
+            # 截取所需长度
+            required_length = max(self.class_repeats.values()) * self.samples_per_class
+            sampling_matrix[i] = repeated[:required_length]
+        
+        return sampling_matrix.reshape(self.num_classes, -1, self.samples_per_class)
+
+    def __iter__(self):
+        # 转置维度：类别 × 总批次 → 总批次 × 类别
+        batch_plan = self.sampling_plan.transpose(1, 0, 2)
+        
+        # 打乱批次顺序
+        np.random.shuffle(batch_plan)
+        
+        # 生成最终批次
+        for batch in batch_plan:
+            # 合并所有类别的样本并打乱顺序
+            combined = batch.flatten()
+            np.random.shuffle(combined)
+            yield combined.tolist()
+
+    def __len__(self):
+        return self.sampling_plan.shape[1]
+
+
+'''
+Uneven sample distribution will affect the performance of the model. 
+For example, the model has higher accuracy for shorter samples.
+A uniform sampler ensures that the samples in each batch are evenly distributed.
+e.g. sequence length 0:1:2:3:4 = 1:1:1:1:1
+'''
+class BalancedBatchSampler(Sampler):
+    def __init__(self, A_indices, B_indices, C_indices, D_indices, E_indices, batch_size, epoch_length, rank = 0, world_size = 1):
+        """
+        A_indices: 类别A的样本索引列表
+        B_indices: 类别B的样本索引列表
+        C_indices: 类别C的样本索引列表
+        D_indices: 类别D的样本索引列表
+        E_indices: 类别E的样本索引列表
+        batch_size: 每个批次的大小, 必须能被5整除
+        epoch_length: 每个epoch的批次数量
+        """
+        super().__init__(None)
+        self.A = A_indices[rank::world_size]
+        self.B = B_indices[rank::world_size]
+        self.C = C_indices[rank::world_size]
+        self.D = D_indices[rank::world_size]
+        self.E = E_indices[rank::world_size]
+
+        random.shuffle(self.A)
+        random.shuffle(self.B)
+        random.shuffle(self.C)
+        random.shuffle(self.D)
+        random.shuffle(self.E)
+
+        self.batch_size = batch_size
+        self.n = batch_size // 5
+        self.epoch_length = epoch_length
+        self.epoch = 0
+        self.rank = rank
+        self.world_size = world_size
+        
+        assert batch_size % 5 == 0, "batch_size必须能被5整除"
+    
+    def set_epoch(self, epoch):
+        self.epoch = epoch
+        random.seed(epoch + self.rank)
+        torch.manual_seed(epoch + self.rank)
+
+    def __iter__(self):
+        # random.seed(self.epoch)
+
+        # 生成指定数量的平衡批次
+        for i in range(self.epoch_length):
+            # 从每个类别中随机选择n个样本（不允许重复）
+            # batch_A = random.choices(self.A, k=self.n)
+            # batch_B = random.choices(self.B, k=self.n)
+            # batch_C = random.choices(self.C, k=self.n)
+            # batch_D = random.choices(self.D, k=self.n)
+            # batch_E = random.choices(self.E, k=self.n)
+        
+            batch_A = self.A[self.n * i : self.n * (i + 1)]
+            batch_B = self.B[self.n * i : self.n * (i + 1)]
+            batch_C = self.C[self.n * i : self.n * (i + 1)]
+            batch_D = self.D[self.n * i : self.n * (i + 1)]
+            batch_E = self.E[self.n * i : self.n * (i + 1)]
+            
+            # 合并并打乱顺序
+            combined = batch_A + batch_B + batch_C + batch_D + batch_E
+            random.shuffle(combined)
+
+            yield combined
+
+    def __len__(self):
+        return self.epoch_length
+
+
+# cfg = Config('./configs/r50.json')
+
+# dataset = SeqDeepFakeDataset(
+#     cfg=cfg,
+#     mode="train",
+#     data_root='data',
+#     dataset_name='SD3'
+# )
+
+# # sampler = BalancedBatchSampler(
+# #     dataset,
+# #     40
+# # )
+
+# # sampler = EfficientBalancedBatchSampler(
+# #     dataset,
+# #     40,
+# #     8
+# # )
+
+# sampler = BalancedBatchSampler(
+#     list(range(0, 16036)),
+#     list(range(16036, 37897)),
+#     list(range(37897, 57159)),
+#     list(range(57159, 73044)),
+#     list(range(73044, 80000)),
+#     40,
+#     2000
+# )
+
+# dataloader = torch.utils.data.DataLoader(
+#     dataset,
+#     batch_sampler= sampler,
+#     pin_memory=True,
+#     # num_workers=8
+# )
+
+# print(len(dataloader))
+
+# for steps, (_, _, caps, _, length) in enumerate(dataloader):     # masks.shape: [bs, 512, 512]
+#     print(caps)
+#     pdb.set_trace()

FAITH/README.md

@@ -0,0 +1,205 @@
+<!-- <div align="center">
+
+<h1>SeqDeepFake: Detecting and Recovering Sequential DeepFake Manipulation</h1>
+
+<div>
+    <a href='https://rshaojimmy.github.io/' target='_blank'>Rui Shao</a>,
+    <a href='https://tianxingwu.github.io/' arget='_blank'>Tianxing Wu</a>,
+    <a href='https://liuziwei7.github.io/' target='_blank'>Ziwei Liu</a>
+</div>
+<div>
+    S-Lab, Nanyang Technological University&emsp;
+</div>
+
+<h4 align="center">
+  <a href="https://rshaojimmy.github.io/Projects/SeqDeepFake" target='_blank'>[Project Page]</a> |
+  <a href="https://arxiv.org/pdf/2207.02204.pdf" target='_blank'>[Paper]</a> |
+  <a href="https://arxiv.org/pdf/2309.14991.pdf" target='_blank'>[Extension Paper]</a> |
+  <a href="https://huggingface.co/datasets/rshaojimmy/Seq-DeepFake/tree/main" target='_blank'>[Dataset]</a>
+</h4>
+
+<img src='./figs/SeqDeepFake.gif' width='90%'>
+
+</div>
+
+## Updates
+- [02/2024] Dataset link has been updated with hugginface.
+- [09/2023] Arxiv extension paper released.
+- [07/2022] Pretrained models are uploaded.
+- [07/2022] Project page and dataset are released.
+- [07/2022] Code is released.
+
+## Introduction
+This is the official implementation of *Detecting and Recovering Sequential DeepFake Manipulation*. We introduce a novel research problem: Detecting Sequential DeepFake Manipulation (**Seq-DeepFake**), which focus on detecting the sequences of multi-step facial manipulations. To faciliatate the study of Seq-Deepfake, we provide a large-scale Sequential Deepfake Dataset, and propose a concise yet effective Seq-DeepFake Transformer (**SeqFakeFormer**).
+
+The framework of the proposed method:
+
+<div align="center">
+<img src='./figs/SeqFakeFormer.png' width='100%'>
+</div>
+
+
+
+
+## Installation
+
+### Download
+```
+git clone https://github.com/rshao/SeqDeepFake.git
+cd SeqDeepFake
+```
+
+
+### Environment
+We recommend using Anaconda to manage the python environment:
+```
+conda create -n seqdeepfake python=3.6
+conda activate seqdeepfake
+conda install -c pytorch pytorch=1.6.0 torchvision=0.7.0 cudatoolkit==10.1.243
+conda install pandas
+conda install tqdm
+conda install pillow
+pip install tensorboard==2.4.1
+```
+
+
+## Dataset Preparation
+
+### A brief introduction
+We contribute the first large-scale Sequential DeepFake Dataset, **Seq-Deepfake**, including **~85k** sequentially manipulated face images, each annotated with its ground-truth manipulation sequence.
+
+The images are generated based on the following two different facial manipulation methods, with **28** / **26** types of manipulation sequences (including original), repectively. The lengths of all manipulation sequences range from 1~5. 
+
+- Sequential facial components manipulation (based on [CelebAMask-HQ](http://mmlab.ie.cuhk.edu.hk/projects/CelebA/CelebAMask_HQ.html) and [StyleMapGAN](https://arxiv.org/abs/2104.14754))
+- Sequential facial attributes manipulation (based on [FFHQ](https://github.com/NVlabs/ffhq-dataset) and [Talk-To-Edit](https://arxiv.org/abs/2109.04425))
+
+Here are some sample images and statistics:
+<div align="center">
+<img src='./figs/dataset.png' width='90%'>
+</div>
+
+### Annotations
+Each image in the dataset is annotated with a list of length 5, indicating the ground-truth manipulation sequence. The labels in the sequence are defined as follows:
+
+For Sequential facial components manipulation:
+
+```
+0: 'NA', 1: 'nose', 2: 'eye', 3: 'eyebrow', 4: 'lip', 5: 'hair'
+
+Note: 'NA' means no manipulation is taken in this step.
+```
+
+For Sequential facial attributes manipulation:
+```
+0: 'NA', 1: 'Bangs', 2: 'Eyeglasses', 3: 'Beard', 4: 'Smiling', 5: 'Young'
+
+Note: 'NA' means no manipulation is taken in this step.
+```
+Note that label `0` serves as the placeholder for sequential manipulations shorter than 5 steps. For example, the annotation for manipulation sequence `nose-eye-lip` would be: `[1, 2, 4, 0, 0]`. Original images are annotated with `[0, 0, 0, 0, 0]`.
+
+
+### Prepare data
+You can download the Seq-Deepfake dataset through this link: <a href="https://lifehkbueduhk-my.sharepoint.com/:f:/g/personal/16483782_life_hkbu_edu_hk/Evp-uhtWYMBLi9G9JlPcKCEBewkMqPCU69L4Kf29qDQaOw?e=G9JaRm" target='_blank'>[Dataset]</a>
+
+After unzip all sub files, the structure of the dataset should be as follows:
+
+```
+./
+├── facial_attributes
+│   ├── annotations
+│   |   ├── train.csv
+│   |   ├── test.csv
+│   |   └── val.csv
+│   └── images
+│       ├── train
+│       │   ├── Bangs-Eyeglasses-Smiling-Young
+│       │   |   ├── xxxxxx.jpg
+|       |   |   ...
+|       |   |   └── xxxxxx.jpg
+|       |   ...
+│       │   ├── Young-Smiling-Eyeglasses
+│       │   |   ├── xxxxxx.jpg
+|       |   |   ...
+|       |   |   └── xxxxxx.jpg
+│       │   └── original
+│       │       ├── xxxxxx.jpg
+|       |       ...
+|       |       └── xxxxxx.jpg
+│       ├── test
+│       │   % the same structure as in train
+│       └── val
+│           % the same structure as in train
+└── facial_components
+    ├── annotations
+    |   ├── train.csv
+    |   ├── test.csv
+    |   └── val.csv
+    └── images
+        ├── train
+        │   ├── eyebrow-eye-hair-nose-lip
+        │   |   ├── xxxxxx.jpg
+        |   |   ...
+        |   |   └── xxxxxx.jpg
+        |   ...
+        │   ├── nose-eyebrow-lip-eye-hair
+        │   |   ├── xxxxxx.jpg
+        |   |   ...
+        |   |   └── xxxxxx.jpg
+        │   └── original
+        │       ├── xxxxxx.jpg
+        |       ...
+        |       └── xxxxxx.jpg
+        ├── test
+        │   % the same structure as in train
+        └── val
+            % the same structure as in train
+```
+
+
+## Training
+
+### Single-GPU
+
+Modify `train.sh` and run:
+```
+sh train.sh
+```
+
+Please refer to the following instructions about some arguments:
+
+| Args | Description
+| :-------- | :--------
+| CONFIG | Path of the network and optimization configuration file.
+| DATA_DIR | Directory to the downloaded dataset.
+| DATASET_NAME | Name of the selected manipulation type. Choose from 'facial_components' and 'facial_attributes'.
+| RESULTS_DIR | Directory to save logs and checkpoints.
+
+
+You can change the network and optimization configurations by adding new configuration files under the directory `./configs/`.
+
+
+### Multiple-GPUs (Slurm)
+
+We also provide slurm script that supports multiple GPUs training:
+```
+sh train_slurm.sh
+```
+where `PARTITION` and `NODE` should be modified according to your own environment. The number of GPUs to be used can be set through the `NUM_GPU` argument.
+
+## Testing
+Modify `test.sh` and run:
+```
+sh test.sh
+```
+
+For the arguments in `test.sh`, please refer to the training instructions above, plus the following ones:
+| Args | Description
+| :--- | :----------
+| TEST_TYPE | The evaluation metrics to use. Choose from 'fixed' and 'adaptive'.
+| LOG_NAME | Should be set according to the log_name of your trained checkpoint to be tested.
+
+We also provide slurm script for testing:
+
+```
+sh test_slurm.sh
+```

FAITH/configs/r34.json

@@ -0,0 +1,39 @@
+{
+    "backbone":{
+        "network": "resnet34",
+        "position_embedding": "sine",
+        "Frozen_BatchNorm2d": false
+    },
+    "optimizer":{
+        "batch_size": 32,
+        "lr_backbone": 1e-4,
+        "lr": 1e-3,
+        "epochs": 170,
+        "warmup": true,
+        "warmup_epochs": 20,
+        "lr_milestones": [70,120],
+        "start_epoch": 0,
+        "weight_decay": 1e-4,
+        "clip_max_norm": 0.1
+    },
+    "transformer":{
+        "SOS_token_id": 0,
+        "EOS_token_id": 6,
+        "PAD_token_id": 7,
+        "smooth": 4,
+        "dynamic_scale": "type3",
+        "max_position_embeddings": 6,
+        "vocab_size": 8,
+        "layer_norm_eps": 1e-12,
+        "dropout": 0.1,
+        "hidden_dim": 256,
+        "enc_layers": 2,
+        "dec_layers": 2,
+        "dim_feedforward": 512,
+        "nheads": 4,
+        "pre_norm": true
+    },
+    "dataset":{
+        "imgsize": 256
+    }
+}

FAITH/configs/r50.json

@@ -0,0 +1,39 @@
+{
+    "backbone":{
+        "network": "resnet50",
+        "position_embedding": "sine",
+        "Frozen_BatchNorm2d": false
+    },
+    "optimizer":{
+        "batch_size": 48,
+        "lr_backbone": 1e-4,
+        "lr": 1e-3,
+        "epochs": 150,
+        "warmup": true,
+        "warmup_epochs": 25,
+        "lr_milestones": [50,75,100],
+        "start_epoch": 0,
+        "weight_decay": 1e-4,
+        "clip_max_norm": 0.1
+    },
+    "transformer":{
+        "SOS_token_id": 0,
+        "EOS_token_id": 7,
+        "PAD_token_id": 8,
+        "smooth": 4,
+        "dynamic_scale": "type3",
+        "max_position_embeddings": 5,
+        "vocab_size": 9,
+        "layer_norm_eps": 1e-12,
+        "dropout": 0.1,
+        "hidden_dim": 512,
+        "enc_layers": 2,
+        "dec_layers": 2,
+        "dim_feedforward": 512,
+        "nheads": 4,
+        "pre_norm": true
+    },
+    "dataset":{
+        "imgsize": 512
+    }
+}

FAITH/datasets/add_noise.py

@@ -0,0 +1,92 @@
+# import cv2
+# import numpy as np
+
+# def add_salt_pepper_noise(image, prob):
+#     """
+#     为图像添加椒盐噪声
+#     :param image: 输入图像（彩色或灰度）
+#     :param prob: 噪声比例（总像素点的比例）
+#     :return: 带噪声的图像
+#     """
+#     output = image.copy()
+#     # 获取图像维度
+#     if len(image.shape) == 3:
+#         row, col, ch = image.shape
+#     else:
+#         row, col = image.shape
+#         ch = 1
+    
+#     # 生成随机矩阵
+#     rnd = np.random.rand(row, col)
+#     # 盐噪声（白色）
+#     salt = rnd < prob / 2
+#     # 椒噪声（黑色）
+#     pepper = (rnd >= prob / 2) & (rnd < prob)
+    
+#     # 应用噪声
+#     if ch == 1:
+#         output[salt] = 255
+#         output[pepper] = 0
+#     else:
+#         for c in range(ch):
+#             output[:, :, c][salt] = 255
+#             output[:, :, c][pepper] = 0
+#     return output
+
+
+
+# if __name__ == "__main__":
+#     # 设置随机种子以确保结果可重复
+#     np.random.seed(42)
+
+#     # 读取图像
+#     image = cv2.imread('../../../ultraedit/UltraEdit/sequential_deepfake_dataset/0/50.jpg')
+
+#     # 添加不同强度的噪声
+#     noisy_small = add_salt_pepper_noise(image, 0.05)  # 少量噪声（5%）
+#     noisy_medium = add_salt_pepper_noise(image, 0.1)  # 中等噪声（10%）
+#     noisy_large = add_salt_pepper_noise(image, 0.2)   # 大量噪声（20%）
+
+#     # 保存结果
+#     cv2.imwrite('noisy_small_sp.jpg', noisy_small)
+#     cv2.imwrite('noisy_medium_sp.jpg', noisy_medium)
+#     cv2.imwrite('noisy_large_sp.jpg', noisy_large)
+
+from PIL import Image
+import numpy as np
+
+def add_gaussian_noise(image_path: str, sigma: float) -> Image.Image:
+    """
+    为图像添加高斯噪声 (PIL实现版)
+    :param image_path: 输入图像路径
+    :param sigma: 噪声的标准差，控制噪声强度
+    :return: 带噪声的PIL.Image对象
+    """
+    # 打开图像并转换为numpy数组
+    img = Image.open(image_path)
+    img_array = np.array(img)
+    
+    # 生成高斯噪声 (与图像形状相同)
+    noise = np.random.normal(0, sigma, img_array.shape).astype(np.int32)
+    
+    # 添加噪声并截断到有效范围
+    noisy_array = np.clip(img_array.astype(np.int32) + noise, 0, 255).astype(np.uint8)
+    
+    # 将numpy数组转换回Image对象
+    return Image.fromarray(noisy_array)
+
+
+if __name__ == "__main__":
+    image_path = "../../../ultraedit/UltraEdit/sequential_deepfake_dataset/0/50.jpg"  # 输入图像路径
+    # 使用示例
+    # noisy_small = add_gaussian_noise(image_path, sigma=20)  # 少量噪声
+    # noisy_medium = add_gaussian_noise(image_path, sigma=30)  # 中等噪声
+    noisy_large = add_gaussian_noise(image_path, sigma=40)  # 大量噪声
+
+    print(type(noisy_large))
+    print(noisy_large.size)
+
+    # # 保存结果
+    # noisy_small.save("noisy_small.jpg")
+    # noisy_medium.save("noisy_medium.jpg")
+    # noisy_large.save("noisy_large.jpg")

FAITH/datasets/compress.py

@@ -0,0 +1,104 @@
+import os
+from PIL import Image
+from io import BytesIO
+# from torchvision import transforms
+
+
+def compress_image(input_path, target_ratio, output_path=""):
+    """
+    压缩图像到指定的压缩率
+    :param input_path: 输入图像路径
+    :param output_path: 输出图像路径
+    :param target_ratio: 目标压缩率（例如0.25表示25%）
+    """
+    # 获取原始文件大小
+    original_size = os.path.getsize(input_path)
+    target_size = original_size * target_ratio
+
+    # 打开图像并转换为RGB模式（避免透明通道问题）
+    img = Image.open(input_path)
+    if img.mode in ('RGBA', 'LA', 'P'):
+        img = img.convert('RGB')
+
+    # 寻找最佳质量参数
+    best_quality = find_optimal_quality(img, target_size)
+
+    # 将压缩结果保存到内存缓冲区
+    buffer = BytesIO()
+    img.save(buffer, format='JPEG', quality=best_quality, optimize=True)
+    # compressed_size = buffer.tell()  # 获取当前缓冲区大小
+    
+    # 从缓冲区创建新的Image对象
+    buffer.seek(0)  # 重置指针位置
+    compressed_img = Image.open(buffer)
+
+    # # 保存压缩后的图像
+    # img.save(output_path, format='JPEG', quality=best_quality, optimize=True)
+    # compressed_size = os.path.getsize(output_path)
+
+    # 计算实际压缩率
+    # achieved_ratio = compressed_size / original_size
+
+    # trans = transforms.Compose([
+    #     transforms.Resize(512),
+    #     transforms.ToTensor(),
+    #     transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)),
+    # ])
+
+    # compressed_img = trans(compressed_img)
+
+    # print(type(compressed_img))
+    # print(compressed_img.shape)
+    # print(f"输入文件: {input_path}")
+    # print(f"输入文件大小: {original_size}")
+    # print(f"目标压缩率: {target_ratio * 100}%")
+    # print(f"实际压缩率: {achieved_ratio * 100:.2f}%")
+    # print(f"使用的质量参数: {best_quality}")
+    # # print(f"输出文件: {output_path}")
+    # print(f"输出文件大小: {compressed_size}\n")
+
+    return compressed_img
+
+
+def find_optimal_quality(img, target_size, max_iter=20):
+    """
+    使用二分查找寻找最接近目标大小的JPEG质量参数
+    :param img: PIL图像对象
+    :param target_size: 目标文件大小（字节）
+    :param max_iter: 最大迭代次数
+    :return: 最佳质量参数（1-95）
+    """
+    low, high = 1, 95
+    best_quality = 95
+    best_diff = float('inf')
+
+    for _ in range(max_iter):
+        mid = (low + high) // 2
+        buffer = BytesIO()
+        img.save(buffer, format='JPEG', quality=mid, optimize=True)
+        current_size = buffer.tell()
+        current_diff = current_size - target_size
+
+        # 更新最佳质量参数
+        if abs(current_diff) < best_diff:
+            best_diff = abs(current_diff)
+            best_quality = mid
+
+        # 调整二分查找区间
+        if current_size < target_size:
+            low = mid + 1  # 需要更高的质量以增大文件
+        else:
+            high = mid - 1  # 需要更低的质量以减小文件
+
+        if low > high:
+            break
+
+    return best_quality
+
+# 示例用法
+if __name__ == "__main__":
+    input_image = "../../../ultraedit/UltraEdit/sequential_deepfake_dataset/87739/30_10_21_62.jpg"  # 替换为你的输入图片路径
+    compress_image(input_image, "../compressed_10.jpg", 0.1)
+    compress_image(input_image, "../compressed_25.jpg", 0.25)
+    compress_image(input_image, "../compressed_50.jpg", 0.5)
+    compress_image(input_image, "../compressed_75.jpg", 0.75)

FAITH/datasets/dataset.py

@@ -0,0 +1,209 @@
+import torch
+from torch.utils.data import Dataset
+import numpy as np
+import os
+import os.path
+from PIL import Image
+# import pandas as pd
+from torchvision import transforms
+from tools.utils import nested_tensor_from_tensor_list
+from .compress import compress_image
+from .add_noise import add_gaussian_noise
+
+# def read_data(file, root = None):
+#     # info = pd.read_csv(file)
+#     # img_list = info['file_path'].tolist()
+#     # label_list = info['label'].tolist()
+
+#     # f = open("./test.txt", "w")
+#     # for i in range(len(img_list)):
+#     #     f.write(img_list[i] + ";" + label_list[i])
+#     #     # f.write(label_list[i])
+#     #     f.write('\n')
+#     # f.close()
+
+#     dataset = []
+
+#     # img_list, label_list = [], []
+
+#     img_list_different_length = [[], [], [], [], []]
+#     label_list_different_length = [[], [], [], [], []]
+#     # length_list_different_length = [[], [], [], [], []]
+    
+#     with open(file, "r") as f:
+#         for line in f:
+#             t = line.split(";")
+#             # img = t[0]
+#             label_list_split = t[1].split(',')
+#             label = [int(label_list_split[0][1]), int(label_list_split[1][1]), int(label_list_split[2][1]), int(label_list_split[3][1])]
+#             # print(label)
+#             if 0 in label:
+#                 index = label.index(0)
+#             else:
+#                 index = 4
+
+#             if root:
+#                 t[0] = os.path.join(root, t[0]) # from relative path to absolute path
+            
+#             # if ("val" in file or "test" in file):
+#             if 1:
+#                 img_list_different_length[index].append(t[0])
+#                 label_list_different_length[index].append(label)
+#             # else:
+#                 # img_list.append(t[0])
+#                 # label_list.append(label)
+#                 # dataset.append((t[0], label, index))
+
+#     if ("val" in file or "test" in file):
+#         min_count = min(len(arr) for arr in label_list_different_length)
+#         for i in range(5):
+#             for j in range(min_count):
+#                 dataset.append((img_list_different_length[i][j], label_list_different_length[i][j]))
+#     else:
+#         for i in range(5):
+#             for j in range(len(label_list_different_length[i])):
+#                 dataset.append((img_list_different_length[i][j], label_list_different_length[i][j]))
+#             # print(len(dataset))
+#             # img_list = img_list + img_list_different_length[i][:min_count + 1]
+#             # label_list = label_list + label_list_different_length[i][:min_count + 1]
+
+#     # # with open(file.replace("csv", "txt"), "r") as f:
+#     # with open(file, "r") as f:
+#     #     for line in f:
+#     #         t = line.split(";")
+#     #         img_list.append(t[0])
+#     #         label_list.append(t[1])
+
+#     # return img_list, label_list, length_list
+#     return dataset
+
+
+def read_data(file, root=None):
+    dataset = []
+    # img_list, label_list = [], []
+
+    with open(file, "r") as f:
+        for line in f:
+            t = line.split(";")
+            dataset.append((t[0][3:].replace("sequential_deepfake_dataset", "SEED"), t[1]))
+
+    return dataset
+
+
+def make_dataset(csv_file, root=None):
+    dataset = []
+
+    imgs, labels = read_data(csv_file)
+
+    for i in range(len(imgs)):
+    # for i in range(1000):
+        # if root:
+        #     imgs[i] = os.path.join(root, imgs[i]) # from relative path to absolute path
+        if 0 in labels[i]:
+            length = labels[i].index(0)
+        else:
+            length = 4
+        dataset.append((imgs[i], labels[i], length))
+    # print(dataset)
+    return dataset
+
+
+def create_train_transforms(image_size):
+    return transforms.Compose([
+        transforms.Resize(image_size),
+        transforms.ColorJitter(brightness=[0.5, 1.3], contrast=[
+                                0.8, 1.5], saturation=[0.2, 1.5]),  # 修改图像的亮度、对比度和饱和度
+        transforms.RandomHorizontalFlip(),      # 按照概率p水平翻转图像
+        transforms.ToTensor(),
+        transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)),
+    ])
+
+
+def create_val_transforms(image_size):
+    return transforms.Compose([
+        transforms.Resize(image_size),
+        transforms.ToTensor(),
+        transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)),
+    ])
+
+
+class SeqDeepFakeDataset(Dataset):
+
+    def __init__(self,
+                 cfg=None,
+                 data_root=None,
+                 mode="train",
+                 dataset_name=None
+                 ):
+        super().__init__()
+        self.mode = mode
+        self.cfg = cfg
+        if self.mode == "train":
+            self.transforms = create_train_transforms(cfg.imgsize)
+        elif self.mode in ["val", "test"]:
+            self.transforms = create_val_transforms(cfg.imgsize)
+        else:
+            raise ValueError(f"WRONG INPUT MODE: {self.mode}!")
+
+        self.data = read_data(os.path.join(data_root, f"{dataset_name}/{mode}.txt"), root=data_root)
+        
+        self.SOS_token_id = cfg.SOS_token_id
+        self.EOS_token_id = cfg.EOS_token_id
+        self.PAD_token_id = cfg.PAD_token_id
+
+    def __getitem__(self, index: int):
+        img_path, label = self.data[index]
+        if self.mode in ["train"]:
+            label_list_split = label.split(',')
+
+            label_list = [int(label_list_split[0][1]), int(label_list_split[1][1]), int(label_list_split[2][1]), int(label_list_split[3][1])]
+
+            caption = np.array(label_list)
+
+            if np.count_nonzero(caption) == 0:
+                caption_mask = (1-np.array([1, 1, 0, 0, 0, 0])).astype(bool)
+                caption = np.insert(caption, [0, 0], [self.SOS_token_id, self.EOS_token_id])
+                caption[np.where(caption_mask==True)] = self.PAD_token_id
+
+            elif np.count_nonzero(caption) == len(caption):
+                caption_mask = (1-np.array([1, 1, 1, 1, 1, 1])).astype(bool)
+                caption = np.insert(caption, [0, 4], [self.SOS_token_id, self.EOS_token_id])
+            else:
+                first_zero_idx = np.where(caption==0)[0][0]
+                caption = np.insert(caption, [0, first_zero_idx], [self.SOS_token_id, self.EOS_token_id])
+                EOS_idx = np.where(caption==self.EOS_token_id)[0][0]
+                caption_mask = (1-np.pad(np.ones(EOS_idx+1), (0, len(caption)-(EOS_idx+1)))).astype(bool)
+                caption[np.where(caption_mask==True)] = self.PAD_token_id
+            
+            image = Image.open(img_path).convert('RGB')
+            if self.transforms:
+                image = self.transforms(image)
+
+            image = nested_tensor_from_tensor_list(self.cfg.imgsize, image.unsqueeze(0))
+
+            return image.tensors.squeeze(0), image.mask.squeeze(0), caption, caption_mask
+        elif self.mode in ["val"]:
+            label_list_split = label.split(',')
+            label_list = [int(label_list_split[0][1]), int(label_list_split[1][1]), int(label_list_split[2][1]), int(label_list_split[3][1])]
+            
+            image = Image.open(img_path).convert('RGB')
+            if self.transforms:
+                image = self.transforms(image)
+
+            return image, torch.FloatTensor(label_list), img_path
+        elif self.mode in ["test"]:
+            label_list_split = label.split(',')
+            label_list = [int(label_list_split[0][1]), int(label_list_split[1][1]), int(label_list_split[2][1]), int(label_list_split[3][1])]
+            
+            # image = Image.open(img_path).convert('RGB')
+            # image = compress_image(img_path, 0.75)
+            # image = add_gaussian_noise(img_path, 20)
+            if self.transforms:
+                image = self.transforms(image)
+
+            return image, torch.FloatTensor(label_list), img_path
+        else:
+            raise ValueError(f"WRONG INPUT MODE: {self.mode}!")
+
+    def __len__(self):
+        return len(self.data)

FAITH/models/DCT.py

@@ -0,0 +1,92 @@
+import cv2
+import numpy as np
+from scipy.fftpack import dctn, idctn
+from torch_dct import dct_2d, idct_2d
+
+
+import pdb
+import torch
+from torch import nn
+from PIL import Image
+from torchvision import transforms
+
+
+class DCT(nn.Module):
+    def __init__(self) -> None:
+        super().__init__()
+        self.conv = nn.Conv2d(1, 1, kernel_size=16, stride=16, padding=0, bias=False)
+        # self.pool = nn.AdaptiveAvgPool2d((32, 32))
+
+    def forward(self, images):
+        """ 输入维度: [B, C, H, W] """
+        # 灰度化（保持GPU计算）
+        images_gray = torch.mean(images, dim=1)  # [B, H, W]
+
+        # 二维DCT变换
+        dct_coeff = dct_2d(images_gray, norm='ortho')  # [B, H, W]
+
+        # 创建高通滤波器掩膜（保留右下四分之一）
+        B, H, W = dct_coeff.shape
+        mask = torch.zeros((H, W), device=images.device)
+        mask[H//2:, W//2:] = 1  # 右下区域
+        mask = mask.unsqueeze(0)  # [1, H, W] 用于广播
+
+        # 应用高通滤波
+        dct_highpass = dct_coeff * mask  # 广播乘法 [B, H, W]
+
+        # 逆DCT变换
+        img_highpass = idct_2d(dct_highpass, norm='ortho')  # [B, H, W]
+        img_highpass = torch.abs(img_highpass)  # 确保数值稳定性
+
+        # # masked_image = Image.fromarray(img_highpass)       # .size: [512, 512]
+        # masked_image = transforms.ToPILImage()(img_highpass[0])       # .size: [512, 512]
+        # masked_image.save("./dct_test.jpg")
+
+        # 通过卷积层（保持通道维度）
+        coeffs = self.conv(img_highpass.unsqueeze(1)).flatten(1)  # [B, 1024]
+
+        return coeffs
+
+
+    def forward_single_image(self, image):
+        image = np.array(image)
+        # 执行二维DCT变换
+        dct_coeff = dctn(image.astype(float), norm='ortho')
+
+        # 创建高频掩码（保留右下四分之一）
+        rows, cols = image.shape
+        mask = np.zeros((rows, cols))
+        mask[rows//2:, cols//2:] = 1
+
+        # 提取高频分量
+        high_freq_dct = dct_coeff * mask
+
+        # 逆DCT变换恢复高频图像
+        masked_image = idctn(high_freq_dct, norm='ortho')
+        masked_image = np.clip(masked_image, 0, 255).astype(np.uint8) * 10
+
+        masked_image = Image.fromarray(masked_image)       # .size: [512, 512]
+        masked_image.save("./dct_test.jpg")
+
+        return masked_image
+
+
+
+if __name__ == "__main__":
+    img_path = "../../../ultraedit/UltraEdit/sequential_deepfake_dataset/0/50.jpg"
+    image = Image.open(img_path).convert('RGB')
+
+    trans = transforms.Compose([
+        transforms.ColorJitter(brightness=[0.5, 1.3], contrast=[
+                                0.8, 1.5], saturation=[0.2, 1.5]),  # 修改图像的亮度、对比度和饱和度
+        transforms.RandomHorizontalFlip(),      # 按照概率p水平翻转图像
+        transforms.ToTensor(),
+        transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)),
+    ])
+
+    input_image = trans(image).unsqueeze(0)
+    print(input_image.shape)
+
+    # pdb.set_trace()
+    mask_generator = DCT()
+    output = mask_generator.forward(input_image)

FAITH/models/FFT.py

@@ -0,0 +1,193 @@
+import pdb
+import numpy as np
+import torch
+from torch import nn
+from PIL import Image
+from torchvision import transforms
+
+
+class FFT(nn.Module):
+    def __init__(self) -> None:
+        super().__init__()
+        self.conv = nn.Conv2d(1, 1, kernel_size=16, stride=16, padding=0, bias=False)
+        # self.pool = nn.AdaptiveAvgPool2d((32, 32))
+
+
+    def forward(self, images):
+        # batch_size = images.shape[0]
+        # 灰度化 (保持GPU计算)
+        images_gray = torch.mean(images, dim=1)  # [B, H, W]
+
+        # 快速傅里叶变换
+        fft_result = torch.fft.fft2(images_gray)  # [B, H, W]
+
+        # 频谱中心化
+        fft_shifted = torch.fft.fftshift(fft_result, dim=(-2, -1))
+
+        # 创建高通滤波器掩膜（GPU上创建）
+        H, W = images_gray.shape[-2], images_gray.shape[-1]
+        radius = H // 8
+        mask = torch.ones((H, W), device=images.device)
+        center = H // 2
+        mask[center-radius:center+radius, center-radius:center+radius] = 0
+        mask = mask.unsqueeze(0)  # [1, H, W] 用于广播
+
+        # 应用高通滤波
+        fft_shifted_highpass = fft_shifted * mask  # 广播乘法
+
+        # 逆中心化
+        fft_ishift = torch.fft.ifftshift(fft_shifted_highpass, dim=(-2, -1))
+
+        # 逆傅里叶变换
+        img_complex = torch.fft.ifft2(fft_ishift)
+        img_highpass = torch.abs(img_complex)  # [B, H, W]
+
+        # 通过卷积层
+        img_highpass = img_highpass.unsqueeze(1)  # 添加通道维度 [B, 1, H, W]
+        
+        # masked_image = Image.fromarray(np.array(img_highpass[0][0] * 100).astype(np.uint8))       # .size: [512, 512]
+        # masked_image.save("./test.jpg")
+
+        coeffs = self.conv(img_highpass).flatten(1)  # [B, 1024]
+
+        # print(coeffs)
+        return coeffs
+
+
+    def forward_cpu(self, images):
+        batch_size = images.shape[0]
+        coeffs = torch.zeros(batch_size, 1024).cuda()
+        images = torch.mean(images, dim=1)
+        
+        for i in range(batch_size):
+            img_array = np.array(images[i])
+            print(img_array.shape)
+            # 执行FFT并中心化
+            fft_result = np.fft.fft2(img_array)
+            fft_shifted = np.fft.fftshift(fft_result)
+
+            # 创建高通滤波器掩膜（保留高频，去除低频）
+            rows, cols = img_array.shape
+            center_row, center_col = rows // 2, cols // 2
+            radius = rows // 8  # 控制保留高频的范围，值越小保留的高频越多
+            mask = np.ones((rows, cols), np.uint8)
+            mask[center_row-radius:center_row+radius, center_col-radius:center_col+radius] = 0
+
+            # 应用掩膜，保留高频成分
+            fft_shifted_highpass = fft_shifted * mask
+            
+            fft_ishift = np.fft.ifftshift(fft_shifted_highpass)
+            img_highpass = np.abs(np.fft.ifft2(fft_ishift)) * 100
+            
+            masked_image = Image.fromarray(img_highpass.astype(np.uint8))       # .size: [512, 512]
+            masked_image.save("./test.jpg")
+            coeffs[i] = self.conv(torch.from_numpy(img_highpass).float().unsqueeze(0).unsqueeze(0).cuda()).flatten(0)
+        
+        return coeffs
+    
+
+    def forward2(self, image):
+        # batch_size = images.shape[0]
+        coeffs = torch.zeros(1, 1024).cuda()
+        
+        # for i in range(batch_size):
+        if 1:
+            image_array = np.array(image).astype(np.complex64)      # .shape: [512, 512, 3]
+            freq_image = np.fft.fftn(image_array, axes=(0, 1))
+
+            height, width = image_array.shape
+
+            mask = self._create_balanced_mask(height, width)    # .shape: [512, 512, 3]
+            self.masked_freq_image = freq_image * mask
+            masked_image_array = np.fft.ifftn(self.masked_freq_image, axes=(0, 1)).real     # .shape: [512, 512, 3]
+            masked_image = Image.fromarray(masked_image_array.astype(np.uint8))
+            # pdb.set_trace()
+            masked_image.save("./test.jpg")
+            
+            # coeffs[i] = self.pool(self.conv(masked_image)).flatten(0)
+        
+        return coeffs
+    
+
+    def _create_balanced_mask(self, height, width):
+        mask = np.zeros((height, width), dtype=np.complex64)
+
+        # Determine the region of the frequency domain to mask
+        y_start, y_end = 3 * height // 4, height
+        x_start, x_end = 3 * width // 4, width
+
+        # num_frequencies = int(np.ceil((y_end - y_start) * (x_end - x_start) * self.ratio))
+        mask_frequencies_indices = np.random.permutation((y_end - y_start) * (x_end - x_start))
+        y_indices = mask_frequencies_indices // (x_end - x_start) + y_start
+        x_indices = mask_frequencies_indices % (x_end - x_start) + x_start
+
+        mask[y_indices, x_indices] = 1
+
+        return mask
+
+
+class FrequencyMaskGenerator(nn.Module):
+    def __init__(self, ratio: float = 1, band: str = 'high') -> None:
+        # self.ratio = ratio
+        self.band = band  # 'low', 'mid', 'high', 'all'
+
+    def transform(self, image: Image.Image) -> Image.Image:
+        image_array = np.array(image).astype(np.complex64)      # .shape: [512, 512, 3]
+        freq_image = np.fft.fftn(image_array, axes=(0, 1))
+
+        height, width, _ = image_array.shape
+        
+        mask = self._create_balanced_mask(height, width)    # .shape: [512, 512, 3]
+        self.masked_freq_image = freq_image * mask
+        masked_image_array = np.fft.ifftn(self.masked_freq_image, axes=(0, 1)).real
+        masked_image = Image.fromarray(masked_image_array.astype(np.uint8))
+        return masked_image
+
+    def _create_balanced_mask(self, height, width):
+        mask = np.zeros((height, width, 3), dtype=np.complex64)
+
+        # Determine the region of the frequency domain to mask
+        if self.band == 'low':
+            y_start, y_end = 0, height // 4
+            x_start, x_end = 0, width // 4
+        elif self.band == 'mid':
+            y_start, y_end = height // 4, 3 * height // 4
+            x_start, x_end = width // 4, 3 * width // 4
+        elif self.band == 'high':
+            y_start, y_end = 3 * height // 4, height
+            x_start, x_end = 3 * width // 4, width
+        elif self.band == 'all':
+            y_start, y_end = 0, height
+            x_start, x_end = 0, width
+        else:
+            raise ValueError(f"Invalid band: {self.band}")
+
+        # num_frequencies = int(np.ceil((y_end - y_start) * (x_end - x_start) * self.ratio))
+        mask_frequencies_indices = np.random.permutation((y_end - y_start) * (x_end - x_start))
+        y_indices = mask_frequencies_indices // (x_end - x_start) + y_start
+        x_indices = mask_frequencies_indices % (x_end - x_start) + x_start
+        
+        pdb.set_trace()
+
+        mask[y_indices, x_indices, :] = 1
+        return mask
+    
+
+if __name__ == "__main__":
+    img_path = "../../../ultraedit/UltraEdit/sequential_deepfake_dataset/0/50.jpg"
+    image = Image.open(img_path).convert('RGB')
+
+    transforms = transforms.Compose([
+        transforms.ColorJitter(brightness=[0.5, 1.3], contrast=[
+                                0.8, 1.5], saturation=[0.2, 1.5]),  # 修改图像的亮度、对比度和饱和度
+        transforms.RandomHorizontalFlip(),      # 按照概率p水平翻转图像
+        transforms.ToTensor(),
+        transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)),
+    ])
+
+    input_images = transforms(image).unsqueeze(0)
+    print(input_images.shape)
+
+    # pdb.set_trace()
+    mask_generator = FFT()
+    after_image = mask_generator.forward(input_images)

FAITH/models/FrozenCLIPTextEncoder.py

@@ -0,0 +1,104 @@
+import pdb
+import torch
+from transformers import CLIPTokenizer, CLIPTextModel
+import torch.nn as nn
+
+
+class AbstractEncoder(nn.Module):
+    def __init__(self):
+        super().__init__()
+
+    def encode(self, *args, **kwargs):
+        raise NotImplementedError
+
+
+ATTRIBUTE_MAPPING = {
+    1: 'eye',
+    2: 'lip',
+    3: 'hair',
+    4: 'glasses',
+    5: 'hat',
+    6: 'eyebrow'
+}
+
+ORDER_MAPPING = {
+    1: 'first',
+    2: 'second',
+    3: 'third',
+    4: 'last'
+}
+
+
+class FrozenCLIPEmbedder(AbstractEncoder):
+    """Uses the CLIP transformer encoder for text (from Hugging Face)"""
+    def __init__(self, version="openai/clip-vit-large-patch14", device="cuda", max_length=16):
+        super().__init__()
+        self.tokenizer = CLIPTokenizer.from_pretrained(version)
+        self.transformer = CLIPTextModel.from_pretrained(version)
+        self.device = device
+        self.max_length = max_length
+        self.freeze()
+
+    def freeze(self):
+        self.transformer = self.transformer.eval()
+        for param in self.parameters():
+            param.requires_grad = False
+
+    def forward(self, text):
+        assert torch.is_tensor(text)
+        input_shape = text.shape    # .shape: [bs, 5]
+        # text = self.label_mapping(text)     # len(text): bs * 5
+        batch_encoding = self.tokenizer(self.label_mapping(text), truncation=False, return_length=True,
+                                        return_overflowing_tokens=False, padding=True, return_tensors="pt")
+        tokens = batch_encoding["input_ids"].to(self.device)
+        # outputs = self.transformer(input_ids=tokens).pooler_output
+        outputs = self.transformer(input_ids=tokens).last_hidden_state[:, 1, :]     # .shape: [bs * 5, 768]
+
+        # pdb.set_trace()
+        # outputs = torch.sum(outputs, dim=1)
+        # PAD 置零
+        indices = (text.contiguous().view(-1) == 8).nonzero(as_tuple=True)[0]
+        outputs[indices] = 0
+
+        outputs = outputs.contiguous().view(input_shape[0], input_shape[1], -1)
+        return outputs
+        # outputs = self.transformer(input_ids=tokens)
+
+        # z = outputs.last_hidden_state   # .shape: [bs, max_length, 768]
+        # return z
+
+    def label_mapping(self, batch_sequence):
+        max_sequence_length = batch_sequence.shape[1]
+        # pdb.set_trace()
+        
+        batch_sequence = batch_sequence.contiguous().view(-1).tolist()    # .shape: [bs * 5]
+
+        sentences = []
+        for i, attribute in enumerate(batch_sequence):
+            # pdb.set_trace()
+            if attribute == 0:
+                sentence = "START"
+            elif attribute == 7:
+                sentence = "END"
+            elif attribute == 8:    # TEST sequence : [SOS, PAD, PAD, PAD]
+                sentence = "PAD"   # [bos, pad, pad]  [40906, 40907]
+            else:
+                if i < len(batch_sequence) - 1 and batch_sequence[i + 1] == 8:
+                    order = 'last'
+                else:
+                    order = ORDER_MAPPING[i % max_sequence_length]
+                # sentence = f"The {ATTRIBUTE_MAPPING[attribute]} is edited {order}"
+                sentence = f"{ATTRIBUTE_MAPPING[attribute]} {order}"
+            sentences.append(sentence)
+
+        return sentences
+
+
+    def encode(self, text):
+        return self(text)
+    
+
+
+if __name__ == "__main__":
+    model = FrozenCLIPEmbedder().cuda()
+    model(torch.tensor([[0, 1, 2, 3, 4], [0, 3, 2, 8, 8], [0, 1, 5, 6, 8]]).cuda())

FAITH/models/SeqFakeFormer.py

@@ -0,0 +1,73 @@
+import torch
+from torch import nn
+import torch.nn.functional as F
+
+from tools.utils import NestedTensor, nested_tensor_from_tensor_list
+from .backbone import build_backbone
+from .transformer_SECA import build_transformer
+# import pdb
+# from PIL import Image
+# import requests
+
+class SeqFakeFormer(nn.Module):
+    def __init__(self, backbone, transformer, hidden_dim, vocab_size, imgsize):
+        super().__init__()
+        self.backbone = backbone
+        self.imgsize = imgsize
+        self.input_proj = nn.Conv2d(
+            backbone.num_channels, hidden_dim, kernel_size=1)
+        self.transformer = transformer
+        self.mlp = MLP(hidden_dim, 512, vocab_size, 3)      # FFN
+
+    def forward(self, samples, target, target_mask, img_path = None):
+        """
+        samples.shape: [bs, 3, img_size, img_size]
+        target.shape: [bs, max_position_embeddings]
+        target_mask.shape: [bs, max_position_embeddings]
+        """
+        # pdb.set_trace()
+        if not isinstance(samples, NestedTensor):
+            samples = nested_tensor_from_tensor_list(self.imgsize, samples)
+
+        features, pos = self.backbone(samples)      # CNN (Resnet-50)
+
+        # src.shape: [bs, num_channels, 32, 32]; mask.shape: [bs, 32, 32]
+        src, mask = features[-1].decompose()    # Resnet-50所指定的最后一层的feature map和mask
+        assert mask is not None
+        
+        # height and width
+        h_w = torch.tensor([self.imgsize, self.imgsize]).repeat(src.shape[0], 1).to(src.device)     # h_w.shape: [bs, 2]
+        h_w = h_w.unsqueeze(0)      # h_w.shape: [1, bs, 2]
+
+        hs = self.transformer(self.input_proj(src), mask,
+                              pos[-1], target, target_mask, h_w, samples.tensors, img_path)    # hs.shape: [max_position_embeddings, bs, hidden_dim]
+
+        out = self.mlp(hs.permute(1, 0, 2))     # out.shape: [bs, max_position_embeddings, vocab_size]
+        # print(out)
+        return out
+
+
+class MLP(nn.Module):
+    """ Very simple multi-layer perceptron (also called FFN)"""
+
+    def __init__(self, input_dim, hidden_dim, output_dim, num_layers):
+        super().__init__()
+        self.num_layers = num_layers
+        h = [hidden_dim] * (num_layers - 1)
+        # input_dim -> hidden_dim -> hidden_dim -> output_dim
+        self.layers = nn.ModuleList(nn.Linear(n, k)
+                                    for n, k in zip([input_dim] + h, h + [output_dim]))
+
+    def forward(self, x):
+        for i, layer in enumerate(self.layers):
+            x = F.relu(layer(x)) if i < self.num_layers - 1 else layer(x)
+        return x
+
+
+def build_model(config):
+    backbone = build_backbone(config)
+    transformer = build_transformer(config)
+
+    model = SeqFakeFormer(backbone, transformer, config.hidden_dim, config.vocab_size, config.imgsize)
+
+    return model

FAITH/models/attention_layer.py

@@ -0,0 +1,409 @@
+import pdb
+import cv2
+import numpy as np
+import torch
+from torch.nn.functional import linear, pad
+from torch import Tensor
+from torch.nn import MultiheadAttention
+
+from typing import Optional, Tuple, List
+import warnings
+import torch.nn.functional as F
+import torchvision
+
+import torch
+
+def scale_to_target_range(source_tensor, target_tensor):
+    """
+    将 source_tensor 的数据放缩到 target_tensor 的均值和方差范围
+    :param source_tensor: 需要放缩的 Tensor
+    :param target_tensor: 目标 Tensor, 提供均值和方差
+    :return: 放缩后的 Tensor
+    """
+    # 计算目标 Tensor 的均值和标准差
+    # pdb.set_trace()
+    target_mean = target_tensor.mean() / 5
+    target_std = target_tensor.std() / 5
+
+    # 计算源 Tensor 的均值和标准差
+    source_mean = source_tensor.mean()
+    source_std = source_tensor.std()
+
+    # 对源 Tensor 进行标准化（使其均值为 0，方差为 1）
+    source_normalized = (source_tensor - source_mean) / source_std
+
+    # 将标准化后的源 Tensor 放缩到目标 Tensor 的均值和方差
+    scaled_tensor = source_normalized * target_std + target_mean
+
+    return scaled_tensor
+
+
+
+def multi_head_attention_forward(
+                                 query: Tensor,
+                                 key: Tensor,
+                                 value: Tensor,
+                                 embed_dim_to_check: int,
+                                 num_heads: int,
+                                 in_proj_weight: Tensor,
+                                 in_proj_bias: Tensor,
+                                 bias_k: Optional[Tensor],
+                                 bias_v: Optional[Tensor],
+                                 add_zero_attn: bool,
+                                 dropout_p: float,
+                                 out_proj_weight: Tensor,
+                                 out_proj_bias: Tensor,
+                                 training: bool = True,
+                                 key_padding_mask: Optional[Tensor] = None,
+                                 need_weights: bool = True,
+                                 attn_mask: Optional[Tensor] = None,
+                                 use_separate_proj_weight: bool = False,
+                                 q_proj_weight: Optional[Tensor] = None,
+                                 k_proj_weight: Optional[Tensor] = None,
+                                 v_proj_weight: Optional[Tensor] = None,
+                                 static_k: Optional[Tensor] = None,
+                                 static_v: Optional[Tensor] = None,
+                                 gaussian: Optional[Tensor] = None,
+                                 idx = -1,
+                                 images = None,
+                                 img_path = None
+                                 ) -> Tuple[Tensor, Optional[Tensor]]:
+    r"""
+    Args:
+        query, key, value: map a query and a set of key-value pairs to an output.
+            See "Attention Is All You Need" for more details.
+        embed_dim_to_check: total dimension of the model.
+        num_heads: parallel attention heads.
+        in_proj_weight, in_proj_bias: input projection weight and bias.
+        bias_k, bias_v: bias of the key and value sequences to be added at dim=0.
+        add_zero_attn: add a new batch of zeros to the key and
+                       value sequences at dim=1.
+        dropout_p: probability of an element to be zeroed.
+        out_proj_weight, out_proj_bias: the output projection weight and bias.
+        training: apply dropout if is ``True``.
+        key_padding_mask: if provided, specified padding elements in the key will
+            be ignored by the attention. This is an binary mask. When the value is True,
+            the corresponding value on the attention layer will be filled with -inf.
+        need_weights: output attn_output_weights.
+        attn_mask: 2D or 3D mask that prevents attention to certain positions. A 2D mask will be broadcasted for all
+            the batches while a 3D mask allows to specify a different mask for the entries of each batch.
+        use_separate_proj_weight: the function accept the proj. weights for query, key,
+            and value in different forms. If false, in_proj_weight will be used, which is
+            a combination of q_proj_weight, k_proj_weight, v_proj_weight.
+        q_proj_weight, k_proj_weight, v_proj_weight: input projection weight and bias.
+        static_k, static_v: static key and value used for attention operators.
+        gaussian: the generated Gaussian-like weight map
+    Shape:
+        Inputs:
+        - query: :math:`(L, N, E)` where L is the target sequence length, N is the batch size, E is
+          the embedding dimension.
+        - key: :math:`(S, N, E)`, where S is the source sequence length, N is the batch size, E is
+          the embedding dimension.
+        - value: :math:`(S, N, E)` where S is the source sequence length, N is the batch size, E is
+          the embedding dimension.
+        - key_padding_mask: :math:`(N, S)` where N is the batch size, S is the source sequence length.
+          If a ByteTensor is provided, the non-zero positions will be ignored while the zero positions
+          will be unchanged. If a BoolTensor is provided, the positions with the
+          value of ``True`` will be ignored while the position with the value of ``False`` will be unchanged.
+        - attn_mask: 2D mask :math:`(L, S)` where L is the target sequence length, S is the source sequence length.
+          3D mask :math:`(N*num_heads, L, S)` where N is the batch size, L is the target sequence length,
+          S is the source sequence length. attn_mask ensures that position i is allowed to attend the unmasked
+          positions. If a ByteTensor is provided, the non-zero positions are not allowed to attend
+          while the zero positions will be unchanged. If a BoolTensor is provided, positions with ``True``
+          are not allowed to attend while ``False`` values will be unchanged. If a FloatTensor
+          is provided, it will be added to the attention weight.
+        - static_k: :math:`(N*num_heads, S, E/num_heads)`, where S is the source sequence length,
+          N is the batch size, E is the embedding dimension. E/num_heads is the head dimension.
+        - static_v: :math:`(N*num_heads, S, E/num_heads)`, where S is the source sequence length,
+          N is the batch size, E is the embedding dimension. E/num_heads is the head dimension.
+        Outputs:
+        - attn_output: :math:`(L, N, E)` where L is the target sequence length, N is the batch size,
+          E is the embedding dimension.
+        - attn_output_weights: :math:`(N, L, S)` where N is the batch size,
+          L is the target sequence length, S is the source sequence length.
+    """
+    '''
+    query.shape: [5, bs, hidden_dim]
+    key.shape, value.shape: [1024, bs, hidden_dim]
+    embed_dim_to_check: hidden_dim
+    '''
+    tgt_len, bsz, embed_dim = query.size()  # 5, bs, hidden_dim
+    assert embed_dim == embed_dim_to_check
+    # allow MHA to have different sizes for the feature dimension
+    assert key.size(0) == value.size(0) and key.size(1) == value.size(1)
+
+    head_dim = embed_dim // num_heads
+    assert head_dim * num_heads == embed_dim, "embed_dim must be divisible by num_heads"
+    scaling = float(head_dim) ** -0.5
+
+    if not use_separate_proj_weight:
+        if torch.equal(query, key) and torch.equal(key, value):
+            # self-attention
+            q, k, v = linear(query, in_proj_weight, in_proj_bias).chunk(3, dim=-1)
+
+        elif torch.equal(key, value):
+            # encoder-decoder attention
+            # This is inline in_proj function with in_proj_weight and in_proj_bias
+            _b = in_proj_bias
+            _start = 0
+            _end = embed_dim
+            _w = in_proj_weight[_start:_end, :]
+            if _b is not None:
+                _b = _b[_start:_end]
+            q = linear(query, _w, _b)
+
+            if key is None:
+                assert value is None
+                k = None
+                v = None
+            else:
+                # This is inline in_proj function with in_proj_weight and in_proj_bias
+                _b = in_proj_bias
+                _start = embed_dim
+                _end = None
+                _w = in_proj_weight[_start:, :]
+                if _b is not None:
+                    _b = _b[_start:]
+                k, v = linear(key, _w, _b).chunk(2, dim=-1)
+        else:
+            # This is inline in_proj function with in_proj_weight and in_proj_bias
+            _b = in_proj_bias   # Parameter(torch.empty(3 * embed_dim))
+            _start = 0
+            _end = embed_dim
+            _w = in_proj_weight[_start:_end, :]
+            if _b is not None:
+                _b = _b[_start:_end]    # Parameter(torch.empty(embed_dim))
+            q = linear(query, _w, _b)   # .shape: [5, bs, hidden_dim]
+
+            # This is inline in_proj function with in_proj_weight and in_proj_bias
+            _b = in_proj_bias
+            _start = embed_dim
+            _end = embed_dim * 2
+            _w = in_proj_weight[_start:_end, :]
+            if _b is not None:
+                _b = _b[_start:_end]
+            k = linear(key, _w, _b)     # [1024, bs, hidden_dim]
+
+            # This is inline in_proj function with in_proj_weight and in_proj_bias
+            _b = in_proj_bias
+            _start = embed_dim * 2
+            _end = None
+            _w = in_proj_weight[_start:, :]
+            if _b is not None:
+                _b = _b[_start:]
+            v = linear(value, _w, _b)   # [1024, bs, hidden_dim]
+    else:
+        q_proj_weight_non_opt = torch.jit._unwrap_optional(q_proj_weight)
+        len1, len2 = q_proj_weight_non_opt.size()
+        assert len1 == embed_dim and len2 == query.size(-1)
+
+        k_proj_weight_non_opt = torch.jit._unwrap_optional(k_proj_weight)
+        len1, len2 = k_proj_weight_non_opt.size()
+        assert len1 == embed_dim and len2 == key.size(-1)
+
+        v_proj_weight_non_opt = torch.jit._unwrap_optional(v_proj_weight)
+        len1, len2 = v_proj_weight_non_opt.size()
+        assert len1 == embed_dim and len2 == value.size(-1)
+
+        if in_proj_bias is not None:
+            q = linear(query, q_proj_weight_non_opt, in_proj_bias[0:embed_dim])
+            k = linear(key, k_proj_weight_non_opt, in_proj_bias[embed_dim:(embed_dim * 2)])
+            v = linear(value, v_proj_weight_non_opt, in_proj_bias[(embed_dim * 2):])
+        else:
+            q = linear(query, q_proj_weight_non_opt, in_proj_bias)
+            k = linear(key, k_proj_weight_non_opt, in_proj_bias)
+            v = linear(value, v_proj_weight_non_opt, in_proj_bias)
+    q = q * scaling
+
+    if attn_mask is not None:
+        assert attn_mask.dtype == torch.float32 or attn_mask.dtype == torch.float64 or \
+            attn_mask.dtype == torch.float16 or attn_mask.dtype == torch.uint8 or attn_mask.dtype == torch.bool, \
+            'Only float, byte, and bool types are supported for attn_mask, not {}'.format(attn_mask.dtype)
+        if attn_mask.dtype == torch.uint8:
+            warnings.warn("Byte tensor for attn_mask in nn.MultiheadAttention is deprecated. Use bool tensor instead.")
+            attn_mask = attn_mask.to(torch.bool)
+
+        if attn_mask.dim() == 2:
+            attn_mask = attn_mask.unsqueeze(0)
+            if list(attn_mask.size()) != [1, query.size(0), key.size(0)]:
+                raise RuntimeError('The size of the 2D attn_mask is not correct.')
+        elif attn_mask.dim() == 3:
+            if list(attn_mask.size()) != [bsz * num_heads, query.size(0), key.size(0)]:
+                raise RuntimeError('The size of the 3D attn_mask is not correct.')
+        else:
+            raise RuntimeError("attn_mask's dimension {} is not supported".format(attn_mask.dim()))
+        # attn_mask's dim is 3 now.
+
+    # convert ByteTensor key_padding_mask to bool
+    if key_padding_mask is not None and key_padding_mask.dtype == torch.uint8:
+        warnings.warn("Byte tensor for key_padding_mask in nn.MultiheadAttention is deprecated. Use bool tensor instead.")
+        key_padding_mask = key_padding_mask.to(torch.bool)
+
+    if bias_k is not None and bias_v is not None:
+        if static_k is None and static_v is None:
+            k = torch.cat([k, bias_k.repeat(1, bsz, 1)])
+            v = torch.cat([v, bias_v.repeat(1, bsz, 1)])
+            if attn_mask is not None:
+                attn_mask = pad(attn_mask, (0, 1))
+            if key_padding_mask is not None:
+                key_padding_mask = pad(key_padding_mask, (0, 1))
+        else:
+            assert static_k is None, "bias cannot be added to static key."
+            assert static_v is None, "bias cannot be added to static value."
+    else:
+        assert bias_k is None
+        assert bias_v is None
+
+    q = q.contiguous().view(tgt_len, bsz * num_heads, head_dim).transpose(0, 1)     # .shape: [bs * nhead, tgt_len, head_dim]
+    if k is not None:
+        k = k.contiguous().view(-1, bsz * num_heads, head_dim).transpose(0, 1)      # .shape: [bs * nhead, 1024, head_dim]
+    if v is not None:
+        v = v.contiguous().view(-1, bsz * num_heads, head_dim).transpose(0, 1)      # .shape: [bs * nhead, 1024, head_dim]
+
+    if static_k is not None:
+        assert static_k.size(0) == bsz * num_heads
+        assert static_k.size(2) == head_dim
+        k = static_k
+
+    if static_v is not None:
+        assert static_v.size(0) == bsz * num_heads
+        assert static_v.size(2) == head_dim
+        v = static_v
+
+    src_len = k.size(1)
+
+    if key_padding_mask is not None:        # .shape: [bs, 1024]
+        assert key_padding_mask.size(0) == bsz
+        assert key_padding_mask.size(1) == src_len
+
+    if add_zero_attn:
+        src_len += 1
+        k = torch.cat([k, torch.zeros((k.size(0), 1) + k.size()[2:], dtype=k.dtype, device=k.device)], dim=1)
+        v = torch.cat([v, torch.zeros((v.size(0), 1) + v.size()[2:], dtype=v.dtype, device=v.device)], dim=1)
+        if attn_mask is not None:
+            attn_mask = pad(attn_mask, (0, 1))
+        if key_padding_mask is not None:
+            key_padding_mask = pad(key_padding_mask, (0, 1))
+    naive = True
+    if naive:
+        attn_output_weights = torch.bmm(q, k.transpose(1, 2))       # .shape: [bs * nhead, tgt_len, 1024]
+        assert list(attn_output_weights.size()) == [bsz * num_heads, tgt_len, src_len]
+
+        if attn_mask is not None:
+            if attn_mask.dtype == torch.bool:
+                attn_output_weights.masked_fill_(attn_mask, float('-inf'))
+            else:
+                attn_output_weights += attn_mask
+
+        if key_padding_mask is not None:
+            attn_output_weights = attn_output_weights.view(bsz, num_heads, tgt_len, src_len)
+            attn_output_weights = attn_output_weights.masked_fill(
+                key_padding_mask.unsqueeze(1).unsqueeze(2), float('-inf'),)
+            attn_output_weights = attn_output_weights.view(bsz * num_heads, tgt_len, src_len)
+
+        # gaussian[0].shape: [5, 1024, bs * nhead]
+
+        delta = gaussian[0].permute(2, 0, 1)
+        delta = scale_to_target_range(delta, attn_output_weights)
+        # pdb.set_trace()
+
+        attn_output_weights = attn_output_weights + delta
+        # attention_map = attn_output_weights[0, 2, :].view(32, 32)
+
+        # attention_map = (attention_map - attention_map.min()) / (attention_map.max() - attention_map.min())
+        # attention_map = F.interpolate(attention_map.unsqueeze(0).unsqueeze(0), size=[512, 512],mode='bilinear').detach().cpu()
+        # attention_map = np.uint8(255 * attention_map)[0][0]   # .shape: [512, 512]
+
+        # normed_mask = cv2.applyColorMap(attention_map, cv2.COLORMAP_JET)     # .shape: [512, 512, 3]
+        
+        # # print(image_path[bs], input_caps[bs].detach().cpu(), caps[bs, 1:])
+        # a = cv2.resize(cv2.imread(img_path[0]), (512, 512))       # .shape: [512, 512, 3]
+        # normed_mask = cv2.addWeighted(a, 0.7, normed_mask, 0.5, 0)
+        # cv2.imwrite("./attn_maps/test.png", normed_mask)
+        
+        attn_output_weights = torch.nn.functional.softmax(attn_output_weights, dim=-1)
+        attn_output_weights = torch.nn.functional.dropout(attn_output_weights, p=dropout_p,
+                                                          training=training)
+
+        attn_output = torch.bmm(attn_output_weights, v)
+        assert list(attn_output.size()) == [bsz * num_heads, tgt_len, head_dim]
+
+    attn_output = attn_output.transpose(0, 1).contiguous().view(tgt_len, bsz, embed_dim)
+    attn_output = linear(attn_output, out_proj_weight, out_proj_bias)   # .shape: [tgt_len, bs, hidden_dim]
+
+    return attn_output, attn_output_weights.view(bsz, num_heads, tgt_len, src_len)
+
+
+class GaussianMultiheadAttention(MultiheadAttention):
+    def __init__(self, embed_dim, num_heads, **kwargs):
+        super(GaussianMultiheadAttention, self).__init__(embed_dim, num_heads, **kwargs)
+        self.gaussian = True
+
+    def forward(self, query, key, value, key_padding_mask=None,
+                need_weights=False, attn_mask=None, gaussian=None, idx = -1, images=None, img_path = None):
+        # type: (Tensor, Tensor, Tensor, Optional[Tensor], bool, Optional[Tensor], Optional[Tensor]) -> Tuple[Tensor, Optional[Tensor]]
+        r"""
+    Args:
+        query, key, value: map a query and a set of key-value pairs to an output.
+            See "Attention Is All You Need" for more details.
+        key_padding_mask: if provided, specified padding elements in the key will
+            be ignored by the attention. When given a binary mask and a value is True,
+            the corresponding value on the attention layer will be ignored. When given
+            a byte mask and a value is non-zero, the corresponding value on the attention
+            layer will be ignored
+        need_weights: output attn_output_weights.
+        attn_mask: 2D or 3D mask that prevents attention to certain positions. A 2D mask will be broadcasted for all
+            the batches while a 3D mask allows to specify a different mask for the entries of each batch.
+        gaussian: 2D gaussian attention map that focus attention to certain object queries' initial estimations
+            with handcrafted query spatial priors.
+
+    Shape:
+        - Inputs:
+        - query: :math:`(L, N, E)` where L is the target sequence length, N is the batch size, E is
+          the embedding dimension.
+        - key: :math:`(S, N, E)`, where S is the source sequence length, N is the batch size, E is
+          the embedding dimension.
+        - value: :math:`(S, N, E)` where S is the source sequence length, N is the batch size, E is
+          the embedding dimension.
+        - key_padding_mask: :math:`(N, S)` where N is the batch size, S is the source sequence length.
+          If a ByteTensor is provided, the non-zero positions will be ignored while the position
+          with the zero positions will be unchanged. If a BoolTensor is provided, the positions with the
+          value of ``True`` will be ignored while the position with the value of ``False`` will be unchanged.
+        - attn_mask: 2D mask :math:`(L, S)` where L is the target sequence length, S is the source sequence length.
+          3D mask :math:`(N*num_heads, L, S)` where N is the batch size, L is the target sequence length,
+          S is the source sequence length. attn_mask ensure that position i is allowed to attend the unmasked
+          positions. If a ByteTensor is provided, the non-zero positions are not allowed to attend
+          while the zero positions will be unchanged. If a BoolTensor is provided, positions with ``True``
+          is not allowed to attend while ``False`` values will be unchanged. If a FloatTensor
+          is provided, it will be added to the attention weight.
+        - gaussian: :math:`(L, S, nhead * batch_size)`, where nhead is the number of head in multi-head
+          attention module, L is the target sequence length, S is the source sequence length.
+
+        - Outputs:
+        - attn_output: :math:`(L, N, E)` where L is the target sequence length, N is the batch size,
+          E is the embedding dimension.
+        - attn_output_weights: :math:`(N, L, S)` where N is the batch size,
+          L is the target sequence length, S is the source sequence length.
+        """
+        if not self._qkv_same_embed_dim:
+            return multi_head_attention_forward(
+                query, key, value, self.embed_dim, self.num_heads,
+                self.in_proj_weight, self.in_proj_bias,
+                self.bias_k, self.bias_v, self.add_zero_attn,
+                self.dropout, self.out_proj.weight, self.out_proj.bias,
+                training=self.training,
+                key_padding_mask=key_padding_mask, need_weights=need_weights,
+                attn_mask=attn_mask, use_separate_proj_weight=True,
+                q_proj_weight=self.q_proj_weight, k_proj_weight=self.k_proj_weight,
+                v_proj_weight=self.v_proj_weight, gaussian=gaussian)
+        else:   # here: self._qkv_same_embed_dim = True
+            return multi_head_attention_forward(
+                query, key, value, self.embed_dim, self.num_heads,
+                self.in_proj_weight, self.in_proj_bias,
+                self.bias_k, self.bias_v, self.add_zero_attn,
+                self.dropout, self.out_proj.weight, self.out_proj.bias,
+                training=self.training,
+                key_padding_mask=key_padding_mask, need_weights=need_weights,
+                attn_mask=attn_mask, gaussian=gaussian, idx = idx, images=images, img_path = img_path)
+
+

FAITH/models/backbone.py

@@ -0,0 +1,121 @@
+import pdb
+import torch
+import torch.nn.functional as F
+import torchvision
+from torch import nn
+from torchvision.models._utils import IntermediateLayerGetter
+from typing import Dict, List
+
+from tools.utils import NestedTensor, is_main_process
+from .position_encoding import build_position_encoding
+
+
+class FrozenBatchNorm2d(torch.nn.Module):
+    """
+    BatchNorm2d where the batch statistics and the affine parameters are fixed.
+    Copy-paste from torchvision.misc.ops with added eps before rqsrt,
+    without which any other models than torchvision.models.resnet[18,34,50,101]
+    produce nans.
+    """
+
+    def __init__(self, n):
+        super(FrozenBatchNorm2d, self).__init__()
+        self.register_buffer("weight", torch.ones(n))
+        self.register_buffer("bias", torch.zeros(n))
+        self.register_buffer("running_mean", torch.zeros(n))
+        self.register_buffer("running_var", torch.ones(n))
+
+    def _load_from_state_dict(self, state_dict, prefix, local_metadata, strict,
+                              missing_keys, unexpected_keys, error_msgs):
+        num_batches_tracked_key = prefix + 'num_batches_tracked'
+        if num_batches_tracked_key in state_dict:
+            del state_dict[num_batches_tracked_key]
+
+        super(FrozenBatchNorm2d, self)._load_from_state_dict(
+            state_dict, prefix, local_metadata, strict,
+            missing_keys, unexpected_keys, error_msgs)
+
+    def forward(self, x):
+        # move reshapes to the beginning
+        # to make it fuser-friendly
+        w = self.weight.reshape(1, -1, 1, 1)
+        b = self.bias.reshape(1, -1, 1, 1)
+        rv = self.running_var.reshape(1, -1, 1, 1)
+        rm = self.running_mean.reshape(1, -1, 1, 1)
+        eps = 1e-5
+        scale = w * (rv + eps).rsqrt()
+        bias = b - rm * scale
+        return x * scale + bias
+
+
+class BackboneBase(nn.Module):
+    def __init__(self, backbone: nn.Module, train_backbone: bool, num_channels: int, return_interm_layers: bool):
+        super().__init__()
+        for name, parameter in backbone.named_parameters():
+            if not train_backbone or 'layer2' not in name and 'layer3' not in name and 'layer4' not in name:
+                parameter.requires_grad_(False)
+        if return_interm_layers:
+            return_layers = {"layer1": "0", "layer2": "1", "layer3": "2", "layer4": "3"}
+        else:
+            return_layers = {'layer4': "0"}
+        self.body = IntermediateLayerGetter(backbone, return_layers=return_layers)      # 获取中间层的输出
+        self.num_channels = num_channels
+
+    def forward(self, tensor_list: NestedTensor):
+        # print(tensor_list.mask)
+        xs = self.body(tensor_list.tensors)     # xs['0'].shape: [bs, 2048, 32, 32]
+        out: Dict[str, NestedTensor] = {}
+        for name, x in xs.items():
+            m = tensor_list.mask    # m.shape: [bs, img_size, img_size]   all False
+            assert m is not None
+            mask = F.interpolate(m[None].float(), size=x.shape[-2:]).to(torch.bool)[0]      # [bs, 32, 32] all False
+            out[name] = NestedTensor(x, mask)
+        return out
+
+
+class Backbone(BackboneBase):
+    """ResNet backbone with frozen BatchNorm."""
+    def __init__(self, name: str,
+                 train_backbone: bool,
+                 return_interm_layers: bool,
+                 dilation: bool,
+                 Frozen_BatchNorm2d: bool):
+        if Frozen_BatchNorm2d:
+            backbone = getattr(torchvision.models, name)(
+                replace_stride_with_dilation=[False, False, dilation],
+                pretrained=is_main_process(), norm_layer=FrozenBatchNorm2d)
+        else:
+            backbone = getattr(torchvision.models, name)(
+                replace_stride_with_dilation=[False, False, dilation],
+                pretrained=is_main_process(), norm_layer=nn.BatchNorm2d)
+        num_channels = 512 if name in ('resnet18', 'resnet34') else 2048
+        super().__init__(backbone, train_backbone, num_channels, return_interm_layers)
+
+
+class Joiner(nn.Sequential):
+    def __init__(self, backbone, position_embedding):
+        super().__init__(backbone, position_embedding)
+
+    def forward(self, tensor_list: NestedTensor):
+        xs = self[0](tensor_list)
+        out: List[NestedTensor] = []
+        pos = []
+        for name, x in xs.items():
+            out.append(x)
+            # position encoding
+            pos.append(self[1](x).to(x.tensors.dtype))  # pos[0].shape: [bs, 512, 32, 32]
+
+        return out, pos
+
+
+def build_backbone(config):
+    
+    position_embedding = build_position_encoding(config)
+
+    train_backbone = config.lr_backbone > 0
+    return_interm_layers = False
+    backbone = Backbone(config.backbone, train_backbone, return_interm_layers, config.dilation, config.Frozen_BatchNorm2d)
+    model = Joiner(backbone, position_embedding)
+    model.num_channels = backbone.num_channels
+
+    return model

FAITH/models/configuration.py

@@ -0,0 +1,61 @@
+import json
+
+class Config(object):
+    def __init__(self, config_file):
+        with open(config_file) as f:
+            cfgs = json.load(f)
+        
+        # Learning Rates
+        self.lr_backbone = cfgs["optimizer"]["lr_backbone"]
+        self.lr = cfgs["optimizer"]["lr"]
+
+        # Epochs
+        self.epochs = cfgs["optimizer"]["epochs"]
+        self.warmup = cfgs["optimizer"]["warmup"]
+        self.warmup_epochs = cfgs["optimizer"]["warmup_epochs"]
+        self.lr_milestones = cfgs["optimizer"]["lr_milestones"]
+
+        self.start_epoch = cfgs["optimizer"]["start_epoch"]
+        self.weight_decay = cfgs["optimizer"]["weight_decay"]
+
+        # Backbone
+        # resnet34 resnet50
+        self.backbone = cfgs["backbone"]["network"]
+        if self.backbone == 'resnet50' or self.backbone == 'resnet101':
+            self.dilation = True
+        elif self.backbone == 'resnet34' or self.backbone == 'resnet18':
+            self.dilation = False
+        else:
+            raise ValueError(f"{self.backbone} is not a supported backbone!")
+
+        self.position_embedding = cfgs["backbone"]["position_embedding"] # sine learned
+        self.Frozen_BatchNorm2d = cfgs["backbone"]["Frozen_BatchNorm2d"]
+
+        # Basic
+        self.batch_size = cfgs["optimizer"]["batch_size"]
+        self.clip_max_norm = cfgs["optimizer"]["clip_max_norm"]
+
+        # Transformer
+        self.SOS_token_id = cfgs["transformer"]["SOS_token_id"]
+        self.EOS_token_id = cfgs["transformer"]["EOS_token_id"]
+        self.PAD_token_id = cfgs["transformer"]["PAD_token_id"]
+
+        self.smooth = cfgs["transformer"]["smooth"]
+        self.dynamic_scale = cfgs["transformer"]["dynamic_scale"]
+
+        self.max_position_embeddings = cfgs["transformer"]["max_position_embeddings"]
+        self.vocab_size = cfgs["transformer"]["vocab_size"]
+
+
+        self.layer_norm_eps = cfgs["transformer"]["layer_norm_eps"]
+        self.dropout = cfgs["transformer"]["dropout"]
+
+        self.hidden_dim = cfgs["transformer"]["hidden_dim"]
+        self.enc_layers = cfgs["transformer"]["enc_layers"]
+        self.dec_layers = cfgs["transformer"]["dec_layers"]
+        self.dim_feedforward = cfgs["transformer"]["dim_feedforward"]
+        self.nheads = cfgs["transformer"]["nheads"]
+        self.pre_norm = cfgs["transformer"]["pre_norm"]
+
+        # Dataset
+        self.imgsize = cfgs["dataset"]["imgsize"]

FAITH/models/position_encoding.py

@@ -0,0 +1,85 @@
+import math
+import torch
+from torch import nn
+
+from tools.utils import NestedTensor
+
+
+class PositionEmbeddingSine(nn.Module):
+    """
+    This is a more standard version of the position embedding, very similar to the one
+    used by the Attention is all you need paper, generalized to work on images.
+    """
+    def __init__(self, num_pos_feats=64, temperature=10000, normalize=False, scale=None):
+        super().__init__()
+        self.num_pos_feats = num_pos_feats
+        self.temperature = temperature
+        self.normalize = normalize
+        if scale is not None and normalize is False:
+            raise ValueError("normalize should be True if scale is passed")
+        if scale is None:
+            scale = 2 * math.pi
+        self.scale = scale
+
+    def forward(self, tensor_list: NestedTensor):
+        x = tensor_list.tensors
+        mask = tensor_list.mask
+        assert mask is not None
+        not_mask = ~mask
+        y_embed = not_mask.cumsum(1, dtype=torch.float32)
+        x_embed = not_mask.cumsum(2, dtype=torch.float32)
+        if self.normalize:
+            eps = 1e-6
+            y_embed = y_embed / (y_embed[:, -1:, :] + eps) * self.scale
+            x_embed = x_embed / (x_embed[:, :, -1:] + eps) * self.scale
+
+        dim_t = torch.arange(self.num_pos_feats, dtype=torch.float32, device=x.device)
+        dim_t = self.temperature ** (2 * (dim_t // 2) / self.num_pos_feats)
+
+        pos_x = x_embed[:, :, :, None] / dim_t
+        pos_y = y_embed[:, :, :, None] / dim_t
+        pos_x = torch.stack((pos_x[:, :, :, 0::2].sin(), pos_x[:, :, :, 1::2].cos()), dim=4).flatten(3)
+        pos_y = torch.stack((pos_y[:, :, :, 0::2].sin(), pos_y[:, :, :, 1::2].cos()), dim=4).flatten(3)
+        pos = torch.cat((pos_y, pos_x), dim=3).permute(0, 3, 1, 2)
+        return pos
+
+
+class PositionEmbeddingLearned(nn.Module):
+    """
+    Absolute pos embedding, learned.
+    """
+    def __init__(self, num_pos_feats=256):
+        super().__init__()
+        self.row_embed = nn.Embedding(50, num_pos_feats)
+        self.col_embed = nn.Embedding(50, num_pos_feats)
+        self.reset_parameters()
+
+    def reset_parameters(self):
+        nn.init.uniform_(self.row_embed.weight)
+        nn.init.uniform_(self.col_embed.weight)
+
+    def forward(self, tensor_list: NestedTensor):
+        x = tensor_list.tensors
+        h, w = x.shape[-2:]
+        i = torch.arange(w, device=x.device)
+        j = torch.arange(h, device=x.device)
+        x_emb = self.col_embed(i)
+        y_emb = self.row_embed(j)
+        pos = torch.cat([
+            x_emb.unsqueeze(0).repeat(h, 1, 1),
+            y_emb.unsqueeze(1).repeat(1, w, 1),
+        ], dim=-1).permute(2, 0, 1).unsqueeze(0).repeat(x.shape[0], 1, 1, 1)
+        return pos
+
+
+def build_position_encoding(config):
+    N_steps = config.hidden_dim // 2
+    if config.position_embedding in ('v2', 'sine'):
+        # TODO find a better way of exposing other arguments
+        position_embedding = PositionEmbeddingSine(N_steps, normalize=True)
+    elif config.position_embedding in ('v3', 'learned'):
+        position_embedding = PositionEmbeddingLearned(N_steps)
+    else:
+        raise ValueError(f"not supported {config.position_embedding}")
+
+    return position_embedding

FAITH/models/transformer_SECA.py

@@ -0,0 +1,630 @@
+import copy
+from typing import Optional, List
+
+import cv2
+import numpy as np
+import torch
+import torch.nn.functional as F
+from torch import nn, Tensor
+import pdb
+
+# from .FrozenCLIPTextEncoder import FrozenCLIPEmbedder
+from .attention_layer import GaussianMultiheadAttention
+from pytorch_wavelets import DWTForward # (or import DWT, IDWT)
+# from .FFT import FFT
+# from .DCT import DCT
+
+class Transformer(nn.Module):
+
+    def __init__(self, config, d_model=512, nhead=8, num_encoder_layers=6,
+                 num_decoder_layers=6, dim_feedforward=2048, dropout=0.1,
+                 activation="relu", normalize_before=False,
+                 return_intermediate_dec=False, smooth=8, dynamic_scale=True):
+        super().__init__()
+
+        encoder_layer = TransformerEncoderLayer(d_model, nhead, dim_feedforward,
+                                                dropout, activation, normalize_before)
+        encoder_norm = nn.LayerNorm(d_model) if normalize_before else None
+        self.encoder = TransformerEncoder(encoder_layer, num_encoder_layers, encoder_norm)  # Transformer Encooder
+
+        self.embeddings = DecoderEmbeddings(config)
+
+        decoder_layers = []
+        for layer_index in range(num_decoder_layers):
+            decoder_layer = TransformerDecoderLayer(dynamic_scale, smooth, layer_index,
+                                                    d_model, nhead, dim_feedforward, dropout,
+                                                    activation, normalize_before)
+            decoder_layers.append(decoder_layer)
+        decoder_norm = nn.LayerNorm(d_model)
+        self.decoder = TransformerDecoder(decoder_layers, num_decoder_layers, decoder_norm,
+                                          return_intermediate=return_intermediate_dec)      # Transformer Decoder
+
+        self._reset_parameters()
+        # if dynamic_scale in ["type2", "type3", "type4"]:
+        #     for layer_index in range(num_decoder_layers):
+        #         nn.init.zeros_(self.decoder.layers[layer_index].point3.weight)      # 用全0初始化权重
+        #         with torch.no_grad():
+        #             nn.init.ones_(self.decoder.layers[layer_index].point3.bias)     # 用全1初始化偏差
+        
+        # nn.init.normal_(self.embeddings.projection_layer.weight, mean=0.05, std=0.01)
+
+        self.d_model = d_model
+        self.nhead = nhead
+
+    def _reset_parameters(self):
+        for p in self.parameters():
+            if p.dim() > 1:
+                nn.init.xavier_uniform_(p)      # 用均匀分布初始化参数
+
+    def forward(self, src, mask, pos_embed, tgt, tgt_mask, h_w, images, img_path = None):
+        # flatten NxCxHxW to HWxNxC
+        '''
+        src.shape: [bs, hidden_dim, 32, 32]
+        mask.shape: [bs, 32, 32]
+        pos_embed.shape: [bs, 512, 32, 32]
+        tgt.shape: [bs, 5]
+        tgt_mask.shape: [bs, 5]
+        h_w.shape: [1, bs, 2]
+        '''
+        bs, c, h, w = src.shape
+        grid_y, grid_x = torch.meshgrid(torch.arange(0, h), torch.arange(0, w))     # 返回一个h × w大小的网格，可用于生成坐标       # grid_y.shape: [32, 32], grid_x.shape: [32, 32]
+        grid = torch.stack((grid_x, grid_y), 2).float().to(src.device)      # grid.shape: [32, 32, 2]
+        grid = grid.reshape(-1, 2).unsqueeze(1).repeat(1, bs * self.nhead, 1)   # grid.shape: [1024, bs * self.nhead, 2]
+
+        src = src.flatten(2).permute(2, 0, 1)       # src.shape: [1024, bs, hidden_dim]
+        pos_embed = pos_embed.flatten(2).permute(2, 0, 1)       # pos_embed.shape: [1024, bs, 512]
+
+        tgt = self.embeddings(tgt).permute(1, 0, 2)     # Tokenizer     tgt.shape: [5, bs, hidden_dim]
+        query_embed = self.embeddings.position_embeddings.weight.unsqueeze(1)       # query_embed.shape: [5, 1, hidden_dim]
+        query_embed = query_embed.repeat(1, bs, 1)     # query_embed.shape: [5, bs, hidden_dim]
+
+        mask = mask.flatten(1)  # mask.shape: [bs, 1024]
+
+        # original Transformer visual encoder
+        memory = self.encoder(src, src_key_padding_mask=mask, pos=pos_embed)    # memory.shape: [1024, bs, hidden_dim]
+
+        hs = self.decoder(grid, h_w, tgt, memory, memory_key_padding_mask=mask, tgt_key_padding_mask=tgt_mask,
+                                  pos=pos_embed, query_pos=query_embed,
+                                  tgt_mask=generate_square_subsequent_mask(len(tgt)).to(tgt.device), images=images, img_path = img_path)        # hs.shape: [max_position_embeddings, bs, hidden_dim]
+        # print(hs)
+        return hs
+
+
+class TransformerEncoder(nn.Module):
+
+    def __init__(self, encoder_layer, num_layers, norm=None):
+        super().__init__()
+        self.layers = _get_clones(encoder_layer, num_layers)
+        self.num_layers = num_layers
+        self.norm = norm
+
+    def forward(self, src,
+                mask: Optional[Tensor] = None,
+                src_key_padding_mask: Optional[Tensor] = None,
+                pos: Optional[Tensor] = None):
+        '''
+        src.shape, pos.shape: [1024, bs, hidden_dim]
+        mask: None
+        src_key_padding_mask.shape: [bs, 1024]
+        '''
+        output = src
+
+        for layer in self.layers:
+            output = layer(output, src_mask=mask,
+                           src_key_padding_mask=src_key_padding_mask, pos=pos)
+
+        if self.norm is not None:
+            output = self.norm(output)
+
+        return output
+
+
+class TransformerDecoder(nn.Module):
+
+    def __init__(self, decoder_layer, num_layers, norm=None, return_intermediate=False):
+        super().__init__()
+        self.layers = nn.ModuleList(decoder_layer)
+        self.num_layers = num_layers
+        self.norm = norm
+        self.return_intermediate = return_intermediate
+
+    def forward(self, grid, h_w, tgt, memory,
+                tgt_mask: Optional[Tensor] = None,
+                memory_mask: Optional[Tensor] = None,
+                tgt_key_padding_mask: Optional[Tensor] = None,
+                memory_key_padding_mask: Optional[Tensor] = None,
+                pos: Optional[Tensor] = None,
+                query_pos: Optional[Tensor] = None, images = None, img_path = None):
+        output = tgt
+
+        intermediate = []
+
+        points = []
+        point_sigmoid_ref = None
+        for layer in self.layers:
+            # output, point, point_sigmoid_ref = layer(
+            #     grid, h_w, output, memory, tgt_mask=tgt_mask,
+            #     memory_mask=memory_mask, tgt_key_padding_mask=tgt_key_padding_mask,
+            #     memory_key_padding_mask=memory_key_padding_mask,
+            #     pos=pos, query_pos=query_pos, point_ref_previous=point_sigmoid_ref
+            # )
+
+            output = layer(
+                grid, h_w, output, memory, tgt_mask=tgt_mask,
+                memory_mask=memory_mask, tgt_key_padding_mask=tgt_key_padding_mask,
+                memory_key_padding_mask=memory_key_padding_mask,
+                pos=pos, query_pos=query_pos, point_ref_previous=point_sigmoid_ref, images=images, img_path = img_path
+            )
+            # points.append(point)
+            if self.return_intermediate:
+                intermediate.append(self.norm(output))
+
+        if self.norm is not None:
+            output = self.norm(output)
+            if self.return_intermediate:
+                intermediate.pop()
+                intermediate.append(output)
+
+        if self.return_intermediate:
+            return torch.stack(intermediate), points[0]
+
+        return output
+
+
+class TransformerEncoderLayer(nn.Module):
+
+    def __init__(self, d_model, nhead, dim_feedforward=2048, dropout=0.1,
+                 activation="relu", normalize_before=False):
+        super().__init__()
+        self.self_attn = nn.MultiheadAttention(d_model, nhead, dropout=dropout)
+        # Implementation of Feedforward model
+        self.linear1 = nn.Linear(d_model, dim_feedforward)
+        self.dropout = nn.Dropout(dropout)
+        self.linear2 = nn.Linear(dim_feedforward, d_model)
+
+        self.norm1 = nn.LayerNorm(d_model)
+        self.norm2 = nn.LayerNorm(d_model)
+        self.dropout1 = nn.Dropout(dropout)
+        self.dropout2 = nn.Dropout(dropout)
+
+        self.activation = _get_activation_fn(activation)
+        self.normalize_before = normalize_before
+
+    def with_pos_embed(self, tensor, pos: Optional[Tensor]):
+        return tensor if pos is None else tensor + pos
+
+    def forward_post(self,
+                     src,
+                     src_mask: Optional[Tensor] = None,
+                     src_key_padding_mask: Optional[Tensor] = None,
+                     pos: Optional[Tensor] = None):
+        q = k = self.with_pos_embed(src, pos)
+        src2 = self.self_attn(q, k, value=src, attn_mask=src_mask,
+                              key_padding_mask=src_key_padding_mask)[0]
+        src = src + self.dropout1(src2)
+        src = self.norm1(src)
+        src2 = self.linear2(self.dropout(self.activation(self.linear1(src))))
+        src = src + self.dropout2(src2)
+        src = self.norm2(src)
+        return src
+
+    def forward_pre(self, src,
+                    src_mask: Optional[Tensor] = None,
+                    src_key_padding_mask: Optional[Tensor] = None,
+                    pos: Optional[Tensor] = None):
+        '''
+        src.shape, pos.shape: [1024, bs, hidden_dim]
+        src_mask: None
+        src_key_padding_mask.shape: [bs, 1024]
+        '''
+        src2 = self.norm1(src)  # .shape: [1024, bs, hidden_dim]
+        q = k = self.with_pos_embed(src2, pos)      # 将pos添加到feature map上
+        src2 = self.self_attn(q, k, value=src2, attn_mask=src_mask,
+                              key_padding_mask=src_key_padding_mask)[0]     # .shape: [1024, bs, hidden_dim]
+        src = src + self.dropout1(src2)
+        src2 = self.norm2(src)
+        src2 = self.linear2(self.dropout(self.activation(self.linear1(src2))))
+        src = src + self.dropout2(src2)
+        return src
+
+    def forward(self, src,
+                src_mask: Optional[Tensor] = None,
+                src_key_padding_mask: Optional[Tensor] = None,
+                pos: Optional[Tensor] = None):
+        if self.normalize_before:
+            return self.forward_pre(src, src_mask, src_key_padding_mask, pos)
+        return self.forward_post(src, src_mask, src_key_padding_mask, pos)
+
+
+class TransformerDecoderLayer(nn.Module):
+
+    def __init__(self, dynamic_scale, smooth, layer_index,
+                 d_model, nhead, dim_feedforward=2048, dropout=0.1,
+                 activation="relu", normalize_before=False):
+        super().__init__()
+        self.wavelettransformer = WaveletTransformer()
+        # self.fft = FFT()
+        # self.dct = DCT()
+        self.self_attn = nn.MultiheadAttention(d_model, nhead, dropout=dropout)
+        self.multihead_attn = GaussianMultiheadAttention(d_model, nhead, dropout=dropout)
+        # Implementation of Feedforward model
+        self.linear1 = nn.Linear(d_model, dim_feedforward)
+        self.dropout = nn.Dropout(dropout)
+        self.linear2 = nn.Linear(dim_feedforward, d_model)
+
+        self.smooth = smooth
+        self.dynamic_scale = dynamic_scale
+
+        self.norm1 = nn.LayerNorm(d_model)
+        self.norm2 = nn.LayerNorm(d_model)
+        self.norm3 = nn.LayerNorm(d_model)
+        # self.norm4 = nn.LayerNorm(d_model)
+        self.dropout1 = nn.Dropout(dropout)
+        self.dropout2 = nn.Dropout(dropout)
+        self.dropout3 = nn.Dropout(dropout)
+
+        # if layer_index == 0:
+        #     self.point1 = MLP(d_model, d_model, 2, 3)
+        #     self.point2 = nn.Linear(d_model, 2*nhead)
+        # else:
+        #     self.point2 = nn.Linear(d_model, 2*nhead)
+        self.layer_index = layer_index
+        # if self.dynamic_scale == "type2":
+        #     self.point3 = nn.Linear(d_model, nhead)
+        # elif self.dynamic_scale == "type3":
+        #     self.point3 = nn.Linear(d_model, 2*nhead)
+        # elif self.dynamic_scale == "type4":
+        #     self.point3 = nn.Linear(d_model, 3*nhead)
+
+        self.activation = _get_activation_fn(activation)
+        self.normalize_before = normalize_before
+
+        self.nhead = nhead
+
+    def with_pos_embed(self, tensor, pos: Optional[Tensor]):
+        return tensor if pos is None else tensor + pos
+
+    def forward_post(self, grid, h_w, tgt, memory,
+                     tgt_mask: Optional[Tensor] = None,
+                     memory_mask: Optional[Tensor] = None,
+                     tgt_key_padding_mask: Optional[Tensor] = None,
+                     memory_key_padding_mask: Optional[Tensor] = None,
+                     pos: Optional[Tensor] = None,
+                     query_pos: Optional[Tensor] = None,
+                     point_ref_previous: Optional[Tensor] = None):
+        tgt_len = tgt.shape[0]
+
+        out = self.norm4(tgt + query_pos)
+        point_sigmoid_offset = self.point2(out)
+
+        q = k = self.with_pos_embed(tgt, query_pos)
+        tgt2 = self.self_attn(q, k, value=tgt, attn_mask=tgt_mask,
+                              key_padding_mask=tgt_key_padding_mask)[0]
+        tgt = tgt + self.dropout1(tgt2)
+        tgt = self.norm1(tgt)
+
+        if self.layer_index == 0:
+            point_sigmoid_ref_inter = self.point1(out)
+            point_sigmoid_ref = point_sigmoid_ref_inter.sigmoid()
+            point_sigmoid_ref = (h_w - 0) * point_sigmoid_ref / int((h_w.max().item()/int(grid.max()+1)))
+            point_sigmoid_ref = point_sigmoid_ref.repeat(1, 1, self.nhead)
+        else:
+            point_sigmoid_ref = point_ref_previous
+
+        point = point_sigmoid_ref + point_sigmoid_offset
+        point = point.view(tgt_len, -1, 2)
+        distance = (point.unsqueeze(1) - grid.unsqueeze(0)).pow(2)
+
+        if self.dynamic_scale == "type1":
+            scale = 1
+            distance = distance.sum(-1) * scale
+        elif self.dynamic_scale == "type2":
+            scale = self.point3(out)
+            scale = scale * scale
+            scale = scale.reshape(tgt_len, -1).unsqueeze(1)
+            distance = distance.sum(-1) * scale
+        elif self.dynamic_scale == "type3":
+            scale = self.point3(out)
+            scale = scale * scale
+            scale = scale.reshape(tgt_len, -1, 2).unsqueeze(1)
+            distance = (distance * scale).sum(-1)
+        elif self.dynamic_scale == "type4":
+            scale = self.point3(out)
+            scale = scale * scale
+            scale = scale.reshape(tgt_len, -1, 3).unsqueeze(1)
+            distance = torch.cat([distance, torch.prod(distance, dim=-1, keepdim=True)], dim=-1)
+            distance = (distance * scale).sum(-1)
+
+        gaussian = -(distance - 0).abs() / self.smooth
+
+        tgt2 = self.multihead_attn(query=self.with_pos_embed(tgt, query_pos),
+                                   key=self.with_pos_embed(memory, pos),
+                                   value=memory, attn_mask=memory_mask,
+                                   key_padding_mask=memory_key_padding_mask,
+                                   gaussian=[gaussian])[0]
+        tgt = tgt + self.dropout2(tgt2)
+        tgt = self.norm2(tgt)
+        tgt2 = self.linear2(self.dropout(self.activation(self.linear1(tgt))))
+        tgt = tgt + self.dropout3(tgt2)
+        tgt = self.norm3(tgt)
+        if self.layer_index == 0:
+            return tgt, point_sigmoid_ref_inter, point_sigmoid_ref
+        else:
+            return tgt, None, point_sigmoid_ref
+
+    def forward_pre(self, grid, h_w, tgt, memory,
+                    tgt_mask: Optional[Tensor] = None,
+                    memory_mask: Optional[Tensor] = None,
+                    tgt_key_padding_mask: Optional[Tensor] = None,
+                    memory_key_padding_mask: Optional[Tensor] = None,
+                    pos: Optional[Tensor] = None,
+                    query_pos: Optional[Tensor] = None,
+                    point_ref_previous: Optional[Tensor] = None,
+                    idx = -1, images=None, img_path = None):
+        '''
+        grid.shape: [1024, bs * nhead, 2]
+        tgt.shape, query_pos.shape: [5, bs, hidden_dim]
+        '''
+
+        # tgt_len = tgt.shape[0]
+        # out = self.norm4(tgt + query_pos)
+        # point_sigmoid_offset = self.point2(out)    # Δt .shape: [5, bs, 2 * nhead]
+
+        tgt2 = self.norm1(tgt)
+        q = k = self.with_pos_embed(tgt2, query_pos)
+        tgt2 = self.self_attn(q, k, value=tgt2, attn_mask=tgt_mask,
+                              key_padding_mask=tgt_key_padding_mask)[0]     # .shape: [5, bs, hidden_dim]
+        tgt = tgt + self.dropout1(tgt2)
+
+        # if self.layer_index == 0:
+        #     point_sigmoid_ref_inter = self.point1(out)      # .shape: [5, bs, 2]
+        #     point_sigmoid_ref = point_sigmoid_ref_inter.sigmoid()
+        #     point_sigmoid_ref = (h_w - 0) * point_sigmoid_ref / int((h_w.max().item()/int(grid.max()+1)))
+        #     point_sigmoid_ref = point_sigmoid_ref.repeat(1, 1, self.nhead)  # [5, bs, 2 * nhead]
+        # else:
+        #     point_sigmoid_ref = point_ref_previous  # t .shape: [5, bs, 2 * nhead]
+
+        # point = point_sigmoid_ref + point_sigmoid_offset
+        # point = point.view(tgt_len, -1, 2)      # .shape: [5, bs * nhead, 2]
+        # distance = (point.unsqueeze(1) - grid.unsqueeze(0)).pow(2)  # distance.shape: [5, 1024, bs * nhead, 2] = [5, 1, bs * nhead, 2] - [1, 1024, bs * nhead, 2]
+
+        # if self.dynamic_scale == "type1":
+        #     scale = 1
+        #     distance = distance.sum(-1) * scale
+        # elif self.dynamic_scale == "type2":
+        #     scale = self.point3(out)
+        #     scale = scale * scale
+        #     scale = scale.reshape(tgt_len, -1).unsqueeze(1)
+        #     distance = distance.sum(-1) * scale
+        # elif self.dynamic_scale == "type3":
+        #     scale = self.point3(out)    # .shape: [5, bs, 2 * nhead]
+        #     scale = scale * scale
+        #     scale = scale.reshape(tgt_len, -1, 2).unsqueeze(1)  # .shape: [5, 1, bs * nhead, 2]
+        #     distance = (distance * scale).sum(-1)   # distance.shape = [5, 1024, bs * nhead]
+        # elif self.dynamic_scale == "type4":
+        #     scale = self.point3(out)
+        #     scale = scale * scale
+        #     scale = scale.reshape(tgt_len, -1, 3).unsqueeze(1)
+        #     distance = torch.cat([distance, torch.prod(distance, dim=-1, keepdim=True)], dim=-1)
+        #     distance = (distance * scale).sum(-1)
+
+        # gaussian = -(distance - 0).abs() / self.smooth  # .shape: [5, 1024, bs * nhead]
+        
+        gaussian = self.wavelettransformer(images).permute(1, 0).repeat(5, 1, self.nhead)       # .shape: [5, 1024, bs * nhead]
+        # gaussian = self.fft(images).permute(1, 0).repeat(5, 1, self.nhead)
+        # gaussian = self.dct(images).permute(1, 0).repeat(5, 1, self.nhead)
+
+        # gaussian[gaussian < (torch.max(gaussian) + torch.min(gaussian)) / 2] = 0
+        # pdb.set_trace()
+
+        tgt2 = self.norm2(tgt)
+        tgt2 = self.multihead_attn(query=self.with_pos_embed(tgt2, query_pos),
+                                   key=self.with_pos_embed(memory, pos),
+                                   value=memory, attn_mask=memory_mask,
+                                   key_padding_mask=memory_key_padding_mask,
+                                   gaussian=[gaussian],
+                                   idx = idx, images=images, img_path = img_path)[0]
+            
+        # 生成attention map
+        # attn_out_weights_ = attn_out_weights[0][0][0]
+
+        tgt = tgt + self.dropout2(tgt2)
+        tgt2 = self.norm3(tgt)
+        tgt2 = self.linear2(self.dropout(self.activation(self.linear1(tgt2))))
+        tgt = tgt + self.dropout3(tgt2)
+        
+        # if self.layer_index == 0:
+        #     return tgt, point_sigmoid_ref_inter, point_sigmoid_ref
+        # else:
+        #     return tgt, None, point_sigmoid_ref
+        return tgt
+
+    def forward(self, grid, h_w, tgt, memory,
+                tgt_mask: Optional[Tensor] = None,
+                memory_mask: Optional[Tensor] = None,
+                tgt_key_padding_mask: Optional[Tensor] = None,
+                memory_key_padding_mask: Optional[Tensor] = None,
+                pos: Optional[Tensor] = None,
+                query_pos: Optional[Tensor] = None,
+                point_ref_previous: Optional[Tensor] = None, images=None, img_path = None):
+        if self.normalize_before:
+            return self.forward_pre(grid, h_w, tgt, memory, tgt_mask, memory_mask,
+                                    tgt_key_padding_mask, memory_key_padding_mask, pos, query_pos,
+                                    point_ref_previous, self.layer_index, images=images, img_path = img_path)
+        return self.forward_post(grid, h_w, tgt, memory, tgt_mask, memory_mask,
+                                 tgt_key_padding_mask, memory_key_padding_mask, pos, query_pos,
+                                 point_ref_previous)
+
+
+# 定义一个包含卷积和池化的网络
+class ConvNet(nn.Module):
+    def __init__(self):
+        super(ConvNet, self).__init__()
+        
+        # 第一个卷积层，输入9个通道，输出64个通道，卷积核大小3x3，步幅1，填充1
+        self.conv1 = nn.Conv2d(9, 64, kernel_size=3, stride=1, padding=1)  
+        self.pool = nn.MaxPool2d(kernel_size=2, stride=2)  # 池化操作，每次池化减半空间尺寸
+        
+        # 第二个卷积层，输入64个通道，输出128个通道，卷积核大小3x3，步幅1，填充1
+        self.conv2 = nn.Conv2d(64, 128, kernel_size=3, stride=1, padding=1)
+        
+        # 第三个卷积层，输入128个通道，输出1个通道，卷积核大小3x3，步幅1，填充1
+        self.conv3 = nn.Conv2d(128, 1, kernel_size=3, stride=1, padding=1)
+
+    def forward(self, x):
+        x = self.pool(self.conv1(x))  # (1, 9, 256, 256) -> (1, 64, 256, 256) -> (1, 64, 128, 128)
+        x = self.pool(self.conv2(x))  # (1, 64, 128, 128) -> (1, 128, 128, 128) -> (1, 128, 64, 64)
+        x = self.pool(self.conv3(x))  # (1, 128, 64, 64) -> (1, 1, 64, 64) -> (1, 1, 32, 32)
+
+        return x.flatten(0)    # (1024,)
+    
+
+class WaveletTransformer(nn.Module):
+    def __init__(self):
+        super().__init__()
+        # self.ConvNet = ConvNet()
+        self.xfm = DWTForward(J=1, mode='zero', wave='haar').cuda()  # Accepts all wave types available to PyWavelets
+        self.xfm.requires_grad_ = False
+        self.conv = nn.Conv2d(3, 1, kernel_size=3, stride=1, padding=1) 
+        self.pool = nn.AdaptiveAvgPool2d((32, 32))
+
+    # def forward(self, images):
+    #     # images.shapes: [bs, 3, 512, 512]
+    #     batch_size = images.shape[0]    
+    #     # 预先分配输出张量
+    #     coeffs = torch.zeros(batch_size, 1024).cuda()
+    #     for i in range(batch_size):
+    #         # pdb.set_trace()
+    #         wave = self.wavelet(images[i])  
+    #         # coeffs[i] = self.ConvNet(wave)
+    #         coeffs[i] = self.pool(self.conv(wave)).flatten(0)
+    #     # pdb.set_trace()
+    #     return coeffs       # .shape: [bs, 1024]
+
+    # def wavelet(self, image):
+    #     #J为分解的层次数,wave表示使用的变换方法
+    #     _, Yh = self.xfm(image.unsqueeze(0))
+    #     # pdb.set_trace()
+        
+    #     # h = torch.cat((Yh[0][:,:,0,:,:], Yh[0][:,:,1,:,:], Yh[0][:,:,2,:,:]), dim=1)
+    #     h = Yh[0][:, :, 2, :, :]    # .shape: [1, 3, 256, 256]
+
+    #     return h
+
+    def forward(self, images):
+    # 输入 images.shape: [B, 3, 512, 512]
+    
+        # 批量小波变换
+        wave = self.wavelet_batch(images)  # 输出 [B, 3, 256, 256]
+        
+        # 并行卷积和池化
+        coeffs = self.pool(self.conv(wave)).flatten(1)  # 直接处理整个batch
+        
+        return coeffs  # 输出 [B, 1024]
+
+    def wavelet_batch(self, images):
+        # 批量处理版本
+        _, Yh = self.xfm(images)          # 保持输入为完整batch
+        
+        # 直接批量索引操作
+        return Yh[0][:, :, 2, :, :]      # 输出 [B, 3, 256, 256]
+
+
+class MLP(nn.Module):
+    """ Very simple multi-layer perceptron (also called FFN)"""
+
+    def __init__(self, input_dim, hidden_dim, output_dim, num_layers):
+        super().__init__()
+        self.num_layers = num_layers
+        h = [hidden_dim] * (num_layers - 1)
+        self.layers = nn.ModuleList(nn.Linear(n, k) for n, k in zip([input_dim] + h, h + [output_dim]))
+
+    def forward(self, x):
+        for i, layer in enumerate(self.layers):
+            x = F.relu(layer(x)) if i < self.num_layers - 1 else layer(x)
+        return x
+
+
+def _get_clones(module, N):
+    return nn.ModuleList([copy.deepcopy(module) for i in range(N)])
+
+
+class DecoderEmbeddings(nn.Module):
+    def __init__(self, config):
+        super().__init__()
+        self.word_embeddings = nn.Embedding(
+            config.vocab_size, config.hidden_dim, padding_idx=config.PAD_token_id)
+        # self.clip_text_embeddings = FrozenCLIPEmbedder(max_length=10)
+
+        self.position_embeddings = nn.Embedding(
+            config.max_position_embeddings, config.hidden_dim
+        )
+        # self.projection_layer = nn.Linear(768, config.hidden_dim)
+        # self.clip_layernorm = nn.LayerNorm(config.hidden_dim, eps=config.layer_norm_eps)
+
+        self.LayerNorm = torch.nn.LayerNorm(
+            config.hidden_dim, eps=config.layer_norm_eps)
+        self.dropout = nn.Dropout(config.dropout)
+
+    def forward(self, x):
+        # pdb.set_trace()
+        input_shape = x.size()  # x.size(): [bs, 5]
+        # seq_length = input_shape[1]
+        # device = x.device
+
+        position_ids = torch.arange(
+            input_shape[1], dtype=torch.long, device=x.device)
+        position_ids = position_ids.unsqueeze(0).expand(input_shape)
+
+        input_embeds = self.word_embeddings(x)      # .shape: [bs, 5, hidden_dim]
+        # input_embeds = self.clip_text_embeddings(x)     # .shape: [bs, 5, 768]
+        # TODO: init
+        # input_embeds = self.projection_layer(input_embeds) # .shape: [bs, 5, hidden_dim]
+        # input_embeds = self.clip_layernorm(input_embeds)
+
+        position_embeds = self.position_embeddings(position_ids)    # .shape: [bs, 5, hidden_dim]
+        # position_embeds = self.LayerNorm(position_embeds)
+
+        embeddings = input_embeds + position_embeds
+        embeddings = self.LayerNorm(embeddings)
+        embeddings = self.dropout(embeddings)
+
+        return embeddings
+
+
+# 得到下半部分全为0，上半部分全为'-inf'的矩阵
+def generate_square_subsequent_mask(sz):
+    r"""Generate a square mask for the sequence. The masked positions are filled with float('-inf').
+        Unmasked positions are filled with float(0.0).
+    """
+    mask = (torch.triu(torch.ones(sz, sz)) == 1).transpose(0, 1)    # triu: 获取矩阵的上三角部分
+    mask = mask.float().masked_fill(mask == 0, float(
+        '-inf')).masked_fill(mask == 1, float(0.0))     
+    return mask     # .shape: [sz, sz]
+
+
+def build_transformer(config):
+    return Transformer(
+        config,
+        d_model=config.hidden_dim,
+        dropout=config.dropout,
+        nhead=config.nheads,
+        dim_feedforward=config.dim_feedforward,
+        num_encoder_layers=config.enc_layers,
+        num_decoder_layers=config.dec_layers,
+        normalize_before=config.pre_norm,
+        return_intermediate_dec=False,
+        smooth=config.smooth,
+        dynamic_scale=config.dynamic_scale,
+    )
+
+
+def _get_activation_fn(activation):
+    """Return an activation function given a string"""
+    if activation == "relu":
+        return F.relu
+    if activation == "gelu":
+        return F.gelu
+    if activation == "glu":
+        return F.glu
+    raise RuntimeError(F"activation should be relu/gelu, not {activation}.")

FAITH/pytorch_wavelets/.travis.yml

@@ -0,0 +1,14 @@
+language: python
+# Run in a container
+dist: trusty
+sudo: false
+python:
+    - "3.5"
+    - "3.6"
+#Command to install dependencies
+git:
+    depth: 1
+install: 
+    - pip install --quiet -r tests/requirements.txt
+    - pip install .
+script: pytest 

FAITH/pytorch_wavelets/LICENSE

@@ -0,0 +1,28 @@
+This licence applies to any parts of this library which are novel in comparison
+to the original DTCWT MATLAB toolbox written by Nick Kingsbury and Cian
+Shaffrey. See the Provenance section of README.rst file for details on any further
+restrictions of use. If you wish to use the DTCWT, you should read that license as well.
+The DWT sections come under this license.
+
+MIT License
+
+Copyright (c) 2020 Fergal Cotter
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+