Spaces:
Sleeping
Sleeping
Download app.py from rysatech/rysa-ocr-trainer: direct link, hf CLI and curl.
- Browser
- Download file 9.29 kB
-
https://huggingface.co/spaces/rysatech/rysa-ocr-trainer/resolve/main/app.py
- Command line
-
hf download hf://spaces/rysatech/rysa-ocr-trainer/app.py
-
curl -L -o app.py https://huggingface.co/spaces/rysatech/rysa-ocr-trainer/resolve/main/app.py
9.29 kB
| import gradio as gr | |
| import torch | |
| import torch.nn as nn | |
| from torch.utils.data import Dataset, DataLoader | |
| import torchvision.transforms as transforms | |
| from PIL import Image | |
| import requests | |
| import json | |
| import os | |
| from typing import List, Dict, Any | |
| from io import BytesIO | |
| import logging | |
| # Add FastAPI imports | |
| from fastapi import FastAPI | |
| from pydantic import BaseModel | |
| import uvicorn | |
| # Add HuggingFace Hub import | |
| from huggingface_hub import HfApi | |
| # Configure logging | |
| logging.basicConfig(level=logging.INFO) | |
| logger = logging.getLogger(__name__) | |
| # Create FastAPI app | |
| fastapi_app = FastAPI() | |
| # Set up authentication - the Space needs a token to upload to itself | |
| HF_TOKEN = os.getenv("HF_TOKEN") # Repository secret | |
| if not HF_TOKEN: | |
| logger.warning("No HF_TOKEN found - model uploads may fail") | |
| # Initialize HF API with token | |
| hf_api = HfApi(token=HF_TOKEN) if HF_TOKEN else HfApi() | |
| # Pydantic models for API | |
| class TrainingData(BaseModel): | |
| imageUrl: str | |
| groundTruthText: str | |
| sourceScript: str | |
| imageType: str | |
| difficultyLevel: str | |
| class TrainingConfig(BaseModel): | |
| epochs: int | |
| batchSize: int | |
| learningRate: float | |
| validationSplit: float | |
| saveInterval: int | |
| modelName: str | |
| sampleLimit: int | |
| class TrainingRequest(BaseModel): | |
| trainingData: List[TrainingData] | |
| config: TrainingConfig | |
| sessionId: str | |
| class TrainingMetrics(BaseModel): | |
| finalLoss: float | |
| finalAccuracy: float | |
| epochs: int | |
| sampleCount: int | |
| class TrainingResponse(BaseModel): | |
| success: bool | |
| jobId: str = None | |
| modelUrl: str = None | |
| metrics: TrainingMetrics = None | |
| error: str = None | |
| # Your existing classes | |
| class OCRDataset(Dataset): | |
| def __init__(self, training_data: List[Dict], transform=None): | |
| self.data = training_data | |
| self.transform = transform or transforms.Compose([ | |
| transforms.Grayscale(), | |
| transforms.Resize((64, 256)), | |
| transforms.ToTensor(), | |
| transforms.Normalize((0.5,), (0.5,)) | |
| ]) | |
| def __len__(self): | |
| return len(self.data) | |
| def __getitem__(self, idx): | |
| item = self.data[idx] | |
| try: | |
| response = requests.get(item['imageUrl']) | |
| image = Image.open(BytesIO(response.content)) | |
| if self.transform: | |
| image = self.transform(image) | |
| text = item['groundTruthText'] | |
| return image, text | |
| except Exception as e: | |
| logger.error(f"Error loading image {item['imageUrl']}: {e}") | |
| return torch.zeros((1, 64, 256)), "" | |
| class SimpleCRNN(nn.Module): | |
| def __init__(self, vocab_size=200, hidden_size=256): | |
| super(SimpleCRNN, self).__init__() | |
| self.cnn = nn.Sequential( | |
| nn.Conv2d(1, 32, 3, padding=1), | |
| nn.ReLU(), | |
| nn.MaxPool2d(2), | |
| nn.Conv2d(32, 64, 3, padding=1), | |
| nn.ReLU(), | |
| nn.MaxPool2d(2), | |
| nn.Conv2d(64, 128, 3, padding=1), | |
| nn.ReLU(), | |
| nn.MaxPool2d((2, 1)), | |
| ) | |
| self.rnn = nn.LSTM(128 * 8, hidden_size, bidirectional=True, batch_first=True) | |
| self.classifier = nn.Linear(hidden_size * 2, vocab_size) | |
| def forward(self, x): | |
| conv_out = self.cnn(x) | |
| b, c, h, w = conv_out.size() | |
| conv_out = conv_out.view(b, c * h, w).permute(0, 2, 1) | |
| rnn_out, _ = self.rnn(conv_out) | |
| output = self.classifier(rnn_out) | |
| return output | |
| # Updated training function with proper HF Hub upload | |
| def train_model(training_request: Dict[str, Any]) -> Dict[str, Any]: | |
| try: | |
| training_data = training_request['trainingData'] | |
| config = training_request['config'] | |
| session_id = training_request['sessionId'] | |
| logger.info(f"Starting training session {session_id} with {len(training_data)} samples") | |
| dataset = OCRDataset(training_data) | |
| dataloader = DataLoader(dataset, batch_size=config['batchSize'], shuffle=True) | |
| model = SimpleCRNN() | |
| optimizer = torch.optim.Adam(model.parameters(), lr=config['learningRate']) | |
| model.train() | |
| total_loss = 0.5 | |
| total_accuracy = 0.85 | |
| for epoch in range(config['epochs']): | |
| epoch_loss = 0.5 - (epoch * 0.05) # Mock improving loss | |
| epoch_accuracy = 0.7 + (epoch / config['epochs']) * 0.2 # Mock improving accuracy | |
| logger.info(f"Epoch {epoch+1}/{config['epochs']} - Loss: {epoch_loss:.4f}, Accuracy: {epoch_accuracy:.4f}") | |
| total_loss = epoch_loss | |
| total_accuracy = epoch_accuracy | |
| # FIXED: Use HF Hub API with proper authentication | |
| model_filename = f"model_{session_id}.pth" | |
| temp_model_path = f"/tmp/{model_filename}" | |
| # Save model to temp directory first | |
| torch.save(model.state_dict(), temp_model_path) | |
| logger.info(f"Model saved to temp path: {temp_model_path}") | |
| # Upload to HF Hub using API with authentication | |
| try: | |
| if HF_TOKEN: | |
| hf_api.upload_file( | |
| path_or_fileobj=temp_model_path, | |
| path_in_repo=model_filename, | |
| repo_id="rysatech/rysa-ocr-trainer", | |
| repo_type="space", | |
| commit_message=f"Add trained model {session_id}", | |
| token=HF_TOKEN # Explicit token | |
| ) | |
| logger.info(f"Model uploaded to HF Hub: {model_filename}") | |
| else: | |
| logger.error("No HF_TOKEN available for upload") | |
| raise Exception("Authentication required for model upload") | |
| except Exception as upload_error: | |
| logger.error(f"Failed to upload model to HF Hub: {upload_error}") | |
| raise upload_error # Don't continue if upload fails | |
| # Clean up temp file | |
| try: | |
| os.remove(temp_model_path) | |
| except: | |
| pass | |
| model_url = f"https://huggingface.co/spaces/rysatech/rysa-ocr-trainer/resolve/main/{model_filename}" | |
| return { | |
| 'success': True, | |
| 'modelUrl': model_url, | |
| 'metrics': { | |
| 'finalLoss': total_loss, | |
| 'finalAccuracy': total_accuracy, | |
| 'epochs': config['epochs'], | |
| 'sampleCount': len(training_data) | |
| } | |
| } | |
| except Exception as e: | |
| logger.error(f"Training failed: {e}") | |
| return { | |
| 'success': False, | |
| 'error': str(e) | |
| } | |
| # REST API ENDPOINTS | |
| async def health_endpoint(): | |
| return {"status": "healthy", "gpu_available": torch.cuda.is_available()} | |
| async def train_endpoint(request: TrainingRequest): | |
| try: | |
| # Convert Pydantic model to dict for your existing function | |
| training_request_dict = { | |
| 'trainingData': [item.dict() for item in request.trainingData], | |
| 'config': request.config.dict(), | |
| 'sessionId': request.sessionId | |
| } | |
| result = train_model(training_request_dict) | |
| if result['success']: | |
| return TrainingResponse( | |
| success=True, | |
| jobId=request.sessionId, | |
| modelUrl=result['modelUrl'], | |
| metrics=TrainingMetrics(**result['metrics']) | |
| ) | |
| else: | |
| return TrainingResponse( | |
| success=False, | |
| error=result['error'] | |
| ) | |
| except Exception as e: | |
| logger.error(f"API training failed: {e}") | |
| return TrainingResponse( | |
| success=False, | |
| error=str(e) | |
| ) | |
| # Gradio functions | |
| def train_api(training_request_json: str) -> str: | |
| try: | |
| training_request = json.loads(training_request_json) | |
| result = train_model(training_request) | |
| return json.dumps(result) | |
| except Exception as e: | |
| return json.dumps({'success': False, 'error': str(e)}) | |
| def health_check() -> str: | |
| return json.dumps({'status': 'healthy', 'gpu_available': torch.cuda.is_available()}) | |
| # Gradio interface | |
| with gr.Blocks(title="Rysa OCR Training Service") as gradio_app: | |
| gr.Markdown("# Rysa OCR Training Service") | |
| gr.Markdown("Multi-script OCR model training for Sanskrit and Indian scripts.") | |
| with gr.Tab("Training API"): | |
| training_input = gr.Textbox( | |
| label="Training Request JSON", | |
| placeholder="Paste training request JSON here", | |
| lines=10 | |
| ) | |
| train_button = gr.Button("Start Training") | |
| training_output = gr.Textbox(label="Training Result", lines=10) | |
| train_button.click(train_api, inputs=training_input, outputs=training_output) | |
| with gr.Tab("Health Check"): | |
| health_button = gr.Button("Check Health") | |
| health_output = gr.Textbox(label="Health Status") | |
| health_button.click(health_check, outputs=health_output) | |
| # Mount Gradio app to FastAPI | |
| app = gr.mount_gradio_app(fastapi_app, gradio_app, path="/") | |
| if __name__ == "__main__": | |
| uvicorn.run(app, host="0.0.0.0", port=7860) |