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

npcpy/data/text.py

@@ -37,70 +37,70 @@ def rag_search(
             )
     results = []
 
-    # Compute the embedding of the query
+    
     query_embedding = embedding_model.encode(
         query, convert_to_tensor=True, show_progress_bar=False
     )
     if isinstance(text_data, str):
-        # split at the sentence level
+        
         lines = text_data.split(".")
         if not lines:
             return results
-        # Compute embeddings for each line
+        
         if text_data_embedded is None:
             line_embeddings = embedding_model.encode(lines, convert_to_tensor=True)
         else:
             line_embeddings = text_data_embedded
-        # Compute cosine similarities
+        
         cosine_scores = util.cos_sim(query_embedding, line_embeddings)[0].cpu().numpy()
 
-        # Find indices of lines above the similarity threshold
+        
         relevant_line_indices = np.where(cosine_scores >= similarity_threshold)[0]
-        # print("relevant_line_indices", cosine_scores)
-        # print(np.mean(cosine_scores))
-        # print(np.max(cosine_scores))
+        
+        
+        
 
         for idx in relevant_line_indices:
             idx = int(idx)
-            # Get context lines (±10 lines)
+            
             start_idx = max(0, idx - 10)
-            end_idx = min(len(lines), idx + 11)  # +11 because end index is exclusive
+            end_idx = min(len(lines), idx + 11)  
             snippet = ". ".join(lines[start_idx:end_idx])
             results.append(snippet)
 
     elif isinstance(text_data, dict):
         for filename, content in text_data.items():
-            # Split content into lines
+            
             lines = content.split("\n")
             if not lines:
                 continue
-            # Compute embeddings for each line
+            
             if text_data_embedded is None:
                 line_embeddings = embedding_model.encode(lines, convert_to_tensor=True)
             else:
                 line_embeddings = text_data_embedded[filename]
-            # Compute cosine similarities
+            
             cosine_scores = (
                 util.cos_sim(query_embedding, line_embeddings)[0].cpu().numpy()
             )
 
-            # Find indices of lines above the similarity threshold
-            ##print("most similar", np.max(cosine_scores))
-            ##print("most similar doc", lines[np.argmax(cosine_scores)])
+            
+            
+            
             relevant_line_indices = np.where(cosine_scores >= similarity_threshold)[0]
-            # print("relevant_line_indices", cosine_scores)
-            # print(np.mean(cosine_scores))
-            # print(np.max(cosine_scores))
+            
+            
+            
             for idx in relevant_line_indices:
-                idx = int(idx)  # Ensure idx is an integer
-                # Get context lines (±10 lines)
+                idx = int(idx)  
+                
                 start_idx = max(0, idx - 10)
                 end_idx = min(
                     len(lines), idx + 11
-                )  # +11 because end index is exclusive
+                )  
                 snippet = "\n".join(lines[start_idx:end_idx])
                 results.append((filename, snippet))
-        # print("results", results)
+        
     return results
 
 
@@ -122,10 +122,10 @@ def load_all_files(
     """
     text_data = {}
     if depth < 1:
-        return text_data  # Reached the specified depth, stop recursion.
+        return text_data  
 
     if extensions is None:
-        # Default to common text file extensions
+        
         extensions = [
             ".txt",
             ".md",
@@ -139,11 +139,11 @@ def load_all_files(
             ".ts",
             ".tsx",
             ".npc",
-            # Add more extensions if needed
+            
         ]
 
     try:
-        # List all entries in the directory
+        
         entries = os.listdir(directory)
     except Exception as e:
         print(f"Could not list directory {directory}: {e}")
@@ -159,7 +159,7 @@ def load_all_files(
                 except Exception as e:
                     print(f"Could not read file {path}: {e}")
         elif os.path.isdir(path):
-            # Recurse into subdirectories, decreasing depth by 1
+            
             subdir_data = load_all_files(path, extensions, depth=depth - 1)
             text_data.update(subdir_data)
 

npcpy/data/video.py

@@ -1,8 +1,10 @@
-# video.py
+
 
 
 def process_video(file_path, table_name):
-    # implement with moon dream
+    
+    import cv2
+    import base64
 
     embeddings = []
     texts = []
@@ -16,37 +18,11 @@ def process_video(file_path, table_name):
             if not ret:
                 break
 
-            # Process every nth frame (adjust n as needed for performance)
-            n = 10  # Process every 10th frame
-            if i % n == 0:
-                # Image Embeddings
-                _, buffer = cv2.imencode(".jpg", frame)  # Encode frame as JPG
-                base64_image = base64.b64encode(buffer).decode("utf-8")
-                image_info = {
-                    "filename": f"frame_{i}.jpg",
-                    "file_path": f"data:image/jpeg;base64,{base64_image}",
-                }  # Use data URL for OpenAI
-                image_embedding_response = get_llm_response(
-                    "Describe this image.",
-                    image=image_info,
-                    model="gpt-4",
-                    provider="openai",
-                )  # Replace with your image embedding model
-                if (
-                    isinstance(image_embedding_response, dict)
-                    and "error" in image_embedding_response
-                ):
-                    print(
-                        f"Error generating image embedding: {image_embedding_response['error']}"
-                    )
-                else:
-                    # Assuming your image embedding model returns a textual description
-                    embeddings.append(image_embedding_response)
-                    texts.append(f"Frame {i}: {image_embedding_response}")
-
-        video.release()
+            
+            n = 10  
+        
         return embeddings, texts
 
     except Exception as e:
         print(f"Error processing video: {e}")
-        return [], []  # Return empty lists in case of error
+        return [], []  

npcpy/data/web.py

@@ -1,4 +1,4 @@
-# search.py
+
 
 import requests
 import os
@@ -21,6 +21,25 @@ except:
     pass
 
 
+
+
+
+def search_exa(query:str, 
+               api_key:str = None, 
+               top_k = 5,
+               **kwargs):
+    from exa_py import Exa
+    if api_key is None:
+        api_key = os.environ.get('EXA_API_KEY') 
+    exa = Exa(api_key)
+
+    results = exa.search_and_contents(
+        query, 
+        text=True   
+    )
+    return results.results[0:top_k]
+
+
 def search_perplexity(
     query: str,
     api_key: str = None,
@@ -30,8 +49,11 @@ def search_perplexity(
     top_p: float = 0.9,
 ):
     if api_key is None:
-        api_key = os.environ["PERPLEXITY_API_KEY"]
-    # print("api_key", api_key)
+        api_key = os.environ.get("PERPLEXITY_API_KEY")
+        if api_key is None: 
+            raise 
+        
+    
     url = "https://api.perplexity.ai/chat/completions"
     payload = {
         "model": "sonar",
@@ -52,13 +74,17 @@ def search_perplexity(
         "response_format": None,
     }
 
-    # Headers for the request, including the Authorization bearer token
-    headers = {"Authorization": f"Bearer {api_key}", "Content-Type": "application/json"}
+    
+    headers = {"Authorization": f"Bearer {api_key}", 
+               "Content-Type": "application/json"}
+
+    
+    response = requests.post(url,
+                             json=payload,
+                             headers=headers)
+    
+    response = response.json()
 
-    # Make the POST request to the API
-    response = requests.post(url, json=payload, headers=headers)
-    response = json.loads(response.text)
-    #print(response)
     return [response["choices"][0]["message"]["content"], response["citations"]]
 
 
@@ -68,7 +94,7 @@ def search_web(
     provider: str=None,
     api_key=None,
     perplexity_kwargs: Optional[Dict[str, Any]] = None,
-) -> List[Dict[str, str]]:
+) -> List:
     """
     Function Description:
         This function searches the web for information based on a query.
@@ -76,7 +102,7 @@ def search_web(
         query: The search query.
     Keyword Args:
         num_results: The number of search results to retrieve.
-        provider: The search engine provider to use ('google' or 'duckduckgo').
+        provider: The search engine provider to use ('perplexity' or 'duckduckgo').
     Returns:
         A list of dictionaries with 'title', 'link', and 'content' keys.
     """
@@ -88,7 +114,7 @@ def search_web(
 
     if provider == "perplexity":
         search_result = search_perplexity(query, api_key=api_key, **perplexity_kwargs)
-        # print(search_result, type(search_result))
+        
         return search_result
 
     if provider == "duckduckgo":
@@ -108,30 +134,32 @@ def search_web(
             print("DuckDuckGo search failed: ", e)
             urls = []
             results = []
+    elif provider =='exa':
+        return search_exa(query, api_key=api_key, )
 
-    elif provider =='google':  # google
+    elif provider =='google':  
         urls = list(search(query, num_results=num_results))
-        # google shit doesnt seem to be working anymore, apparently a lbock they made on browsers without js?
-        #print("urls", urls)
-        #print(provider)
+        
+        
+        
         for url in urls:
             try:
-                # Fetch the webpage content
+                
                 headers = {
                     "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36"
                 }
                 response = requests.get(url, headers=headers, timeout=5)
                 response.raise_for_status()
 
-                # Parse with BeautifulSoup
+                
                 soup = BeautifulSoup(response.text, "html.parser")
 
-                # Get title and content
+                
                 title = soup.title.string if soup.title else url
 
-                # Extract text content and clean it up
+                
                 content = " ".join([p.get_text() for p in soup.find_all("p")])
-                content = " ".join(content.split())  # Clean up whitespace
+                content = " ".join(content.split())  
 
                 results.append(
                     {
@@ -147,8 +175,8 @@ def search_web(
                 print(f"Error fetching {url}: {str(e)}")
                 continue
 
-    # except Exception as e:
-    #    print(f"Search error: {str(e)}")
+    
+    
     content_str = "\n".join(
         [r["content"] + "\n Citation: " + r["link"] + "\n\n\n" for r in results]
     )

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']