latest fix

.env-example

@@ -31,4 +31,4 @@ MY_SECRET_TOKEN="SECRET_CODE_TOKEN"
 # LLM_TEMPERATURE=0.1
 
 # Maximum tokens for response
-# LLM_MAX_TOKENS=4096
+# LLM_MAX_TOKENS=4096

README.md

@@ -1,154 +1,22 @@
-# AI-Contain-Checker
-
-A modular AI content detection system with support for **image classification**, **image edit detection**, **Nepali text classification**, and **general text classification**. Built for performance and extensibility, it is ideal for detecting AI-generated content in both visual and textual forms.
-
-
-## 🌟 Features
-
-### 🖼️ Image Classifier
-
-* **Purpose**: Classifies whether an image is AI-generated or a real-life photo.
-* **Model**: Fine-tuned **InceptionV3** CNN.
-* **Dataset**: Custom curated dataset with **\~79,950 images** for binary classification.
-* **Location**: [`features/image_classifier`](features/image_classifier)
-* **Docs**: [`docs/features/image_classifier.md`](docs/features/image_classifier.md)
-
-### 🖌️ Image Edit Detector
-
-* **Purpose**: Detects image tampering or post-processing.
-* **Techniques Used**:
-
-  * **Error Level Analysis (ELA)**: Visualizes compression artifacts.
-  * **Fast Fourier Transform (FFT)**: Detects unnatural frequency patterns.
-* **Location**: [`features/image_edit_detector`](features/image_edit_detector)
-* **Docs**:
-
-  * [ELA](docs/detector/ELA.md)
-  * [FFT](docs/detector/fft.md )
-  * [Metadata Analysis](docs/detector/meta.md)
-  * [Backend Notes](docs/detector/note-for-backend.md)
-
-### 📝 Nepali Text Classifier
-
-* **Purpose**: Determines if Nepali text content is AI-generated or written by a human.
-* **Model**: Based on `XLMRClassifier` fine-tuned on Nepali language data.
-* **Dataset**: Scraped dataset of **\~18,000** Nepali texts.
-* **Location**: [`features/nepali_text_classifier`](features/nepali_text_classifier)
-* **Docs**: [`docs/features/nepali_text_classifier.md`](docs/features/nepali_text_classifier.md)
-
-### 🌐 English Text Classifier
-
-* **Purpose**: Detects if English text is AI-generated or human-written.
-* **Pipeline**:
-
-  * Uses **GPT2 tokenizer** for input preprocessing.
-  * Custom binary classifier to differentiate between AI and human-written content.
-* **Location**: [`features/text_classifier`](features/text_classifier)
-* **Docs**: [`docs/features/text_classifier.md`](docs/features/text_classifier.md)
-
----
-
-## 🗂️ Project Structure
-
-```bash
-AI-Checker/
-│
-├── app.py                  # Main FastAPI entry point
-├── config.py               # Configuration settings
-├── Dockerfile              # Docker build script
-├── Procfile                # Deployment file for Heroku or similar
-├── requirements.txt        # Python dependencies
-├── README.md               # You are here 📘
-│
-├── features/               # Core detection modules
-│   ├── image_classifier/
-│   ├── image_edit_detector/
-│   ├── nepali_text_classifier/
-│   └── text_classifier/
-│
-├── docs/                   # Internal and API documentation
-│   ├── api_endpoints.md
-│   ├── deployment.md
-│   ├── detector/
-│   │   ├── ELA.md
-│   │   ├── fft.md
-│   │   ├── meta.md
-│   │   └── note-for-backend.md
-│   ├── functions.md
-│   ├── nestjs_integration.md
-│   ├── security.md
-│   ├── setup.md
-│   └── structure.md
-│
-├── IMG_Models/             # Saved image classifier model(s)
-│   └── latest-my_cnn_model.h5
-│
-├── notebooks/              # Experimental and debug notebooks
-├── static/                 # Static assets if needed
-└── test.md                 # Test notes
-````
-
 ---
-
-## 📚 Documentation Links
-
-* [API Endpoints](docs/api_endpoints.md)
-* [Deployment Guide](docs/deployment.md)
-* [Detector Documentation](docs/detector/)
-
-  * [Error Level Analysis (ELA)](docs/detector/ELA.md)
-  * [Fast Fourier Transform (FFT)](docs/detector/fft.md)
-  * [Metadata Analysis](docs/detector/meta.md)
-  * [Backend Notes](docs/detector/note-for-backend.md)
-* [Functions Overview](docs/functions.md)
-* [NestJS Integration Guide](docs/nestjs_integration.md)
-* [Security Details](docs/security.md)
-* [Setup Instructions](docs/setup.md)
-* [Project Structure](docs/structure.md)
-
----
-
-## 🚀 Usage
-
-1. **Install dependencies**
-
-   ```bash
-   pip install -r requirements.txt
-   ```
-
-2. **Run the API**
-
-   ```bash
-   chroma run --path ./chroma_database ## to run chromadb locally
-   uvicorn app:app --reload --port 8001 ## fastapi (run after chromadb)
-
-   ```
-
-3. **Build Docker (optional)**
-
-   ```bash
-   docker build -t ai-contain-checker .
-   docker run -p 8000:8000 ai-contain-checker
-   ```
-
----
-
-## 🔐 Security & Integration
-
-* **Token Authentication** and **IP Whitelisting** supported.
-* NestJS integration guide: [`docs/nestjs_integration.md`](docs/nestjs_integration.md)
-* Rate limiting handled using `slowapi`.
-
+title: Testing AI Contain
+emoji: 🤖
+colorFrom: blue
+colorTo: green
+sdk: docker
+sdk_version: "latest"
+app_file: app.py
+pinned: false
 ---
 
-## 🛡️ Future Plans
+# Testing AI Contain
 
-* Add **video classifier** module.
-* Expand dataset for **multilingual** AI content detection.
-* Add **fine-tuning UI** for models.
+This Hugging Face Space uses **Docker** to run a custom environment for AI content detection.
 
----
+## How to run locally
 
-## 📄 License
+```bash
+docker build -t testing-ai-contain .
+docker run -p 7860:7860 testing-ai-contain
 
-See full license terms here: [`LICENSE.md`](license.md)
+```

READMEs.md

@@ -0,0 +1,152 @@
+# AI-Contain-Checker
+
+A modular AI content detection system with support for **image classification**, **image edit detection**, **Nepali text classification**, and **general text classification**. Built for performance and extensibility, it is ideal for detecting AI-generated content in both visual and textual forms.
+
+
+## 🌟 Features
+
+### 🖼️ Image Classifier
+
+* **Purpose**: Classifies whether an image is AI-generated or a real-life photo.
+* **Model**: Fine-tuned **InceptionV3** CNN.
+* **Dataset**: Custom curated dataset with **\~79,950 images** for binary classification.
+* **Location**: [`features/image_classifier`](features/image_classifier)
+* **Docs**: [`docs/features/image_classifier.md`](docs/features/image_classifier.md)
+
+### 🖌️ Image Edit Detector
+
+* **Purpose**: Detects image tampering or post-processing.
+* **Techniques Used**:
+
+  * **Error Level Analysis (ELA)**: Visualizes compression artifacts.
+  * **Fast Fourier Transform (FFT)**: Detects unnatural frequency patterns.
+* **Location**: [`features/image_edit_detector`](features/image_edit_detector)
+* **Docs**:
+
+  * [ELA](docs/detector/ELA.md)
+  * [FFT](docs/detector/fft.md )
+  * [Metadata Analysis](docs/detector/meta.md)
+  * [Backend Notes](docs/detector/note-for-backend.md)
+
+### 📝 Nepali Text Classifier
+
+* **Purpose**: Determines if Nepali text content is AI-generated or written by a human.
+* **Model**: Based on `XLMRClassifier` fine-tuned on Nepali language data.
+* **Dataset**: Scraped dataset of **\~18,000** Nepali texts.
+* **Location**: [`features/nepali_text_classifier`](features/nepali_text_classifier)
+* **Docs**: [`docs/features/nepali_text_classifier.md`](docs/features/nepali_text_classifier.md)
+
+### 🌐 English Text Classifier
+
+* **Purpose**: Detects if English text is AI-generated or human-written.
+* **Pipeline**:
+
+  * Uses **GPT2 tokenizer** for input preprocessing.
+  * Custom binary classifier to differentiate between AI and human-written content.
+* **Location**: [`features/text_classifier`](features/text_classifier)
+* **Docs**: [`docs/features/text_classifier.md`](docs/features/text_classifier.md)
+
+---
+
+## 🗂️ Project Structure
+
+```bash
+AI-Checker/
+│
+├── app.py                  # Main FastAPI entry point
+├── config.py               # Configuration settings
+├── Dockerfile              # Docker build script
+├── Procfile                # Deployment file for Heroku or similar
+├── requirements.txt        # Python dependencies
+├── README.md               # You are here 📘
+│
+├── features/               # Core detection modules
+│   ├── image_classifier/
+│   ├── image_edit_detector/
+│   ├── nepali_text_classifier/
+│   └── text_classifier/
+│
+├── docs/                   # Internal and API documentation
+│   ├── api_endpoints.md
+│   ├── deployment.md
+│   ├── detector/
+│   │   ├── ELA.md
+│   │   ├── fft.md
+│   │   ├── meta.md
+│   │   └── note-for-backend.md
+│   ├── functions.md
+│   ├── nestjs_integration.md
+│   ├── security.md
+│   ├── setup.md
+│   └── structure.md
+│
+├── IMG_Models/             # Saved image classifier model(s)
+│   └── latest-my_cnn_model.h5
+│
+├── notebooks/              # Experimental and debug notebooks
+├── static/                 # Static assets if needed
+└── test.md                 # Test notes
+````
+
+---
+
+## 📚 Documentation Links
+
+* [API Endpoints](docs/api_endpoints.md)
+* [Deployment Guide](docs/deployment.md)
+* [Detector Documentation](docs/detector/)
+
+  * [Error Level Analysis (ELA)](docs/detector/ELA.md)
+  * [Fast Fourier Transform (FFT)](docs/detector/fft.md)
+  * [Metadata Analysis](docs/detector/meta.md)
+  * [Backend Notes](docs/detector/note-for-backend.md)
+* [Functions Overview](docs/functions.md)
+* [NestJS Integration Guide](docs/nestjs_integration.md)
+* [Security Details](docs/security.md)
+* [Setup Instructions](docs/setup.md)
+* [Project Structure](docs/structure.md)
+
+---
+
+## 🚀 Usage
+
+1. **Install dependencies**
+
+   ```bash
+   pip install -r requirements.txt
+   ```
+
+2. **Run the API**
+
+   ```bash
+   uvicorn app:app --reload
+   ```
+
+3. **Build Docker (optional)**
+
+   ```bash
+   docker build -t ai-contain-checker .
+   docker run -p 8000:8000 ai-contain-checker
+   ```
+
+---
+
+## 🔐 Security & Integration
+
+* **Token Authentication** and **IP Whitelisting** supported.
+* NestJS integration guide: [`docs/nestjs_integration.md`](docs/nestjs_integration.md)
+* Rate limiting handled using `slowapi`.
+
+---
+
+## 🛡️ Future Plans
+
+* Add **video classifier** module.
+* Expand dataset for **multilingual** AI content detection.
+* Add **fine-tuning UI** for models.
+
+---
+
+## 📄 License
+
+See full license terms here: [`LICENSE.md`](license.md)

app.py

@@ -11,7 +11,6 @@ from features.nepali_text_classifier.routes import (
 )
 from features.image_classifier.routes import router as image_classifier_router
 from features.image_edit_detector.routes import router as image_edit_detector_router
-from features.rag_chatbot.routes import router as rag_router  
 from fastapi.staticfiles import StaticFiles
 
 from config import ACCESS_RATE
@@ -42,8 +41,6 @@ app.include_router(text_classifier_router, prefix="/text")
 app.include_router(nepali_text_classifier_router, prefix="/NP")
 app.include_router(image_classifier_router, prefix="/AI-image")
 app.include_router(image_edit_detector_router, prefix="/detect")
-app.include_router(rag_router, prefix="/rag") 
-
 
 
 @app.get("/")

docs/detector/ai_human_image_checker.md

@@ -0,0 +1,132 @@
+Real vs. Fake Image Classification for Production Pipeline
+==========================================================
+
+1\. Business Problem
+--------------------
+
+This project addresses the critical business need to automatically identify and flag manipulated or synthetically generated images. By accurately classifying images as **"real"** or **"fake,"** we can enhance the integrity of our platform, prevent the spread of misinformation, and protect our users from fraudulent content. This solution is designed for integration into our production pipeline to process images in real-time.
+
+2\. Solution Overview
+---------------------
+
+This solution leverages OpenAI's CLIP (Contrastive Language-Image Pre-Training) model to differentiate between real and fake images. The system operates as follows:
+
+1.  **Feature Extraction:** A pre-trained CLIP model ('ViT-L/14') converts input images into 768-dimensional feature vectors.
+    
+2.  **Classification:** A Support Vector Machine (SVM) model, trained on our internal dataset of real and fake images, classifies the feature vectors.
+    
+3.  **Deployment:** The trained model is deployed as a service that can be integrated into our production image processing pipeline.
+    
+
+The model has achieved an accuracy of **98.29%** on our internal test set, demonstrating its effectiveness in distinguishing between real and fake images.
+
+3\. Getting Started
+-------------------
+
+### 3.1. Dependencies
+
+To ensure a reproducible environment, all dependencies are listed in the requirements.txt file. Install them using pip:
+
+```bash
+pip install -r requirements.txt
+```
+
+**requirements.txt**:
+ - numpy 
+ - Pillow  
+ - torch  
+ - clip-by-openai  
+ - scikit-learn  
+ - tqdm  
+ - seaborn  
+ - matplotlib
+
+### 3.2. Data Preparation
+
+The model was trained on a dataset of real and fake images obtained form kaggle the dataset link is https://www.kaggle.com/datasets/tristanzhang32/ai-generated-images-vs-real-images/data$0.
+
+### 3.3. Usage
+
+#### 3.3.1. Feature Extraction
+
+To extract features from a new dataset, run the following command:
+
+```
+ python extract_features.py --data_dir /path/to/your/data --output_file features.npz
+ ```   
+
+#### 3.3.2. Model Training
+
+To retrain the SVM model on a new set of extracted features, run:
+
+```
+python train_model.py --features_file features.npz --model_output_path model.joblib   
+```
+
+#### 3.3.3. Inference
+
+To classify a single image using the trained model, use the provided inference script:
+```
+ python classify.py --image_path /path/to/your/image.jpg --model_path model.joblib  
+ ```
+
+4\. Production Deployment
+-------------------------
+
+The image classification model is deployed as a microservice. The service exposes an API endpoint that accepts an image and returns a classification result ("real" or "fake").
+
+### 4.1. API Specification
+
+*   **Endpoint:** /classify
+    
+*   **Method:** POST
+    
+*   **Request Body:** multipart/form-data with a single field image.
+    
+*   **Response:**
+    
+    *   JSON{ "classification": "real", "confidence": 0.95}
+        
+    *   JSON{ "error": "Error message"}
+        
+
+### 4.2. Scalability and Monitoring
+
+The service is deployed in a containerized environment (e.g., Docker) and managed by an orchestrator (e.g., Kubernetes) to ensure scalability and high availability. Monitoring and logging are in place to track model performance, API latency, and error rates.
+
+5\. Model Versioning
+--------------------
+
+We use a combination of Git for code versioning and a model registry for tracking trained model artifacts. Each model is versioned and associated with the commit hash of the code that produced it. The current production model is **v1.2.0**.
+
+6\. Testing
+-----------
+
+The project includes a suite of tests to ensure correctness and reliability:
+
+*   **Unit tests:** To verify individual functions and components.
+    
+*   **Integration tests:** To test the interaction between different parts of the system.
+    
+*   **Model evaluation tests:** To continuously monitor model performance on a golden dataset.
+    
+
+To run the tests, execute:
+``` 
+pytest   
+```
+
+7\. Future Work
+---------------
+
+*   **Explore more advanced classifiers:** Investigate the use of neural network-based classifiers on top of CLIP features.
+    
+*   **Fine-tune the CLIP model:** For even better performance, we can fine-tune the CLIP model on our specific domain of images.
+    
+*   **Expand the training dataset:** Continuously augment the training data with new examples of real and fake images to improve the model's robustness.
+    
+
+8\. Contact/Support
+-------------------
+
+For any questions or issues regarding this project, please contact the Machine Learning team at [your-team-email@yourcompany.com](mailto:your-team-email@yourcompany.com) .

features/ai_human_image_classifier/controller.py

@@ -0,0 +1,35 @@
+from typing import IO
+from preprocessor import preprocessor
+from inferencer import inferencer
+
+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 = inferencer.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."}
+
+controller = ClassificationController()

features/ai_human_image_classifier/inferencer.py

@@ -0,0 +1,48 @@
+import torch
+import numpy as np
+from model_loader import models
+
+class Inferencer:
+
+    def __init__(self):
+        self.clip_model = models.clip_model
+        self.svm_model = models.svm_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.
+        """
+
+        image_features = self.clip_model.encode_image(image_tensor)
+        image_features_np = image_features.cpu().numpy()
+
+        prediction = self.svm_model.predict(image_features_np)[0]
+
+        if hasattr(self.svm_model, "predict_proba"):
+            # If yes, use predict_proba for a true confidence score
+            confidence_scores = self.svm_model.predict_proba(image_features_np)[0]
+            confidence = float(np.max(confidence_scores))
+        else:
+            # If no, use decision_function as a fallback confidence measure.
+            # The absolute value of the decision function score indicates confidence.
+            # We can apply a sigmoid function to scale it to a [0, 1] range for consistency.
+            decision_score = self.svm_model.decision_function(image_features_np)[0]
+            confidence = 1 / (1 + np.exp(-np.abs(decision_score)))
+            confidence = float(confidence)
+
+        label_map = {0: 'real', 1: 'fake'}
+        classification_label = label_map.get(prediction, "unknown")
+
+        return {
+            "classification": classification_label,
+            "confidence": confidence
+        }
+
+inferencer = Inferencer()

features/ai_human_image_classifier/main.py

@@ -0,0 +1,27 @@
+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 fake using OpenAI's CLIP and an SVM model.",
+    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/ai_human_image_classifier/model_loader.py

@@ -0,0 +1,80 @@
+import clip
+import torch
+import joblib
+from pathlib import Path
+from huggingface_hub import hf_hub_download
+
+class ModelLoader:
+    """
+    A class to load and hold the machine learning models.
+    This ensures that models are loaded only once.
+    """
+    def __init__(self, clip_model_name: str, svm_repo_id: str, svm_filename: str):
+        """
+        Initializes the ModelLoader and loads the models.
+
+        Args:
+            clip_model_name (str): The name of the CLIP model to load (e.g., 'ViT-L/14').
+            svm_repo_id (str): The repository ID on Hugging Face (e.g., 'rhnsa/ai_human_image_detector').
+            svm_filename (str): The name of the model file in the repository (e.g., 'model.joblib').
+        """
+        self.device = "cuda" if torch.cuda.is_available() else "cpu"
+        print(f"Using device: {self.device}")
+
+        self.clip_model, self.clip_preprocess = self._load_clip_model(clip_model_name)
+        self.svm_model = self._load_svm_model(repo_id=svm_repo_id, filename=svm_filename)
+        print("Models loaded successfully.")
+
+    def _load_clip_model(self, model_name: str):
+        """
+        Loads the specified CLIP model and its preprocessor.
+        
+        Args:
+            model_name (str): The name of the CLIP model.
+        
+        Returns:
+            A tuple containing the loaded CLIP model and its preprocess function.
+        """
+        try:
+            model, preprocess = clip.load(model_name, device=self.device)
+            return model, preprocess
+        except Exception as e:
+            print(f"Error loading CLIP model: {e}")
+            raise
+
+    def _load_svm_model(self, repo_id: str, filename: str):
+        """
+        Downloads and loads the SVM 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 in the repository.
+
+        Returns:
+            The loaded SVM model object.
+        """
+        print(f"Downloading SVM 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"SVM model downloaded to: {model_path}")
+            
+            # Load the model from the downloaded path
+            svm_model = joblib.load(model_path)
+            return svm_model
+        except Exception as e:
+            print(f"Error downloading or loading SVM model from Hugging Face: {e}")
+            raise
+
+# --- Global Model Instance ---
+# This creates a single instance of the models that can be imported by other modules.
+CLIP_MODEL_NAME = 'ViT-L/14'
+SVM_REPO_ID = 'rhnsa/ai_human_image_detector'
+SVM_FILENAME = 'svm_model_real.joblib' # The name of your model file in the Hugging Face repo
+
+# This instance will be created when the application starts.
+models = ModelLoader(
+    clip_model_name=CLIP_MODEL_NAME, 
+    svm_repo_id=SVM_REPO_ID, 
+    svm_filename=SVM_FILENAME
+)

features/ai_human_image_classifier/preprocessor.py

@@ -0,0 +1,34 @@
+from PIL import Image
+import torch
+from typing import IO
+from model_loader import models
+
+class ImagePreprocessor:
+
+    def __init__(self):
+        self.preprocess = models.clip_preprocess
+        self.device = models.device
+
+    def process(self, image_file: IO) -> torch.Tensor:
+        """
+        Opens an image file, preprocesses it, and returns it as 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:
+            # Open the image from the file-like object
+            image = Image.open(image_file).convert("RGB")
+        except Exception as e:
+            print(f"Error opening image: {e}")
+            # You might want to raise a custom exception here
+            raise ValueError("Invalid or corrupted image file.")
+
+        # Apply the CLIP preprocessing transformations and move to the correct device
+        image_tensor = self.preprocess(image).unsqueeze(0).to(self.device)
+        return image_tensor
+    
+preprocessor = ImagePreprocessor()

features/ai_human_image_classifier/routes.py

@@ -0,0 +1,44 @@
+from fastapi import APIRouter, File, UploadFile, HTTPException, status
+from fastapi.responses import JSONResponse
+from controller import controller
+
+from fastapi import Request, Depends
+from fastapi.security import HTTPBearer
+from slowapi import Limiter
+from slowapi.util import get_remote_address
+
+
+router = APIRouter()
+limiter = Limiter(key_func=get_remote_address)
+security = HTTPBearer()
+# Create an API router
+router = APIRouter()
+
+@router.post("/classify", 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)
+

features/nepali_text_classifier/preprocess.py

@@ -1,9 +1,9 @@
-import fitz  # PyMuPDF
+# import fitz  # PyMuPDF
 import docx
 from io import BytesIO
 import logging
 from fastapi import HTTPException
-
+from pypdf import PdfReader  
 
 def parse_docx(file: BytesIO):
     doc = docx.Document(file)
@@ -15,11 +15,10 @@ def parse_docx(file: BytesIO):
 
 def parse_pdf(file: BytesIO):
     try:
-        doc = fitz.open(stream=file, filetype="pdf")
+        doc = PdfReader(file)
         text = ""
-        for page_num in range(doc.page_count):
-            page = doc.load_page(page_num)
-            text += page.get_text()
+        for page in doc.pages:
+            text += page.extract_text()
         return text 
     except Exception as e:
         logging.error(f"Error while processing PDF: {str(e)}")

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)
+

features/text_classifier/controller.py

@@ -60,12 +60,12 @@ async def handle_file_upload(file: UploadFile):
     try:
         file_contents = await extract_file_contents(file)
         if len(file_contents) > 10000:
-            raise HTTPException(status_code=413, detail="Text must be less than 10,000 characters")
+            return {"status_code": 413, "detail": "Text must be less than 10,000 characters"}
 
         cleaned_text = file_contents.replace("\n", " ").replace("\t", " ").strip()
         if not cleaned_text:
             raise HTTPException(status_code=404, detail="The file is empty or only contains whitespace.")
-      
+        # print(f"Cleaned text: '{cleaned_text}'")  # Debugging statement
         label, perplexity, ai_likelihood = await asyncio.to_thread(classify_text, cleaned_text)
         return {
             "content": file_contents,
@@ -102,12 +102,15 @@ async def handle_sentence_level_analysis(text: str):
             "ai_likelihood": ai_likelihood
         })
 
-    return {"analysis": results}# Analyze each sentence from uploaded file
+    return {"analysis": results}
+
+# Analyze each sentence from uploaded file
 async def handle_file_sentence(file: UploadFile):
     try:
         file_contents = await extract_file_contents(file)
         if len(file_contents) > 10000:
-            raise HTTPException(status_code=413, detail="Text must be less than 10,000 characters")
+            # raise HTTPException(status_code=413, detail="Text must be less than 10,000 characters")
+            return {"status_code": 413, "detail": "Text must be less than 10,000 characters"}
 
         cleaned_text = file_contents.replace("\n", " ").replace("\t", " ").strip()
         if not cleaned_text:

features/text_classifier/preprocess.py

@@ -1,4 +1,4 @@
-import fitz  # PyMuPDF
+from pypdf import PdfReader  
 import docx
 from io import BytesIO
 import logging
@@ -15,18 +15,16 @@ def parse_docx(file: BytesIO):
 
 def parse_pdf(file: BytesIO):
     try:
-        doc = fitz.open(stream=file, filetype="pdf")
+        doc = PdfReader(file)
         text = ""
-        for page_num in range(doc.page_count):
-            page = doc.load_page(page_num)
-            text += page.get_text()
-        return text
+        for page in doc.pages:
+            text += page.extract_text()
+        return text 
     except Exception as e:
         logging.error(f"Error while processing PDF: {str(e)}")
         raise HTTPException(
             status_code=500, detail="Error processing PDF file")
 
-
 def parse_txt(file: BytesIO):
     return file.read().decode("utf-8")
 

requirements.txt

@@ -15,16 +15,6 @@ tensorflow
 opencv-python
 pillow
 scipy
-fitz
+pypdf
 frontend
 tools
-langchain
-langchain-community
-langchain-openai
-faiss-cpu
-PyPDF2
-tiktoken
-chromadb
-langchain_chroma
-sentence-transformers
-tf-keras

test.md

@@ -0,0 +1,31 @@
+
+**Update: Edited & AI-Generated Content Detection – Project Plan**
+
+### 🔍 Phase 1: Rule-Based Image Detection (In Progress)
+
+We're implementing three core techniques to individually flag edited or AI-generated images:
+
+* **ELA (Error Level Analysis):** Highlights inconsistencies via JPEG recompression.
+* **FFT (Frequency Analysis):** Uses 2D Fourier Transform to detect unnatural image frequency patterns.
+* **Metadata Analysis:** Parses EXIF data to catch clues like editing software tags.
+
+ These give us visual + interpretable results for each image, and currently offer \~60–70% accuracy on typical AI-edited content.
+
+---
+
+###  Phase 2: AI vs Human Detection System (Coming Soon)
+
+**Goal:** Build an AI model that classifies whether content is AI- or human-made — initially focusing on **images**, and later expanding to **text**.
+
+**Data Strategy:**
+
+* Scraping large volumes of recent AI-gen images (e.g. SDXL, Gibbli, MidJourney).
+* Balancing with high-quality human images.
+
+**Model Plan:**
+
+* Use ELA, FFT, and metadata as feature extractors.
+* Feed these into a CNN or ensemble model.
+* Later, unify into a full web-based platform (upload → get AI/human probability).
+
+