Upload 5 files

Dockerfile

@@ -0,0 +1,33 @@
+FROM python:3.9-slim
+
+# Set working directory
+WORKDIR /app
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    && 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 app.py .
+
+# Copy model directory (make sure gpu_base_model2 exists)
+# You can also mount this as a volume or download it at runtime
+COPY gpu_base_model2 ./gpu_base_model2
+
+# Expose port
+EXPOSE 8000
+
+# Health check
+HEALTHCHECK --interval=30s --timeout=10s --start-period=40s --retries=3 \
+    CMD python -c "import requests; requests.get('http://localhost:8000/health')"
+
+# Run the application
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "8000"]
+

LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2024 Text Correction App
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

README.md

@@ -1,12 +1,164 @@
----
-title: TextCorrectionModel
-emoji: 🐨
-colorFrom: green
-colorTo: gray
-sdk: docker
-pinned: false
-license: mit
-short_description: This will recieve a text and correct the text and return it.
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Text Correction API Server
+
+This is the server-side API for text correction using your trained model.
+
+## 📝 License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+
+## 🚀 Setup
+
+### 1. Install Dependencies
+
+```bash
+pip install -r requirements.txt
+```
+
+### 2. Set Model Path
+
+Make sure your trained model is in the `gpu_base_model2` directory, or set the `MODEL_PATH` environment variable:
+
+```bash
+export MODEL_PATH="./gpu_base_model2"
+```
+
+### 3. Run the Server
+
+#### Local Development:
+```bash
+python main.py
+```
+
+Or using uvicorn directly:
+```bash
+uvicorn main:app --reload --host 0.0.0.0 --port 8000
+```
+
+The API will be available at: `http://localhost:8000`
+
+### 4. Test the API
+
+```bash
+# Health check
+curl http://localhost:8000/health
+
+# Correct text
+curl -X POST http://localhost:8000/correct \
+  -H "Content-Type: application/json" \
+  -d '{"text": "helo wrld this is a test"}'
+```
+
+## 📡 API Endpoints
+
+### GET `/health`
+Check if the API and model are ready.
+
+**Response:**
+```json
+{
+  "status": "healthy",
+  "model_loaded": true,
+  "device": "cuda"
+}
+```
+
+### POST `/correct`
+Correct text using the trained model.
+
+**Request:**
+```json
+{
+  "text": "helo wrld this is a test"
+}
+```
+
+**Response:**
+```json
+{
+  "corrected_text": "hello world this is a test",
+  "processing_time": 0.45
+}
+```
+
+## 🌐 Deployment Options
+
+### Option 1: Hugging Face Spaces (Free) - Recommended
+
+1. **Create a new Space** at https://huggingface.co/new-space
+   - Name: `your-username-text-correction`
+   - SDK: Docker
+   - License: **MIT** (or Apache 2.0)
+   - Click "Create Space"
+
+2. **Upload files:**
+   - Upload all files from this directory
+   - Upload your `gpu_base_model2/` folder
+
+3. **Your API will be live at:**
+   ```
+   https://your-username-text-correction.hf.space/correct
+   ```
+
+### Option 2: Render (Free tier available)
+
+1. Create a new Web Service
+2. Connect your GitHub repository
+3. Set build command: `pip install -r requirements.txt`
+4. Set start command: `uvicorn main:app --host 0.0.0.0 --port $PORT`
+5. Deploy
+
+### Option 3: Railway (Free tier available)
+
+1. Create a new project
+2. Add a service from GitHub
+3. Railway will auto-detect the Python app
+4. Set environment variable `MODEL_PATH` if needed
+5. Deploy
+
+### Option 4: AWS/GCP/Azure
+For production deployments with more control.
+
+## ⚙️ Environment Variables
+
+- `MODEL_PATH`: Path to your trained model (default: `./gpu_base_model2`)
+- `PORT`: Server port (default: `8000`)
+
+## 🔒 Security Notes
+
+⚠️ **Important for Production:**
+1. Add authentication to your API endpoints
+2. Set proper CORS origins (not `*`)
+3. Add rate limiting
+4. Use HTTPS
+5. Keep your API key secure
+
+## 🐛 Troubleshooting
+
+### Model not loading
+- Check that `gpu_base_model2` directory exists
+- Verify all model files are present
+- Check console logs for specific errors
+
+### Out of memory
+- Reduce `max_length` in the generate function
+- Use smaller batch sizes
+- Consider using CPU instead of GPU
+
+### Slow inference
+- Use GPU if available
+- Reduce `num_beams` parameter
+- Use quantization for faster inference
+
+## 📊 Usage
+
+This API is designed to be called from an iOS app for correcting OCR text. The typical flow is:
+
+1. User takes/selects an image
+2. OCR extracts text from the image
+3. Extracted text is sent to this API
+4. API corrects the text using the trained model
+5. Corrected text is returned to the app
+
+## 🤝 Contributing
+
+This is a private project for text correction. For questions or issues, please contact the project owner.

app.py

@@ -0,0 +1,176 @@
+"""
+FastAPI Server for Text Correction
+Deploy this to run your text correction model as an API
+"""
+
+from fastapi import FastAPI, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel
+from transformers import AutoModelForSeq2SeqLM, AutoTokenizer
+import torch
+import os
+from typing import Optional
+
+# Initialize FastAPI app
+app = FastAPI(
+    title="Text Correction API",
+    description="API for correcting OCR text using trained model",
+    version="1.0.0"
+)
+
+# Add CORS middleware to allow requests from iOS app
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],  # In production, specify your iOS app's domain
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Global variables for model
+model = None
+tokenizer = None
+device = None
+
+# Pydantic models for request/response
+class TextRequest(BaseModel):
+    text: str
+
+class TextResponse(BaseModel):
+    corrected_text: str
+    processing_time: float
+
+class HealthResponse(BaseModel):
+    status: str
+    model_loaded: bool
+    device: str
+
+# Load model at startup
+@app.on_event("startup")
+async def load_model():
+    global model, tokenizer, device
+    
+    print("🚀 Starting Text Correction API...")
+    
+    # Determine device
+    device = "cuda" if torch.cuda.is_available() else "cpu"
+    print(f"📱 Using device: {device}")
+    
+    # Load model and tokenizer
+    try:
+        model_path = os.getenv("MODEL_PATH", "./gpu_base_model2")
+        print(f"📦 Loading model from: {model_path}")
+        
+        model = AutoModelForSeq2SeqLM.from_pretrained(model_path)
+        tokenizer = AutoTokenizer.from_pretrained(model_path)
+        
+        # Move model to device
+        model.to(device)
+        model.eval()
+        
+        print("✅ Model loaded successfully!")
+        print(f"   - Model type: {type(model).__name__}")
+        print(f"   - Vocabulary size: {tokenizer.vocab_size}")
+        print(f"   - Device: {device}")
+        
+    except Exception as e:
+        print(f"❌ Error loading model: {e}")
+        print("⚠️  API will not work until model is loaded")
+
+# Health check endpoint
+@app.get("/health", response_model=HealthResponse)
+async def health_check():
+    """Check if the API and model are ready"""
+    return HealthResponse(
+        status="healthy" if model is not None else "unhealthy",
+        model_loaded=model is not None,
+        device=device or "unknown"
+    )
+
+# Text correction endpoint
+@app.post("/correct", response_model=TextResponse)
+async def correct_text(request: TextRequest):
+    """
+    Correct text using the trained model
+    
+    Args:
+        request: TextRequest containing the text to correct
+        
+    Returns:
+        TextResponse with corrected text and processing time
+    """
+    import time
+    
+    if model is None or tokenizer is None:
+        raise HTTPException(
+            status_code=503,
+            detail="Model not loaded. Please wait for the model to initialize."
+        )
+    
+    if not request.text or not request.text.strip():
+        raise HTTPException(
+            status_code=400,
+            detail="Text cannot be empty"
+        )
+    
+    start_time = time.time()
+    
+    try:
+        # Tokenize input text
+        inputs = tokenizer(
+            request.text,
+            return_tensors="pt",
+            max_length=512,
+            truncation=True,
+            padding=True
+        ).to(device)
+        
+        # Generate corrected text
+        with torch.no_grad():
+            outputs = model.generate(
+                inputs.input_ids,
+                attention_mask=inputs.attention_mask,
+                max_length=512,
+                num_beams=5,
+                early_stopping=True,
+                pad_token_id=tokenizer.pad_token_id,
+                eos_token_id=tokenizer.eos_token_id
+            )
+        
+        # Decode output
+        corrected_text = tokenizer.decode(outputs[0], skip_special_tokens=True)
+        
+        processing_time = time.time() - start_time
+        
+        print(f"✅ Text corrected in {processing_time:.2f}s")
+        print(f"   Input: {request.text[:50]}...")
+        print(f"   Output: {corrected_text[:50]}...")
+        
+        return TextResponse(
+            corrected_text=corrected_text,
+            processing_time=round(processing_time, 2)
+        )
+        
+    except Exception as e:
+        print(f"❌ Error during correction: {e}")
+        raise HTTPException(
+            status_code=500,
+            detail=f"Text correction failed: {str(e)}"
+        )
+
+# Root endpoint
+@app.get("/")
+async def root():
+    return {
+        "message": "Text Correction API",
+        "version": "1.0.0",
+        "endpoints": {
+            "health": "/health",
+            "correct": "/correct (POST)"
+        }
+    }
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=8000)
+

requirements.txt

@@ -0,0 +1,7 @@
+fastapi==0.104.1
+uvicorn[standard]==0.24.0
+transformers==4.35.0
+torch==2.1.0
+pydantic==2.5.0
+python-multipart==0.0.6
+