added real and forgery detection model

features/real_forged_classifier/controller.py

@@ -0,0 +1,36 @@
+from typing import IO
+from preprocessor import preprocessor
+from inferencer import interferencer
+
+class ClassificationController:
+    """
+    Controller to handle the image classification logic.
+    """
+    def classify_image(self, image_file: IO) -> dict:
+        """
+        Orchestrates the classification of a single image file.
+
+        Args:
+            image_file (IO): The image file to classify.
+
+        Returns:
+            dict: The classification result.
+        """
+        try:
+            # Step 1: Preprocess the image
+            image_tensor = preprocessor.process(image_file)
+
+            # Step 2: Perform inference
+            result = interferencer.predict(image_tensor)
+
+            return result
+        except ValueError as e:
+            # Handle specific errors like invalid images
+            return {"error": str(e)}
+        except Exception as e:
+            # Handle unexpected errors
+            print(f"An unexpected error occurred: {e}")
+            return {"error": "An internal error occurred during classification."}
+
+# Create a single instance of the controller
+controller = ClassificationController()

features/real_forged_classifier/inferencer.py

@@ -0,0 +1,52 @@
+import torch
+import torch.nn.functional as F
+import numpy as np
+
+# Import the globally loaded models instance
+from model_loader import models
+
+class Interferencer:
+    """
+    Performs inference using the FFT CNN model.
+    """
+    def __init__(self):
+        """
+        Initializes the interferencer with the loaded model.
+        """
+        self.fft_model = models.fft_model
+
+    @torch.no_grad()
+    def predict(self, image_tensor: torch.Tensor) -> dict:
+        """
+        Takes a preprocessed image tensor and returns the classification result.
+
+        Args:
+            image_tensor (torch.Tensor): The preprocessed image tensor.
+
+        Returns:
+            dict: A dictionary containing the classification label and confidence score.
+        """
+        # 1. Get model outputs (logits)
+        outputs = self.fft_model(image_tensor)
+        
+        # 2. Apply softmax to get probabilities
+        probabilities = F.softmax(outputs, dim=1)
+        
+        # 3. Get the confidence and the predicted class index
+        confidence, predicted_idx = torch.max(probabilities, 1)
+        
+        prediction = predicted_idx.item()
+        
+        # 4. Map the prediction to a human-readable label
+        # Ensure this mapping matches the labels used during training
+        # Typically: 0 -> fake, 1 -> real
+        label_map = {0: 'fake', 1: 'real'}
+        classification_label = label_map.get(prediction, "unknown")
+
+        return {
+            "classification": classification_label,
+            "confidence": confidence.item()
+        }
+
+# Create a single instance of the interferencer
+interferencer = Interferencer()

features/real_forged_classifier/main.py

@@ -0,0 +1,26 @@
+from fastapi import FastAPI
+from routes import router as api_router
+
+# Initialize the FastAPI app
+app = FastAPI(
+    title="Real vs. Fake Image Classification API",
+    description="An API to classify images as real or forged using FFT and cnn.",
+    version="1.0.0"
+)
+
+# Include the API router
+# All routes defined in routes.py will be available under the /api prefix
+app.include_router(api_router, prefix="/api", tags=["Classification"])
+
+@app.get("/", tags=["Root"])
+async def read_root():
+    """
+    A simple root endpoint to confirm the API is running.
+    """
+    return {"message": "Welcome to the Image Classification API. Go to /docs for the API documentation."}
+
+# To run this application:
+# 1. Make sure you have all dependencies from requirements.txt installed.
+# 2. Make sure the 'svm_model.joblib' file is in the same directory.
+# 3. Run the following command in your terminal:
+#    uvicorn main:app --reload

features/real_forged_classifier/model.py

@@ -0,0 +1,34 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+class FFTCNN(nn.Module):
+    """
+    Defines the Convolutional Neural Network architecture.
+    This structure must match the model that was trained and saved.
+    """
+    def __init__(self):
+        super(FFTCNN, self).__init__()
+         # Ensure 'self.' is used here to define the layers as instance attributes
+        self.conv_layers = nn.Sequential(
+            nn.Conv2d(1, 16, kernel_size=3, padding=1),
+            nn.ReLU(),
+            nn.MaxPool2d(kernel_size=2, stride=2),
+            nn.Conv2d(16, 32, kernel_size=3, padding=1),
+            nn.ReLU(),
+            nn.MaxPool2d(kernel_size=2, stride=2)
+        )
+        
+        # Ensure 'self.' is used here as well
+        self.fc_layers = nn.Sequential(
+            nn.Linear(32 * 56 * 56, 128), # This size depends on your 224x224 input
+            nn.ReLU(),
+            nn.Linear(128, 2) # 2 output classes
+        )
+
+    def forward(self, x):
+        # Now, 'self.conv_layers' can be found because it was defined correctly
+        x = self.conv_layers(x)
+        x = x.view(x.size(0), -1) # Flatten the feature maps
+        x = self.fc_layers(x)
+        return x

features/real_forged_classifier/model_loader.py

@@ -0,0 +1,60 @@
+import torch
+from pathlib import Path
+from huggingface_hub import hf_hub_download
+from model import FFTCNN # Import the model architecture
+
+class ModelLoader:
+    """
+    A class to load and hold the PyTorch CNN model.
+    """
+    def __init__(self, model_repo_id: str, model_filename: str):
+        """
+        Initializes the ModelLoader and loads the model.
+
+        Args:
+            model_repo_id (str): The repository ID on Hugging Face.
+            model_filename (str): The name of the model file (.pth) in the repository.
+        """
+        self.device = "cuda" if torch.cuda.is_available() else "cpu"
+        print(f"Using device: {self.device}")
+
+        self.fft_model = self._load_fft_model(repo_id=model_repo_id, filename=model_filename)
+        print("FFT CNN model loaded successfully.")
+
+    def _load_fft_model(self, repo_id: str, filename: str):
+        """
+        Downloads and loads the FFT CNN model from a Hugging Face Hub repository.
+
+        Args:
+            repo_id (str): The repository ID on Hugging Face.
+            filename (str): The name of the model file (.pth) in the repository.
+
+        Returns:
+            The loaded PyTorch model object.
+        """
+        print(f"Downloading FFT CNN model from Hugging Face repo: {repo_id}")
+        try:
+            # Download the model file from the Hub. It returns the cached path.
+            model_path = hf_hub_download(repo_id=repo_id, filename=filename)
+            print(f"Model downloaded to: {model_path}")
+            
+            # Initialize the model architecture
+            model = FFTCNN()
+            
+            # Load the saved weights (state_dict) into the model
+            model.load_state_dict(torch.load(model_path, map_location=torch.device(self.device)))
+            
+            # Set the model to evaluation mode
+            model.to(self.device)
+            model.eval()
+            
+            return model
+        except Exception as e:
+            print(f"Error downloading or loading model from Hugging Face: {e}")
+            raise
+
+# --- Global Model Instance ---
+MODEL_REPO_ID = 'rhnsa/real_forged_classifier' 
+MODEL_FILENAME = 'fft_cnn_model_78.pth'
+models = ModelLoader(model_repo_id=MODEL_REPO_ID, model_filename=MODEL_FILENAME)
+

features/real_forged_classifier/preprocessor.py

@@ -0,0 +1,67 @@
+from PIL import Image
+import torch
+import numpy as np
+from typing import IO
+import cv2
+from torchvision import transforms
+
+# Import the globally loaded models instance
+from model_loader import models
+
+class ImagePreprocessor:
+    """
+    Handles preprocessing of images for the FFT CNN model.
+    """
+    def __init__(self):
+        """
+        Initializes the preprocessor.
+        """
+        self.device = models.device
+        # Define the image transformations, matching the training process
+        self.transform = transforms.Compose([
+            transforms.ToPILImage(),
+            transforms.Resize((224, 224)),
+            transforms.ToTensor(),
+        ])
+
+    def process(self, image_file: IO) -> torch.Tensor:
+        """
+        Opens an image file, applies FFT, preprocesses it, and returns a tensor.
+
+        Args:
+            image_file (IO): The image file object (e.g., from a file upload).
+
+        Returns:
+            torch.Tensor: The preprocessed image as a tensor, ready for the model.
+        """
+        try:
+            # Read the image file into a numpy array
+            image_np = np.frombuffer(image_file.read(), np.uint8)
+            # Decode the image as grayscale
+            img = cv2.imdecode(image_np, cv2.IMREAD_GRAYSCALE)
+        except Exception as e:
+            print(f"Error reading or decoding image: {e}")
+            raise ValueError("Invalid or corrupted image file.")
+
+        if img is None:
+            raise ValueError("Could not decode image. File may be empty or corrupted.")
+
+        # 1. Apply Fast Fourier Transform (FFT)
+        f = np.fft.fft2(img)
+        fshift = np.fft.fftshift(f)
+        magnitude_spectrum = 20 * np.log(np.abs(fshift) + 1) # Add 1 to avoid log(0)
+
+        # Normalize the magnitude spectrum to be in the range [0, 255]
+        magnitude_spectrum = cv2.normalize(magnitude_spectrum, None, 0, 255, cv2.NORM_MINMAX)
+        magnitude_spectrum = np.uint8(magnitude_spectrum)
+        
+        # 2. Apply torchvision transforms
+        image_tensor = self.transform(magnitude_spectrum)
+        
+        # Add a batch dimension and move to the correct device
+        image_tensor = image_tensor.unsqueeze(0).to(self.device)
+        
+        return image_tensor
+
+# Create a single instance of the preprocessor
+preprocessor = ImagePreprocessor()

features/real_forged_classifier/routes.py

@@ -0,0 +1,37 @@
+from fastapi import APIRouter, File, UploadFile, HTTPException, status
+from fastapi.responses import JSONResponse
+
+# Import the controller instance
+from controller import controller
+
+# Create an API router
+router = APIRouter()
+
+@router.post("/classify_forgery", summary="Classify an image as Real or Fake")
+async def classify_image_endpoint(image: UploadFile = File(...)):
+    """
+    Accepts an image file and classifies it as 'real' or 'fake'.
+
+    - **image**: The image file to be classified (e.g., JPEG, PNG).
+
+    Returns a JSON object with the classification and a confidence score.
+    """
+    # Check for a valid image content type
+    if not image.content_type.startswith("image/"):
+        raise HTTPException(
+            status_code=status.HTTP_415_UNSUPPORTED_MEDIA_TYPE,
+            detail="Unsupported file type. Please upload an image (e.g., JPEG, PNG)."
+        )
+
+    # The controller expects a file-like object, which `image.file` provides
+    result = controller.classify_image(image.file)
+
+    if "error" in result:
+        # If the controller returned an error, forward it as an HTTP exception
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail=result["error"]
+        )
+    
+    return JSONResponse(content=result, status_code=status.HTTP_200_OK)
+