gptmed 0.4.0__py3-none-any.whl → 0.5.0__py3-none-any.whl

gptmed/api.py

@@ -139,6 +139,14 @@ def train_from_config(
     # Print device information
     device_manager.print_device_info(verbose=verbose)
     
+    # Optionally enable Redis metrics storage
+    from gptmed.observability.redis_metrics_storage import RedisMetricsStorage
+    from gptmed.observability.metrics_tracker import MetricsTracker
+
+    redis_enabled = False
+    if 'redis' in config and config['redis'].get('enabled', False):
+        redis_enabled = True
+
     # Create TrainingService with DeviceManager
     training_service = TrainingService(
         device_manager=device_manager,
@@ -203,6 +211,7 @@ def train_from_config(
         log_dir=args['log_dir'],
         device=actual_device,  # Use actual device from DeviceManager
         seed=args['seed'],
+        resume_from=args.get('resume_from'),  # Pass resume checkpoint path
     )
     
     # Create optimizer
@@ -219,6 +228,23 @@ def train_from_config(
         weight_decay=args['weight_decay'],
     )
     
+
+    # If Redis is enabled, inject RedisMetricsStorage into MetricsTracker
+    observers = None
+    if redis_enabled:
+        if verbose:
+            print("\n🔗 Enabling Redis metrics storage...")
+        observers = [
+            MetricsTracker(
+                log_dir=train_config.log_dir,
+                experiment_name="gptmed_training",
+                moving_avg_window=100,
+                log_interval=train_config.log_interval,
+                verbose=verbose,
+                storage_backend=RedisMetricsStorage(),
+            )
+        ]
+
     # Execute training using TrainingService
     results = training_service.execute_training(
         model=model,
@@ -227,9 +253,9 @@ def train_from_config(
         optimizer=optimizer,
         train_config=train_config,
         device=actual_device,
-        model_config_dict=model.config.to_dict()
+        model_config_dict=model.config.to_dict(),
+        observers=observers,
     )
-    
     return results
 
 

gptmed/configs/config_loader.py

@@ -35,6 +35,14 @@ def load_yaml_config(config_path: str) -> Dict[str, Any]:
         except yaml.YAMLError as e:
             raise ValueError(f"Error parsing YAML configuration: {e}")
     
+    # If redis section is missing, add defaults
+    if 'redis' not in config:
+        config['redis'] = {
+            'host': 'localhost',
+            'port': 6379,
+            'db': 0,
+            'password': None
+        }
     return config
 
 
@@ -86,6 +94,17 @@ def validate_config(config: Dict[str, Any]) -> None:
             f"Must be one of {valid_devices}"
         )
 
+    # Validate redis config
+    redis_cfg = config.get('redis', {})
+    if not isinstance(redis_cfg, dict):
+        raise ValueError("Redis config must be a dictionary.")
+    if 'host' not in redis_cfg or not redis_cfg['host']:
+        raise ValueError("Redis config missing 'host'.")
+    if 'port' not in redis_cfg or not isinstance(redis_cfg['port'], int):
+        raise ValueError("Redis config missing or invalid 'port'.")
+    if 'db' not in redis_cfg or not isinstance(redis_cfg['db'], int):
+        raise ValueError("Redis config missing or invalid 'db'.")
+
 
 def config_to_args(config: Dict[str, Any]) -> Dict[str, Any]:
     """
@@ -135,6 +154,14 @@ def config_to_args(config: Dict[str, Any]) -> Dict[str, Any]:
         'max_steps': config.get('advanced', {}).get('max_steps', -1),
         'resume_from': config.get('advanced', {}).get('resume_from'),
         'quick_test': config.get('advanced', {}).get('quick_test', False),
+
+        # Redis
+        'redis_config': config.get('redis', {
+            'host': 'localhost',
+            'port': 6379,
+            'db': 0,
+            'password': None
+        }),
     }
     
     return args
@@ -185,6 +212,12 @@ def create_default_config_file(output_path: str = 'training_config.yaml') -> Non
             'max_steps': -1,
             'resume_from': None,
             'quick_test': False
+        },
+        'redis': {
+            'host': 'localhost',
+            'port': 6379,
+            'db': 0,
+            'password': None
         }
     }
     

gptmed/configs/configs.py

@@ -0,0 +1,17 @@
+"""
+Configuration for Redis connection for real-time training metrics storage.
+"""
+
+import os
+
+REDIS_HOST = "localhost"
+REDIS_PORT = 6379
+REDIS_DB = 0
+REDIS_PASSWORD = None
+
+REDIS_CONFIG = {
+    "host": REDIS_HOST,
+    "port": REDIS_PORT,
+    "db": REDIS_DB,
+    "password": REDIS_PASSWORD,
+}

gptmed/configs/train_config.py

@@ -37,6 +37,7 @@ COMMON FAILURE MODES:
 
 from dataclasses import dataclass
 from pathlib import Path
+from typing import Optional
 import json
 
 
@@ -91,6 +92,9 @@ class TrainingConfig:
     # Reproducibility
     seed: int = 42
 
+    # Resume training
+    resume_from: Optional[str] = None  # Path to checkpoint to resume from
+
     def to_dict(self) -> dict:
         """Convert to dictionary."""
         return {
@@ -117,6 +121,7 @@ class TrainingConfig:
             "device": self.device,
             "use_amp": self.use_amp,
             "seed": self.seed,
+            "resume_from": self.resume_from,
         }
 
     def save(self, path: Path):

gptmed/observability/metrics_tracker.py

@@ -21,6 +21,7 @@ WHAT TO LOOK FOR:
 - Loss = NaN → Exploding gradients
 """
 
+
 import json
 import math
 import time
@@ -36,6 +37,9 @@ from gptmed.observability.base import (
     GradientMetrics,
 )
 
+# Import the interface but not the Redis implementation directly (for loose coupling)
+from gptmed.observability.redis_metrics_storage import MetricsStorageInterface
+
 
 @dataclass
 class LossCurvePoint:
@@ -79,6 +83,7 @@ class MetricsTracker(TrainingObserver):
         moving_avg_window: int = 100,
         log_interval: int = 10,
         verbose: bool = True,
+        storage_backend: Optional[MetricsStorageInterface] = None,
     ):
         """
         Initialize MetricsTracker.
@@ -91,26 +96,31 @@ class MetricsTracker(TrainingObserver):
             verbose: Whether to print progress
         """
         super().__init__(name="MetricsTracker")
-        
+
         self.log_dir = Path(log_dir)
         self.log_dir.mkdir(parents=True, exist_ok=True)
-        
+
         self.experiment_name = experiment_name
         self.moving_avg_window = moving_avg_window
         self.log_interval = log_interval
         self.verbose = verbose
-        
+
+        # Optional metrics storage backend (e.g., Redis)
+        self.storage_backend = storage_backend
+
         # Initialize storage
         self._reset_storage()
-        
+
         # File paths
         self.metrics_file = self.log_dir / f"{experiment_name}_metrics.jsonl"
         self.summary_file = self.log_dir / f"{experiment_name}_summary.json"
-        
+
         if self.verbose:
             print(f"📊 MetricsTracker initialized")
             print(f"   Log directory: {self.log_dir}")
             print(f"   Moving average window: {moving_avg_window}")
+            if self.storage_backend:
+                print(f"   Using external metrics storage: {type(self.storage_backend).__name__}")
     
     def _reset_storage(self) -> None:
         """Reset all metric storage."""
@@ -163,53 +173,69 @@ class MetricsTracker(TrainingObserver):
     def on_step(self, metrics: StepMetrics) -> None:
         """Called after each training step."""
         timestamp = time.time() - self.start_time if self.start_time else 0
-        
+
         # Store loss
         self.train_losses.append(LossCurvePoint(
             step=metrics.step,
             loss=metrics.loss,
             timestamp=timestamp,
         ))
-        
+
         # Update moving average buffer
         self._loss_buffer.append(metrics.loss)
-        
+
         # Store learning rate
         self.learning_rates.append((metrics.step, metrics.learning_rate))
-        
+
         # Store gradient norm
         self.gradient_norms.append((metrics.step, metrics.grad_norm))
-        
+
         # Store perplexity
         self.train_perplexities.append((metrics.step, metrics.perplexity))
-        
+
         # Log to file periodically
         if metrics.step % self.log_interval == 0:
             self._log_step(metrics, timestamp)
+            # Also log to external storage if available
+            if self.storage_backend:
+                self.storage_backend.save_step_metrics({
+                    "type": "step",
+                    "timestamp": timestamp,
+                    "moving_avg_loss": self.get_moving_average(),
+                    **metrics.to_dict(),
+                })
     
     def on_validation(self, metrics: ValidationMetrics) -> None:
         """Called after validation."""
         timestamp = time.time() - self.start_time if self.start_time else 0
-        
+
         # Store validation loss
         self.val_losses.append(LossCurvePoint(
             step=metrics.step,
             loss=metrics.val_loss,
             timestamp=timestamp,
         ))
-        
+
         # Store validation perplexity
         self.val_perplexities.append((metrics.step, metrics.val_perplexity))
-        
+
         # Track best
         if metrics.val_loss < self.best_val_loss:
             self.best_val_loss = metrics.val_loss
             self.best_val_step = metrics.step
             if self.verbose:
                 print(f"   ⭐ New best val_loss: {metrics.val_loss:.4f}")
-        
+
         # Log to file
         self._log_validation(metrics, timestamp)
+        # Also log to external storage if available
+        if self.storage_backend:
+            self.storage_backend.save_validation_metrics({
+                "type": "validation",
+                "timestamp": timestamp,
+                "is_best": metrics.val_loss <= self.best_val_loss,
+                **metrics.to_dict(),
+            })
     
     def on_train_end(self, final_metrics: Dict[str, Any]) -> None:
         """Called when training completes."""

gptmed/observability/redis_metrics_storage.py

@@ -0,0 +1,26 @@
+"""
+Redis client for real-time metrics storage.
+Follows SOLID principles: single responsibility, dependency inversion, and interface segregation.
+"""
+
+import redis
+from typing import Any, Dict
+from gptmed.configs.configs import REDIS_CONFIG
+
+class MetricsStorageInterface:
+    """Interface for metrics storage backends."""
+    def save_step_metrics(self, metrics: Dict[str, Any]):
+        raise NotImplementedError
+    def save_validation_metrics(self, metrics: Dict[str, Any]):
+        raise NotImplementedError
+
+class RedisMetricsStorage(MetricsStorageInterface):
+    """Redis implementation for metrics storage."""
+    def __init__(self):
+        self.client = redis.Redis(**REDIS_CONFIG)
+    def save_step_metrics(self, metrics: Dict[str, Any]):
+        # Use a Redis list for steps
+        self.client.rpush("training:steps", str(metrics))
+    def save_validation_metrics(self, metrics: Dict[str, Any]):
+        # Use a Redis list for validation
+        self.client.rpush("training:validation", str(metrics))

{gptmed-0.4.0.dist-info → gptmed-0.5.0.dist-info}/METADATA

@@ -1,9 +1,8 @@
 Metadata-Version: 2.4
 Name: gptmed
-Version: 0.4.0
+Version: 0.5.0
 Summary: A lightweight GPT-based language model framework for training custom question-answering models on any domain
-Author-email: Sanjog Sigdel <sigdelsanjog@gmail.com>
-Maintainer-email: Sanjog Sigdel <sigdelsanjog@gmail.com>
+Author-email: Sanjog Sigdel <sigdelsanjog@gmail.com>, Sanjog Sigdel <sanjog.sigdel@ku.edu.np>
 License-Expression: MIT
 Project-URL: Homepage, https://github.com/sigdelsanjog/gptmed
 Project-URL: Documentation, https://github.com/sigdelsanjog/gptmed#readme

{gptmed-0.4.0.dist-info → gptmed-0.5.0.dist-info}/RECORD

@@ -1,8 +1,9 @@
 gptmed/__init__.py,sha256=lSCUt0jmB81dEG0UroQdrk8TMG9Hv-_a14nAvB6yYiQ,2725
-gptmed/api.py,sha256=k9a_1F2h__xgKnH2l0FaJqAqu-iTYt5tu_VfVO0UhrA,9806
+gptmed/api.py,sha256=BhR2I5CZNlYD34U4i85FQTUp8tLNyzhOrsT7monKpW0,10780
 gptmed/configs/__init__.py,sha256=yRa-zgPQ-OCzu8fvCrfWMG-CjF3dru3PZzknzm0oUaQ,23
-gptmed/configs/config_loader.py,sha256=3GQ1iCNpdJ5yALWXA3SPPHRkaUO-117vdArEL6u7sK8,6354
-gptmed/configs/train_config.py,sha256=KqfNBh9hdTTd_6gEAlrClU8sVFSlVDmZJOrf3cPwFe8,4657
+gptmed/configs/config_loader.py,sha256=NhIjmZ5ACcwZubdEcDq42PJuR03ulmZv_GYizhOIlPI,7466
+gptmed/configs/configs.py,sha256=704fWZS2OSRloEuhwlP6ezLly2paZfsdYCkJ1jfKuPE,293
+gptmed/configs/train_config.py,sha256=cuGE5o4N3TA65Sue8J3XrbmI5QKI7Ww3WeHd2M7yoHQ,4828
 gptmed/configs/training_config.yaml,sha256=EEZZa3kcsZr3g-_fKDPYZt4_NTpmS-3NvJrTYSWNc8g,2874
 gptmed/data/__init__.py,sha256=iAHeakB5pBAd7MkmarPPY0UKS9bTaO_winLZ23Y2O90,54
 gptmed/data/parsers/__init__.py,sha256=BgVzXuZgeE5DUCC4SzN7vflL40wQ4Q4_4DmJ1Y43_nw,211
@@ -25,7 +26,8 @@ gptmed/model/configs/model_config.py,sha256=wI-i2Dw_pTdIKCDe1pqLvP3ky3YedEy7DwZY
 gptmed/observability/__init__.py,sha256=AtGf0D8jEx2LGQ0Ro-Eh0SFDuA5ZjZkot7D1Y8j1jiM,1180
 gptmed/observability/base.py,sha256=Mi3F95bJ9Tw5scoSyw9AtKlcu9aG444G1UlycIIGCtI,10748
 gptmed/observability/callbacks.py,sha256=1b84_e86mfyt2EQGzf-6K2Sba3bZJt4I3bBJb52TAbA,13170
-gptmed/observability/metrics_tracker.py,sha256=Bs6tppQYG9AOb3rj2T1lhWKDyOw4R4ZG6nFGRiek8FQ,19441
+gptmed/observability/metrics_tracker.py,sha256=AEGcAjMTGMy--NIBxPEWfvwa3e5lvdkJEDNxHss6Dak,20493
+gptmed/observability/redis_metrics_storage.py,sha256=CYNRYB481-tGZ-BTMOSFlP-enn26dxg3nrUEni2hDXA,1014
 gptmed/services/__init__.py,sha256=FtM7NQ_S4VOfl2n6A6cLcOxG9-w7BK7DicQsUvOMmGE,369
 gptmed/services/device_manager.py,sha256=RSsu0RlsexCIO-p4eejOZAPLgpaVA0y9niTg8wf1luY,7513
 gptmed/services/training_service.py,sha256=cF3yYo8aZe7BfQ-paTN-l7EYs9h8L_JUyRhiI0GEP4E,16921
@@ -40,9 +42,9 @@ gptmed/training/utils.py,sha256=pJxCwneNr2STITIYwIDCxRzIICDFOxOMzK8DT7ck2oQ,5651
 gptmed/utils/__init__.py,sha256=XuMhIqOXF7mjnog_6Iky-hSbwvFb0iK42B4iDUpgi0U,44
 gptmed/utils/checkpoints.py,sha256=jPKJtO0YRZieGmpwqotgDkBzd__s_raDxS1kLpfjBJE,7113
 gptmed/utils/logging.py,sha256=7dJc1tayMxCBjFSDXe4r9ACUTpoPTTGsJ0UZMTqZIDY,5303
-gptmed-0.4.0.dist-info/licenses/LICENSE,sha256=v2spsd7N1pKFFh2G8wGP_45iwe5S0DYiJzG4im8Rupc,1066
-gptmed-0.4.0.dist-info/METADATA,sha256=kVsL6zbBoGw1jrlaDiPkBAr_D7YedPCSwZkjGCFz04c,13832
-gptmed-0.4.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-gptmed-0.4.0.dist-info/entry_points.txt,sha256=ATqOzTtPVdUiFX5ZSeo3n9JkUCqocUxEXTgy1CfNRZE,110
-gptmed-0.4.0.dist-info/top_level.txt,sha256=mhyEq3rG33t21ziJz5w3TPgx0RjPf4zXMNUx2JTiNmE,7
-gptmed-0.4.0.dist-info/RECORD,,
+gptmed-0.5.0.dist-info/licenses/LICENSE,sha256=v2spsd7N1pKFFh2G8wGP_45iwe5S0DYiJzG4im8Rupc,1066
+gptmed-0.5.0.dist-info/METADATA,sha256=EcZFQ_be5xb2uhu6x8HwReHloAEypxZUp2foN5Xn6VY,13816
+gptmed-0.5.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+gptmed-0.5.0.dist-info/entry_points.txt,sha256=ATqOzTtPVdUiFX5ZSeo3n9JkUCqocUxEXTgy1CfNRZE,110
+gptmed-0.5.0.dist-info/top_level.txt,sha256=mhyEq3rG33t21ziJz5w3TPgx0RjPf4zXMNUx2JTiNmE,7
+gptmed-0.5.0.dist-info/RECORD,,