Update app.py

app.py

@@ -1,98 +1,70 @@
+import os
+import uuid
 import gradio as gr
-from transformers import AutoFeatureExtractor, AutoModelForImageClassification
-import torch
-from torchvision import transforms
-from PIL import Image
-import pytesseract
-import cv2
-import numpy as np
+from inference_sdk import InferenceHTTPClient
 
-# -------------------------------------------------------------
-#  Setup OCR
-# -------------------------------------------------------------
-pytesseract.pytesseract.tesseract_cmd = "/usr/bin/tesseract"
+# Ensure uploads folder exists
+UPLOAD_DIR = "uploads"
+os.makedirs(UPLOAD_DIR, exist_ok=True)
 
-# -------------------------------------------------------------
-#  Load Pretrained Vision Model
-# -------------------------------------------------------------
-# Using ResNet18 for demonstration
-from torchvision.models import resnet18
+# Initialize Roboflow inference client
+CLIENT = InferenceHTTPClient(
+    api_url="https://serverless.roboflow.com",
+    api_key="i22FWkifZzD236Hhg56U"  # ⚠️ Replace with your actual API key if different
+)
 
-model = resnet18(weights="IMAGENET1K_V1")
-model.eval()
+# Model ID (Project Slug + Version)
+MODEL_ID = "detecting-fake-certificates-bj1x6/3"
 
-# Define transform for the model
-preprocess = transforms.Compose([
-    transforms.Resize((224, 224)),
-    transforms.ToTensor(),
-    transforms.Normalize(
-        mean=[0.485, 0.456, 0.406],
-        std=[0.229, 0.224, 0.225]
-    )
-])
 
-# -------------------------------------------------------------
-#  Certificate Verification Function
-# -------------------------------------------------------------
-REQUIRED_KEYWORDS = ["certificate", "proudly presented", "position", "organized by", "date"]
+def analyze_certificate(image):
+    """Save uploaded image locally and send it to Roboflow for inference."""
+    try:
+        # Save image with unique filename
+        filename = f"{uuid.uuid4()}.jpg"
+        save_path = os.path.join(UPLOAD_DIR, filename)
+        image.save(save_path)
+        print(f"[INFO] Image saved at {save_path}")
 
-def verify_certificate(image):
-    # Ensure PIL Image
-    if not isinstance(image, Image.Image):
-        image = Image.fromarray(image)
-    image = image.convert("RGB")
+        # Perform inference using Roboflow model
+        result = CLIENT.infer(save_path, model_id=MODEL_ID)
+        print("[INFO] Inference result:", result)
 
-    # ------------------------------
-    # 1️⃣ Model Prediction (generic)
-    # ------------------------------
-    input_tensor = preprocess(image).unsqueeze(0)  # add batch dim
-    with torch.no_grad():
-        outputs = model(input_tensor)
-        probs = torch.nn.functional.softmax(outputs[0], dim=0)
-        top_prob, top_catid = torch.topk(probs, 1)
-    model_confidence = float(top_prob.item())
-    model_label = str(top_catid.item())  # generic label index
+        # Parse predictions
+        predictions = result.get("predictions", [])
+        if not predictions:
+            return "⚠️ No objects detected — possibly a valid certificate.", save_path
 
-    # ------------------------------
-    # 2️⃣ OCR Extraction
-    # ------------------------------
-    img_np = np.array(image)
-    gray = cv2.cvtColor(img_np, cv2.COLOR_RGB2GRAY)
-    text = pytesseract.image_to_string(gray)
+        # Build readable output
+        output_lines = []
+        for pred in predictions:
+            cls = pred.get("class", "unknown")
+            conf = round(pred.get("confidence", 0) * 100, 2)
+            output_lines.append(f"- {cls} ({conf}% confidence)")
 
-    # ------------------------------
-    # 3️⃣ Heuristic Text Scoring
-    # ------------------------------
-    keyword_matches = sum([1 for kw in REQUIRED_KEYWORDS if kw.lower() in text.lower()])
-    ocr_score = keyword_matches / len(REQUIRED_KEYWORDS)
+        output_text = "✅ **Detections:**\n" + "\n".join(output_lines)
+        return output_text, save_path
 
-    # ------------------------------
-    # 4️⃣ Combine Model + OCR
-    # ------------------------------
-    combined_confidence = round((model_confidence + ocr_score) / 2, 4)
+    except Exception as e:
+        print("[ERROR]", e)
+        return f"❌ Error during inference: {e}", None
 
-    # ------------------------------
-    # 5️⃣ Return Result
-    # ------------------------------
-    result = {
-        "model_label": model_label,
-        "model_confidence": round(model_confidence, 4),
-        "ocr_score": round(ocr_score, 4),
-        "combined_confidence": combined_confidence,
-        "text_preview": text[:300]
-    }
-    return result
 
-# -------------------------------------------------------------
-#  Gradio Interface
-# -------------------------------------------------------------
+# Gradio interface
 demo = gr.Interface(
-    fn=verify_certificate,
-    inputs=gr.Image(type="numpy", label="Upload Certificate Image"),
-    outputs=gr.JSON(label="Verification Result"),
-    title="Certificate Verification AI 🧠",
-    description="Uploads a certificate image, checks for authenticity using a vision model and OCR keyword heuristics."
+    fn=analyze_certificate,
+    inputs=gr.Image(type="pil", label="Upload a Certificate"),
+    outputs=[
+        gr.Textbox(label="Inference Result"),
+        gr.Image(label="Uploaded Image")
+    ],
+    title="Fake Certificate Detector 🧠",
+    description=(
+        "Upload a certificate image — this app will use a trained Roboflow model "
+        "(`detecting-fake-certificates-bj1x6/3`) to detect possible signs of forgery."
+    ),
+    allow_flagging="never"
 )
 
 if __name__ == "__main__":
-    demo.launch()
+    demo.launch(server_name="0.0.0.0", server_port=7860)