Upload 6 files

Dockerfile

@@ -0,0 +1,25 @@
+FROM python:3.9-slim
+
+# Environment variables for ONNX Runtime 1.18.0
+ENV PYTHONUNBUFFERED=1
+ENV PORT=7860
+ENV OMP_NUM_THREADS=1
+ENV ORT_DISABLE_ALL_WARNINGS=1
+ENV ONNXRUNTIME_DISABLE_STACK_EXECUTABILITY_WARNING=1
+
+# Working directory  
+WORKDIR /app
+
+# Copy and install Python requirements
+COPY requirements.txt .
+RUN pip install --no-cache-dir --upgrade pip && \
+    pip install --no-cache-dir -r requirements.txt
+
+# Copy application files
+COPY . .
+
+# Expose port
+EXPOSE 7860
+
+# Start application with more verbose logging and timeout settings
+CMD ["python", "-m", "uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860", "--timeout-keep-alive", "300", "--log-level", "info"]

app.py

@@ -0,0 +1,366 @@
+import os
+import io
+import json
+import base64
+import secrets
+from PIL import Image
+import numpy as np
+
+# Set environment variables for ONNX Runtime 1.18.0
+os.environ['OMP_NUM_THREADS'] = '1'
+os.environ['ORT_DISABLE_ALL_WARNINGS'] = '1'
+os.environ['ONNXRUNTIME_DISABLE_STACK_EXECUTABILITY_WARNING'] = '1'
+
+# Import ONNX Runtime 1.18.0 with error handling
+try:
+    import onnxruntime as ort
+    print("✅ ONNX Runtime 1.18.0 imported successfully")
+except ImportError as e:
+    print(f"⚠️ ONNX Runtime import error: {e}")
+    print("🔧 Applying workarounds for ONNX Runtime 1.18.0...")
+    
+    # Workarounds for newer ONNX Runtime versions
+    import sys
+    import warnings
+    warnings.filterwarnings('ignore')
+    
+    try:
+        import ctypes
+        # Disable executable stack warnings
+        libc = ctypes.CDLL("libc.so.6")
+        libc.personality(0x040000)
+    except:
+        pass
+    
+    import onnxruntime as ort
+    print("✅ ONNX Runtime 1.18.0 imported with workarounds")
+
+from fastapi import FastAPI, HTTPException, Depends, Header
+from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
+from pydantic import BaseModel
+from typing import Optional, List
+import yaml
+
+# Load configuration
+with open('data.yaml', 'r') as f:
+    config = yaml.safe_load(f)
+
+# Initialize FastAPI app
+app = FastAPI(
+    title="Geetest Slider Detection API",
+    description="ONNX-based slider position detection for Geetest captcha",
+    version="1.0.0"
+)
+
+# Security
+security = HTTPBearer()
+SECRET_KEY = os.getenv("API_SECRET_KEY", "DASDAS2")
+
+# Load ONNX model with better error handling
+session = None
+model_loaded = False
+
+def load_onnx_model():
+    global session, model_loaded
+    try:
+        # Check if model file exists
+        if not os.path.exists("best_model.onnx"):
+            print("⚠️  Model file 'best_model.onnx' not found")
+            return False
+        
+        # ONNX Runtime 1.18.0 session creation with optimized settings
+        session_options = ort.SessionOptions()
+        session_options.enable_cpu_mem_arena = False
+        session_options.enable_mem_pattern = False
+        session_options.enable_mem_reuse = False
+        session_options.execution_mode = ort.ExecutionMode.ORT_SEQUENTIAL
+        session_options.inter_op_num_threads = 1
+        session_options.intra_op_num_threads = 1
+        
+        # CPU provider options for ONNX Runtime 1.18.0
+        cpu_provider_options = {
+            'arena_extend_strategy': 'kSameAsRequested',
+            'enable_cpu_mem_arena': '0'
+        }
+        
+        providers = [('CPUExecutionProvider', cpu_provider_options)]
+        
+        session = ort.InferenceSession(
+            "best_model.onnx", 
+            providers=providers,
+            sess_options=session_options
+        )
+        
+        print("✅ ONNX model loaded successfully")
+        print(f"✅ ONNX Runtime version: {ort.__version__}")
+        print(f"✅ Using providers: {session.get_providers()}")
+        model_loaded = True
+        return True
+        
+    except Exception as e:
+        print(f"❌ Error loading ONNX model: {e}")
+        
+        # Fallback with basic configuration
+        try:
+            print("🔧 Trying fallback configuration...")
+            session = ort.InferenceSession("best_model.onnx", providers=['CPUExecutionProvider'])
+            print("✅ ONNX model loaded with fallback configuration")
+            model_loaded = True
+            return True
+        except Exception as fallback_error:
+            print(f"❌ Fallback failed: {fallback_error}")
+            print("💡 Tip: Make sure 'best_model.onnx' is uploaded to the Space")
+            session = None
+            model_loaded = False
+            return False
+
+# Try to load model on startup
+load_onnx_model()
+
+class PredictionRequest(BaseModel):
+    image: str  # Base64 encoded image
+    task: str = "slider_detection"
+    confidence_threshold: float = 0.5
+
+class BoundingBox(BaseModel):
+    x: float
+    y: float
+    width: float
+    height: float
+    confidence: float
+
+class PredictionResponse(BaseModel):
+    success: bool
+    bbox: Optional[BoundingBox] = None
+    slider_position: Optional[float] = None
+    confidence: float = 0.0
+    message: str = ""
+
+def verify_api_key(credentials: HTTPAuthorizationCredentials = Depends(security)):
+    """Verify API key for authentication"""
+    if credentials.credentials != SECRET_KEY:
+        raise HTTPException(
+            status_code=401,
+            detail="Invalid API key"
+        )
+    return credentials.credentials
+
+def preprocess_image(image: Image.Image, target_size=(640, 640)):
+    """Preprocess image for ONNX model"""
+    try:
+        # Convert to RGB if needed
+        if image.mode != 'RGB':
+            image = image.convert('RGB')
+        
+        # Resize while maintaining aspect ratio
+        original_size = image.size
+        image = image.resize(target_size, Image.LANCZOS)
+        
+        # Convert to numpy array and normalize
+        img_array = np.array(image, dtype=np.float32)
+        img_array = img_array / 255.0  # Normalize to [0, 1]
+        
+        # Transpose to CHW format (channels first)
+        img_array = np.transpose(img_array, (2, 0, 1))
+        
+        # Add batch dimension
+        img_array = np.expand_dims(img_array, axis=0)
+        
+        return img_array, original_size
+        
+    except Exception as e:
+        raise HTTPException(status_code=400, detail=f"Error preprocessing image: {str(e)}")
+
+def postprocess_predictions(outputs, original_size, target_size=(640, 640), confidence_threshold=0.5):
+    """Postprocess ONNX model outputs"""
+    try:
+        # Extract predictions (assuming YOLOv8 format)
+        predictions = outputs[0]  # Shape: [1, 84, 8400] or similar
+        
+        # Handle different output formats
+        if len(predictions.shape) == 3:
+            predictions = predictions[0]  # Remove batch dimension
+        
+        # Transpose if needed to get [num_boxes, features]
+        if predictions.shape[0] < predictions.shape[1]:
+            predictions = predictions.T
+        
+        # Extract bbox coordinates and confidence
+        boxes = predictions[:, :4]  # x, y, w, h
+        confidences = predictions[:, 4]  # objectness score
+        
+        # Filter by confidence
+        valid_indices = confidences > confidence_threshold
+        
+        if not np.any(valid_indices):
+            return None
+        
+        # Get best detection
+        best_idx = np.argmax(confidences)
+        best_box = boxes[best_idx]
+        best_conf = confidences[best_idx]
+        
+        # Scale coordinates back to original image size
+        scale_x = original_size[0] / target_size[0]
+        scale_y = original_size[1] / target_size[1]
+        
+        x_center, y_center, width, height = best_box
+        
+        # Convert to absolute coordinates
+        x_center *= scale_x
+        y_center *= scale_y
+        width *= scale_x
+        height *= scale_y
+        
+        # Convert center format to corner format
+        x = x_center - width / 2
+        y = y_center - height / 2
+        
+        # Calculate slider position (x-coordinate of the gap/missing piece)
+        slider_position = x_center  # Use center x as slider position
+        
+        return BoundingBox(
+            x=float(x),
+            y=float(y),
+            width=float(width),
+            height=float(height),
+            confidence=float(best_conf)
+        ), float(slider_position)
+        
+    except Exception as e:
+        print(f"Error in postprocessing: {e}")
+        return None, None
+
+@app.get("/")
+async def root():
+    """Health check endpoint"""
+    return {
+        "status": "ok",
+        "message": "Geetest Slider Detection API is running",
+        "model_loaded": model_loaded
+    }
+
+@app.get("/")
+async def root():
+    """Root endpoint - keeps Space alive and shows API info"""
+    return {
+        "message": "🚀 Geetest Slider API v1.0 - ONNX Runtime 1.18.0",
+        "status": "running",
+        "model_loaded": model_loaded,
+        "onnx_version": ort.__version__ if 'ort' in globals() else "not loaded",
+        "api_endpoints": {
+            "predict": "POST /predict (requires Authorization: Bearer token)",
+            "health": "GET /health",
+            "reload": "POST /reload-model (requires auth)"
+        },
+        "usage": "Send base64 image to /predict endpoint with your API key"
+    }
+
+@app.get("/health")
+async def health():
+    """Detailed health check"""
+    return {
+        "status": "healthy" if model_loaded else "unhealthy",
+        "model_loaded": model_loaded,
+        "onnx_providers": session.get_providers() if session else None,
+        "config": {
+            "classes": config.get('names', []),
+            "nc": config.get('nc', 0)
+        }
+    }
+
+@app.post("/reload-model")
+async def reload_model(api_key: str = Depends(verify_api_key)):
+    """Reload ONNX model (useful for debugging)"""
+    success = load_onnx_model()
+    return {
+        "success": success,
+        "model_loaded": model_loaded,
+        "message": "Model reloaded successfully" if success else "Failed to reload model"
+    }
+
+@app.post("/predict", response_model=PredictionResponse)
+async def predict_slider(
+    request: PredictionRequest,
+    api_key: str = Depends(verify_api_key)
+):
+    """Predict slider position from captcha image"""
+    
+    if not model_loaded or session is None:
+        raise HTTPException(status_code=503, detail="Model not loaded - please upload best_model.onnx")
+    
+    try:
+        # Decode base64 image
+        try:
+            image_data = base64.b64decode(request.image)
+            image = Image.open(io.BytesIO(image_data))
+        except Exception as e:
+            raise HTTPException(status_code=400, detail=f"Invalid image data: {str(e)}")
+        
+        # Preprocess image
+        processed_image, original_size = preprocess_image(image)
+        
+        # Run inference
+        input_name = session.get_inputs()[0].name
+        outputs = session.run(None, {input_name: processed_image})
+        
+        # Postprocess results
+        bbox, slider_position = postprocess_predictions(
+            outputs, 
+            original_size, 
+            confidence_threshold=request.confidence_threshold
+        )
+        
+        if bbox is None:
+            return PredictionResponse(
+                success=False,
+                message="No slider detection found",
+                confidence=0.0
+            )
+        
+        return PredictionResponse(
+            success=True,
+            bbox=bbox,
+            slider_position=slider_position,
+            confidence=bbox.confidence,
+            message="Slider position detected successfully"
+        )
+        
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Prediction error: {str(e)}")
+
+@app.post("/predict-batch")
+async def predict_batch(
+    images: List[str],
+    confidence_threshold: float = 0.5,
+    api_key: str = Depends(verify_api_key)
+):
+    """Batch prediction for multiple images"""
+    
+    if not model_loaded or session is None:
+        raise HTTPException(status_code=503, detail="Model not loaded - please upload best_model.onnx")
+    
+    results = []
+    for i, img_base64 in enumerate(images):
+        try:
+            request = PredictionRequest(
+                image=img_base64,
+                confidence_threshold=confidence_threshold
+            )
+            result = await predict_slider(request, api_key)
+            results.append({"index": i, "result": result})
+        except Exception as e:
+            results.append({
+                "index": i, 
+                "error": str(e),
+                "result": PredictionResponse(success=False, message=str(e))
+            })
+    
+    return {"predictions": results}
+
+if __name__ == "__main__":
+    import uvicorn
+    port = int(os.getenv("PORT", 7860))
+    uvicorn.run(app, host="0.0.0.0", port=port)

best_model.onnx

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

data.yaml

@@ -0,0 +1,12 @@
+names:
+- slide_captcha - v4 slide captcha
+nc: 1
+roboflow:
+  license: CC BY 4.0
+  project: slider-vytcr
+  url: https://universe.roboflow.com/slider-hbeeu/slider-vytcr/dataset/2
+  version: 2
+  workspace: slider-hbeeu
+test: ../test/images
+train: ../train/images
+val: ../valid/images

deploy-to-hf.py

@@ -0,0 +1,89 @@
+#!/usr/bin/env python3
+"""
+Script untuk deploy ke Hugging Face Spaces
+"""
+
+import os
+import subprocess
+import sys
+from pathlib import Path
+
+def run_command(cmd, cwd=None):
+    """Run shell command"""
+    try:
+        result = subprocess.run(cmd, shell=True, cwd=cwd, capture_output=True, text=True)
+        if result.returncode != 0:
+            print(f"❌ Error running command: {cmd}")
+            print(f"Error: {result.stderr}")
+            return False
+        print(f"✅ Success: {cmd}")
+        if result.stdout:
+            print(result.stdout)
+        return True
+    except Exception as e:
+        print(f"❌ Exception running command: {cmd}")
+        print(f"Error: {e}")
+        return False
+
+def main():
+    """Main deployment function"""
+    print("🚀 Deploying Geetest Slider Detection API to Hugging Face Spaces...")
+    
+    # Check if we're in the right directory
+    if not Path("app.py").exists():
+        print("❌ Error: app.py not found. Make sure you're in the deployment directory.")
+        sys.exit(1)
+    
+    # Check if model file exists
+    if not Path("best_model.onnx").exists():
+        print("⚠️  Warning: best_model.onnx not found!")
+        print("   Make sure to upload your trained ONNX model before deployment.")
+        response = input("   Continue anyway? (y/N): ")
+        if response.lower() != 'y':
+            sys.exit(1)
+    
+    # Get Hugging Face username and space name
+    hf_username = input("Enter your Hugging Face username: ")
+    space_name = input("Enter space name (e.g., geetest-slider-api): ")
+    
+    if not hf_username or not space_name:
+        print("❌ Username and space name are required!")
+        sys.exit(1)
+    
+    # Set up Git repository
+    print("\n📦 Setting up Git repository...")
+    
+    # Initialize git if not already done
+    if not Path(".git").exists():
+        run_command("git init")
+        run_command("git lfs install")
+    
+    # Add files
+    run_command("git add .")
+    run_command("git commit -m 'Initial deployment of Geetest Slider Detection API'")
+    
+    # Add Hugging Face remote
+    remote_url = f"https://huggingface.co/spaces/{hf_username}/{space_name}"
+    run_command(f"git remote add origin {remote_url}")
+    
+    # Push to Hugging Face Spaces
+    print("\n🚀 Pushing to Hugging Face Spaces...")
+    if run_command("git push -u origin main"):
+        print(f"\n🎉 Deployment successful!")
+        print(f"Your API will be available at: {remote_url}")
+        print(f"\n🔑 Don't forget to set your API_SECRET_KEY in the Space settings!")
+        print("   Go to: Space Settings > Variables and secrets")
+        print("   Add: API_SECRET_KEY = your-secure-api-key")
+    else:
+        # Try with master branch
+        print("Trying with master branch...")
+        run_command("git push -u origin master")
+    
+    print("\n📋 Next steps:")
+    print("1. Upload your trained best_model.onnx file to the Space")
+    print("2. Set the API_SECRET_KEY environment variable")
+    print("3. Make the Space private for security")
+    print("4. Test the API endpoints")
+
+if __name__ == "__main__":
+    main()

requirements.txt

@@ -0,0 +1,8 @@
+fastapi==0.104.1
+uvicorn==0.24.0
+pydantic==2.5.0
+pillow==10.1.0
+numpy==1.24.4
+onnxruntime==1.18.0
+pyyaml==6.0.1
+python-multipart==0.0.6