From 4a24be1605ff9ad4a305ea7d41f1cebd674658d3 Mon Sep 17 00:00:00 2001
From: remsky <jeremy.braun@ucalgary.ca>
Date: Wed, 22 Jan 2025 02:33:29 -0700
Subject: [PATCH] Refactor model loading and configuration: update, adjust
 model loading device,. add async streaming examples and remove unused warmup
 service.

---
 api/src/builds/models.py                      |   2 +-
 api/src/core/config.py                        |   6 +-
 api/src/core/model_config.py                  |  25 +-
 api/src/inference/model_manager.py            | 175 ++++++-----
 api/src/inference/onnx_cpu.py                 |  66 +----
 api/src/inference/onnx_gpu.py                 |  78 +----
 api/src/inference/pytorch_gpu.py              | 134 ++++++---
 api/src/inference/session_pool.py             | 271 ++++++++++++++++++
 api/src/inference/voice_manager.py            |  60 ++--
 api/src/main.py                               |  63 +++-
 api/src/routers/development.py                |   9 +-
 api/src/routers/openai_compatible.py          |  38 ++-
 .../services/text_processing/phonemizer.py    |   9 +-
 api/src/services/tts_service.py               | 201 ++++++-------
 api/src/services/warmup.py                    |  60 ----
 docker/gpu/docker-compose.yml                 |   2 +-
 examples/openai_streaming_audio.py            |   4 +-
 examples/simul_file_test.py                   |  53 ++++
 examples/simul_openai_streaming_audio.py      |  91 ++++++
 examples/simul_speaker_test.py                |  66 +++++
 examples/speech.mp3                           | Bin 0 -> 73440 bytes
 21 files changed, 929 insertions(+), 484 deletions(-)
 create mode 100644 api/src/inference/session_pool.py
 delete mode 100644 api/src/services/warmup.py
 create mode 100644 examples/simul_file_test.py
 create mode 100644 examples/simul_openai_streaming_audio.py
 create mode 100644 examples/simul_speaker_test.py

diff --git a/api/src/builds/models.py b/api/src/builds/models.py
index bfd52ad..5495465 100644
--- a/api/src/builds/models.py
+++ b/api/src/builds/models.py
@@ -367,7 +367,7 @@ async def build_model(path, device):
         decoder=decoder.to(device).eval(),
         text_encoder=text_encoder.to(device).eval(),
     )
-    weights = await load_model_weights(path, device='cpu')
+    weights = await load_model_weights(path, device=device)
     for key, state_dict in weights['net'].items():
         assert key in model, key
         try:
diff --git a/api/src/core/config.py b/api/src/core/config.py
index 91aec63..03ce30e 100644
--- a/api/src/core/config.py
+++ b/api/src/core/config.py
@@ -15,9 +15,9 @@ class Settings(BaseSettings):
     default_voice: str = "af"
     use_gpu: bool = False  # Whether to use GPU acceleration if available
     use_onnx: bool = True  # Whether to use ONNX runtime
-    # Paths relative to api directory
-    model_dir: str = "src/models"  # Model directory relative to api/
-    voices_dir: str = "src/voices"  # Voices directory relative to api/
+    # Container absolute paths
+    model_dir: str = "/app/api/src/models"  # Absolute path in container
+    voices_dir: str = "/app/api/src/voices"  # Absolute path in container
     
     # Model filenames
     pytorch_model_file: str = "kokoro-v0_19.pth"
diff --git a/api/src/core/model_config.py b/api/src/core/model_config.py
index dc82aee..f9ae254 100644
--- a/api/src/core/model_config.py
+++ b/api/src/core/model_config.py
@@ -6,6 +6,11 @@ from pydantic import BaseModel, Field
 class ONNXCPUConfig(BaseModel):
     """ONNX CPU runtime configuration."""
     
+    # Session pooling
+    max_instances: int = Field(4, description="Maximum concurrent model instances")
+    instance_timeout: int = Field(300, description="Session timeout in seconds")
+    
+    # Runtime settings
     num_threads: int = Field(8, description="Number of threads for parallel operations")
     inter_op_threads: int = Field(4, description="Number of threads for operator parallelism")
     execution_mode: str = Field("parallel", description="ONNX execution mode")
@@ -20,9 +25,14 @@ class ONNXCPUConfig(BaseModel):
 class ONNXGPUConfig(ONNXCPUConfig):
     """ONNX GPU-specific configuration."""
     
+    # CUDA settings
     device_id: int = Field(0, description="CUDA device ID")
     gpu_mem_limit: float = Field(0.7, description="Fraction of GPU memory to use")
     cudnn_conv_algo_search: str = Field("EXHAUSTIVE", description="CuDNN convolution algorithm search")
+    
+    # Stream management
+    cuda_streams: int = Field(2, description="Number of CUDA streams for inference")
+    stream_timeout: int = Field(60, description="Stream timeout in seconds")
     do_copy_in_default_stream: bool = Field(True, description="Copy in default CUDA stream")
 
     class Config:
@@ -32,8 +42,6 @@ class ONNXGPUConfig(ONNXCPUConfig):
 class PyTorchCPUConfig(BaseModel):
     """PyTorch CPU backend configuration."""
     
-    max_batch_size: int = Field(32, description="Maximum batch size for batched inference")
-    stream_buffer_size: int = Field(8, description="Size of stream buffer")
     memory_threshold: float = Field(0.8, description="Memory threshold for cleanup")
     retry_on_oom: bool = Field(True, description="Whether to retry on OOM errors")
     num_threads: int = Field(8, description="Number of threads for parallel operations")
@@ -49,18 +57,11 @@ class PyTorchGPUConfig(BaseModel):
     device_id: int = Field(0, description="CUDA device ID")
     use_fp16: bool = Field(True, description="Whether to use FP16 precision")
     use_triton: bool = Field(True, description="Whether to use Triton for CUDA kernels")
-    max_batch_size: int = Field(32, description="Maximum batch size for batched inference")
-    stream_buffer_size: int = Field(8, description="Size of CUDA stream buffer")
     memory_threshold: float = Field(0.8, description="Memory threshold for cleanup")
     retry_on_oom: bool = Field(True, description="Whether to retry on OOM errors")
     sync_cuda: bool = Field(True, description="Whether to synchronize CUDA operations")
-
-    class Config:
-        frozen = True
-    """PyTorch CPU-specific configuration."""
-    
-    num_threads: int = Field(8, description="Number of threads for parallel operations")
-    pin_memory: bool = Field(True, description="Whether to pin memory for faster CPU-GPU transfer")
+    cuda_streams: int = Field(2, description="Number of CUDA streams for inference")
+    stream_timeout: int = Field(60, description="Stream timeout in seconds")
 
     class Config:
         frozen = True
@@ -74,7 +75,7 @@ class ModelConfig(BaseModel):
     device_type: str = Field("auto", description="Device type ('cpu', 'gpu', or 'auto')")
     cache_models: bool = Field(True, description="Whether to cache loaded models")
     cache_voices: bool = Field(True, description="Whether to cache voice tensors")
-    voice_cache_size: int = Field(10, description="Maximum number of cached voices")
+    voice_cache_size: int = Field(2, description="Maximum number of cached voices")
     
     # Backend-specific configs
     onnx_cpu: ONNXCPUConfig = Field(default_factory=ONNXCPUConfig)
diff --git a/api/src/inference/model_manager.py b/api/src/inference/model_manager.py
index 26621c2..ed67ce8 100644
--- a/api/src/inference/model_manager.py
+++ b/api/src/inference/model_manager.py
@@ -1,5 +1,6 @@
 """Model management and caching."""
 
+import asyncio
 from typing import Dict, Optional
 
 import torch
@@ -13,11 +14,19 @@ from .onnx_cpu import ONNXCPUBackend
 from .onnx_gpu import ONNXGPUBackend
 from .pytorch_cpu import PyTorchCPUBackend
 from .pytorch_gpu import PyTorchGPUBackend
+from .session_pool import CPUSessionPool, StreamingSessionPool
+
+
+# Global singleton instance and state
+_manager_instance = None
+_manager_lock = asyncio.Lock()
+_loaded_models = {}
+_backends = {}
 
 
 class ModelManager:
     """Manages model loading and inference across backends."""
-
+    
     def __init__(self, config: Optional[ModelConfig] = None):
         """Initialize model manager.
         
@@ -25,65 +34,60 @@ class ModelManager:
             config: Optional configuration
         """
         self._config = config or model_config
-        self._backends: Dict[str, BaseModelBackend] = {}
-        self._current_backend: Optional[str] = None
-        self._initialize_backends()
+        global _loaded_models, _backends
+        self._loaded_models = _loaded_models
+        self._backends = _backends
+        
+        # Initialize session pools
+        self._session_pools = {
+            'onnx_cpu': CPUSessionPool(),
+            'onnx_gpu': StreamingSessionPool()
+        }
+        
+        # Initialize locks
+        self._backend_locks: Dict[str, asyncio.Lock] = {}
 
-    def _initialize_backends(self) -> None:
-        """Initialize available backends based on settings."""
-        has_gpu = settings.use_gpu and torch.cuda.is_available()
+    def _determine_device(self) -> str:
+        """Determine device based on settings."""
+        if settings.use_gpu and torch.cuda.is_available():
+            return "cuda"
+        return "cpu"
+
+    async def initialize(self) -> None:
+        """Initialize backends."""
+        if self._backends:
+            logger.debug("Using existing backend instances")
+            return
+            
+        device = self._determine_device()
         
         try:
-            if has_gpu:
+            if device == "cuda":
                 if settings.use_onnx:
-                    # ONNX GPU primary
                     self._backends['onnx_gpu'] = ONNXGPUBackend()
                     self._current_backend = 'onnx_gpu'
-                    logger.info("Initialized ONNX GPU backend")
-                    
-                    # PyTorch GPU fallback
-                    self._backends['pytorch_gpu'] = PyTorchGPUBackend()
-                    logger.info("Initialized PyTorch GPU backend")
+                    logger.info("Initialized new ONNX GPU backend")
                 else:
-                    # PyTorch GPU primary
                     self._backends['pytorch_gpu'] = PyTorchGPUBackend()
                     self._current_backend = 'pytorch_gpu'
-                    logger.info("Initialized PyTorch GPU backend")
+                    logger.info("Initialized new PyTorch GPU backend")
+            else:
+                if settings.use_onnx:
+                    self._backends['onnx_cpu'] = ONNXCPUBackend()
+                    self._current_backend = 'onnx_cpu'
+                    logger.info("Initialized new ONNX CPU backend")
+                else:
+                    self._backends['pytorch_cpu'] = PyTorchCPUBackend()
+                    self._current_backend = 'pytorch_cpu'
+                    logger.info("Initialized new PyTorch CPU backend")
                     
-                    # ONNX GPU fallback
-                    self._backends['onnx_gpu'] = ONNXGPUBackend()
-                    logger.info("Initialized ONNX GPU backend")
-            else:
-                self._initialize_cpu_backends()
-        except Exception as e:
-            logger.error(f"Failed to initialize GPU backends: {e}")
-            # Fallback to CPU if GPU fails
-            self._initialize_cpu_backends()
-
-    def _initialize_cpu_backends(self) -> None:
-        """Initialize CPU backends based on settings."""
-        try:
-            if settings.use_onnx:
-                # ONNX CPU primary
-                self._backends['onnx_cpu'] = ONNXCPUBackend()
-                self._current_backend = 'onnx_cpu'
-                logger.info("Initialized ONNX CPU backend")
+            # Initialize locks for each backend
+            for backend in self._backends:
+                self._backend_locks[backend] = asyncio.Lock()
                 
-                # PyTorch CPU fallback
-                self._backends['pytorch_cpu'] = PyTorchCPUBackend()
-                logger.info("Initialized PyTorch CPU backend")
-            else:
-                # PyTorch CPU primary
-                self._backends['pytorch_cpu'] = PyTorchCPUBackend()
-                self._current_backend = 'pytorch_cpu'
-                logger.info("Initialized PyTorch CPU backend")
-                
-                # ONNX CPU fallback
-                self._backends['onnx_cpu'] = ONNXCPUBackend()
-                logger.info("Initialized ONNX CPU backend")
         except Exception as e:
-            logger.error(f"Failed to initialize CPU backends: {e}")
-            raise RuntimeError("No backends available")
+            logger.error(f"Failed to initialize backend: {e}")
+            raise RuntimeError("Failed to initialize backend")
 
     def get_backend(self, backend_type: Optional[str] = None) -> BaseModelBackend:
         """Get specified backend.
@@ -154,19 +158,42 @@ class ModelManager:
             if backend_type is None:
                 backend_type = self._determine_backend(abs_path)
             
-            backend = self.get_backend(backend_type)
+            # Get backend lock
+            lock = self._backend_locks[backend_type]
             
-            # Load model
-            await backend.load_model(abs_path)
-            logger.info(f"Loaded model on {backend_type} backend")
-            
-            # Run warmup if voice provided
-            if warmup_voice is not None:
-                await self._warmup_inference(backend, warmup_voice)
+            async with lock:
+                backend = self.get_backend(backend_type)
+                
+                # For ONNX backends, use session pool
+                if backend_type.startswith('onnx'):
+                    pool = self._session_pools[backend_type]
+                    backend._session = await pool.get_session(abs_path)
+                    self._loaded_models[backend_type] = abs_path
+                    logger.info(f"Fetched model instance from {backend_type} pool")
+                    
+                # For PyTorch backends, load normally
+                else:
+                    # Check if model is already loaded
+                    if (backend_type in self._loaded_models and 
+                        self._loaded_models[backend_type] == abs_path and
+                        backend.is_loaded):
+                        logger.info(f"Fetching existing model instance from {backend_type}")
+                        return
+                        
+                    # Load model
+                    await backend.load_model(abs_path)
+                    self._loaded_models[backend_type] = abs_path
+                    logger.info(f"Initialized new model instance on {backend_type}")
+                
+                # Run warmup if voice provided
+                if warmup_voice is not None:
+                    await self._warmup_inference(backend, warmup_voice)
             
         except Exception as e:
+            # Clear cached path on failure
+            self._loaded_models.pop(backend_type, None)
             raise RuntimeError(f"Failed to load model: {e}")
-            
+
     async def _warmup_inference(self, backend: BaseModelBackend, voice: torch.Tensor) -> None:
         """Run warmup inference to initialize model.
         
@@ -188,7 +215,7 @@ class ModelManager:
             
             # Run inference
             backend.generate(tokens, voice, speed=1.0)
-            logger.info("Completed warmup inference")
+            logger.debug("Completed warmup inference")
             
         except Exception as e:
             logger.warning(f"Warmup inference failed: {e}")
@@ -221,16 +248,23 @@ class ModelManager:
 
         try:
             # Generate audio using provided voice tensor
+            # No lock needed here since inference is thread-safe
             return backend.generate(tokens, voice, speed)
-            
         except Exception as e:
             raise RuntimeError(f"Generation failed: {e}")
 
     def unload_all(self) -> None:
-        """Unload models from all backends."""
+        """Unload models from all backends and clear cache."""
+        # Clean up session pools
+        for pool in self._session_pools.values():
+            pool.cleanup()
+            
+        # Unload PyTorch backends
         for backend in self._backends.values():
             backend.unload()
-        logger.info("Unloaded all models")
+            
+        self._loaded_models.clear()
+        logger.info("Unloaded all models and cleared cache")
 
     @property
     def available_backends(self) -> list[str]:
@@ -251,12 +285,8 @@ class ModelManager:
         return self._current_backend
 
 
-# Module-level instance
-_manager: Optional[ModelManager] = None
-
-
-def get_manager(config: Optional[ModelConfig] = None) -> ModelManager:
-    """Get or create global model manager instance.
+async def get_manager(config: Optional[ModelConfig] = None) -> ModelManager:
+    """Get global model manager instance.
     
     Args:
         config: Optional model configuration
@@ -264,7 +294,10 @@ def get_manager(config: Optional[ModelConfig] = None) -> ModelManager:
     Returns:
         ModelManager instance
     """
-    global _manager
-    if _manager is None:
-        _manager = ModelManager(config)
-    return _manager
\ No newline at end of file
+    global _manager_instance
+    
+    async with _manager_lock:
+        if _manager_instance is None:
+            _manager_instance = ModelManager(config)
+            await _manager_instance.initialize()
+        return _manager_instance
\ No newline at end of file
diff --git a/api/src/inference/onnx_cpu.py b/api/src/inference/onnx_cpu.py
index 34d68ac..b17227c 100644
--- a/api/src/inference/onnx_cpu.py
+++ b/api/src/inference/onnx_cpu.py
@@ -1,20 +1,16 @@
 """CPU-based ONNX inference backend."""
 
-from typing import Dict, Optional
+from typing import Optional
 
 import numpy as np
 import torch
 from loguru import logger
-from onnxruntime import (
-    ExecutionMode,
-    GraphOptimizationLevel,
-    InferenceSession,
-    SessionOptions
-)
+from onnxruntime import InferenceSession
 
 from ..core import paths
 from ..core.model_config import model_config
 from .base import BaseModelBackend
+from .session_pool import create_session_options, create_provider_options
 
 
 class ONNXCPUBackend(BaseModelBackend):
@@ -47,8 +43,8 @@ class ONNXCPUBackend(BaseModelBackend):
             logger.info(f"Loading ONNX model: {model_path}")
             
             # Configure session
-            options = self._create_session_options()
-            provider_options = self._create_provider_options()
+            options = create_session_options(is_gpu=False)
+            provider_options = create_provider_options(is_gpu=False)
             
             # Create session
             self._session = InferenceSession(
@@ -84,9 +80,9 @@ class ONNXCPUBackend(BaseModelBackend):
             raise RuntimeError("Model not loaded")
 
         try:
-            # Prepare inputs
-            tokens_input = np.array([tokens], dtype=np.int64)
-            style_input = voice[len(tokens)].numpy()
+            # Prepare inputs with start/end tokens
+            tokens_input = np.array([[0, *tokens, 0]], dtype=np.int64)  # Add start/end tokens
+            style_input = voice[len(tokens) + 2].numpy()  # Adjust index for start/end tokens
             speed_input = np.full(1, speed, dtype=np.float32)
 
             # Run inference
@@ -104,52 +100,6 @@ class ONNXCPUBackend(BaseModelBackend):
         except Exception as e:
             raise RuntimeError(f"Generation failed: {e}")
 
-    def _create_session_options(self) -> SessionOptions:
-        """Create ONNX session options.
-        
-        Returns:
-            Configured session options
-        """
-        options = SessionOptions()
-        config = model_config.onnx_cpu
-        
-        # Set optimization level
-        if config.optimization_level == "all":
-            options.graph_optimization_level = GraphOptimizationLevel.ORT_ENABLE_ALL
-        elif config.optimization_level == "basic":
-            options.graph_optimization_level = GraphOptimizationLevel.ORT_ENABLE_BASIC
-        else:
-            options.graph_optimization_level = GraphOptimizationLevel.ORT_DISABLE_ALL
-        
-        # Configure threading
-        options.intra_op_num_threads = config.num_threads
-        options.inter_op_num_threads = config.inter_op_threads
-        
-        # Set execution mode
-        options.execution_mode = (
-            ExecutionMode.ORT_PARALLEL
-            if config.execution_mode == "parallel"
-            else ExecutionMode.ORT_SEQUENTIAL
-        )
-        
-        # Configure memory optimization
-        options.enable_mem_pattern = config.memory_pattern
-        
-        return options
-
-    def _create_provider_options(self) -> Dict:
-        """Create CPU provider options.
-        
-        Returns:
-            Provider configuration
-        """
-        return {
-            "CPUExecutionProvider": {
-                "arena_extend_strategy": model_config.onnx_cpu.arena_extend_strategy,
-                "cpu_memory_arena_cfg": "cpu:0"
-            }
-        }
-
     def unload(self) -> None:
         """Unload model and free resources."""
         if self._session is not None:
diff --git a/api/src/inference/onnx_gpu.py b/api/src/inference/onnx_gpu.py
index 2df32e2..f11534e 100644
--- a/api/src/inference/onnx_gpu.py
+++ b/api/src/inference/onnx_gpu.py
@@ -1,20 +1,16 @@
 """GPU-based ONNX inference backend."""
 
-from typing import Dict, Optional
+from typing import Optional
 
 import numpy as np
 import torch
 from loguru import logger
-from onnxruntime import (
-    ExecutionMode,
-    GraphOptimizationLevel,
-    InferenceSession,
-    SessionOptions
-)
+from onnxruntime import InferenceSession
 
 from ..core import paths
 from ..core.model_config import model_config
 from .base import BaseModelBackend
+from .session_pool import create_session_options, create_provider_options
 
 
 class ONNXGPUBackend(BaseModelBackend):
@@ -27,6 +23,9 @@ class ONNXGPUBackend(BaseModelBackend):
             raise RuntimeError("CUDA not available")
         self._device = "cuda"
         self._session: Optional[InferenceSession] = None
+        
+        # Configure GPU
+        torch.cuda.set_device(model_config.onnx_gpu.device_id)
 
     @property
     def is_loaded(self) -> bool:
@@ -49,8 +48,8 @@ class ONNXGPUBackend(BaseModelBackend):
             logger.info(f"Loading ONNX model on GPU: {model_path}")
             
             # Configure session
-            options = self._create_session_options()
-            provider_options = self._create_provider_options()
+            options = create_session_options(is_gpu=True)
+            provider_options = create_provider_options(is_gpu=True)
             
             # Create session with CUDA provider
             self._session = InferenceSession(
@@ -87,8 +86,8 @@ class ONNXGPUBackend(BaseModelBackend):
 
         try:
             # Prepare inputs
-            tokens_input = np.array([tokens], dtype=np.int64)
-            style_input = voice[len(tokens)].cpu().numpy()  # Move to CPU for ONNX
+            tokens_input = np.array([[0, *tokens, 0]], dtype=np.int64)  # Add start/end tokens
+            style_input = voice[len(tokens) + 2].cpu().numpy()  # Move to CPU for ONNX
             speed_input = np.full(1, speed, dtype=np.float32)
 
             # Run inference
@@ -104,62 +103,15 @@ class ONNXGPUBackend(BaseModelBackend):
             return result[0]
             
         except Exception as e:
+            if "out of memory" in str(e).lower():
+                # Clear CUDA cache and retry
+                torch.cuda.empty_cache()
+                return self.generate(tokens, voice, speed)
             raise RuntimeError(f"Generation failed: {e}")
 
-    def _create_session_options(self) -> SessionOptions:
-        """Create ONNX session options.
-        
-        Returns:
-            Configured session options
-        """
-        options = SessionOptions()
-        config = model_config.onnx_gpu
-        
-        # Set optimization level
-        if config.optimization_level == "all":
-            options.graph_optimization_level = GraphOptimizationLevel.ORT_ENABLE_ALL
-        elif config.optimization_level == "basic":
-            options.graph_optimization_level = GraphOptimizationLevel.ORT_ENABLE_BASIC
-        else:
-            options.graph_optimization_level = GraphOptimizationLevel.ORT_DISABLE_ALL
-        
-        # Configure threading
-        options.intra_op_num_threads = config.num_threads
-        options.inter_op_num_threads = config.inter_op_threads
-        
-        # Set execution mode
-        options.execution_mode = (
-            ExecutionMode.ORT_PARALLEL
-            if config.execution_mode == "parallel"
-            else ExecutionMode.ORT_SEQUENTIAL
-        )
-        
-        # Configure memory optimization
-        options.enable_mem_pattern = config.memory_pattern
-        
-        return options
-
-    def _create_provider_options(self) -> Dict:
-        """Create CUDA provider options.
-        
-        Returns:
-            Provider configuration
-        """
-        config = model_config.onnx_gpu
-        return {
-            "CUDAExecutionProvider": {
-                "device_id": config.device_id,
-                "arena_extend_strategy": config.arena_extend_strategy,
-                "gpu_mem_limit": int(config.gpu_mem_limit * torch.cuda.get_device_properties(0).total_memory),
-                "cudnn_conv_algo_search": config.cudnn_conv_algo_search,
-                "do_copy_in_default_stream": config.do_copy_in_default_stream
-            }
-        }
-
     def unload(self) -> None:
         """Unload model and free resources."""
         if self._session is not None:
             del self._session
             self._session = None
-            if torch.cuda.is_available():
-                torch.cuda.empty_cache()
\ No newline at end of file
+            torch.cuda.empty_cache()
\ No newline at end of file
diff --git a/api/src/inference/pytorch_gpu.py b/api/src/inference/pytorch_gpu.py
index 2995818..fc07a0d 100644
--- a/api/src/inference/pytorch_gpu.py
+++ b/api/src/inference/pytorch_gpu.py
@@ -13,8 +13,37 @@ from ..core.model_config import model_config
 from .base import BaseModelBackend
 
 
+class CUDAStreamManager:
+    """CUDA stream manager."""
+    
+    def __init__(self, num_streams: int):
+        """Initialize stream manager.
+        
+        Args:
+            num_streams: Number of CUDA streams
+        """
+        self.streams = [torch.cuda.Stream() for _ in range(num_streams)]
+        self._current = 0
+        
+    def get_next_stream(self) -> torch.cuda.Stream:
+        """Get next available stream.
+        
+        Returns:
+            CUDA stream
+        """
+        stream = self.streams[self._current]
+        self._current = (self._current + 1) % len(self.streams)
+        return stream
+
+
 @torch.no_grad()
-def forward(model: torch.nn.Module, tokens: list[int], ref_s: torch.Tensor, speed: float) -> np.ndarray:
+def forward(
+    model: torch.nn.Module,
+    tokens: list[int],
+    ref_s: torch.Tensor,
+    speed: float,
+    stream: Optional[torch.cuda.Stream] = None
+) -> np.ndarray:
     """Forward pass through model.
     
     Args:
@@ -22,59 +51,67 @@ def forward(model: torch.nn.Module, tokens: list[int], ref_s: torch.Tensor, spee
         tokens: Input tokens
         ref_s: Reference signal (shape: [1, n_features])
         speed: Speed multiplier
+        stream: Optional CUDA stream
         
     Returns:
         Generated audio
     """
     device = ref_s.device
     
-    # Initial tensor setup
-    tokens = torch.LongTensor([[0, *tokens, 0]]).to(device)
-    input_lengths = torch.LongTensor([tokens.shape[-1]]).to(device)
-    text_mask = length_to_mask(input_lengths).to(device)
+    # Use provided stream or default
+    with torch.cuda.stream(stream) if stream else torch.cuda.default_stream():
+        # Initial tensor setup
+        tokens = torch.LongTensor([[0, *tokens, 0]]).to(device)
+        input_lengths = torch.LongTensor([tokens.shape[-1]]).to(device)
+        text_mask = length_to_mask(input_lengths).to(device)
 
-    # Split reference signals (style_dim=128 from config)
-    style_dim = 128
-    s_ref = ref_s[:, :style_dim].clone().to(device)
-    s_content = ref_s[:, style_dim:].clone().to(device)
+        # Split reference signals (style_dim=128 from config)
+        style_dim = 128
+        s_ref = ref_s[:, :style_dim].clone().to(device)
+        s_content = ref_s[:, style_dim:].clone().to(device)
 
-    # BERT and encoder pass
-    bert_dur = model.bert(tokens, attention_mask=(~text_mask).int())
-    d_en = model.bert_encoder(bert_dur).transpose(-1, -2)
+        # BERT and encoder pass
+        bert_dur = model.bert(tokens, attention_mask=(~text_mask).int())
+        d_en = model.bert_encoder(bert_dur).transpose(-1, -2)
 
-    # Predictor forward pass
-    d = model.predictor.text_encoder(d_en, s_content, input_lengths, text_mask)
-    x, _ = model.predictor.lstm(d)
+        # Predictor forward pass
+        d = model.predictor.text_encoder(d_en, s_content, input_lengths, text_mask)
+        x, _ = model.predictor.lstm(d)
 
-    # Duration prediction
-    duration = model.predictor.duration_proj(x)
-    duration = torch.sigmoid(duration).sum(axis=-1) / speed
-    pred_dur = torch.round(duration).clamp(min=1).long()
-    del duration, x
+        # Duration prediction
+        duration = model.predictor.duration_proj(x)
+        duration = torch.sigmoid(duration).sum(axis=-1) / speed
+        pred_dur = torch.round(duration).clamp(min=1).long()
+        del duration, x
 
-    # Alignment matrix construction
-    pred_aln_trg = torch.zeros(input_lengths.item(), pred_dur.sum().item(), device=device)
-    c_frame = 0
-    for i in range(pred_aln_trg.size(0)):
-        pred_aln_trg[i, c_frame:c_frame + pred_dur[0, i].item()] = 1
-        c_frame += pred_dur[0, i].item()
-    pred_aln_trg = pred_aln_trg.unsqueeze(0)
+        # Alignment matrix construction
+        pred_aln_trg = torch.zeros(input_lengths.item(), pred_dur.sum().item(), device=device)
+        c_frame = 0
+        for i in range(pred_aln_trg.size(0)):
+            pred_aln_trg[i, c_frame:c_frame + pred_dur[0, i].item()] = 1
+            c_frame += pred_dur[0, i].item()
+        pred_aln_trg = pred_aln_trg.unsqueeze(0)
 
-    # Matrix multiplications
-    en = d.transpose(-1, -2) @ pred_aln_trg
-    del d
-    
-    F0_pred, N_pred = model.predictor.F0Ntrain(en, s_content)
-    del en
+        # Matrix multiplications
+        en = d.transpose(-1, -2) @ pred_aln_trg
+        del d
+        
+        F0_pred, N_pred = model.predictor.F0Ntrain(en, s_content)
+        del en
 
-    # Final text encoding and decoding
-    t_en = model.text_encoder(tokens, input_lengths, text_mask)
-    asr = t_en @ pred_aln_trg
-    del t_en
+        # Final text encoding and decoding
+        t_en = model.text_encoder(tokens, input_lengths, text_mask)
+        asr = t_en @ pred_aln_trg
+        del t_en
 
-    # Generate output
-    output = model.decoder(asr, F0_pred, N_pred, s_ref)
-    return output.squeeze().cpu().numpy()
+        # Generate output
+        output = model.decoder(asr, F0_pred, N_pred, s_ref)
+        
+        # Ensure operation completion if using custom stream
+        if stream:
+            stream.synchronize()
+            
+        return output.squeeze().cpu().numpy()
 
 
 def length_to_mask(lengths: torch.Tensor) -> torch.Tensor:
@@ -92,9 +129,10 @@ class PyTorchGPUBackend(BaseModelBackend):
     def __init__(self):
         """Initialize GPU backend."""
         super().__init__()
-        if not torch.cuda.is_available():
-            raise RuntimeError("CUDA not available")
-        self._device = "cuda"
+        from ..core.config import settings
+        if not (settings.use_gpu and torch.cuda.is_available()):
+            raise RuntimeError("GPU backend requires GPU support and use_gpu=True")
+        self._device = "cuda"  # Device is enforced by backend selection in model_manager
         self._model: Optional[torch.nn.Module] = None
         
         # Configure GPU settings
@@ -102,6 +140,9 @@ class PyTorchGPUBackend(BaseModelBackend):
         if config.sync_cuda:
             torch.cuda.synchronize()
         torch.cuda.set_device(config.device_id)
+        
+        # Initialize stream manager
+        self._stream_manager = CUDAStreamManager(config.cuda_streams)
 
     async def load_model(self, path: str) -> None:
         """Load PyTorch model.
@@ -154,8 +195,11 @@ class PyTorchGPUBackend(BaseModelBackend):
             if ref_s.dim() == 1:
                 ref_s = ref_s.unsqueeze(0)  # Add batch dimension if needed
             
-            # Generate audio
-            return forward(self._model, tokens, ref_s, speed)
+            # Get next available stream
+            stream = self._stream_manager.get_next_stream()
+            
+            # Generate audio using stream
+            return forward(self._model, tokens, ref_s, speed, stream)
             
         except Exception as e:
             logger.error(f"Generation failed: {e}")
diff --git a/api/src/inference/session_pool.py b/api/src/inference/session_pool.py
new file mode 100644
index 0000000..4674a91
--- /dev/null
+++ b/api/src/inference/session_pool.py
@@ -0,0 +1,271 @@
+"""Session pooling for model inference."""
+
+import asyncio
+import time
+from dataclasses import dataclass
+from typing import Dict, Optional, Set
+
+import torch
+from loguru import logger
+from onnxruntime import (
+    ExecutionMode,
+    GraphOptimizationLevel,
+    InferenceSession,
+    SessionOptions
+)
+
+from ..core import paths
+from ..core.model_config import model_config
+
+
+@dataclass
+class SessionInfo:
+    """Session information."""
+    session: InferenceSession
+    last_used: float
+    stream_id: Optional[int] = None
+
+
+def create_session_options(is_gpu: bool = False) -> SessionOptions:
+    """Create ONNX session options.
+    
+    Args:
+        is_gpu: Whether to use GPU configuration
+        
+    Returns:
+        Configured session options
+    """
+    options = SessionOptions()
+    config = model_config.onnx_gpu if is_gpu else model_config.onnx_cpu
+    
+    # Set optimization level
+    if config.optimization_level == "all":
+        options.graph_optimization_level = GraphOptimizationLevel.ORT_ENABLE_ALL
+    elif config.optimization_level == "basic":
+        options.graph_optimization_level = GraphOptimizationLevel.ORT_ENABLE_BASIC
+    else:
+        options.graph_optimization_level = GraphOptimizationLevel.ORT_DISABLE_ALL
+    
+    # Configure threading
+    options.intra_op_num_threads = config.num_threads
+    options.inter_op_num_threads = config.inter_op_threads
+    
+    # Set execution mode
+    options.execution_mode = (
+        ExecutionMode.ORT_PARALLEL
+        if config.execution_mode == "parallel"
+        else ExecutionMode.ORT_SEQUENTIAL
+    )
+    
+    # Configure memory optimization
+    options.enable_mem_pattern = config.memory_pattern
+    
+    return options
+
+
+def create_provider_options(is_gpu: bool = False) -> Dict:
+    """Create provider options.
+    
+    Args:
+        is_gpu: Whether to use GPU configuration
+        
+    Returns:
+        Provider configuration
+    """
+    if is_gpu:
+        config = model_config.onnx_gpu
+        return {
+            "CUDAExecutionProvider": {
+                "device_id": config.device_id,
+                "arena_extend_strategy": config.arena_extend_strategy,
+                "gpu_mem_limit": int(config.gpu_mem_limit * torch.cuda.get_device_properties(0).total_memory),
+                "cudnn_conv_algo_search": config.cudnn_conv_algo_search,
+                "do_copy_in_default_stream": config.do_copy_in_default_stream
+            }
+        }
+    else:
+        return {
+            "CPUExecutionProvider": {
+                "arena_extend_strategy": model_config.onnx_cpu.arena_extend_strategy,
+                "cpu_memory_arena_cfg": "cpu:0"
+            }
+        }
+
+
+class BaseSessionPool:
+    """Base session pool implementation."""
+    
+    def __init__(self, max_size: int, timeout: int):
+        """Initialize session pool.
+        
+        Args:
+            max_size: Maximum number of concurrent sessions
+            timeout: Session timeout in seconds
+        """
+        self._max_size = max_size
+        self._timeout = timeout
+        self._sessions: Dict[str, SessionInfo] = {}
+        self._lock = asyncio.Lock()
+        
+    async def get_session(self, model_path: str) -> InferenceSession:
+        """Get session from pool.
+        
+        Args:
+            model_path: Path to model file
+            
+        Returns:
+            ONNX inference session
+            
+        Raises:
+            RuntimeError: If no sessions available
+        """
+        async with self._lock:
+            # Clean expired sessions
+            self._cleanup_expired()
+            
+            # Check if session exists and is valid
+            if model_path in self._sessions:
+                session_info = self._sessions[model_path]
+                session_info.last_used = time.time()
+                return session_info.session
+                
+            # Check if we can create new session
+            if len(self._sessions) >= self._max_size:
+                raise RuntimeError(
+                    f"Maximum number of sessions reached ({self._max_size})"
+                )
+                
+            # Create new session
+            session = await self._create_session(model_path)
+            self._sessions[model_path] = SessionInfo(
+                session=session,
+                last_used=time.time()
+            )
+            return session
+            
+    def _cleanup_expired(self) -> None:
+        """Remove expired sessions."""
+        current_time = time.time()
+        expired = [
+            path for path, info in self._sessions.items()
+            if current_time - info.last_used > self._timeout
+        ]
+        for path in expired:
+            logger.info(f"Removing expired session: {path}")
+            del self._sessions[path]
+            
+    async def _create_session(self, model_path: str) -> InferenceSession:
+        """Create new session.
+        
+        Args:
+            model_path: Path to model file
+            
+        Returns:
+            ONNX inference session
+        """
+        raise NotImplementedError
+        
+    def cleanup(self) -> None:
+        """Clean up all sessions."""
+        self._sessions.clear()
+
+
+class StreamingSessionPool(BaseSessionPool):
+    """GPU session pool with CUDA streams."""
+    
+    def __init__(self):
+        """Initialize GPU session pool."""
+        config = model_config.onnx_gpu
+        super().__init__(config.cuda_streams, config.stream_timeout)
+        self._available_streams: Set[int] = set(range(config.cuda_streams))
+        
+    async def get_session(self, model_path: str) -> InferenceSession:
+        """Get session with CUDA stream.
+        
+        Args:
+            model_path: Path to model file
+            
+        Returns:
+            ONNX inference session
+            
+        Raises:
+            RuntimeError: If no streams available
+        """
+        async with self._lock:
+            # Clean expired sessions
+            self._cleanup_expired()
+            
+            # Try to find existing session
+            if model_path in self._sessions:
+                session_info = self._sessions[model_path]
+                session_info.last_used = time.time()
+                return session_info.session
+                
+            # Get available stream
+            if not self._available_streams:
+                raise RuntimeError("No CUDA streams available")
+            stream_id = self._available_streams.pop()
+            
+            try:
+                # Create new session
+                session = await self._create_session(model_path)
+                self._sessions[model_path] = SessionInfo(
+                    session=session,
+                    last_used=time.time(),
+                    stream_id=stream_id
+                )
+                return session
+                
+            except Exception:
+                # Return stream to pool on failure
+                self._available_streams.add(stream_id)
+                raise
+                
+    def _cleanup_expired(self) -> None:
+        """Remove expired sessions and return streams."""
+        current_time = time.time()
+        expired = [
+            path for path, info in self._sessions.items()
+            if current_time - info.last_used > self._timeout
+        ]
+        for path in expired:
+            info = self._sessions[path]
+            if info.stream_id is not None:
+                self._available_streams.add(info.stream_id)
+            logger.info(f"Removing expired session: {path}")
+            del self._sessions[path]
+            
+    async def _create_session(self, model_path: str) -> InferenceSession:
+        """Create new session with CUDA provider."""
+        abs_path = await paths.get_model_path(model_path)
+        options = create_session_options(is_gpu=True)
+        provider_options = create_provider_options(is_gpu=True)
+        
+        return InferenceSession(
+            abs_path,
+            sess_options=options,
+            providers=["CUDAExecutionProvider"],
+            provider_options=[provider_options]
+        )
+
+
+class CPUSessionPool(BaseSessionPool):
+    """CPU session pool."""
+    
+    def __init__(self):
+        """Initialize CPU session pool."""
+        config = model_config.onnx_cpu
+        super().__init__(config.max_instances, config.instance_timeout)
+        
+    async def _create_session(self, model_path: str) -> InferenceSession:
+        """Create new session with CPU provider."""
+        abs_path = await paths.get_model_path(model_path)
+        options = create_session_options(is_gpu=False)
+        provider_options = create_provider_options(is_gpu=False)
+        
+        return InferenceSession(
+            abs_path,
+            sess_options=options,
+            providers=["CPUExecutionProvider"],
+            provider_options=[provider_options]
+        )
\ No newline at end of file
diff --git a/api/src/inference/voice_manager.py b/api/src/inference/voice_manager.py
index 15932c7..67f34a3 100644
--- a/api/src/inference/voice_manager.py
+++ b/api/src/inference/voice_manager.py
@@ -1,11 +1,10 @@
 """Voice pack management and caching."""
 
 import os
-from typing import Dict, List, Optional, Union
+from typing import Dict, List, Optional
 
 import torch
 from loguru import logger
-from pydantic import BaseModel
 
 from ..core import paths
 from ..core.config import settings
@@ -13,7 +12,7 @@ from ..structures.model_schemas import VoiceConfig
 
 
 class VoiceManager:
-    """Manages voice loading, caching, and operations."""
+    """Manages voice loading and operations."""
 
     def __init__(self, config: Optional[VoiceConfig] = None):
         """Initialize voice manager.
@@ -33,15 +32,8 @@ class VoiceManager:
         Returns:
             Path to voice file if exists, None otherwise
         """
-        # Get api directory path (two levels up from inference)
         api_dir = os.path.dirname(os.path.dirname(os.path.dirname(__file__)))
-        
-        # Construct voice path relative to api directory
         voice_path = os.path.join(api_dir, settings.voices_dir, f"{voice_name}.pt")
-        
-        # Ensure voices directory exists
-        os.makedirs(os.path.dirname(voice_path), exist_ok=True)
-        
         return voice_path if os.path.exists(voice_path) else None
 
     async def load_voice(self, voice_name: str, device: str = "cpu") -> torch.Tensor:
@@ -66,21 +58,20 @@ class VoiceManager:
         if self._config.use_cache and cache_key in self._voice_cache:
             return self._voice_cache[cache_key]
 
+        # Load voice tensor
         try:
-            # Load voice tensor
             voice = await paths.load_voice_tensor(voice_path, device=device)
-
-            # Cache if enabled
-            if self._config.use_cache:
-                self._manage_cache()
-                self._voice_cache[cache_key] = voice
-                logger.debug(f"Cached voice: {voice_name} on {device}")
-
-            return voice
-
         except Exception as e:
             raise RuntimeError(f"Failed to load voice {voice_name}: {e}")
 
+        # Cache if enabled
+        if self._config.use_cache:
+            self._manage_cache()
+            self._voice_cache[cache_key] = voice
+            logger.debug(f"Cached voice: {voice_name} on {device}")
+
+        return voice
+
     def _manage_cache(self) -> None:
         """Manage voice cache size."""
         if len(self._voice_cache) >= self._config.cache_size:
@@ -123,14 +114,14 @@ class VoiceManager:
             # Get api directory path
             api_dir = os.path.dirname(os.path.dirname(os.path.dirname(__file__)))
             voices_dir = os.path.join(api_dir, settings.voices_dir)
-            
-            # Ensure voices directory exists
             os.makedirs(voices_dir, exist_ok=True)
             
             # Save combined voice
             combined_path = os.path.join(voices_dir, f"{combined_name}.pt")
             try:
                 torch.save(combined_tensor, combined_path)
+                # Cache the new combined voice
+                self._voice_cache[f"{combined_path}_{device}"] = combined_tensor
             except Exception as e:
                 raise RuntimeError(f"Failed to save combined voice: {e}")
 
@@ -147,17 +138,13 @@ class VoiceManager:
         """
         voices = []
         try:
-            # Get api directory path
             api_dir = os.path.dirname(os.path.dirname(os.path.dirname(__file__)))
             voices_dir = os.path.join(api_dir, settings.voices_dir)
-            
-            # Ensure voices directory exists
             os.makedirs(voices_dir, exist_ok=True)
             
-            # List voice files
             for entry in os.listdir(voices_dir):
                 if entry.endswith(".pt"):
-                    voices.append(entry[:-3])  # Remove .pt extension
+                    voices.append(entry[:-3])
         except Exception as e:
             logger.error(f"Error listing voices: {e}")
         return sorted(voices)
@@ -174,11 +161,8 @@ class VoiceManager:
         try:
             if not os.path.exists(voice_path):
                 return False
-            
-            # Try loading voice
             voice = torch.load(voice_path, map_location="cpu")
             return isinstance(voice, torch.Tensor)
-            
         except Exception:
             return False
 
@@ -195,12 +179,12 @@ class VoiceManager:
         }
 
 
-# Module-level instance
-_manager: Optional[VoiceManager] = None
+# Global singleton instance
+_manager_instance = None
 
 
-def get_manager(config: Optional[VoiceConfig] = None) -> VoiceManager:
-    """Get or create global voice manager instance.
+async def get_manager(config: Optional[VoiceConfig] = None) -> VoiceManager:
+    """Get global voice manager instance.
     
     Args:
         config: Optional voice configuration
@@ -208,7 +192,7 @@ def get_manager(config: Optional[VoiceConfig] = None) -> VoiceManager:
     Returns:
         VoiceManager instance
     """
-    global _manager
-    if _manager is None:
-        _manager = VoiceManager(config)
-    return _manager
\ No newline at end of file
+    global _manager_instance
+    if _manager_instance is None:
+        _manager_instance = VoiceManager(config)
+    return _manager_instance
\ No newline at end of file
diff --git a/api/src/main.py b/api/src/main.py
index ec1b6c8..8516325 100644
--- a/api/src/main.py
+++ b/api/src/main.py
@@ -1,10 +1,13 @@
+
 """
 FastAPI OpenAI Compatible API
 """
 
+import os
 import sys
 from contextlib import asynccontextmanager
 
+import torch
 import uvicorn
 from fastapi import FastAPI
 from fastapi.middleware.cors import CORSMiddleware
@@ -41,19 +44,59 @@ setup_logger()
 @asynccontextmanager
 async def lifespan(app: FastAPI):
     """Lifespan context manager for model initialization"""
+    from .inference.model_manager import get_manager
+    from .inference.voice_manager import get_manager as get_voice_manager
+
     logger.info("Loading TTS model and voice packs...")
 
-    # Initialize service
-    service = TTSService()
-    await service.ensure_initialized()
-    
-    # Get available voices
-    voices = await service.list_voices()
-    voicepack_count = len(voices)
+    try:
+        # Initialize managers globally
+        model_manager = await get_manager()
+        voice_manager = await get_voice_manager()
 
-    # Get device info from model manager
-    device = "GPU" if settings.use_gpu else "CPU"
-    model = "ONNX" if settings.use_onnx else "PyTorch"
+        # Determine backend type based on settings
+        if settings.use_gpu and torch.cuda.is_available():
+            backend_type = 'pytorch_gpu' if not settings.use_onnx else 'onnx_gpu'
+        else:
+            backend_type = 'pytorch_cpu' if not settings.use_onnx else 'onnx_cpu'
+
+        # Get backend and initialize model
+        backend = model_manager.get_backend(backend_type)
+        
+        # Use model path directly from settings
+        model_file = settings.pytorch_model_file if not settings.use_onnx else settings.onnx_model_file
+        model_path = os.path.join(settings.model_dir, model_file)
+        
+        
+        if not os.path.exists(model_path):
+            raise RuntimeError(f"Model file not found: {model_path}")
+
+        # Pre-cache default voice and use for warmup
+        warmup_voice = await voice_manager.load_voice(settings.default_voice, device=backend.device)
+        logger.info(f"Pre-cached voice {settings.default_voice} for warmup")
+        
+        # Initialize model with warmup voice
+        await model_manager.load_model(model_path, warmup_voice, backend_type)
+
+        # Pre-cache common voices in background
+        common_voices = ['af', 'af_bella', 'af_sarah', 'af_nicole']
+        for voice_name in common_voices:
+            try:
+                await voice_manager.load_voice(voice_name, device=backend.device)
+                logger.debug(f"Pre-cached voice {voice_name}")
+            except Exception as e:
+                logger.warning(f"Failed to pre-cache voice {voice_name}: {e}")
+
+        # Get available voices for startup message
+        voices = await voice_manager.list_voices()
+        voicepack_count = len(voices)
+
+        # Get device info for startup message
+        device = "GPU" if settings.use_gpu else "CPU"
+        model = "ONNX" if settings.use_onnx else "PyTorch"
+    except Exception as e:
+        logger.error(f"Failed to initialize model: {e}")
+        raise
     boundary = "░" * 2*12
     startup_msg = f"""
 
diff --git a/api/src/routers/development.py b/api/src/routers/development.py
index 4713440..b8ecf35 100644
--- a/api/src/routers/development.py
+++ b/api/src/routers/development.py
@@ -1,7 +1,7 @@
 from typing import List
 
 import numpy as np
-from fastapi import APIRouter, Depends, HTTPException, Response
+from fastapi import APIRouter, Depends, HTTPException, Request, Response
 from loguru import logger
 
 from ..services.audio import AudioService
@@ -16,9 +16,9 @@ from ..structures.text_schemas import (
 router = APIRouter(tags=["text processing"])
 
 
-def get_tts_service() -> TTSService:
+async def get_tts_service() -> TTSService:
     """Dependency to get TTSService instance"""
-    return TTSService()
+    return await TTSService.create()  # Create service with properly initialized managers
 
 
 @router.post("/text/phonemize", response_model=PhonemeResponse, tags=["deprecated"])
@@ -82,9 +82,6 @@ async def generate_from_phonemes(
         )
 
     try:
-        # Ensure service is initialized
-        await tts_service.ensure_initialized()
-
         # Validate voice exists
         available_voices = await tts_service.list_voices()
         if request.voice not in available_voices:
diff --git a/api/src/routers/openai_compatible.py b/api/src/routers/openai_compatible.py
index 57d1257..4d1ca7a 100644
--- a/api/src/routers/openai_compatible.py
+++ b/api/src/routers/openai_compatible.py
@@ -1,6 +1,6 @@
 from typing import AsyncGenerator, List, Union
 
-from fastapi import APIRouter, Depends, Header, HTTPException, Response, Request
+from fastapi import APIRouter, Depends, Header, HTTPException, Request, Response
 from fastapi.responses import StreamingResponse
 from loguru import logger
 
@@ -13,10 +13,28 @@ router = APIRouter(
     responses={404: {"description": "Not found"}},
 )
 
+# Global TTSService instance with lock
+_tts_service = None
+_init_lock = None
 
-def get_tts_service() -> TTSService:
-    """Dependency to get TTSService instance with database session"""
-    return TTSService()  # Initialize TTSService with default settings
+async def get_tts_service() -> TTSService:
+    """Get global TTSService instance"""
+    global _tts_service, _init_lock
+    
+    # Create lock if needed
+    if _init_lock is None:
+        import asyncio
+        _init_lock = asyncio.Lock()
+    
+    # Initialize service if needed
+    if _tts_service is None:
+        async with _init_lock:
+            # Double check pattern
+            if _tts_service is None:
+                _tts_service = await TTSService.create()
+                logger.info("Created global TTSService instance")
+    
+    return _tts_service
 
 
 async def process_voices(
@@ -78,11 +96,13 @@ async def stream_audio_chunks(
 async def create_speech(
     request: OpenAISpeechRequest,
     client_request: Request,
-    tts_service: TTSService = Depends(get_tts_service),
     x_raw_response: str = Header(None, alias="x-raw-response"),
 ):
     """OpenAI-compatible endpoint for text-to-speech"""
     try:
+        # Get global service instance
+        tts_service = await get_tts_service()
+        
         # Process voice combination and validate
         voice_to_use = await process_voices(request.voice, tts_service)
 
@@ -145,9 +165,10 @@ async def create_speech(
 
 
 @router.get("/audio/voices")
-async def list_voices(tts_service: TTSService = Depends(get_tts_service)):
+async def list_voices():
     """List all available voices for text-to-speech"""
     try:
+        tts_service = await get_tts_service()
         voices = await tts_service.list_voices()
         return {"voices": voices}
     except Exception as e:
@@ -156,9 +177,7 @@ async def list_voices(tts_service: TTSService = Depends(get_tts_service)):
 
 
 @router.post("/audio/voices/combine")
-async def combine_voices(
-    request: Union[str, List[str]], tts_service: TTSService = Depends(get_tts_service)
-):
+async def combine_voices(request: Union[str, List[str]]):
     """Combine multiple voices into a new voice.
 
     Args:
@@ -174,6 +193,7 @@ async def combine_voices(
             - 500: Server error (file system issues, combination failed)
     """
     try:
+        tts_service = await get_tts_service()
         combined_voice = await process_voices(request, tts_service)
         voices = await tts_service.list_voices()
         return {"voices": voices, "voice": combined_voice}
diff --git a/api/src/services/text_processing/phonemizer.py b/api/src/services/text_processing/phonemizer.py
index a328bb5..b0782f3 100644
--- a/api/src/services/text_processing/phonemizer.py
+++ b/api/src/services/text_processing/phonemizer.py
@@ -4,7 +4,7 @@ from abc import ABC, abstractmethod
 import phonemizer
 
 from .normalizer import normalize_text
-
+phonemizers = {}
 
 class PhonemizerBackend(ABC):
     """Abstract base class for phonemization backends"""
@@ -91,8 +91,9 @@ def phonemize(text: str, language: str = "a", normalize: bool = True) -> str:
     Returns:
         Phonemized text
     """
+    global phonemizers
     if normalize:
         text = normalize_text(text)
-
-    phonemizer = create_phonemizer(language)
-    return phonemizer.phonemize(text)
+    if language not in phonemizers:
+        phonemizers[language]=create_phonemizer(language)
+    return phonemizers[language].phonemize(text)
\ No newline at end of file
diff --git a/api/src/services/tts_service.py b/api/src/services/tts_service.py
index 9c51b19..83bf8e1 100644
--- a/api/src/services/tts_service.py
+++ b/api/src/services/tts_service.py
@@ -1,9 +1,8 @@
 """TTS service using model and voice managers."""
 
 import io
-import os
 import time
-from typing import List, Tuple
+from typing import List, Tuple, Optional
 
 import numpy as np
 import scipy.io.wavfile as wavfile
@@ -17,9 +16,14 @@ from .audio import AudioNormalizer, AudioService
 from .text_processing import chunker, normalize_text, process_text
 
 
+import asyncio
+
 class TTSService:
     """Text-to-speech service."""
 
+    # Limit concurrent chunk processing
+    _chunk_semaphore = asyncio.Semaphore(4)
+
     def __init__(self, output_dir: str = None):
         """Initialize service.
         
@@ -27,53 +31,24 @@ class TTSService:
             output_dir: Optional output directory for saving audio
         """
         self.output_dir = output_dir
-        self.model_manager = get_model_manager()
-        self.voice_manager = get_voice_manager()
-        self._initialized = False
-        self._initialization_error = None
+        self.model_manager = None
+        self._voice_manager = None
 
-    async def ensure_initialized(self):
-        """Ensure model is initialized."""
-        if self._initialized:
-            return
-        if self._initialization_error:
-            raise self._initialization_error
-
-        try:
-            # Get api directory path (one level up from src)
-            api_dir = os.path.dirname(os.path.dirname(os.path.dirname(__file__)))
+    @classmethod
+    async def create(cls, output_dir: str = None) -> 'TTSService':
+        """Create and initialize TTSService instance.
+        
+        Args:
+            output_dir: Optional output directory for saving audio
             
-            # Determine model file and backend based on hardware
-            if settings.use_gpu and torch.cuda.is_available():
-                model_file = settings.pytorch_model_file
-                backend_type = 'pytorch_gpu'
-            else:
-                model_file = settings.onnx_model_file
-                backend_type = 'onnx_cpu'
-            
-            # Construct model path relative to api directory
-            model_path = os.path.join(api_dir, settings.model_dir, model_file)
-            
-            # Ensure model directory exists
-            os.makedirs(os.path.dirname(model_path), exist_ok=True)
-            
-            if not os.path.exists(model_path):
-                raise RuntimeError(f"Model file not found: {model_path}")
-            
-            # Load default voice for warmup
-            backend = self.model_manager.get_backend(backend_type)
-            warmup_voice = await self.voice_manager.load_voice(settings.default_voice, device=backend.device)
-            logger.info(f"Loaded voice {settings.default_voice} for warmup")
-            
-            # Initialize model with warmup voice
-            await self.model_manager.load_model(model_path, warmup_voice, backend_type)
-            logger.info(f"Initialized model on {backend_type} backend")
-            self._initialized = True
-            
-        except Exception as e:
-            logger.error(f"Failed to initialize model: {e}")
-            self._initialization_error = RuntimeError(f"Model initialization failed: {e}")
-            raise self._initialization_error
+        Returns:
+            Initialized TTSService instance
+        """
+        service = cls(output_dir)
+        # Initialize managers
+        service.model_manager = await get_model_manager()
+        service._voice_manager = await get_voice_manager()
+        return service
 
     async def generate_audio(
         self, text: str, voice: str, speed: float = 1.0
@@ -88,8 +63,8 @@ class TTSService:
         Returns:
             Audio samples and processing time
         """
-        await self.ensure_initialized()
         start_time = time.time()
+        voice_tensor = None
 
         try:
             # Normalize text
@@ -98,31 +73,40 @@ class TTSService:
                 raise ValueError("Text is empty after preprocessing")
             text = str(normalized)
 
-            # Process text into chunks
-            audio_chunks = []
-            for chunk in chunker.split_text(text):
-                try:
-                    # Convert chunk to token IDs
-                    tokens = process_text(chunk)
-                    if not tokens:
-                        continue
+            # Get backend and load voice
+            backend = self.model_manager.get_backend()
+            voice_tensor = await self._voice_manager.load_voice(voice, device=backend.device)
 
-                    # Get backend and load voice
-                    backend = self.model_manager.get_backend()
-                    voice_tensor = await self.voice_manager.load_voice(voice, device=backend.device)
-                    
-                    # Generate audio
-                    chunk_audio = await self.model_manager.generate(
-                        tokens,
-                        voice_tensor,
-                        speed=speed
-                    )
-                    if chunk_audio is not None:
-                        audio_chunks.append(chunk_audio)
-                except Exception as e:
-                    logger.error(f"Failed to process chunk: '{chunk}'. Error: {str(e)}")
-                    continue
+            # Get all chunks upfront
+            chunks = list(chunker.split_text(text))
+            if not chunks:
+                raise ValueError("No text chunks to process")
 
+            # Process chunk with concurrency control
+            async def process_chunk(chunk: str) -> Optional[np.ndarray]:
+                async with self._chunk_semaphore:
+                    try:
+                        tokens = process_text(chunk)
+                        if not tokens:
+                            return None
+                        
+                        # Generate audio
+                        return await self.model_manager.generate(
+                            tokens,
+                            voice_tensor,
+                            speed=speed
+                        )
+                    except Exception as e:
+                        logger.error(f"Failed to process chunk: '{chunk}'. Error: {str(e)}")
+                        return None
+
+            # Process all chunks concurrently
+            chunk_results = await asyncio.gather(*[
+                process_chunk(chunk) for chunk in chunks
+            ])
+
+            # Filter out None results and combine
+            audio_chunks = [chunk for chunk in chunk_results if chunk is not None]
             if not audio_chunks:
                 raise ValueError("No audio chunks were generated successfully")
 
@@ -134,6 +118,11 @@ class TTSService:
         except Exception as e:
             logger.error(f"Error in audio generation: {str(e)}")
             raise
+        finally:
+            # Always clean up voice tensor
+            if voice_tensor is not None:
+                del voice_tensor
+                torch.cuda.empty_cache()
 
     async def generate_audio_stream(
         self,
@@ -153,33 +142,34 @@ class TTSService:
         Yields:
             Audio chunks as bytes
         """
-        await self.ensure_initialized()
-
+        # Setup audio processing
+        stream_normalizer = AudioNormalizer()
+        voice_tensor = None
+        
         try:
-            # Setup audio processing
-            stream_normalizer = AudioNormalizer()
-            
             # Normalize text
             normalized = normalize_text(text)
             if not normalized:
                 raise ValueError("Text is empty after preprocessing")
             text = str(normalized)
 
-            # Process chunks
-            is_first = True
-            chunk_gen = chunker.split_text(text)
-            current_chunk = next(chunk_gen, None)
+            # Get backend and load voice
+            backend = self.model_manager.get_backend()
+            voice_tensor = await self._voice_manager.load_voice(voice, device=backend.device)
+
+            # Get all chunks upfront
+            chunks = list(chunker.split_text(text))
+            if not chunks:
+                raise ValueError("No text chunks to process")
+
+            # Process chunk with concurrency control
+            async def process_chunk(chunk: str, is_first: bool, is_last: bool) -> Optional[bytes]:
+                async with self._chunk_semaphore:
+                    try:
+                        tokens = process_text(chunk)
+                        if not tokens:
+                            return None
 
-            while current_chunk is not None:
-                next_chunk = next(chunk_gen, None)
-                try:
-                    # Convert chunk to token IDs
-                    tokens = process_text(current_chunk)
-                    if tokens:
-                        # Get backend and load voice
-                        backend = self.model_manager.get_backend()
-                        voice_tensor = await self.voice_manager.load_voice(voice, device=backend.device)
-                        
                         # Generate audio
                         chunk_audio = await self.model_manager.generate(
                             tokens,
@@ -189,26 +179,38 @@ class TTSService:
 
                         if chunk_audio is not None:
                             # Convert to bytes
-                            chunk_bytes = AudioService.convert_audio(
+                            return AudioService.convert_audio(
                                 chunk_audio,
                                 24000,
                                 output_format,
                                 is_first_chunk=is_first,
                                 normalizer=stream_normalizer,
-                                is_last_chunk=(next_chunk is None),
+                                is_last_chunk=is_last,
                                 stream=True
                             )
-                            yield chunk_bytes
-                            is_first = False
+                    except Exception as e:
+                        logger.error(f"Failed to generate audio for chunk: '{chunk}'. Error: {str(e)}")
+                        return None
 
-                except Exception as e:
-                    logger.error(f"Failed to generate audio for chunk: '{current_chunk}'. Error: {str(e)}")
+            # Create tasks for all chunks
+            tasks = [
+                process_chunk(chunk, i==0, i==len(chunks)-1)
+                for i, chunk in enumerate(chunks)
+            ]
 
-                current_chunk = next_chunk
+            # Process chunks concurrently and yield results in order
+            for chunk_bytes in await asyncio.gather(*tasks):
+                if chunk_bytes is not None:
+                    yield chunk_bytes
 
         except Exception as e:
             logger.error(f"Error in audio generation stream: {str(e)}")
             raise
+        finally:
+            # Always clean up voice tensor
+            if voice_tensor is not None:
+                del voice_tensor
+                torch.cuda.empty_cache()
 
     async def combine_voices(self, voices: List[str]) -> str:
         """Combine multiple voices.
@@ -219,8 +221,7 @@ class TTSService:
         Returns:
             Name of combined voice
         """
-        await self.ensure_initialized()
-        return await self.voice_manager.combine_voices(voices)
+        return await self._voice_manager.combine_voices(voices)
 
     async def list_voices(self) -> List[str]:
         """List available voices.
@@ -228,7 +229,7 @@ class TTSService:
         Returns:
             List of voice names
         """
-        return await self.voice_manager.list_voices()
+        return await self._voice_manager.list_voices()
 
     def _audio_to_bytes(self, audio: np.ndarray) -> bytes:
         """Convert audio to WAV bytes.
diff --git a/api/src/services/warmup.py b/api/src/services/warmup.py
deleted file mode 100644
index 3a50000..0000000
--- a/api/src/services/warmup.py
+++ /dev/null
@@ -1,60 +0,0 @@
-import os
-from typing import List, Tuple
-
-import torch
-from loguru import logger
-
-from ..core.config import settings
-from .tts_model import TTSModel
-from .tts_service import TTSService
-
-
-class WarmupService:
-    """Service for warming up TTS models and voice caches"""
-
-    def __init__(self):
-        """Initialize warmup service and ensure model is ready"""
-        # Initialize model if not already initialized
-        if TTSModel._instance is None:
-            TTSModel.initialize(settings.model_dir)
-        self.tts_service = TTSService()
-
-    def load_voices(self) -> List[Tuple[str, torch.Tensor]]:
-        """Load and cache voices up to LRU limit"""
-        # Get all voices sorted by filename length (shorter names first, usually base voices)
-        voice_files = sorted(
-            [f for f in os.listdir(TTSModel.VOICES_DIR) if f.endswith(".pt")], key=len
-        )
-
-        n_voices_cache = 1
-        loaded_voices = []
-        for voice_file in voice_files[:n_voices_cache]:
-            try:
-                voice_path = os.path.join(TTSModel.VOICES_DIR, voice_file)
-                # load using service, lru cache
-                voicepack = self.tts_service._load_voice(voice_path)
-                loaded_voices.append(
-                    (voice_file[:-3], voicepack)
-                )  # Store name and tensor
-                # voicepack = torch.load(voice_path, map_location=TTSModel.get_device(), weights_only=True)
-                # logger.info(f"Loaded voice {voice_file[:-3]} into cache")
-            except Exception as e:
-                logger.error(f"Failed to load voice {voice_file}: {e}")
-        logger.info(f"Pre-loaded {len(loaded_voices)} voices into cache")
-        return loaded_voices
-
-    async def warmup_voices(
-        self, warmup_text: str, loaded_voices: List[Tuple[str, torch.Tensor]]
-    ):
-        """Warm up voice inference and streaming"""
-        n_warmups = 1
-        for voice_name, _ in loaded_voices[:n_warmups]:
-            try:
-                logger.info(f"Running warmup inference on voice {voice_name}")
-                async for _ in self.tts_service.generate_audio_stream(
-                    warmup_text, voice_name, 1.0, "pcm"
-                ):
-                    pass  # Process all chunks to properly warm up
-                logger.info(f"Completed warmup for voice {voice_name}")
-            except Exception as e:
-                logger.warning(f"Warmup failed for voice {voice_name}: {e}")
diff --git a/docker/gpu/docker-compose.yml b/docker/gpu/docker-compose.yml
index 458eff9..f27e15b 100644
--- a/docker/gpu/docker-compose.yml
+++ b/docker/gpu/docker-compose.yml
@@ -10,7 +10,7 @@ services:
     ports:
       - "8880:8880"
     environment:
-      - PYTHONPATH=/app
+      - PYTHONPATH=/app:/app/api
       - USE_GPU=true
       - USE_ONNX=false
       - PYTHONUNBUFFERED=1
diff --git a/examples/openai_streaming_audio.py b/examples/openai_streaming_audio.py
index 35ef58f..353ee3d 100644
--- a/examples/openai_streaming_audio.py
+++ b/examples/openai_streaming_audio.py
@@ -25,9 +25,7 @@ def main() -> None:
 def stream_to_speakers() -> None:
     import pyaudio
 
-    player_stream = pyaudio.PyAudio().open(
-        format=pyaudio.paInt16, channels=1, rate=24000, output=True
-    )
+    player_stream = pyaudio.PyAudio().open(format=pyaudio.paInt16, channels=1, rate=24000, output=True)
 
     start_time = time.time()
 
diff --git a/examples/simul_file_test.py b/examples/simul_file_test.py
new file mode 100644
index 0000000..c1f14a0
--- /dev/null
+++ b/examples/simul_file_test.py
@@ -0,0 +1,53 @@
+#!/usr/bin/env rye run python
+import asyncio
+import time
+from pathlib import Path
+from openai import AsyncOpenAI
+
+# Initialize async client
+openai = AsyncOpenAI(base_url="http://localhost:8880/v1", api_key="not-needed-for-local")
+
+async def save_to_file(text: str, file_id: int) -> None:
+    """Save TTS output to file asynchronously"""
+    speech_file_path = Path(__file__).parent / f"speech_{file_id}.mp3"
+    
+    start_time = time.time()
+    print(f"Starting file {file_id}")
+    
+    try:
+        # Use streaming endpoint with mp3 format
+        async with openai.audio.speech.with_streaming_response.create(
+            model="kokoro",
+            voice="af_bella",
+            input=text,
+            response_format="mp3"
+        ) as response:
+            print(f"File {file_id} - Time to first byte: {int((time.time() - start_time) * 1000)}ms")
+            
+            # Open file in binary write mode
+            with open(speech_file_path, 'wb') as f:
+                async for chunk in response.iter_bytes():
+                    f.write(chunk)
+            
+            print(f"File {file_id} completed in {int((time.time() - start_time) * 1000)}ms")
+    except Exception as e:
+        print(f"Error processing file {file_id}: {e}")
+
+async def main() -> None:
+    # Different text samples for variety
+    texts = [
+        "The quick brown fox jumped over the lazy dogs. I see skies of blue and clouds of white",
+        "I see skies of blue and clouds of white. I see skies of blue and clouds of white",
+    ]
+    
+    # Create tasks for saving to files
+    file_tasks = [
+        save_to_file(text, i) 
+        for i, text in enumerate(texts)
+    ]
+    
+    # Run file tasks concurrently
+    await asyncio.gather(*file_tasks)
+
+if __name__ == "__main__":
+    asyncio.run(main())
\ No newline at end of file
diff --git a/examples/simul_openai_streaming_audio.py b/examples/simul_openai_streaming_audio.py
new file mode 100644
index 0000000..befae01
--- /dev/null
+++ b/examples/simul_openai_streaming_audio.py
@@ -0,0 +1,91 @@
+#!/usr/bin/env rye run python
+import asyncio
+import time
+from pathlib import Path
+import pyaudio
+from openai import AsyncOpenAI
+
+# Initialize async client
+openai = AsyncOpenAI(base_url="http://localhost:8880/v1", api_key="not-needed-for-local")
+
+# Create a shared PyAudio instance
+p = pyaudio.PyAudio()
+
+async def stream_to_speakers(text: str, stream_id: int) -> None:
+    """Stream TTS audio to speakers asynchronously"""
+    player_stream = p.open(
+        format=pyaudio.paInt16,
+        channels=1,
+        rate=24000,
+        output=True
+    )
+
+    start_time = time.time()
+    print(f"Starting stream {stream_id}")
+
+    try:
+        async with openai.audio.speech.with_streaming_response.create(
+            model="kokoro",
+            voice="af_bella",
+            response_format="pcm",
+            input=text
+        ) as response:
+            print(f"Stream {stream_id} - Time to first byte: {int((time.time() - start_time) * 1000)}ms")
+            
+            async for chunk in response.iter_bytes(chunk_size=1024):
+                player_stream.write(chunk)
+                # Small sleep to allow other coroutines to run
+                await asyncio.sleep(0.001)
+
+        print(f"Stream {stream_id} completed in {int((time.time() - start_time) * 1000)}ms")
+    
+    finally:
+        player_stream.stop_stream()
+        player_stream.close()
+
+async def save_to_file(text: str, file_id: int) -> None:
+    """Save TTS output to file asynchronously"""
+    speech_file_path = Path(__file__).parent / f"speech_{file_id}.mp3"
+    
+    async with openai.audio.speech.with_streaming_response.create(
+        model="kokoro",
+        voice="af_bella",
+        input=text
+    ) as response:
+        # Open file in binary write mode
+        with open(speech_file_path, 'wb') as f:
+            async for chunk in response.iter_bytes():
+                f.write(chunk)
+        print(f"File {file_id} saved to {speech_file_path}")
+
+async def main() -> None:
+    # Different text samples for variety
+    texts = [
+        "The quick brown fox jumped over the lazy dogs. I see skies of blue and clouds of white",
+        "I see skies of blue and clouds of white. I see skies of blue and clouds of white",
+    ]
+    
+    # Create tasks for streaming to speakers
+    speaker_tasks = [
+        stream_to_speakers(text, i) 
+        for i, text in enumerate(texts)
+    ]
+    
+    # Create tasks for saving to files
+    file_tasks = [
+        save_to_file(text, i) 
+        for i, text in enumerate(texts)
+    ]
+    
+    # Combine all tasks
+    all_tasks = speaker_tasks + file_tasks
+    
+    # Run all tasks concurrently
+    try:
+        await asyncio.gather(*all_tasks)
+    finally:
+        # Clean up PyAudio
+        p.terminate()
+
+if __name__ == "__main__":
+    asyncio.run(main())
\ No newline at end of file
diff --git a/examples/simul_speaker_test.py b/examples/simul_speaker_test.py
new file mode 100644
index 0000000..d2e4354
--- /dev/null
+++ b/examples/simul_speaker_test.py
@@ -0,0 +1,66 @@
+#!/usr/bin/env rye run python
+import asyncio
+import time
+import pyaudio
+from openai import AsyncOpenAI
+
+# Initialize async client
+openai = AsyncOpenAI(base_url="http://localhost:8880/v1", api_key="not-needed-for-local")
+
+# Create a shared PyAudio instance
+p = pyaudio.PyAudio()
+
+async def stream_to_speakers(text: str, stream_id: int) -> None:
+    """Stream TTS audio to speakers asynchronously"""
+    player_stream = p.open(
+        format=pyaudio.paInt16,
+        channels=1,
+        rate=24000,
+        output=True
+    )
+
+    start_time = time.time()
+    print(f"Starting stream {stream_id}")
+
+    try:
+        async with openai.audio.speech.with_streaming_response.create(
+            model="kokoro",
+            voice="af_bella",
+            response_format="pcm",
+            input=text
+        ) as response:
+            print(f"Stream {stream_id} - Time to first byte: {int((time.time() - start_time) * 1000)}ms")
+            
+            async for chunk in response.iter_bytes(chunk_size=1024):
+                player_stream.write(chunk)
+                # Small sleep to allow other coroutines to run
+                await asyncio.sleep(0.001)
+
+        print(f"Stream {stream_id} completed in {int((time.time() - start_time) * 1000)}ms")
+    
+    finally:
+        player_stream.stop_stream()
+        player_stream.close()
+
+async def main() -> None:
+    # Different text samples for variety
+    texts = [
+        "The quick brown fox jumped over the lazy dogs. I see skies of blue and clouds of white",
+        "I see skies of blue and clouds of white. I see skies of blue and clouds of white",
+    ]
+    
+    # Create tasks for streaming to speakers
+    speaker_tasks = [
+        stream_to_speakers(text, i) 
+        for i, text in enumerate(texts)
+    ]
+    
+    # Run speaker tasks concurrently
+    try:
+        await asyncio.gather(*speaker_tasks)
+    finally:
+        # Clean up PyAudio
+        p.terminate()
+
+if __name__ == "__main__":
+    asyncio.run(main())
\ No newline at end of file
diff --git a/examples/speech.mp3 b/examples/speech.mp3
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..be3431b8562f5065dfb4f5f81ff1eae2a4511047 100644
GIT binary patch
literal 73440
zcmeFZc~DbXxA1*3l7tYF5Fmk|Nq`t8JqbYpwL5_j0z?gy0-`2Nf>R@);?Q;`LV$?O
zB#0VD0nuh~Kt(%@GN~ZWtu~X0V>`FqZR@Act$V+!@BQa{{=9EJ`&25YDm#^R*00uD
zd#|;2zPz331^#;kZA<#$>%HaImmYx3n*d-)l(_|-Xl-jprO}<4u5OD!u9uJRcYJ@L
zC}f2sEOJdutW=hmv}yAXsTn(V@7b?VX|#C<3W`e0D=Ljub@ffhe{MN-`rP?TT|NB+
z!&gSH-@JYA{>0>?*{9EbfA#MDpMQP+`dczFe?@@jLN*9OGXGl?lF<puV*r5hn;h<!
zKdArvga5q$TN?QCUwmPrZ{PYKJxBiEGyZRUrhkLZfB60z%KBe8^*?<77ef0tME(!o
ze?wXS3#a~v@Bcz*|Axr_;rnkW>wn?Y|M2}^2<_hx`Tu&poHTz|M^8e}LOQ2i<rlf+
zreo(4$Yaf)M`cx0?Ujy-+E)EkDx#w*A)D#sE?fBP`FRLHO=S8}b)t{nCR7xS)=)U6
z0iw&{UZmh0LDew?svD($rO~pMwxmGbLKvoK*!RrZ&2hz|-^}hT>Ux772|ePCf?iQT
z2^vEXsjjKFRZ@wiUZG84k5qrB_~<}a*3Mg&LU^jZXtiwl+ZNT<bhP4T_cKaRC7sZ+
za>6k25;mWS_cqQ2UNX~Lf|I0C7SVeGwdbJ7f`N)+e9D7wD0%@=AOv1>K~vM&sTA++
z%C0Ku=(GSmkDFPDcpH&#KlkKJAR?pr(XwxRzwGGr!2%E4N^aa!g>N$dQ&N@u>d~C&
z^p+^EQy10{udTzrFm2l+OFLHN?R${;I^3y`2YQEY%xbVP`n>A0TDQmTy)^!5ssLc6
zN(EI~6C8?UvB!@0czUTh*Dy}rdW55>AhT-@sfST-(JphzGM9<#a&d7)K&Zeeq!=&2
zw^WCihb_PJr<83GCWgWpMJNWG#!z9p18OJ3f|}%$jKB)Jf*3h>mWDEqU)2nM)mFDS
zvS~$8fFXDX0lF+29I(q0g{?Ps`Ip(1tlj>5*F8JB9*XkkDU*-avpiYvcmmW)%3;^|
z8&y|a13NK0Pc!}YZ9H~4S{?dvOX~vM%gwWs&?IJ998FW-wsCrPaadv;1FBRVN;a~F
z$mhC6<YxyLuSXXG0e>z|v<2^WzSx4@t;sn*Kyuu!cEAAwdV^%>u{~`x-(5ay2j;~=
zw+yw2!+#04jz1^8F#9ptoW{DJjACKl`um%VK{foJL3C2n#Ku01x2w0N3JKTtbqctb
z5QGe%s)b7<VuHpSj4b%Epc=ZrNUG`$v=2Z<E*^}UAc|CL0KtLUJm0O|$iwy{ZNtr*
zoN!w(Ip=d+&8$!sf>fz?YO9D)RqXSd&&ibhZ+!pWjrFMoX5WAq10{$=#?b5xXOf=;
z!Zj^e<2j4Owc?vWMI0iGrO$gk@8$uI;r%RrLtI4N_5z+MDKnWBBk)xn3{#uKY^EU?
zpSA8|wMv_1mM%L+kq{ECcwHf_SYbUn7Y|%?(15Mt?ZeNL@a?23{EEmxgZsVZ23DD9
zs^uX}$8!f|im(;dE7&)qBvw0K*XUZqn~4~I3e0^#cJ$oPw$IRL@0-@-tAuuEqc?Q8
z=5?i!M|18)Skk0LRJ-+L0Rb9UR<eQ%wM$umHky3Ya0=q<)koKQzuV$kven53e$CnK
z-aie>?nurKNfgSqb~0GJ$Nlre6<0IzVn@SQjDc1d>62r`!e60g-doq`^jsl1W)GE-
z#O~PRACYjaVsXz%p+73YE@v+})QPs)=B6L7w>Pfq8kXEXj~hWhs5EGzs^l1iT~Sh$
z$*;?SQh-_wsAa5-(Uz)d*bvewM<a7<!E{x#bt%48Ys9Ji{DubC*D|s6veUj5Yl1Yw
zZpS<pK1i3-BG0P6s{_`iqKt8YDzhX{@7Qp!-efZ&gWpV+90X+NF&Pmp4m0j#2*u1=
zI~Mxl%90Wu$}aMaBIn&ekcMCE6j5vq@A<~}NhZ~&<*WT>ra{exTbQ^L<+Y*EnN=`^
z-KU&(cQ1h5&mhoLcvn1x77e-};QGtC`Sf|q67nHnN&plr=j8dxwyF?|g3^#d;@U+4
zRSRwz*l|S7W{%L)QWWtN0_bb<u*H7s3s}aDD&Lh;+F=fKK<<nM2R)t`_drZyidB8u
zUiyQ)JhD5>XE$q5JkZ2GiFakp(IG!xA^DNaZ7}ZE{^z6Lk#T?}c^%;5Sj9^B3GOM7
z(6+Gz@ia;Z#qH#~J!VV`cj2%^5N-iT5&W1;(nPNfoXC44KC$ltovA#sV)jPVqmTNh
zy3k!K%3!gOG@8Zy0ly8o<`JqzzRSzw7a`g2TZVgnp5(S0b9+3@xTmN6qPc!nelqZV
zG1|v`@n)e|5eF2Go`hilHfmzr&KanWh}(;j7)*k`z=P%g9EK{$?ar5Ws@yO|;7T#t
zIOC)_5CpcgM)sRr=@tI<`(7VI#a}0LyLKcwNr1)!3q1zNa-rlZffJ97PQ`~(cj&0V
z!)RuHY7WHOXN_%bulwTwud8~)>sy0LdY{~D+@>ntBq*2Pjeu7_g#!zp<ON6Ss?o-M
zj*yy`o<$K5jE6-o9LmDzrMadQn{Rx7&Aji^!FkwLnHYv((Um}#*u#pJ;R1&EfAAxu
zv{btI6l$+Iz?750Bkcl%z}o?1F-AmzffD>vs-HPGoO4KUmK-;ZjSOe=S*#f{pl@r~
zVqKsh9b4EaJ;Sqg_)c+`Vpev-oQQ(oaM{hmN7yF2O3ud71*b!ILi1fQ6@y2Hc>F4q
z>?t;`Ab?en&`-?Gdh$V`tU(d5JTM@?+}}UHz}-b6E4Yq#kNcY}idGWVHs$`}_MA+x
zN~W)pZVzaKEcQ;W%6h?x3|+DvmiIEk0?gY&-kmW*Lx#ata~an{UP;6jJ3XXBw?x`j
za(51ZiJ;ZpXu(8HxcFNfYXyQo$urzS-l<mdQKv1XHl9nfYDx$`#Bp@*cm67A*ixFb
zb?+!)WgK!=q}#?~+KFG0(XJ3bB!rj5{7yP08?KMFOPD~C0Q|D}crg|;PX;q}ow`Mi
zrFL+IevYY$JrG{DZZleAvut|VTY+HgRBMyGMd)%_s+uFa9W~E7i1#M(Ojy@KwM#WL
z)P7@AT5>PlK96FwXXa27-CGqTF<Q9nN$#HaT*(SgYT6q->3SdkhaOlkPx=VRMv{#Y
zYJ=Ir${fG2E_oMMqh$!Ko_*sxl%C<!;rehpl~4{v2EewoobwR>_FY8MsCz@hWE}pG
zxodtbJG6_@{z`J<#vt{=WJ;HFt&2LSDCPWl^TIvcF=^55^2|<D5K7|gJQ0>Pf^%!T
zcDcYoeagdR>?+2z-r&1=xK|uUtUj*`T-o<>1KXM5x}|oiwDm^Mq8NNO7Zs_uaM3{-
zFn#3S*{{N#U2;X!Q~`;HJ}|7RI{Y0@K_UqGFx%vdLo@Kx6&Hw|y_0^G>*qx{4;9rK
z`&4G9*H=p;QblA43M;Det64a;t>tYzQ5WsHC3jWKi?Du;v(vqVx-7%EM<AX@I(<$B
zwS=m|4g#muems!nx=j(3>E(q^$n7B^Am(o4ZV~ni*hLe;kkVsh4ZnwI@clSJmo?z)
zHy&V8>%|r1>Xi6?Dq};qm7|?Gi-0L6kD4U9UjAK_v_J>*p4xFa2+wQ@z8mQxg5sT8
z3zrpUvF+}&2pXQ5m8{mqvlt}<m?Wp%3X~$o97$`o?%H$pz9Nc(tJQX)GB=7q^3y5C
zikl$=aW)qVaNDp)l>#juk{e4@X04RW-13zA2hn(aU1GmirTMw-L6y#il(LS-kbV7Q
zPw|YH(x!yY^_*AasZwKeUHvz{*S7cibaEc1eoAVjop6c$Ve>l7>C+2Eu82-z*b6I`
zxrU({a2hMumZ7ZdX}f0`(e#vkg%f8dHUUWqdyk4qfa@FvfY5W9KVZfe<Eeq2zIBm>
z?j*))CeIt{c&K8_`Kx9QC$a=tLIm7t;6s$E?*hSk=kZhurWX=qeE`a_PGd5@uAKP8
z=h4BL?x@Vsm*p!%L+cKEk`2L+zO%X|tNQ-Y(RtD*{1fvqO7C1lHOo)tct`sb{*W1C
zXurX1IX&aO;}sZ?g1=I7)-zQ(VMfL~D}xvhhJ?bko^ep5_u@^5EuUfmTtgR^k(OA#
z6L1_@o}wYy$1U6h=`z`ezh|>)(;P7ZX=k3&SxDY3*MHo8hk_a$N1(d=`-_58oP|_8
zM#NmYqz{?r4lS--5z5w+`glEyQKm^~kj_ChC@D&UWN2e8Og?UM{0L2e=GQKwTEiu<
zJ7)x%_SEf9jyP0!+50)5<!q1Ckm|9aXw<r_R9u2Eb5szWXNQu~;*30Zh;jiXLj9dx
zf{^9kg@DEKRYXp5cA4496jsv7d4!Yq(8JvO60FI*V{L&EMc$}`Mz5hvAHbFOKcI~V
zyFtL@uVtc5tyN<rcrqvnmj25>r^kNd%V{p|nyOMA<=xH+<YHo9npk7@wa)sCbI)25
zb_y<u9Ro{U%i^4ZcM}{}8a4vh_0JNpjLvmTV7QYvCwq?N0X$J|3<&hxIlfumjSiJg
z^)wnb_CW=Y(bF-_plMwS6ZDdvGaWN$ue%)M!EGu@C>bNTcR7twxB-FrHR&ID?ns<V
zHY2m8?FPdEMe^rC*83WR+uEs2=~V+gf+sQ-@DTP0eIVWax<%;%yb&sZ_L#xF?XO=(
z=!8z^7ePmPdlq<3`sH;XY3F}#YSF-Dm}L{>QQpMN&>{}5&51)p5ffB_dOjMCppw}B
zLzn>(Do+QfS-hmA{zjW^2WKyK9ov!|uJ6_S5LA1K-g_g;s@j8E3Atb|a|DKv!CTd`
zqP1tX<WI!mnKbM|;~er;Ju8V0R8eF_tXN4`8238Q+9-g{R*l^AF7r1QJH4$78`bQD
zO!O`1Vd3V>@}#eGRqC*&$0DadE9%DcNNrZ}AuApXR*=k(6p~V;&j*_ECYe3biiTm~
z2~A-e%2I08cGhswq~LJ6`>7uxaCLtnZDEI`81RyjygTY7iWOeFB%KgNb_5!2NxJD8
z_L0r)2`B;{RcC+WJCP3e>Eu3ab6U`YUN;A3*Jd9OO=JalD1ML|3B<L|m!2Co>G#<A
z87uE^ov$TqM)EfG$KxE5`Le<CzCyGBN)7Jar|dJrbK`6Zs<VBoq+^Ed*>nqA4`g4k
zL<(in25|6$_5?XrYS$Pw=C!B18#1gN9eeG-ThV|wPV$I1Og<KOdWh@#=2#wJ$&>jK
zT^9np5yejSSTtX-v^E!Z$8LjxUX<$!*~@dv#X^^dY&~6GNrOItq1Qt>aEP7{I}pkr
zJ2W~WI%p$Aih3U|+OsrZyz4z|-iB9cc>+n~`N6dX>{Iq&fa1RJb&6Y-gJ&|(^N2tx
zxz_zwY{^Te*&0q;9x|TmJVPbo&+fivAcqZR+g7*o{`BPQ-R#&YhmYxLt$(M5k#&Xp
z%>j#ZN^%5u%i@CQnrMKyq=}tvMp|hv0!N)A%X1O{_$43!>$##uH-t%m>Yea~&#-Ey
zB*j%)gmoWszb2-oM?e_bVBs{Y#u@Iw2z^Nu#Y{jO|FT^dC@vN|#$5j`Xe!R$*U6>B
zXp-7E%m&p!7^{J5+mYto)mLkMgUULiS}BC<jFIlqPSPQ&xho}R&B>O~lLRYBmJ$Z!
zGq~~^FL*yU%=R1K$2${zPJP=Sk)ykx>I<Clls6s)_++BEsscl}TJ!OAot+BF2Hdw5
z(Bw+>f@($qk&NFc9B}JAn-txI8&X0M^Q5F(e)V=USt5v2jdQC7IoWAR;#?D#MrS9Q
zbMaNA_{$BO&Zu|@>>2Y<iY-`0#(S_Uq%~0rVM5h)B3VBj^=bXPMvtKe+aUU&0)d3U
zGu~X2V-|s9?j9Pb#+=Jt`nf5$pG(*3$&5xvnm1!5%+fC6;)+oTL;=w0KF0E9VPR1k
zv3MdRa^s@8?yYYGw(^B2r|UPI-{i7>^^#3Wc>N7{xfLl@B2(spm;@jF9r<}z12NS9
zd)s+K97a1T*qb_?jpKsT3^x#@oxiKs5Q`PM@K-25Bsn<l02Pyw^JBsNfzjaD8DfQQ
z;~vz6Q?IrCQe2!t1DuhM!{Il|7<RO<lBnkHCBD-=!5UO-!bC=(Q{JG-`?WSTI-?CN
za@tbOXnM?uH(4Z0p4Vbs1$ueb<sbq&j<3^TGJC1-uy@@_#>S~e0yggaHK--H%2S?D
z-x}Xk?oK2-O`H>i*A_tls4eTe^a!-cTsZ)Z3x4%7`;s~5i2M5;#Rx|TQG^<%(V)hq
zDV-?Nf7x$@PbcXi=hT@VA%c&@h&`lJLCQ^*Q-U1#^-{CkZH~1!;M&kJfs6g``PVn%
z*Vb;fGvK6&Sh@*8*o0Aw3i`!UMXW9-*C)I0>EJV*ZYZqQMva2aDUJOKGb5D;J*!d#
zsy{Jlz4XKR$QtcJ6BLK%$b#2Sa5kaV3Xz8)FalPM7;1?H<XILH8mn(gln`y^2d6E>
z=xn02{K&Pf`-M4~0X!rIg*w+vcMXGp!E(wJVsd4D%(~O}yGAS422wKU9^C!|U-t#^
z$Q~U5PBV@Z{e9xF5DOAwKb?kkb)(1>ZJd>2uaW3cMU#z~&NInYKyJ*SuOz<ewiA}~
zLgaOhKAA`xeIsA3LiLVlGkW=uIwh?z)X~8_2s*fIxS2$hrwurF{nX{cVLZuU9c)C#
zOiI`HU>P43Xc#rV!~)R&X}5|IZu!G4;8!e*m}=X%q~H$iy_V)&l3S0Cy^Ch5%sHAx
zb4_uez{m}anI2aJvB*JCqF*mGh=|<|+cAz$pUY4oQpK%0AXI{(Eig~25Edr}hhxdU
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
P`oDbt8$$axZu$QJ+4lEo

literal 0
HcmV?d00001