DSPy: The framework for programming—not prompting—language models
Python
Fix imports related to the removal of dsp/* (#1937)
Omar Khattab1c4f050b5225
diff --git a/dspy/__init__.py b/dspy/__init__.pyindex d79a51d5d..aa555ad32 100644--- a/dspy/__init__.py+++ b/dspy/__init__.py@@ -18,8 +18,8 @@ from dspy.dsp.utils.settings import settingsconfigure_dspy_loggers(__name__)-from dspy.dsp.modules.colbertv2 import ColBERTv2-# from dspy.dsp.modules.you import You+from dspy.dsp.colbertv2 import ColBERTv2+# from dspy.dsp.you import Youconfigure = settings.configurecontext = settings.contextdiff --git a/dspy/dsp/modules/cache_utils.py b/dspy/dsp/cache_utils.pysimilarity index 100%rename from dspy/dsp/modules/cache_utils.pyrename to dspy/dsp/cache_utils.pydiff --git a/dspy/dsp/modules/colbertv2.py b/dspy/dsp/colbertv2.pysimilarity index 98%rename from dspy/dsp/modules/colbertv2.pyrename to dspy/dsp/colbertv2.pyindex ba0ccbea1..6b1fd8cb3 100644--- a/dspy/dsp/modules/colbertv2.py+++ b/dspy/dsp/colbertv2.py@@ -3,7 +3,7 @@ from typing import Any, List, Optional, Unionimport requests-from dspy.dsp.modules.cache_utils import CacheMemory, NotebookCacheMemory+from dspy.dsp.cache_utils import CacheMemory, NotebookCacheMemoryfrom dspy.dsp.utils import dotdict# TODO: Ideally, this takes the name of the index and looks up its port.diff --git a/dspy/retrieve/faiss_rm.py b/dspy/retrieve/faiss_rm.pyindex a66140f93..5ac4de971 100755--- a/dspy/retrieve/faiss_rm.py+++ b/dspy/retrieve/faiss_rm.py@@ -1,156 +1,156 @@-"""Retriever model for faiss: https://github.com/facebookresearch/faiss.-Author: Jagane Sundar: https://github.com/jagane.-"""--import logging-from typing import Optional, Union--import numpy as np--import dspy-from dspy.dsp.modules.sentence_vectorizer import SentenceTransformersVectorizer-from dspy.dsp.utils import dotdict--try:- import faiss-except ImportError:- faiss = None--if faiss is None:- raise ImportError(- """- The faiss package is required. Install it using `pip install dspy-ai[faiss-cpu]`- """,- )---logger = logging.getLogger(__name__)-class FaissRM(dspy.Retrieve):- """A retrieval module that uses an in-memory Faiss to return the top passages for a given query.-- Args:- document_chunks: the input text chunks- vectorizer: an object that is a subclass of BaseSentenceVectorizer- k (int, optional): The number of top passages to retrieve. Defaults to 3.-- Returns:- dspy.Prediction: An object containing the retrieved passages.-- Examples:- Below is a code snippet that shows how to use this as the default retriver:- ```python- import dspy- from dspy.retrieve import faiss_rm-- document_chunks = [- "The superbowl this year was played between the San Francisco 49ers and the Kanasas City Chiefs",- "Pop corn is often served in a bowl",- "The Rice Bowl is a Chinese Restaurant located in the city of Tucson, Arizona",- "Mars is the fourth planet in the Solar System",- "An aquarium is a place where children can learn about marine life",- "The capital of the United States is Washington, D.C",- "Rock and Roll musicians are honored by being inducted in the Rock and Roll Hall of Fame",- "Music albums were published on Long Play Records in the 70s and 80s",- "Sichuan cuisine is a spicy cuisine from central China",- "The interest rates for mortgages is considered to be very high in 2024",- ]-- frm = faiss_rm.FaissRM(document_chunks)- turbo = dspy.OpenAI(model="gpt-3.5-turbo")- dspy.settings.configure(lm=turbo, rm=frm)- print(frm(["I am in the mood for Chinese food"]))- ```-- Below is a code snippet that shows how to use this in the forward() function of a module- ```python- self.retrieve = FaissRM(k=num_passages)- ```- """-- def __init__(self, document_chunks, vectorizer=None, k: int = 3):- """Inits the faiss retriever.-- Args:- document_chunks: a list of input strings.- vectorizer: an object that is a subclass of BaseTransformersVectorizer.- k: number of matches to return.- """- if vectorizer:- self._vectorizer = vectorizer- else:- self._vectorizer = SentenceTransformersVectorizer()- embeddings = self._vectorizer(document_chunks)- xb = np.array(embeddings)- d = len(xb[0])- logger.info(f"FaissRM: embedding size={d}")- if len(xb) < 100:- self._faiss_index = faiss.IndexFlatL2(d)- self._faiss_index.add(xb)- else:- # if we have at least 100 vectors, we use Voronoi cells- nlist = 100- quantizer = faiss.IndexFlatL2(d)- self._faiss_index = faiss.IndexIVFFlat(quantizer, d, nlist)- self._faiss_index.train(xb)- self._faiss_index.add(xb)-- logger.info(f"{self._faiss_index.ntotal} vectors in faiss index")- self._document_chunks = document_chunks # save the input document chunks-- super().__init__(k=k)-- def _dump_raw_results(self, queries, index_list, distance_list) -> None:- for i in range(len(queries)):- indices = index_list[i]- distances = distance_list[i]- logger.debug(f"Query: {queries[i]}")- for j in range(len(indices)):- logger.debug(f" Hit {j} = {indices[j]}/{distances[j]}: {self._document_chunks[indices[j]]}")- return-- def forward(self, query_or_queries: Union[str, list[str]], k: Optional[int] = None, **kwargs) -> dspy.Prediction:- """Search the faiss index for k or self.k top passages for query.-- Args:- query_or_queries (Union[str, List[str]]): The query or queries to search for.-- Returns:- dspy.Prediction: An object containing the retrieved passages.- """- queries = [query_or_queries] if isinstance(query_or_queries, str) else query_or_queries- queries = [q for q in queries if q] # Filter empty queries- embeddings = self._vectorizer(queries)- emb_npa = np.array(embeddings)- # For single query, just look up the top k passages- if len(queries) == 1:- distance_list, index_list = self._faiss_index.search(emb_npa, k or self.k)- # self._dump_raw_results(queries, index_list, distance_list)- passages = [(self._document_chunks[ind], ind) for ind in index_list[0]]- return [dotdict({"long_text": passage[0], "index": passage[1]}) for passage in passages]-- distance_list, index_list = self._faiss_index.search(emb_npa, (k or self.k) * 3, **kwargs)- # self._dump_raw_results(queries, index_list, distance_list)- passage_scores = {}- for emb in range(len(embeddings)):- indices = index_list[emb] # indices of neighbors for embeddings[emb] - this is an array of k*3 integers- distances = distance_list[- emb- ] # distances of neighbors for embeddings[emb] - this is an array of k*3 floating point numbers- for res in range((k or self.k) * 3):- neighbor = indices[res]- distance = distances[res]- if neighbor in passage_scores:- passage_scores[neighbor].append(distance)- else:- passage_scores[neighbor] = [distance]- # Note re. sorting:- # first degree sort: number of queries that got a hit with any particular document chunk. More- # is a better match. This is len(queries)-len(x[1])- # second degree sort: sum of the distances of each hit returned by faiss. Smaller distance is a better match- sorted_passages = sorted(passage_scores.items(), key=lambda x: (len(queries) - len(x[1]), sum(x[1])))[- : k or self.k- ]- return [- dotdict({"long_text": self._document_chunks[passage_index], "index": passage_index})- for passage_index, _ in sorted_passages- ]+# """Retriever model for faiss: https://github.com/facebookresearch/faiss.+# Author: Jagane Sundar: https://github.com/jagane.+# """++# import logging+# from typing import Optional, Union++# import numpy as np++# import dspy+# from dspy.dsp.modules.sentence_vectorizer import SentenceTransformersVectorizer+# from dspy.dsp.utils import dotdict++# try:+# import faiss+# except ImportError:+# faiss = None++# if faiss is None:+# raise ImportError(+# """+# The faiss package is required. Install it using `pip install dspy-ai[faiss-cpu]`+# """,+# )+++# logger = logging.getLogger(__name__)+# class FaissRM(dspy.Retrieve):+# """A retrieval module that uses an in-memory Faiss to return the top passages for a given query.++# Args:+# document_chunks: the input text chunks+# vectorizer: an object that is a subclass of BaseSentenceVectorizer+# k (int, optional): The number of top passages to retrieve. Defaults to 3.++# Returns:+# dspy.Prediction: An object containing the retrieved passages.++# Examples:+# Below is a code snippet that shows how to use this as the default retriver:+# ```python+# import dspy+# from dspy.retrieve import faiss_rm++# document_chunks = [+# "The superbowl this year was played between the San Francisco 49ers and the Kanasas City Chiefs",+# "Pop corn is often served in a bowl",+# "The Rice Bowl is a Chinese Restaurant located in the city of Tucson, Arizona",+# "Mars is the fourth planet in the Solar System",+# "An aquarium is a place where children can learn about marine life",+# "The capital of the United States is Washington, D.C",+# "Rock and Roll musicians are honored by being inducted in the Rock and Roll Hall of Fame",+# "Music albums were published on Long Play Records in the 70s and 80s",+# "Sichuan cuisine is a spicy cuisine from central China",+# "The interest rates for mortgages is considered to be very high in 2024",+# ]++# frm = faiss_rm.FaissRM(document_chunks)+# turbo = dspy.OpenAI(model="gpt-3.5-turbo")+# dspy.settings.configure(lm=turbo, rm=frm)+# print(frm(["I am in the mood for Chinese food"]))+# ```++# Below is a code snippet that shows how to use this in the forward() function of a module+# ```python+# self.retrieve = FaissRM(k=num_passages)+# ```+# """++# def __init__(self, document_chunks, vectorizer=None, k: int = 3):+# """Inits the faiss retriever.++# Args:+# document_chunks: a list of input strings.+# vectorizer: an object that is a subclass of BaseTransformersVectorizer.+# k: number of matches to return.+# """+# if vectorizer:+# self._vectorizer = vectorizer+# else:+# self._vectorizer = SentenceTransformersVectorizer()+# embeddings = self._vectorizer(document_chunks)+# xb = np.array(embeddings)+# d = len(xb[0])+# logger.info(f"FaissRM: embedding size={d}")+# if len(xb) < 100:+# self._faiss_index = faiss.IndexFlatL2(d)+# self._faiss_index.add(xb)+# else:+# # if we have at least 100 vectors, we use Voronoi cells+# nlist = 100+# quantizer = faiss.IndexFlatL2(d)+# self._faiss_index = faiss.IndexIVFFlat(quantizer, d, nlist)+# self._faiss_index.train(xb)+# self._faiss_index.add(xb)++# logger.info(f"{self._faiss_index.ntotal} vectors in faiss index")+# self._document_chunks = document_chunks # save the input document chunks++# super().__init__(k=k)++# def _dump_raw_results(self, queries, index_list, distance_list) -> None:+# for i in range(len(queries)):+# indices = index_list[i]+# distances = distance_list[i]+# logger.debug(f"Query: {queries[i]}")+# for j in range(len(indices)):+# logger.debug(f" Hit {j} = {indices[j]}/{distances[j]}: {self._document_chunks[indices[j]]}")+# return++# def forward(self, query_or_queries: Union[str, list[str]], k: Optional[int] = None, **kwargs) -> dspy.Prediction:+# """Search the faiss index for k or self.k top passages for query.++# Args:+# query_or_queries (Union[str, List[str]]): The query or queries to search for.++# Returns:+# dspy.Prediction: An object containing the retrieved passages.+# """+# queries = [query_or_queries] if isinstance(query_or_queries, str) else query_or_queries+# queries = [q for q in queries if q] # Filter empty queries+# embeddings = self._vectorizer(queries)+# emb_npa = np.array(embeddings)+# # For single query, just look up the top k passages+# if len(queries) == 1:+# distance_list, index_list = self._faiss_index.search(emb_npa, k or self.k)+# # self._dump_raw_results(queries, index_list, distance_list)+# passages = [(self._document_chunks[ind], ind) for ind in index_list[0]]+# return [dotdict({"long_text": passage[0], "index": passage[1]}) for passage in passages]++# distance_list, index_list = self._faiss_index.search(emb_npa, (k or self.k) * 3, **kwargs)+# # self._dump_raw_results(queries, index_list, distance_list)+# passage_scores = {}+# for emb in range(len(embeddings)):+# indices = index_list[emb] # indices of neighbors for embeddings[emb] - this is an array of k*3 integers+# distances = distance_list[+# emb+# ] # distances of neighbors for embeddings[emb] - this is an array of k*3 floating point numbers+# for res in range((k or self.k) * 3):+# neighbor = indices[res]+# distance = distances[res]+# if neighbor in passage_scores:+# passage_scores[neighbor].append(distance)+# else:+# passage_scores[neighbor] = [distance]+# # Note re. sorting:+# # first degree sort: number of queries that got a hit with any particular document chunk. More+# # is a better match. This is len(queries)-len(x[1])+# # second degree sort: sum of the distances of each hit returned by faiss. Smaller distance is a better match+# sorted_passages = sorted(passage_scores.items(), key=lambda x: (len(queries) - len(x[1]), sum(x[1])))[+# : k or self.k+# ]+# return [+# dotdict({"long_text": self._document_chunks[passage_index], "index": passage_index})+# for passage_index, _ in sorted_passages+# ]diff --git a/dspy/retrieve/my_scale_rm.py b/dspy/retrieve/my_scale_rm.pyindex 2b4a48979..8d61d0028 100644--- a/dspy/retrieve/my_scale_rm.py+++ b/dspy/retrieve/my_scale_rm.py@@ -1,231 +1,231 @@-import functools-import os-from typing import List, Optional--import openai--import dspy-from dspy.dsp.modules.cache_utils import NotebookCacheMemory, cache_turn_on-from dspy.dsp.utils import dotdict--# Check for necessary libraries and suggest installation if not found.-try:- import clickhouse_connect-except ImportError:- raise ImportError(- "The 'myscale' extra is required to use MyScaleRM. Install it with `pip install dspy-ai[myscale]`",- )--# Verify the compatibility of the OpenAI library version installed.-try:- major, minor, _ = map(int, openai.__version__.split("."))- OPENAI_VERSION_COMPATIBLE = major >= 1 and minor >= 16-except Exception:- OPENAI_VERSION_COMPATIBLE = False--if not OPENAI_VERSION_COMPATIBLE:- raise ImportError(- "An incompatible OpenAI library version is installed. Ensure you have version 1.16.1 or later.",- )--# Attempt to handle specific OpenAI errors; fallback to general ones if necessary.-try:- import openai.error-- ERRORS = (openai.error.RateLimitError, openai.error.ServiceUnavailableError, openai.error.APIError)-except Exception:- ERRORS = (openai.RateLimitError, openai.APIError)---class MyScaleRM(dspy.Retrieve):- """- A retrieval module that uses MyScaleDB to return the top passages for a given query.-- MyScaleDB is a fork of ClickHouse that focuses on vector similarity search and full- text search. MyScaleRM is designed to facilitate easy retrieval of information from- MyScaleDB using embeddings. It supports embedding generation through either a local- model or the OpenAI API. This class abstracts away the complexities of connecting to- MyScaleDB, managing API keys, and processing queries to return semantically- relevant results.-- Assumes that a table named `database.table` exists in MyScaleDB, and that the- table has column named `vector_column` that stores vector data and a vector index has- been created on this column. Other metadata are stored in `metadata_columns`.-- Args:- client (clickhouse_connect.driver.client.Client): A client connection to the MyScaleDB.- table (str): Name of the table within the database to perform queries against.- database (str, optional): Name of the database to query within MyScaleDB.- metadata_columns(List[str], optional): A list of columns to include in the results.- vector_column (str, optional): The name of the column in the table that stores vector data.- k (int, optional): The number of closest matches to retrieve for a given query.- openai_api_key (str, optional): The API key for accessing OpenAI's services.- model (str, optional): Specifies the particular OpenAI model to use for embedding generation.- use_local_model (bool): Flag indicating whether a local model is used for embeddings.-- """-- def __init__(- self,- client: clickhouse_connect.driver.client.Client,- table: str,- database: str = "default",- metadata_columns: List[str] = ["text"],- vector_column: str = "vector",- k: int = 3,- openai_api_key: Optional[str] = None,- openai_model: Optional[str] = None,- local_embed_model: Optional[str] = None,- ):- self.client = client- self.database = database- self.table = table- if not metadata_columns:- raise ValueError("metadata_columns is required")- self.metadata_columns = metadata_columns- self.vector_column = vector_column- self.k = k- self.openai_api_key = openai_api_key- self.model = openai_model- self.use_local_model = False-- if local_embed_model:- self.setup_local_model(local_embed_model)- elif openai_api_key:- os.environ["OPENAI_API_KEY"] = self.openai_api_key-- def setup_local_model(self, model_name: str):- """- Configures a local model for embedding generation, including model and tokenizer loading.-- Args:- model_name: The name or path to the pre-trained model to load.-- Raises:- ModuleNotFoundError: If necessary libraries (torch or transformers) are not installed.- """- try:- import torch- from transformers import AutoModel, AutoTokenizer- except ImportError as exc:- raise ModuleNotFoundError(- """You need to install PyTorch and Hugging Face's transformers library to use a local embedding model.- Install the pytorch using `pip install torch` and transformers using `pip install transformers` """,- ) from exc-- try:- self._local_embed_model = AutoModel.from_pretrained(model_name)- self._local_tokenizer = AutoTokenizer.from_pretrained(model_name)- self.use_local_model = True- except Exception as e:- raise ValueError(f"Failed to load model or tokenizer. Error: {str(e)}")-- if torch.cuda.is_available():- self.device = torch.device("cuda:0")- elif torch.backends.mps.is_available():- self.device = torch.device("mps")- else:- self.device = torch.device("cpu")-- self._local_embed_model.to(self.device)-- @functools.lru_cache(maxsize=None if cache_turn_on else 0)- @NotebookCacheMemory.cache- def get_embeddings(self, query: str) -> List[float]:- """- Determines the appropriate source (OpenAI or local model) for embedding generation based on class configuration,- and retrieves embeddings for the provided queries.-- Args:- query: A query to generate embeddings for.-- Returns:- A list of embeddings corresponding to the query in the input list.-- Raises:- ValueError: If neither an OpenAI API key nor a local model has been configured.- """- if self.openai_api_key and self.model:- return self._get_embeddings_from_openai(query)- elif self.use_local_model:- return self._get_embedding_from_local_model(query)- else:- raise ValueError("No valid method for obtaining embeddings is configured.")-- # TO DO Add this method as Util method outside MyScaleRM- def _get_embeddings_from_openai(self, query: str) -> List[float]:- """- Uses the OpenAI API to generate embeddings for the given query.-- Args:- query: A string for which to generate embeddings.-- Returns:- A list containing the embedding of a query.- """- response = openai.embeddings.create(model=self.model, input=query)- return response.data[0].embedding-- # TO DO Add this method as Util method outside MyScaleRM- def _get_embedding_from_local_model(self, query: str) -> List[float]:- """- Generates embeddings for a single query using the configured local model.-- Args:- query: The text query to generate an embedding for.-- Returns:- A list representing the query's embedding.- """- import torch-- self._local_embed_model.eval() # Ensure the model is in evaluation mode-- inputs = self._local_tokenizer(query, return_tensors="pt", padding=True, truncation=True).to(self.device)- with torch.no_grad():- output = self._local_embed_model(**inputs)-- return output.last_hidden_state.mean(dim=1).squeeze().numpy().tolist()-- def forward(self, user_query: str, k: Optional[int] = None) -> List[dotdict]:- """- Executes a retrieval operation based on a user's query and returns the top k relevant results.-- Args:- user_query: The query text to search for.- k: Optional; The number of top matches to return. Defaults to the class's configured k value.-- Returns:- A list of dotdict objects containing the formatted retrieval results.-- Raises:- ValueError: If the user_query is None.- """- if user_query is None:- raise ValueError("Query is required")- k = k or self.k- embeddings = self.get_embeddings(user_query)- columns_string = ", ".join(self.metadata_columns)- result = self.client.query(f"""- SELECT {columns_string},- distance({self.vector_column}, {embeddings}) as dist FROM {self.database}.{self.table} ORDER BY dist LIMIT {k}- """)- result = self.client.query(f"""- SELECT {columns_string}, distance({self.vector_column}, {embeddings}) AS dist- FROM {self.database}.{self.table}- ORDER BY dist- LIMIT {k}- """)-- # Convert the metadata into strings to pass to dspy.Prediction- results = []- for row in result.named_results():- if len(self.metadata_columns) == 1:- results.append(row[self.metadata_columns[0]])- else:- row_strings = [f"{column}: {row[column]}" for column in self.metadata_columns] # Format row data- row_string = "\n".join(row_strings) # Combine formatted data- results.append(row_string) # Append to results-- # Return list of dotdict- return [dotdict({"long_text": passage}) for passage in results]+# import functools+# import os+# from typing import List, Optional++# import openai++# import dspy+# from dspy.dsp.modules.cache_utils import NotebookCacheMemory, cache_turn_on+# from dspy.dsp.utils import dotdict++# # Check for necessary libraries and suggest installation if not found.+# try:+# import clickhouse_connect+# except ImportError:+# raise ImportError(+# "The 'myscale' extra is required to use MyScaleRM. Install it with `pip install dspy-ai[myscale]`",+# )++# # Verify the compatibility of the OpenAI library version installed.+# try:+# major, minor, _ = map(int, openai.__version__.split("."))+# OPENAI_VERSION_COMPATIBLE = major >= 1 and minor >= 16+# except Exception:+# OPENAI_VERSION_COMPATIBLE = False++# if not OPENAI_VERSION_COMPATIBLE:+# raise ImportError(+# "An incompatible OpenAI library version is installed. Ensure you have version 1.16.1 or later.",+# )++# # Attempt to handle specific OpenAI errors; fallback to general ones if necessary.+# try:+# import openai.error++# ERRORS = (openai.error.RateLimitError, openai.error.ServiceUnavailableError, openai.error.APIError)+# except Exception:+# ERRORS = (openai.RateLimitError, openai.APIError)+++# class MyScaleRM(dspy.Retrieve):+# """+# A retrieval module that uses MyScaleDB to return the top passages for a given query.++# MyScaleDB is a fork of ClickHouse that focuses on vector similarity search and full+# text search. MyScaleRM is designed to facilitate easy retrieval of information from+# MyScaleDB using embeddings. It supports embedding generation through either a local+# model or the OpenAI API. This class abstracts away the complexities of connecting to+# MyScaleDB, managing API keys, and processing queries to return semantically+# relevant results.++# Assumes that a table named `database.table` exists in MyScaleDB, and that the+# table has column named `vector_column` that stores vector data and a vector index has+# been created on this column. Other metadata are stored in `metadata_columns`.++# Args:+# client (clickhouse_connect.driver.client.Client): A client connection to the MyScaleDB.+# table (str): Name of the table within the database to perform queries against.+# database (str, optional): Name of the database to query within MyScaleDB.+# metadata_columns(List[str], optional): A list of columns to include in the results.+# vector_column (str, optional): The name of the column in the table that stores vector data.+# k (int, optional): The number of closest matches to retrieve for a given query.+# openai_api_key (str, optional): The API key for accessing OpenAI's services.+# model (str, optional): Specifies the particular OpenAI model to use for embedding generation.+# use_local_model (bool): Flag indicating whether a local model is used for embeddings.++# """++# def __init__(+# self,+# client: clickhouse_connect.driver.client.Client,+# table: str,+# database: str = "default",+# metadata_columns: List[str] = ["text"],+# vector_column: str = "vector",+# k: int = 3,+# openai_api_key: Optional[str] = None,+# openai_model: Optional[str] = None,+# local_embed_model: Optional[str] = None,+# ):+# self.client = client+# self.database = database+# self.table = table+# if not metadata_columns:+# raise ValueError("metadata_columns is required")+# self.metadata_columns = metadata_columns+# self.vector_column = vector_column+# self.k = k+# self.openai_api_key = openai_api_key+# self.model = openai_model+# self.use_local_model = False++# if local_embed_model:+# self.setup_local_model(local_embed_model)+# elif openai_api_key:+# os.environ["OPENAI_API_KEY"] = self.openai_api_key++# def setup_local_model(self, model_name: str):+# """+# Configures a local model for embedding generation, including model and tokenizer loading.++# Args:+# model_name: The name or path to the pre-trained model to load.++# Raises:+# ModuleNotFoundError: If necessary libraries (torch or transformers) are not installed.+# """+# try:+# import torch+# from transformers import AutoModel, AutoTokenizer+# except ImportError as exc:+# raise ModuleNotFoundError(+# """You need to install PyTorch and Hugging Face's transformers library to use a local embedding model.+# Install the pytorch using `pip install torch` and transformers using `pip install transformers` """,+# ) from exc++# try:+# self._local_embed_model = AutoModel.from_pretrained(model_name)+# self._local_tokenizer = AutoTokenizer.from_pretrained(model_name)+# self.use_local_model = True+# except Exception as e:+# raise ValueError(f"Failed to load model or tokenizer. Error: {str(e)}")++# if torch.cuda.is_available():+# self.device = torch.device("cuda:0")+# elif torch.backends.mps.is_available():+# self.device = torch.device("mps")+# else:+# self.device = torch.device("cpu")++# self._local_embed_model.to(self.device)++# @functools.lru_cache(maxsize=None if cache_turn_on else 0)+# @NotebookCacheMemory.cache+# def get_embeddings(self, query: str) -> List[float]:+# """+# Determines the appropriate source (OpenAI or local model) for embedding generation based on class configuration,+# and retrieves embeddings for the provided queries.++# Args:+# query: A query to generate embeddings for.++# Returns:+# A list of embeddings corresponding to the query in the input list.++# Raises:+# ValueError: If neither an OpenAI API key nor a local model has been configured.+# """+# if self.openai_api_key and self.model:+# return self._get_embeddings_from_openai(query)+# elif self.use_local_model:+# return self._get_embedding_from_local_model(query)+# else:+# raise ValueError("No valid method for obtaining embeddings is configured.")++# # TO DO Add this method as Util method outside MyScaleRM+# def _get_embeddings_from_openai(self, query: str) -> List[float]:+# """+# Uses the OpenAI API to generate embeddings for the given query.++# Args:+# query: A string for which to generate embeddings.++# Returns:+# A list containing the embedding of a query.+# """+# response = openai.embeddings.create(model=self.model, input=query)+# return response.data[0].embedding++# # TO DO Add this method as Util method outside MyScaleRM+# def _get_embedding_from_local_model(self, query: str) -> List[float]:+# """+# Generates embeddings for a single query using the configured local model.++# Args:+# query: The text query to generate an embedding for.++# Returns:+# A list representing the query's embedding.+# """+# import torch++# self._local_embed_model.eval() # Ensure the model is in evaluation mode++# inputs = self._local_tokenizer(query, return_tensors="pt", padding=True, truncation=True).to(self.device)+# with torch.no_grad():+# output = self._local_embed_model(**inputs)++# return output.last_hidden_state.mean(dim=1).squeeze().numpy().tolist()++# def forward(self, user_query: str, k: Optional[int] = None) -> List[dotdict]:+# """+# Executes a retrieval operation based on a user's query and returns the top k relevant results.++# Args:+# user_query: The query text to search for.+# k: Optional; The number of top matches to return. Defaults to the class's configured k value.++# Returns:+# A list of dotdict objects containing the formatted retrieval results.++# Raises:+# ValueError: If the user_query is None.+# """+# if user_query is None:+# raise ValueError("Query is required")+# k = k or self.k+# embeddings = self.get_embeddings(user_query)+# columns_string = ", ".join(self.metadata_columns)+# result = self.client.query(f"""+# SELECT {columns_string},+# distance({self.vector_column}, {embeddings}) as dist FROM {self.database}.{self.table} ORDER BY dist LIMIT {k}+# """)+# result = self.client.query(f"""+# SELECT {columns_string}, distance({self.vector_column}, {embeddings}) AS dist+# FROM {self.database}.{self.table}+# ORDER BY dist+# LIMIT {k}+# """)++# # Convert the metadata into strings to pass to dspy.Prediction+# results = []+# for row in result.named_results():+# if len(self.metadata_columns) == 1:+# results.append(row[self.metadata_columns[0]])+# else:+# row_strings = [f"{column}: {row[column]}" for column in self.metadata_columns] # Format row data+# row_string = "\n".join(row_strings) # Combine formatted data+# results.append(row_string) # Append to results++# # Return list of dotdict+# return [dotdict({"long_text": passage}) for passage in results]diff --git a/dspy/retrieve/qdrant_rm.py b/dspy/retrieve/qdrant_rm.pyindex 01af9fccb..956adeab4 100644--- a/dspy/retrieve/qdrant_rm.py+++ b/dspy/retrieve/qdrant_rm.py@@ -1,116 +1,116 @@-from collections import defaultdict-from typing import Optional, Union--import dspy-from dspy.dsp.modules.sentence_vectorizer import BaseSentenceVectorizer, FastEmbedVectorizer-from dspy.dsp.utils import dotdict--try:- from qdrant_client import QdrantClient, models-except ImportError as e:- raise ImportError(- "The 'qdrant' extra is required to use QdrantRM. Install it with `pip install dspy-ai[qdrant]`",- ) from e---class QdrantRM(dspy.Retrieve):- """A retrieval module that uses Qdrant to return the top passages for a given query.-- Args:- qdrant_collection_name (str): The name of the Qdrant collection.- qdrant_client (QdrantClient): An instance of `qdrant_client.QdrantClient`.- k (int, optional): The default number of top passages to retrieve. Default: 3.- document_field (str, optional): The key in the Qdrant payload with the content. Default: `"document"`.- vectorizer (BaseSentenceVectorizer, optional): An implementation `BaseSentenceVectorizer`.- Default: `FastEmbedVectorizer`.- vector_name (str, optional): Name of the vector in the collection. Default: The first available vector name.-- Examples:- Below is a code snippet that shows how to use Qdrant as the default retriver:- ```python- from qdrant_client import QdrantClient-- llm = dspy.OpenAI(model="gpt-3.5-turbo")- qdrant_client = QdrantClient()- retriever_model = QdrantRM("my_collection_name", qdrant_client=qdrant_client)- dspy.settings.configure(lm=llm, rm=retriever_model)- ```-- Below is a code snippet that shows how to use Qdrant in the forward() function of a module- ```python- self.retrieve = QdrantRM(question, k=num_passages, filter=filter)- ```- """-- def __init__(- self,- qdrant_collection_name: str,- qdrant_client: QdrantClient,- k: int = 3,- document_field: str = "document",- vectorizer: Optional[BaseSentenceVectorizer] = None,- vector_name: Optional[str] = None,- ):- self._collection_name = qdrant_collection_name- self._client = qdrant_client-- self._vectorizer = vectorizer or FastEmbedVectorizer(self._client.embedding_model_name)-- self._document_field = document_field-- self._vector_name = vector_name or self._get_first_vector_name()-- super().__init__(k=k)-- def forward(self, query_or_queries: Union[str, list[str]], k: Optional[int] = None, filter: Optional[models.Filter]=None) -> dspy.Prediction:- """Search with Qdrant for self.k top passages for query.-- Args:- query_or_queries (Union[str, List[str]]): The query or queries to search for.- k (Optional[int]): The number of top passages to retrieve. Defaults to self.k.- filter (Optional["Filter"]): "Look only for points which satisfies this conditions". Default: None.-- Returns:- dspy.Prediction: An object containing the retrieved passages.- """- queries = [query_or_queries] if isinstance(query_or_queries, str) else query_or_queries- queries = [q for q in queries if q] # Filter empty queries-- vectors = self._vectorizer(queries)-- search_requests = [- models.QueryRequest(- query=vector,- using=self._vector_name,- limit=k or self.k,- with_payload=[self._document_field],- filter=filter,- )- for vector in vectors- ]- batch_results = self._client.query_batch_points(self._collection_name, requests=search_requests)-- passages_scores = defaultdict(float)- for batch in batch_results:- for result in batch.points:- # If a passage is returned multiple times, the score is accumulated.- document = result.payload.get(self._document_field)- passages_scores[document] += result.score-- # Sort passages by their accumulated scores in descending order- sorted_passages = sorted(passages_scores.items(), key=lambda x: x[1], reverse=True)[:k]-- # Wrap each sorted passage in a dotdict with 'long_text'- return [dotdict({"long_text": passage}) for passage, _ in sorted_passages]-- def _get_first_vector_name(self) -> Optional[str]:- vectors = self._client.get_collection(self._collection_name).config.params.vectors-- if not isinstance(vectors, dict):- # The collection only has the default, unnamed vector- return None-- first_vector_name = list(vectors.keys())[0]-- # The collection has multiple vectors. Could also include the falsy unnamed vector - Empty string("")- return first_vector_name or None+# from collections import defaultdict+# from typing import Optional, Union++# import dspy+# from dspy.dsp.modules.sentence_vectorizer import BaseSentenceVectorizer, FastEmbedVectorizer+# from dspy.dsp.utils import dotdict++# try:+# from qdrant_client import QdrantClient, models+# except ImportError as e:+# raise ImportError(+# "The 'qdrant' extra is required to use QdrantRM. Install it with `pip install dspy-ai[qdrant]`",+# ) from e+++# class QdrantRM(dspy.Retrieve):+# """A retrieval module that uses Qdrant to return the top passages for a given query.++# Args:+# qdrant_collection_name (str): The name of the Qdrant collection.+# qdrant_client (QdrantClient): An instance of `qdrant_client.QdrantClient`.+# k (int, optional): The default number of top passages to retrieve. Default: 3.+# document_field (str, optional): The key in the Qdrant payload with the content. Default: `"document"`.+# vectorizer (BaseSentenceVectorizer, optional): An implementation `BaseSentenceVectorizer`.+# Default: `FastEmbedVectorizer`.+# vector_name (str, optional): Name of the vector in the collection. Default: The first available vector name.++# Examples:+# Below is a code snippet that shows how to use Qdrant as the default retriver:+# ```python+# from qdrant_client import QdrantClient++# llm = dspy.OpenAI(model="gpt-3.5-turbo")+# qdrant_client = QdrantClient()+# retriever_model = QdrantRM("my_collection_name", qdrant_client=qdrant_client)+# dspy.settings.configure(lm=llm, rm=retriever_model)+# ```++# Below is a code snippet that shows how to use Qdrant in the forward() function of a module+# ```python+# self.retrieve = QdrantRM(question, k=num_passages, filter=filter)+# ```+# """++# def __init__(+# self,+# qdrant_collection_name: str,+# qdrant_client: QdrantClient,+# k: int = 3,+# document_field: str = "document",+# vectorizer: Optional[BaseSentenceVectorizer] = None,+# vector_name: Optional[str] = None,+# ):+# self._collection_name = qdrant_collection_name+# self._client = qdrant_client++# self._vectorizer = vectorizer or FastEmbedVectorizer(self._client.embedding_model_name)++# self._document_field = document_field++# self._vector_name = vector_name or self._get_first_vector_name()++# super().__init__(k=k)++# def forward(self, query_or_queries: Union[str, list[str]], k: Optional[int] = None, filter: Optional[models.Filter]=None) -> dspy.Prediction:+# """Search with Qdrant for self.k top passages for query.++# Args:+# query_or_queries (Union[str, List[str]]): The query or queries to search for.+# k (Optional[int]): The number of top passages to retrieve. Defaults to self.k.+# filter (Optional["Filter"]): "Look only for points which satisfies this conditions". Default: None.++# Returns:+# dspy.Prediction: An object containing the retrieved passages.+# """+# queries = [query_or_queries] if isinstance(query_or_queries, str) else query_or_queries+# queries = [q for q in queries if q] # Filter empty queries++# vectors = self._vectorizer(queries)++# search_requests = [+# models.QueryRequest(+# query=vector,+# using=self._vector_name,+# limit=k or self.k,+# with_payload=[self._document_field],+# filter=filter,+# )+# for vector in vectors+# ]+# batch_results = self._client.query_batch_points(self._collection_name, requests=search_requests)++# passages_scores = defaultdict(float)+# for batch in batch_results:+# for result in batch.points:+# # If a passage is returned multiple times, the score is accumulated.+# document = result.payload.get(self._document_field)+# passages_scores[document] += result.score++# # Sort passages by their accumulated scores in descending order+# sorted_passages = sorted(passages_scores.items(), key=lambda x: x[1], reverse=True)[:k]++# # Wrap each sorted passage in a dotdict with 'long_text'+# return [dotdict({"long_text": passage}) for passage, _ in sorted_passages]++# def _get_first_vector_name(self) -> Optional[str]:+# vectors = self._client.get_collection(self._collection_name).config.params.vectors++# if not isinstance(vectors, dict):+# # The collection only has the default, unnamed vector+# return None++# first_vector_name = list(vectors.keys())[0]++# # The collection has multiple vectors. Could also include the falsy unnamed vector - Empty string("")+# return first_vector_name or Nonediff --git a/setup.py b/setup.pyindex 2e074d33f..dace8c814 100644--- a/setup.py+++ b/setup.py@@ -16,11 +16,11 @@ setup(description="DSPy",long_description=long_description,long_description_content_type="text/markdown",- url="https://github.com/stanfordnlp/dsp",+ url="https://github.com/stanfordnlp/dspy",author="Omar Khattab",author_email="[email protected]",license="MIT License",- packages=find_packages(include=["dsp.*", "dspy.*", "dsp", "dspy"]),+ packages=find_packages(include=["dspy.*", "dspy"]),python_requires=">=3.9",install_requires=requirements,