Upload 4 files

app.py

@@ -0,0 +1,98 @@
+from fastapi import FastAPI, File, UploadFile, Body
+from fastapi.responses import RedirectResponse
+from fastapi.middleware.cors import CORSMiddleware
+from PIL import Image
+import io
+import numpy as np
+from Apps.structure import ImagePredictionResponse, TextPredictionRequest, TextPredictionResponse, PredictionEntry
+from Apps.imagePreprocess import profile_image_for_cnn_predict, CNNPredict, ResnetPredict, clip_predict
+from Apps.textPreprocess import predict_text
+import tensorflow as tf
+
+origins=[
+    "http://localhost:5173",
+    "http://localhost",
+    "https://authentica-ai.vercel.app",
+]
+
+app = FastAPI(
+    title="Authentica API",
+    description=(
+        "Simple demo API for image and text prediction. "
+        "Upload an image to `/predict/image` or POST text to `/predict/text`."
+    ),
+    version="0.1.0",
+)
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=origins,
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+@app.get("/", include_in_schema=False)
+async def root():
+    # Redirect to the automatic Swagger UI provided by FastAPI
+    return RedirectResponse(url="/docs")
+
+@app.post(
+    "/predict/image",
+    response_model=ImagePredictionResponse,
+    summary="Predict image using all available models",
+    description="Upload an image file (jpg/png). It is evaluated on all 3 models and class index/confidence is returned.",
+)
+async def predict(image: UploadFile = File(...)):
+    """Accept an image upload and return a prediction using loaded model."""
+    
+    image_data = await image.read()
+    pil_img = Image.open(io.BytesIO(image_data)).convert("RGB")
+    profile_img = profile_image_for_cnn_predict(pil_img, crop_size=512)
+    if isinstance(profile_img, str):
+            return (f"Error processing image: {profile_img}")
+    else:
+        print(f"Profile image shape: {profile_img.shape}")
+        cnnPred = CNNPredict(profile_img)
+        resnetPred = ResnetPredict(profile_img)
+        clipPred = clip_predict(pil_img, crop_size=512)
+        #print(f"CNN Prediction (Real prob): {cnnPred:.4f}")
+        #print(f"ResNet Prediction (Real prob): {resnetPred:.4f}")
+        #print(f"CLIP Prediction (AI prob): {clipPred:.4f}")
+        resnet_class = 1 if resnetPred >= 0.5 else 0
+        cnn_class = 1 if cnnPred >= 0.5 else 0
+        clip_class = 0 if clipPred > 0.5 else 1
+        resnet_conf = resnetPred if resnetPred >= 0.5 else 1 - resnetPred
+        cnn_conf = cnnPred if cnnPred >= 0.5 else 1 - cnnPred
+        clip_conf = clipPred if clipPred > 0.5 else 1 - clipPred
+        #Predicted classes 1 is Real, 0 is AI
+        predictions = [
+            PredictionEntry(model="CNN", predicted_class=cnn_class, confidence=round(float(cnn_conf), 4)),
+            PredictionEntry(model="ResNet", predicted_class=resnet_class, confidence=round(float(resnet_conf), 4)),
+            PredictionEntry(model="CLIP", predicted_class=clip_class, confidence=round(float(clip_conf), 4)),
+        ]
+    return ImagePredictionResponse(predictions=predictions)
+
+@app.post(
+    "/predict/text",
+    response_model=TextPredictionResponse,
+    summary="Predict text",
+    description="POST a JSON body with `text` to get a predicted label and confidence.",
+)
+async def predict_text_endpoint(payload: TextPredictionRequest = Body(...)):
+    """Accept a text string and return a prediction of whether it's human or AI-generated."""
+    try:
+        # Use the text prediction function from textPreprocess.py
+        result = predict_text(payload.text)
+        
+        return TextPredictionResponse(
+            predicted_class=result["predicted_class"], 
+            confidence=result["confidence"]
+        )
+    except Exception as e:
+        # Return a fallback response in case of error
+        print(f"Error in text prediction: {e}")
+        return TextPredictionResponse(predicted_class="Human", confidence=0.5)
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="127.0.0.1", port=8000)

imagePreprocess.py

@@ -0,0 +1,223 @@
+import os
+from pathlib import Path
+from PIL import Image, ImageOps
+import cv2
+import numpy as np
+import tensorflow as tf
+from tensorflow.keras.applications.resnet50 import preprocess_input
+import torch
+import clip
+
+BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+MODELS_DIR = os.path.join(BASE_DIR, "Lib/Models/Image")
+
+# Load models and preprocessing once at module level
+clip_mod, clip_pre = clip.load("ViT-B/32", jit=False)
+clip_mod.eval()
+for p in clip_mod.parameters():
+    p.requires_grad = False
+mlp_model= tf.keras.models.load_model(os.path.join(MODELS_DIR, "clip_model.keras"))
+cnn_model = tf.keras.models.load_model(os.path.join(MODELS_DIR, "cnn_model.keras"))
+resnet_model = tf.keras.models.load_model(os.path.join(MODELS_DIR, "resnet_model.keras"))
+
+
+def center_crop(image: Image.Image, crop_size=512) -> Image.Image | str:
+    try:
+            image = ImageOps.exif_transpose(image)
+            w, h = image.size
+            if w < crop_size or h < crop_size:
+                # skip small images
+                return f"skipped image (too small) ({w}x{h})"
+            left = (w - crop_size) // 2
+            top = (h - crop_size) // 2
+            right = left + crop_size
+            bottom = top + crop_size
+            cropped = image.crop((left, top, right, bottom))
+            return cropped
+    except Exception as e:
+        return f"Error when cropping center: {e}"
+
+
+def denoise(src_image: Image) -> np.ndarray | str:
+    """Read image, denoise (GPU if available) and return denoised image."""
+    img = np.array(src_image)   # BGR uint8 numpy array
+    img = cv2.cvtColor(img, cv2.COLOR_RGB2BGR)
+    if src_image is None:
+        print(f"WARNING: No source image, skipping.")
+        return False
+    # Denoising parameters
+    H = 10           # filter strength for luminance component (recommended 3-15)
+    H_COLOR = 10     # same for color components
+    TEMPLATE_WINDOW_SIZE = 7
+    SEARCH_WINDOW_SIZE = 21
+    # Use CUDA if available, otherwise CPU fallback
+    use_cuda = False
+    try:
+        use_cuda = hasattr(cv2, 'cuda') and cv2.cuda.getCudaEnabledDeviceCount() > 0
+    except Exception:
+        use_cuda = False
+    if use_cuda:
+        # Create a GpuMat and upload the numpy image to GPU
+        gpu_img = cv2.cuda_GpuMat()
+        gpu_img.upload(img)   # <-- this converts numpy -> GpuMat on device
+        den_gpu = cv2.cuda.fastNlMeansDenoisingColored(
+           gpu_img,H,H_COLOR,None,SEARCH_WINDOW_SIZE,TEMPLATE_WINDOW_SIZE
+        )
+
+        # Download result back to CPU
+        den = den_gpu.download()
+    else:
+        # Fallback to CPU implementation
+        print("NOTICE: CUDA not available — using CPU denoiser.")
+        den = cv2.fastNlMeansDenoisingColored(
+            img, None,
+            H, H_COLOR,
+            TEMPLATE_WINDOW_SIZE,
+            SEARCH_WINDOW_SIZE
+        )
+    #cv2.imwrite("denoised.png", den)  # for debugging
+    den = cv2.cvtColor(den, cv2.COLOR_BGR2RGB)
+    den = Image.fromarray(den)
+    return den
+    
+def compute_profile(raw_image: Image, den_image: Image, normalize=False ,verbose= True) -> np.ndarray | str:
+    # read images
+    if raw_image is None:
+        return print(f"WARNING: couldn't read raw image")
+    if den_image is None:
+        return print(f"WARNING: couldn't read denoised image")
+        
+    raw = np.array(raw_image)  # RGB uint8 numpy array
+    raw = cv2.cvtColor(raw, cv2.COLOR_RGB2BGR)
+    den = np.array(den_image)  # RGB uint8 numpy array
+    den = cv2.cvtColor(den, cv2.COLOR_RGB2BGR)
+    # if shapes differ, resize den to raw's size (keeps alignment); warn
+    if den.shape != raw.shape:
+        if verbose:
+            print(f"NOTE: shape mismatch, resizing denoised from {den.shape[:2]} to {raw.shape[:2]}")
+        den = cv2.resize(den, (raw.shape[1], raw.shape[0]), interpolation=cv2.INTER_LINEAR)
+
+    # absolute difference per-channel
+    diff = cv2.absdiff(raw, den)               # BGR, uint8
+    gray = cv2.cvtColor(diff, cv2.COLOR_BGR2GRAY)  # single-channel uint8
+
+    # optionally normalize to full 0-255 (per-image)
+    if normalize:
+        # cv2.normalize will map min->0 and max->255
+        # but if the image is flat (min==max) normalize will set to 0; handle that
+        minv = int(gray.min())
+        maxv = int(gray.max())
+        if maxv > minv:
+            norm = cv2.normalize(gray, None, alpha=0, beta=255, norm_type=cv2.NORM_MINMAX)
+            out = norm
+        else:
+            # nothing to normalize (flat), keep as-is (all zeros)
+            out = gray
+    else:
+        # keep raw diff values but ensure dtype uint8 (already uint8) and values are 0..255
+        out = gray
+    #cv2.imwrite("profile.png", out)  # for debugging
+    return out
+
+def profile_image_for_cnn_predict(pil_img: Image, crop_size=512):
+    """Preprocess the input image and return a numpy array ready for model prediction."""
+    # Step 1: Center crop the image
+    cropped_img = center_crop(pil_img, crop_size=crop_size)
+    if isinstance(cropped_img, str):
+        return cropped_img  # return error message if cropping failed
+    # Step 2: Denoise the cropped image
+    denoised_img = denoise(cropped_img)
+    if isinstance(denoised_img, str):
+        return denoised_img  # return error message if denoising failed
+    # Step 3: Compute the profile image
+    profile_img = compute_profile(cropped_img, denoised_img, normalize=False)
+    if isinstance(profile_img, str):
+        return profile_img  # return error message if profile computation failed
+    return profile_img
+
+
+def prepare_cv2_image_for_resnet(cv2_gray_img, target_size=(512,512)):
+    img_rgb = cv2.cvtColor(cv2_gray_img, cv2.COLOR_GRAY2RGB)
+    img_rgb = cv2.resize(img_rgb, (target_size[1], target_size[0]), interpolation=cv2.INTER_AREA)
+    img_rgb = img_rgb.astype('float32')
+    # 5) add batch dim
+    x = np.expand_dims(img_rgb, axis=0)   # shape (1, H, W, 3)
+    x = preprocess_input(x)              
+    return x
+
+def predict_image_prob_clip(image: Image.Image, threshold=0.5,
+                       clip_model=None, clip_preprocess=None,
+                       keras_mlp=None):
+    """
+    Predicts probability that image is AI-generated (AI=1) using CLIP + Keras MLP.
+
+    Args:
+      path_or_image: str (file path) or PIL.Image.Image or numpy array (H,W,3)
+      threshold: float threshold for binary label
+      clip_model, clip_preprocess: optionally pass existing CLIP objects
+      keras_mlp: optionally pass existing loaded Keras model
+    Returns:
+      dict: {'prob': float_prob_AI, 'label': 'AI' or 'Real'}
+    """
+
+
+    # --- try to reuse provided CLIP objects, otherwise load ---
+    if clip_model is None or clip_preprocess is None:
+        print("Loading Default CLIP model...")
+        # pick a model name: prefer provided arg, else try global, else ViT-B/32
+        cmn = "ViT-B/32"
+        clip_model, clip_preprocess = clip.load(cmn, device="cpu", jit=False)
+        clip_model.eval()
+        for p in clip_model.parameters():
+            p.requires_grad = False
+
+    # --- try to reuse provided keras model, otherwise load from disk ---
+    if keras_mlp is None:
+        print("No keras model provided...")
+        return None
+    # --- load/normalize image ---
+    # assume PIL image
+    img = image.convert('RGB')
+   
+    # --- preprocess for CLIP and get embedding ---
+    input_tensor = clip_preprocess(img).unsqueeze(0).to("cpu")  # shape (1,C,H,W)
+    with torch.no_grad():
+        emb = clip_model.encode_image(input_tensor)   # (1, D)
+        emb = emb / emb.norm(dim=-1, keepdim=True)    # L2 normalize
+
+    emb_np = emb.cpu().numpy().astype('float32')     # shape (1, D)
+
+    # --- predict with Keras MLP ---
+    probs = keras_mlp.predict(emb_np, verbose=0).reshape(-1,)
+    prob = float(probs[0])
+    return prob
+
+def clip_predict(pil_img: Image, crop_size=512):
+    # pass model objects explicitly (faster if you call this repeatedly)
+    pil_img = center_crop(pil_img, crop_size=crop_size)
+    
+    if isinstance(pil_img, str):
+        return pil_img  # return error message
+    
+    return predict_image_prob_clip(pil_img,
+                         clip_model=clip_mod,
+                         clip_preprocess=clip_pre,
+                         keras_mlp=mlp_model)
+    
+
+def CNNPredict(predict_img: np.ndarray):
+    #1 Real 0 AI
+     #normalize image
+    # expand dims to add channel axis
+     predict_img = predict_img.astype('float32') / 255.0  # shape (H, W)
+     predict_img = np.expand_dims(predict_img, axis=-1)  # shape (H, W, 1)
+    # expand dims to add batch axis
+     predict_img = np.expand_dims(predict_img, axis=0)   # shape (1, H, W, 1)
+     prediction = cnn_model.predict(predict_img)
+     return prediction[0][0]
+ 
+def ResnetPredict(predict_img):
+    #1 Real 0 AI
+    predict_img = prepare_cv2_image_for_resnet(predict_img)
+    prediction = resnet_model.predict(predict_img)
+    return prediction[0][0]

structure.py

@@ -0,0 +1,18 @@
+from pydantic import BaseModel, Field
+from typing import List
+
+class PredictionEntry(BaseModel):
+    model: str = Field(..., description="Name of the model used for prediction")
+    predicted_class: int = Field(..., description="Predicted class index")
+    confidence: float = Field(..., ge=0.0, le=1.0, description="Prediction confidence (0-1)")
+
+class ImagePredictionResponse(BaseModel):
+    predictions: List[PredictionEntry] = Field(..., description="List of predictions with model, class, and confidence")
+
+class TextPredictionRequest(BaseModel):
+    text: str = Field(..., example="This is a sample text to classify")
+
+
+class TextPredictionResponse(BaseModel):
+    predicted_class: str = Field(..., description="Predicted label for the input text")
+    confidence: float = Field(..., ge=0.0, le=1.0)

textPreprocess.py

@@ -0,0 +1,123 @@
+import torch
+from transformers import AutoTokenizer, AutoModelForSequenceClassification, AutoConfig
+import os
+
+# ── 1) Configuration ────────────────────────────────────────────────────────────
+BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+MODEL_DIR = os.path.join(BASE_DIR, "Lib/Models/Text")  # Update this path to your model location
+MAX_LEN = 512
+
+# ── 2) Load model & tokenizer ──────────────────────────────────────────────────
+device = "cuda" if torch.cuda.is_available() else "cpu"
+print(f"Text prediction device: {device}")
+
+# Global variables for model and tokenizer
+tokenizer = None
+model = None
+ID2LABEL = {0: "human", 1: "ai"}
+
+try:
+    # Config carries id2label/label2id if you saved them
+    config = AutoConfig.from_pretrained(MODEL_DIR)
+    
+    # Loads tokenizer.json + special_tokens_map.json automatically
+    tokenizer = AutoTokenizer.from_pretrained(MODEL_DIR, use_fast=True)
+    
+    # Loads model.safetensors automatically (no extra flags needed)
+    model = AutoModelForSequenceClassification.from_pretrained(MODEL_DIR, config=config)
+    model.eval().to(device)
+    
+    # Update label mapping from config if available
+    ID2LABEL = model.config.id2label if getattr(model.config, "id2label", None) else {0: "human", 1: "ai"}
+    
+    print(f"Text classification model loaded successfully")
+    print("Labels:", ID2LABEL)
+except Exception as e:
+    print(f"Error loading text model: {e}")
+    print("Text prediction will return fallback responses")
+
+# ── 3) Inference function ──────────────────────────────────────────────────────
+@torch.inference_mode()
+def predict_text(text: str, max_length: int = None):
+    """
+    Predict whether the given text is human-written or AI-generated.
+    
+    Args:
+        text (str): The text to classify
+        max_length (int): Maximum sequence length for tokenization (defaults to MAX_LEN)
+        
+    Returns:
+        dict: Contains predicted_class and confidence
+    """
+    if model is None or tokenizer is None:
+        return {"predicted_class": "Human", "confidence": 0}
+    
+    if max_length is None:
+        max_length = MAX_LEN
+    
+    try:
+        # Tokenize input
+        enc = tokenizer(
+            text,
+            return_tensors="pt",
+            truncation=True,
+            max_length=max_length,
+        )
+        enc = {k: v.to(device) for k, v in enc.items()}
+        
+        # Get predictions
+        logits = model(**enc).logits
+        probs = torch.softmax(logits, dim=-1).squeeze(0).detach().cpu().numpy()
+        pred_id = int(probs.argmax(-1))
+        
+        # Get label (capitalize first letter for consistency)
+        label = ID2LABEL.get(pred_id, str(pred_id))
+        label = label.capitalize()  # "human" -> "Human", "ai" -> "Ai"
+        
+        return {
+            "predicted_class": label,
+            "confidence": float(probs[pred_id])
+        }
+    except Exception as e:
+        print(f"Error during text prediction: {e}")
+        return {"predicted_class": "Human", "confidence": 0}
+
+# ── 4) Batch prediction (optional, for future use) ─────────────────────────────
+@torch.inference_mode()
+def predict_batch(texts, batch_size=16):
+    """
+    Predict multiple texts in batches.
+    
+    Args:
+        texts (list): List of text strings to classify
+        batch_size (int): Batch size for processing
+        
+    Returns:
+        list: List of prediction dictionaries
+    """
+    if model is None or tokenizer is None:
+        return [{"predicted_class": "Human", "confidence": 0} for _ in texts]
+    
+    results = []
+    for i in range(0, len(texts), batch_size):
+        chunk = texts[i:i+batch_size]
+        enc = tokenizer(
+            chunk,
+            return_tensors="pt",
+            truncation=True,
+            max_length=MAX_LEN,
+            padding=True,
+        )
+        enc = {k: v.to(device) for k, v in enc.items()}
+        logits = model(**enc).logits
+        probs = torch.softmax(logits, dim=-1).detach().cpu().numpy()
+        ids = probs.argmax(-1)
+        
+        for t, pid, p in zip(chunk, ids, probs):
+            label = ID2LABEL.get(int(pid), str(int(pid))).capitalize()
+            results.append({
+                "text": t,
+                "predicted_class": label,
+                "confidence": float(p[int(pid)])
+            })
+    return results