isa-model 0.4.0__py3-none-any.whl → 0.4.4__py3-none-any.whl

isa_model/training/core/utils.py

@@ -1,213 +0,0 @@
-"""
-Training Utilities
-
-Helper functions and utilities for training operations.
-"""
-
-import os
-import json
-import logging
-import datetime
-from typing import Dict, Any, Optional, List
-from pathlib import Path
-
-logger = logging.getLogger(__name__)
-
-
-class TrainingUtils:
-    """Utility functions for training operations."""
-    
-    @staticmethod
-    def generate_output_dir(model_name: str, training_type: str, base_dir: str = "training_outputs") -> str:
-        """Generate a timestamped output directory."""
-        timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
-        safe_model_name = model_name.replace("/", "_").replace(":", "_")
-        output_dir = os.path.join(base_dir, f"{safe_model_name}_{training_type}_{timestamp}")
-        return output_dir
-    
-    @staticmethod
-    def save_training_args(args: Dict[str, Any], output_dir: str) -> None:
-        """Save training arguments to file."""
-        args_path = Path(output_dir) / "training_args.json"
-        args_path.parent.mkdir(parents=True, exist_ok=True)
-        
-        with open(args_path, 'w') as f:
-            json.dump(args, f, indent=2, default=str)
-        
-        logger.info(f"Training arguments saved to: {args_path}")
-    
-    @staticmethod
-    def load_training_args(output_dir: str) -> Dict[str, Any]:
-        """Load training arguments from file."""
-        args_path = Path(output_dir) / "training_args.json"
-        
-        if not args_path.exists():
-            raise FileNotFoundError(f"Training args not found: {args_path}")
-        
-        with open(args_path, 'r') as f:
-            args = json.load(f)
-        
-        return args
-    
-    @staticmethod
-    def get_model_info(model_name: str) -> Dict[str, Any]:
-        """Get information about a model."""
-        try:
-            from transformers import AutoConfig
-            
-            config = AutoConfig.from_pretrained(model_name, trust_remote_code=True)
-            
-            model_info = {
-                "model_name": model_name,
-                "model_type": config.model_type,
-                "vocab_size": getattr(config, 'vocab_size', None),
-                "hidden_size": getattr(config, 'hidden_size', None),
-                "num_layers": getattr(config, 'num_hidden_layers', None),
-                "num_attention_heads": getattr(config, 'num_attention_heads', None),
-                "max_position_embeddings": getattr(config, 'max_position_embeddings', None),
-            }
-            
-            return model_info
-            
-        except Exception as e:
-            logger.warning(f"Could not get model info for {model_name}: {e}")
-            return {"model_name": model_name, "error": str(e)}
-    
-    @staticmethod
-    def estimate_memory_usage(
-        model_name: str,
-        batch_size: int = 1,
-        max_length: int = 1024,
-        use_lora: bool = True
-    ) -> Dict[str, Any]:
-        """Estimate memory usage for training."""
-        try:
-            model_info = TrainingUtils.get_model_info(model_name)
-            
-            # Rough estimation based on model parameters
-            hidden_size = model_info.get('hidden_size', 4096)
-            num_layers = model_info.get('num_layers', 32)
-            vocab_size = model_info.get('vocab_size', 32000)
-            
-            # Estimate model parameters (in millions)
-            param_count = (hidden_size * hidden_size * 12 * num_layers + vocab_size * hidden_size) / 1e6
-            
-            # Base memory for model (assuming fp16)
-            model_memory_gb = param_count * 2 / 1024  # 2 bytes per parameter
-            
-            # Training memory overhead (gradients, optimizer states, activations)
-            if use_lora:
-                training_overhead = 2.0  # LoRA reduces memory usage significantly
-            else:
-                training_overhead = 4.0  # Full fine-tuning needs more memory
-            
-            # Batch and sequence length impact
-            sequence_memory = batch_size * max_length * hidden_size * 2 / (1024**3)  # Activation memory
-            
-            total_memory_gb = model_memory_gb * training_overhead + sequence_memory
-            
-            return {
-                "estimated_params_millions": param_count,
-                "model_memory_gb": model_memory_gb,
-                "total_training_memory_gb": total_memory_gb,
-                "recommended_gpu": TrainingUtils._recommend_gpu(total_memory_gb),
-                "use_lora": use_lora,
-                "batch_size": batch_size,
-                "max_length": max_length
-            }
-            
-        except Exception as e:
-            logger.warning(f"Could not estimate memory usage: {e}")
-            return {"error": str(e)}
-    
-    @staticmethod
-    def _recommend_gpu(memory_gb: float) -> str:
-        """Recommend GPU based on memory requirements."""
-        if memory_gb <= 8:
-            return "RTX 3080/4070 (8-12GB)"
-        elif memory_gb <= 16:
-            return "RTX 4080/4090 (16GB)"
-        elif memory_gb <= 24:
-            return "RTX A6000/4090 (24GB)"
-        elif memory_gb <= 40:
-            return "A100 40GB"
-        elif memory_gb <= 80:
-            return "A100 80GB"
-        else:
-            return "Multiple A100 80GB (Multi-GPU required)"
-    
-    @staticmethod
-    def validate_training_config(config: Dict[str, Any]) -> List[str]:
-        """Validate training configuration and return any issues."""
-        issues = []
-        
-        # Check required fields
-        required_fields = ["model_name", "output_dir"]
-        for field in required_fields:
-            if field not in config:
-                issues.append(f"Missing required field: {field}")
-        
-        # Check batch size
-        if config.get("batch_size", 0) <= 0:
-            issues.append("batch_size must be positive")
-        
-        # Check learning rate
-        lr = config.get("learning_rate", 0)
-        if lr <= 0 or lr > 1:
-            issues.append("learning_rate should be between 0 and 1")
-        
-        # Check epochs
-        if config.get("num_epochs", 0) <= 0:
-            issues.append("num_epochs must be positive")
-        
-        # Check LoRA config
-        if config.get("use_lora", False):
-            lora_rank = config.get("lora_rank", 8)
-            if lora_rank <= 0 or lora_rank > 256:
-                issues.append("lora_rank should be between 1 and 256")
-        
-        return issues
-    
-    @staticmethod
-    def format_training_summary(
-        config: Dict[str, Any],
-        model_info: Dict[str, Any],
-        memory_estimate: Dict[str, Any]
-    ) -> str:
-        """Format a training summary for display."""
-        summary = []
-        summary.append("=" * 60)
-        summary.append("TRAINING CONFIGURATION SUMMARY")
-        summary.append("=" * 60)
-        
-        # Model information
-        summary.append(f"Model: {config.get('model_name', 'Unknown')}")
-        summary.append(f"Model Type: {model_info.get('model_type', 'Unknown')}")
-        summary.append(f"Parameters: ~{memory_estimate.get('estimated_params_millions', 0):.1f}M")
-        
-        # Training configuration
-        summary.append(f"\nTraining Configuration:")
-        summary.append(f"  Training Type: {config.get('training_type', 'sft')}")
-        summary.append(f"  Epochs: {config.get('num_epochs', 3)}")
-        summary.append(f"  Batch Size: {config.get('batch_size', 4)}")
-        summary.append(f"  Learning Rate: {config.get('learning_rate', 2e-5)}")
-        summary.append(f"  Max Length: {config.get('max_length', 1024)}")
-        
-        # LoRA configuration
-        if config.get('use_lora', True):
-            summary.append(f"\nLoRA Configuration:")
-            summary.append(f"  LoRA Rank: {config.get('lora_rank', 8)}")
-            summary.append(f"  LoRA Alpha: {config.get('lora_alpha', 16)}")
-            summary.append(f"  LoRA Dropout: {config.get('lora_dropout', 0.05)}")
-        
-        # Memory estimation
-        summary.append(f"\nMemory Estimation:")
-        summary.append(f"  Estimated Memory: ~{memory_estimate.get('total_training_memory_gb', 0):.1f}GB")
-        summary.append(f"  Recommended GPU: {memory_estimate.get('recommended_gpu', 'Unknown')}")
-        
-        # Output
-        summary.append(f"\nOutput Directory: {config.get('output_dir', 'Unknown')}")
-        
-        summary.append("=" * 60)
-        
-        return "\n".join(summary) 

isa_model/training/examples/intelligent_training_example.py

@@ -1,281 +0,0 @@
-#!/usr/bin/env python3
-"""
-Intelligent Training System Example
-
-This script demonstrates the capabilities of the intelligent training system:
-- Natural language training request analysis
-- Automatic model and resource selection
-- Cost and performance optimization
-- Training option comparison
-- Best practices recommendations
-
-Run this script to see the intelligent training system in action.
-"""
-
-import os
-import sys
-import json
-from pathlib import Path
-
-# Add the parent directory to path for imports
-sys.path.insert(0, str(Path(__file__).parent.parent.parent.parent))
-
-def main():
-    """Demonstrate intelligent training capabilities."""
-    
-    print("🧠 Intelligent Training System Demo")
-    print("=" * 50)
-    
-    try:
-        # Import intelligent training components
-        from isa_model.training import (
-            IntelligentTrainingFactory, 
-            INTELLIGENT_AVAILABLE
-        )
-        
-        if not INTELLIGENT_AVAILABLE:
-            print("❌ Intelligent training features not available")
-            return
-        
-        print("✅ Intelligent training system loaded successfully\n")
-        
-        # Initialize intelligent factory
-        print("🔧 Initializing intelligent training factory...")
-        factory = IntelligentTrainingFactory()
-        
-        # Example 1: Natural Language Training Request
-        print("\n" + "="*50)
-        print("📝 EXAMPLE 1: Natural Language Analysis")
-        print("="*50)
-        
-        description = "Train a customer service chatbot for a medical company that can answer patient questions about symptoms and treatments in Chinese"
-        dataset_path = "medical_qa_chinese.json"  # Hypothetical dataset
-        
-        print(f"Request: {description}")
-        print(f"Dataset: {dataset_path}")
-        
-        try:
-            recommendation = factory.analyze_training_request(
-                description=description,
-                dataset_source=dataset_path,
-                quality_target="high",
-                budget_limit=300.0,
-                time_limit=12
-            )
-            
-            print(f"\n✅ Analysis completed successfully!")
-            print(f"📱 Recommended Model: {recommendation.model_name}")
-            print(f"🖥️  Recommended GPU: {recommendation.recommended_gpu}")
-            print(f"💰 Estimated Cost: ${recommendation.estimated_cost:.2f}")
-            print(f"⏱️  Estimated Time: {recommendation.estimated_time:.1f} hours")
-            
-        except Exception as e:
-            print(f"❌ Analysis failed: {e}")
-        
-        # Example 2: Training Options Comparison
-        print("\n" + "="*50)
-        print("📊 EXAMPLE 2: Training Options Comparison")
-        print("="*50)
-        
-        description2 = "Fine-tune a code generation model for Python development"
-        dataset_path2 = "python_code_dataset.json"
-        
-        print(f"Request: {description2}")
-        print(f"Comparing quality targets: fast, balanced, high")
-        
-        try:
-            comparisons = factory.compare_training_options(
-                description=description2,
-                dataset_source=dataset_path2,
-                quality_targets=["fast", "balanced", "high"],
-                budget_limits=[50.0, 150.0, 300.0]
-            )
-            
-            print(f"✅ Generated {len(comparisons)} training options for comparison")
-            
-        except Exception as e:
-            print(f"❌ Comparison failed: {e}")
-        
-        # Example 3: Best Practices
-        print("\n" + "="*50)
-        print("💡 EXAMPLE 3: Best Practices")
-        print("="*50)
-        
-        task_types = ["chat", "classification", "generation"]
-        domains = ["medical", "legal", "general"]
-        
-        for task_type in task_types:
-            for domain in domains:
-                try:
-                    practices = factory.get_best_practices(task_type, domain)
-                    if practices:
-                        print(f"\n📋 {task_type.title()} + {domain.title()}:")
-                        for practice in practices[:2]:  # Show top 2
-                            print(f"  • {practice}")
-                except Exception as e:
-                    continue
-        
-        # Example 4: System Capabilities
-        print("\n" + "="*50)
-        print("🎯 EXAMPLE 4: System Capabilities")
-        print("="*50)
-        
-        try:
-            capabilities = factory.get_supported_capabilities()
-            
-            print(f"📱 Supported Models: {len(capabilities.get('task_types', []))} task types")
-            print(f"🌍 Supported Domains: {len(capabilities.get('domains', []))} domains")
-            print(f"🖥️  Available GPUs: {len(capabilities.get('gpu_types', []))} types")
-            print(f"☁️  Cloud Providers: {len(capabilities.get('cloud_providers', []))} providers")
-            
-            print("\nTask Types:")
-            for task in capabilities.get('task_types', [])[:5]:
-                print(f"  • {task}")
-            
-            print("\nDomains:")
-            for domain in capabilities.get('domains', [])[:5]:
-                print(f"  • {domain}")
-            
-            print("\nGPU Types:")
-            for gpu in capabilities.get('gpu_types', [])[:5]:
-                print(f"  • {gpu}")
-                
-        except Exception as e:
-            print(f"❌ Failed to get capabilities: {e}")
-        
-        # Example 5: Intelligence Statistics
-        print("\n" + "="*50)
-        print("📈 EXAMPLE 5: Intelligence Statistics")
-        print("="*50)
-        
-        try:
-            stats = factory.get_intelligence_statistics()
-            
-            if stats.get('intelligence_enabled'):
-                kb_stats = stats.get('knowledge_base', {})
-                print(f"📚 Knowledge Base:")
-                print(f"  • Models: {kb_stats.get('total_models', 0)}")
-                print(f"  • Best Practices: {kb_stats.get('best_practices', 0)}")
-                print(f"  • Benchmarks: {kb_stats.get('benchmarks', 0)}")
-                
-                resource_stats = stats.get('resource_optimizer', {})
-                print(f"🖥️  Resource Optimizer:")
-                print(f"  • GPUs: {resource_stats.get('total_gpus', 0)}")
-                print(f"  • Providers: {resource_stats.get('total_providers', 0)}")
-                print(f"  • Avg Cost/Hour: ${resource_stats.get('avg_cost_per_hour', 0):.2f}")
-            
-        except Exception as e:
-            print(f"❌ Failed to get statistics: {e}")
-        
-        # Example 6: Recommendation Scenarios
-        print("\n" + "="*50)
-        print("🎭 EXAMPLE 6: Different Scenarios")
-        print("="*50)
-        
-        scenarios = [
-            {
-                "name": "Budget-Conscious Student",
-                "description": "Create a simple English grammar checker",
-                "dataset": "grammar_corrections.json",
-                "budget": 25.0,
-                "time": 4,
-                "target": "fast"
-            },
-            {
-                "name": "Enterprise Company",
-                "description": "Advanced legal document analysis system",
-                "dataset": "legal_documents.json", 
-                "budget": 1000.0,
-                "time": 24,
-                "target": "high"
-            },
-            {
-                "name": "Research Lab",
-                "description": "Multi-modal medical image description model",
-                "dataset": "medical_images_captions.json",
-                "budget": 500.0,
-                "time": 16,
-                "target": "balanced"
-            }
-        ]
-        
-        for scenario in scenarios:
-            print(f"\n👤 {scenario['name']}:")
-            print(f"   Request: {scenario['description']}")
-            print(f"   Budget: ${scenario['budget']}, Time: {scenario['time']}h, Target: {scenario['target']}")
-            
-            try:
-                rec = factory.analyze_training_request(
-                    description=scenario['description'],
-                    dataset_source=scenario['dataset'],
-                    quality_target=scenario['target'],
-                    budget_limit=scenario['budget'],
-                    time_limit=scenario['time']
-                )
-                
-                print(f"   → Model: {rec.model_name}")
-                print(f"   → GPU: {rec.recommended_gpu}")
-                print(f"   → Cost: ${rec.estimated_cost:.2f}")
-                print(f"   → Confidence: {rec.confidence_score:.1%}")
-                
-            except Exception as e:
-                print(f"   ❌ Failed: {e}")
-        
-        # Summary
-        print("\n" + "="*50)
-        print("✅ DEMO COMPLETED SUCCESSFULLY")
-        print("="*50)
-        print("The intelligent training system is ready to use!")
-        print("\nNext steps:")
-        print("1. Prepare your dataset in JSON format")
-        print("2. Use analyze_training_request() for recommendations")
-        print("3. Use train_with_recommendation() to start training")
-        print("4. Monitor progress and collect results")
-        
-    except ImportError as e:
-        print(f"❌ Import error: {e}")
-        print("Make sure the isa_model package is properly installed")
-    except Exception as e:
-        print(f"❌ Demo failed: {e}")
-        import traceback
-        traceback.print_exc()
-
-
-def create_sample_dataset():
-    """Create a sample dataset for testing."""
-    sample_data = [
-        {
-            "instruction": "What are the symptoms of the common cold?",
-            "input": "",
-            "output": "Common cold symptoms include runny nose, sneezing, coughing, sore throat, mild headache, and fatigue."
-        },
-        {
-            "instruction": "How can I prevent getting sick?",
-            "input": "",
-            "output": "To prevent illness, wash your hands frequently, maintain a healthy diet, get adequate sleep, exercise regularly, and avoid close contact with sick people."
-        },
-        {
-            "instruction": "When should I see a doctor?",
-            "input": "I have a fever and cough for 3 days",
-            "output": "You should see a doctor if you have a persistent fever and cough for more than 3 days, especially if symptoms are worsening or you have difficulty breathing."
-        }
-    ]
-    
-    # Create sample dataset file
-    os.makedirs("sample_data", exist_ok=True)
-    with open("sample_data/medical_qa_sample.json", "w") as f:
-        json.dump(sample_data, f, indent=2)
-    
-    print("📁 Created sample dataset: sample_data/medical_qa_sample.json")
-
-
-if __name__ == "__main__":
-    print("🚀 Starting Intelligent Training System Demo\n")
-    
-    # Create sample dataset
-    create_sample_dataset()
-    
-    # Run main demo
-    main()
-    
-    print("\n🎉 Demo finished! Thank you for trying the intelligent training system.")