diff --git a/.gitattributes b/.gitattributes index bed0738c7eeb449bca98b5d2f33c89a1ee56349a..e435d13f030806dd24dbcb3c4f5184c91753a76c 100644 --- a/.gitattributes +++ b/.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 diff --git a/FAITH/.DS_Store b/FAITH/.DS_Store new file mode 100644 index 0000000000000000000000000000000000000000..b995c2ec565934e0767f9e4f47bb75bf4d30db8f Binary files /dev/null and b/FAITH/.DS_Store differ diff --git a/FAITH/BatchSampler.py b/FAITH/BatchSampler.py new file mode 100644 index 0000000000000000000000000000000000000000..7802f327dca3811bd72a55799a10cf87c4e5176e --- /dev/null +++ b/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() \ No newline at end of file diff --git a/FAITH/README.md b/FAITH/README.md new file mode 100644 index 0000000000000000000000000000000000000000..bea74ef45c670074df2d02c68993fc98eb14b73f --- /dev/null +++ b/FAITH/README.md @@ -0,0 +1,205 @@ +{mask.shape}") + for img, pad_img, m in zip(tensor_list, tensor, mask): + pad_img[: img.shape[0], : img.shape[1], : img.shape[2]].copy_(img) + m[: img.shape[1], :img.shape[2]] = False + # print(f"2-----{mask}") + # print(f"2.1----->{mask.shape}") + else: + raise ValueError('not supported') + # print(f"2-----{mask}") + # print(f"2----->{mask.shape}") + return NestedTensor(tensor, mask) + +def is_dist_avail_and_initialized(): + if not dist.is_available(): + return False + if not dist.is_initialized(): + return False + return True + +def get_rank(): + if not is_dist_avail_and_initialized(): + return 0 + return dist.get_rank() + +def is_main_process(): + return get_rank() == 0 diff --git a/FAITH/train.py b/FAITH/train.py new file mode 100644 index 0000000000000000000000000000000000000000..6c60be9631ddb0547d2d20c83a9b2ccc47dd3d49 --- /dev/null +++ b/FAITH/train.py @@ -0,0 +1,564 @@ +import os +# import cv2 +# import torch.nn.functional as F +# os.environ['CUDA_VISIBLE_DEVICES'] = '0,2,6,7' +from pathlib import Path +import pdb +import sys +import argparse +import time +import torch +import numpy as np +import random +import logging +from types import MethodType +import pandas as pd +import warnings +warnings.filterwarnings('ignore') + +from BatchSampler import BalancedBatchSampler +from datasets.dataset import SeqDeepFakeDataset +from tools.utils import AverageMeter, NestedTensor + +from tools.env import init_dist +import torch.multiprocessing as mp +import torch.distributed as dist +import wandb +# os.environ['WANDB_DISABLED'] = 'true' +from tqdm import tqdm +from torch.utils.tensorboard import SummaryWriter +import numpy as np + +sys.path.append(str(Path(__file__).resolve().parents[1])) + +from models.configuration import Config +from models import SeqFakeFormer +import math + +from sam.sam import SAM + +def setlogger(log_file): + filehandler = logging.FileHandler(log_file) + streamhandler = logging.StreamHandler() + + logger = logging.getLogger('') + logger.setLevel(logging.INFO) + logger.addHandler(filehandler) + logger.addHandler(streamhandler) + + def epochInfo(self, set, idx, acc_fixed, acc_adaptive, acc_full): + self.info('{set}-{idx:d} epoch | acc_fixed:{acc_fixed:.2f}% | acc_adaptive:{acc_adaptive:.2f}% | acc_full:{acc_full:.2f}%'.format( + set=set, + idx=idx, + acc_fixed=acc_fixed, + acc_adaptive=acc_adaptive, + acc_full = acc_full + )) + + logger.epochInfo = MethodType(epochInfo, logger) + + return logger + + +def set_random_seed(seed, deterministic=False): + """Set random seed. + Args: + seed (int): Seed to be used. + deterministic (bool): Whether to set the deterministic option for + CUDNN backend, i.e., set `torch.backends.cudnn.deterministic` + to True and `torch.backends.cudnn.benchmark` to False. + Default: False. + """ + random.seed(seed) + np.random.seed(seed) + torch.manual_seed(seed) + torch.cuda.manual_seed(seed) + torch.cuda.manual_seed_all(seed) + os.environ['PYTHONHASHSEED'] = str(seed) + if deterministic: + torch.backends.cudnn.deterministic = True + torch.backends.cudnn.benchmark = False + + +def mkdir(path): + if not os.path.exists(path): + os.makedirs(path, exist_ok = True) + + +def preset_model(args, cfg, model, logger, sum_steps): + param_dicts = [ + {"params": [p for n, p in model.named_parameters() if "backbone" not in n and p.requires_grad]}, + { + "params": [p for n, p in model.named_parameters() if "backbone" in n and p.requires_grad], + "lr": cfg.lr_backbone, + }, + ] + + # optimizer = torch.optim.AdamW( + # param_dicts, lr=cfg.lr, weight_decay=cfg.weight_decay) + + # SAM optimizer + base_optimizer = torch.optim.AdamW + optimizer = SAM(param_dicts, base_optimizer, lr=cfg.lr, weight_decay=cfg.weight_decay) + + if cfg.warmup: + # lr_scaler = 5 * cfg.lr_backbone / cfg.lr # lr: 2e-3 -> 5e-4 + # warm_up_with_multistep_lr = lambda epoch: (epoch+1) / cfg.warmup_epochs if epoch < cfg.warmup_epochs else lr_scaler + 0.5 * (1 - lr_scaler) * (1 + math.cos((epoch - cfg.warmup_epochs) * math.pi / (cfg.epochs - cfg.warmup_epochs))) + warm_up_with_multistep_lr = lambda epoch: (epoch+1) / cfg.warmup_epochs if epoch < cfg.warmup_epochs else 0.5**len([m for m in cfg.lr_milestones if m <= epoch]) + scheduler = torch.optim.lr_scheduler.LambdaLR(optimizer, lr_lambda=warm_up_with_multistep_lr) + else: + # scheduler = torch.optim.lr_scheduler.StepLR(optimizer, cfg.lr_drop) + scheduler = torch.optim.lr_scheduler.StepLR(optimizer.base_optimizer, cfg.lr_drop) + + if args.resume: + checkpoint = torch.load(args.resume, map_location='cpu') + model.load_state_dict(checkpoint['state_dict']) + model.cuda(args.gpu) + model = torch.nn.parallel.DistributedDataParallel(model, device_ids=[args.gpu]) + start_epoch = checkpoint['epoch'] + + if args.log: + logger.info(f'Loading model from {args.resume}...') + logger.info(f'start_epoch: {start_epoch}...') + + optimizer.load_state_dict(checkpoint['optimizer']) + for state in optimizer.state.values(): + for k, v in state.items(): + if torch.is_tensor(v): + state[k] = v.cuda(args.gpu) + + scheduler.load_state_dict(checkpoint['scheduler']) + else: + if args.log: + logger.info('Create new model') + + model.cuda(args.gpu) + model = torch.nn.parallel.DistributedDataParallel(model, device_ids=[args.gpu]) + start_epoch = 0 + + return model, optimizer, start_epoch, scheduler + +# def read_csv(field, file): +# info = pd.read_csv(file) +# image_list = info[field[0]].tolist() +# score_list = info[field[1]].tolist() +# return image_list, score_list + + + +# def evalute(cfg, val_dataloader, model): +# # switch model to evaluation mode +# model.eval() +# criterion = torch.nn.CrossEntropyLoss(ignore_index=cfg.PAD_token_id) +# criterion.eval() +# total = len(val_dataloader) + +# with torch.no_grad(): +# validation_loss = 0.0 + +# for steps, (images, masks, caps, cap_masks) in enumerate(tqdm(val_dataloader)): + +# samples = NestedTensor(images, masks).to(0) +# caps = caps.cuda() +# cap_masks = cap_masks.cuda() + +# input_caps = caps[:, :-1] +# pad_token_input_caps = cfg.PAD_token_id*torch.ones_like(input_caps) +# input_caps = torch.where(input_caps==cfg.EOS_token_id, pad_token_input_caps, input_caps) +# input_cap_masks = input_caps==cfg.PAD_token_id + +# outputs = model(samples, input_caps, input_cap_masks) +# loss = criterion(outputs.permute(0, 2, 1), caps[:, 1:]) + + +# validation_loss += loss.item() + +# loss = validation_loss / total + +# return loss + + +def create_caption_and_mask(cfg): + caption_template = cfg.PAD_token_id*torch.ones((1, cfg.max_position_embeddings), dtype=torch.long).cuda() + mask_template = torch.ones((1, cfg.max_position_embeddings), dtype=torch.bool).cuda() + + caption_template[:, 0] = cfg.SOS_token_id + mask_template[:, 0] = False + + return caption_template, mask_template + + +def evalute_transformer(cfg, val_dataloader, model, f_path): + # switch model to evaluation mode + model.eval() + + with torch.no_grad(): + running_corrects_fixed = 0.0 + epoch_size_fixed = 0.0 + + running_corrects_adaptive = 0.0 + epoch_size_adaptive = 0.0 + + running_corrects_full = 0.0 + epoch_size_full = 0.0 + + f = open(os.path.join(f_path, "log_val_output.txt"), 'w') + + for steps, (image, labels, img_path) in enumerate(tqdm(val_dataloader)): + caption, cap_mask = create_caption_and_mask(cfg) + image, labels = image.cuda(), labels.long().cuda() + for i in range(cfg.max_position_embeddings - 1): + + predictions = model(image, caption, cap_mask) + predictions = predictions[:, i, :] + predicted_id = torch.argmax(predictions, axis=-1) + # FIXME: 替换为CLIP Text Encoder后模型倾向于在第一个或第二个位置预测EOS_token + if predicted_id[0] == cfg.EOS_token_id: + caption = caption[:, 1:] + zero = torch.zeros_like(caption) + caption = torch.where(caption==cfg.PAD_token_id, zero, caption) + break + + caption[:, i+1] = predicted_id[0] + cap_mask[:, i+1] = False + + if caption.shape[1] == cfg.max_position_embeddings: + caption = caption[:, 1:] + + running_corrects_fixed += torch.sum(caption.cpu() == labels.data.cpu()) + epoch_size_fixed += image.size(0)*labels.shape[1] + + cmp_len = max(len(torch.where(labels[0]>0)[0]), len(torch.where(caption[0]>0)[0])) + if cmp_len == 0: + running_corrects_adaptive += 1 + cmp_len = 1 + else: + running_corrects_adaptive += torch.sum(caption[:,:cmp_len].cpu() == labels[:,:cmp_len].data.cpu()) + epoch_size_adaptive += image.size(0) * cmp_len + + if torch.equal(caption.cpu(), labels.data.cpu()): + running_corrects_full += 1 + epoch_size_full += 1 + + f.write(f"caption: {caption.tolist()[0]}, label: {labels.tolist()[0]}") + f.write("\n") + + ACC_fixed = running_corrects_fixed.double() / epoch_size_fixed * 100 + ACC_adaptive = running_corrects_adaptive.double() / epoch_size_adaptive * 100 + ACC_full = running_corrects_full / epoch_size_full * 100 + + f.write(f"fixed_acc: {ACC_fixed: .2f}%; adaptive_acc: {ACC_adaptive: .2f}%; full_acc: {ACC_full: .2f}%") + f.close() + + return ACC_fixed, ACC_adaptive, ACC_full + + +def train(args, cfg, train_dataloader, train_sampler, val_dataloader, model, summary_writer, logger, log_dir): + max_epochs = cfg.epochs + max_iters = len(train_dataloader) + sum_steps = max_epochs*max_iters + + model, optimizer, start_epoch, scheduler = preset_model(args, cfg, model, logger, sum_steps) + + criterion = torch.nn.CrossEntropyLoss(ignore_index = cfg.PAD_token_id).cuda(args.gpu) + + global_step = start_epoch*len(train_dataloader) + if args.log: + logger.info(f'global_step: {global_step}...') + + # best_val_acc_fixed = 0 + # best_val_acc_adaptive = 0 + + for current_epoch in range(start_epoch, max_epochs): + + train_sampler.set_epoch(current_epoch) + loss_logger = AverageMeter() + # ---------- + # Training + # ---------- + current_lr = optimizer.state_dict()['param_groups'][0]['lr'] + if args.log: + logger.info(f'############# Starting Epoch {current_epoch} | LR: {current_lr} #############') + + model.train() + criterion.train() + + if args.log: + train_dataloader = tqdm(train_dataloader, dynamic_ncols=True) + for steps, (images, masks, caps, cap_masks) in enumerate(train_dataloader): # masks.shape: [bs, 512, 512] + current_lr = optimizer.state_dict()['param_groups'][0]['lr'] + + samples = NestedTensor(images, masks).to(args.gpu) + caps = caps.cuda(args.gpu) # [bs, max_position_embeddings + 1] + # cap_masks = cap_masks.cuda(args.gpu) + + input_caps = caps[:, :-1] + pad_token_input_caps = cfg.PAD_token_id * torch.ones_like(input_caps) + input_caps = torch.where(input_caps == cfg.EOS_token_id, pad_token_input_caps, input_caps) # 将EOS替换为PAD + input_cap_masks = input_caps == cfg.PAD_token_id + + outputs = model(samples, input_caps, input_cap_masks) # .shape: [bs, max_position_embeddings, vocab_size] + # pdb.set_trace() + # for bs in range(attn_out_weights_.shape[0]): + # for attr in range(5): + # pdb.set_trace() + # attn_out_weights = attn_out_weights_[bs][0][attr].view(32, 32) + # attn_out_weights = (attn_out_weights - attn_out_weights.min()) / (attn_out_weights.max() - attn_out_weights.min()) + # attn_out_weights = F.interpolate(attn_out_weights.unsqueeze(0).unsqueeze(0), size=[512, 512],mode='bilinear').detach().cpu() + # attn_out_weights = np.uint8(255 * attn_out_weights)[0][0] # .shape: [512, 512] + + # normed_mask = cv2.applyColorMap(attn_out_weights, cv2.COLORMAP_JET) # .shape: [512, 512, 3] + + # print(image_path[bs], input_caps[bs].detach().cpu(), caps[bs, 1:]) + # a = cv2.resize(cv2.imread(image_path[bs]), (512, 512)) # .shape: [512, 512, 3] + # normed_mask = cv2.addWeighted(a, 0.6, normed_mask, 0.4, 0) + # cv2.imwrite("./attn_maps/test.png", normed_mask) + # raise + + # outputs.permute(0, 2, 1).shape: [bs, vocab_size, max_position_embeddings] + # caps[:, 1:].shape: [bs, max_position_embeddings] + loss = criterion(outputs.permute(0, 2, 1), caps[:, 1:]) + # print(outputs) + if not math.isfinite(loss): + print(f'Loss is {loss}, stopping training') + sys.exit(1) + + # SAM Optimizer + with model.no_sync(): + loss.backward() + if cfg.clip_max_norm > 0: # 梯度剪裁（防止梯度爆炸）：设定阈值，使得grad = min(grad, threshold) + torch.nn.utils.clip_grad_norm_(model.parameters(), cfg.clip_max_norm) + optimizer.first_step(zero_grad=True) + + outputs = model(samples, input_caps, input_cap_masks) # .shape: [bs, max_position_embeddings, vocab_size] + criterion(outputs.permute(0, 2, 1), caps[:, 1:]).backward() + if cfg.clip_max_norm > 0: # 梯度剪裁（防止梯度爆炸）：设定阈值，使得grad = min(grad, threshold) + torch.nn.utils.clip_grad_norm_(model.parameters(), cfg.clip_max_norm) + optimizer.second_step(zero_grad=True) + + + # optimizer.zero_grad() + # loss.backward() + # if cfg.clip_max_norm > 0: # 梯度剪裁（防止梯度爆炸）：设定阈值，使得grad = min(grad, threshold) + # torch.nn.utils.clip_grad_norm_(model.parameters(), cfg.clip_max_norm) + # optimizer.step() + + loss_logger.update(loss.item(), images.size(0)) + + global_step+=1 + + #============ tensorboard train log info ============# + if args.log: + lossinfo = { + 'Train_Loss': loss.item(), + 'Train_Loss_avg': loss_logger.avg, + } + for tag, value in lossinfo.items(): + summary_writer.add_scalar(tag, value, global_step) + + #============ print the train log info ============# + train_dataloader.set_description( + 'epoch: {epoch} | lr: {lr:.5f} | loss: {loss:.5f} '.format( + epoch=current_epoch, + loss=loss_logger.avg, + lr = current_lr + ) + ) + + if dist.get_rank() == 0: + wandb.log({"idx": global_step, "loss": loss_logger.avg}) + + if dist.get_rank() == 0: + wandb.log({"epoch": current_epoch, "lr": current_lr}) + + scheduler.step(current_epoch) + #============ train model save ============# + if args.model_save_epoch is not None: + if (current_epoch % args.model_save_epoch == 0): + if args.log: + model_save_path = os.path.join(log_dir, 'snapshots') + mkdir(model_save_path) + torch.save({ + 'epoch': current_epoch+1, + 'state_dict': model.module.state_dict(), + 'optimizer' : optimizer.state_dict(), + 'scheduler' : scheduler.state_dict(), + }, os.path.join(model_save_path, "model-{}.pt".format(current_epoch))) + # ---------- + # Validation + # ---------- + if current_epoch % args.val_epoch == 0: + if args.log: + model_save_path = os.path.join(log_dir, 'snapshots') + mkdir(model_save_path) + ACC_fixed, ACC_adaptive, ACC_full = evalute_transformer(cfg, val_dataloader, model.module, model_save_path) + print(f"Validation epoch: {current_epoch}, fixed_acc: {ACC_fixed}, adaptive_acc: {ACC_adaptive}, full_acc: {ACC_full}") + #============ print the val log info ============# + logger.epochInfo('Validation', current_epoch, ACC_fixed, ACC_adaptive, ACC_full) + + if dist.get_rank() == 0: + wandb.log({"epoch": current_epoch, "val_fixed_acc": ACC_fixed, "val_adaptive_acc": ACC_adaptive, "val_full_acc": ACC_full}) + + #============ tensorboard val log info ============# + valinfo = { + 'Val_ACC_fixed': ACC_fixed, + 'Val_ACC_adaptive': ACC_adaptive, + } + for tag, value in valinfo.items(): + summary_writer.add_scalar(tag, value, current_epoch) + + # if ACC_fixed >= best_val_acc_fixed: + # best_val_acc_fixed = ACC_fixed + # torch.save({ + # 'best_val_acc_fixed': best_val_acc_fixed, + # 'best_state_dict_fixed': model.module.state_dict(), + # }, os.path.join(model_save_path, "best_model_fixed.pt")) + + # if ACC_adaptive >= best_val_acc_adaptive: + # best_val_acc_adaptive = ACC_adaptive + # torch.save({ + # 'best_val_acc_adaptive': best_val_acc_adaptive, + # 'best_state_dict_adaptive': model.module.state_dict(), + # }, os.path.join(model_save_path, "best_model_adaptive.pt")) + + +def main_worker(gpu, args, cfg): + """ + parameter: + gpu: 进程id号(从0到总进程数目-1) + """ + + + if gpu is not None: + args.gpu = gpu + + init_dist(args) + + if dist.get_rank() == 0: + # start a new wandb run to track this script + wandb.init( + # set the wandb project where this run will be logged + project="Sequential-Detection-Model-on-SEED", + name=args.tag, + + # track hyperparameters and run metadata + config={ + "learning_rate": cfg.lr, + "architecture": "SeqFakeFormer", + # "dataset": "SEED", + "epochs": cfg.epochs, + "seed": args.manual_seed, + } + ) + # else: + # time.sleep(15) + + log_dir = os.path.join(args.results_dir, cfg.backbone, args.dataset_name, args.log_name, args.tag) + os.makedirs(log_dir, exist_ok=True) + log_file = os.path.join(log_dir, 'log.txt') + logger = setlogger(log_file) + + if args.log: + summary_writer = SummaryWriter(log_dir) + else: + summary_writer = None + + model = SeqFakeFormer.build_model(cfg) + + # TODO: check its performance + model = torch.nn.SyncBatchNorm.convert_sync_batchnorm(model).cuda() + + if args.log: + logger.info('******************************') + logger.info(args) + logger.info('******************************') + logger.info(cfg.__dict__) + logger.info('******************************') + logger.info(str(model)) + logger.info('******************************') + + batch_size = cfg.batch_size + + train_dataset = SeqDeepFakeDataset( + cfg=cfg, + mode="train", + data_root=args.data_dir, + dataset_name=args.dataset_name + ) + val_dataset = SeqDeepFakeDataset( + cfg=cfg, + mode="val", + data_root=args.data_dir, + dataset_name=args.dataset_name + ) + if args.log: + print('train_dataset_length:', len(train_dataset)) + + # train_sampler = torch.utils.data.distributed.DistributedSampler( + # train_dataset, num_replicas=args.world_size, rank=args.rank) + # train_sampler = None + + train_sampler = BalancedBatchSampler( + list(range(0, 16000)), + list(range(16000, 32000)), + list(range(32000, 48000)), + list(range(48000, 64000)), + list(range(64000, 80000)), + 40, + 666, + rank = args.rank, + world_size=args.world_size + ) + train_dataloader = torch.utils.data.DataLoader( + train_dataset, batch_sampler=train_sampler) + + if args.log: + print('val_dataset_length:',len(val_dataset)) + val_dataloader = torch.utils.data.DataLoader(val_dataset, batch_size=1, shuffle=True) + train(args, cfg, train_dataloader, train_sampler, val_dataloader, model, summary_writer, logger, log_dir) + + if dist.get_rank() == 0: + wandb.finish() + + +if __name__ == '__main__': + + parser = argparse.ArgumentParser() + arg = parser.add_argument + + arg('--cfg', type=str, default=None, help='path of config json file') + arg('--tag', default="seqdeepfake", help='tag of experiment') + arg('--results_dir', type=str, default='result') + arg('--data_dir', type=str, default=None) + arg('--dataset_name', type=str, default=None) + arg('--resume', type=str, default=None) + arg('--log_name', '-l', type=str) + + arg('--model_save_epoch', type=int, default=None) + arg('--val_epoch', type=int, default=1) + arg('--manual_seed', type=int, default=777) + + arg('--rank', default=-1, type=int, + help='node rank for distributed training') + arg('--world_size', default=1, type=int, + help='world size for distributed training') + arg('--dist-url', default='tcp://127.0.0.1:23459', type=str, + help='url used to set up distributed training') + arg('--dist-backend', default='nccl', type=str, + help='distributed backend') + arg('--launcher', choices=['none', 'pytorch', 'slurm', 'mpi'], default='none', + help='job launcher') + + args = parser.parse_args() + set_random_seed(args.manual_seed) + cfg = Config(args.cfg) + + if args.launcher == 'none': + args.launcher = 'pytorch' + main_worker(0, args, cfg) + else: + # 统计能用的GPU数量（决定了要开几个进程，也被称为world size） + ngpus_per_node = torch.cuda.device_count() + args.ngpus_per_node = ngpus_per_node + # 多进程启动 + mp.spawn(main_worker, nprocs=ngpus_per_node, args=(args, cfg)) diff --git a/FAITH/train.sh b/FAITH/train.sh new file mode 100644 index 0000000000000000000000000000000000000000..b5eb1c94097aac1afcc9d0d3244a9888648c42dc --- /dev/null +++ b/FAITH/train.sh @@ -0,0 +1,27 @@ +LOGNAME="LOGNAME" +CONFIG='./configs/r50.json' +DATA_DIR='data' +DATASET_NAME='SD3' +RESULTS_DIR='./results' + +HOST='127.0.0.1' +PORT='12145' +NUM_GPU=3 + +# CUDA_VISIBLE_DEVICES=1,2 \ +python train.py \ +--log_name ${LOGNAME} \ +--cfg ${CONFIG} \ +--data_dir ${DATA_DIR} \ +--dataset_name ${DATASET_NAME} \ +--val_epoch 2 \ +--model_save_epoch 2 \ +--manual_seed 10371115 \ +--dist-url tcp://${HOST}:${PORT} \ +--world_size $NUM_GPU \ +--rank 0 \ +--launcher pytorch \ +--results_dir ${RESULTS_DIR} \ +--tag "tag_name" \ +# --resume ./results/resnet50/SD3/with_CLIP_Text_Encoder/seqfakeformer_with_CLIPTextEncoder_2/snapshots/model-42.pt +# --resume ./results/resnet50/SD3/pretrained-r50-c_dim512_finetuned/seqfakeformer_finetuned/snapshots/model-104.pt \ No newline at end of file diff --git a/FAITH/train_slurm.sh b/FAITH/train_slurm.sh new file mode 100644 index 0000000000000000000000000000000000000000..bc2e826bcb6420addc955fe75b58076610a96bb9 --- /dev/null +++ b/FAITH/train_slurm.sh @@ -0,0 +1,28 @@ +LOGNAME="pretrained-r50-c" +CONFIG='./configs/r50.json' +DATA_DIR='data' +DATASET_NAME='SD3' +RESULTS_DIR='./results' + +HOST='127.0.0.1' +PORT='12345' +NUM_GPU=1 + +PARTITION='RTX3090' +NODE='3' + +srun -p ${PARTITION} --mpi=pmi2 --gres=gpu:$NUM_GPU --ntasks-per-node=${NUM_GPU} -n1 -w ${NODE}\ + --job-name=seqdeepfake --kill-on-bad-exit=1 --cpus-per-task=4 \ + python train.py \ + --log_name ${LOGNAME} \ + --cfg ${CONFIG} \ + --data_dir ${DATA_DIR} \ + --dataset_name ${DATASET_NAME} \ + --val_epoch 10 \ + --model_save_epoch 10 \ + --manual_seed 777 \ + --dist-url tcp://${HOST}:${PORT} \ + --world_size ${NUM_GPU} \ + --rank 0 \ + --launcher pytorch \ + --results_dir ${RESULTS_DIR} diff --git a/FAITH/util_z/calculate_acc.py b/FAITH/util_z/calculate_acc.py new file mode 100644 index 0000000000000000000000000000000000000000..ad80036b043c30d2373d4d8407a1e00d77feaaea --- /dev/null +++ b/FAITH/util_z/calculate_acc.py @@ -0,0 +1,86 @@ +def get_nonzero_idx(nums: list): + for i in range(len(nums) - 1, -1, -1): + if nums[i] > 0: + return i + + return -1 + + + +fixed_acc_numerator = 0 +fixed_acc_denominator = 0 + +adaptive_acc_numerator = 0 +adaptive_acc_denominator = 0 + +full_acc_numerator = 0 +full_acc_denominator = 0 + +test_set_length = 0 + +test_type = "fixed" + +with open(f"../test_label_and_acc/before_finetune/output.txt", "r") as f: + for line in f: + caption = [] + label = [] + + cap_idx = line.find("caption: [[") + # print(line[cap_idx: cap_idx + 10]) + if cap_idx != -1: + idx = cap_idx + len("caption: [[") + while line[idx] != "]": + if line[idx].isdigit(): + caption.append(int(line[idx])) + if len(caption) >= 4: + break + idx += 1 + else: + break + + label_idx = line.find("label: [[") + # print(line[cap_idx: cap_idx + 10]) + if label_idx != -1: + idx = label_idx + len("label: [[") + while line[idx] != "]": + if line[idx].isdigit(): + label.append(int(line[idx])) + if len(label) >= 4: + break + idx += 1 + else: + break + + # print(f"caption: {caption}, label: {label}") + test_set_length += 1 + + assert len(caption) == len(label) + + fixed_acc_numerator += sum(x == y for x, y in zip(caption, label)) + fixed_acc_denominator += len(caption) + + adaptive_sample_length = max(get_nonzero_idx(caption), get_nonzero_idx(label)) + # print(adaptive_sample_length) + if adaptive_sample_length == -1: + adaptive_acc_numerator += 1 + adaptive_acc_denominator += 1 + else: + adaptive_acc_numerator += sum(x == y for x, y in zip(caption[:adaptive_sample_length + 1], label[: adaptive_sample_length + 1])) + adaptive_acc_denominator += adaptive_sample_length + 1 + + if caption == label: + # print(caption, label) + full_acc_numerator += 1 + full_acc_denominator += 1 + + +print(f"test_set_length: {test_set_length}") + +print(f"fixed_acc_numerator: {fixed_acc_numerator}, fixed_acc_denominator: {fixed_acc_denominator}") +print(f"fixed_acc: {fixed_acc_numerator / fixed_acc_denominator * 100 : .2f}%") + +print(f"adaptive_acc_numerator: {adaptive_acc_numerator}, adaptive_acc_denominator: {adaptive_acc_denominator}") +print(f"adaptive_acc: {adaptive_acc_numerator / adaptive_acc_denominator * 100 : .2f}%") + +print(f"full_acc_numerator: {full_acc_numerator}, full_acc_denominator: {full_acc_denominator}") +print(f"full_acc: {full_acc_numerator / full_acc_denominator * 100 : .2f}%") \ No newline at end of file diff --git a/FAITH/util_z/calculate_acc_at_specific_length.py b/FAITH/util_z/calculate_acc_at_specific_length.py new file mode 100644 index 0000000000000000000000000000000000000000..8cf4bf6e79358729def322eb58338db16e68ee04 --- /dev/null +++ b/FAITH/util_z/calculate_acc_at_specific_length.py @@ -0,0 +1,102 @@ +def get_nonzero_idx(nums: list): + for i in range(len(nums) - 1, -1, -1): + if nums[i] > 0: + return i + + return -1 + + +# test_type = "fixed" + +caption_different_length = [[], [], [], [], []] +label_different_length = [[], [], [], [], []] + +with open(f"../results/resnet50/SD3/uniform_SD3_frequency/baseline_2/test_result/model-96.txt", "r") as f: + for line in f: + caption = [] + label = [] + + cap_idx = line.find("caption: [[") + # print(line[cap_idx: cap_idx + 10]) + if cap_idx != -1: + idx = cap_idx + len("caption: [[") + while line[idx] != "]": + if line[idx].isdigit(): + caption.append(int(line[idx])) + if len(caption) >= 4: + break + idx += 1 + else: + break + + label_idx = line.find("label: [[") + # print(line[cap_idx: cap_idx + 10]) + if label_idx != -1: + idx = label_idx + len("label: [[") + while line[idx] != "]": + if line[idx].isdigit(): + label.append(int(line[idx])) + if len(label) >= 4: + break + idx += 1 + else: + break + + idx = get_nonzero_idx(label) + 1 + caption_different_length[idx].append(caption) + label_different_length[idx].append(label) + + +# for i in range(5): +# print(len(caption_different_length[i])) +# print(len(label_different_length[i])) + +# print(caption_different_length[-1][-3]) +# print(label_different_length[1]) + +for i in range(5): + fixed_acc_numerator = 0 + fixed_acc_denominator = 0 + + adaptive_acc_numerator = 0 + adaptive_acc_denominator = 0 + + full_acc_numerator = 0 + full_acc_denominator = 0 + + count_length = 0 + + for (caption, label) in zip(caption_different_length[i], label_different_length[i]): + assert len(caption) == len(label) + count_length += 1 + + fixed_acc_numerator += sum(x == y for x, y in zip(caption, label)) + fixed_acc_denominator += len(caption) + + adaptive_sample_length = max(get_nonzero_idx(caption), get_nonzero_idx(label)) + # print(adaptive_sample_length) + if adaptive_sample_length == -1: + adaptive_acc_numerator += 1 + adaptive_acc_denominator += 1 + else: + adaptive_acc_numerator += sum(x == y for x, y in zip(caption[:adaptive_sample_length + 1], label[: adaptive_sample_length + 1])) + adaptive_acc_denominator += adaptive_sample_length + 1 + + if caption == label: + # print(caption, label) + full_acc_numerator += 1 + full_acc_denominator += 1 + + print(f"length: {i}") + print(f"count: {count_length}") + + print(f"fixed_acc_numerator: {fixed_acc_numerator}, fixed_acc_denominator: {fixed_acc_denominator}") + print(f"fixed_acc: {fixed_acc_numerator / fixed_acc_denominator * 100 : .2f}%") + + print(f"adaptive_acc_numerator: {adaptive_acc_numerator}, adaptive_acc_denominator: {adaptive_acc_denominator}") + print(f"adaptive_acc: {adaptive_acc_numerator / adaptive_acc_denominator * 100 : .2f}%") + + print(f"full_acc_numerator: {full_acc_numerator}, full_acc_denominator: {full_acc_denominator}") + print(f"full_acc: {full_acc_numerator / full_acc_denominator * 100 : .2f}%") + + print("------------------------------------------") \ No newline at end of file diff --git a/FAITH/util_z/dataset_to_txt.py b/FAITH/util_z/dataset_to_txt.py new file mode 100644 index 0000000000000000000000000000000000000000..8d9d712c668911bc83b711e70c13a21b7ad7575f --- /dev/null +++ b/FAITH/util_z/dataset_to_txt.py @@ -0,0 +1,51 @@ +import os +import json + + +# DiffSeq -> SeqFakeFormer +# MAPPING = { +# 1: 2, # eye +# 2: 4, # lip +# 3: 5, # hair +# 4: 6, # glasses +# 5: 7, # hat +# 6: 3 # eyebrow +# } +MAX_LABEL_LENGTH = 4 + + +with open("../data/SD3/all.txt", "w") as f_w: +# if True: + + idx_list = range(100000) + # idx_list = [9] + + for idx in idx_list: + file_path = f"../../../ultraedit/UltraEdit/sequential_deepfake_dataset/{idx}/config.jsonl" + + if os.path.exists(file_path): + with open(file_path, "r") as f_r: + contents = json.loads(f_r.readline()) + sequence = contents["sequence"] + model_sequence = contents["model_sequence"] + + image_path = file_path.replace("config.jsonl", f"{'_'.join([str(x) + str(y) for x, y in zip(sequence, model_sequence)])}.jpg") + + assert len(sequence) <= MAX_LABEL_LENGTH, "AssertError: Need to modify the label" + # sequence = [MAPPING[x] for x in sequence] + for _ in range(len(sequence), MAX_LABEL_LENGTH): + sequence.append(0) + + f_w.write(image_path + ";" + str(sequence)) + f_w.write("\n") + + else: + if 0 <= idx < 30000: + image_path = f"../../../ultraedit/UltraEdit/origin_dataset/CelebAMask-HQ/CelebA-HQ-img/{idx}.jpg" + elif 30000 <= idx < 100000: + image_path = f"../../../ultraedit/UltraEdit/origin_dataset/FFHQ/FFHQ/{str(idx - 30000).zfill(5)}.png" + else: + raise NotImplementedError + + f_w.write(image_path + ";" + str([0] * MAX_LABEL_LENGTH)) + f_w.write("\n") \ No newline at end of file diff --git a/FAITH/util_z/split_by_length.py b/FAITH/util_z/split_by_length.py new file mode 100644 index 0000000000000000000000000000000000000000..ee3895c51e45d4372a6e6a2469bd5d65d1e7dc9a --- /dev/null +++ b/FAITH/util_z/split_by_length.py @@ -0,0 +1,119 @@ +# f_0 = open("../data/SD3/0.txt", "w") +# f_1 = open("../data/SD3/1.txt", "w") +# f_2 = open("../data/SD3/0.txt", "w") +# f_3 = open("../data/SD3/0.txt", "w") +# f_4 = open("../data/SD3/0.txt", "w") + +import os +import json +import random + + +# DiffSeq -> SeqFakeFormer +# MAPPING = { +# 1: 2, # eye +# 2: 4, # lip +# 3: 5, # hair +# 4: 6, # glasses +# 5: 7, # hat +# 6: 3 # eyebrow +# } + +MAX_LABEL_LENGTH = 4 +length2file = [[], [], [], [], []] + +if True: + idx_list = range(100000) + # idx_list = [9] + + for idx in idx_list: + file_path = f"../../../ultraedit/UltraEdit/sequential_deepfake_dataset/{idx}/config.jsonl" + + if os.path.exists(file_path): + with open(file_path, "r") as f_r: + contents = json.loads(f_r.readline()) + sequence = contents["sequence"] + # model_sequence = contents["model_sequence"] + length2file[len(sequence)].append(idx) + + # image_path = file_path.replace("config.jsonl", f"{'_'.join([str(x) + str(y) for x, y in zip(sequence, model_sequence)])}.jpg") + + # assert len(sequence) <= MAX_LABEL_LENGTH, "AssertError: Need to modify the label" + # # sequence = [MAPPING[x] for x in sequence] + # for _ in range(len(sequence), MAX_LABEL_LENGTH): + # sequence.append(0) + + # else: + # if 0 <= idx < 30000: + # image_path = f"../../../ultraedit/UltraEdit/origin_dataset/CelebAMask-HQ/CelebA-HQ-img/{idx}.jpg" + # elif 30000 <= idx < 100000: + # image_path = f"../../../ultraedit/UltraEdit/origin_dataset/FFHQ/FFHQ/{str(idx - 30000).zfill(5)}.png" + # else: + # raise NotImplementedError + # length2file[0].append(idx) + +sampled_1 = random.sample(length2file[1], 20000) +sampled_2 = random.sample(length2file[2], 20000) +sampled_3 = random.sample(length2file[3], 20000) +sampled_4 = random.sample(length2file[4], 20000) +sampled_0 = [] + +sampled_1.sort() +sampled_2.sort() +sampled_3.sort() +sampled_4.sort() + +for i in range(100000): + if i not in sampled_1 + sampled_2 + sampled_3 + sampled_4: + sampled_0.append(i) + +# print(sampled_0) + +f_0 = open("../data/SD3/0.txt", "w") +f_1 = open("../data/SD3/1.txt", "w") +f_2 = open("../data/SD3/2.txt", "w") +f_3 = open("../data/SD3/3.txt", "w") +f_4 = open("../data/SD3/4.txt", "w") + + +for idx in sampled_1 + sampled_2 + sampled_3 + sampled_4: + file_path = f"../../../ultraedit/UltraEdit/sequential_deepfake_dataset/{idx}/config.jsonl" + + with open(file_path, "r") as f_r: + contents = json.loads(f_r.readline()) + sequence = contents["sequence"] + model_sequence = contents["model_sequence"] + + length = len(sequence) + + image_path = file_path.replace("config.jsonl", f"{'_'.join([str(x) + str(y) for x, y in zip(sequence, model_sequence)])}.jpg") + + assert len(sequence) <= MAX_LABEL_LENGTH, "AssertError: Need to modify the label" + # sequence = [MAPPING[x] for x in sequence] + for _ in range(len(sequence), MAX_LABEL_LENGTH): + sequence.append(0) + + if length == 1: + f_1.write(image_path + ";" + str(sequence)) + f_1.write("\n") + elif length == 2: + f_2.write(image_path + ";" + str(sequence)) + f_2.write("\n") + elif length == 3: + f_3.write(image_path + ";" + str(sequence)) + f_3.write("\n") + elif length == 4: + f_4.write(image_path + ";" + str(sequence)) + f_4.write("\n") + + +for idx in sampled_0: + if 0 <= idx < 30000: + image_path = f"../../../ultraedit/UltraEdit/origin_dataset/CelebAMask-HQ/CelebA-HQ-img/{idx}.jpg" + elif 30000 <= idx < 100000: + image_path = f"../../../ultraedit/UltraEdit/origin_dataset/FFHQ/FFHQ/{str(idx - 30000).zfill(5)}.png" + else: + raise NotImplementedError + + f_0.write(image_path + ";" + str([0] * MAX_LABEL_LENGTH)) + f_0.write("\n") \ No newline at end of file diff --git a/FAITH/util_z/split_train_val_test.py b/FAITH/util_z/split_train_val_test.py new file mode 100644 index 0000000000000000000000000000000000000000..c199d26d7441a2a617ad34f16ff9fbcabe3ccfdc --- /dev/null +++ b/FAITH/util_z/split_train_val_test.py @@ -0,0 +1,44 @@ +import random + +f_train = open("../data/SD3/train.txt", "w") +f_val = open("../data/SD3/val.txt", "w") +f_test = open("../data/SD3/test.txt", "w") + +# cnt = 0 +# with open("../data/SD3/all.txt", "r") as f_all: +# for line in f_all: + +# if cnt in val_label: +# f_val.write(line) +# elif cnt in test_label: +# f_test.write(line) +# else: +# f_train.write(line) + +# cnt += 1 + +# v2 +all_label = list(range(20000)) + +for i in range(5): + cnt = 0 + random.shuffle(all_label) + + # train: val: test = 0.8: 0.1: 0.1 + val_label = all_label[-4000: -2000] + test_label = all_label[-2000: ] + + with open(f"../data/SD3/after_sample/{i}.txt", "r") as f: + for line in f: + if cnt in val_label: + f_val.write(line) + elif cnt in test_label: + f_test.write(line) + else: + f_train.write(line) + + cnt += 1 + +f_train.close() +f_val.close() +f_test.close() \ No newline at end of file diff --git a/FAITH/wavelet/0.jpg b/FAITH/wavelet/0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..fb12973b7490d9ab6a809a73ab79e04e820b02c3 --- /dev/null +++ b/FAITH/wavelet/0.jpg @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:61dd7068e1d08a406847b6c6bbe3f902597afdc8e89c3ef15849d40ca6ce01e4 +size 103801 diff --git a/FAITH/wavelet/img_grid_0.jpg b/FAITH/wavelet/img_grid_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..8508509f865c8074c86ce8e4dd87d19033c3ecba --- /dev/null +++ b/FAITH/wavelet/img_grid_0.jpg @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:446008fd7790bd5bd16eedd0a177475c760115c71d9eefc900db7097ec04dec4 +size 32436 diff --git a/FAITH/wavelet/img_grid_37.jpg b/FAITH/wavelet/img_grid_37.jpg new file mode 100644 index 0000000000000000000000000000000000000000..9f1e7bae11f0d37e59610b418ba5d2426e8daeb8 --- /dev/null +++ b/FAITH/wavelet/img_grid_37.jpg @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:34f5b7d8f5d391cc4b42a97eb400d52d01db883b1d93410656add5b8056080e8 +size 17786 diff --git a/FAITH/wavelet/img_grid_37_ori.jpg b/FAITH/wavelet/img_grid_37_ori.jpg new file mode 100644 index 0000000000000000000000000000000000000000..b50e75d832b79b15e0ce3cb835b209fbb58eabb5 --- /dev/null +++ b/FAITH/wavelet/img_grid_37_ori.jpg @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:0bc2cbf33b6dffce5aafb85d1cdbd4eebb367342874ddf852c6f31c43ad1c848 +size 40723 diff --git a/FAITH/wavelet/test.jpg b/FAITH/wavelet/test.jpg new file mode 100644 index 0000000000000000000000000000000000000000..585e2fd15c48fc729d085934394ca224449b861a --- /dev/null +++ b/FAITH/wavelet/test.jpg @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:0174f2a49b292a48a8a1835f0bfa65a9195b74f3e19a4ad009a81cde0c416ec3 +size 30364 diff --git a/FAITH/wavelet/test_HH.jpg b/FAITH/wavelet/test_HH.jpg new file mode 100644 index 0000000000000000000000000000000000000000..ff9bab8306e7d80aafbfa809287dacc0bd53d065 --- /dev/null +++ b/FAITH/wavelet/test_HH.jpg @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:715d52cca73e858d4ce66d14c533f167c4d3a995479cee7e6bbb896ef917884d +size 14254 diff --git a/FAITH/wavelet/wavelet.py b/FAITH/wavelet/wavelet.py new file mode 100644 index 0000000000000000000000000000000000000000..9dd72f70901525092fd0309287cf5b9ae2736932 --- /dev/null +++ b/FAITH/wavelet/wavelet.py @@ -0,0 +1,66 @@ +import torch.nn as nn +import torch +import pdb +import os, torchvision +from PIL import Image +from torchvision import transforms as trans + +def test3(): + from pytorch_wavelets import DWTForward, DWTInverse # (or import DWT, IDWT) + #J为分解的层次数,wave表示使用的变换方法 + xfm = DWTForward(J=1, mode='zero', wave='haar') # Accepts all wave types available to PyWavelets + # ifm = DWTInverse(mode='zero', wave='haar') + + # img = Image.open('../../../ultraedit/UltraEdit/origin_dataset/CelebAMask-HQ/CelebA-HQ-img/37.jpg') + # img = Image.open('../../../ultraedit/UltraEdit/sequential_deepfake_dataset/37/50_10_21_62.jpg') + img = Image.open('../../../ultraedit/UltraEdit/sequential_deepfake_dataset/541/50_11_62_22.jpg') + transform = trans.Compose([ + trans.ToTensor() + ]) + img = transform(img).unsqueeze(0) + print(img.shape) + Yl, Yh = xfm(img) + print(Yl.shape) + print(len(Yh)) + # print(Yh[0].shape) + i = 0 + # for i in range(len(Yh)): + if 1: + print(Yh[i].shape) + if i == len(Yh)-1: + h = torch.zeros([4,3,Yh[i].size(3),Yh[i].size(3)]).float() + h[0,:,:,:] = Yl + else: + h = torch.zeros([3,3,Yh[i].size(3),Yh[i].size(3)]).float() + + for j in range(3): + if i == len(Yh)-1: + h[j+1,:,:,:] = Yh[i][:,:,j,:,:] + else: + h[j,:,:,:] = Yh[i][:,:,j,:,:] + # pdb.set_trace() + + if i == len(Yh)-1: + img_grid = torchvision.utils.make_grid(h, 2) #一行2张图片 + else: + img_grid = torchvision.utils.make_grid(h, 3) + + s_img = Yh[0][:,:,2,:,:] + print(f"s_img.shape: {s_img.shape}") + # print(torch.max(s_img) + torch.min(s_img)) + + # s_img = s_img * 20 + # print(torch.max(s_img) + torch.min(s_img)) + s_img[s_img < torch.max(s_img) / 20] = 0 + + s_img = s_img[0][0] * 12 + # print(f"s_img.shape: {s_img.shape}" ) + torchvision.utils.save_image(s_img, "test_HH.jpg") + + # img_grid = img_grid * 100 + # img_grid[img_grid < 1] = 0 + # torchvision.utils.save_image(img_grid, 'test.jpg') + # pdb.set_trace() + +if __name__ == '__main__': + test3() \ No newline at end of file