rag added

features/real_forged_classifier/controller.py

@@ -1,36 +0,0 @@
-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

@@ -1,52 +0,0 @@
-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

@@ -1,26 +0,0 @@
-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

@@ -1,34 +0,0 @@
-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

@@ -1,60 +0,0 @@
-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

@@ -1,67 +0,0 @@
-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

@@ -1,37 +0,0 @@
-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)
-