Upload 8 files

Dockerfile

@@ -0,0 +1,37 @@
+FROM python:3.10-slim
+
+WORKDIR /app
+
+# Install system dependencies for OpenCV and other libraries
+RUN apt-get update && apt-get install -y \
+    git \
+    libgl1-mesa-glx \
+    libglib2.0-0 \
+    libsm6 \
+    libxext6 \
+    libxrender-dev \
+    libgomp1 \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy requirements first for better caching
+COPY requirements.txt .
+
+# Install Python dependencies
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy application files
+COPY config.py .
+COPY model_manager.py .
+COPY inference.py .
+COPY app.py .
+COPY utils/ utils/
+
+# Expose Hugging Face Spaces default port
+EXPOSE 7860
+
+# Health check
+HEALTHCHECK --interval=30s --timeout=10s --start-period=60s --retries=3 \
+    CMD python -c "import requests; requests.get('http://localhost:7860/health')"
+
+# Run the FastAPI application
+CMD ["python", "app.py"]

app.py

@@ -0,0 +1,245 @@
+"""
+FastAPI Server for Invoice Information Extractor
+Provides REST API for invoice processing
+"""
+
+from fastapi import FastAPI, File, UploadFile, HTTPException, Form
+from fastapi.responses import JSONResponse
+from fastapi.middleware.cors import CORSMiddleware
+from contextlib import asynccontextmanager
+from typing import Optional
+import tempfile
+import os
+import shutil
+
+from config import API_TITLE, API_DESCRIPTION, API_VERSION
+from model_manager import model_manager
+from inference import InferenceProcessor
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    """Lifecycle manager - loads models on startup"""
+    print("🚀 Starting Invoice Information Extractor API...")
+    print("=" * 60)
+    
+    # Load models on startup
+    try:
+        model_manager.load_models()
+        print("=" * 60)
+        print("✅ API is ready to accept requests!")
+        print("=" * 60)
+    except Exception as e:
+        print(f"❌ Failed to load models: {str(e)}")
+        raise
+    
+    yield
+    
+    # Cleanup on shutdown
+    print("🛑 Shutting down API...")
+
+
+# Initialize FastAPI app
+app = FastAPI(
+    title=API_TITLE,
+    description=API_DESCRIPTION,
+    version=API_VERSION,
+    lifespan=lifespan
+)
+
+# Add CORS middleware
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+
+@app.get("/")
+async def root():
+    """Root endpoint - API information"""
+    return {
+        "name": API_TITLE,
+        "version": API_VERSION,
+        "status": "running",
+        "models_loaded": model_manager.is_loaded(),
+        "endpoints": {
+            "health": "/health",
+            "extract": "/extract (POST)",
+            "docs": "/docs"
+        }
+    }
+
+
+@app.get("/health")
+async def health_check():
+    """Health check endpoint"""
+    return {
+        "status": "healthy",
+        "models_loaded": model_manager.is_loaded()
+    }
+
+
+@app.post("/extract")
+async def extract_invoice(
+    file: UploadFile = File(..., description="Invoice image file (JPG, PNG, JPEG)"),
+    doc_id: Optional[str] = Form(None, description="Optional document identifier")
+):
+    """
+    Extract information from invoice image
+    
+    **Parameters:**
+    - **file**: Invoice image file (required)
+    - **doc_id**: Optional document identifier (auto-generated from filename if not provided)
+    
+    **Returns:**
+    - JSON with extracted fields, confidence scores, and metadata
+    
+    **Example Response:**
+    ```json
+    {
+        "doc_id": "invoice_001",
+        "fields": {
+            "dealer_name": "ABC Tractors Pvt Ltd",
+            "model_name": "Mahindra 575 DI",
+            "horse_power": 50,
+            "asset_cost": 525000,
+            "signature": {"present": true, "bbox": [100, 200, 300, 250]},
+            "stamp": {"present": true, "bbox": [400, 500, 500, 550]}
+        },
+        "confidence": 0.89,
+        "processing_time_sec": 3.8,
+        "cost_estimate_usd": 0.000528
+    }
+    ```
+    """
+    
+    # Validate file type
+    if not file.content_type.startswith("image/"):
+        raise HTTPException(
+            status_code=400,
+            detail="File must be an image (JPG, PNG, JPEG)"
+        )
+    
+    # Check if models are loaded
+    if not model_manager.is_loaded():
+        raise HTTPException(
+            status_code=503,
+            detail="Models not loaded. Please wait for server initialization."
+        )
+    
+    # Save uploaded file to temporary location
+    temp_file = None
+    try:
+        # Create temporary file
+        suffix = os.path.splitext(file.filename)[1]
+        with tempfile.NamedTemporaryFile(delete=False, suffix=suffix) as temp:
+            temp_file = temp.name
+            # Write uploaded file content
+            shutil.copyfileobj(file.file, temp)
+        
+        # Use filename as doc_id if not provided
+        if doc_id is None:
+            doc_id = os.path.splitext(file.filename)[0]
+        
+        # Process invoice
+        result = InferenceProcessor.process_invoice(temp_file, doc_id)
+        
+        return JSONResponse(content=result)
+        
+    except Exception as e:
+        raise HTTPException(
+            status_code=500,
+            detail=f"Error processing invoice: {str(e)}"
+        )
+    
+    finally:
+        # Clean up temporary file
+        if temp_file and os.path.exists(temp_file):
+            try:
+                os.unlink(temp_file)
+            except:
+                pass
+        
+        # Close uploaded file
+        file.file.close()
+
+
+@app.post("/extract_batch")
+async def extract_batch(
+    files: list[UploadFile] = File(..., description="Multiple invoice images")
+):
+    """
+    Extract information from multiple invoice images
+    
+    **Parameters:**
+    - **files**: List of invoice image files
+    
+    **Returns:**
+    - JSON array with results for each invoice
+    """
+    
+    if not model_manager.is_loaded():
+        raise HTTPException(
+            status_code=503,
+            detail="Models not loaded. Please wait for server initialization."
+        )
+    
+    results = []
+    temp_files = []
+    
+    try:
+        for file in files:
+            # Validate file type
+            if not file.content_type.startswith("image/"):
+                results.append({
+                    "filename": file.filename,
+                    "error": "File must be an image"
+                })
+                continue
+            
+            # Save to temp file
+            suffix = os.path.splitext(file.filename)[1]
+            with tempfile.NamedTemporaryFile(delete=False, suffix=suffix) as temp:
+                temp_file = temp.name
+                temp_files.append(temp_file)
+                shutil.copyfileobj(file.file, temp)
+            
+            # Process
+            try:
+                doc_id = os.path.splitext(file.filename)[0]
+                result = InferenceProcessor.process_invoice(temp_file, doc_id)
+                results.append(result)
+            except Exception as e:
+                results.append({
+                    "filename": file.filename,
+                    "error": str(e)
+                })
+        
+        return JSONResponse(content={"results": results})
+        
+    finally:
+        # Cleanup
+        for temp_file in temp_files:
+            if os.path.exists(temp_file):
+                try:
+                    os.unlink(temp_file)
+                except:
+                    pass
+        
+        for file in files:
+            file.file.close()
+
+
+if __name__ == "__main__":
+    import uvicorn
+    
+    # Run server
+    uvicorn.run(
+        "app:app",
+        host="0.0.0.0",
+        port=7860,  # Hugging Face Spaces default port
+        reload=False
+    )

config.py

@@ -0,0 +1,49 @@
+"""
+Configuration settings for Invoice Information Extractor API
+"""
+
+import os
+from pathlib import Path
+
+# Base directories
+BASE_DIR = Path(__file__).resolve().parent
+MODELS_DIR = BASE_DIR / "utils" / "models"
+
+# Model paths
+YOLO_MODEL_PATH = MODELS_DIR / "best.pt"
+
+# VLM Model Configuration
+VLM_MODEL_ID = "Qwen/Qwen2.5-VL-7B-Instruct"
+
+# Quantization settings
+QUANTIZATION_CONFIG = {
+    "load_in_4bit": True,
+    "bnb_4bit_quant_type": "nf4",
+    "bnb_4bit_compute_dtype": "float16",
+    "bnb_4bit_use_double_quant": True
+}
+
+# Image processing settings
+MAX_IMAGE_SIZE = 512  # Maximum dimension for resizing
+
+# Detection thresholds
+YOLO_CONFIDENCE_THRESHOLD = 0.25
+
+# Validation ranges
+HP_VALID_RANGE = (20, 120)
+ASSET_COST_VALID_RANGE = (100_000, 3_000_000)
+
+# Cost calculation
+COST_PER_GPU_HOUR = 0.5  # USD
+
+# API settings
+API_TITLE = "Invoice Information Extractor API"
+API_DESCRIPTION = """
+Extract structured information from Indian tractor invoices using AI.
+
+**Features:**
+- Extracts dealer name, model name, horse power, and asset cost
+- Detects signatures and stamps with bounding boxes
+- Provides confidence scores and cost estimates
+"""
+API_VERSION = "1.0.0"

inference.py

@@ -0,0 +1,351 @@
+"""
+Inference Processor - Handles VLM extraction, validation, and result formatting
+"""
+
+import torch
+import time
+import json
+import codecs
+import re
+from PIL import Image
+from qwen_vl_utils import process_vision_info
+from typing import Dict, Tuple
+
+from config import (
+    MAX_IMAGE_SIZE,
+    HP_VALID_RANGE,
+    ASSET_COST_VALID_RANGE,
+    COST_PER_GPU_HOUR
+)
+from model_manager import model_manager
+
+
+EXTRACTION_PROMPT = """
+You are an expert at reading noisy, handwritten Indian invoices and quotations.
+
+Your task is to extract text EXACTLY as it appears in the image.
+Do NOT translate, summarize, normalize, or rewrite any text.
+Preserve the original language (Hindi, Marathi, Kannada, English, etc.).
+
+Carefully read the image and extract the following fields.
+
+Return ONLY valid JSON in this format:
+
+{
+  "dealer_name": string,
+  "model_name": string,
+  "horse_power": number,
+  "asset_cost": number
+}
+
+Critical rules:
+- Dealer name must be copied exactly from the image in the original language and spelling.
+- Model name must be copied exactly from the image without translation.
+- Do NOT convert regional language text into English.
+- Do NOT expand abbreviations or correct spelling.
+- Only numbers may be normalized.
+
+Extraction hints:
+- Asset cost is the total amount, usually the largest number on the page, the total amount after TAX, final price or final cost.
+- Dealer name is usually at the top header or company name.
+- Model name often appears near words like Model, Tractor, Variant.
+- Horse power must come ONLY from explicit HP text, never from model numbers.
+- Horse power may appear as "HP", handwritten like "49 HP", "63hp", "HP-30".
+- Remove commas and currency symbols from numbers only.
+- If handwriting is unclear, make your best reasonable interpretation of the characters — but preserve language.
+
+Output rules:
+- Output ONLY valid JSON.
+- Do NOT include markdown, explanations, or extra text.
+"""
+
+
+class InferenceProcessor:
+    """Handles VLM inference, validation, and result processing"""
+    
+    @staticmethod
+    def preprocess_image(image_path: str) -> Image.Image:
+        """Load and resize image if needed"""
+        image = Image.open(image_path).convert("RGB")
+        
+        # Resize if too large
+        if max(image.size) > MAX_IMAGE_SIZE:
+            ratio = MAX_IMAGE_SIZE / max(image.size)
+            new_size = (int(image.size[0] * ratio), int(image.size[1] * ratio))
+            image = image.resize(new_size, Image.LANCZOS)
+            print(f"🔄 Image resized to {new_size}")
+        
+        return image
+    
+    @staticmethod
+    def run_vlm_extraction(image: Image.Image) -> Tuple[str, float]:
+        """Run VLM model to extract invoice fields"""
+        if not model_manager.is_loaded():
+            raise RuntimeError("Models not loaded")
+        
+        model = model_manager.vlm_model
+        processor = model_manager.processor
+        
+        messages = [
+            {
+                "role": "user",
+                "content": [
+                    {"type": "image", "image": image},
+                    {"type": "text", "text": EXTRACTION_PROMPT}
+                ]
+            }
+        ]
+        
+        # Apply chat template
+        text = processor.apply_chat_template(
+            messages,
+            tokenize=False,
+            add_generation_prompt=True
+        )
+        
+        # Process vision input
+        image_inputs, video_inputs = process_vision_info(messages)
+        inputs = processor(
+            text=[text],
+            images=image_inputs,
+            videos=video_inputs,
+            padding=True,
+            return_tensors="pt",
+        )
+        inputs = inputs.to("cuda")
+        
+        start = time.time()
+        
+        # Generate
+        generated_ids = model.generate(**inputs, max_new_tokens=256)
+        
+        latency = time.time() - start
+        
+        # Decode output
+        generated_ids_trimmed = [
+            out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)
+        ]
+        output_text = processor.batch_decode(
+            generated_ids_trimmed, 
+            skip_special_tokens=True, 
+            clean_up_tokenization_spaces=False
+        )
+        
+        output_text = output_text[0] if isinstance(output_text, list) else output_text
+        
+        # Clean up GPU memory
+        del inputs, generated_ids, generated_ids_trimmed
+        if torch.cuda.is_available():
+            torch.cuda.empty_cache()
+        
+        return output_text, latency
+    
+    @staticmethod
+    def extract_json_from_output(text: str) -> Dict:
+        """Extract JSON from model output"""
+        # Handle single/double backticks
+        if text.count('```') in [1, 2]:
+            data = text.split('```')[1]
+            if data.startswith('json'):
+                data = data[4:]
+            try:
+                return json.loads(codecs.decode(data, "unicode-escape"))
+            except:
+                pass
+        
+        # Try markdown code blocks
+        markdown_match = re.search(r'```(?:json)?\s*(\{.*?\})\s*```', text, re.DOTALL)
+        if markdown_match:
+            try:
+                return json.loads(markdown_match.group(1))
+            except json.JSONDecodeError:
+                pass
+        
+        # Find JSON blocks
+        json_matches = re.finditer(r'\{[^{}]*(?:\{[^{}]*\}[^{}]*)*\}', text, re.DOTALL)
+        
+        for match in json_matches:
+            json_str = match.group(0)
+            try:
+                parsed = json.loads(json_str)
+                # Verify expected keys
+                if all(key in parsed for key in ["dealer_name", "model_name", "horse_power", "asset_cost"]):
+                    return parsed
+            except json.JSONDecodeError:
+                continue
+        
+        # Fallback
+        return {
+            "dealer_name": None,
+            "model_name": None,
+            "horse_power": None,
+            "asset_cost": None
+        }
+    
+    @staticmethod
+    def clean_text(text) -> str:
+        """Clean text field"""
+        if not text:
+            return None
+        text = str(text).strip()
+        text = re.sub(r"\s+", " ", text)
+        return text if len(text) > 1 else None
+    
+    @staticmethod
+    def clean_number(num):
+        """Clean number field"""
+        try:
+            if num is None:
+                return None
+            return int(float(num))
+        except:
+            return None
+    
+    @staticmethod
+    def fix_horse_power(vlm_hp, model_name) -> Tuple:
+        """Fix common HP extraction mistakes"""
+        # Accept if in valid range
+        if vlm_hp is not None and HP_VALID_RANGE[0] <= vlm_hp <= HP_VALID_RANGE[1]:
+            return vlm_hp, 1.0
+        
+        # Try extracting from model name
+        if model_name:
+            match = re.search(r"HP[- ]?(\d+)", model_name, re.I)
+            if match:
+                hp = int(match.group(1))
+                if HP_VALID_RANGE[0] <= hp <= HP_VALID_RANGE[1]:
+                    return hp, 0.8
+        
+        return None, 0.2
+    
+    @staticmethod
+    def validate_asset_cost(cost) -> Tuple:
+        """Validate asset cost"""
+        if cost is None:
+            return None, 0.2
+        
+        cost = InferenceProcessor.clean_number(cost)
+        
+        if ASSET_COST_VALID_RANGE[0] <= cost <= ASSET_COST_VALID_RANGE[1]:
+            return cost, 1.0
+        
+        return None, 0.3
+    
+    @staticmethod
+    def validate_text_field(text) -> Tuple:
+        """Validate text fields"""
+        text = InferenceProcessor.clean_text(text)
+        if not text or len(text) < 3:
+            return None, 0.3
+        return text, 1.0
+    
+    @staticmethod
+    def validate_prediction(raw_json: Dict) -> Tuple[Dict, float, list]:
+        """Validate and fix extracted fields"""
+        warnings = []
+        confidences = []
+        
+        # Dealer
+        dealer, dealer_conf = InferenceProcessor.validate_text_field(raw_json.get("dealer_name"))
+        if dealer is None:
+            warnings.append("Dealer name invalid")
+        confidences.append(dealer_conf)
+        
+        # Model
+        model_name, model_conf = InferenceProcessor.validate_text_field(raw_json.get("model_name"))
+        if model_name is None:
+            warnings.append("Model name invalid")
+        confidences.append(model_conf)
+        
+        # Horse Power
+        hp_raw = InferenceProcessor.clean_number(raw_json.get("horse_power"))
+        hp, hp_conf = InferenceProcessor.fix_horse_power(hp_raw, model_name)
+        if hp is None:
+            warnings.append("Horse power invalid")
+        confidences.append(hp_conf)
+        
+        # Asset Cost
+        cost_raw = InferenceProcessor.clean_number(raw_json.get("asset_cost"))
+        cost, cost_conf = InferenceProcessor.validate_asset_cost(cost_raw)
+        if cost is None:
+            warnings.append("Asset cost invalid")
+        confidences.append(cost_conf)
+        
+        # Overall field confidence
+        field_confidence = round(sum(confidences) / len(confidences), 3)
+        
+        validated = {
+            "dealer_name": dealer,
+            "model_name": model_name,
+            "horse_power": hp,
+            "asset_cost": cost
+        }
+        
+        return validated, field_confidence, warnings
+    
+    @staticmethod
+    def process_invoice(image_path: str, doc_id: str = None) -> Dict:
+        """
+        Complete invoice processing pipeline
+        
+        Args:
+            image_path: Path to invoice image
+            doc_id: Document identifier (optional)
+        
+        Returns:
+            dict: Complete JSON output with all fields
+        """
+        total_start = time.time()
+        
+        # Generate doc_id if not provided
+        if doc_id is None:
+            import os
+            doc_id = os.path.splitext(os.path.basename(image_path))[0]
+        
+        # Step 1: Preprocess image
+        image = InferenceProcessor.preprocess_image(image_path)
+        
+        # Step 2: YOLO Detection
+        signature_info, stamp_info, signature_conf, stamp_conf = model_manager.detect_sign_stamp(image_path)
+        
+        # Step 3: VLM Extraction
+        vlm_output, vlm_latency = InferenceProcessor.run_vlm_extraction(image)
+        
+        # Clean up image
+        image.close()
+        del image
+        
+        # Step 4: Parse JSON
+        raw_json = InferenceProcessor.extract_json_from_output(vlm_output)
+        
+        # Step 5: Validate and fix
+        validated_fields, field_confidence, warnings = InferenceProcessor.validate_prediction(raw_json)
+        
+        # Add signature and stamp
+        validated_fields["signature"] = signature_info
+        validated_fields["stamp"] = stamp_info
+        
+        # Calculate overall confidence
+        confidences = [field_confidence]
+        if signature_info["present"]:
+            confidences.append(signature_conf)
+        if stamp_info["present"]:
+            confidences.append(stamp_conf)
+        
+        overall_confidence = round(sum(confidences) / len(confidences), 3)
+        
+        # Calculate time and cost
+        total_time = time.time() - total_start
+        cost_estimate = (COST_PER_GPU_HOUR * total_time) / 3600
+        
+        # Build result
+        result = {
+            "doc_id": doc_id,
+            "fields": validated_fields,
+            "confidence": overall_confidence,
+            "processing_time_sec": round(total_time, 2),
+            "cost_estimate_usd": round(cost_estimate, 6),
+            "warnings": warnings if warnings else None
+        }
+        
+        return result

model_manager.py

@@ -0,0 +1,145 @@
+"""
+Model Manager - Handles loading and caching of YOLO and VLM models
+"""
+
+import torch
+from transformers import (
+    Qwen2_5_VLForConditionalGeneration,
+    AutoProcessor,
+    BitsAndBytesConfig
+)
+from ultralytics import YOLO
+import os
+from typing import Tuple
+
+from config import (
+    YOLO_MODEL_PATH,
+    VLM_MODEL_ID,
+    QUANTIZATION_CONFIG,
+    YOLO_CONFIDENCE_THRESHOLD
+)
+
+
+class ModelManager:
+    """Singleton class to manage model loading and inference"""
+    
+    _instance = None
+    _initialized = False
+    
+    def __new__(cls):
+        if cls._instance is None:
+            cls._instance = super(ModelManager, cls).__new__(cls)
+        return cls._instance
+    
+    def __init__(self):
+        if not ModelManager._initialized:
+            self.yolo_model = None
+            self.vlm_model = None
+            self.processor = None
+            ModelManager._initialized = True
+    
+    def load_models(self):
+        """Load both YOLO and VLM models into memory"""
+        print("🚀 Starting model loading...")
+        
+        # Load YOLO model
+        self.yolo_model = self._load_yolo_model()
+        
+        # Load VLM model
+        self.vlm_model, self.processor = self._load_vlm_model()
+        
+        print("✅ All models loaded successfully!")
+    
+    def _load_yolo_model(self) -> YOLO:
+        """Load trained YOLO model for signature and stamp detection"""
+        if not os.path.exists(YOLO_MODEL_PATH):
+            raise FileNotFoundError(
+                f"YOLO model not found at {YOLO_MODEL_PATH}. "
+                "Please ensure best.pt is in utils/models/"
+            )
+        
+        yolo_model = YOLO(str(YOLO_MODEL_PATH))
+        print(f"✅ YOLO model loaded from {YOLO_MODEL_PATH}")
+        return yolo_model
+    
+    def _load_vlm_model(self) -> Tuple:
+        """
+        Load Qwen2.5-VL model with 4-bit quantization
+        Downloads from Hugging Face on first run
+        """
+        print(f"📥 Loading VLM model: {VLM_MODEL_ID}")
+        print("   (This will download ~4GB on first run)")
+        
+        # Configure 4-bit quantization
+        bnb_config = BitsAndBytesConfig(
+            load_in_4bit=QUANTIZATION_CONFIG["load_in_4bit"],
+            bnb_4bit_quant_type=QUANTIZATION_CONFIG["bnb_4bit_quant_type"],
+            bnb_4bit_compute_dtype=getattr(torch, QUANTIZATION_CONFIG["bnb_4bit_compute_dtype"]),
+            bnb_4bit_use_double_quant=QUANTIZATION_CONFIG["bnb_4bit_use_double_quant"]
+        )
+        
+        # Load processor
+        processor = AutoProcessor.from_pretrained(
+            VLM_MODEL_ID,
+            trust_remote_code=True
+        )
+        
+        # Load model with quantization
+        model = Qwen2_5_VLForConditionalGeneration.from_pretrained(
+            VLM_MODEL_ID,
+            quantization_config=bnb_config,
+            device_map="auto",
+            torch_dtype=torch.bfloat16,
+            trust_remote_code=True
+        )
+        
+        model.eval()
+        print(f"✅ Qwen2.5-VL model loaded successfully")
+        
+        return model, processor
+    
+    def detect_sign_stamp(self, image_path: str):
+        """
+        Detect signature and stamp in the image using YOLO
+        
+        Returns:
+            tuple: (signature_info, stamp_info, signature_conf, stamp_conf)
+        """
+        if self.yolo_model is None:
+            raise RuntimeError("YOLO model not loaded. Call load_models() first.")
+        
+        results = self.yolo_model(image_path, verbose=False)[0]
+        
+        signature_info = {"present": False, "bbox": None}
+        stamp_info = {"present": False, "bbox": None}
+        signature_conf = 0.0
+        stamp_conf = 0.0
+        
+        if results.boxes is not None:
+            for box in results.boxes:
+                cls_id = int(box.cls[0])
+                conf = float(box.conf[0])
+                
+                if conf > YOLO_CONFIDENCE_THRESHOLD:
+                    bbox = box.xyxy[0].cpu().numpy().tolist()
+                    bbox = [int(coord) for coord in bbox]
+                    
+                    # Class 0: signature, Class 1: stamp
+                    if cls_id == 0 and conf > signature_conf:
+                        signature_info = {"present": True, "bbox": bbox}
+                        signature_conf = conf
+                    elif cls_id == 1 and conf > stamp_conf:
+                        stamp_info = {"present": True, "bbox": bbox}
+                        stamp_conf = conf
+        
+        return signature_info, stamp_info, signature_conf, stamp_conf
+    
+    def is_loaded(self) -> bool:
+        """Check if models are loaded"""
+        return (self.yolo_model is not None and 
+                self.vlm_model is not None and 
+                self.processor is not None)
+
+
+# Global model manager instance
+model_manager = ModelManager()

requirements.txt

@@ -0,0 +1,12 @@
+torch
+transformers
+ultralytics
+pillow
+accelerate
+bitsandbytes
+opencv-python
+pyyaml
+qwen-vl-utils[decord]
+fastapi
+uvicorn[standard]
+python-multipart

start.sh

@@ -0,0 +1,26 @@
+#!/bin/bash
+
+# Startup script for Invoice Information Extractor API
+# For Hugging Face Spaces or production deployment
+
+echo "🚀 Invoice Information Extractor - Starting..."
+echo "=============================================="
+
+# Check Python version
+python_version=$(python --version 2>&1)
+echo "Python: $python_version"
+
+# Check CUDA availability
+if command -v nvidia-smi &> /dev/null; then
+    echo "GPU: Available"
+    nvidia-smi --query-gpu=name,memory.total --format=csv,noheader
+else
+    echo "⚠️  WARNING: No GPU detected. This application requires GPU!"
+fi
+
+echo ""
+echo "Starting FastAPI server..."
+echo "=============================================="
+
+# Start the application
+python app.py

utils/models/best.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:47241e8bafe01e99fc875e1010191d0aa40d797b5f1a5d5110d1cce8b6da8f3d
+size 22508131