changing library

app/services/embedding_service copy.py

@@ -0,0 +1,97 @@
+import logging
+import numpy as np
+from typing import List, Dict, Any, Tuple
+from sentence_transformers import SentenceTransformer
+import torch
+import os
+
+os.environ["PYTORCH_ENABLE_META_TENSORS"] = "0"
+
+logger = logging.getLogger(__name__)
+
+class EmbeddingService:
+    """Service for handling document embeddings using Sentence Transformers."""
+    
+    def __init__(self, model_name: str = "all-MiniLM-L6-v2"):
+        """
+        Initialize the embedding system.
+        
+        Args:
+            model_name: Name of the Sentence Transformers model to use. Default is "all-MiniLM-L6-v2" (80MB).
+        """
+        logger.info(f"Loading embedding model: {model_name}")
+        
+        # Explicitly set device to CPU to avoid meta tensor issue
+        torch.set_grad_enabled(False)
+        # With 16GB of RAM, we can afford to use standard loading without memory optimization
+        # Force the model to load fully into memory without any meta tensors
+        torch.cuda.empty_cache() if torch.cuda.is_available() else None
+
+        #########################################################
+        torch.set_default_device("cpu")
+        #########################################################
+        
+        self.model = SentenceTransformer(model_name, device="cpu")
+
+        # Ensure model is fully materialized, not using meta tensors
+        for param in self.model.parameters():
+            if hasattr(param, 'is_meta') and param.is_meta:
+                # Should not happen with environment variable set, but just in case
+                raise RuntimeError("Meta tensors still detected despite disabling them")
+        
+        self.embedding_dim = self.model.get_sentence_embedding_dimension()
+        logger.info(f"Embedding dimension: {self.embedding_dim}")
+        
+    def embed_documents(self, documents: List[Dict[str, Any]]) -> Tuple[np.ndarray, List[Dict[str, Any]]]:
+        """
+        Embed a list of documents.
+        
+        Args:
+            documents: List of document dictionaries.
+            
+        Returns:
+            Tuple of (embeddings array, documents).
+        """
+        texts = [doc["text"] for doc in documents]
+        logger.info(f"Embedding {len(texts)} documents...")
+        embeddings = self.model.encode(texts, show_progress_bar=True, convert_to_numpy=True)
+        
+        return embeddings, documents
+    
+    def embed_query(self, query: str) -> np.ndarray:
+        """
+        Embed a search query.
+        
+        Args:
+            query: The search query.
+            
+        Returns:
+            Query embedding array.
+        """
+        return self.model.encode([query], convert_to_numpy=True)
+    
+    def get_model_info(self) -> Dict[str, Any]:
+        """
+        Get information about the embedding model.
+        
+        Returns:
+            Dictionary with model information.
+        """
+        # Access the model attributes in a safer way
+        try:
+            model_name = self.model._model_config.get('name', 
+                         self.model._model_config.get('model_name_or_path', 'unknown'))
+        except:
+            model_name = str(self.model)  # Fallback to string representation
+            
+        try:
+            max_seq_length = self.model.get_max_seq_length()
+        except:
+            max_seq_length = 512  # Default value if method not available
+            
+        return {
+            "model_name": model_name,
+            "dimension": self.embedding_dim,
+            "max_seq_length": max_seq_length,
+            "normalize_embeddings": getattr(self.model, "normalize_embeddings", True)
+        } 

app/services/embedding_service.py

@@ -1,47 +1,62 @@
 import logging
 import numpy as np
-from typing import List, Dict, Any, Tuple
-from sentence_transformers import SentenceTransformer
 import torch
-import os
-
-os.environ["PYTORCH_ENABLE_META_TENSORS"] = "0"
+from typing import List, Dict, Any, Tuple
+from transformers import AutoModel, AutoTokenizer
 
 logger = logging.getLogger(__name__)
 
 class EmbeddingService:
-    """Service for handling document embeddings using Sentence Transformers."""
+    """Service for handling document embeddings using Hugging Face Transformers."""
     
-    def __init__(self, model_name: str = "all-MiniLM-L6-v2"):
+    def __init__(self, model_name: str = "sentence-transformers/all-MiniLM-L6-v2"):
         """
         Initialize the embedding system.
         
         Args:
-            model_name: Name of the Sentence Transformers model to use. Default is "all-MiniLM-L6-v2" (80MB).
+            model_name: Name of the model to use. Default is "sentence-transformers/all-MiniLM-L6-v2".
         """
         logger.info(f"Loading embedding model: {model_name}")
         
-        # Explicitly set device to CPU to avoid meta tensor issue
+        # Disable gradients for inference
         torch.set_grad_enabled(False)
-        # With 16GB of RAM, we can afford to use standard loading without memory optimization
-        # Force the model to load fully into memory without any meta tensors
-        torch.cuda.empty_cache() if torch.cuda.is_available() else None
-
-        #########################################################
-        torch.set_default_device("cpu")
-        #########################################################
         
-        self.model = SentenceTransformer(model_name, device="cpu")
-
-        # Ensure model is fully materialized, not using meta tensors
-        for param in self.model.parameters():
-            if hasattr(param, 'is_meta') and param.is_meta:
-                # Should not happen with environment variable set, but just in case
-                raise RuntimeError("Meta tensors still detected despite disabling them")
+        # Load tokenizer and model
+        self.tokenizer = AutoTokenizer.from_pretrained(model_name)
+        self.model = AutoModel.from_pretrained(model_name)
+        
+        # Move model to CPU and eval mode
+        self.model = self.model.to("cpu")
+        self.model.eval()
         
-        self.embedding_dim = self.model.get_sentence_embedding_dimension()
+        # Get embedding dimension from model config
+        self.embedding_dim = self.model.config.hidden_size
         logger.info(f"Embedding dimension: {self.embedding_dim}")
+    
+    def _mean_pooling(self, model_output, attention_mask):
+        """
+        Perform mean pooling on token embeddings.
+        
+        Args:
+            model_output: Output from the transformer model
+            attention_mask: Attention mask to avoid padding tokens
+            
+        Returns:
+            Sentence embeddings
+        """
+        # First element of model_output contains token embeddings
+        token_embeddings = model_output[0]
+        
+        # Expand attention mask from [batch_size, seq_length] to [batch_size, seq_length, hidden_size]
+        input_mask_expanded = attention_mask.unsqueeze(-1).expand(token_embeddings.size()).float()
+        
+        # Sum token embeddings and divide by the expanded mask
+        sum_embeddings = torch.sum(token_embeddings * input_mask_expanded, 1)
+        sum_mask = torch.clamp(input_mask_expanded.sum(1), min=1e-9)
         
+        # Return mean-pooled embeddings
+        return sum_embeddings / sum_mask
+    
     def embed_documents(self, documents: List[Dict[str, Any]]) -> Tuple[np.ndarray, List[Dict[str, Any]]]:
         """
         Embed a list of documents.
@@ -54,7 +69,38 @@ class EmbeddingService:
         """
         texts = [doc["text"] for doc in documents]
         logger.info(f"Embedding {len(texts)} documents...")
-        embeddings = self.model.encode(texts, show_progress_bar=True, convert_to_numpy=True)
+        
+        # Process in batches to avoid OOM
+        batch_size = 32
+        all_embeddings = []
+        
+        for i in range(0, len(texts), batch_size):
+            batch_texts = texts[i:i+batch_size]
+            
+            # Tokenize batch
+            encoded_input = self.tokenizer(
+                batch_texts,
+                padding=True,
+                truncation=True,
+                max_length=512,
+                return_tensors='pt'
+            ).to("cpu")
+            
+            # Compute token embeddings
+            with torch.no_grad():
+                model_output = self.model(**encoded_input)
+            
+            # Apply mean pooling
+            batch_embeddings = self._mean_pooling(model_output, encoded_input['attention_mask'])
+            
+            # Normalize embeddings
+            batch_embeddings = torch.nn.functional.normalize(batch_embeddings, p=2, dim=1)
+            
+            # Convert to numpy and add to result
+            all_embeddings.append(batch_embeddings.cpu().numpy())
+        
+        # Combine all batches
+        embeddings = np.vstack(all_embeddings)
         
         return embeddings, documents
     
@@ -68,7 +114,26 @@ class EmbeddingService:
         Returns:
             Query embedding array.
         """
-        return self.model.encode([query], convert_to_numpy=True)
+        # Tokenize query
+        encoded_input = self.tokenizer(
+            [query],
+            padding=True,
+            truncation=True,
+            max_length=512,
+            return_tensors='pt'
+        ).to("cpu")
+        
+        # Compute token embeddings
+        with torch.no_grad():
+            model_output = self.model(**encoded_input)
+        
+        # Apply mean pooling
+        embeddings = self._mean_pooling(model_output, encoded_input['attention_mask'])
+        
+        # Normalize embeddings
+        embeddings = torch.nn.functional.normalize(embeddings, p=2, dim=1)
+        
+        return embeddings.cpu().numpy()
     
     def get_model_info(self) -> Dict[str, Any]:
         """
@@ -77,21 +142,9 @@ class EmbeddingService:
         Returns:
             Dictionary with model information.
         """
-        # Access the model attributes in a safer way
-        try:
-            model_name = self.model._model_config.get('name', 
-                         self.model._model_config.get('model_name_or_path', 'unknown'))
-        except:
-            model_name = str(self.model)  # Fallback to string representation
-            
-        try:
-            max_seq_length = self.model.get_max_seq_length()
-        except:
-            max_seq_length = 512  # Default value if method not available
-            
         return {
-            "model_name": model_name,
+            "model_name": self.model.config.name_or_path,
             "dimension": self.embedding_dim,
-            "max_seq_length": max_seq_length,
-            "normalize_embeddings": getattr(self.model, "normalize_embeddings", True)
-        } 
+            "max_seq_length": self.model.config.max_position_embeddings,
+            "normalize_embeddings": True  # We're always normalizing
+        }

logs/app.log

@@ -2487,3 +2487,28 @@
 2025-05-13 15:26:46,505 - INFO - Application shut down
 2025-05-13 15:26:51,494 - INFO - Application started
 2025-05-13 15:26:56,341 - INFO - Application started
+2025-05-13 15:27:24,810 - INFO - ArXiv API service initialized
+2025-05-13 15:27:24,811 - INFO - Document processor initialized with chunk_size=500, chunk_overlap=50
+2025-05-13 15:27:24,811 - INFO - Loading embedding model: sentence-transformers/all-MiniLM-L6-v2
+2025-05-13 15:27:24,814 - INFO - Load pretrained SentenceTransformer: sentence-transformers/all-MiniLM-L6-v2
+2025-05-13 15:27:27,035 - INFO - Embedding dimension: 384
+2025-05-13 15:27:27,036 - INFO - Vector database initialized with dimension 384
+2025-05-13 15:27:27,036 - INFO - LLM service initialized with 3 supported models
+2025-05-13 15:27:27,036 - INFO - RAG service initialized
+2025-05-13 15:27:27,039 - INFO - Searching ArXiv with query: latest advancements quantum computing AND (cat:cs.LG OR cat:quant-ph)
+2025-05-13 15:27:27,040 - INFO - Requesting page (first: True, try: 0): https://export.arxiv.org/api/query?search_query=latest+advancements+quantum+computing+AND+%28cat%3Acs.LG+OR+cat%3Aquant-ph%29&id_list=&sortBy=relevance&sortOrder=descending&start=0&max_results=100
+2025-05-13 15:27:31,218 - INFO - Got first page: 100 of 144553 total results
+2025-05-13 15:27:31,219 - INFO - Found 10 papers
+2025-05-13 15:27:31,219 - INFO - Split paper 'A Survey on Quantum Machine Learning: Current Trends, Challenges, Opportunities, and the Road Ahead' into 4 chunks
+2025-05-13 15:27:31,219 - INFO - Split paper 'Quantum Machine Learning: A Hands-on Tutorial for Machine Learning Practitioners and Researchers' into 3 chunks
+2025-05-13 15:27:31,219 - INFO - Split paper 'Deep-Q Learning with Hybrid Quantum Neural Network on Solving Maze Problems' into 4 chunks
+2025-05-13 15:27:31,219 - INFO - Split paper 'Generalization Error Bound for Quantum Machine Learning in NISQ Era -- A Survey' into 5 chunks
+2025-05-13 15:27:31,219 - INFO - Split paper 'Quantum Supervised Learning' into 4 chunks
+2025-05-13 15:27:31,219 - INFO - Split paper 'What is my quantum computer good for? Quantum capability learning with physics-aware neural networks' into 4 chunks
+2025-05-13 15:27:31,219 - INFO - Split paper 'Quantum-Assisted Clustering Algorithms for NISQ-Era Devices' into 3 chunks
+2025-05-13 15:27:31,219 - INFO - Split paper 'Benchmarking MedMNIST dataset on real quantum hardware' into 5 chunks
+2025-05-13 15:27:31,219 - INFO - Split paper 'From Quantum Graph Computing to Quantum Graph Learning: A Survey' into 4 chunks
+2025-05-13 15:27:31,219 - INFO - Split paper 'Advances in Quantum Deep Learning: An Overview' into 3 chunks
+2025-05-13 15:27:31,220 - INFO - Embedding 39 documents...
+2025-05-13 15:27:31,612 - INFO - Added 39 documents to vector database. Total: 39
+2025-05-13 15:52:38,024 - INFO - Application started