feat: init commit for hugging face space

.gitattributes

@@ -1,3 +1,4 @@
+packaged_models/*.pt filter=lfs diff=lfs merge=lfs -text
 *.7z filter=lfs diff=lfs merge=lfs -text
 *.arrow filter=lfs diff=lfs merge=lfs -text
 *.bin filter=lfs diff=lfs merge=lfs -text
@@ -33,4 +34,3 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
-packaged_models/*.pt filter=lfs diff=lfs merge=lfs -text

README.md

@@ -1,12 +1,20 @@
 ---
 title: Scriptify Api
-emoji: 🏆
-colorFrom: blue
+emoji: ✍️
+colorFrom: indigo
 colorTo: green
-sdk: docker
+sdk: python
+app_file: main.py 
+python_version: 3.9
 pinned: false
 license: mit
 short_description: An API for generating realistic handwriting stroke points.
 ---
 
+
+# Scriptify Handwriting Generation API
+
+This Space hosts an API for generating handwriting from text.
+Use the `/generate` endpoint with a POST request.
+
 Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

inference_utils.py

@@ -0,0 +1,48 @@
+from typing import Dict
+import numpy as np 
+
+NULL_CHAR = '\x00'
+
+def construct_alphabet_list(alphabet_string: str) -> list[str]:
+    if not isinstance(alphabet_string, str):
+        raise TypeError("alphabet_string must be a string") 
+    
+    char_list = list(alphabet_string) 
+    return [NULL_CHAR] + char_list 
+
+def get_alphabet_map(alphabet_list: list[str]) -> Dict[str, int]:
+    """creates a char to index map from full alphabet list"""
+    return {char: idx for idx, char in enumerate(alphabet_list)}  
+
+def encode_text(text: str, char_to_index_map: Dict[str, int], 
+                max_length: int, add_eos: bool = True, eos_char_index: int = 0
+                ) -> tuple[np.ndarray, int]:
+    """Encode a text string into a sequence of integer indices"""
+    encoded = [char_to_index_map.get(c, eos_char_index) for c in text] 
+    if add_eos:
+        encoded.append(eos_char_index) 
+
+    true_length = len(encoded)
+
+    if true_length <= max_length: 
+        padded_encoded = np.full(max_length, eos_char_index, dtype=np.int64) 
+        padded_encoded[:true_length] = encoded 
+    else:
+        padded_encoded = np.array(encoded[:max_length], dtype=np.int64) 
+        true_length = max_length 
+    
+    return np.array([padded_encoded]), true_length
+
+
+def convert_offsets_to_absolute_coords(stroke_offsets: list[list[float]]) -> list[list[float]]:
+    if not stroke_offsets:
+        return []
+    
+    # convert to numpy for vectorized operations
+    strokes_array = np.array(stroke_offsets)
+    
+    # vectorized cumulative sum for x and y 
+    strokes_array[:, 0] = np.cumsum(strokes_array[:, 0])  # cumulative dx
+    strokes_array[:, 1] = np.cumsum(strokes_array[:, 1])  # cumulative dy
+    
+    return strokes_array.tolist()

main.py

@@ -0,0 +1,263 @@
+from typing import Optional
+from fastapi import FastAPI, HTTPException, status 
+from fastapi.middleware.cors import CORSMiddleware 
+from pydantic import BaseModel, Field
+import torch 
+import torch.nn.functional as F 
+from pathlib import Path 
+import logging 
+import time 
+from contextlib import asynccontextmanager
+from inference_utils import construct_alphabet_list, convert_offsets_to_absolute_coords, encode_text, get_alphabet_map
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__) 
+
+MODEL_DIR = Path("../../ml/packaged_models") 
+SCRIPTED_MODEL_NAME = "handwriting_model.scripted.pt" 
+METADATA_MODEL_NAME = "handwriting_model.pt" 
+
+scripted_model: Optional[torch.jit.ScriptModule] = None 
+model_metadata: Optional[dict] = None 
+device: Optional[torch.device] = None 
+alphabet_map: Optional[dict[str, int]] = None 
+ALPHABET_LIST: Optional[list[str]] = None 
+ALPHABET_SIZE: Optional[int] = None 
+max_text_len: Optional[int] = None 
+output_mixture_components: Optional[int] = None # To store num_mixtures for GMM sampling
+lstm_size: Optional[int] = None 
+attention_mixture_components: Optional[int] = None 
+
+# Patience for early stopping in generate_strokes
+PATIENCE_PEN_UP_EOS = 15
+MIN_MOVEMENT_THRESHOLD = 0.02 
+
+
+class HandwritingRequest(BaseModel):
+    text: str = Field(..., min_length=1, max_length=40, description="Text to generate handwriting for")
+    max_length: int = Field(default=700, ge=50, le=1500, description="Maximum number of stroke points")
+    bias: float = Field(default=0.75, ge=0.1, le=2.0, description="Sampling bias for generation")
+class HandwritingResponse(BaseModel):
+    success: bool = True
+    input_text: str
+    generation_time_ms: float
+    num_points: int
+    strokes: list[list[float]]
+    message: str = "Successfully generated handwriting."
+
+class HealthResponse(BaseModel):
+    status: str 
+    model_loaded: bool 
+    device: str 
+    model_metadata_keys: Optional[list[str]] = None 
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    """Lifespan context manager for startup and shutdown events"""
+    global scripted_model, model_metadata, device, alphabet_map, max_text_len, ALPHABET_LIST, output_mixture_components, lstm_size, attention_mixture_components, ALPHABET_SIZE
+    logger.info("Attempting to load model resources during startup") 
+    try:
+        device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+        logger.info(f"Using device: {device}")
+        
+        scripted_model_path = MODEL_DIR / SCRIPTED_MODEL_NAME
+        metadata_model_path = MODEL_DIR / METADATA_MODEL_NAME
+        
+        if  not scripted_model_path.exists():
+            logger.error(f"Traced model not found at {scripted_model_path}")
+            raise FileNotFoundError(f"Traced model not found at {scripted_model_path}")
+        if not metadata_model_path or not metadata_model_path.exists():
+            logger.error(f"Metadata model file not found at {metadata_model_path}")
+            raise FileNotFoundError(f"Metadata model file not found at {metadata_model_path}")
+
+        # Load the traced model
+        scripted_model = torch.jit.load(scripted_model_path, map_location=device)
+        if scripted_model:
+            scripted_model.eval()
+            logger.info(f"Traced model loaded successfully from {scripted_model_path}")
+
+        # Load the metadata
+        model_metadata = torch.load(metadata_model_path, map_location='cpu')
+        if model_metadata:
+            logger.info(f"Model metadata loaded successfully from {metadata_model_path}")
+            logger.info(f"Model metadata keys: {list(model_metadata.keys())}")
+            
+            config_full = model_metadata['config_full']
+            if not config_full or not isinstance(config_full, dict):
+                raise ValueError(f"Key `config_full` not found or not a dict")
+            
+            dataset_config = config_full['dataset']
+            model_params = config_full['model_params']
+
+            if not dataset_config or not isinstance(dataset_config, dict):
+                raise ValueError(f"Key `dataset` not found or not a dict in config_full")
+            alphabet_str = dataset_config['alphabet_string']
+            max_text_len = dataset_config['max_text_len']
+            output_mixture_components = model_params['output_mixture_components']
+
+            lstm_size = model_params['lstm_size']
+            attention_mixture_components = model_params['attention_mixture_components']
+
+            ALPHABET_LIST = construct_alphabet_list(alphabet_str)
+            ALPHABET_SIZE = len(ALPHABET_LIST)
+            alphabet_map = get_alphabet_map(ALPHABET_LIST) 
+            
+            logger.info(f"Alphabet created. Size: {len(ALPHABET_LIST)}")
+            logger.info("Model resources are loaded and ready")
+        else:
+            raise ValueError(f"Failed to load content frm metadata file")
+
+    except Exception as e:
+        logger.error(f"Error loading model resources: {e}", exc_info=True)
+        scripted_model = None
+        model_metadata = None
+        raise
+    
+    yield
+    
+    # Cleanup on shutdown
+    logger.info("Shutting down API and cleaning up resources")
+    scripted_model = None 
+    model_metadata = None 
+
+app = FastAPI(
+    title="Scriptify API", 
+    description="API to generate handwriting from text using a PyTorch model.", 
+    version="0.1.0",
+    lifespan=lifespan
+)
+
+# add CORS middleware
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["http://localhost:5173","http://127.0.0.1:5173"],
+    allow_credentials=True,
+    allow_methods=["GET", "POST"],
+    allow_headers=["*"],
+)
+
+@app.get("/", tags=["General"])
+async def read_root():
+    return {"message": "Welcome to the Scriptify Handwriting Generation API!"}
+
+@app.get("/health", response_model=HealthResponse, tags=["General"])
+async def health_check():
+    global scripted_model, model_metadata, device, alphabet_map, max_text_len, ALPHABET_LIST 
+    
+    is_healthy = all([scripted_model, model_metadata, device, alphabet_map, max_text_len, ALPHABET_LIST])
+    
+    return HealthResponse(
+        status="healthy" if is_healthy else "unhealthy",
+        model_loaded=bool(scripted_model),
+        device=str(device) if device else "unknown",
+        model_metadata_keys=list(model_metadata.keys()) if model_metadata else None,
+    )
+
+def text_to_tensor(text: str, device: torch.device) -> tuple[torch.Tensor, torch.Tensor]:
+    """Convert text to tensor format expected by the model"""
+    global alphabet_map, max_text_len  
+    if alphabet_map is None:
+        raise ValueError("Alphabet map not initialized during api startup")
+    if max_text_len is None:
+        raise ValueError("`max_text_len` is not initialized during api startup")
+    padded_encoded_np, true_length = encode_text(
+        text=text, 
+        char_to_index_map=alphabet_map, 
+        max_length=max_text_len 
+    )
+
+    char_seq = torch.from_numpy(padded_encoded_np).to(device=device, dtype=torch.long)
+    char_len = torch.tensor([true_length], device=device, dtype=torch.long)
+
+    return char_seq, char_len
+
+def generate_strokes(
+    char_seq: torch.Tensor,
+    char_lengths: torch.Tensor,
+    max_gen_len: int,
+    api_bias: float,
+    current_device: torch.device
+) -> list[list[float]]:
+    """Generate strokes using the model's built-in sample method"""
+    global scripted_model
+    if scripted_model is None:
+        raise ValueError("Scripted model not initialized.")
+    
+    with torch.no_grad():
+        try:
+            stroke_tensors = scripted_model.sample(
+                char_seq, 
+                char_lengths, 
+                max_length=max_gen_len, 
+                bias=api_bias
+            )
+            
+            if len(stroke_tensors) == 1 and stroke_tensors[0].dim() == 2:
+                all_strokes_tensor = stroke_tensors[0]
+                stroke_offsets = all_strokes_tensor.cpu().numpy().tolist()
+            else:
+                stroke_offsets = []
+                for stroke_tensor in stroke_tensors:
+                    if stroke_tensor.dim() == 2:
+                        stroke_data = stroke_tensor.squeeze(0).cpu().numpy().tolist()
+                    else:
+                        stroke_data = stroke_tensor.cpu().numpy().tolist()
+                    
+                    if len(stroke_data) == 3:
+                        stroke_offsets.append(stroke_data)
+            
+            return stroke_offsets
+            
+        except Exception as e:
+            logger.error(f"Error in model sampling: {e}", exc_info=True)
+            return []
+            
+@app.post("/generate", response_model=HandwritingResponse, tags=["Generation"])
+async def generate_handwriting_endpoint(request: HandwritingRequest):
+    if not all([scripted_model, model_metadata, device, alphabet_map, max_text_len]):
+        logger.error("API not fully initialized. Check /health endpoint.")
+        raise HTTPException(
+            status_code=status.HTTP_503_SERVICE_UNAVAILABLE,
+            detail="Model or required resources not loaded."
+        )
+    
+    assert device is not None, "Device is None inside generate_handwriting"
+    start_time = time.time()
+    
+    try:
+        char_seq_tensor, char_lengths_tensor = text_to_tensor(request.text, device)
+
+        relative_stroke_offsets = generate_strokes(
+            char_seq_tensor, char_lengths_tensor, request.max_length, request.bias, device
+        )
+
+        if not relative_stroke_offsets:
+            return HandwritingResponse(
+                success=False,
+                input_text=request.text,
+                strokes=[],
+                num_points=0,
+                generation_time_ms=(time.time() - start_time) * 1000,
+                message="No strokes generated."
+            )
+
+        absolute_stroke_coords = convert_offsets_to_absolute_coords(relative_stroke_offsets)
+        generation_time_ms = (time.time() - start_time) * 1000
+
+        return HandwritingResponse(
+            input_text=request.text,
+            strokes=absolute_stroke_coords,
+            num_points=len(absolute_stroke_coords),
+            generation_time_ms=generation_time_ms
+        )
+    except ValueError as ve:
+        logger.error(f"ValueError during generation for '{request.text}': {ve}", exc_info=True)
+        raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail=str(ve))
+    except Exception as e:
+        logger.error(f"Unexpected error for '{request.text}': {e}", exc_info=True)
+        raise HTTPException(status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail="An unexpected error occurred.")
+
+if __name__ == "__main__":
+    import uvicorn
+    logger.info("Starting Uvicorn server for Scriptify API...")
+    uvicorn.run("main:app", host="0.0.0.0", port=8000, reload=True, app_dir=".")

packaged_models/model.pt

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

packaged_models/model.scripted.pt

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

packaged_models/model.scripted.quantized.pt

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

requirements.txt

@@ -0,0 +1,30 @@
+annotated-types==0.7.0
+anyio==4.9.0
+click==8.1.8
+exceptiongroup==1.3.0
+fastapi==0.115.12
+filelock==3.13.1
+fsspec==2024.6.1
+h11==0.16.0
+httptools==0.6.4
+idna==3.10
+Jinja2==3.1.4
+MarkupSafe==2.1.5
+mpmath==1.3.0
+networkx==3.2.1
+numpy==2.0.2
+pydantic==2.11.5
+pydantic-settings==2.9.1
+pydantic_core==2.33.2
+python-dotenv==1.1.0
+PyYAML==6.0.2
+sniffio==1.3.1
+starlette==0.46.2
+sympy==1.13.1
+torch==2.5.1+cpu
+typing-inspection==0.4.1
+typing_extensions==4.13.2
+uvicorn==0.34.2
+uvloop==0.21.0
+watchfiles==1.0.5
+websockets==15.0.1