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

npcpy/ft/sft.py

@@ -0,0 +1,248 @@
+# structured fine tuning of LLMs to produce structured output
+from dataclasses import dataclass, field
+from datasets import Dataset
+import json
+import numpy as np
+import os
+try:
+    import torch
+    from transformers import (
+        AutoModelForCausalLM, 
+        AutoTokenizer, 
+        TrainingArguments
+    )
+    from trl import SFTTrainer
+    from peft import LoraConfig
+except:
+    torch = None
+    SFTTrainer = None
+    LoraConfig = None
+    AutoModelForCausalLM = None
+    AutoTokenizer = None
+    TrainingArguments = None
+
+from typing import List, Dict, Any, Optional
+
+
+@dataclass
+class SFTConfig:
+    base_model_name: str = "google/gemma-3-270m-it"
+    output_model_path: str = "models/sft_model"
+    lora_r: int = 8
+    lora_alpha: int = 16
+    use_4bit: bool = False
+    fp16: bool = False
+    bf16: bool = False
+    lora_dropout: float = 0.15
+    lora_target_modules: List[str] = field(
+        default_factory=lambda: ["q_proj", "v_proj"]
+    )
+    num_train_epochs: int = 20
+    per_device_train_batch_size: int = 2
+    gradient_accumulation_steps: int = 4
+    learning_rate: float = 3e-5
+    logging_steps: int = 10
+    optim: str = "adamw_torch"
+    lr_scheduler_type: str = "cosine_with_restarts"
+    weight_decay: float = 0.01
+    max_length: int = 512
+    save_steps: int = 50
+
+
+def format_training_examples(
+    inputs: List[str],
+    outputs: List[str],
+    format_style: str = "gemma"
+) -> List[Dict[str, str]]:
+
+    formatted = []
+    
+    for inp, out in zip(inputs, outputs):
+        if format_style == "gemma":
+            text = (
+                f"<start_of_turn>user\n{inp}<end_of_turn>\n"
+                f"<start_of_turn>model\n{out}<end_of_turn>"
+            )
+        elif format_style == "llama":
+            text = (
+                f"<|begin_of_text|><|start_header_id|>user"
+                f"<|end_header_id|>\n\n{inp}<|eot_id|>"
+                f"<|start_header_id|>assistant<|end_header_id|>"
+                f"\n\n{out}<|eot_id|>"
+            )
+        else:
+            text = f"Input: {inp}\nOutput: {out}"
+        
+        formatted.append({"text": text})
+    
+    return formatted
+
+
+def run_sft(
+    X: List[str],
+    y: List[str],
+    config: Optional[SFTConfig] = None,
+    validation_split: float = 0.0,
+    format_style: str = "gemma"
+) -> str:
+
+    if config is None:
+        config = SFTConfig()
+    
+    if len(X) != len(y):
+        raise ValueError(
+            f"X and y must have same length: {len(X)} vs {len(y)}"
+        )
+    
+    formatted_examples = format_training_examples(
+        X, y, format_style
+    )
+    
+    if validation_split > 0:
+        split_idx = int(len(formatted_examples) * (1 - validation_split))
+        train_examples = formatted_examples[:split_idx]
+        val_examples = formatted_examples[split_idx:]
+        print(
+            f"Split: {len(train_examples)} train, "
+            f"{len(val_examples)} val"
+        )
+    else:
+        train_examples = formatted_examples
+        val_examples = []
+    
+    dataset = Dataset.from_list(train_examples)
+    
+    model = AutoModelForCausalLM.from_pretrained(
+        config.base_model_name,
+        trust_remote_code=True,
+        attn_implementation="eager"
+    )
+    model.config.use_cache = False
+    
+    tokenizer = AutoTokenizer.from_pretrained(
+        config.base_model_name,
+        trust_remote_code=True
+    )
+    tokenizer.pad_token = tokenizer.eos_token
+    tokenizer.padding_side = "right"
+    
+    peft_config = LoraConfig(
+        r=config.lora_r,
+        lora_alpha=config.lora_alpha,
+        lora_dropout=config.lora_dropout,
+        target_modules=config.lora_target_modules,
+        bias="none",
+        task_type="CAUSAL_LM"
+    )
+    
+    training_args = TrainingArguments(
+        output_dir=config.output_model_path,
+        num_train_epochs=config.num_train_epochs,
+        per_device_train_batch_size=(
+            config.per_device_train_batch_size
+        ),
+        gradient_accumulation_steps=(
+            config.gradient_accumulation_steps
+        ),
+        optim=config.optim,
+        logging_steps=config.logging_steps,
+        learning_rate=config.learning_rate,
+        fp16=config.fp16,
+        bf16=config.bf16,
+        lr_scheduler_type=config.lr_scheduler_type,
+        group_by_length=True,
+        save_steps=config.save_steps,
+        weight_decay=config.weight_decay,
+    )
+            
+    def formatting_func(example):
+        return example["text"]
+
+    trainer = SFTTrainer(
+        model=model,
+        train_dataset=dataset,
+        peft_config=peft_config,
+        args=training_args,
+        processing_class=tokenizer,
+        formatting_func=formatting_func
+    )
+    
+    print(f"Training on {len(dataset)} examples")
+    trainer.train()
+    
+    trainer.save_model(config.output_model_path)
+    print(f"Model saved to {config.output_model_path}")
+    
+    return config.output_model_path
+
+
+def load_sft_model(model_path: str):
+
+    model = AutoModelForCausalLM.from_pretrained(
+        model_path,
+        torch_dtype=torch.float32,
+        device_map="auto",
+        attn_implementation="eager"
+    )
+    
+    tokenizer = AutoTokenizer.from_pretrained(
+        model_path,
+        trust_remote_code=True
+    )
+    
+    if tokenizer.pad_token is None:
+        tokenizer.pad_token = tokenizer.eos_token
+    
+    return model, tokenizer
+def predict_sft(
+    model,
+    tokenizer,
+    prompt: str,
+    max_new_tokens: int = 128,
+    temperature: float = 0.7
+) -> str:
+
+    device = next(model.parameters()).device
+    
+    formatted_prompt = (
+        f"<start_of_turn>user\n{prompt}<end_of_turn>\n"
+        f"<start_of_turn>model\n"
+    )
+    
+    inputs = tokenizer(
+        formatted_prompt,
+        return_tensors="pt",
+        truncation=True,
+        max_length=512
+    )
+    
+    input_ids = inputs.input_ids.to(device)
+    attention_mask = inputs.attention_mask.to(device)
+    
+    with torch.no_grad():
+        outputs = model.generate(
+            input_ids=input_ids,
+            attention_mask=attention_mask,
+            max_new_tokens=max_new_tokens,
+            temperature=temperature,
+            do_sample=temperature > 0,
+            pad_token_id=tokenizer.eos_token_id
+        )
+    
+    full_response = tokenizer.decode(
+        outputs[0],
+        skip_special_tokens=False
+    )
+    
+    if "<start_of_turn>model\n" in full_response:
+        response = full_response.split(
+            "<start_of_turn>model\n"
+        )[-1]
+        response = response.split("<end_of_turn>")[0].strip()
+    else:
+        response = tokenizer.decode(
+            outputs[0][len(input_ids[0]):],
+            skip_special_tokens=True
+        )
+    
+    return response

npcpy/ft/usft.py

@@ -0,0 +1,128 @@
+from dataclasses import dataclass, field
+try:
+    from datasets import Dataset, load_dataset
+    import torch
+    from transformers import (
+        AutoModelForCausalLM,
+        AutoTokenizer,
+        TrainingArguments
+    )
+    from trl import SFTTrainer
+    from peft import LoraConfig
+except:
+    Dataset = None
+    load_dataset = None
+    torch = None
+    AutoModelForCausalLM = None
+    AutoTokenizer = None
+    TrainingArguments = None
+    SFTTrainer = None
+    
+from typing import List, Optional
+
+
+@dataclass
+class USFTConfig:
+    base_model_name: str = "Qwen/Qwen3-0.6B"
+    output_model_path: str = "models/usft_model"
+    lora_r: int = 8
+    lora_alpha: int = 16
+    lora_dropout: float = 0.15
+    lora_target_modules: List[str] = field(
+        default_factory=lambda: ["q_proj", "v_proj"]
+    )
+    num_train_epochs: int = 3
+    per_device_train_batch_size: int = 4
+    gradient_accumulation_steps: int = 4
+    learning_rate: float = 2e-5
+    logging_steps: int = 10
+    optim: str = "adamw_torch"
+    lr_scheduler_type: str = "cosine"
+    weight_decay: float = 0.01
+    max_length: int = 512
+    save_steps: int = 100
+
+
+def run_usft(
+    texts: List[str],
+    config: Optional[USFTConfig] = None
+) -> str:
+    
+    if config is None:
+        config = USFTConfig()
+    
+    dataset = Dataset.from_dict({"text": texts})
+    
+    model = AutoModelForCausalLM.from_pretrained(
+        config.base_model_name,
+        trust_remote_code=True,
+        attn_implementation="eager"
+    )
+    model.config.use_cache = False
+    
+    tokenizer = AutoTokenizer.from_pretrained(
+        config.base_model_name,
+        trust_remote_code=True
+    )
+    
+    if tokenizer.pad_token is None:
+        tokenizer.pad_token = tokenizer.eos_token
+    
+    tokenizer.padding_side = "right"
+    
+    peft_config = LoraConfig(
+        r=config.lora_r,
+        lora_alpha=config.lora_alpha,
+        lora_dropout=config.lora_dropout,
+        target_modules=config.lora_target_modules,
+        bias="none",
+        task_type="CAUSAL_LM"
+    )
+    
+    training_args = TrainingArguments(
+        output_dir=config.output_model_path,
+        num_train_epochs=config.num_train_epochs,
+        per_device_train_batch_size=(
+            config.per_device_train_batch_size
+        ),
+        gradient_accumulation_steps=(
+            config.gradient_accumulation_steps
+        ),
+        optim=config.optim,
+        logging_steps=config.logging_steps,
+        learning_rate=config.learning_rate,
+        fp16=False,
+        bf16=torch.cuda.is_available(),
+        lr_scheduler_type=config.lr_scheduler_type,
+        save_steps=config.save_steps,
+        weight_decay=config.weight_decay,
+    )
+    
+    trainer = SFTTrainer(
+        model=model,
+        train_dataset=dataset,
+        peft_config=peft_config,
+        args=training_args,
+        max_seq_length=config.max_length,
+        dataset_text_field="text"
+    )
+    
+    print(f"Starting USFT on {len(dataset)} texts")
+    trainer.train()
+    
+    trainer.save_model(config.output_model_path)
+    print(f"Model saved to {config.output_model_path}")
+    
+    return config.output_model_path
+
+
+def load_corpus_from_hf(dataset_name: str, split: str = "train"):
+    
+    ds = load_dataset(dataset_name, split=split)
+    
+    if "text" in ds.column_names:
+        return ds["text"]
+    elif "content" in ds.column_names:
+        return ds["content"]
+    else:
+        return [str(item) for item in ds]

npcpy/gen/audio_gen.py

@@ -0,0 +1,24 @@
+import os
+def tts_elevenlabs(text, 
+                   api_key=None,
+                   voice_id='JBFqnCBsd6RMkjVDRZzb', 
+                   model_id='eleven_multilingual_v2',
+                   output_format= 'mp3_44100_128'):
+    if api_key is None:
+        api_key = os.environ.get('ELEVENLABS_API_KEY')
+    from elevenlabs.client import ElevenLabs
+    from elevenlabs import play
+
+    client = ElevenLabs(
+        api_key=api_key,
+    )
+
+    audio = client.text_to_speech.convert(
+        text=text,
+        voice_id=voice_id,
+        model_id=model_id,
+        output_format= output_format
+    )
+
+    play(audio)
+    return audio

npcpy/gen/embeddings.py

@@ -1,9 +1,9 @@
-#######
-#######
-#######
-#######
-####### EMBEDDINGS
-#######
+
+
+
+
+
+
 from typing import List, Dict, Optional
 import numpy as np
 from datetime import datetime
@@ -49,17 +49,17 @@ def store_embeddings_for_model(
     collection_name = f"{provider}_{model}_embeddings"
     collection = chroma_client.get_collection(collection_name)
 
-    # Create meaningful metadata for each document (adjust as necessary)
+    
     if metadata is None:
-        metadata = [{"text_length": len(text)} for text in texts]  # Example metadata
+        metadata = [{"text_length": len(text)} for text in texts]  
         print(
             "metadata is none, creating metadata for each document as the length of the text"
         )
-    # Add embeddings to the collection with metadata
+    
     collection.add(
         ids=[str(i) for i in range(len(texts))],
         embeddings=embeddings,
-        metadatas=metadata,  # Passing populated metadata
+        metadatas=metadata,  
         documents=texts,
     )
 
@@ -67,7 +67,7 @@ def store_embeddings_for_model(
 def delete_embeddings_from_collection(collection, ids):
     """Delete embeddings by id from Chroma collection."""
     if ids:
-        collection.delete(ids=ids)  # Only delete if ids are provided
+        collection.delete(ids=ids)  
 
 
 def get_embeddings(
@@ -83,6 +83,6 @@ def get_embeddings(
     else:
         raise ValueError(f"Unsupported provider: {provider}")
 
-    # Store the embeddings in the relevant Chroma collection
-    # store_embeddings_for_model(texts, embeddings, model, provider)
+    
+    
     return embeddings

npcpy/gen/image_gen.py

@@ -86,6 +86,16 @@ def generate_image_diffusers(
         else:
             raise e
 
+import os
+import base64
+import io
+from typing import Union, List, Optional
+
+import PIL
+from PIL import Image
+
+import requests
+from urllib.request import urlopen
 
 def openai_image_gen(
     prompt: str,
@@ -97,36 +107,47 @@ def openai_image_gen(
 ):
     """Generate or edit an image using the OpenAI API."""
     from openai import OpenAI
-    
+
     client = OpenAI()
-    
+
     if height is None:
         height = 1024
     if width is None:
-        width = 1024  
-    
-    size_str = f"{width}x{height}" 
+        width = 1024
+
+    size_str = f"{width}x{height}"
 
     if attachments is not None:
         processed_images = []
+        files_to_close = []
         for attachment in attachments:
             if isinstance(attachment, str):
-                processed_images.append(open(attachment, "rb"))
+                file_handle = open(attachment, "rb")
+                processed_images.append(file_handle)
+                files_to_close.append(file_handle)
             elif isinstance(attachment, bytes):
-                processed_images.append(io.BytesIO(attachment))
+                img_byte_arr = io.BytesIO(attachment)
+                img_byte_arr.name = 'image.png'  # FIX: Add filename hint
+                processed_images.append(img_byte_arr)
             elif isinstance(attachment, Image.Image):
                 img_byte_arr = io.BytesIO()
                 attachment.save(img_byte_arr, format='PNG')
                 img_byte_arr.seek(0)
+                img_byte_arr.name = 'image.png'  # FIX: Add filename hint
                 processed_images.append(img_byte_arr)
         
-        result = client.images.edit(
-            model=model,
-            image=processed_images[0],
-            prompt=prompt,
-            n=n_images,
-            size=size_str,
-        )
+        try:
+            result = client.images.edit(
+                model=model,
+                image=processed_images[0],
+                prompt=prompt,
+                n=n_images,
+                size=size_str,
+            )
+        finally:
+            # This ensures any files we opened are properly closed
+            for f in files_to_close:
+                f.close()
     else:
         result = client.images.generate(
             model=model,
@@ -134,7 +155,7 @@ def openai_image_gen(
             n=n_images,
             size=size_str,
         )
-    
+
     collected_images = []
     for item_data in result.data:
         if model == 'gpt-image-1':
@@ -153,6 +174,7 @@ def openai_image_gen(
     return collected_images
 
 
+
 def gemini_image_gen(
     prompt: str,
     model: str = "gemini-2.5-flash",