FAITH/BatchSampler.py

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()