Upload 2 files

config.py

@@ -394,6 +394,15 @@ def load_config() -> AppConfig:
     try:
         with open(config_path, "r") as f:
             raw = json.load(f)
+
+            # helper to convert a dict into an object with attribute access
+            class AttrDict(dict):
+                __getattr__ = dict.get
+                __setattr__ = dict.__setitem__
+
+            # wrap TRANSFORMER_CONFIG if it's a dict
+            if isinstance(raw.get("TRANSFORMER_CONFIG"), dict):
+                raw["TRANSFORMER_CONFIG"] = AttrDict(raw["TRANSFORMER_CONFIG"])
     except Exception as e:
         logger.error(f"Failed to read config.json: {e}", exc_info=True)
         raise

model_Custm.py

@@ -1,31 +1,26 @@
 # model_Custm.py
+# Consolidated imports
 import os
 import sys
 import math
-import torch
 import logging
-import numpy as np
+import torch
 import torch.nn as nn
+import numpy as np
+import transformers
 from typing import Optional, List, Dict, Union
 
-# Import the carbon tracking early - before transformers
-from codecarbon import EmissionsTracker  # Import EmissionsTracker
-
-# Apply patches before importing transformers
+from codecarbon import EmissionsTracker
 import transformer_patches
 
-# Now we can safely import transformers
-import transformers
-
-# Continue with standard imports
 from service_registry import registry, MODEL, TOKENIZER
 from utils.transformer_utils import get_tokenizer
 from utils.smartHybridAttention import SmartHybridAttention, get_hybrid_attention_config
-
-# Import base interfaces
 from base_interfaces.common_types import *
 from base_interfaces.model_interface import AbstractModel
 
+from config import app_config
+
 logger = logging.getLogger(__name__)
 
 # Check if transformers integrations has CodeCarbonCallback
@@ -40,58 +35,34 @@ if hasattr(transformers.integrations, 'CodeCarbonCallback'):
     else:
         logger.info(f"Using original implementation for CodeCarbonCallback from {callback_module}")
 
-# Continue with existing code
-try:
-    if 'TLM_DATA_DIR' in os.environ:
-        data_dir = os.environ.get('TLM_DATA_DIR', '/tmp/tlm_data')
-        model_dir = os.path.join(data_dir, "models")
-        logging.info(f"Using data directory from environment: {data_dir}")
-        from types import SimpleNamespace
-        app_config = SimpleNamespace()
-        app_config.DATA_DIR = data_dir
-        app_config.MODEL_DIR = model_dir
-        app_config.TRANSFORMER_CONFIG = SimpleNamespace()
-        app_config.TRANSFORMER_CONFIG.MAX_SEQ_LENGTH = 512
-        try:
-            from config import load_config, app_config as config_app_config
-            app_config = load_config() if not hasattr(config_app_config, 'DATA_DIR') else config_app_config
-        except Exception as config_error:
-            logging.warning(f"Using minimal config due to error: {config_error}")
-    else:
-        from config import load_config, app_config as config_app_config
-        app_config = load_config() if not hasattr(config_app_config, 'DATA_DIR') else config_app_config
-except Exception as e:
-    logging.warning(f"Error importing config: {e}")
-    from types import SimpleNamespace
-    app_config = SimpleNamespace()
-    app_config.DATA_DIR = '/tmp/tlm_data'
-    app_config.MODEL_DIR = '/tmp/tlm_data/models'
-    app_config.TRANSFORMER_CONFIG = SimpleNamespace()
-    app_config.TRANSFORMER_CONFIG.MAX_SEQ_LENGTH = 512
-
-# Ensure the necessary directories exist, but don't fail if they can't be created
-try:
-    os.makedirs(getattr(app_config, "DATA_DIR", "/tmp/tlm_data"), exist_ok=True)
-    os.makedirs(getattr(app_config, "MODEL_DIR", "/tmp/tlm_data/models"), exist_ok=True)
-except Exception as e:
-    logging.warning(f"Could not create directories: {e}")
-
-# Configure logging and suppress TensorFlow warnings
-os.environ["TF_ENABLE_ONEDNN_OPTS"] = "0"
-os.environ["TF_CPP_MIN_LOG_LEVEL"] = "2"
+# Ensure data/model directories exist (silently ignore errors)
+for d in (app_config.DATA_DIR, app_config.MODEL_DIR):
+    try: os.makedirs(d, exist_ok=True)
+    except Exception as _e: logger.warning(f"Could not create directory {d}: {_e}")
+
+# Suppress TensorFlow logs if present
+os.environ.setdefault("TF_ENABLE_ONEDNN_OPTS", "0")
+os.environ.setdefault("TF_CPP_MIN_LOG_LEVEL", "2")
 
 # ----------------------------
 # Positional Encoding Module
 # ----------------------------
 class PositionalEncoding(nn.Module):
-    def __init__(self, d_model: int, max_len: int = app_config.TRANSFORMER_CONFIG.MAX_SEQ_LENGTH):
+    def __init__(self, d_model: int, max_len: Optional[int] = None):
         super().__init__()
+        # determine max_len dynamically
+        if max_len is None:
+            cfg = app_config.TRANSFORMER_CONFIG
+            if isinstance(cfg, dict):
+                max_len = cfg.get("MAX_SEQ_LENGTH", 512)
+            else:
+                max_len = getattr(cfg, "MAX_SEQ_LENGTH", 512)
         pe = torch.zeros(max_len, d_model)
         position = torch.arange(0, max_len, dtype=torch.float).unsqueeze(1)
         div_term = torch.exp(torch.arange(0, d_model, 2, dtype=torch.float) * (-math.log(10000.0) / d_model))
         pe[:, 0::2] = torch.sin(position * div_term)
         pe[:, 1::2] = torch.cos(position * div_term)
-        pe = pe.unsqueeze(1)  # shape: (max_len, 1, d_model)
+        pe = pe.unsqueeze(1)
         self.register_buffer("pe", pe)
     def forward(self, x: torch.Tensor) -> torch.Tensor:
         # x shape: (seq_len, batch_size, d_model)
@@ -772,18 +743,4 @@ def initialize_tokenizer():
     except Exception as e:
         logger.error(f"Default tokenizer initialization failed: {e}")
         tokenizer = None
-    return tokenizer
-
-# NOTE: This file is currently empty (no class or functions defined).
-# As a result:
-# 1. service_registry.ensure_models_registered() cannot find Wildnerve_tlm01 here,
-#    so it falls back (or errors) when registering the custom model.
-# 2. The handler tries to import `find_weights`, which doesn’t exist in this module
-#    (hence "No module named 'find_weights'" in the logs).
-# 3. Since no model class is present, the pipeline never registers a MODEL or PIPELINE,
-#    triggering "cannot import name 'PIPELINE' from 'service_registry'".
-# 
-# To fix:
-# - Merge the real Wildnerve_tlm01 implementation into this file (or import it).
-# - Provide a stub `find_weights.py` with the expected functions.
-# - Define or register PIPELINE in service_registry, or remove its import from main/handler.
+    return tokenizer