💳 Massive ResNet for Credit Card Fraud Detection

"The Beast" - A 4096-width Deep Residual Network trained on 2x Tesla T4 GPUs with a batch size of 24,576.

This repository contains a high-performance Pytorch model designed to detect fraudulent credit card transactions. Unlike standard lightweight models, this architecture utilizes massive capacity (ResNet-style blocks with 4096 neurons) and aggressive data augmentation to achieve state-of-the-art Precision-Recall performance.

🏆 Performance

This model was evaluated on the highly imbalanced Credit Card Fraud Detection dataset (284,807 transactions, only 492 frauds).

Note: Achieving >0.80 PR-AUC on this dataset is considered elite performance.

🏗️ Architecture

The solution uses a hybrid approach (though the .pt file provided here is the primary Supervised Classifier).

Classifier (Classifier.pt)

• Type: Deep Residual Network (Pre-Activation ResNet).
• Input Dimension: 62 (after feature engineering).
• Hidden Width: 4096 neurons per layer.
• Depth: 6 Residual Blocks + Bottlenecks.
• Activation: Mish (Self Regularized Non-Monotonic).
• Regularization: Dynamic Gaussian Noise Injection, Dropout (0.2 - 0.5), Weight Decay.
• File Size: ~815 MB.

Autoencoder (Autoencoder.pt)

• Type: Denoising Bottleneck ResNet Autoencoder.
• Purpose: Unsupervised Anomaly Detection (reconstruction error).
• Threshold: 0.0115 (95th percentile).

⚙️ Training Details

• Hardware: 2x NVIDIA Tesla T4 (DataParallel).
• Batch Size: 24,576 (utilized to stabilize gradients and maximize CUDA saturation).
• Optimizer: AdamW (lr=1e-3 with OneCycleLR Warmup).
• Loss Function: Focal Loss (to handle class imbalance).
• Preprocessing:
  • Feature Engineering: V-feature interactions, Cyclical Time encoding, Log-Amount.
  • Scaling: QuantileTransformer (Output distribution: Normal/Gaussian).
  • Augmentation: BorderlineSMOTE (Ratio 1:1) used during training to force learning of hard decision boundaries.

💻 How to Use

Since this is a custom Pytorch architecture, you need to define the class structure before loading the weights.

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

# 1. Define the Architecture
class GaussianNoise(nn.Module):
    def __init__(self, sigma=0.05):
        super().__init__()
        self.sigma = sigma
    def forward(self, x):
        if self.training: return x + torch.randn_like(x) * self.sigma
        return x

class Mish(nn.Module):
    def forward(self, x): return x * torch.tanh(F.softplus(x))

class ResBlock(nn.Module):
    def __init__(self, dim, dropout=0.2):
        super().__init__()
        self.norm1 = nn.BatchNorm1d(dim)
        self.act1 = Mish()
        self.fc1 = nn.Linear(dim, dim)
        self.drop1 = nn.Dropout(dropout)
        self.norm2 = nn.BatchNorm1d(dim)
        self.act2 = Mish()
        self.fc2 = nn.Linear(dim, dim)
        self.drop2 = nn.Dropout(dropout)
    def forward(self, x):
        res = x
        x = self.norm1(x)
        x = self.act1(x)
        x = self.fc1(x)
        x = self.drop1(x)
        x = self.norm2(x)
        x = self.act2(x)
        x = self.fc2(x)
        x = self.drop2(x)
        return x + res

class ResNetClassifier(nn.Module):
    def __init__(self, input_dim=62): # Default input dim from engineering
        super().__init__()
        self.noise = GaussianNoise(0.05)
        self.proj = nn.Linear(input_dim, 4096)
        self.blocks = nn.Sequential(
            ResBlock(4096, 0.4), ResBlock(4096, 0.4),
            ResBlock(4096, 0.3), ResBlock(4096, 0.3),
            ResBlock(4096, 0.2), ResBlock(4096, 0.2)
        )
        self.bottleneck = nn.Sequential(
            nn.BatchNorm1d(4096), Mish(),
            nn.Linear(4096, 512), Mish()
        )
        self.head = nn.Linear(512, 1)

    def forward(self, x):
        x = self.noise(x)
        x = self.proj(x)
        x = self.blocks(x)
        x = self.bottleneck(x)
        return self.head(x).squeeze()

# 2. Load the Model
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
model = ResNetClassifier(input_dim=62)

# Download 'Classifier.pt' from this repo
model.load_state_dict(torch.load("Classifier.pt", map_location=device))
model.to(device)
model.eval()

print("✅ Model loaded successfully!")

⚠️ Preprocessing Requirement

• Crucial: This model expects input data to be scaled using sklearn.preprocessing.QuantileTransformer(output_distribution='normal'). Do not feed raw data or StandardScaled data, or the predictions will be incorrect.

License

Apache 2.0