Upload 8 files

adapter_layer.py

@@ -1,16 +1,15 @@
 import os
 import sys
 import json
-import nltk
-import torch
-import inspect
 import logging
 import pydantic              # required
-import codecarbon    
 import importlib.util        # required
 from typing import Dict, Any, Optional, List, Tuple
 from service_registry import registry, MODEL, PRETRAINED_MODEL, TOKENIZER
 
+# Force low memory usage mode
+os.environ["LOW_MEMORY_MODE"] = "1"
+
 # Log versions and fail fast if missing
 logger = logging.getLogger(__name__)
 logger.info(f"Using pydantic v{pydantic.__version__}")
@@ -18,6 +17,18 @@ logger.info(f"Using codecarbon v{codecarbon.__version__}")
 
 print(f"Successfully using installed dependencies - pydantic: {pydantic.__version__}, codecarbon: {codecarbon.__version__}")
 
+# MEMORY OPTIMIZATION: Show current memory usage
+def log_memory_usage():
+    try:
+        import psutil
+        process = psutil.Process(os.getpid())
+        memory_info = process.memory_info()
+        memory_mb = memory_info.rss / 1024 / 1024
+        logger.info(f"Current memory usage: {memory_mb:.2f} MB")
+        return memory_mb
+    except:
+        return 0
+
 # Import dependency helpers
 def is_module_available(module_name):
     try:
@@ -49,299 +60,209 @@ except ImportError as e:
                     return "model_Custm", 0.8
             return "model_PrTr", 0.6
 
+# MEMORY OPTIMIZATION: Create basic PromptAnalyzer without loading models
+class BasicPromptAnalyzer:
+    def __init__(self, **kwargs):
+        self.logger = logging.getLogger(__name__)
+        self.predefined_topics = {
+            "programming": ["python", "java", "code"],
+            "general": ["weather", "hello", "chat"]
+        }
+    
+    def analyze_prompt(self, prompt: str):
+        # Simple keyword-based routing
+        prompt_lower = prompt.lower()
+        for tech_word in self.predefined_topics.get("programming", []):
+            if tech_word in prompt_lower:
+                return "model_Custm", 0.8
+        return "model_PrTr", 0.6
+
 class WildnerveModelAdapter:
-    """Adapter layer that interfaces between HF inference endpoints and the model."""
-    RETRY_COUNT = 5
+    """Ultra-lightweight adapter layer for HF inference endpoints."""
 
     def __init__(self, model_path: str):
         self.model_path = model_path
         self.tokenizer = None
         self.model = None
-        self.initialized = False
+        self.model_loaded = False
+        logger.info(f"Creating adapter with path: {model_path}")
         
-        # ensure model directory and repo root are first on import path
-        root = os.getcwd()
-        paths = []
-        if os.path.isdir(model_path):
-            paths.append(model_path)
-        else:
-            logger.warning(f"Model path not found or not a directory: {model_path}")
-        paths.append(root)
-        for p in paths:
-            if p not in sys.path:
-                sys.path.insert(0, p)
-            
-        logger.info(f"Model adapter initialized with path: {model_path}")
-
-        # Initialize components with retry logic
-        for attempt in range(1, self.RETRY_COUNT + 1):
-            try:
-                self._initialize_tokenizer()
-                logger.info("Tokenizer initialized")
-                break
-            except Exception as e:
-                logger.warning(f"Tokenizer init attempt {attempt}/{self.RETRY_COUNT} failed: {e}")
-                logger.debug("Tokenizer init stack trace:", exc_info=True)
-                if attempt == self.RETRY_COUNT:
-                    raise
-
-        for attempt in range(1, self.RETRY_COUNT + 1):
-            try:
-                self._initialize_model()
-                logger.info("Model initialized")
-                break
-            except Exception as e:
-                logger.warning(f"Model init attempt {attempt}/{self.RETRY_COUNT} failed: {e}")
-                logger.debug("Model init stack trace:", exc_info=True)
-                if attempt == self.RETRY_COUNT:
-                    raise
-    def _initialize_tokenizer(self):
-        """Initialize tokenizer via our local wrapper first, then fallback."""
-        try:
-            # primary: use our tokenizer.py
-            from tokenizer import TokenizerWrapper
-            self.tokenizer = TokenizerWrapper()
-            logger.info("Using TokenizerWrapper from tokenizer.py")
-            return
-        except Exception as e:
-            logger.warning(f"TokenizerWrapper init failed: {e}")
-
-        # Try to import from service_registry if available
-        try:
-            if is_module_available('service_registry'):
-                from service_registry import registry, TOKENIZER
-                
-                if registry.has(TOKENIZER):
-                    self.tokenizer = registry.get(TOKENIZER)
-                    logger.info("Retrieved tokenizer from registry")
-                    return
-                    
-            # Try loading from the original tokenizer.py
-            if is_module_available('tokenizer'):
-                from tokenizer import TokenizerWrapper, get_tokenizer
-                self.tokenizer = get_tokenizer()
-                logger.info("Created TokenizerWrapper instance")
-                return
-                
-        except Exception as e:
-            logger.warning(f"Error initializing original tokenizer: {e}")
+        # Safe verification of model file existence
+        self._verify_model_files()
         
-        # Final fallback: use your get_tokenizer wrapper
-        try:
-            from tokenizer import get_tokenizer
-            self.tokenizer = get_tokenizer()
-            logger.info("Using get_tokenizer() fallback")
-            return
-        except Exception as e:
-            logger.error(f"No tokenizer could be initialized: {e}")
-            raise ImportError("Tokenizer initialization failed")
-    
-    def _initialize_model(self):
-        """Initialize the model from service registry or create it directly."""
-        max_attempts = 5
-        attempt = 0
+    def _verify_model_files(self):
+        """Verify model files exist without loading them"""
+        script_dir = os.path.dirname(os.path.abspath(__file__))
+        model_files = ["model_Custm.py", "model_PrTr.py"]
         
-        while attempt < max_attempts:
-            attempt += 1
-            try:
-                # Ensure there's a model in the registry
-                from service_registry import registry, MODEL, ensure_models_registered
-                ensure_models_registered()  # This will load model_Custm if needed
-                
-                if registry.has(MODEL):
-                    self.model = registry.get(MODEL)
-                    logger.info(f"Successfully loaded model from service registry")
-                    
-                    # Ensure the model has the specializations loaded
-                    if hasattr(self.model, "load_specializations"):
-                        try:
-                            self.model.load_specializations()
-                            logger.info(f"Loaded specializations for model")
-                        except Exception as e:
-                            logger.warning(f"Error loading specializations: {e}")
-                    
-                    return
-                    
-                # Fall back to creating the model directly
-                logger.warning("No model in registry, creating model_Custm directly")
-                from model_Custm import Wildnerve_tlm01
-                self.model = Wildnerve_tlm01(
-                    vocab_size=30522,
-                    specialization="general",
-                    dataset_path=None,
-                    model_name="bert-base-uncased",
-                    embedding_dim=768,
-                    num_heads=12,
-                    hidden_dim=768,
-                    num_layers=2,
-                    output_size=768,
-                    dropout=0.1,
-                    max_seq_length=128,
-                    pooling_mode="mean",
-                    tokenizer=self.tokenizer
-                )
-                logger.info("Successfully created model_Custm directly")
-                return
-                
-            except Exception as e:
-                logger.warning(f"Error on model init attempt {attempt}/{max_attempts}: {e}")
+        self.available_models = {}
+        for filename in model_files:
+            filepath = os.path.join(script_dir, filename)
+            if os.path.exists(filepath):
+                module_name = filename.replace('.py', '')
+                self.available_models[module_name] = filepath
+                logger.info(f"Found model file: {filename}")
+        
+        if not self.available_models:
+            logger.warning("No model files found - will use stub implementation")
+            # Create stub file if needed
+            stub_path = os.path.join(script_dir, "model_stub.py")
+            if not os.path.exists(stub_path):
+                try:
+                    with open(stub_path, "w") as f:
+                        f.write("""
+# Minimal stub model
+import torch.nn as nn
+class Wildnerve_tlm01(nn.Module):
+    def __init__(self, **kwargs):
+        super().__init__()
+        self.is_stub = True
+        for key, value in kwargs.items():
+            setattr(self, key, value)
+    def generate(self, prompt=None, **kwargs):
+        return f"Stub model response for: {prompt[:30]}..."
+""")
+                    logger.info("Created stub model file")
+                except Exception as e:
+                    logger.error(f"Failed to create stub model: {e}")
+        
+    def generate(self, text_input, max_length=None, **kwargs):
+        """Generate text - with lazy model loading"""
+        try:
+            # Try to load model on first use
+            if not self.model_loaded:
+                self._lazy_load_model()
+            
+            # If we have a model now, use it
+            if self.model:
+                try:
+                    logger.info(f"Generating with model: {type(self.model).__name__}")
+                    return self.model.generate(
+                        prompt=text_input, 
+                        max_length=max_length,
+                        **kwargs
+                    )
+                except Exception as e:
+                    logger.error(f"Model generation error: {e}")
+                    # Try tokenizer-only response as fallback
+            
+            # If we have a tokenizer but no model, use simple responses
+            if self.tokenizer and not self.model:
+                # Try to get a slightly better response with tokenizer
+                tokenized = self.tokenizer(text_input, return_tensors="pt", truncation=True)
+                return f"Processing: {text_input[:50]}..."
                 
-            # Wait briefly before next attempt
-            import time
-            time.sleep(1)
+            # If no model or tokenizer, return simple response
+            return f"I've received your input about '{text_input[:30]}...'"
             
-        # All attempts failed
-        raise ImportError("No model registered in service registry")
-
-        # When storing models/objects, make sure we don't create circular references
-        if registry.has(MODEL):
-            self.model = registry.get(MODEL)
-            # Don't add back-references to registry or other objects that might 
-            # include this adapter, to avoid circular references
-
-    def _build_init_kwargs(self):
-        return {
-            "vocab_size": 30522,
-            "specialization": "general",
-            "dataset_path": None,
-            "model_name": "bert-base-uncased",
-            "embedding_dim": 768,
-            "num_heads": 12,
-            "hidden_dim": 768,
-            "num_layers": 6,
-            "output_size": 768,
-            "dropout": 0.1,
-            "max_seq_length": 512,
-            "pooling_mode": "mean",
-            "tokenizer": self.tokenizer
-        }
-    
-    def _split_prompt(self, prompt: str) -> Tuple[str, str]:
-        """Return (technical_sentences, general_sentences)."""
-        # download punkt if needed
-        try:
-            nltk.data.find("tokenizers/punkt")
-        except LookupError:
-            nltk.download("punkt")
-
-        sents = nltk.sent_tokenize(prompt)
-        analyzer = PromptAnalyzer()
-        tech_keys = set(analyzer.predefined_topics.get("programming", []))
-        tech_list, gen_list = [], []
-        for s in sents:
-            # simple keyword check
-            if any(k in s.lower() for k in tech_keys):
-                tech_list.append(s)
-            else:
-                gen_list.append(s)
-        return " ".join(tech_list).strip(), " ".join(gen_list).strip()
+        except Exception as e:
+            logger.error(f"Error in generate method: {e}")
+            return f"An error occurred processing your request: {str(e)}"
 
-    def generate(self, text_input, max_length=None, **kwargs):
-        """Generate text using the model - centralized generation point"""
+    def _lazy_load_model(self):
+        """Try to load a model on demand, with multiple fallback options"""
         try:
-            # Use PromptAnalyzer to determine which model to use
-            try:
-                from model_List import PromptAnalyzer
-                analyzer = PromptAnalyzer()
-                model_type, confidence = analyzer.analyze_prompt(text_input)
-                logger.info(f"PromptAnalyzer selected {model_type} with confidence {confidence:.2f}")
-            except Exception as e:
-                logger.error(f"Error using PromptAnalyzer: {e}")
-                model_type = "model_Custm"  # Default to custom model on error
-                
-            # Enhanced generation parameters with strong repetition prevention
-            generation_kwargs = {
-                'max_length': max_length or 150,
-                'temperature': kwargs.get('temperature', 0.7),
-                'top_p': kwargs.get('top_p', 0.95),
-                'top_k': kwargs.get('top_k', 50),
-                'repetition_penalty': kwargs.get('repetition_penalty', 1.3),  # Increased from 1.2
-                'no_repeat_ngram_size': kwargs.get('no_repeat_ngram_size', 3),  # Increased from 2
-                'do_sample': kwargs.get('do_sample', True),
-                'num_return_sequences': kwargs.get('num_return_sequences', 1),
-                'early_stopping': kwargs.get('early_stopping', True),
-                'bad_words_ids': kwargs.get('bad_words_ids', None),  # Block repetitive phrases
-                'min_length': kwargs.get('min_length', 10),  # Ensure reasonable response length
-            }
+            logger.info("Attempting to load model on first request")
             
-            # Create penalty_alpha for GPT-2 encoder-decoder attention
-            if 'penalty_alpha' not in kwargs:
-                generation_kwargs['penalty_alpha'] = 0.6  # Helps prevent looping in GPT-2
-                
-            # Override with any explicitly provided kwargs
-            generation_kwargs.update({k:v for k,v in kwargs.items() if k not in ('prompt', 'context')})
+            # First initialize tokenizer if not already done
+            self._initialize_minimal_tokenizer()
             
-            if model_type == "model_Custm":
-                # Use the Custom Wildnerve model for technical topics
-                custom_model = registry.get(MODEL)
-                if custom_model:
-                    try:
-                        logger.info("Using custom Wildnerve-tlm01_Hybrid_Model for technical prompt")
-                        # Check signature of the generate method
-                        import inspect
-                        if hasattr(custom_model, "generate"):
-                            sig = inspect.signature(custom_model.generate)
-                            if "prompt" in sig.parameters:
-                                return custom_model.generate(prompt=text_input, **generation_kwargs)
-                            else:
-                                # If no prompt parameter, try tokenizing first
-                                inputs = self.tokenizer(text_input, return_tensors="pt", truncation=True, padding=True)
-                                return custom_model.generate(input_ids=inputs.input_ids, **generation_kwargs)
-                        else:
-                            logger.warning("Custom model doesn't have generate method, falling back to pretrained")
-                    except Exception as e:
-                        logger.error(f"Error using custom model: {e}")
-            else:
-                # Use the Pretrained model (GPT-2) for general topics
-                pre = registry.get(PRETRAINED_MODEL)
-                if pre:
-                    try:
-                        logger.info("Using GPT-2 pretrained model for general prompt")
-                        # Try to use the pretrained model's generate method
-                        if hasattr(pre, "generate"):
-                            # Check the signature of the generate method to determine correct parameters
-                            import inspect
-                            sig = inspect.signature(pre.generate)
-                            if "prompt" in sig.parameters:
-                                return pre.generate(prompt=text_input, **generation_kwargs)
-                            else:
-                                # If no prompt parameter, try tokenizing first
-                                inputs = self.tokenizer(text_input, return_tensors="pt", truncation=True, padding=True)
-                                return pre.generate(input_ids=inputs.input_ids, **generation_kwargs)  # Explicitly pass as input_ids
-                        else:
-                            logger.warning("Pretrained model doesn't have generate method")
-                    except Exception as e:
-                        logger.error(f"Error using pretrained model: {e}")
+            # Try to load model_Custm first
+            if "model_Custm" in self.available_models:
+                try:
+                    logger.info("Trying to load model_Custm")
+                    model_custm_spec = importlib.util.spec_from_file_location(
+                        "model_Custm", 
+                        self.available_models["model_Custm"]
+                    )
+                    model_custm = importlib.util.module_from_spec(model_custm_spec)
+                    model_custm_spec.loader.exec_module(model_custm)
+                    
+                    if hasattr(model_custm, "Wildnerve_tlm01"):
+                        logger.info("Creating Wildnerve_tlm01 from model_Custm")
+                        model_class = getattr(model_custm, "Wildnerve_tlm01")
+                        self.model = model_class(
+                            tokenizer=self.tokenizer,
+                            vocab_size=50257,  # GPT-2 vocab size
+                            specialization="general",
+                            embedding_dim=768,
+                            num_heads=12,
+                            hidden_dim=768,
+                            num_layers=2,  # Reduced for memory efficiency
+                            output_size=50257,  # Match GPT-2 vocab
+                            dropout=0.1,
+                            max_seq_length=128  # Reduced for memory
+                        )
+                        logger.info("Successfully created custom model")
+                        self.model_loaded = True
+                        return
+                except Exception as e:
+                    logger.error(f"Failed to load model_Custm: {e}")
             
-            # Fall back to using the custom model if needed
-            if self.model:
+            # Try model_PrTr next
+            if "model_PrTr" in self.available_models:
                 try:
-                    logger.info("Using custom model for generation")
+                    logger.info("Trying to load model_PrTr")
+                    model_prtr_spec = importlib.util.spec_from_file_location(
+                        "model_PrTr", 
+                        self.available_models["model_PrTr"]
+                    )
+                    model_prtr = importlib.util.module_from_spec(model_prtr_spec)
+                    model_prtr_spec.loader.exec_module(model_prtr)
                     
-                    # Check if the model is expecting a prompt parameter or input_ids
-                    import inspect
-                    if hasattr(self.model, "generate"):
-                        sig = inspect.signature(self.model.generate)
-                        if "prompt" in sig.parameters:
-                            # Model accepts prompt parameter directly
-                            return self.model.generate(prompt=text_input, **generation_kwargs)  # Explicitly pass as prompt
-                        else:
-                            # Model expects tokenized input_ids instead
-                            logger.info("Model expects tokenized input - converting prompt to input_ids")
-                            inputs = self.tokenizer(text_input, return_tensors="pt", truncation=True, padding=True)
-                            return self.model.generate(input_ids=inputs.input_ids, **generation_kwargs)  # Explicitly pass as input_ids
-                    else:
-                        logger.error("Model has no generate method")
-                        # Simple fallback for models without generate
-                        return f"I'm processing your request about '{text_input[:30]}...'"
+                    if hasattr(model_prtr, "Wildnerve_tlm01"):
+                        logger.info("Creating Wildnerve_tlm01 from model_PrTr")
+                        model_class = getattr(model_prtr, "Wildnerve_tlm01")
+                        self.model = model_class(
+                            tokenizer=self.tokenizer,
+                            model_name="gpt2"
+                        )
+                        logger.info("Successfully created pretrained model")
+                        self.model_loaded = True
+                        return
                 except Exception as e:
-                    logger.error(f"Error using custom model: {e}")
+                    logger.error(f"Failed to load model_PrTr: {e}")
+            
+            # Try stub model as last resort
+            try:
+                logger.info("Trying to load model_stub")
+                script_dir = os.path.dirname(os.path.abspath(__file__))
+                stub_path = os.path.join(script_dir, "model_stub.py")
+                
+                if os.path.exists(stub_path):
+                    stub_spec = importlib.util.spec_from_file_location("model_stub", stub_path)
+                    model_stub = importlib.util.module_from_spec(stub_spec)
+                    stub_spec.loader.exec_module(model_stub)
                     
-                    # Add last-chance fallback with generic response
-                    return f"I apologize, but I'm experiencing some technical difficulties processing your request about '{text_input[:30]}...'. (Error: {str(e)})"
+                    if hasattr(model_stub, "Wildnerve_tlm01"):
+                        logger.info("Creating stub model")
+                        model_class = getattr(model_stub, "Wildnerve_tlm01")
+                        self.model = model_class(
+                            tokenizer=self.tokenizer,
+                            specialization="stub"
+                        )
+                        logger.warning("Using STUB model - limited functionality")
+                        self.model_loaded = True
+                        return
+            except Exception as e:
+                logger.error(f"Failed to load stub model: {e}")
             
-            # Final fallback
-            return f"I apologize, but I'm unable to process your request about '{text_input[:30]}...' at this time."
+            logger.error("All model loading attempts failed")
+                
         except Exception as e:
-            logger.error(f"Error in generate method: {e}")
-            return f"An error occurred while generating text: {str(e)}"
+            logger.error(f"Error in _lazy_load_model: {e}")
+        finally:
+            # Always mark as loaded to avoid repeated attempts
+            self.model_loaded = True
+
+    def _initialize_minimal_tokenizer(self):
+        """Initialize just the tokenizer, not the model"""
+        try:
+            from transformers import AutoTokenizer
+            self.tokenizer = AutoTokenizer.from_pretrained("gpt2", use_fast=True)
+            logger.info("Initialized minimal tokenizer")
+        except Exception as e:
+            logger.error(f"Failed to initialize tokenizer: {e}")
+
+# Add import for inspect at the top
+import inspect

handler.py

@@ -16,7 +16,43 @@ logging.basicConfig(
 logger = logging.getLogger(__name__)
 
 # --- DEBUG: confirm correct handler.py is loaded ---
-print("DEBUG: using Wildnerve-tlm_HF/handler.py — v5 with robust config handling")
+print("DEBUG: using Wildnerve-tlm_HF/handler.py — v7 with file verification")
+
+# Set aggressive memory optimization
+os.environ["PYTORCH_CUDA_ALLOC_CONF"] = "max_split_size_mb:32"
+os.environ["TRANSFORMERS_OFFLINE"] = "1"  # Prevent downloading models
+os.environ["LOW_MEMORY_MODE"] = "1"  # Custom flag for our code to detect
+
+# VERIFY CRITICAL FILES: Check required model files exist before proceeding
+def verify_required_files():
+    """Verify that critical model files exist without importing them"""
+    script_dir = os.path.dirname(os.path.abspath(__file__))
+    required_files = [
+        "model_Custm.py",
+        "model_PrTr.py",
+        "adapter_layer.py",
+        "tokenizer.py"
+    ]
+    
+    missing_files = []
+    for filename in required_files:
+        filepath = os.path.join(script_dir, filename)
+        if not os.path.exists(filepath):
+            missing_files.append(filename)
+            logger.warning(f"Required file not found: {filename}")
+        else:
+            file_size = os.path.getsize(filepath) / 1024  # KB
+            logger.info(f"Found required file: {filename} ({file_size:.1f} KB)")
+    
+    if missing_files:
+        logger.error(f"Missing required files: {', '.join(missing_files)}")
+        return False
+    return True
+
+# Verify required files exist but don't load them yet
+critical_files_verified = verify_required_files()
+if not critical_files_verified:
+    logger.warning("Some critical model files are missing - expect errors during request handling")
 
 # Safe config import that won't fail during initialization
 try:
@@ -33,12 +69,28 @@ except Exception as e:
         }
     }
 
-# Add this near the top (after imports)
-try:
-    from service_registry import ensure_models_registered
-    ensure_models_registered()
-except Exception as e:
-    logger.error(f"Error ensuring models are registered: {e}")
+# MEMORY OPTIMIZATION: Avoid loading pretrained models during init
+os.environ["TRANSFORMERS_OFFLINE"] = "1"  # Prevent downloading models
+os.environ["PYTORCH_CUDA_ALLOC_CONF"] = "max_split_size_mb:128"  # Limit CUDA allocations
+
+# Add safeguard for memory usage
+def check_memory_usage():
+    """Check memory usage and log warning if too high"""
+    try:
+        import psutil
+        process = psutil.Process(os.getpid())
+        memory_info = process.memory_info()
+        memory_mb = memory_info.rss / 1024 / 1024
+        logger.info(f"Current memory usage: {memory_mb:.2f} MB")
+        if memory_mb > 1800:  # 1.8 GB (90% of limit)
+            logger.warning(f"Memory usage critical: {memory_mb:.2f} MB. Consider reducing model size.")
+        return memory_mb
+    except Exception as e:
+        logger.warning(f"Error checking memory usage: {e}")
+        return 0
+
+# Check memory at startup
+check_memory_usage()
 
 # Safely check for required packages without crashing
 try:
@@ -74,6 +126,7 @@ try:
     script_dir = os.path.dirname(os.path.abspath(__file__))
     sys.path.insert(0, script_dir)
     
+    # MEMORY OPTIMIZATION: Import but don't initialize yet
     from adapter_layer import WildnerveModelAdapter
     logger.info("Successfully imported adapter_layer module")
     
@@ -106,61 +159,57 @@ except Exception as e:
 
 class EndpointHandler:
     def __init__(self, model_dir: str = None):
-        # HF toolkit passes model directory here; log or ignore
-        if model_dir:
-            logger.info(f"Handler init with path: {model_dir}")
-        try:
-            # Try to import adapter layer
-            try:
-                # For more reliable importing
-                script_dir = os.path.dirname(os.path.abspath(__file__))
-                sys.path.insert(0, script_dir)
-                
-                from adapter_layer import WildnerveModelAdapter
-                logger.info("Successfully imported adapter_layer module")
-            except ImportError as e:
-                logger.error(f"Could not import adapter_layer: {e}")
-                # Create a minimal placeholder adapter class
-                class WildnerveModelAdapter:
-                    def __init__(self, model_path: str =""):
-                        self.model_path = model_path
-                        logger.info(f"Using fallback WildnerveModelAdapter with path: {model_path}")
-                        
-                    def generate(self, text_input, **kwargs):
-                        return f"Model adapter unavailable. Received input: {text_input[:30]}..."
-
-            # supply model_dir as the adapter's model_path
-            self.adapter = WildnerveModelAdapter(model_dir or "")
-        except Exception as e:
-            logger.error(f"Adapter init failed: {e}", exc_info=True)
-            self.init_error = str(e)
-            self.adapter = None
-
+        # Do absolute minimal initialization here
+        self.model_dir = model_dir
+        self.adapter = None
+        self.initialized = False
+        self.critical_files_verified = critical_files_verified
+        logger.info(f"Handler init with minimal footprint: {model_dir}")
+        
     def __call__(self, data, parameters=None):
-        if self.adapter is None:
-            return [{"generated_text": f"Initialization error: {self.init_error}"}]
+        # Lazy initialization on first request
+        if not self.initialized:
+            self._initialize_on_demand()
         
         # Extract prompt text
         text = data.get("inputs") if isinstance(data, dict) else str(data)
         
         try:
-            # Generate response
+            # Warning response if critical files are missing
+            if not self.critical_files_verified:
+                logger.warning("Attempting to process request with missing critical files")
+                return [{
+                    "generated_text": "System initialization issue: Some model files appear to be missing. " + 
+                                      f"Processing your request about '{text[:30]}...' with limited functionality."
+                }]
+            
+            # Simple response for first call
+            if not self.adapter:
+                logger.info("Using simple text response (no adapter)")
+                return [{"generated_text": f"Processing your request about '{text[:30]}...'"}]
+            
+            # Generate response with adapter if available
             out = self.adapter.generate(text, **(parameters or {}))
             
-            # Ensure output is JSON serializable
-            if torch.is_tensor(out):
-                # Convert tensor to string
-                logger.warning("Model returned a tensor instead of text, attempting to convert")
-                if out.dim() > 0 and hasattr(self.adapter, "tokenizer"):
-                    out = self.adapter.tokenizer.decode(out.cpu().squeeze(), skip_special_tokens=True)
-                else:
-                    out = str(out)
-                    
-            # Final check to ensure string output
+            # Ensure output is valid string
             if not isinstance(out, str):
                 out = str(out)
                 
             return [{"generated_text": out}]
         except Exception as e:
             logger.error(f"Generation error: {e}", exc_info=True)
-            return [{"generated_text": f"Error: {e}"}]
+            return [{"generated_text": f"Error processing your request: {str(e)}"}]
+    
+    def _initialize_on_demand(self):
+        """Initialize adapter when first needed"""
+        try:
+            logger.info("Performing lazy initialization on first request")
+            
+            # Import with minimal dependencies
+            from adapter_layer import WildnerveModelAdapter
+            self.adapter = WildnerveModelAdapter(self.model_dir or "")
+            self.initialized = True
+            logger.info("Adapter initialized successfully")
+        except Exception as e:
+            logger.error(f"Error initializing adapter: {e}", exc_info=True)
+            # Continue without adapter, we'll return simple responses

model_PrTr.py

@@ -100,7 +100,8 @@ class Wildnerve_tlm01(nn.Module, AbstractModel):
             from transformers import GPT2LMHeadModel, GPT2Tokenizer
             
             # Initialize the model and tokenizer
-            self.gpt2_model = GPT2LMHeadModel.from_pretrained(model_name)
+            self.model_name = model_name
+            self.gpt2_model = None  # Will be loaded on first use
             
             # Ensure proper tokenizer setup for GPT-2
             if tokenizer is not None:
@@ -115,10 +116,10 @@ class Wildnerve_tlm01(nn.Module, AbstractModel):
                 self.tokenizer.pad_token = self.tokenizer.eos_token
                 self.tokenizer.pad_token_id = self.tokenizer.eos_token_id
             
-            logger.info(f"Successfully loaded GPT-2 model: {model_name}")
+            logger.info(f"Successfully initialized GPT-2 model: {model_name}")
             
         except Exception as e:
-            logger.error(f"Error loading GPT-2 model: {e}", exc_info=True)
+            logger.error(f"Error initializing GPT-2 model: {e}", exc_info=True)
             raise
 
         # Register this model instance in the registry by specialization
@@ -129,6 +130,10 @@ class Wildnerve_tlm01(nn.Module, AbstractModel):
         registry.register(PRETRAINED_MODEL, self, overwrite=True)
         logger.info("Registered GPT-2 model as pretrained model")
 
+    def _ensure_model_loaded(self):
+        if self.gpt2_model is None:
+            self.gpt2_model = GPT2LMHeadModel.from_pretrained(self.model_name)
+
     # Replace the old forward method with GPT-2 specific implementation
     def forward(self, src: torch.Tensor, tgt: Optional[torch.Tensor] = None, 
            src_key_padding_mask: Optional[torch.Tensor] = None,
@@ -136,6 +141,7 @@ class Wildnerve_tlm01(nn.Module, AbstractModel):
            return_sequence: bool = False,
            **kwargs) -> torch.Tensor:
         
+        self._ensure_model_loaded()  # Load model only when needed
         # Use GPT-2 directly for generation
         outputs = self.gpt2_model(src, **kwargs)
         return outputs.logits
@@ -143,6 +149,7 @@ class Wildnerve_tlm01(nn.Module, AbstractModel):
     # Update generate to handle both direct prompt and tokenized input
     def generate(self, prompt=None, input_ids=None, max_length=None, **kwargs):
         """Generate text using the GPT-2 model"""
+        self._ensure_model_loaded()  # Load model only when needed
         try:
             # Try to use adapter_layer.generate if available (consolidate generation paths)
             adapter_layer = registry.get("adapter_layer")
@@ -204,6 +211,7 @@ class Wildnerve_tlm01(nn.Module, AbstractModel):
 
     def generate_streaming(self, prompt=None, input_ids=None, **kwargs):
         """Generate tokens one by one in streaming fashion"""
+        self._ensure_model_loaded()  # Load model only when needed
         try:
             # Handle either text or tokenized input
             if prompt is not None and input_ids is None:

model_stub.py

@@ -0,0 +1,58 @@
+"""
+Minimal model stub that can be used if the real model files aren't found.
+Uses near-zero memory while still providing the expected interface.
+"""
+import os
+import logging
+import torch.nn as nn
+
+logger = logging.getLogger(__name__)
+logger.warning("Using minimal model stub - EMERGENCY FALLBACK MODE")
+
+class Wildnerve_tlm01(nn.Module):
+    """Ultra-minimal model implementation that uses almost no memory"""
+    
+    def __init__(self, **kwargs):
+        """Initialize with minimal footprint - store kwargs for compatibility"""
+        super().__init__()
+        self.is_stub = True
+        
+        # Store passed parameters without using them
+        for key, value in kwargs.items():
+            setattr(self, key, value)
+            
+        # Important: store tokenizer if provided
+        self.tokenizer = kwargs.get('tokenizer')
+        self.specialization = kwargs.get('specialization', 'general')
+        
+        logger.warning(f"Created stub model with specialization: {self.specialization}")
+    
+    def forward(self, input_ids=None, attention_mask=None, **kwargs):
+        """Minimal forward implementation that returns empty tensor"""
+        batch_size = 1
+        seq_length = 10
+        vocab_size = getattr(self, 'vocab_size', 50257) 
+        
+        if input_ids is not None:
+            batch_size = input_ids.shape[0]
+            seq_length = input_ids.shape[1]
+            
+        import torch
+        # Return zeros - uses minimal memory
+        return torch.zeros((batch_size, seq_length, vocab_size))
+    
+    def generate(self, prompt=None, **kwargs):
+        """Return a templated response"""
+        if prompt:
+            return f"[STUB MODEL] I've received your request about '{prompt[:50]}...'"
+        return "[STUB MODEL] I've received your request"
+    
+    def generate_streaming(self, prompt=None, **kwargs):
+        """Simulate streaming response"""
+        import time
+        response = self.generate(prompt)
+        words = response.split()
+        
+        for word in words:
+            yield word + " "
+            time.sleep(0.05)  # Simulate streaming delay

service_registry.py

@@ -1,5 +1,5 @@
 """
-Simple service registry for dependency injection
+Minimal service registry for dependency injection
 """
 import logging
 import traceback
@@ -7,17 +7,17 @@ from typing import Any, Dict, Optional
 
 logger = logging.getLogger(__name__)
 
-# Constants used as keys - let's clarify with better names
-MODEL = "model"  # The custom Wildnerve-tlm01_Hybrid_Model 
-PRETRAINED_MODEL = "pretrained_model"  # GPT-2 model
+# Constants used as keys
+MODEL = "model" 
+PRETRAINED_MODEL = "pretrained_model"
 TOKENIZER = "tokenizer"
 MODEL_MANAGER = "model_manager"
 COMMUNICATOR = "communicator"
 PIPELINE = "pipeline"
-TRANSFORMER = "transformer"  # Generic transformer key
+TRANSFORMER = "transformer"
 
 class ServiceRegistry:
-    """A simple service registry for dependency management"""
+    """A minimal service registry that avoids loading heavy models"""
     
     def __init__(self):
         self._services = {}
@@ -34,7 +34,7 @@ class ServiceRegistry:
     def get(self, key: str) -> Optional[Any]:
         """Get a service by its key"""
         if key not in self._services:
-            logger.warning(f"No service registered with key: {key}")
+            # Don't log warning to avoid excessive logs
             return None
             
         return self._services[key]
@@ -51,130 +51,5 @@ class ServiceRegistry:
 registry = ServiceRegistry()
 
 def ensure_models_registered():
-    """Ensure at least one model is registered in the registry."""
-    # First make sure we have a CUSTOM model (Wildnerve-tlm01_Hybrid_Model)
-    if not registry.has(MODEL):
-        logger.info("No custom model in registry, registering Wildnerve-tlm01_Hybrid_Model")
-        try:
-            import os, importlib.util
-            
-            # Find model_Custm.py in the same directory as this file
-            this_dir = os.path.dirname(os.path.abspath(__file__))
-            model_path = os.path.join(this_dir, "model_Custm.py")
-            
-            # Add more debug logging
-            logger.info(f"Model path exists: {os.path.exists(model_path)}")
-            logger.info(f"Model directory content: {os.listdir(os.path.dirname(model_path))}")
-            
-            if os.path.exists(model_path):
-                # Dynamic import of model_Custm.py for Wildnerve-tlm01_Hybrid_Model
-                spec = importlib.util.spec_from_file_location("model_custm", model_path)
-                model_module = importlib.util.module_from_spec(spec)
-                spec.loader.exec_module(model_module)
-                
-                # Get the model class for Wildnerve-tlm01_Hybrid_Model
-                if hasattr(model_module, "Wildnerve_tlm01"):
-                    from tokenizer import TokenizerWrapper
-                    
-                    # Create tokenizer and model
-                    tok = TokenizerWrapper()
-                    model_class = getattr(model_module, "Wildnerve_tlm01")
-                    model = model_class(
-                        vocab_size=50257,  # Updated to GPT-2 vocab size
-                        specialization="general",
-                        dataset_path=None,
-                        model_name="gpt2",  # Changed from bert-base-uncased
-                        embedding_dim=768,
-                        num_heads=12,
-                        hidden_dim=768,
-                        num_layers=2,
-                        output_size=50257,  # Match GPT-2 vocab size
-                        dropout=0.1,
-                        max_seq_length=128,
-                        pooling_mode="last",  # GPT-2 typically uses last token
-                        tokenizer=tok
-                    )
-                    
-                    # Register both tokenizer and the Wildnerve-tlm01_Hybrid_Model
-                    registry.register(TOKENIZER, tok, overwrite=True)
-                    registry.register(MODEL, model, overwrite=True)
-                    logger.info("Successfully registered Wildnerve-tlm01_Hybrid_Model as MODEL")
-                    return True
-            
-            logger.error(f"model_Custm.py not found at {model_path}")
-            return False
-            
-        except Exception as e:
-            # More detailed error logging
-            logger.error(f"Failed to register Wildnerve-tlm01_Hybrid_Model: {e}")
-            logger.error(f"Exception details: {type(e).__name__}")
-            logger.error(f"Exception traceback: {traceback.format_exc()}")
-            return False
-    
-    # Then check if we have a GPT-2 PRETRAINED model
-    if not registry.has(PRETRAINED_MODEL):
-        logger.info("No GPT-2 model in registry, registering GPT-2")
-        try:
-            import os, importlib.util
-            # Import required modules at this scope
-            try:
-                from transformers import GPT2LMHeadModel, GPT2Tokenizer
-            except ImportError:
-                logger.error("Failed to import required GPT-2 modules")
-                return False
-            
-            # Find model_PrTr.py in the same directory as this file
-            this_dir = os.path.dirname(os.path.abspath(__file__))
-            model_path = os.path.join(this_dir, "model_PrTr.py")
-            
-            if os.path.exists(model_path):
-                # Dynamic import of model_PrTr.py
-                spec = importlib.util.spec_from_file_location("model_prtr", model_path)
-                model_module = importlib.util.module_from_spec(spec)
-                spec.loader.exec_module(model_module)
-                
-                # Get GPT-2 wrapper class
-                model_class = None
-                if hasattr(model_module, "PretrainedTransformer"):
-                    model_class = getattr(model_module, "PretrainedTransformer")
-                elif hasattr(model_module, "Wildnerve_tlm01"):
-                    model_class = getattr(model_module, "Wildnerve_tlm01")
-                
-                if model_class:
-                    # Get tokenizer first
-                    tok = registry.get(TOKENIZER)
-                    if not tok:
-                        try:
-                            # Create GPT-2 tokenizer
-                            tok = GPT2Tokenizer.from_pretrained("gpt2")
-                            if tok.pad_token_id is None:
-                                tok.pad_token = tok.eos_token
-                                tok.pad_token_id = tok.eos_token_id
-                            registry.register(TOKENIZER, tok, overwrite=True)
-                            logger.info("Created GPT-2 tokenizer directly")
-                        except Exception as e:
-                            logger.error(f"Failed to create GPT-2 tokenizer: {e}")
-                            return False
-                    
-                    # Create GPT-2 model instance
-                    model = model_class(
-                        model_name="gpt2",  # Explicitly use gpt2
-                        tokenizer=tok
-                    )
-                    
-                    # Register as GPT-2 pretrained model
-                    registry.register(PRETRAINED_MODEL, model, overwrite=True)
-                    logger.info("Successfully registered GPT-2 as PRETRAINED_MODEL")
-                    return True
-
-            logger.error(f"model_PrTr.py not found at {model_path}")
-            
-        except Exception as e:
-            logger.error(f"Failed to register GPT-2 model: {e}")
-            logger.error(f"Exception details: {type(e).__name__}")
-            logger.error(f"Exception traceback: {traceback.format_exc()}")
-    
+    """Placeholder function - don't actually register models at startup"""
     return True
-
-# Execute this during module import to ensure models are registered
-ensure_models_registered()

smartHybridAttention.py

@@ -177,9 +177,8 @@ class SmartHybridAttention(nn.Module):
         # Ensure int type for memory tokens
         self.memory_tokens = int(memory_tokens) if isinstance(memory_tokens, (int, float)) else 32
         
-        # Initialize memory parameter
-        self.persistent_memory = nn.Parameter(torch.zeros(self.memory_tokens, 1, self.dim))
-        nn.init.normal_(self.persistent_memory, mean=0.0, std=0.02)
+        # Delayed initialization for memory parameter
+        self._persistent_memory_initialized = False
         
         # Projections
         self.q_proj = nn.Linear(self.dim, self.dim)
@@ -232,6 +231,12 @@ class SmartHybridAttention(nn.Module):
         except:
             return {}
 
+    def _init_memory(self):
+        if not self._persistent_memory_initialized:
+            self.persistent_memory = nn.Parameter(torch.zeros(self.memory_tokens, 1, self.dim))
+            nn.init.normal_(self.persistent_memory, mean=0.0, std=0.02)
+            self._persistent_memory_initialized = True
+
     def _create_sliding_window_mask(
         self, 
         seq_len: int, 
@@ -304,6 +309,7 @@ class SmartHybridAttention(nn.Module):
     ) -> torch.Tensor:
         """Apply attention with persistent memory tokens for long-range context.
            Returns: Output tensor after attention [seq_len, batch, dim]"""
+        self._init_memory()  # Initialize memory only when needed
         seq_len, batch_size, _ = query.size()
         
         # Expand memory tokens to batch size

tokenizer.py

@@ -1,86 +1,14 @@
-# Tokenizer Wrapper Module
 import os
-import torch
+import json
 import logging
-import sentencepiece as spm
-from typing import List, Union, Dict, Optional, Tuple, Any
-from transformers import AutoTokenizer, PreTrainedTokenizerBase, BertTokenizer
-from pathlib import Path
-from functools import lru_cache
-import importlib.util
-
-# Check if sentencepiece is available but don't crash if not
-SP_AVAILABLE = importlib.util.find_spec("sentencepiece") is not None
-if SP_AVAILABLE:
-    import sentencepiece as spm
-else:
-    logging.warning("sentencepiece not available; some tokenizer features will be limited")
-
-from config import app_config
-from service_registry import registry, TOKENIZER
+from typing import List, Dict, Optional, Union, Any
 
 logger = logging.getLogger(__name__)
 
 class TokenizerWrapper:
-    """A wrapper for transformer tokenizers with fallbacks"""
+    """Lightweight wrapper around GPT-2 tokenizer with memory optimization"""
     
-    def __init__(self, model_name="gpt2"):
+    def __init__(self, model_name: str = "gpt2", load_vocab: bool = True):
         self.model_name = model_name
-        try:
-            self.tokenizer = AutoTokenizer.from_pretrained(model_name)
-            # Add pad token if it doesn't exist (important for GPT-2)
-            if self.tokenizer.pad_token is None:
-                self.tokenizer.pad_token = self.tokenizer.eos_token
-            logger.info(f"Initialized tokenizer from {model_name}")
-        except Exception as e:
-            logger.error(f"Error loading tokenizer: {e}")
-            self.tokenizer = None
-            
-    def __call__(self, text, **kwargs):
-        """Make the wrapper callable like a standard HF tokenizer"""
-        if self.tokenizer is None:
-            raise ValueError("Tokenizer not initialized")
-        return self.tokenizer(text, **kwargs)
-    
-    def encode(self, text, **kwargs):
-        """Encode text to token IDs"""
-        if self.tokenizer is None:
-            raise ValueError("Tokenizer not initialized")
-        return self.tokenizer.encode(text, **kwargs)
-        
-    def decode(self, token_ids, **kwargs):
-        """Decode token IDs to text"""
-        if self.tokenizer is None:
-            raise ValueError("Tokenizer not initialized")
-        return self.tokenizer.decode(token_ids, **kwargs)
-        
-    def tokenize(self, text, **kwargs):
-        """Tokenize text to tokens"""
-        if self.tokenizer is None:
-            raise ValueError("Tokenizer not initialized")
-        return self.tokenizer.tokenize(text, **kwargs)
-    
-def get_tokenizer(model_name="gpt2"):
-    """Get a tokenizer instance with proper fallback handling"""
-    try:
-        return TokenizerWrapper(model_name)
-    except Exception as e:
-        logger.error(f"Error creating TokenizerWrapper: {e}")
-        try:
-            return AutoTokenizer.from_pretrained(model_name)
-        except Exception as e2:
-            logger.error(f"Error loading AutoTokenizer: {e2}")
-            return None
-
-if __name__ == "__main__":
-    # Example usage showcasing advanced features
-    wrapper = TokenizerWrapper(sp_model_path="c:\\Users\\User\\OneDrive\\Documents\\tlm\\Wildnerve-tlm_HF\\sentencepiece.model")
-    sample_text = "This is an ADVANCED Test sentence! With    multiple    spaces and Punctuation."
-    tokens_sp = wrapper.tokenize(sample_text, use_sentencepiece=True)
-    tokens_tr = wrapper.tokenize(sample_text, use_sentencepiece=False)
-    encoded = wrapper.encode(sample_text)
-    decoded = wrapper.decode(encoded) if encoded else ""
-    print("SentencePiece Tokens:", tokens_sp)
-    print("Transformer Tokens:", tokens_tr)
-    print("Encoded:", encoded)
-    print("Decoded:", decoded)
+        self.pad_token = "<pad>"
+        self.eos_token = "