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

isa_model/training/__init__.py

@@ -1,168 +0,0 @@
-"""
-ISA Model Training Module
-
-Provides unified training capabilities for AI models including:
-- Local training with SFT (Supervised Fine-Tuning)
-- Cloud training on RunPod
-- Model evaluation and management
-- HuggingFace integration
-- 🧠 Intelligent training with AI-powered optimization
-
-Example usage:
-    ```python
-    from isa_model.training import TrainingFactory, train_gemma
-    
-    # Quick Gemma training
-    model_path = train_gemma(
-        dataset_path="tatsu-lab/alpaca",
-        model_size="4b",
-        num_epochs=3
-    )
-    
-    # Advanced training with custom configuration
-    factory = TrainingFactory()
-    model_path = factory.train_model(
-        model_name="google/gemma-2-4b-it",
-        dataset_path="your-dataset.json",
-        use_lora=True,
-        batch_size=4,
-        num_epochs=3
-    )
-    
-    # 🧠 Intelligent training with natural language
-    from isa_model.training import IntelligentTrainingFactory
-    
-    intelligent_factory = IntelligentTrainingFactory()
-    recommendation = intelligent_factory.analyze_training_request(
-        "Train a customer service chatbot for medical domain",
-        dataset_path="medical_dialogues.json",
-        quality_target="high",
-        budget_limit=200.0
-    )
-    model_path = intelligent_factory.train_with_recommendation(recommendation)
-    ```
-"""
-
-# Import the new clean factory
-from .factory import TrainingFactory, train_gemma
-
-# Import core components
-from .core import (
-    TrainingConfig,
-    LoRAConfig, 
-    DatasetConfig,
-    BaseTrainer,
-    SFTTrainer,
-    TrainingUtils,
-    DatasetManager,
-    RunPodConfig,
-    StorageConfig,
-    JobConfig
-)
-
-# Import cloud training components
-from .cloud import (
-    TrainingJobOrchestrator
-)
-
-# Import intelligent training components (optional)
-try:
-    from .intelligent import (
-        IntelligentTrainingFactory,
-        IntelligentDecisionEngine,
-        TaskClassifier,
-        KnowledgeBase,
-        ResourceOptimizer,
-        TrainingRequest,
-        TrainingRecommendation
-    )
-    INTELLIGENT_AVAILABLE = True
-except ImportError as e:
-    INTELLIGENT_AVAILABLE = False
-    # Create placeholder classes for graceful degradation
-    class IntelligentTrainingFactory:
-        def __init__(self, *args, **kwargs):
-            raise ImportError("Intelligent training features not available. Please install required dependencies.")
-    
-    class IntelligentDecisionEngine:
-        def __init__(self, *args, **kwargs):
-            raise ImportError("Intelligent training features not available.")
-    
-    class TaskClassifier:
-        def __init__(self, *args, **kwargs):
-            raise ImportError("Intelligent training features not available.")
-    
-    class KnowledgeBase:
-        def __init__(self, *args, **kwargs):
-            raise ImportError("Intelligent training features not available.")
-    
-    class ResourceOptimizer:
-        def __init__(self, *args, **kwargs):
-            raise ImportError("Intelligent training features not available.")
-    
-    class TrainingRequest:
-        def __init__(self, *args, **kwargs):
-            raise ImportError("Intelligent training features not available.")
-    
-    class TrainingRecommendation:
-        def __init__(self, *args, **kwargs):
-            raise ImportError("Intelligent training features not available.")
-
-__all__ = [
-    # Main factory
-    'TrainingFactory',
-    'train_gemma',
-    
-    # Core components
-    'TrainingConfig',
-    'LoRAConfig',
-    'DatasetConfig', 
-    'BaseTrainer',
-    'SFTTrainer',
-    'TrainingUtils',
-    'DatasetManager',
-    
-    # Cloud components
-    'RunPodConfig',
-    'StorageConfig',
-    'JobConfig',
-    'TrainingJobOrchestrator',
-    
-    # Intelligent training components
-    'IntelligentTrainingFactory',
-    'IntelligentDecisionEngine',
-    'TaskClassifier',
-    'KnowledgeBase',
-    'ResourceOptimizer',
-    'TrainingRequest',
-    'TrainingRecommendation',
-    'INTELLIGENT_AVAILABLE',
-    
-    # Training storage components (optional)
-    'TrainingStorage',
-    'TrainingRepository',
-    'CoreModelIntegration'
-]
-
-# Import training storage components (optional)
-try:
-    from .storage import (
-        TrainingStorage,
-        TrainingRepository,
-        CoreModelIntegration
-    )
-    STORAGE_AVAILABLE = True
-except ImportError:
-    STORAGE_AVAILABLE = False
-    # Create placeholder classes for graceful degradation
-    class TrainingStorage:
-        def __init__(self, *args, **kwargs):
-            raise ImportError("Training storage features not available.")
-    
-    class TrainingRepository:
-        def __init__(self, *args, **kwargs):
-            raise ImportError("Training repository features not available.")
-    
-    class CoreModelIntegration:
-        def __init__(self, *args, **kwargs):
-            raise ImportError("Core model integration features not available.") 

isa_model/training/annotation/annotation_schema.py

@@ -1,47 +0,0 @@
-# app/services/llm_model/tracing/annotation/annotation_schema.py
-from enum import Enum
-from pydantic import BaseModel, Field
-from typing import Dict, Any, List, Optional
-from datetime import datetime
-
-class AnnotationType(str, Enum):
-    ACCURACY = "accuracy"
-    HELPFULNESS = "helpfulness"
-    TOXICITY = "toxicity"
-    CUSTOM = "custom"
-
-class RatingScale(int, Enum):
-    POOR = 1
-    FAIR = 2
-    GOOD = 3
-    EXCELLENT = 4
-
-class AnnotationAspects(BaseModel):
-    factually_correct: bool = True
-    relevant: bool = True
-    harmful: bool = False
-    biased: bool = False
-    complete: bool = True
-    efficient: bool = True
-
-class BetterResponse(BaseModel):
-    content: str
-    reason: Optional[str]
-    metadata: Optional[Dict[str, Any]] = {}
-
-class AnnotationFeedback(BaseModel):
-    rating: RatingScale
-    category: AnnotationType
-    aspects: AnnotationAspects
-    better_response: Optional[BetterResponse]
-    comment: Optional[str]
-    metadata: Optional[Dict[str, Any]] = {}
-    is_selected_for_training: bool = False  
-
-class ItemAnnotation(BaseModel):
-    item_id: str
-    feedback: Optional[AnnotationFeedback]
-    status: str = "pending"  
-    annotated_at: Optional[datetime]
-    annotator_id: Optional[str]
-    training_status: Optional[str] = None  

isa_model/training/annotation/processors/annotation_processor.py

@@ -1,126 +0,0 @@
-from typing import Dict, Any, List
-from datetime import datetime
-from app.config.config_manager import config_manager
-from app.services.training.llm_model.annotation.annotation_schema import AnnotationFeedback, RatingScale, AnnotationAspects
-from bson.objectid import ObjectId
-from app.services.training.llm_model.annotation.storage.dataset_manager import DatasetManager
-
-class AnnotationProcessor:
-    def __init__(self):
-        self.logger = config_manager.get_logger(__name__)
-        self.dataset_manager = DatasetManager()
-        self.batch_size = 1000  # Configure as needed
-    
-    async def process_queue(self) -> None:
-        """Process pending items and create datasets"""
-        db = await config_manager.get_db('mongodb')
-        queue = db['training_queue']
-        
-        # Process SFT items
-        sft_items = await self._get_pending_items("sft")
-        if len(sft_items) >= self.batch_size:
-            await self._create_sft_dataset(sft_items)
-        
-        # Process RLHF items
-        rlhf_items = await self._get_pending_items("rlhf")
-        if len(rlhf_items) >= self.batch_size:
-            await self._create_rlhf_dataset(rlhf_items)
-
-    async def _create_sft_dataset(self, items: List[Dict[str, Any]]):
-        """Create and upload SFT dataset"""
-        dataset = await self.dataset_manager.create_dataset(
-            name=f"sft_dataset_v{datetime.now().strftime('%Y%m%d')}",
-            type="sft",
-            version=datetime.now().strftime("%Y%m%d"),
-            source_annotations=[item["annotation_id"] for item in items]
-        )
-        
-        formatted_data = [
-            await self._process_sft_item(item) 
-            for item in items
-        ]
-        
-        await self.dataset_manager.upload_dataset_file(
-            dataset.id,
-            formatted_data
-        )
-
-    async def _process_sft_item(self, item: Dict[str, Any]) -> Dict[str, Any]:
-        """Process item for SFT dataset generation
-        Format follows HF conversation format for SFT training
-        """
-        db = await config_manager.get_db('mongodb')
-        annotations = db['annotations']
-        
-        # Get full annotation context
-        annotation = await annotations.find_one({"_id": ObjectId(item["annotation_id"])})
-        target_item = next(i for i in annotation["items"] if i["item_id"] == item["item_id"])
-        
-        # Format as conversation
-        messages = [
-            {
-                "role": "system",
-                "content": "You are a helpful AI assistant that provides accurate and relevant information."
-            },
-            {
-                "role": "user",
-                "content": target_item["input"]["messages"][0]["content"]
-            },
-            {
-                "role": "assistant", 
-                "content": target_item["output"]["content"]
-            }
-        ]
-
-        return {
-            "messages": messages,
-            "metadata": {
-                "rating": item["feedback"]["rating"],
-                "aspects": item["feedback"]["aspects"],
-                "category": item["feedback"]["category"]
-            }
-        }
-
-    async def _process_rlhf_item(self, item: Dict[str, Any]) -> Dict[str, Any]:
-        """Process item for RLHF dataset generation
-        Format follows preference pairs structure for RLHF training
-        """
-        db = await config_manager.get_db('mongodb')
-        annotations = db['annotations']
-        
-        # Get full annotation context
-        annotation = await annotations.find_one({"_id": ObjectId(item["annotation_id"])})
-        target_item = next(i for i in annotation["items"] if i["item_id"] == item["item_id"])
-        
-        # Format as preference pairs
-        return {
-            "prompt": target_item["input"]["messages"][0]["content"],
-            "chosen": item["feedback"]["better_response"]["content"],
-            "rejected": target_item["output"]["content"],
-            "metadata": {
-                "reason": item["feedback"]["better_response"]["reason"],
-                "category": item["feedback"]["category"]
-            }
-        }
-
-    async def get_training_data(
-        self,
-        data_type: str,
-        limit: int = 1000
-    ) -> List[Dict[str, Any]]:
-        """Retrieve formatted training data"""
-        db = await config_manager.get_db('mongodb')
-        training_data = db['training_data']
-        
-        data = await training_data.find(
-            {"type": data_type}
-        ).limit(limit).to_list(length=limit)
-        
-        if data_type == "sft":
-            return [item["data"]["messages"] for item in data]
-        else:  # rlhf
-            return [{
-                "prompt": item["data"]["prompt"],
-                "chosen": item["data"]["chosen"],
-                "rejected": item["data"]["rejected"]
-            } for item in data]

isa_model/training/annotation/storage/dataset_manager.py

@@ -1,131 +0,0 @@
-# app/services/llm_model/annotation/dataset/dataset_manager.py
-from typing import Dict, Any, List
-from datetime import datetime
-import json
-import io
-from app.config.config_manager import config_manager
-from .dataset_schema import Dataset, DatasetType, DatasetStatus, DatasetFiles, DatasetStats
-from bson import ObjectId
-
-class DatasetManager:
-    def __init__(self):
-        self.logger = config_manager.get_logger(__name__)
-        self.minio_client = None
-        self.bucket_name = "training-datasets"
-
-    async def _ensure_minio_client(self):
-        if not self.minio_client:
-            self.minio_client = await config_manager.get_storage_client()
-
-    async def create_dataset(
-        self, 
-        name: str,
-        type: DatasetType,
-        version: str,
-        source_annotations: List[str]
-    ) -> Dataset:
-        """Create a new dataset record"""
-        db = await config_manager.get_db('mongodb')
-        collection = db['training_datasets']
-        
-        dataset = Dataset(
-            name=name,
-            type=type,
-            version=version,
-            storage_path=f"datasets/{type.value}/{version}",
-            files=DatasetFiles(
-                train="train.jsonl",
-                eval=None,
-                test=None
-            ),
-            stats=DatasetStats(
-                total_examples=0,
-                avg_length=0.0,
-                num_conversations=0,
-                additional_metrics={}
-            ),
-            source_annotations=source_annotations,
-            created_at=datetime.utcnow(),
-            status=DatasetStatus.PENDING,
-            metadata={}
-        )
-        
-        result = await collection.insert_one(dataset.dict(exclude={'id'}))
-        return Dataset(**{**dataset.dict(), '_id': result.inserted_id})
-
-    async def upload_dataset_file(
-        self,
-        dataset_id: str,
-        data: List[Dict[str, Any]],
-        file_type: str = "train"
-    ) -> bool:
-        """Upload dataset to MinIO"""
-        try:
-            await self._ensure_minio_client()
-            db = await config_manager.get_db('mongodb')
-            
-            object_id = ObjectId(dataset_id)
-            dataset = await db['training_datasets'].find_one({"_id": object_id})
-            
-            if not dataset:
-                self.logger.error(f"Dataset not found with id: {dataset_id}")
-                return False
-            
-            # Convert to JSONL
-            buffer = io.StringIO()
-            for item in data:
-                buffer.write(json.dumps(item) + "\n")
-            
-            storage_path = dataset['storage_path'].rstrip('/')
-            file_path = f"{storage_path}/{file_type}.jsonl"
-            
-            buffer_value = buffer.getvalue().encode()
-            
-            self.logger.debug(f"Uploading to MinIO path: {file_path}")
-            
-            self.minio_client.put_object(
-                self.bucket_name,
-                file_path,
-                io.BytesIO(buffer_value),
-                len(buffer_value)
-            )
-            
-            avg_length = sum(len(str(item)) for item in data) / len(data) if data else 0
-            
-            await db['training_datasets'].update_one(
-                {"_id": object_id},
-                {
-                    "$set": {
-                        f"files.{file_type}": f"{file_type}.jsonl",
-                        "stats.total_examples": len(data),
-                        "stats.avg_length": avg_length,
-                        "stats.num_conversations": len(data),
-                        "status": DatasetStatus.READY
-                    }
-                }
-            )
-            
-            return True
-            
-        except Exception as e:
-            self.logger.error(f"Failed to upload dataset: {e}")
-            return False
-
-    async def get_dataset_info(self, dataset_id: str) -> Dict[str, Any]:
-        """Get dataset information"""
-        try:
-            db = await config_manager.get_db('mongodb')
-            object_id = ObjectId(dataset_id)  # Convert string ID to ObjectId
-            dataset = await db['training_datasets'].find_one({"_id": object_id})
-            
-            if not dataset:
-                self.logger.error(f"Dataset not found with id: {dataset_id}")
-                return None
-            
-            # Convert ObjectId to string for JSON serialization
-            dataset['_id'] = str(dataset['_id'])
-            return dataset
-            
-        except Exception as e:
-            self.logger.error(f"Failed to get dataset info: {e}")
-            return None

isa_model/training/annotation/storage/dataset_schema.py

@@ -1,44 +0,0 @@
-# app/services/llm_model/annotation/dataset/dataset_schema.py
-from enum import Enum
-from pydantic import BaseModel, Field
-from typing import Dict, List, Optional
-from datetime import datetime
-from bson import ObjectId
-
-class DatasetType(str, Enum):
-    SFT = "sft"
-    RLHF = "rlhf"
-
-class DatasetStatus(str, Enum):
-    PENDING = "pending"
-    PROCESSING = "processing"
-    READY = "ready"
-    ERROR = "error"
-
-class DatasetFiles(BaseModel):
-    train: str
-    eval: Optional[str]
-    test: Optional[str]
-
-class DatasetStats(BaseModel):
-    total_examples: int
-    avg_length: Optional[float]
-    num_conversations: Optional[int]
-    additional_metrics: Optional[Dict] = {}
-
-class Dataset(BaseModel):
-    id: Optional[ObjectId] = Field(None, alias="_id")
-    name: str
-    type: DatasetType
-    version: str
-    storage_path: str
-    files: DatasetFiles
-    stats: DatasetStats
-    source_annotations: List[str]
-    created_at: datetime
-    status: DatasetStatus
-    metadata: Optional[Dict] = {}
-
-    class Config:
-        arbitrary_types_allowed = True
-        populate_by_name = True

isa_model/training/annotation/tests/test_annotation_flow.py

@@ -1,109 +0,0 @@
-# test_annotation_flow.py
-import os 
-os.environ["ENV"] = "local"
-
-import asyncio
-from datetime import datetime
-from bson import ObjectId
-from app.services.llm_model.annotation.views.annotation_controller import AnnotationController
-from app.services.llm_model.annotation.processors.annotation_processor import AnnotationProcessor
-from app.services.llm_model.annotation.annotation_schema import (
-    AnnotationFeedback, 
-    RatingScale, 
-    AnnotationType,
-    AnnotationAspects,
-    BetterResponse
-)
-from app.config.config_manager import config_manager 
-
-async def setup_test_data():
-    """Setup initial test data in MongoDB"""
-    db = await config_manager.get_db('mongodb')
-    
-    # Create a test annotation
-    test_annotation = {
-        "_id": ObjectId(),
-        "project_name": "test_project",
-        "items": [{
-            "item_id": "test_item_1",
-            "input": {
-                "messages": [{
-                    "role": "user",
-                    "content": "What is the capital of France?"
-                }]
-            },
-            "output": {
-                "content": "The capital of France is Paris."
-            },
-            "status": "pending"
-        }],
-        "created_at": datetime.utcnow().isoformat()
-    }
-    
-    await db['annotations'].insert_one(test_annotation)
-    return test_annotation
-
-async def test_annotation_flow():
-    """Test the complete annotation flow"""
-    try:
-        # Initialize controllers
-        annotation_controller = AnnotationController()
-        annotation_processor = AnnotationProcessor()
-        
-        # Setup test data
-        test_data = await setup_test_data()
-        annotation_id = str(test_data["_id"])
-        item_id = test_data["items"][0]["item_id"]
-        
-        print("1. Created test annotation")
-        
-        # Create test feedback
-        feedback = AnnotationFeedback(
-            rating=RatingScale.EXCELLENT,
-            category=AnnotationType.ACCURACY,
-            aspects=AnnotationAspects(
-                factually_correct=True,
-                relevant=True,
-                harmful=False,
-                biased=False,
-                complete=True,
-                efficient=True
-            ),
-            better_response=BetterResponse(
-                content="Paris is the capital city of France, known for its iconic Eiffel Tower.",
-                reason="Added more context and detail"
-            ),
-            comment="Good response, but could be more detailed"
-        )
-        
-        # Submit annotation
-        result = await annotation_controller.submit_annotation(
-            annotation_id=annotation_id,
-            item_id=item_id,
-            feedback=feedback,
-            annotator_id="test_annotator"
-        )
-        
-        print("2. Submitted annotation:", result)
-        
-        # Process annotation queue
-        await annotation_processor.process_queue()
-        print("3. Processed annotation queue")
-        
-        # Verify dataset creation
-        db = await config_manager.get_db('mongodb')
-        datasets = await db['training_datasets'].find().to_list(length=10)
-        
-        print("\nCreated Datasets:")
-        for dataset in datasets:
-            print(f"- {dataset['name']} ({dataset['type']})")
-            print(f"  Status: {dataset['status']}")
-            print(f"  Examples: {dataset['stats']['total_examples']}")
-            
-    except Exception as e:
-        print(f"Error during test: {e}")
-
-if __name__ == "__main__":
-    # Run the test
-    print("Starting annotation flow test...")
-    asyncio.run(test_annotation_flow())