npcpy 1.0.26__py3-none-any.whl → 1.2.32__py3-none-any.whl

npcpy/ft/memory_trainer.py

@@ -0,0 +1,171 @@
+try:
+    from torch.utils.data import Dataset
+    import torch
+    import torch.nn as nn
+    from transformers import AutoTokenizer, AutoModelForSequenceClassification, Trainer, TrainingArguments
+
+    import json
+    from typing import List, Dict, Tuple
+    import random
+
+    class MemoryDataset(Dataset):
+        def __init__(self, examples: List[Dict], tokenizer, max_length=512):
+            self.examples = examples
+            self.tokenizer = tokenizer
+            self.max_length = max_length
+        
+        def __len__(self):
+            return len(self.examples)
+        
+        def __getitem__(self, idx):
+            example = self.examples[idx]
+            
+            
+            text = f"Memory: {example['memory']}\nContext: {example.get('context', '')}"
+            
+            encoding = self.tokenizer(
+                text,
+                truncation=True,
+                padding='max_length',
+                max_length=self.max_length,
+                return_tensors='pt'
+            )
+            
+            return {
+                'input_ids': encoding['input_ids'].flatten(),
+                'attention_mask': encoding['attention_mask'].flatten(),
+                'labels': torch.tensor(example['label'], dtype=torch.long)
+            }
+
+    class MemoryTrainer:
+        def __init__(self, model_name="google/gemma-2b", device="cpu"):
+            self.device = device
+            self.tokenizer = AutoTokenizer.from_pretrained(model_name)
+            if self.tokenizer.pad_token is None:
+                self.tokenizer.pad_token = self.tokenizer.eos_token
+            
+            
+            self.model = AutoModelForSequenceClassification.from_pretrained(
+                model_name, 
+                num_labels=3
+            ).to(device)
+        
+        def prepare_training_data(self, approved_memories: List[Dict], 
+                                rejected_memories: List[Dict]) -> List[Dict]:
+            """Prepare training data from memory examples"""
+            examples = []
+            
+            
+            for memory in approved_memories:
+                examples.append({
+                    "memory": memory.get("final_memory") or memory.get("initial_memory"),
+                    "context": memory.get("context", ""),
+                    "label": 1
+                })
+            
+            
+            for memory in rejected_memories:
+                examples.append({
+                    "memory": memory.get("initial_memory"),
+                    "context": memory.get("context", ""),
+                    "label": 0
+                })
+            
+            
+            edited_examples = []
+            for memory in approved_memories[:len(rejected_memories)//2]:
+                if memory.get("final_memory") and memory.get("initial_memory"):
+                    
+                    edited_examples.append({
+                        "memory": memory.get("initial_memory"),
+                        "context": memory.get("context", ""),
+                        "label": 2
+                    })
+            
+            examples.extend(edited_examples)
+            random.shuffle(examples)
+            return examples
+
+        def train(self, approved_memories: List[Dict], rejected_memories: List[Dict], 
+                output_dir: str = "./memory_model", epochs: int = 3):
+            """Train the memory classification model"""
+            
+            if len(approved_memories) < 10 or len(rejected_memories) < 10:
+                print("Not enough training data. Need at least 10 approved and 10 rejected memories.")
+                return False
+            
+            training_data = self.prepare_training_data(approved_memories, rejected_memories)
+            
+            
+            split_idx = int(0.8 * len(training_data))
+            train_data = training_data[:split_idx]
+            val_data = training_data[split_idx:]
+            
+            train_dataset = MemoryDataset(train_data, self.tokenizer)
+            val_dataset = MemoryDataset(val_data, self.tokenizer)
+            
+            training_args = TrainingArguments(
+                output_dir=output_dir,
+                num_train_epochs=epochs,
+                per_device_train_batch_size=4,
+                per_device_eval_batch_size=4,
+                warmup_steps=100,
+                weight_decay=0.01,
+                logging_dir='./logs',
+                evaluation_strategy="epoch",
+                save_strategy="epoch",
+                load_best_model_at_end=True,
+            )
+            
+            trainer = Trainer(
+                model=self.model,
+                args=training_args,
+                train_dataset=train_dataset,
+                eval_dataset=val_dataset,
+            )
+            
+            trainer.train()
+            trainer.save_model()
+            self.tokenizer.save_pretrained(output_dir)
+            
+            print(f"Model trained and saved to {output_dir}")
+            return True
+
+        def predict_memory_action(self, memory_content: str, context: str = "") -> Tuple[str, float]:
+            """Predict what action to take on a memory"""
+            text = f"Memory: {memory_content}\nContext: {context}"
+            
+            encoding = self.tokenizer(
+                text,
+                truncation=True,
+                padding=True,
+                max_length=512,
+                return_tensors='pt'
+            ).to(self.device)
+            
+            with torch.no_grad():
+                outputs = self.model(**encoding)
+                probabilities = torch.softmax(outputs.logits, dim=-1)
+                predicted_class = torch.argmax(probabilities, dim=-1).item()
+                confidence = probabilities[0][predicted_class].item()
+            
+            actions = {0: "model-rejected", 1: "model-approved", 2: "needs-editing"}
+            return actions[predicted_class], confidence
+
+        def auto_approve_memory(self, memory_content: str, context: str = "", 
+                            confidence_threshold: float = 0.8) -> Dict:
+            """Auto-approve memory if confidence is high enough"""
+            action, confidence = self.predict_memory_action(memory_content, context)
+            
+            if confidence >= confidence_threshold:
+                return {"action": action, "confidence": confidence, "auto_processed": True}
+            else:
+                return {"action": "pending_approval", "confidence": confidence, "auto_processed": False}    
+except:
+    Dataset = None
+    nn = None
+    Trainer = None
+    TrainingArguments = None
+
+    MemoryDataset = None
+    MemoryTrainer = None

npcpy/ft/model_ensembler.py

@@ -0,0 +1,357 @@
+import time
+import copy
+import random
+from dataclasses import dataclass, field
+from typing import List, Dict, Any, Optional
+from npcpy.llm_funcs import get_llm_response
+
+try:
+    from npcpy.ft.sft import predict_sft, load_sft_model
+except:
+    pass
+
+@dataclass
+class ModelGene:
+    """
+    Represents a specialized model with trigger patterns 
+    and confidence threshold
+    """
+    sft_path: Optional[str] = None
+    rl_path: Optional[str] = None
+    base_model: str = "Qwen/Qwen3-0.6B"
+    specialization: str = "general"
+    trigger_patterns: List[str] = field(default_factory=list)
+    confidence_threshold: float = 0.7
+
+
+def generate_trigger_patterns(specialization: str) -> List[str]:
+    """
+    Generate trigger patterns for a given specialization domain
+    """
+    patterns = {
+        'math': ['calculate', 'solve', 'equation', 'number'],
+        'code': ['function', 'class', 'bug', 'debug', 'code'],
+        'creative': ['story', 'poem', 'creative', 'imagine'],
+        'factual': ['what is', 'who is', 'when did', 'where is'],
+        'analysis': ['analyze', 'compare', 'evaluate', 'assess']
+    }
+    
+    return patterns.get(specialization, ['general'])
+
+
+def create_model_genome(
+    specializations: List[str],
+    base_model: str = "Qwen/Qwen3-0.6B"
+) -> List[ModelGene]:
+    """
+    Initialize a genome of specialized models
+    """
+    genome = []
+    
+    for spec in specializations:
+        gene = ModelGene(
+            base_model=base_model,
+            specialization=spec,
+            trigger_patterns=generate_trigger_patterns(spec),
+            confidence_threshold=random.uniform(0.6, 0.9)
+        )
+        genome.append(gene)
+    
+    return genome
+
+
+def mutate_model_genome(
+    genome: List[ModelGene],
+    mutation_type: str = 'random'
+) -> List[ModelGene]:
+    """
+    Apply genetic mutation to model genome
+    """
+    new_genome = copy.deepcopy(genome)
+    
+    mutations = [
+        'adjust_threshold',
+        'add_trigger',
+        'remove_gene',
+        'duplicate_gene'
+    ]
+    
+    if mutation_type == 'random':
+        mutation_type = random.choice(mutations)
+    
+    if mutation_type == 'adjust_threshold':
+        gene = random.choice(new_genome)
+        gene.confidence_threshold += random.uniform(-0.1, 0.1)
+        gene.confidence_threshold = max(
+            0.5,
+            min(0.95, gene.confidence_threshold)
+        )
+    
+    elif mutation_type == 'add_trigger':
+        gene = random.choice(new_genome)
+        new_trigger = f"pattern_{random.randint(1, 100)}"
+        if new_trigger not in gene.trigger_patterns:
+            gene.trigger_patterns.append(new_trigger)
+    
+    elif mutation_type == 'remove_gene' and len(new_genome) > 1:
+        new_genome.pop(random.randint(0, len(new_genome) - 1))
+    
+    elif mutation_type == 'duplicate_gene':
+        gene = random.choice(new_genome)
+        new_gene = copy.deepcopy(gene)
+        new_gene.specialization = f"{gene.specialization}_variant"
+        new_genome.append(new_gene)
+    
+    return new_genome
+
+
+def crossover_model_genomes(
+    genome1: List[ModelGene],
+    genome2: List[ModelGene]
+) -> List[ModelGene]:
+    """
+    Crossover two model genomes to create child genome
+    """
+    if not genome1 or not genome2:
+        return genome1 or genome2
+    
+    split = random.randint(1, min(len(genome1), len(genome2)) - 1)
+    
+    child = genome1[:split] + genome2[split:]
+    
+    return child
+
+
+def evaluate_model_genome(
+    genome: List[ModelGene],
+    test_cases: List[Dict[str, Any]],
+    router: 'ResponseRouter'
+) -> float:
+    """
+    Evaluate fitness of a model genome based on accuracy, 
+    speed and efficiency
+    """
+    correct = 0
+    total_time = 0
+    fast_responses = 0
+    
+    for test_case in test_cases:
+        result = router.route_query(
+            test_case['query'],
+            genome,
+            test_case.get('ground_truth')
+        )
+        
+        if result['correct']:
+            correct += 1
+        
+        total_time += result['response_time']
+        
+        if result['used_fast_path']:
+            fast_responses += 1
+    
+    accuracy = correct / len(test_cases)
+    speed_bonus = fast_responses / len(test_cases)
+    efficiency = 1.0 / (total_time / len(test_cases))
+    
+    fitness = (
+        accuracy * 0.6 +
+        speed_bonus * 0.2 +
+        efficiency * 0.2
+    )
+    
+    return fitness
+
+
+class ResponseRouter:
+    """
+    Routes queries through fast path, ensemble or full reasoning 
+    based on confidence thresholds
+    """
+    def __init__(
+        self,
+        fast_threshold: float = 0.8,
+        ensemble_threshold: float = 0.6
+    ):
+        self.fast_threshold = fast_threshold
+        self.ensemble_threshold = ensemble_threshold
+        self.response_cache = {}
+    
+    def route_query(
+        self,
+        query: str,
+        genome: List[ModelGene],
+        ground_truth: Optional[str] = None
+    ) -> Dict[str, Any]:
+        """
+        Route query through system 1 fast path, 
+        ensemble or system 2 reasoning
+        """
+        start_time = time.time()
+        
+        fast_response = self._try_fast_path(query, genome)
+        
+        if fast_response and fast_response['confidence'] > (
+            self.fast_threshold
+        ):
+            response_time = time.time() - start_time
+            
+            return {
+                'response': fast_response['answer'],
+                'confidence': fast_response['confidence'],
+                'used_fast_path': True,
+                'response_time': response_time,
+                'correct': (
+                    ground_truth is None or 
+                    self._check_correctness(
+                        fast_response['answer'],
+                        ground_truth
+                    )
+                )
+            }
+        
+        ensemble_response = self._try_ensemble(query, genome)
+        
+        if ensemble_response['confidence'] > (
+            self.ensemble_threshold
+        ):
+            response_time = time.time() - start_time
+            
+            return {
+                'response': ensemble_response['answer'],
+                'confidence': ensemble_response['confidence'],
+                'used_fast_path': False,
+                'used_ensemble': True,
+                'response_time': response_time,
+                'correct': (
+                    ground_truth is None or
+                    self._check_correctness(
+                        ensemble_response['answer'],
+                        ground_truth
+                    )
+                )
+            }
+        
+        full_response = self._full_reasoning(query)
+        response_time = time.time() - start_time
+        
+        return {
+            'response': full_response,
+            'confidence': 0.5,
+            'used_fast_path': False,
+            'used_ensemble': False,
+            'response_time': response_time,
+            'correct': (
+                ground_truth is None or
+                self._check_correctness(
+                    full_response,
+                    ground_truth
+                )
+            )
+        }
+    
+    def _try_fast_path(
+        self,
+        query: str,
+        genome: List[ModelGene]
+    ) -> Optional[Dict[str, Any]]:
+        """
+        Try fast system 1 gut reaction using pattern matching
+        """
+        query_lower = query.lower()
+        
+        for gene in genome:
+            if any(
+                pattern in query_lower 
+                for pattern in gene.trigger_patterns
+            ):
+                if gene.sft_path:
+                    model, tokenizer = load_sft_model(gene.sft_path)
+                    
+                    response = predict_sft(
+                        model,
+                        tokenizer,
+                        query,
+                        temperature=0.1
+                    )
+                    
+                    return {
+                        'answer': response,
+                        'confidence': gene.confidence_threshold
+                    }
+        
+        return None
+    
+    def _try_ensemble(
+        self,
+        query: str,
+        genome: List[ModelGene]
+    ) -> Dict[str, Any]:
+        """
+        Try ensemble voting across specialized models
+        """
+        responses = []
+        
+        for gene in genome:
+            if gene.sft_path or gene.rl_path:
+                model_path = gene.rl_path or gene.sft_path
+                
+                model, tokenizer = load_sft_model(model_path)
+                
+                response = predict_sft(
+                    model,
+                    tokenizer,
+                    query,
+                    temperature=0.3
+                )
+                
+                responses.append({
+                    'answer': response,
+                    'weight': gene.confidence_threshold
+                })
+        
+        if not responses:
+            return {'answer': '', 'confidence': 0.0}
+        
+        best_response = max(responses, key=lambda x: x['weight'])
+        
+        avg_confidence = sum(
+            r['weight'] for r in responses
+        ) / len(responses)
+        
+        return {
+            'answer': best_response['answer'],
+            'confidence': avg_confidence
+        }
+    
+    def _full_reasoning(
+        self,
+        query: str,
+        model: str = "qwen3:1.7b",
+        provider: str = "ollama"
+    ) -> str:
+        """
+        Fall back to full system 2 reasoning
+        """
+        response = get_llm_response(
+            query,
+            model=model,
+            provider=provider
+        )
+        
+        return response.get('response', '')
+    
+    def _check_correctness(
+        self,
+        response: str,
+        ground_truth: str
+    ) -> bool:
+        """
+        Check if response matches ground truth
+        """
+        response_lower = response.lower().strip()
+        truth_lower = ground_truth.lower().strip()
+        
+        return response_lower == truth_lower or (
+            truth_lower in response_lower
+        )