PaddleOCR-VL

Dockerfile

@@ -1,15 +1,24 @@
-FROM python:3.12-slim
-WORKDIR /app
-COPY . .
+# Use a slim Python base image for CPU-only deployment
+FROM python:3.10-slim
+
+# Set working directory
+WORKDIR /code
 
-RUN apt-get update && apt-get install -y --no-install-recommends \
-    libgl1 libglib2.0-0 && \
-    rm -rf /var/lib/apt/lists/*
+# Install system dependencies (if needed for PIL or other libs)
+RUN apt-get update && apt-get install -y \
+    libgl1-mesa-glx \
+    libglib2.0-0 \
+    && rm -rf /var/lib/apt/lists/*
 
-RUN pip install --no-cache-dir torch --index-url https://download.pytorch.org/whl/cpu
+# Copy and install Python dependencies
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
 
-RUN pip install --no-cache-dir \
-    fastapi uvicorn python-multipart pillow transformers
+# Copy the application code
+COPY . .
 
+# Expose the port (Hugging Face Spaces expects 7860 for FastAPI/Gradio)
 EXPOSE 7860
-CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]
+
+# Run the FastAPI app with uvicorn
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860", "--reload"]

app.py

@@ -1,77 +1,36 @@
-import logging
 import io
-import time
-import json
-from fastapi import FastAPI, File, Form, UploadFile, HTTPException
-from fastapi.middleware.gzip import GZipMiddleware
-from PIL import Image
 import torch
-from transformers import AutoProcessor, AutoModelForImageTextToText
-
-logging.basicConfig(level=logging.INFO, format="%(asctime)s | %(levelname)s | %(message)s")
-logger = logging.getLogger(__name__)
-
-app = FastAPI(title="GLM-OCR Structured Extraction API", version="1.0.0")
-app.add_middleware(GZipMiddleware, minimum_size=1000)
-
-# ── Built-in schemas ──────────────────────────────────────────────
-SCHEMAS = {
-    "pan_card": {
-        "name": "string",
-        "father_name": "string",
-        "date_of_birth": "string",
-        "pan_number": "string"
-    },
-    "aadhaar_card": {
-        "name": "string",
-        "date_of_birth": "string",
-        "gender": "string",
-        "aadhaar_number": "string",
-        "address": "string"
-    },
-    "invoice": {
-        "invoice_number": "string",
-        "date": "string",
-        "vendor_name": "string",
-        "total_amount": "string",
-        "line_items": "array"
-    },
-    "business_card": {
-        "name": "string",
-        "title": "string",
-        "company": "string",
-        "email": "string",
-        "phone": "string",
-        "website": "string"
-    },
-    "receipt": {
-        "store_name": "string",
-        "date": "string",
-        "items": "array",
-        "subtotal": "string",
-        "tax": "string",
-        "total": "string"
-    }
-}
+from fastapi import FastAPI, File, UploadFile, HTTPException,Form
+from fastapi.responses import JSONResponse
+from PIL import Image
+from transformers import AutoModelForCausalLM, AutoProcessor
+import uvicorn
+
+app = FastAPI(title="PaddleOCR-VL API", version="1.0.0")
+
+MODEL_ID = "PaddlePaddle/PaddleOCR-VL"
+DEVICE = "cpu"
 
-DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
-MODEL_ID = "zai-org/GLM-OCR"
+model = None
+processor = None
 
-logger.info(f"=== LOADING GLM-OCR on {DEVICE} ===")
-processor = AutoProcessor.from_pretrained(MODEL_ID, trust_remote_code=True)
-model = AutoModelForImageTextToText.from_pretrained(
-    MODEL_ID,
-    torch_dtype=torch.bfloat16 if DEVICE == "cuda" else torch.float32,
-    trust_remote_code=True,
-).to(DEVICE)
-model.eval()
-logger.info("✅ GLM-OCR ready!")
+
+@app.on_event("startup")
+async def load_model():
+    global model, processor
+    print(f"Loading model {MODEL_ID} on {DEVICE}...")
+    model = AutoModelForCausalLM.from_pretrained(
+        MODEL_ID,
+        trust_remote_code=True,
+        torch_dtype=torch.float32  # Use float32 for reliable CPU inference
+    ).to(DEVICE).eval()
+    processor = AutoProcessor.from_pretrained(MODEL_ID, trust_remote_code=True)
+    print("Model loaded successfully!")
 
 
-# ── Routes ────────────────────────────────────────────────────────
 @app.get("/")
 async def root():
-    return {"message": "GLM-OCR API ready!", "endpoints": ["GET /schemas", "POST /ocr/extract"]}
+    return {"message": "PaddleOCR-VL API ready!", "endpoints": ["GET /schemas", "POST /ocr/extract"]}
 
 
 @app.get("/health")
@@ -80,98 +39,73 @@ async def health():
 
 
 @app.get("/schemas")
-async def list_schemas():
-    return {"available": list(SCHEMAS.keys()), "schemas": SCHEMAS}
+async def schemas():
+    from fastapi.openapi.utils import get_openapi
+    return get_openapi(
+        title="PaddleOCR-VL API",
+        version="1.0.0",
+        description="API for OCR extraction using PaddleOCR-VL model",
+        routes=app.routes,
+    )
 
 
 @app.post("/ocr/extract")
-async def extract(
-    image: UploadFile = File(...),
-    schema_name: str = Form(default="", description="Built-in: pan_card, aadhaar_card, invoice, business_card, receipt"),
-    custom_schema: str = Form(default="", description='Custom JSON e.g. {"company":"string","gst":"string"}'),
+async def ocr_extract(
+        file: UploadFile = File(..., description="Image file to process"),
+        query: str = Form("OCR:",
+                          description="Specific query about the image (e.g., 'What is the date on this document?')")
 ):
-    # ── Validate inputs ───────────────────────────────────────────
-    if not schema_name and not custom_schema:
-        raise HTTPException(status_code=422, detail='Provide schema_name or custom_schema.')
-
-    if schema_name and schema_name not in SCHEMAS:
-        raise HTTPException(status_code=422, detail=f"Unknown schema. Available: {list(SCHEMAS.keys())}")
-
-    if image.content_type not in {"image/jpeg", "image/png", "image/webp", "image/bmp", "image/tiff"}:
-        raise HTTPException(status_code=415, detail=f"Unsupported type: {image.content_type}")
-
-    raw = await image.read()
-    if len(raw) > 10 * 1024 * 1024:
-        raise HTTPException(status_code=413, detail="File too large. Max 10MB.")
+    if not file.content_type.startswith("image/"):
+        raise HTTPException(status_code=400, detail="File must be an image (e.g., PNG, JPEG)")
 
-    # ── Resolve schema ────────────────────────────────────────────
-    if schema_name:
-        schema = SCHEMAS[schema_name]
-        schema_label = schema_name
-    else:
-        try:
-            schema = json.loads(custom_schema)
-            schema_label = "custom"
-        except json.JSONDecodeError:
-            raise HTTPException(status_code=422, detail="custom_schema must be valid JSON.")
-
-    logger.info(f"📸 Extract | file: {image.filename} | schema: {schema_label}")
-    t0 = time.perf_counter()
-
-    # ── Run GLM-OCR with JSON schema prompt ───────────────────────
+    contents = await file.read()
     try:
-        img = Image.open(io.BytesIO(raw)).convert("RGB")
-
-        # GLM-OCR natively understands JSON schema extraction prompts
-        prompt = (
-            f"Extract information from this document and return ONLY a valid JSON object "
-            f"matching this schema: {json.dumps(schema)}. "
-            f"Use null for missing fields. No explanation, no markdown."
+        image = Image.open(io.BytesIO(contents)).convert("RGB")
+    except Exception as e:
+        raise HTTPException(status_code=400, detail=f"Invalid image file: {str(e)}")
+
+    # Use the provided query as the prompt
+    messages = [
+        {
+            "role": "user",
+            "content": [
+                {"type": "image", "image": image},
+                {"type": "text", "text": query}
+            ]
+        }
+    ]
+
+    inputs = processor.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True,
+        return_dict=True,
+        return_tensors="pt"
+    ).to(DEVICE)
+
+    with torch.no_grad():
+        outputs = model.generate(
+            **inputs,
+            max_new_tokens=1024,
+            do_sample=False,  # Greedy decoding for deterministic OCR-like responses
+            temperature=0.1  # Low temp for factual extraction
         )
 
-        messages = [{"role": "user", "content": [
-            {"type": "image", "image": img},
-            {"type": "text",  "text": prompt}
-        ]}]
-
-        text = processor.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
-        inputs = processor(text=text, images=[img], return_tensors="pt").to(DEVICE)
-
-        with torch.inference_mode():
-            outputs = model.generate(
-                **inputs,
-                max_new_tokens=1024,
-                do_sample=False,
-            )
-
-        input_len = inputs["input_ids"].shape[1]
-        raw_output = processor.decode(outputs[0][input_len:], skip_special_tokens=True).strip()
-
-        # ── Parse JSON from response ──────────────────────────────
-        try:
-            # Strip markdown fences if present
-            clean = raw_output.replace("```json", "").replace("```", "").strip()
-            structured = json.loads(clean)
-        except json.JSONDecodeError:
-            # Fallback: extract JSON block
-            start, end = clean.find("{"), clean.rfind("}") + 1
-            structured = json.loads(clean[start:end]) if start != -1 else {"raw": raw_output}
-
-    except Exception as e:
-        logger.error(f"❌ Error: {e}")
-        raise HTTPException(status_code=500, detail="Extraction failed.")
+    result = processor.batch_decode(outputs, skip_special_tokens=True)[0]
 
-    elapsed = round((time.perf_counter() - t0) * 1000)
-    logger.info(f"✅ Done in {elapsed}ms")
+    # Clean up: Remove the query prefix from the response
+    if query in result:
+        extracted_text = result.split(query, 1)[1].strip()
+    else:
+        extracted_text = result.strip()
 
     return {
-        "data": structured,
-        "schema_used": schema_label,
-        "inference_ms": elapsed,
-        "model": MODEL_ID,
+        "query": query,
+        "extracted_text": extracted_text,
+        "full_response": result,
+        "model": MODEL_ID
     }
 
 
 if __name__ == "__main__":
-    import uvicorn
-    uvicorn.run("app:app", host="0.0.0.0", port=7860, reload=False)
+    uvicorn.run(app, host="0.0.0.0", port=7860)

requirements.txt

@@ -1,6 +1,6 @@
-fastapi
-uvicorn
-python-multipart
-pillow
-transformers
-torch --index-url https://download.pytorch.org/whl/cpu
+fastapi==0.115.0
+uvicorn[standard]==0.32.0
+transformers==4.46.3
+torch==2.5.1
+pillow==11.1.0
+python-multipart==0.0.12