gptmed 0.0.1__py3-none-any.whl → 0.1.2__py3-none-any.whl

gptmed/__init__.py

@@ -1,21 +1,32 @@
 """
-llm-med: A lightweight medical question-answering language model
+GptMed: A lightweight GPT-based language model framework
 
-This package provides a GPT-based transformer architecture trained on the MedQuAD dataset
-for medical domain question answering.
+A domain-agnostic framework for training custom question-answering models.
+Train your own GPT model on any Q&A dataset - medical, technical support,
+education, or any other domain.
 
-Main Components:
-- model: GPT transformer architecture
-- inference: Text generation and sampling
-- training: Training loop and utilities
-- tokenizer: SentencePiece tokenizer
-- configs: Configuration management
-- utils: Utility functions
+Quick Start:
+    >>> import gptmed
+    >>> 
+    >>> # 1. Create a config file
+    >>> gptmed.create_config('my_config.yaml')
+    >>> 
+    >>> # 2. Edit my_config.yaml with your settings
+    >>> 
+    >>> # 3. Train your model
+    >>> results = gptmed.train_from_config('my_config.yaml')
+    >>> 
+    >>> # 4. Generate answers
+    >>> answer = gptmed.generate(
+    ...     checkpoint=results['best_checkpoint'],
+    ...     tokenizer='tokenizer/my_tokenizer.model',
+    ...     prompt='Your question here?'
+    ... )
 
-Example:
-    >>> from llm_med.model.architecture import GPTTransformer
-    >>> from llm_med.model.configs.model_config import get_small_config
-    >>> from llm_med.inference.generator import TextGenerator
+Advanced Usage:
+    >>> from gptmed.model.architecture import GPTTransformer
+    >>> from gptmed.model.configs.model_config import get_small_config
+    >>> from gptmed.inference.generator import TextGenerator
     >>> 
     >>> config = get_small_config()
     >>> model = GPTTransformer(config)
@@ -25,11 +36,23 @@ __version__ = "0.2.0"
 __author__ = "Sanjog Sigdel"
 __email__ = "sigdelsanjog@gmail.com"
 
+# High-level API - Main user interface
+from gptmed.api import (
+    create_config,
+    train_from_config,
+    generate,
+)
+
 # Expose main components at package level for convenience
-from llm_med.model.architecture import GPTTransformer
-from llm_med.model.configs.model_config import ModelConfig, get_small_config, get_tiny_config
+from gptmed.model.architecture import GPTTransformer
+from gptmed.model.configs.model_config import ModelConfig, get_small_config, get_tiny_config
 
 __all__ = [
+    # Simple API
+    "create_config",
+    "train_from_config", 
+    "generate",
+    # Advanced API
     "GPTTransformer",
     "ModelConfig",
     "get_small_config",

gptmed/api.py

@@ -0,0 +1,352 @@
+"""
+High-Level API for GptMed
+
+Simple, user-friendly functions to train and use GPT models.
+This is the main interface users should use.
+
+Example:
+    >>> import gptmed
+    >>> 
+    >>> # Create a config file
+    >>> gptmed.create_config('my_config.yaml')
+    >>> 
+    >>> # Edit my_config.yaml with your settings
+    >>> 
+    >>> # Train the model
+    >>> gptmed.train_from_config('my_config.yaml')
+    >>> 
+    >>> # Generate text
+    >>> answer = gptmed.generate(
+    ...     checkpoint='model/checkpoints/best_model.pt',
+    ...     prompt='Your question?',
+    ...     tokenizer='tokenizer/my_tokenizer.model'
+    ... )
+"""
+
+import torch
+from pathlib import Path
+from typing import Optional, Dict, Any
+
+from gptmed.configs.config_loader import (
+    load_yaml_config,
+    validate_config,
+    config_to_args,
+    create_default_config_file
+)
+from gptmed.model.architecture import GPTTransformer
+from gptmed.model.configs.model_config import get_tiny_config, get_small_config, get_medium_config
+from gptmed.configs.train_config import TrainingConfig
+from gptmed.training.dataset import create_dataloaders
+from gptmed.training.trainer import Trainer
+from gptmed.inference.generator import TextGenerator
+
+
+def create_config(output_path: str = 'training_config.yaml') -> None:
+    """
+    Create a default training configuration file.
+    
+    This creates a YAML file that you can edit with your training settings.
+    
+    Args:
+        output_path: Where to save the config file (default: 'training_config.yaml')
+    
+    Example:
+        >>> import gptmed
+        >>> gptmed.create_config('my_training_config.yaml')
+        >>> # Now edit my_training_config.yaml with your settings
+    """
+    create_default_config_file(output_path)
+
+
+def train_from_config(config_path: str, verbose: bool = True) -> Dict[str, Any]:
+    """
+    Train a GPT model using a YAML configuration file.
+    
+    This is the simplest way to train a model. Just create a config file
+    with create_config(), edit it with your settings, and pass it here.
+    
+    Args:
+        config_path: Path to YAML configuration file
+        verbose: Whether to print training progress (default: True)
+    
+    Returns:
+        Dictionary with training results:
+            - best_checkpoint: Path to best model checkpoint
+            - final_val_loss: Final validation loss
+            - total_epochs: Number of epochs trained
+    
+    Example:
+        >>> import gptmed
+        >>> 
+        >>> # Create and edit config file
+        >>> gptmed.create_config('config.yaml')
+        >>> # ... edit config.yaml ...
+        >>> 
+        >>> # Train the model
+        >>> results = gptmed.train_from_config('config.yaml')
+        >>> print(f"Best model: {results['best_checkpoint']}")
+    
+    Raises:
+        FileNotFoundError: If config file or data files don't exist
+        ValueError: If configuration is invalid
+    """
+    if verbose:
+        print("=" * 60)
+        print("GptMed Training from Configuration File")
+        print("=" * 60)
+    
+    # Load and validate config
+    if verbose:
+        print(f"\n📄 Loading configuration from: {config_path}")
+    config = load_yaml_config(config_path)
+    
+    if verbose:
+        print("✓ Configuration loaded")
+        print("\n🔍 Validating configuration...")
+    validate_config(config)
+    
+    if verbose:
+        print("✓ Configuration valid")
+    
+    # Convert to arguments
+    args = config_to_args(config)
+    
+    # Import here to avoid circular imports
+    import random
+    import numpy as np
+    
+    # Set random seed
+    def set_seed(seed: int):
+        random.seed(seed)
+        np.random.seed(seed)
+        torch.manual_seed(seed)
+        if torch.cuda.is_available():
+            torch.cuda.manual_seed(seed)
+            torch.cuda.manual_seed_all(seed)
+        torch.backends.cudnn.deterministic = True
+        torch.backends.cudnn.benchmark = False
+    
+    if verbose:
+        print(f"\n🎲 Setting random seed: {args['seed']}")
+    set_seed(args['seed'])
+    
+    # Check device
+    device = args['device']
+    if device == 'cuda' and not torch.cuda.is_available():
+        if verbose:
+            print("⚠️  CUDA not available, using CPU")
+        device = 'cpu'
+    
+    # Load model config
+    if verbose:
+        print(f"\n🧠 Creating model: {args['model_size']}")
+    
+    if args['model_size'] == 'tiny':
+        model_config = get_tiny_config()
+    elif args['model_size'] == 'small':
+        model_config = get_small_config()
+    elif args['model_size'] == 'medium':
+        model_config = get_medium_config()
+    else:
+        raise ValueError(f"Unknown model size: {args['model_size']}")
+    
+    # Create model
+    model = GPTTransformer(model_config)
+    total_params = sum(p.numel() for p in model.parameters() if p.requires_grad)
+    
+    if verbose:
+        print(f"  Model size: {args['model_size']}")
+        print(f"  Parameters: {total_params:,}")
+        print(f"  Memory: ~{total_params * 4 / 1024 / 1024:.2f} MB")
+    
+    # Load data
+    if verbose:
+        print(f"\n📊 Loading data...")
+        print(f"  Train: {args['train_data']}")
+        print(f"  Val: {args['val_data']}")
+    
+    train_loader, val_loader = create_dataloaders(
+        train_path=Path(args['train_data']),
+        val_path=Path(args['val_data']),
+        batch_size=args['batch_size'],
+        num_workers=0,
+    )
+    
+    if verbose:
+        print(f"  Train batches: {len(train_loader)}")
+        print(f"  Val batches: {len(val_loader)}")
+    
+    # Create training config
+    train_config = TrainingConfig(
+        batch_size=args['batch_size'],
+        learning_rate=args['learning_rate'],
+        num_epochs=args['num_epochs'],
+        warmup_steps=args['warmup_steps'],
+        grad_clip=args['grad_clip'],
+        weight_decay=args['weight_decay'],
+        betas=args['betas'],
+        eps=args['eps'],
+        max_steps=args['max_steps'],
+        save_every=args['save_every'],
+        eval_every=args['eval_every'],
+        log_every=args['log_every'],
+        keep_last_n=args['keep_last_n'],
+        train_data_path=args['train_data'],
+        val_data_path=args['val_data'],
+        checkpoint_dir=args['checkpoint_dir'],
+        log_dir=args['log_dir'],
+        device=device,
+        seed=args['seed'],
+    )
+    
+    # Create optimizer
+    if verbose:
+        print(f"\n⚙️  Setting up optimizer...")
+        print(f"  Learning rate: {args['learning_rate']}")
+        print(f"  Weight decay: {args['weight_decay']}")
+    
+    optimizer = torch.optim.AdamW(
+        model.parameters(),
+        lr=args['learning_rate'],
+        betas=args['betas'],
+        eps=args['eps'],
+        weight_decay=args['weight_decay'],
+    )
+    
+    # Create trainer
+    if verbose:
+        print(f"\n🎯 Initializing trainer...")
+    
+    trainer = Trainer(
+        model=model,
+        train_loader=train_loader,
+        val_loader=val_loader,
+        optimizer=optimizer,
+        config=train_config,
+        device=device,
+    )
+    
+    # Resume if requested
+    if args['resume_from'] is not None:
+        if verbose:
+            print(f"\n📥 Resuming from checkpoint: {args['resume_from']}")
+        trainer.resume_from_checkpoint(Path(args['resume_from']))
+    
+    # Start training
+    if verbose:
+        print(f"\n{'='*60}")
+        print("🚀 Starting Training!")
+        print(f"{'='*60}\n")
+    
+    try:
+        trainer.train()
+    except KeyboardInterrupt:
+        if verbose:
+            print("\n\n⏸️  Training interrupted by user")
+            print("💾 Saving checkpoint...")
+        trainer.checkpoint_manager.save_checkpoint(
+            model=model,
+            optimizer=optimizer,
+            step=trainer.global_step,
+            epoch=trainer.current_epoch,
+            val_loss=trainer.best_val_loss,
+            model_config=model_config.to_dict(),
+            train_config=train_config.to_dict(),
+        )
+        if verbose:
+            print("✓ Checkpoint saved. Resume with resume_from in config.")
+    
+    # Return results
+    best_checkpoint = Path(train_config.checkpoint_dir) / "best_model.pt"
+    
+    results = {
+        'best_checkpoint': str(best_checkpoint),
+        'final_val_loss': trainer.best_val_loss,
+        'total_epochs': trainer.current_epoch,
+        'checkpoint_dir': train_config.checkpoint_dir,
+        'log_dir': train_config.log_dir,
+    }
+    
+    if verbose:
+        print(f"\n{'='*60}")
+        print("✅ Training Complete!")
+        print(f"{'='*60}")
+        print(f"\n📁 Results:")
+        print(f"  Best checkpoint: {results['best_checkpoint']}")
+        print(f"  Best val loss: {results['final_val_loss']:.4f}")
+        print(f"  Total epochs: {results['total_epochs']}")
+        print(f"  Logs: {results['log_dir']}")
+    
+    return results
+
+
+def generate(
+    checkpoint: str,
+    tokenizer: str,
+    prompt: str,
+    max_length: int = 100,
+    temperature: float = 0.7,
+    top_k: int = 50,
+    top_p: float = 0.9,
+    device: str = "cuda"
+) -> str:
+    """
+    Generate text using a trained model.
+    
+    Args:
+        checkpoint: Path to model checkpoint (.pt file)
+        tokenizer: Path to tokenizer model (.model file)
+        prompt: Input text/question
+        max_length: Maximum tokens to generate
+        temperature: Sampling temperature (higher = more random)
+        top_k: Top-k sampling parameter
+        top_p: Nucleus sampling parameter
+        device: Device to use ('cuda' or 'cpu')
+    
+    Returns:
+        Generated text
+    
+    Example:
+        >>> import gptmed
+        >>> 
+        >>> 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)
+    """
+    # Load checkpoint
+    checkpoint_path = Path(checkpoint)
+    if not checkpoint_path.exists():
+        raise FileNotFoundError(f"Checkpoint not found: {checkpoint}")
+    
+    checkpoint_data = torch.load(checkpoint_path, map_location=device)
+    
+    # Load model config
+    from gptmed.model.configs.model_config import ModelConfig
+    model_config = ModelConfig.from_dict(checkpoint_data['model_config'])
+    
+    # Create and load model
+    model = GPTTransformer(model_config)
+    model.load_state_dict(checkpoint_data['model_state_dict'])
+    
+    # Create generator
+    generator = TextGenerator(
+        model=model,
+        tokenizer_path=tokenizer,
+        device=device
+    )
+    
+    # Generate
+    output = generator.generate(
+        prompt=prompt,
+        max_length=max_length,
+        temperature=temperature,
+        top_k=top_k,
+        top_p=top_p
+    )
+    
+    return output

gptmed/configs/config_loader.py

@@ -0,0 +1,191 @@
+"""
+Configuration File Loader
+
+Load training configuration from YAML file for easy user customization.
+"""
+
+import yaml
+from pathlib import Path
+from typing import Dict, Any, Optional
+from dataclasses import dataclass
+
+
+def load_yaml_config(config_path: str) -> Dict[str, Any]:
+    """
+    Load configuration from YAML file.
+    
+    Args:
+        config_path: Path to YAML configuration file
+        
+    Returns:
+        Dictionary with configuration parameters
+        
+    Raises:
+        FileNotFoundError: If config file doesn't exist
+        yaml.YAMLError: If YAML parsing fails
+    """
+    config_path = Path(config_path)
+    
+    if not config_path.exists():
+        raise FileNotFoundError(f"Configuration file not found: {config_path}")
+    
+    with open(config_path, 'r') as f:
+        try:
+            config = yaml.safe_load(f)
+        except yaml.YAMLError as e:
+            raise ValueError(f"Error parsing YAML configuration: {e}")
+    
+    return config
+
+
+def validate_config(config: Dict[str, Any]) -> None:
+    """
+    Validate configuration parameters.
+    
+    Args:
+        config: Configuration dictionary
+        
+    Raises:
+        ValueError: If configuration is invalid
+    """
+    # Check required sections
+    required_sections = ['model', 'data', 'training']
+    for section in required_sections:
+        if section not in config:
+            raise ValueError(f"Missing required section: {section}")
+    
+    # Validate model size
+    valid_sizes = ['tiny', 'small', 'medium']
+    if config['model']['size'] not in valid_sizes:
+        raise ValueError(f"Invalid model size: {config['model']['size']}. "
+                        f"Must be one of {valid_sizes}")
+    
+    # Validate data paths
+    train_path = Path(config['data']['train_data'])
+    val_path = Path(config['data']['val_data'])
+    
+    if not train_path.exists():
+        raise FileNotFoundError(f"Training data not found: {train_path}")
+    if not val_path.exists():
+        raise FileNotFoundError(f"Validation data not found: {val_path}")
+    
+    # Validate training parameters
+    if config['training']['num_epochs'] <= 0:
+        raise ValueError("num_epochs must be positive")
+    if config['training']['batch_size'] <= 0:
+        raise ValueError("batch_size must be positive")
+    if config['training']['learning_rate'] <= 0:
+        raise ValueError("learning_rate must be positive")
+
+
+def config_to_args(config: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Convert YAML config to training arguments.
+    
+    Args:
+        config: Configuration dictionary from YAML
+        
+    Returns:
+        Flattened dictionary suitable for training
+    """
+    args = {
+        # Model
+        'model_size': config['model']['size'],
+        
+        # Data
+        'train_data': config['data']['train_data'],
+        'val_data': config['data']['val_data'],
+        
+        # Training
+        'num_epochs': config['training']['num_epochs'],
+        'batch_size': config['training']['batch_size'],
+        'learning_rate': config['training']['learning_rate'],
+        'weight_decay': config['training']['weight_decay'],
+        'grad_clip': config['training']['grad_clip'],
+        'warmup_steps': config['training']['warmup_steps'],
+        
+        # Optimizer
+        'betas': tuple(config['optimizer']['betas']),
+        'eps': config['optimizer']['eps'],
+        
+        # Checkpointing
+        'checkpoint_dir': config['checkpointing']['checkpoint_dir'],
+        'save_every': config['checkpointing']['save_every'],
+        'keep_last_n': config['checkpointing']['keep_last_n'],
+        
+        # Logging
+        'log_dir': config['logging']['log_dir'],
+        'eval_every': config['logging']['eval_every'],
+        'log_every': config['logging']['log_every'],
+        
+        # Device
+        'device': config['device']['device'],
+        'seed': config['device']['seed'],
+        
+        # Advanced
+        '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),
+    }
+    
+    return args
+
+
+def create_default_config_file(output_path: str = 'training_config.yaml') -> None:
+    """
+    Create a default configuration file template.
+    
+    Args:
+        output_path: Path where to save the config file
+    """
+    default_config = {
+        'model': {
+            'size': 'small'
+        },
+        'data': {
+            'train_data': './data/tokenized/train.npy',
+            'val_data': './data/tokenized/val.npy'
+        },
+        'training': {
+            'num_epochs': 10,
+            'batch_size': 16,
+            'learning_rate': 0.0003,
+            'weight_decay': 0.01,
+            'grad_clip': 1.0,
+            'warmup_steps': 100
+        },
+        'optimizer': {
+            'betas': [0.9, 0.95],
+            'eps': 1.0e-8
+        },
+        'checkpointing': {
+            'checkpoint_dir': './model/checkpoints',
+            'save_every': 1,
+            'keep_last_n': 3
+        },
+        'logging': {
+            'log_dir': './logs',
+            'eval_every': 100,
+            'log_every': 10
+        },
+        'device': {
+            'device': 'cuda',
+            'seed': 42
+        },
+        'advanced': {
+            'max_steps': -1,
+            'resume_from': None,
+            'quick_test': False
+        }
+    }
+    
+    output_path = Path(output_path)
+    
+    # Create directory if it doesn't exist
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    
+    with open(output_path, 'w') as f:
+        yaml.dump(default_config, f, default_flow_style=False, sort_keys=False)
+    
+    print(f"✓ Created default configuration file: {output_path}")
+    print(f"  Edit this file and then run: gptmed.train_from_config('{output_path}')")

gptmed/configs/training_config.yaml

@@ -0,0 +1,64 @@
+# GptMed Training Configuration File
+# Edit these parameters for your training needs
+
+# ============================================================
+# MODEL CONFIGURATION
+# ============================================================
+model:
+  size: small                    # Options: tiny, small, medium
+                                 # tiny: ~2M params (testing)
+                                 # small: ~10M params (recommended)
+                                 # medium: ~50M params (high quality)
+
+# ============================================================
+# DATA PATHS
+# ============================================================
+data:
+  train_data: ./data/tokenized/train.npy    # Path to training data (.npy file)
+  val_data: ./data/tokenized/val.npy        # Path to validation data (.npy file)
+
+# ============================================================
+# TRAINING HYPERPARAMETERS
+# ============================================================
+training:
+  num_epochs: 10                 # Number of training epochs
+  batch_size: 16                 # Batch size (reduce if OOM: 8, 4)
+  learning_rate: 0.0003          # Learning rate (3e-4)
+  weight_decay: 0.01             # Weight decay for regularization
+  grad_clip: 1.0                 # Gradient clipping value
+  warmup_steps: 100              # Learning rate warmup steps
+  
+# ============================================================
+# OPTIMIZER SETTINGS
+# ============================================================
+optimizer:
+  betas: [0.9, 0.95]             # Adam beta parameters
+  eps: 1.0e-8                    # Adam epsilon
+
+# ============================================================
+# CHECKPOINTING & LOGGING
+# ============================================================
+checkpointing:
+  checkpoint_dir: ./model/checkpoints    # Directory to save checkpoints
+  save_every: 1                          # Save checkpoint every N epochs
+  keep_last_n: 3                         # Keep last N checkpoints
+  
+logging:
+  log_dir: ./logs                # Directory for training logs
+  eval_every: 100                # Evaluate every N steps
+  log_every: 10                  # Log metrics every N steps
+
+# ============================================================
+# DEVICE & PERFORMANCE
+# ============================================================
+device:
+  device: cuda                   # Options: cuda, cpu
+  seed: 42                       # Random seed for reproducibility
+
+# ============================================================
+# ADVANCED OPTIONS (optional)
+# ============================================================
+advanced:
+  max_steps: -1                  # Max training steps (-1 = use num_epochs)
+  resume_from: null              # Path to checkpoint to resume from (null = start fresh)
+  quick_test: false              # Use quick test config for debugging

gptmed/inference/generator.py

@@ -38,11 +38,11 @@ import sentencepiece as spm
 from pathlib import Path
 from typing import List, Optional
 
-from llm_med.model.architecture import GPTTransformer
-from llm_med.model.configs.model_config import ModelConfig
-from llm_med.inference.generation_config import GenerationConfig
-from llm_med.inference.sampling import sample_next_token
-from llm_med.inference.decoding_utils import (
+from gptmed.model.architecture import GPTTransformer
+from gptmed.model.configs.model_config import ModelConfig
+from gptmed.inference.generation_config import GenerationConfig
+from gptmed.inference.sampling import sample_next_token
+from gptmed.inference.decoding_utils import (
     apply_repetition_penalty,
     block_ngram_repeats,
     should_stop_generation,

gptmed/model/__init__.py

@@ -4,6 +4,6 @@ MedLLM Model Package
 This package contains the GPT-based transformer architecture for medical QA.
 """
 
-from llm_med.model.architecture import GPTTransformer
+from gptmed.model.architecture import GPTTransformer
 
 __all__ = ["GPTTransformer"]

gptmed/model/configs/__init__.py

@@ -2,7 +2,7 @@
 Model configuration module
 """
 
-from llm_med.model.configs.model_config import (
+from gptmed.model.configs.model_config import (
     ModelConfig,
     get_tiny_config,
     get_small_config,

gptmed/tokenizer/__init__.py

@@ -2,6 +2,6 @@
 Tokenizer module for MedLLM
 """
 
-from llm_med.tokenizer.train_tokenizer import train_sentencepiece_tokenizer
+from gptmed.tokenizer.train_tokenizer import train_sentencepiece_tokenizer
 
 __all__ = ["train_sentencepiece_tokenizer"]

gptmed/training/train.py

@@ -46,11 +46,11 @@ import sys
 # Add parent directory to path for imports
 sys.path.insert(0, str(Path(__file__).parent.parent))
 
-from llm_med.model.architecture import GPTTransformer
-from llm_med.model.configs.model_config import get_small_config, get_tiny_config
-from llm_med.configs.train_config import get_default_config, get_quick_test_config
-from llm_med.training.dataset import create_dataloaders
-from llm_med.training.trainer import Trainer
+from gptmed.model.architecture import GPTTransformer
+from gptmed.model.configs.model_config import get_small_config, get_tiny_config
+from gptmed.configs.train_config import get_default_config, get_quick_test_config
+from gptmed.training.dataset import create_dataloaders
+from gptmed.training.trainer import Trainer
 
 
 def set_seed(seed: int):
@@ -83,7 +83,7 @@ def count_parameters(model):
 
 
 def main():
-    parser = argparse.ArgumentParser(description="Train GPT model on MedQuAD")
+    parser = argparse.ArgumentParser(description="Train your GPT model")
 
     # Model config
     parser.add_argument(
@@ -136,7 +136,7 @@ def main():
     args = parser.parse_args()
 
     print("=" * 60)
-    print("GPT Training - MedQuAD")
+    print("GPT Training Script")
     print("=" * 60)
 
     # Check CUDA availability
@@ -170,7 +170,6 @@ def main():
         print("Using quick test config (fast debugging)")
     else:
         train_config = get_default_config()
-
     # Override with command-line args
     if args.batch_size is not None:
         train_config.batch_size = args.batch_size

gptmed/training/trainer.py

@@ -51,16 +51,16 @@ import time
 from pathlib import Path
 from typing import Optional
 
-from llm_med.model.architecture import GPTTransformer
-from llm_med.training.utils import (
+from gptmed.model.architecture import GPTTransformer
+from gptmed.training.utils import (
     clip_grad_norm,
     get_lr_with_warmup,
     set_learning_rate,
     estimate_loss_dataloader,
     compute_perplexity,
 )
-from llm_med.utils.logging import MetricsLogger, log_training_step, log_validation
-from llm_med.utils.checkpoints import CheckpointManager
+from gptmed.utils.logging import MetricsLogger, log_training_step, log_validation
+from gptmed.utils.checkpoints import CheckpointManager
 
 
 class Trainer:

{gptmed-0.0.1.dist-info → gptmed-0.1.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gptmed
-Version: 0.0.1
+Version: 0.1.2
 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>
@@ -51,6 +51,7 @@ Requires-Dist: torch>=2.0.0
 Requires-Dist: sentencepiece>=0.1.99
 Requires-Dist: numpy>=1.24.0
 Requires-Dist: tqdm>=4.65.0
+Requires-Dist: pyyaml>=6.0
 Provides-Extra: dev
 Requires-Dist: pytest>=7.0.0; extra == "dev"
 Requires-Dist: black>=22.0.0; extra == "dev"
@@ -69,6 +70,10 @@ A lightweight GPT-based language model framework for training custom question-an
 [![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)
+
+> **New to GptMed?** Check out the [**step-by-step User Manual**](USER_MANUAL.md) for a complete guide on training your own model!
+
 ## Features
 
 - 🧠 **Custom GPT Architecture**: Lightweight transformer model for any Q&A domain
@@ -78,6 +83,27 @@ A lightweight GPT-based language model framework for training custom question-an
 - 📦 **Lightweight**: Small model size suitable for edge deployment
 - 🛠️ **Complete Toolkit**: Includes tokenizer training, model training, and inference utilities
 
+## Table of Contents
+
+- [Features](#features)
+- [Installation](#installation)
+- [Quick Start](#quick-start)
+- [Package Structure](#package-structure)
+  - [Core Modules](#core-modules)
+  - [Model Components](#model-components)
+  - [Training Components](#training-components)
+  - [Inference Components](#inference-components)
+  - [Data Processing](#data-processing)
+  - [Utilities](#utilities)
+- [Model Architecture](#model-architecture)
+- [Configuration](#configuration)
+- [Documentation](#documentation)
+- [Performance](#performance)
+- [Examples](#examples)
+- [Contributing](#contributing)
+- [License](#license)
+- [Support](#support)
+
 ## Installation
 
 ### From PyPI (Recommended)
@@ -204,27 +230,134 @@ config = TrainingConfig(
 )
 ```
 
-## Project Structure
+## Package Structure
+
+### Core Modules
+
+The `gptmed` package contains the following main modules:
+
+```
+gptmed/
+├── model/                  # Model architecture and configurations
+├── inference/              # Text generation and sampling
+├── training/               # Training loops and datasets
+├── tokenizer/              # Tokenizer training and data processing
+├── data/                   # Data parsers and formatters
+├── configs/                # Training configurations
+└── utils/                  # Utilities (checkpoints, logging)
+```
+
+### Model Components
+
+**`gptmed.model.architecture`** - GPT Transformer Implementation
+
+- `GPTTransformer` - Main model class
+- `TransformerBlock` - Individual transformer layers
+- `MultiHeadAttention` - Attention mechanism
+- `FeedForward` - Feed-forward networks
+- `RoPEPositionalEncoding` - Rotary position embeddings
+
+**`gptmed.model.configs`** - Model Configurations
+
+- `get_tiny_config()` - ~2M parameters (testing)
+- `get_small_config()` - ~10M parameters (recommended)
+- `get_medium_config()` - ~50M parameters (high quality)
+- `ModelConfig` - Custom configuration class
+
+### Training Components
+
+**`gptmed.training`** - Training Pipeline
+
+- `train.py` - Main training script (CLI: `gptmed-train`)
+- `Trainer` - Training loop with checkpointing
+- `TokenizedDataset` - PyTorch dataset for tokenized data
+- `create_dataloaders()` - DataLoader creation utilities
+
+**`gptmed.configs`** - Training Configurations
+
+- `TrainingConfig` - Training hyperparameters
+- `get_default_config()` - Default training settings
+- `get_quick_test_config()` - Fast testing configuration
+
+### Inference Components
+
+**`gptmed.inference`** - Text Generation
+
+- `TextGenerator` - Main generation class
+- `generator.py` - CLI command (CLI: `gptmed-generate`)
+- `sampling.py` - Sampling strategies (top-k, top-p, temperature)
+- `decoding_utils.py` - Decoding utilities
+- `GenerationConfig` - Generation parameters
+
+### Data Processing
+
+**`gptmed.tokenizer`** - Tokenizer Training & Data Processing
+
+- `train_tokenizer.py` - Train SentencePiece tokenizer
+- `tokenize_data.py` - Convert text to token sequences
+- SentencePiece BPE tokenizer support
+
+**`gptmed.data.parsers`** - Data Parsing & Formatting
+
+- `MedQuADParser` - XML Q&A parser (example)
+- `CausalTextFormatter` - Format Q&A pairs for training
+- `FormatConfig` - Formatting configuration
+
+### Utilities
+
+**`gptmed.utils`** - Helper Functions
+
+- `checkpoints.py` - Model checkpoint management
+- `logging.py` - Training metrics logging
+
+---
+
+## Detailed Project Structure
 
 ```
 gptmed/
 ├── model/
-│   ├── architecture/      # GPT transformer implementation
-│   └── configs/           # Model configurations
+│   ├── architecture/
+│   │   ├── gpt.py              # GPT transformer model
+│   │   ├── attention.py        # Multi-head attention
+│   │   ├── feedforward.py      # Feed-forward networks
+│   │   └── embeddings.py       # Token + positional embeddings
+│   └── configs/
+│       └── model_config.py     # Model size configurations
 ├── inference/
-│   ├── generator.py       # Text generation
-│   └── sampling.py        # Sampling strategies
+│   ├── generator.py            # Text generation (CLI command)
+│   ├── sampling.py             # Sampling strategies
+│   ├── decoding_utils.py       # Decoding utilities
+│   └── generation_config.py    # Generation parameters
 ├── training/
-│   ├── train.py          # Training script
-│   ├── trainer.py        # Training loop
-│   └── dataset.py        # Data loading
+│   ├── train.py                # Main training script (CLI command)
+│   ├── trainer.py              # Training loop
+│   ├── dataset.py              # PyTorch dataset
+│   └── utils.py                # Training utilities
 ├── tokenizer/
-│   └── train_tokenizer.py # SentencePiece tokenizer
+│   ├── train_tokenizer.py      # Train SentencePiece tokenizer
+│   └── tokenize_data.py        # Tokenize text data
+├── data/
+│   └── parsers/
+│       ├── medquad_parser.py   # Example XML parser
+│       └── text_formatter.py   # Q&A text formatter
 ├── configs/
-│   └── train_config.py   # Training configurations
+│   └── train_config.py         # Training configurations
 └── utils/
-    ├── checkpoints.py    # Model checkpointing
-    └── logging.py        # Training logging
+    ├── checkpoints.py          # Model checkpointing
+    └── logging.py              # Training logging
+```
+
+### Command-Line Interface
+
+The package provides two main CLI commands:
+
+```bash
+# Train a model
+gptmed-train --model-size small --num-epochs 10 --batch-size 16
+
+# Generate text
+gptmed-generate --prompt "Your question?" --max-length 100
 ```
 
 ## Requirements
@@ -237,14 +370,14 @@ gptmed/
 
 ## Documentation
 
-For detailed documentation, visit [GitHub Repository](https://github.com/yourusername/medllm).
+📚 **[Complete User Manual](USER_MANUAL.md)** - Step-by-step guide for training your own model
 
-### Key Guides
+### Quick Links
 
-- [Training Guide](docs/training.md)
-- [Inference Guide](docs/inference.md)
-- [Model Architecture](docs/architecture.md)
-- [API Reference](docs/api.md)
+- [User Manual](USER_MANUAL.md) - **Start here!** Complete training pipeline guide
+- [Architecture Guide](ARCHITECTURE_EXTENSION_GUIDE.md) - Understanding the model architecture
+- [Deployment Guide](DEPLOYMENT_GUIDE.md) - Publishing to PyPI
+- [Changelog](CHANGELOG.md) - Version history
 
 ## Performance
 
@@ -312,7 +445,8 @@ This project is licensed under the MIT License - see the [LICENSE](LICENSE) file
 
 ## Support
 
-- 📫 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
 

{gptmed-0.0.1.dist-info → gptmed-0.1.2.dist-info}/RECORD

@@ -1,6 +1,9 @@
-gptmed/__init__.py,sha256=Hj1lpVY8kVBnVZMpz2Dk_9bQM-pgSpWaim4aYPG4i08,1130
+gptmed/__init__.py,sha256=RoPQCLWrTlvpaKgboeoH9OXn8BB3gmZDUFAytvL8lVU,1676
+gptmed/api.py,sha256=IU5r9ujg3S-Lem5-FOGDDLdh1UJ_FqCbaQayzyJez5c,10774
 gptmed/configs/__init__.py,sha256=yRa-zgPQ-OCzu8fvCrfWMG-CjF3dru3PZzknzm0oUaQ,23
+gptmed/configs/config_loader.py,sha256=hkJRN-Rh6dlzOf97yOjPCVdy-Es5YjgKo3-iOwAeXEI,5833
 gptmed/configs/train_config.py,sha256=KqfNBh9hdTTd_6gEAlrClU8sVFSlVDmZJOrf3cPwFe8,4657
+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
 gptmed/data/parsers/medquad_parser.py,sha256=g3QCRiVBdcq8RdyuYH_qKFrHgU5KkHY59WfWxUwspP0,7974
@@ -8,31 +11,31 @@ gptmed/data/parsers/text_formatter.py,sha256=tVmnDBT54BbxX9BPKMXSPzzLmM39frDxKRK
 gptmed/inference/__init__.py,sha256=NDPViXhOgpItC8n13T9axX4UH1E7mrjt6kJ5OfIwvMs,25
 gptmed/inference/decoding_utils.py,sha256=zTDZYdl2jcGwSrcINXMw-5uoYuF4A9TSushhPxJi1o0,5041
 gptmed/inference/generation_config.py,sha256=hpPyZUk1K6qGSBAoQx3Jm0_ZrrYld77ACxbIlCCCcVU,2813
-gptmed/inference/generator.py,sha256=ZVd4sPSr6l4ov3AhNJib8YDNBERrs39-zdFZumluVnI,7889
+gptmed/inference/generator.py,sha256=6JFmDPQF4btau_Gp5pfk8a5G0Iyg6QsB9Y8Oo4ygH-4,7884
 gptmed/inference/sampling.py,sha256=B6fRlJafypuBMKJ0rTbsk6k8KXloXiIvroi7rN6ekBA,7947
-gptmed/model/__init__.py,sha256=V44r-TSMaZObgHgeXRl2Ec9pkqWUkUVAf37xgtlZQO8,192
+gptmed/model/__init__.py,sha256=brAE8ZhCDeQlU13YSqiBZTrTE8SHL_3bvFhZMzZnh3A,191
 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
 gptmed/model/architecture/embeddings.py,sha256=GoVXctC21MsNwyoIiOq7NX-v_DzYkbFcQAfvZ2fg66s,4717
 gptmed/model/architecture/feedforward.py,sha256=uJ5QOlWX0ritKDQLUE7GPmMojelR9-sTI_BaYc4Ehfw,3232
 gptmed/model/architecture/transformer.py,sha256=H1njPoy0Uam59JbA24C0olEDwPfhh3ev4HsUFRIC_0Y,6626
-gptmed/model/configs/__init__.py,sha256=0ZfBO0k4yFaqh2yO7eVSQUZjHKp-Esjpdn4m6zwhLig,276
+gptmed/model/configs/__init__.py,sha256=LDCWhlCDOU7490wcfSId_jXBPfQrtYQEw8FoD67rqBs,275
 gptmed/model/configs/model_config.py,sha256=wI-i2Dw_pTdIKCDe1pqLvP3ky3YedEy7DwZYN5lwmKE,4673
-gptmed/tokenizer/__init__.py,sha256=Cs6h9mtmh0hbqq1qvawRdggb7-GPKMnISOeNJFEuVqo,158
+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=d--RS5v8ZAWlqux74YHnX-HAmJB1WveK38VxAZ8x2Bo,8157
-gptmed/training/trainer.py,sha256=qOOn5oUVvqQMAbO5KWddngk1QzxdHdyTXEwXrL8uS40,10732
+gptmed/training/train.py,sha256=sp4-1WpEXUTA9V0GUYAgSvMd2aaPkt1aq2PepQFLXD8,8142
+gptmed/training/trainer.py,sha256=asOKT9d7lvmtEm5PIcMHg8iUdulNJpobNFNwOjdkeEg,10728
 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/logging.py,sha256=7dJc1tayMxCBjFSDXe4r9ACUTpoPTTGsJ0UZMTqZIDY,5303
-gptmed-0.0.1.dist-info/licenses/LICENSE,sha256=v2spsd7N1pKFFh2G8wGP_45iwe5S0DYiJzG4im8Rupc,1066
-gptmed-0.0.1.dist-info/METADATA,sha256=tVtGIXe76Iq0IKrHfS0FsFVuJ1_wlLcrejQzg2N6qyA,10196
-gptmed-0.0.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-gptmed-0.0.1.dist-info/entry_points.txt,sha256=ATqOzTtPVdUiFX5ZSeo3n9JkUCqocUxEXTgy1CfNRZE,110
-gptmed-0.0.1.dist-info/top_level.txt,sha256=mhyEq3rG33t21ziJz5w3TPgx0RjPf4zXMNUx2JTiNmE,7
-gptmed-0.0.1.dist-info/RECORD,,
+gptmed-0.1.2.dist-info/licenses/LICENSE,sha256=v2spsd7N1pKFFh2G8wGP_45iwe5S0DYiJzG4im8Rupc,1066
+gptmed-0.1.2.dist-info/METADATA,sha256=XEC0i9WiztPA54N0KnTJL9fBuuoAdmUhR5GeENivki8,14876
+gptmed-0.1.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+gptmed-0.1.2.dist-info/entry_points.txt,sha256=ATqOzTtPVdUiFX5ZSeo3n9JkUCqocUxEXTgy1CfNRZE,110
+gptmed-0.1.2.dist-info/top_level.txt,sha256=mhyEq3rG33t21ziJz5w3TPgx0RjPf4zXMNUx2JTiNmE,7
+gptmed-0.1.2.dist-info/RECORD,,