Optimized api

Dockerfile

@@ -1,32 +1,67 @@
-FROM python:3.9-slim
 
-WORKDIR /code
+# Use minimal Python image with Intel MKL optimizations
+FROM python:3.9-slim-bullseye
 
-# Hugging Face Space requirements 
-ENV HF_HOME=/tmp/cache \
-    TRANSFORMERS_CACHE=/tmp/cache \
-    SENTENCE_TRANSFORMERS_HOME=/tmp/cache \
-    PATH="/home/appuser/.local/bin:${PATH}"
+# Configure environment for CPU optimization
+ENV DEBIAN_FRONTEND=noninteractive \
+    OMP_NUM_THREADS=4 \
+    PORT=7860 \
+    MAX_WORKERS=2
 
-# System dependencies
+# Install system dependencies
 RUN apt-get update && apt-get install -y --no-install-recommends \
-    build-essential \
-    git \
+    gcc \
+    libgl1 \
+    poppler-utils \
     && rm -rf /var/lib/apt/lists/*
 
-# Create cache directory and non-root user
-RUN mkdir -p ${HF_HOME} && chmod 777 ${HF_HOME} && \
-    useradd -m appuser && chown -R appuser /code ${HF_HOME}
+WORKDIR /app
 
-USER appuser
+# Install Python dependencies with CPU-optimized versions
+COPY requirements.txt .
+RUN pip install --no-cache-dir -U pip && \
+    pip install --no-cache-dir \
+    -r requirements.txt \
+    --timeout 600 \
+    --extra-index-url https://download.pytorch.org/whl/cpu
 
-# Install Python dependencies
-COPY --chown=appuser:appuser requirements.txt .
-RUN pip install --no-cache-dir --upgrade pip && \
-    pip install --no-cache-dir -r requirements.txt
+# Copy application files
+COPY . .
 
-# Copy application code
-COPY --chown=appuser:appuser app.py .
+# Start the server
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860", "--workers", "2"]
 
-# Hugging Face Space-specific CMD
-CMD ["python", "-m", "uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]
+
+
+# FROM python:3.9-slim
+
+# WORKDIR /code
+
+# # Hugging Face Space requirements 
+# ENV HF_HOME=/tmp/cache \
+#     TRANSFORMERS_CACHE=/tmp/cache \
+#     SENTENCE_TRANSFORMERS_HOME=/tmp/cache \
+#     PATH="/home/appuser/.local/bin:${PATH}"
+
+# # System dependencies
+# RUN apt-get update && apt-get install -y --no-install-recommends \
+#     build-essential \
+#     git \
+#     && rm -rf /var/lib/apt/lists/*
+
+# # Create cache directory and non-root user
+# RUN mkdir -p ${HF_HOME} && chmod 777 ${HF_HOME} && \
+#     useradd -m appuser && chown -R appuser /code ${HF_HOME}
+
+# USER appuser
+
+# # Install Python dependencies
+# COPY --chown=appuser:appuser requirements.txt .
+# RUN pip install --no-cache-dir --upgrade pip && \
+#     pip install --no-cache-dir -r requirements.txt
+
+# # Copy application code
+# COPY --chown=appuser:appuser app.py .
+
+# # Hugging Face Space-specific CMD
+# CMD ["python", "-m", "uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]

app.py

@@ -1,183 +1,112 @@
 # app.py: AI Detection and Plagiarism Check API 
-
-
-from fastapi import FastAPI, UploadFile, File, HTTPException, BackgroundTasks
+import os
+import time
+import logging
+import numpy as np
+from fastapi import FastAPI, UploadFile, File, HTTPException
 from fastapi.responses import JSONResponse
+from optimum.onnxruntime import ORTModelForSequenceClassification
+from transformers import AutoTokenizer, pipeline
 from sentence_transformers import SentenceTransformer
-from transformers import AutoModelForSequenceClassification, AutoTokenizer
 from PyPDF2 import PdfReader
-from sklearn.metrics.pairwise import cosine_similarity
-import torch
-import os
-import numpy as np
-import shutil
-import uuid
 import tempfile
-import logging
-import time
-from typing import Dict, Any
-
-# Configure logging
-logging.basicConfig(
-    level=logging.INFO,
-    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
-)
-logger = logging.getLogger(__name__)
-
-app = FastAPI(
-    title="Essay Analysis API",
-    version="1.0.0",
-    docs_url="/docs",
-    redoc_url=None
-)
+import torch
 
 # Configuration
-CACHE_DIR = "/tmp/cache"
-PLAGIARISM_THRESHOLD = 0.82
-MAX_TEXT_LENGTH = 512
 MODEL_NAME = "Essay-Grader/roberta-ai-detector-20250401_232702"
-SENTENCE_MODEL = "sentence-transformers/all-roberta-large-v1"
-
-# Global State
-model_status = {
-    "model_loaded": False,
-    "last_error": None
-}
+SENTENCE_MODEL = "sentence-transformers/all-MiniLM-L6-v2"
+PLAGIARISM_THRESHOLD = 0.75
+MAX_TEXT_LENGTH = 2048  # Reduced for CPU efficiency
+BATCH_SIZE = 4
 
-# Model References
-embedder = None
-ai_tokenizer = None
-ai_model = None
+app = FastAPI(title="Essay Analyzer Pro", version="5.0")
 
-def initialize_models():
-    global embedder, ai_tokenizer, ai_model
+# Initialize models
+def load_models():
+    global ai_detector, embedder, tokenizer
     
-    try:
-        # Cleanup existing models
-        if embedder or ai_model:
-            del embedder, ai_tokenizer, ai_model
-            torch.cuda.empty_cache()
-
-        # Load models
-        logger.info("Loading models...")
-        embedder = SentenceTransformer(SENTENCE_MODEL)
-        ai_tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME)
-        ai_model = AutoModelForSequenceClassification.from_pretrained(
-            MODEL_NAME,
-            device_map="auto",
-            torch_dtype=torch.float16 if torch.cuda.is_available() else torch.float32
-        ).eval()
-
-        # Warmup
-        test_text = "Model initialization text. " * 50
-        inputs = ai_tokenizer(test_text, return_tensors="pt", truncation=True)
-        with torch.no_grad():
-            ai_model(**inputs.to(ai_model.device))
-
-        model_status.update({"model_loaded": True, "last_error": None})
-        return True
-
-    except Exception as e:
-        error_msg = f"Model load failed: {str(e)}"
-        logger.error(error_msg)
-        model_status.update({"model_loaded": False, "last_error": error_msg})
-        return False
-
-@app.on_event("startup")
-async def startup_event():
-    for _ in range(3):
-        if initialize_models():
-            return
-        time.sleep(5)
-    logger.error("Failed to initialize models")
-
-def extract_text_from_pdf(pdf_path: str) -> str:
-    try:
-        return " ".join(page.extract_text() for page in PdfReader(pdf_path).pages)
-    except Exception as e:
-        logger.error(f"PDF error: {str(e)}")
-        raise HTTPException(400, "Invalid PDF file")
-
-def chunk_text(text: str) -> list:
-    sentences = [s.strip() for s in text.split('.') if s.strip()]
-    return ['. '.join(sentences[i:i+5]) + '.' for i in range(0, len(sentences), 5)]
-
-def analyze_content(text: str) -> Dict[str, float]:
-    try:
-        inputs = ai_tokenizer(
-            text,
-            truncation=True,
-            padding='max_length',
-            max_length=MAX_TEXT_LENGTH,
-            return_tensors="pt"
-        ).to(ai_model.device)
-        
-        with torch.no_grad():
-            outputs = ai_model(**inputs)
-            probs = torch.softmax(outputs.logits, dim=1).squeeze()
-        
-        return {
-            "Human_Written": round(probs[0].item() * 100, 2),
-            "AI_Generated": round(probs[1].item() * 100, 2)
-        }
-    except Exception as e:
-        logger.error(f"AI analysis failed: {str(e)}")
-        raise
-
-def calculate_plagiarism(chunks: list) -> float:
-    if len(chunks) < 2:
-        return 0.0
+    # Load optimized ONNX model
+    ai_detector = ORTModelForSequenceClassification.from_pretrained(
+        MODEL_NAME,
+        provider="CPUExecutionProvider",
+        file_name="model_optimized.onnx"
+    )
     
-    embeddings = embedder.encode(chunks, batch_size=32)
-    similarity_matrix = cosine_similarity(embeddings)
-    np.fill_diagonal(similarity_matrix, 0)
+    tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME)
     
-    similar_pairs = np.sum(similarity_matrix > PLAGIARISM_THRESHOLD)
-    total_possible = len(chunks) * (len(chunks) - 1) // 2
+    # Initialize embedding model with CPU optimizations
+    embedder = SentenceTransformer(
+        SENTENCE_MODEL,
+        device="cpu",
+        modules_kwargs={"onnx_execution_provider": "CPUExecutionProvider"}
+    )
+
+def process_pdf(file: UploadFile) -> str:
+    """Memory-efficient PDF processing"""
+    with tempfile.NamedTemporaryFile() as tmp:
+        tmp.write(file.file.read())
+        text = " ".join(
+            page.extract_text() or "" 
+            for page in PdfReader(tmp.name).pages
+        )
+    return text.strip()
+
+def analyze_text(text: str) -> dict:
+    """CPU-optimized analysis pipeline"""
+    start_time = time.time()
     
-    return round((similar_pairs / total_possible) * 100, 2) if total_possible else 0.0
-
-@app.post("/analyze")
-async def analyze_essay(file: UploadFile = File(...)) -> Dict[str, Any]:
-    if not model_status["model_loaded"]:
-        raise HTTPException(503, "Service unavailable")
+    # Text preprocessing
+    text = text[:5000]  # Strict length limit
+    chunks = [text[i:i+512] for i in range(0, len(text), 384)][:8]
+    
+    # AI Detection
+    inputs = tokenizer(
+        chunks,
+        padding=True,
+        truncation=True,
+        max_length=512,
+        return_tensors="pt"
+    )
     
-    if not file.filename.lower().endswith(".pdf"):
-        raise HTTPException(400, "PDF files only")
+    outputs = ai_detector(**inputs)
+    probs = torch.nn.functional.softmax(outputs.logits, dim=-1)
+    human = probs[:, 0].mean().item() * 100
+    ai = probs[:, 1].mean().item() * 100
+    
+    # Plagiarism Check
+    embeddings = embedder.encode(chunks, batch_size=BATCH_SIZE)
+    similarity = (embeddings @ embeddings.T) > PLAGIARISM_THRESHOLD
+    plagiarism = similarity.mean() * 100
+    
+    return {
+        "human_written": round(human, 2),
+        "ai_generated": round(ai, 2),
+        "plagiarism_risk": round(plagiarism, 2),
+        "processing_time": round(time.time() - start_time, 2)
+    }
+
+@app.on_event("startup")
+async def startup_event():
+    load_models()
 
+@app.post("/analyze")
+async def analyze(file: UploadFile = File(...)):
     try:
-        with tempfile.TemporaryDirectory() as tmp_dir:
-            # Save file
-            file_path = f"{tmp_dir}/{uuid.uuid4()}.pdf"
-            with open(file_path, "wb") as f:
-                shutil.copyfileobj(file.file, f)
-            
-            # Process
-            text = extract_text_from_pdf(file_path)
-            if not text.strip():
-                raise HTTPException(400, "Empty PDF content")
+        if not file.filename.lower().endswith(".pdf"):
+            raise HTTPException(400, "Only PDF files accepted")
+        
+        text = process_pdf(file)
+        if len(text) < 300:
+            raise HTTPException(400, "Text too short for analysis")
             
-            return {
-                "analysis": {
-                    **analyze_content(text),
-                    "Plagiarism_Score": calculate_plagiarism(chunk_text(text))
-                },
-                "status": "success"
-            }
-
-    except HTTPException:
-        raise
+        return JSONResponse(analyze_text(text))
+    
     except Exception as e:
-        logger.error(f"Processing failed: {str(e)}")
-        raise HTTPException(500, "Analysis error")
+        raise HTTPException(500, f"Analysis failed: {str(e)}")
 
 @app.get("/health")
-async def health_check() -> Dict[str, Any]:
-    return {"status": "operational" if model_status["model_loaded"] else "degraded"}
-
-@app.get("/")
-async def root():
-    return {"message": "Essay Analysis API - POST PDFs to /analyze"}
+async def health_check():
+    return {"status": "ready", "device": "cpu"}
 
 
 # from fastapi import FastAPI, UploadFile, File, HTTPException, BackgroundTasks

convert_model.py

@@ -0,0 +1,16 @@
+from optimum.onnxruntime import ORTModelForSequenceClassification
+
+# Convert and optimize model
+model = ORTModelForSequenceClassification.from_pretrained(
+    "Essay-Grader/roberta-ai-detector-20250401_232702",
+    export=True,
+    provider="CPUExecutionProvider"
+)
+
+# Save optimized model
+model.save_pretrained(
+    "./optimized_model",
+    file_name="model_optimized.onnx"
+)
+
+

model_quantizer.py

@@ -0,0 +1,21 @@
+from transformers import AutoModelForSequenceClassification
+from optimum.onnxruntime import ORTOptimizer, ORTModelForSequenceClassification
+from optimum.onnxruntime.configuration import OptimizationConfig
+
+model = ORTModelForSequenceClassification.from_pretrained(
+    "Essay-Grader/roberta-ai-detector-20250401_232702",
+    from_transformers=True
+ )
+
+optimizer = ORTOptimizer.from_pretrained(model)
+optimization_config = OptimizationConfig(
+    optimization_level=99,
+    enable_transformers_specific_optimizations=True,
+    optimize_for_gpu=True,
+    fp16=True
+)
+
+optimizer.optimize(
+    save_dir="./optimized_model",
+    optimization_config=optimization_config
+)

optimized_model/model_optimized.onnx

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

requirements.txt

@@ -1,18 +1,29 @@
 # requirements.txt
 
-fastapi==0.115.0
-uvicorn==0.34.0
-transformers==4.41.0
-sentence-transformers==2.7.0
-torch==2.3.0
-scikit-learn==1.4.0
-PyPDF2==3.0.1
-numpy==1.26.4
-requests==2.31.0
-safetensors==0.4.3
-huggingface_hub>=0.23.0,<1.0
+fastapi==0.109.2
+uvicorn==0.27.1
+sentence-transformers==2.6.1
+transformers==4.38.2
+torch==2.2.1+cpu --extra-index-url https://download.pytorch.org/whl/cpu
+onnxruntime==1.17.1
+optimum==1.17.1
+pypdf2==3.0.1
+nest-asyncio==1.6.0
 python-multipart==0.0.9
-click==8.1.7
-accelerate>=0.30.0
-bitsandbytes>=0.43.0
-protobuf>=4.25.3
+
+# fastapi==0.115.0
+# uvicorn==0.34.0
+# transformers==4.41.0
+# sentence-transformers==2.7.0
+# torch==2.3.0
+# scikit-learn==1.4.0
+# PyPDF2==3.0.1
+# numpy==1.26.4
+# requests==2.31.0
+# safetensors==0.4.3
+# huggingface_hub>=0.23.0,<1.0
+# python-multipart==0.0.9
+# click==8.1.7
+# accelerate>=0.30.0
+# bitsandbytes>=0.43.0
+# protobuf>=4.25.3