Upload 4 files

model_List.py

@@ -1,22 +1,25 @@
 # model_List.py - Model selection and analysis component with advanced features
-import logging
-import time
-import math
-import torch
-import importlib.util
 import os
 import re
-import logging
-from typing import List, Tuple, Dict, Type, Any, Optional
-import torch
-import numpy as np
-from sklearn.metrics.pairwise import cosine_similarity
+import json
+import time
+import math
 import nltk
 try:
     nltk.data.find('tokenizers/punkt')
 except LookupError:
     nltk.download("punkt")
-from service_registry import registry, TOKENIZER, MODEL
+
+import torch
+import logging
+import numpy as np
+import importlib.util
+from enum import Enum  # Add this import for Enum
+from service_registry import registry, MODEL, PRETRAINED_MODEL
+from sklearn.metrics.pairwise import cosine_similarity
+from typing import List, Tuple, Dict, Type, Any, Optional
+
+logger = logging.getLogger(__name__)
 
 # More robust config import
 try:
@@ -37,8 +40,38 @@ except ImportError:
 # Add SmartHybridAttention imports
 from utils.smartHybridAttention import SmartHybridAttention, get_hybrid_attention_config
 
+# Fix: Import get_sentence_transformer properly
+try:
+    from utils.transformer_utils import get_sentence_transformer
+except ImportError:
+    # Create a fallback implementation if the import fails
+    def get_sentence_transformer(model_name):
+        try:
+            from sentence_transformers import SentenceTransformer
+            return SentenceTransformer(model_name)
+        except ImportError:
+            logger.error("sentence_transformers package not available")
+            # Return a minimal placeholder that won't crash initialization
+            class MinimalSentenceTransformer:
+                def __init__(self, *args, **kwargs):
+                    pass
+                def encode(self, text):
+                    return [0.0] * 384  # Return zero vector with typical dimension
+            return MinimalSentenceTransformer()
+
+from model_Custm import Wildnerve_tlm01 as CustomModel
+
+logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
+class ModelType(Enum):
+    CUSTOM = "model_Custm.py"     # Wildnerve-tlm01 custom implementation
+    PRETRAINED = "model_PrTr.py"  # GPT2 pretrained models
+#    COMBINED = "model_Combn.py"   # Hybrid approach with both
+
+# Replace generic Auto* classes with specific GPT-2 classes
+from transformers import GPT2Tokenizer, GPT2LMHeadModel
+
 class PromptAnalyzer:
     """
     Enhanced prompt analyzer that combines:
@@ -96,9 +129,13 @@ class PromptAnalyzer:
         self.sentence_model = get_sentence_transformer('sentence-transformers/all-MiniLM-L6-v2')
         self.logger.info(f"Using SentenceTransformer model: sentence-transformers/all-MiniLM-L6-v2")
         
-        # Use GPT-2 for perplexity calculation
-        self.tokenizer = AutoTokenizer.from_pretrained("gpt2")
-        self.model = AutoModelForCausalLM.from_pretrained("gpt2")
+        # Use specific GPT-2 classes instead of Auto* classes
+        self.tokenizer = GPT2Tokenizer.from_pretrained("gpt2")
+        # Fix missing pad token in GPT-2
+        if self.tokenizer.pad_token is None:
+            self.tokenizer.pad_token = self.tokenizer.eos_token
+        
+        self.model = GPT2LMHeadModel.from_pretrained("gpt2")
         self.model.eval()
 
         logger.info(f"Initialized PromptAnalyzer with {self.model_name}, specialization: {self.specialization}, hidden_dim: {self.hidden_dim}")

service_registry.py

@@ -2,17 +2,19 @@
 Simple service registry for dependency injection
 """
 import logging
-import traceback  # Add this missing import
+import traceback
 from typing import Any, Dict, Optional
 
 logger = logging.getLogger(__name__)
 
-# Constants used as keys
-MODEL = "model"
-PRETRAINED_MODEL = "pretrained_model"
+# 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
 TOKENIZER = "tokenizer"
 MODEL_MANAGER = "model_manager"
 COMMUNICATOR = "communicator"
+PIPELINE = "pipeline"
+TRANSFORMER = "transformer"  # Generic transformer key
 
 class ServiceRegistry:
     """A simple service registry for dependency management"""
@@ -50,9 +52,9 @@ registry = ServiceRegistry()
 
 def ensure_models_registered():
     """Ensure at least one model is registered in the registry."""
-    # First check and register CUSTOM model if needed
+    # First make sure we have a CUSTOM model (Wildnerve-tlm01_Hybrid_Model)
     if not registry.has(MODEL):
-        logger.info("No model in registry, registering model_Custm")
+        logger.info("No custom model in registry, registering Wildnerve-tlm01_Hybrid_Model")
         try:
             import os, importlib.util
             
@@ -65,12 +67,12 @@ def ensure_models_registered():
             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
+                # 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
+                # Get the model class for Wildnerve-tlm01_Hybrid_Model
                 if hasattr(model_module, "Wildnerve_tlm01"):
                     from tokenizer import TokenizerWrapper
                     
@@ -93,10 +95,10 @@ def ensure_models_registered():
                         tokenizer=tok
                     )
                     
-                    # Register both tokenizer and model
+                    # 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 model_Custm.Wildnerve_tlm01")
+                    logger.info("Successfully registered Wildnerve-tlm01_Hybrid_Model as MODEL")
                     return True
             
             logger.error(f"model_Custm.py not found at {model_path}")
@@ -104,21 +106,21 @@ def ensure_models_registered():
             
         except Exception as e:
             # More detailed error logging
-            logger.error(f"Failed to register model_Custm: {e}")
+            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
     
-    # Next make sure PRETRAINED model is registered too
+    # Then check if we have a GPT-2 PRETRAINED model
     if not registry.has(PRETRAINED_MODEL):
-        logger.info("No pretrained model in registry, registering model_PrTr")
+        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 AutoModelForCausalLM, AutoTokenizer, GPT2LMHeadModel, GPT2Tokenizer
+                from transformers import GPT2LMHeadModel, GPT2Tokenizer
             except ImportError:
-                logger.error("Failed to import required transformer modules")
+                logger.error("Failed to import required GPT-2 modules")
                 return False
             
             # Find model_PrTr.py in the same directory as this file
@@ -131,7 +133,7 @@ def ensure_models_registered():
                 model_module = importlib.util.module_from_spec(spec)
                 spec.loader.exec_module(model_module)
                 
-                # Use PretrainedTransformer if available, otherwise use Wildnerve_tlm01
+                # Get GPT-2 wrapper class
                 model_class = None
                 if hasattr(model_module, "PretrainedTransformer"):
                     model_class = getattr(model_module, "PretrainedTransformer")
@@ -143,7 +145,7 @@ def ensure_models_registered():
                     tok = registry.get(TOKENIZER)
                     if not tok:
                         try:
-                            # Try using GPT2Tokenizer directly instead of AutoTokenizer
+                            # Create GPT-2 tokenizer
                             tok = GPT2Tokenizer.from_pretrained("gpt2")
                             if tok.pad_token_id is None:
                                 tok.pad_token = tok.eos_token
@@ -154,21 +156,21 @@ def ensure_models_registered():
                             logger.error(f"Failed to create GPT-2 tokenizer: {e}")
                             return False
                     
-                    # Create pretrained model
+                    # Create GPT-2 model instance
                     model = model_class(
-                        model_name="gpt2", # Explicitly use gpt2
+                        model_name="gpt2",  # Explicitly use gpt2
                         tokenizer=tok
                     )
                     
-                    # Register as pretrained model
+                    # Register as GPT-2 pretrained model
                     registry.register(PRETRAINED_MODEL, model, overwrite=True)
-                    logger.info("Successfully registered GPT-2 pretrained model")
+                    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 pretrained model: {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()}")