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

npcpy/ft/diff.py

@@ -0,0 +1,110 @@
+# 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

@@ -0,0 +1,115 @@
+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/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