npcpy 1.2.21__py3-none-any.whl → 1.2.23__py3-none-any.whl

npcpy/data/load.py

@@ -132,7 +132,7 @@ def load_file_contents(file_path, chunk_size=None):
         elif file_ext in ['XLS', 'XLSX']:
             df = load_excel(file_path)
             full_content = df.to_string()
-        elif file_ext in ['TXT', 'MD', 'PY', 'JSX', 'TSX', 'TS', 'JS', 'JSON', 'SQL', 'NPC', 'JINX', 'LINE', 'YAML']:
+        elif file_ext in ['TXT', 'MD', 'PY', 'JSX', 'TSX', 'TS', 'JS', 'JSON', 'SQL', 'NPC', 'JINX', 'LINE', 'YAML', 'DART', 'JAVA']:
             full_content = load_txt(file_path)
         elif file_ext == 'JSON':
             data = load_json(file_path)

npcpy/ft/diff.py

@@ -1 +1,110 @@
-# finetuning diffuser models
+# finetuning diffuser models
+try:
+    import torch
+    import torch.nn as nn
+    import torch.nn.functional as F
+    from torch.utils.data import DataLoader, Dataset as TorchDataset
+    from transformers import CLIPTextModel, CLIPTokenizer
+except:
+    torch = None
+    nn = None    
+    F = None
+    DataLoader = None
+    TorchDataset = None
+    CLIPTextModel = None
+    CLIPTokenizer = None
+import math
+from dataclasses import dataclass, field
+from typing import List, Optional, Callable
+import numpy as np
+from PIL import Image
+import os
+from tqdm import tqdm
+import gc
+
+
+@dataclass
+class DiffusionConfig:
+    image_size: int = 128
+    channels: int = 256
+    time_emb_dim: int = 128
+    timesteps: int = 1000
+    beta_start: float = 1e-4
+    beta_end: float = 0.02
+    num_epochs: int = 100
+    batch_size: int = 4
+    learning_rate: float = 1e-5
+    checkpoint_frequency: int = 1000
+    output_dir: str = "diffusion_model"
+    use_clip: bool = True
+    num_channels: int = 1
+
+
+class SinusoidalPositionEmbeddings(nn.Module):
+    
+    def __init__(self, dim):
+        super().__init__()
+        self.dim = dim
+
+    def forward(self, time):
+        device = time.device
+        half_dim = self.dim // 2
+        embeddings = math.log(10000) / (half_dim - 1)
+        embeddings = torch.exp(
+            torch.arange(half_dim, device=device) * -embeddings
+        )
+        embeddings = time[:, None] * embeddings[None, :]
+        embeddings = torch.cat(
+            (embeddings.sin(), embeddings.cos()),
+            dim=-1
+        )
+        return embeddings
+
+
+class SimpleUNet(nn.Module):
+    
+    def __init__(
+        self,
+        image_size=128,
+        channels=256,
+        time_emb_dim=128,
+        num_channels=1
+    ):
+        super().__init__()
+        
+        self.image_size = image_size
+        
+        self.time_mlp = nn.Sequential(
+            SinusoidalPositionEmbeddings(time_emb_dim),
+            nn.Linear(time_emb_dim, time_emb_dim * 4),
+            nn.GELU(),
+            nn.Linear(time_emb_dim * 4, channels),
+        )
+        
+        self.text_mlp = nn.Sequential(
+            nn.Linear(768, time_emb_dim),
+            nn.GELU(),
+            nn.Linear(time_emb_dim, time_emb_dim),
+            nn.GELU(),
+            nn.Linear(time_emb_dim, channels),
+        )
+        
+        self.conv_in = nn.Conv2d(num_channels, channels, 1, padding=0)
+        
+        self.down1 = nn.Sequential(
+            nn.Conv2d(channels, channels * 2, 4, 2, 1),
+            nn.GroupNorm(8, channels * 2),
+            nn.GELU(),
+        )
+        
+        self.down2 = nn.Sequential(
+            nn.Conv2d(channels * 2, channels * 4, 4, 2, 1),
+            nn.GroupNorm(8, channels * 4),
+            nn.GELU(),
+        )
+        
+        self.down3 = nn.Sequential(
+            nn.Conv2d(channels * 4, channels * 8, 4, 2, 1),
+            nn.GroupNorm(8, channels * 8),
+            nn.GELU(),
+        )

npcpy/ft/ge.py

@@ -1 +1,115 @@
-# genetic engineering for using genetic algorithms with LLMs 
+import random
+from dataclasses import dataclass
+from typing import Callable, Optional, List
+
+
+@dataclass
+class GAConfig:
+    population_size: int = 20
+    mutation_rate: float = 0.15
+    crossover_rate: float = 0.7
+    tournament_size: int = 3
+    elitism_count: int = 2
+    generations: int = 50
+
+
+class GeneticEvolver:
+    """
+    Generic GA that takes fitness, mutation, crossover 
+    and initialization functions to evolve any population
+    """
+    def __init__(
+        self,
+        fitness_fn: Callable,
+        mutate_fn: Callable,
+        crossover_fn: Callable,
+        initialize_fn: Callable,
+        config: Optional[GAConfig] = None
+    ):
+        self.fitness_fn = fitness_fn
+        self.mutate_fn = mutate_fn
+        self.crossover_fn = crossover_fn
+        self.initialize_fn = initialize_fn
+        self.config = config or GAConfig()
+        self.population = []
+        self.history = []
+    
+    def initialize_population(self):
+        self.population = [
+            self.initialize_fn() 
+            for _ in range(self.config.population_size)
+        ]
+    
+    def evaluate_population(self) -> List[float]:
+        return [
+            self.fitness_fn(individual) 
+            for individual in self.population
+        ]
+    
+    def tournament_select(self, fitness_scores: List[float]):
+        indices = random.sample(
+            range(len(self.population)),
+            self.config.tournament_size
+        )
+        tournament_fitness = [fitness_scores[i] for i in indices]
+        winner_idx = indices[
+            tournament_fitness.index(max(tournament_fitness))
+        ]
+        return self.population[winner_idx]
+    
+    def evolve_generation(self):
+        fitness_scores = self.evaluate_population()
+        
+        sorted_pop = sorted(
+            zip(self.population, fitness_scores),
+            key=lambda x: x[1],
+            reverse=True
+        )
+        
+        new_population = [
+            ind for ind, _ in sorted_pop[:self.config.elitism_count]
+        ]
+        
+        while len(new_population) < self.config.population_size:
+            parent1 = self.tournament_select(fitness_scores)
+            parent2 = self.tournament_select(fitness_scores)
+            
+            if random.random() < self.config.crossover_rate:
+                child = self.crossover_fn(parent1, parent2)
+            else:
+                child = parent1
+            
+            if random.random() < self.config.mutation_rate:
+                child = self.mutate_fn(child)
+            
+            new_population.append(child)
+        
+        self.population = new_population[:self.config.population_size]
+        
+        best_fitness = max(fitness_scores)
+        avg_fitness = sum(fitness_scores) / len(fitness_scores)
+        
+        return {
+            'best_fitness': best_fitness,
+            'avg_fitness': avg_fitness,
+            'best_individual': sorted_pop[0][0]
+        }
+    
+    def run(self, generations: Optional[int] = None):
+        if not self.population:
+            self.initialize_population()
+        
+        gens = generations or self.config.generations
+        
+        for gen in range(gens):
+            gen_stats = self.evolve_generation()
+            self.history.append(gen_stats)
+            
+            if gen % 10 == 0:
+                print(
+                    f"Gen {gen}: "
+                    f"Best={gen_stats['best_fitness']:.3f}, "
+                    f"Avg={gen_stats['avg_fitness']:.3f}"
+                )
+        
+        return self.history[-1]['best_individual']

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
+        )