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

gptmed/training/trainer.py

@@ -49,7 +49,7 @@ import torch.nn as nn
 from torch.utils.data import DataLoader
 import time
 from pathlib import Path
-from typing import Optional
+from typing import Optional, List
 
 from gptmed.model.architecture import GPTTransformer
 from gptmed.training.utils import (
@@ -62,6 +62,15 @@ from gptmed.training.utils import (
 from gptmed.utils.logging import MetricsLogger, log_training_step, log_validation
 from gptmed.utils.checkpoints import CheckpointManager
 
+# New observability imports
+from gptmed.observability.base import (
+    TrainingObserver,
+    ObserverManager,
+    StepMetrics,
+    ValidationMetrics,
+    GradientMetrics,
+)
+
 
 class Trainer:
     """
@@ -83,6 +92,7 @@ class Trainer:
         optimizer: torch.optim.Optimizer,
         config,  # TrainingConfig
         device: str = "cuda",
+        observers: List[TrainingObserver] = None,
     ):
         """
         Args:
@@ -92,6 +102,7 @@ class Trainer:
             optimizer: Optimizer (e.g., AdamW)
             config: TrainingConfig object
             device: Device to train on
+            observers: List of TrainingObserver instances for monitoring
         """
         self.model = model.to(device)
         self.train_loader = train_loader
@@ -100,7 +111,13 @@ class Trainer:
         self.config = config
         self.device = device
 
-        # Initialize utilities
+        # Initialize observability
+        self.observer_manager = ObserverManager()
+        if observers:
+            for obs in observers:
+                self.observer_manager.add(obs)
+
+        # Initialize utilities (keep for backward compatibility)
         self.logger = MetricsLogger(log_dir=config.log_dir, experiment_name="gpt_training")
 
         self.checkpoint_manager = CheckpointManager(
@@ -124,17 +141,32 @@ class Trainer:
         print(f"  Total steps: {self.total_steps}")
         print(f"  Steps per epoch: {steps_per_epoch}")
         print(f"  Num epochs: {config.num_epochs}")
+        print(f"  Observers: {len(self.observer_manager.observers)}")
+
+    def add_observer(self, observer: TrainingObserver) -> None:
+        """
+        Add an observer for training monitoring.
+        
+        Args:
+            observer: TrainingObserver instance
+        """
+        self.observer_manager.add(observer)
+        print(f"  Added observer: {observer.name}")
 
-    def train_step(self, batch: tuple) -> dict:
+    def train_step(self, batch: tuple, step: int = 0, lr: float = 0.0) -> dict:
         """
         Single training step.
 
         Args:
             batch: (input_ids, target_ids) tuple
+            step: Current global step (for observer metrics)
+            lr: Current learning rate (for observer metrics)
 
         Returns:
             Dictionary with step metrics
         """
+        step_start_time = time.time()
+        
         # Move batch to device
         input_ids, target_ids = batch
         input_ids = input_ids.to(self.device)
@@ -163,14 +195,34 @@ class Trainer:
         # Optimizer step
         self.optimizer.step()
 
-        # Return metrics
-        return {
+        # Calculate tokens per second
+        step_time = time.time() - step_start_time
+        tokens_per_sec = (batch_size * seq_len) / step_time if step_time > 0 else 0
+
+        # Create metrics dict (for backward compatibility)
+        metrics_dict = {
             "loss": loss.item(),
             "grad_norm": grad_norm,
             "batch_size": batch_size,
             "seq_len": seq_len,
+            "tokens_per_sec": tokens_per_sec,
         }
 
+        # Notify observers with StepMetrics
+        step_metrics = StepMetrics(
+            step=step,
+            loss=loss.item(),
+            learning_rate=lr,
+            grad_norm=grad_norm,
+            batch_size=batch_size,
+            seq_len=seq_len,
+            tokens_per_sec=tokens_per_sec,
+        )
+        self.observer_manager.notify_step(step_metrics)
+
+        # Return metrics
+        return metrics_dict
+
     def evaluate(self) -> dict:
         """
         Evaluate on validation set.
@@ -188,6 +240,14 @@ class Trainer:
 
         log_validation(self.global_step, val_loss, val_perplexity)
 
+        # Notify observers
+        val_metrics = ValidationMetrics(
+            step=self.global_step,
+            val_loss=val_loss,
+            val_perplexity=val_perplexity,
+        )
+        self.observer_manager.notify_validation(val_metrics)
+
         return {"val_loss": val_loss, "val_perplexity": val_perplexity}
 
     def train(self):
@@ -200,17 +260,37 @@ class Trainer:
         print("Starting Training")
         print("=" * 60)
 
+        # Notify observers of training start
+        train_config = {
+            "model_size": getattr(self.model.config, 'model_size', 'unknown'),
+            "device": self.device,
+            "batch_size": self.config.batch_size,
+            "learning_rate": self.config.learning_rate,
+            "num_epochs": self.config.num_epochs,
+            "max_steps": self.config.max_steps,
+            "total_steps": self.total_steps,
+            "warmup_steps": self.config.warmup_steps,
+            "grad_clip": self.config.grad_clip,
+            "weight_decay": self.config.weight_decay,
+        }
+        self.observer_manager.notify_train_start(train_config)
+
         self.model.train()
 
         # Training loop
         for epoch in range(self.config.num_epochs):
             self.current_epoch = epoch
 
+            # Notify observers of epoch start
+            self.observer_manager.notify_epoch_start(epoch)
+
             print(f"\n{'='*60}")
             print(f"Epoch {epoch + 1}/{self.config.num_epochs}")
             print(f"{'='*60}")
 
             epoch_start_time = time.time()
+            epoch_loss_sum = 0.0
+            epoch_steps = 0
 
             for batch_idx, batch in enumerate(self.train_loader):
                 step_start_time = time.time()
@@ -226,8 +306,12 @@ class Trainer:
                 )
                 set_learning_rate(self.optimizer, lr)
 
-                # Training step
-                metrics = self.train_step(batch)
+                # Training step (now with step and lr for observers)
+                metrics = self.train_step(batch, step=self.global_step, lr=lr)
+
+                # Track epoch loss
+                epoch_loss_sum += metrics["loss"]
+                epoch_steps += 1
 
                 # Calculate tokens per second
                 step_time = time.time() - step_start_time
@@ -243,7 +327,7 @@ class Trainer:
                         tokens_per_sec=tokens_per_sec,
                     )
 
-                # Log metrics
+                # Log metrics (legacy logger)
                 self.logger.log(
                     self.global_step,
                     {
@@ -269,7 +353,7 @@ class Trainer:
                         is_best = False
 
                     # Save checkpoint
-                    self.checkpoint_manager.save_checkpoint(
+                    checkpoint_path = self.checkpoint_manager.save_checkpoint(
                         model=self.model,
                         optimizer=self.optimizer,
                         step=self.global_step,
@@ -280,8 +364,19 @@ class Trainer:
                         is_best=is_best,
                     )
 
+                    # Notify observers of checkpoint
+                    if checkpoint_path:
+                        self.observer_manager.notify_checkpoint(self.global_step, str(checkpoint_path))
+
                     self.model.train()  # Back to training mode
 
+                    # Check for early stopping (if any observer requests it)
+                    for obs in self.observer_manager.observers:
+                        if hasattr(obs, 'should_stop') and obs.should_stop:
+                            print(f"\nEarly stopping requested by {obs.name}")
+                            self._finish_training()
+                            return
+
                 # Save checkpoint periodically
                 if self.global_step % self.config.save_interval == 0 and self.global_step > 0:
                     self.checkpoint_manager.save_checkpoint(
@@ -299,17 +394,36 @@ class Trainer:
                 # Check if reached max steps
                 if self.config.max_steps > 0 and self.global_step >= self.config.max_steps:
                     print(f"\nReached max_steps ({self.config.max_steps}). Stopping training.")
+                    self._finish_training()
                     return
 
-            # End of epoch
+            # End of epoch - notify observers
             epoch_time = time.time() - epoch_start_time
+            epoch_avg_loss = epoch_loss_sum / epoch_steps if epoch_steps > 0 else 0
+            self.observer_manager.notify_epoch_end(epoch, {
+                "train_loss": epoch_avg_loss,
+                "epoch_time": epoch_time,
+            })
             print(f"\nEpoch {epoch + 1} completed in {epoch_time:.2f}s")
 
+        self._finish_training()
+
+    def _finish_training(self):
+        """Finalize training and notify observers."""
         print("\n" + "=" * 60)
         print("Training Complete!")
         print("=" * 60)
         print(f"Best validation loss: {self.best_val_loss:.4f}")
 
+        # Notify observers of training end
+        final_metrics = {
+            "best_val_loss": self.best_val_loss,
+            "total_steps": self.global_step,
+            "final_epoch": self.current_epoch,
+            "final_checkpoint": str(self.checkpoint_manager.checkpoint_dir / "final_model.pt"),
+        }
+        self.observer_manager.notify_train_end(final_metrics)
+
     def resume_from_checkpoint(self, checkpoint_path: Optional[Path] = None):
         """
         Resume training from a checkpoint.

gptmed/utils/checkpoints.py

@@ -108,7 +108,7 @@ class CheckpointManager:
         # Save as best if applicable
         if is_best or val_loss < self.best_val_loss:
             self.best_val_loss = val_loss
-            best_path = self.checkpoint_dir / "best_model.pt"
+            best_path = self.checkpoint_dir / "final_model.pt"
             torch.save(checkpoint, best_path)
             print(f"Best model saved: {best_path} (val_loss: {val_loss:.4f})")
 

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gptmed
-Version: 0.3.4
+Version: 0.4.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>
@@ -10,7 +10,7 @@ Project-URL: Documentation, https://github.com/sigdelsanjog/gptmed#readme
 Project-URL: Repository, https://github.com/sigdelsanjog/gptmed
 Project-URL: Issues, https://github.com/sigdelsanjog/gptmed/issues
 Keywords: nlp,language-model,transformer,gpt,pytorch,qa,question-answering,training,deep-learning,custom-model
-Classifier: Development Status :: 3 - Alpha
+Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: Science/Research
 Classifier: Intended Audience :: Education
@@ -38,28 +38,64 @@ Requires-Dist: mypy>=0.950; extra == "dev"
 Provides-Extra: training
 Requires-Dist: tensorboard>=2.10.0; extra == "training"
 Requires-Dist: wandb>=0.13.0; extra == "training"
+Provides-Extra: visualization
+Requires-Dist: matplotlib>=3.5.0; extra == "visualization"
+Requires-Dist: seaborn>=0.12.0; extra == "visualization"
+Provides-Extra: xai
+Requires-Dist: matplotlib>=3.5.0; extra == "xai"
+Requires-Dist: seaborn>=0.12.0; extra == "xai"
+Requires-Dist: captum>=0.6.0; extra == "xai"
+Requires-Dist: scikit-learn>=1.0.0; extra == "xai"
 Dynamic: license-file
 
 # GptMed 🤖
 
-A lightweight GPT-based language model framework for training custom question-answering models on any domain. This package provides a transformer-based GPT architecture that you can train on your own Q&A datasets - whether it's casual conversations, technical support, education, or any other domain.
-
+[![Downloads](https://static.pepy.tech/badge/gptmed)](https://pepy.tech/project/gptmed)
+[![Downloads/Month](https://static.pepy.tech/badge/gptmed/month)](https://pepy.tech/project/gptmed)
 [![PyPI version](https://badge.fury.io/py/gptmed.svg)](https://badge.fury.io/py/gptmed)
 [![Python 3.8+](https://img.shields.io/badge/python-3.8+-blue.svg)](https://www.python.org/downloads/)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 
-## 📖 [Complete User Manual](USER_MANUAL.md) | [Quick Start](#quick-start)
+A lightweight GPT-based language model framework for training custom question-answering models on any domain. This package provides a transformer-based GPT architecture that you can train on your own Q&A datasets - whether it's casual conversations, technical support, education, or any other domain.
 
-> **New to GptMed?** Check out the [**step-by-step User Manual**](USER_MANUAL.md) for a complete guide on training your own model!
+## Citation
 
-## Features
+If you use this model in your research, please cite:
 
-- 🧠 **Custom GPT Architecture**: Lightweight transformer model for any Q&A domain
-- 🎯 **Domain-Agnostic**: Train on any question-answering dataset (casual chat, tech support, education, etc.)
-- ⚡ **Fast Inference**: Optimized for quick question answering
-- 🔧 **Flexible Training**: Easy to train on your own custom datasets
-- 📦 **Lightweight**: Small model size suitable for edge deployment
-- 🛠️ **Complete Toolkit**: Includes tokenizer training, model training, and inference utilities
+```bibtex
+@software{gptmed_2026,
+  author = {Sanjog Sigdel},
+  title = {GptMed: A custom causal question answering general purpose GPT Transformer Architecture Model},
+  year = {2026},
+  url = {https://github.com/sigdelsanjog/gptmed}
+}
+```
+
+## Table of Contents
+
+- [Installation](#installation)
+  - [From PyPI (Recommended)](#from-pypi-recommended)
+  - [From Source](#from-source)
+  - [With Optional Dependencies](#with-optional-dependencies)
+- [Quick Start](#quick-start)
+  - [Using the High-Level API](#using-the-high-level-api)
+  - [Inference (Generate Answers)](#inference-generate-answers)
+  - [Using Command Line](#using-command-line)
+  - [Training Your Own Model](#training-your-own-model)
+- [Model Architecture](#model-architecture)
+- [Configuration](#configuration)
+  - [Model Sizes](#model-sizes)
+  - [Training Configuration](#training-configuration)
+- [Observability](#observability)
+- [Project Structure](#project-structure)
+- [Requirements](#requirements)
+- [Documentation](#documentation)
+- [Performance](#performance)
+- [Examples](#examples)
+- [Contributing](#contributing)
+- [Citation](#citation)
+- [License](#license)
+- [Support](#support)
 
 ## Installation
 
@@ -83,15 +119,49 @@ pip install -e .
 # For development
 pip install gptmed[dev]
 
-# For training
+# For training with logging integrations
 pip install gptmed[training]
 
+# For visualization (loss curves, metrics plots)
+pip install gptmed[visualization]
+
+# For Explainable AI features
+pip install gptmed[xai]
+
 # All dependencies
-pip install gptmed[dev,training]
+pip install gptmed[dev,training,visualization,xai]
 ```
 
 ## Quick Start
 
+### Using the High-Level API
+
+The easiest way to use GptMed is through the high-level API:
+
+```python
+import gptmed
+
+# 1. Create a training configuration
+gptmed.create_config('my_config.yaml')
+
+# 2. Edit my_config.yaml with your settings (data paths, model size, etc.)
+
+# 3. Train the model
+gptmed.train_from_config('my_config.yaml')
+
+# 4. Generate answers
+answer = gptmed.generate(
+    checkpoint='model/checkpoints/best_model.pt',
+    tokenizer='tokenizer/my_tokenizer.model',
+    prompt='What is machine learning?',
+    max_length=150,
+    temperature=0.7
+)
+print(answer)
+```
+
+For a complete API testing workflow, see the [gptmed-api folder](https://github.com/sigdelsanjog/gptmed/tree/main/gptmed-api) with ready-to-run examples.
+
 ### Inference (Generate Answers)
 
 ```python
@@ -187,6 +257,50 @@ config = TrainingConfig(
 )
 ```
 
+## Observability
+
+**New in v0.4.0**: Built-in training monitoring with Observer Pattern architecture.
+
+### Features
+
+- 📊 **Loss Curves**: Track training/validation loss over time
+- 📈 **Metrics Tracking**: Perplexity, gradient norms, learning rates
+- 🔔 **Callbacks**: Console output, JSON logging, early stopping
+- 📁 **Export**: CSV export, matplotlib visualizations
+- 🔌 **Extensible**: Add custom observers for integrations (W&B, TensorBoard)
+
+### Quick Example
+
+```python
+from gptmed.observability import MetricsTracker, ConsoleCallback, EarlyStoppingCallback
+
+# Create observers
+tracker = MetricsTracker(output_dir='./metrics')
+console = ConsoleCallback(print_every=50)
+early_stop = EarlyStoppingCallback(patience=3)
+
+# Use with TrainingService (automatic)
+from gptmed.services import TrainingService
+service = TrainingService(config_path='config.yaml')
+service.train()  # Automatically creates MetricsTracker
+
+# Or use with Trainer directly
+trainer = Trainer(model, train_loader, config, observers=[tracker, console])
+trainer.train()
+```
+
+### Available Observers
+
+| Observer                | Description                                               |
+| ----------------------- | --------------------------------------------------------- |
+| `MetricsTracker`        | Comprehensive metrics collection with export capabilities |
+| `ConsoleCallback`       | Real-time console output with progress bars               |
+| `JSONLoggerCallback`    | Structured JSON logging for analysis                      |
+| `EarlyStoppingCallback` | Stop training when validation loss plateaus               |
+| `LRSchedulerCallback`   | Learning rate scheduling integration                      |
+
+See [XAI.md](XAI.md) for future Explainable AI features roadmap.
+
 ## Project Structure
 
 ```
@@ -201,10 +315,16 @@ gptmed/
 │   ├── train.py          # Training script
 │   ├── trainer.py        # Training loop
 │   └── dataset.py        # Data loading
+├── observability/         # Training monitoring & XAI (v0.4.0+)
+│   ├── base.py           # Observer pattern interfaces
+│   ├── metrics_tracker.py # Loss curves & metrics
+│   └── callbacks.py      # Console, JSON, early stopping
 ├── tokenizer/
 │   └── train_tokenizer.py # SentencePiece tokenizer
 ├── configs/
 │   └── train_config.py   # Training configurations
+├── services/
+│   └── training_service.py # High-level training orchestration
 └── utils/
     ├── checkpoints.py    # Model checkpointing
     └── logging.py        # Training logging
@@ -226,6 +346,7 @@ gptmed/
 
 - [User Manual](USER_MANUAL.md) - **Start here!** Complete training pipeline guide
 - [Architecture Guide](ARCHITECTURE_EXTENSION_GUIDE.md) - Understanding the model architecture
+- [XAI Roadmap](XAI.md) - Explainable AI features & implementation guide
 - [Deployment Guide](DEPLOYMENT_GUIDE.md) - Publishing to PyPI
 - [Changelog](CHANGELOG.md) - Version history
 
@@ -241,20 +362,53 @@ _Tested on GTX 1080 8GB_
 
 ## Examples
 
-### Medical Question Answering
+### Domain-Agnostic Usage
+
+GptMed works with **any domain** - just train on your own Q&A data:
 
 ```python
-# Example 1: Symptoms inquiry
-question = "What are the early signs of Alzheimer's disease?"
+# Technical Support Bot
+question = "How do I reset my WiFi router?"
 answer = generator.generate(question, temperature=0.7)
 
-# Example 2: Treatment information
-question = "How is Type 2 diabetes treated?"
+# Educational Assistant
+question = "Explain the water cycle in simple terms"
 answer = generator.generate(question, temperature=0.6)
 
-# Example 3: Medical definitions
-question = "What is hypertension?"
+# Customer Service
+question = "What is your return policy?"
 answer = generator.generate(question, temperature=0.5)
+
+# Medical Q&A (example domain)
+question = "What are the symptoms of flu?"
+answer = generator.generate(question, temperature=0.7)
+```
+
+### Training Observability (v0.4.0+)
+
+Monitor your training with built-in observability:
+
+```python
+from gptmed.observability import MetricsTracker, ConsoleCallback
+
+# Create observers
+tracker = MetricsTracker(output_dir='./metrics')
+console = ConsoleCallback(print_every=10)
+
+# Train with observability
+gptmed.train_from_config(
+    'my_config.yaml',
+    observers=[tracker, console]
+)
+
+# After training - get the report
+report = tracker.get_report()
+print(f"Final Loss: {report['final_loss']:.4f}")
+print(f"Total Steps: {report['total_steps']}")
+
+# Export metrics
+tracker.export_to_csv('training_metrics.csv')
+tracker.plot_loss_curves('loss_curves.png')  # Requires matplotlib
 ```
 
 ## Contributing
@@ -267,19 +421,6 @@ Contributions are welcome! Please feel free to submit a Pull Request.
 4. Push to the branch (`git push origin feature/AmazingFeature`)
 5. Open a Pull Request
 
-## Citation
-
-If you use this model in your research, please cite:
-
-```bibtex
-@software{llm_med_2026,
-  author = {Sanjog Sigdel},
-  title = {GptMed: A custom causal question answering general purpose GPT Transformer Architecture Model},
-  year = {2026},
-  url = {https://github.com/sigdelsanjog/gptmed}
-}
-```
-
 ## License
 
 This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
@@ -289,16 +430,12 @@ This project is licensed under the MIT License - see the [LICENSE](LICENSE) file
 - MedQuAD dataset creators
 - PyTorch team
 
-## Disclaimer
-
-⚠️ **Medical Disclaimer**: This model is for research and educational purposes only. It should NOT be used for actual medical diagnosis or treatment decisions. Always consult qualified healthcare professionals for medical advice.
-
 ## Support
 
-- � **[User Manual](USER_MANUAL.md)** - Complete step-by-step training guide
-- �📫 Issues: [GitHub Issues](https://github.com/sigdelsanjog/gptmed/issues)
+- 📫 [User Manual](USER_MANUAL.md)\*\* - Complete step-by-step training guide
+- 📫 Issues: [GitHub Issues](https://github.com/sigdelsanjog/gptmed/issues)
 - 💬 Discussions: [GitHub Discussions](https://github.com/sigdelsanjog/gptmed/discussions)
-- 📧 Email: sanjog.sigdel@ku.edu.np
+- 📧 Email: sigdelsanjog@gmail.com | sanjog.sigdel@ku.edu.np
 
 ## Changelog
 
@@ -306,4 +443,4 @@ See [CHANGELOG.md](CHANGELOG.md) for version history.
 
 ---
 
-Made with ❤️ for learning purpose
+#### Made with ❤️ from Nepal

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

@@ -1,4 +1,4 @@
-gptmed/__init__.py,sha256=mwzeW2Qc6j1z5f6HOvZ_BNOnFSncWEK2KEkdqq91yYY,1676
+gptmed/__init__.py,sha256=lSCUt0jmB81dEG0UroQdrk8TMG9Hv-_a14nAvB6yYiQ,2725
 gptmed/api.py,sha256=k9a_1F2h__xgKnH2l0FaJqAqu-iTYt5tu_VfVO0UhrA,9806
 gptmed/configs/__init__.py,sha256=yRa-zgPQ-OCzu8fvCrfWMG-CjF3dru3PZzknzm0oUaQ,23
 gptmed/configs/config_loader.py,sha256=3GQ1iCNpdJ5yALWXA3SPPHRkaUO-117vdArEL6u7sK8,6354
@@ -13,7 +13,7 @@ gptmed/inference/decoding_utils.py,sha256=zTDZYdl2jcGwSrcINXMw-5uoYuF4A9TSushhPx
 gptmed/inference/generation_config.py,sha256=hpPyZUk1K6qGSBAoQx3Jm0_ZrrYld77ACxbIlCCCcVU,2813
 gptmed/inference/generator.py,sha256=6JFmDPQF4btau_Gp5pfk8a5G0Iyg6QsB9Y8Oo4ygH-4,7884
 gptmed/inference/sampling.py,sha256=B6fRlJafypuBMKJ0rTbsk6k8KXloXiIvroi7rN6ekBA,7947
-gptmed/model/__init__.py,sha256=brAE8ZhCDeQlU13YSqiBZTrTE8SHL_3bvFhZMzZnh3A,191
+gptmed/model/__init__.py,sha256=j5-KIrO_-913r1exnNzrbuuhuVmRJMmssRWrQjj5rdw,199
 gptmed/model/architecture/__init__.py,sha256=9MpSAYwwZY-t1vBLIupuRtLD7CaOLJRENMh3zKx3M-4,970
 gptmed/model/architecture/attention.py,sha256=Qk1eGl9glKWQbhcXJWmFkO5U3VHBq7OrsjVG0tPmgnY,6420
 gptmed/model/architecture/decoder_block.py,sha256=n-Uo09TDcirKeWTWTNumldGOrx-b2Elb25lbF6cTYwg,3879
@@ -22,20 +22,27 @@ gptmed/model/architecture/feedforward.py,sha256=uJ5QOlWX0ritKDQLUE7GPmMojelR9-sT
 gptmed/model/architecture/transformer.py,sha256=H1njPoy0Uam59JbA24C0olEDwPfhh3ev4HsUFRIC_0Y,6626
 gptmed/model/configs/__init__.py,sha256=LDCWhlCDOU7490wcfSId_jXBPfQrtYQEw8FoD67rqBs,275
 gptmed/model/configs/model_config.py,sha256=wI-i2Dw_pTdIKCDe1pqLvP3ky3YedEy7DwZYN5lwmKE,4673
+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/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
 gptmed/tokenizer/__init__.py,sha256=KhLAHPmQyoWhnKDenyIJRxgFflKI7xklip28j4cKfKw,157
 gptmed/tokenizer/tokenize_data.py,sha256=KgMtMfaz_RtOhN_CrvC267k9ujxRdO89rToVJ6nzdwg,9139
 gptmed/tokenizer/train_tokenizer.py,sha256=f0Hucyft9e8LU2RtpTqg8h_0SpOC_oMABl0_me-wfL8,7068
 gptmed/training/__init__.py,sha256=6G0_gdlwBnQBG8wZlTm2NtgkXZJcXRfLMDQ2iu6O3U4,24
 gptmed/training/dataset.py,sha256=QbNVTN4Og5gqMAV2ckjRX8W_k9aUc9IZJDcu0u9U8t0,5347
 gptmed/training/train.py,sha256=sp4-1WpEXUTA9V0GUYAgSvMd2aaPkt1aq2PepQFLXD8,8142
-gptmed/training/trainer.py,sha256=asOKT9d7lvmtEm5PIcMHg8iUdulNJpobNFNwOjdkeEg,10728
+gptmed/training/trainer.py,sha256=F1K9pkDMU-TbvmGGQ3JjRek4ZoFI6GHIFFEg7yYfIGM,15206
 gptmed/training/utils.py,sha256=pJxCwneNr2STITIYwIDCxRzIICDFOxOMzK8DT7ck2oQ,5651
 gptmed/utils/__init__.py,sha256=XuMhIqOXF7mjnog_6Iky-hSbwvFb0iK42B4iDUpgi0U,44
-gptmed/utils/checkpoints.py,sha256=L4q1-_4GbHCoD7QuEKYeQ-xXDTF-6sqZOxKQ_LT8YmQ,7112
+gptmed/utils/checkpoints.py,sha256=jPKJtO0YRZieGmpwqotgDkBzd__s_raDxS1kLpfjBJE,7113
 gptmed/utils/logging.py,sha256=7dJc1tayMxCBjFSDXe4r9ACUTpoPTTGsJ0UZMTqZIDY,5303
-gptmed-0.3.4.dist-info/licenses/LICENSE,sha256=v2spsd7N1pKFFh2G8wGP_45iwe5S0DYiJzG4im8Rupc,1066
-gptmed-0.3.4.dist-info/METADATA,sha256=G86yfOKlnK4YfNvC6HAAY_z2Z_rhWoSF2_3508mebKA,9382
-gptmed-0.3.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-gptmed-0.3.4.dist-info/entry_points.txt,sha256=ATqOzTtPVdUiFX5ZSeo3n9JkUCqocUxEXTgy1CfNRZE,110
-gptmed-0.3.4.dist-info/top_level.txt,sha256=mhyEq3rG33t21ziJz5w3TPgx0RjPf4zXMNUx2JTiNmE,7
-gptmed-0.3.4.dist-info/RECORD,,
+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,,