feat: added the docker file and feature of img

Dockerfile

@@ -1,9 +1,15 @@
 # Read the doc: https://huggingface.co/docs/hub/spaces-sdks-docker
 # you will also find guides on how best to write your Dockerfile
 
-FROM python:3.9
+FROM python:3.10
 
+# Create user first
 RUN useradd -m -u 1000 user
+
+# Install system dependencies (requires root)
+RUN apt-get update && apt-get install -y libgl1
+
+# Switch to non-root user
 USER user
 ENV PATH="/home/user/.local/bin:$PATH"
 
@@ -14,4 +20,6 @@ RUN pip install --no-cache-dir --upgrade -r requirements.txt
 RUN python -m spacy download en_core_web_sm || echo "Failed to download model"
 
 COPY --chown=user . /app
+
 CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]
+

app.py

@@ -6,7 +6,9 @@ from slowapi.util import get_remote_address
 from fastapi.responses import JSONResponse
 from features.text_classifier.routes import router as text_classifier_router
 from features.nepali_text_classifier.routes import router as nepali_text_classifier_router
+from features.image_classifier.routes import router as image_classifier_router
 from config import ACCESS_RATE
+
 import requests
 limiter = Limiter(key_func=get_remote_address, default_limits=[ACCESS_RATE])
 
@@ -27,11 +29,12 @@ app.add_middleware(SlowAPIMiddleware)
 # Include your routes
 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.get("/")
 @limiter.limit(ACCESS_RATE)
 async def root(request: Request):
     return {
         "message": "API is working",
-        "endpoints": ["/text/analyse", "/text/upload", "/text/analyse-sentences", "/text/analyse-sentance-file"]
+        "endpoints": ["/text/analyse", "/text/upload", "/text/analyse-sentences", "/text/analyse-sentance-file","/NP/analyse","/NP/upload","/NP/analyse-sentences","/NP/file-sentences-analyse","/AI-image/analyse"]
     }
 

features/image_classifier/controller.py

@@ -0,0 +1,11 @@
+from fastapi import HTTPException,File,UploadFile
+from .preprocess import preprocess_image
+from .inferencer import classify_image
+async def Classify_Image_router(file: UploadFile = File(...)):
+    try:
+        image_array = preprocess_image(file)
+        result = classify_image(image_array)
+        return result
+    except Exception as e:
+        raise HTTPException(status_code=400, detail=str(e))
+

features/image_classifier/inferencer.py

@@ -0,0 +1,22 @@
+import numpy as np
+from .model_loader import load_model
+model = load_model()
+
+def classify_image(image: np.ndarray):
+    predictions = model.predict(image)[0]
+    human_conf = float(predictions[0])
+    ai_conf = float(predictions[1])
+
+    if ai_conf > 0.55:
+        label = "AI Generated"
+    elif ai_conf < 0.45:
+        label = "Human Generated"
+    else:
+        label = "Maybe AI"
+
+    return {
+        "label": label,
+        "ai_confidence": round(ai_conf * 100, 2),
+        "human_confidence": round(human_conf * 100, 2)
+    }
+

features/image_classifier/model_loader.py

@@ -0,0 +1,43 @@
+import tensorflow as tf
+from tensorflow.keras.models import load_model as keras_load_model
+import os
+from huggingface_hub import snapshot_download
+import shutil
+
+# Constants
+REPO_ID = "can-org/AI-VS-HUMAN-IMAGE-classifier"
+MODEL_DIR = "./IMG_models"
+MODEL_PATH = os.path.join(MODEL_DIR, 'latest-my_cnn_model.h5')  # adjust path as needed
+
+_model_img = None  # global model variable
+
+def warmup():
+    global _model_img
+    if not os.path.exists(MODEL_DIR):
+        download_model_Repo()
+    _model_img = load_model()
+
+def download_model_Repo():
+    if os.path.exists(MODEL_DIR):
+        return
+    snapshot_path = snapshot_download(repo_id=REPO_ID)
+    os.makedirs(MODEL_DIR, exist_ok=True)
+    shutil.copytree(snapshot_path, MODEL_DIR, dirs_exist_ok=True)
+
+def load_model():
+    if not os.path.exists(MODEL_DIR):
+        download_model_Repo()
+
+    # Check for GPU availability
+    gpus = tf.config.list_physical_devices('GPU')
+    if gpus:
+        # GPU is available, load model normally
+        print("GPU detected, loading model on GPU.")
+        model = keras_load_model(MODEL_PATH)
+    else:
+        # No GPU, force CPU usage
+        print("No GPU detected, forcing model loading on CPU.")
+        with tf.device('/CPU:0'):
+            model = keras_load_model(MODEL_PATH)
+    return model
+

features/image_classifier/preprocess.py

@@ -0,0 +1,18 @@
+import numpy as np
+import cv2
+
+def preprocess_image(file):
+    # Read bytes from UploadFile
+    image_bytes = file.file.read()
+    # Convert bytes to NumPy array
+    nparr = np.frombuffer(image_bytes, np.uint8)
+    img = cv2.imdecode(nparr, cv2.IMREAD_COLOR)
+    if img is None:
+        raise ValueError("Could not decode image.")
+
+    img = cv2.resize(img, (256, 256))  # Changed size to 256x256
+    img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
+    img = img / 255.0
+    img = np.expand_dims(img, axis=0)
+    return img
+

features/image_classifier/routes.py

@@ -0,0 +1,26 @@
+from slowapi import Limiter
+from config import ACCESS_RATE
+from fastapi import APIRouter, File, Request, Depends, HTTPException, UploadFile
+from fastapi.security import HTTPBearer
+from slowapi import Limiter
+from slowapi.util import get_remote_address
+from .controller import Classify_Image_router
+router = APIRouter()
+limiter = Limiter(key_func=get_remote_address)
+security = HTTPBearer()
+
+@router.post("/analyse")
+@limiter.limit(ACCESS_RATE)
+async def analyse(
+    request: Request,
+    file: UploadFile = File(...),
+    token: str = Depends(security)
+):
+    result = await Classify_Image_router(file)  # await the async function
+    return result
+
+@router.get("/health")
+@limiter.limit(ACCESS_RATE)
+def health(request: Request):
+    return {"status": "ok"}
+

features/nepali_text_classifier/controller.py

@@ -3,7 +3,6 @@ from io import BytesIO
 from fastapi import HTTPException, UploadFile, status, Depends
 from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
 import os
-
 from features.nepali_text_classifier.inferencer import classify_text
 from  features.nepali_text_classifier.preprocess import *
 import re

features/nepali_text_classifier/model_loader.py

@@ -8,7 +8,7 @@ from huggingface_hub import snapshot_download
 from transformers import AutoTokenizer, AutoModel
 
 # Configs
-REPO_ID = "Pujan-Dev/Nepali-AI-VS-HUMAN"
+REPO_ID = "can-org/Nepali-AI-VS-HUMAN"
 BASE_DIR = "./np_text_model"
 TOKENIZER_DIR = os.path.join(BASE_DIR, "classifier")  # <- update this to match your uploaded folder
 WEIGHTS_PATH = os.path.join(BASE_DIR, "model_95_acc.pth")  # <- change to match actual uploaded weight

features/nepali_text_classifier/preprocess.py

@@ -20,19 +20,17 @@ def parse_pdf(file: BytesIO):
         for page_num in range(doc.page_count):
             page = doc.load_page(page_num)
             text += page.get_text()
-        return 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")
 
-
-def end_symbol_for_NP_text(text):
-        if not text.endswith("।"):
-            text += "।"
-
-
+def end_symbol_for_NP_text(text: str) -> str:
+    text = text.strip()
+    if not text.endswith("।"):
+        text += "।"
+    return text

features/text_classifier/model_loader.py

@@ -6,7 +6,7 @@ from huggingface_hub import snapshot_download
 import torch
 from dotenv import load_dotenv
 load_dotenv()
-REPO_ID = "Pujan-Dev/AI-Text-Detector"
+REPO_ID = "can-org/AI-Content-Checker"
 MODEL_DIR = "./models"
 TOKENIZER_DIR = os.path.join(MODEL_DIR, "model")
 WEIGHTS_PATH = os.path.join(MODEL_DIR, "model_weights.pth")