Upload 6 files

utils/__init__.py

@@ -0,0 +1 @@
+import os

utils/basicblocks.py

@@ -0,0 +1,32 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+
+BatchNorm2d = nn.BatchNorm2d
+
+def conv3x3(in_planes, out_planes, stride = 1):
+    """3x3 convolution with padding"""
+    return nn.Conv2d(in_planes, out_planes, kernel_size = 3, stride = stride,
+                     padding = 1, bias = False)
+
+def conv1x1(in_planes, out_planes, stride = 1):
+    """3x3 convolution with padding"""
+    return nn.Conv2d(in_planes, out_planes, kernel_size = 1, stride = stride,
+                     padding = 0, bias = False)
+
+class BasicBlock(nn.Module):
+    def __init__(self, inplanes, outplanes, stride = 1):
+        super(BasicBlock, self).__init__()
+        self.conv1 = conv3x3(inplanes, outplanes, stride)
+        self.bn1 = BatchNorm2d(outplanes)
+        self.relu = nn.ReLU(inplace = True)
+        self.conv2 = conv3x3(outplanes, outplanes, 2*stride)
+
+    def forward(self, x):
+        out = self.conv1(x)
+        out = self.bn1(out)
+        out = self.relu(out)
+        out = self.conv2(out)
+
+        return out

utils/classifier.py

@@ -0,0 +1,32 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+class ClassifierModel(nn.Module):
+    def __init__(self, num_classes):
+        super(ClassifierModel, self).__init__()
+        # Apply adaptive average pooling to convert (512, 14, 14) to (512)
+        self.adaptive_pool = nn.AdaptiveAvgPool2d((1, 1))
+        
+        # Define multiple fully connected layers
+        self.fc1 = nn.Linear(512, 256)  # First FC layer, reducing to 256 features
+        self.fc2 = nn.Linear(256, 128)  # Second FC layer, reducing to 128 features
+        self.fc3 = nn.Linear(128, num_classes)  # Final FC layer, outputting num_classes for classification
+        
+        #dropout for regularization
+        self.dropout = nn.Dropout(0.2)
+        
+    def forward(self, x):
+        # Flatten the output from the adaptive pooling
+        x = self.adaptive_pool(x)
+        x = torch.flatten(x, 1)
+        
+        # Pass through the fully connected layers with ReLU activations and dropout
+        x = F.relu(self.fc1(x))
+        x = self.dropout(x)
+        x = F.relu(self.fc2(x))
+        x = self.dropout(x)
+        x = self.fc3(x)  # No activation, raw scores
+        x = F.softmax(x, dim=1)
+        
+        return x

utils/config.py

@@ -0,0 +1,38 @@
+from easydict import EasyDict as edict
+import numpy as np
+
+__C = edict()
+cfg = __C
+
+# 0. basic config
+__C.TAG = 'default'
+__C.CLASSES = ['Real', 'Fake']
+
+
+# config of network input
+__C.MULTIMODAL_FUSION = edict()
+__C.MULTIMODAL_FUSION.IMG_CHANNELS = [3, 64, 128, 256, 512]
+__C.MULTIMODAL_FUSION.DCT_CHANNELS = [1, 64, 128, 256, 512]
+
+
+__C.NUM_EPOCHS = 100
+
+__C.BATCH_SIZE = 64
+
+__C.NUM_WORKERS = 4
+
+__C.LEARNING_RATE = 0.0001
+
+__C.PRETRAINED = False
+
+__C.PRETRAINED_PATH = "/home/user/Documents/Real_and_DeepFake/src/best_model.pth"
+
+
+
+
+__C.TEST_BATCH_SIZE = 512
+
+__C.TEST_CSV = "/home/user/Documents/Real_and_DeepFake/src/dataset/extended_val.csv"
+
+__C.MODEL_PATH = "/home/user/Documents/Real_and_DeepFake/src/best_model.pth"
+

utils/data_transforms.py

@@ -0,0 +1,33 @@
+from torchvision import transforms
+
+
+
+def get_transforms_train():
+# Define the dataset object
+    transform = transform = transforms.Compose([
+        transforms.ToTensor(),
+        transforms.Lambda(lambda x: x.float()) ,
+        transforms.Resize((224, 224)),
+        transforms.RandomHorizontalFlip(),
+        transforms.RandomRotation(10),
+        transforms.Normalize(mean=[(0.485+0.456+0.406)/3], std=[(0.229+ 0.224+ 0.225)/3]),
+    ])
+
+    return transform
+
+
+
+
+def get_transforms_val():
+    transform = transform = transforms.Compose([
+        transforms.ToTensor(),
+        transforms.Lambda(lambda x: x.float()) ,
+        transforms.Resize((224, 224)),
+        # transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
+        transforms.Normalize(mean=[(0.485+0.456+0.406)/3], std=[(0.229+ 0.224+ 0.225)/3]),
+
+        
+    ])
+
+
+    return transform

utils/feature_fusion_block.py

@@ -0,0 +1,46 @@
+
+from torch import nn
+from torch.nn import functional as F
+
+class SpatialAttention(nn.Module):
+    def __init__(self, in_channels):
+        super(SpatialAttention, self).__init__()
+        self.conv1 = nn.Conv2d(in_channels, 1, kernel_size=1, stride=1, padding=0)
+        
+    def forward(self, x):
+        # Calculate attention scores
+        attention_scores = self.conv1(x)
+        attention_scores = F.softmax(attention_scores, dim=2)
+        
+        # Apply attention to input features
+        attended_features = x * attention_scores
+        
+        return attended_features
+
+class DCT_Attention_Fusion_Conv(nn.Module):
+    def __init__(self, channels):
+        super(DCT_Attention_Fusion_Conv, self).__init__()
+        self.rgb_attention = SpatialAttention(channels)
+        self.depth_attention = SpatialAttention(channels)
+        self.rgb_pooling = nn.AdaptiveAvgPool2d(1)
+        self.depth_pooling = nn.AdaptiveAvgPool2d(1)
+        
+    def forward(self, rgb_features, DCT_features):
+        # Spatial attention for both modalities
+        rgb_attended_features = self.rgb_attention(rgb_features)
+        depth_attended_features = self.depth_attention(DCT_features)
+        
+        # Adaptive pooling for both modalities
+        rgb_pooled = self.rgb_pooling(rgb_attended_features)
+        depth_pooled = self.depth_pooling(depth_attended_features)
+        
+        # Upsample attended and pooled features to the original size
+        rgb_upsampled = F.interpolate(rgb_pooled, size=rgb_features.size()[2:], mode='bilinear', align_corners=False)
+        depth_upsampled = F.interpolate(depth_pooled, size=DCT_features.size()[2:], mode='bilinear', align_corners=False)
+        
+        # Concatenate the upsampled features
+        fused_features = F.relu(rgb_upsampled+depth_upsampled)
+        # fused_features = fused_features.sum(dim=1)
+        
+        return fused_features
+