DSPy: The framework for programming—not prompting—language models
Python
Vectorization changed to "DSP way".
Igor Kotenkov7f2ee8d6da2c
diff --git a/dsp/modules/__init__.py b/dsp/modules/__init__.pyindex b2b5f3049..870bafa9e 100644--- a/dsp/modules/__init__.py+++ b/dsp/modules/__init__.py@@ -1,3 +1,4 @@from .cache_utils import *from .gpt3 import *-from .colbertv2 import *\ No newline at end of file+from .colbertv2 import *+from .sentence_vectorizer import *diff --git a/dsp/modules/sentence_vectorizer.py b/dsp/modules/sentence_vectorizer.pynew file mode 100644index 000000000..4ccc7aefc--- /dev/null+++ b/dsp/modules/sentence_vectorizer.py@@ -0,0 +1,75 @@+import abc+from typing import List++import numpy as np++from dsp.utils import determine_devices+++class BaseSentenceVectorizer(abc.ABC):+ def __init__(self) -> None:+ pass++ @abc.abstractmethod+ def __call__(self, inp_examples: List["Example"]) -> np.ndarray:+ pass+++class SentenceTransformersVectorizer(BaseSentenceVectorizer):+ def __init__(+ self,+ model_name_or_path: str = 'all-MiniLM-L6-v2',+ vectorize_bs: int = 256,+ max_gpu_devices: int = 1,+ normalize_embeddings: bool = False+ ):+ # this isn't a good practice, but with top-level import the whole DSP+ # module import will be slow (>5 sec), because SentenceTransformer is doing+ # it's directory/file-related magic under the hood :(+ from sentence_transformers import SentenceTransformer+ self.num_devices, self.is_gpu = determine_devices(max_gpu_devices)+ self.proxy_device = 'cuda' if self.is_gpu else 'cpu'++ self.model = SentenceTransformer(model_name_or_path, device=self.proxy_device)++ self.model_name_or_path = model_name_or_path+ self.vectorize_bs = vectorize_bs+ self.normalize_embeddings = normalize_embeddings++ def __call__(self, inp_examples: List["Example"]) -> np.ndarray:+ text_to_vectorize = [example.text_to_vectorize for example in inp_examples]+ if self.is_gpu and self.num_devices > 1:+ target_devices = list(range(self.num_devices))+ pool = self.model.start_multi_process_pool(target_devices=target_devices)+ # Compute the embeddings using the multi-process pool+ emb = self.model.encode_multi_process(+ sentences=text_to_vectorize,+ pool=pool,+ batch_size=self.vectorize_bs+ )+ self.model.stop_multi_process_pool(pool)+ # for some reason, multi-GPU setup doesn't accept normalize_embeddings parameter+ if self.normalize_embeddings:+ emb = emb / np.linalg.norm(emb)++ return emb+ else:+ emb = self.model.encode(+ sentences=text_to_vectorize,+ batch_size=self.vectorize_bs,+ normalize_embeddings=self.normalize_embeddings+ )+ return emb+++class NaiveGetFieldVectorizer(BaseSentenceVectorizer):+ def __init__(self, field_with_embeding: str = 'vectorized'):+ self.field_with_embeding = field_with_embeding++ def __call__(self, inp_examples: List["Example"]) -> np.ndarray:+ embeddings = [+ getattr(cur_example, self.field_with_embeding).reshape(1, -1)+ for cur_example in inp_examples+ ]+ embeddings = np.concatenate(embeddings, axis=0).astype(np.float32)+ return embeddingsdiff --git a/dsp/primitives/demonstrate.py b/dsp/primitives/demonstrate.pyindex 582c0fc23..7d42003eb 100644--- a/dsp/primitives/demonstrate.py+++ b/dsp/primitives/demonstrate.py@@ -4,8 +4,8 @@ from typing import Callable, Listimport numpy as npimport dsp-from dsp.utils import (EM, DPR_normalize, create_faiss_index,- determine_devices, dotdict, has_answer, normalize_text)+from dsp.utils import (EM, DPR_normalize, create_faiss_index, dotdict,+ has_answer, normalize_text)class Example(dotdict):@@ -125,62 +125,22 @@ def cast_naive_get_question_and_answer(inp_example: Example) -> Example:return inp_example.copy(text_to_vectorize=text_to_vectorize)-def vectorize_naive_get_field(inp_examples: List[Example]) -> np.ndarray:- embeddings = [cur_example.vectorized.reshape(1, -1) for cur_example in inp_examples]- embeddings = np.concatenate(embeddings, axis=0).astype(np.float32)- return embeddings---def get_sentence_transformers_vectorize_func(- model_name_or_path: str = 'all-MiniLM-L6-v2',- vectorize_bs: int = 256,- max_gpu_devices: int = 1,- normalize_embeddings: bool = False-) -> Callable[[List[Example]], np.ndarray]:- from sentence_transformers import SentenceTransformer- num_devices, is_gpu = determine_devices(max_gpu_devices)- proxy_device = 'cuda' if is_gpu else 'cpu'- model = SentenceTransformer(model_name_or_path, device=proxy_device)-- def vectorize_with_sentence_transformers(inp_examples: List[Example]) -> np.ndarray:- text_to_vectorize = [example.text_to_vectorize for example in inp_examples]- if is_gpu and num_devices > 1:- pool = model.start_multi_process_pool(target_devices=list(range(num_devices)))- # Compute the embeddings using the multi-process pool- emb = model.encode_multi_process(text_to_vectorize, pool, batch_size=vectorize_bs)- model.stop_multi_process_pool(pool)- # for some reason, multi-GPU setup doesn't accept normalize_embeddings parameter- if normalize_embeddings:- emb = emb / np.linalg.norm(emb)-- return emb- else:- emb = model.encode(- sentences=text_to_vectorize,- batch_size=vectorize_bs,- normalize_embeddings=normalize_embeddings- )- return emb-- return vectorize_with_sentence_transformers--def knn(train: List[Example],cast: Callable[[Example], Example] = cast_naive_get_only_question_text,- vectorize: Callable[[List[Example]], np.ndarray] = vectorize_naive_get_field,**knn_args) -> Callable[[Example, int], List[Example]]:train_casted_to_vectorize = [cast(cur_elem) for cur_elem in train]- all_vectors = vectorize(train_casted_to_vectorize).astype(np.float32)+ vectorizer: "BaseSentenceVectorizer" = dsp.settings.vectorizer+ all_vectors = vectorizer(train_casted_to_vectorize).astype(np.float32)index = create_faiss_index(emb_dim=all_vectors.shape[1], n_objects=len(train), **knn_args)index.train(all_vectors)index.add(all_vectors)def inner_knn_search(inp_example: Example, k: int) -> List[Example]:- inp_example_vector = vectorize([cast(inp_example)])+ inp_example_vector = vectorizer([cast(inp_example)])_, nearest_samples_idxs = index.search(inp_example_vector, k)train_sampled = [train[cur_idx] for cur_idx in nearest_samples_idxs[0]]return train_sampleddiff --git a/knn_demonstrations_test.ipynb b/knn_demonstrations_test.ipynbindex 28b85ac18..0920ce1a1 100644--- a/knn_demonstrations_test.ipynb+++ b/knn_demonstrations_test.ipynb@@ -67,13 +67,22 @@"metadata": {},"outputs": [],"source": [- "knn_func = dsp.knn(train)"+ "dsp.settings.configure(vectorizer=dsp.NaiveGetFieldVectorizer())"]},{"cell_type": "code","execution_count": 6,"metadata": {},+ "outputs": [],+ "source": [+ "knn_func = dsp.knn(train)"+ ]+ },+ {+ "cell_type": "code",+ "execution_count": 7,+ "metadata": {},"outputs": [{"data": {@@ -81,7 +90,7 @@"[1, 0, 2]"]},- "execution_count": 6,+ "execution_count": 7,"metadata": {},"output_type": "execute_result"}@@ -93,7 +102,7 @@},{"cell_type": "code",- "execution_count": 7,+ "execution_count": 8,"metadata": {},"outputs": [{@@ -102,7 +111,7 @@"[4, 3, 5]"]},- "execution_count": 7,+ "execution_count": 8,"metadata": {},"output_type": "execute_result"}@@ -122,7 +131,7 @@},{"cell_type": "code",- "execution_count": 8,+ "execution_count": 9,"metadata": {},"outputs": [],"source": [@@ -147,16 +156,6 @@"train = [dsp.Example(question=question, answer=answer) for question, answer in train]"]},- {- "cell_type": "code",- "execution_count": 9,- "metadata": {},- "outputs": [],- "source": [- "transformer_vectorize = dsp.get_sentence_transformers_vectorize_func()\n",- "knn_func = dsp.knn(train, vectorize=transformer_vectorize)"- ]- },{"cell_type": "code","execution_count": 10,@@ -177,18 +176,53 @@"source": ["QUERY_IDX = 0\n","\n",- "knn_res_train_vec = knn_func(train[QUERY_IDX], 3)\n",- "print(train[QUERY_IDX].question) # the query itself\n",- "# similar questions\n",- "print('-'*80)\n",- "for i in [train[train.index(i)].question for i in knn_res_train_vec]:\n",- " print(i)"+ "# context manager is working properly\n",+ "with dsp.settings.context(vectorizer=dsp.SentenceTransformersVectorizer()):\n",+ " knn_func = dsp.knn(train)\n",+ " \n",+ "\n",+ " knn_res_train_vec = knn_func(train[QUERY_IDX], 3)\n",+ " print(train[QUERY_IDX].question) # the query itself\n",+ " # similar questions\n",+ " print('-'*80)\n",+ " for i in [train[train.index(i)].question for i in knn_res_train_vec]:\n",+ " print(i)"]},{"cell_type": "code","execution_count": 11,"metadata": {},+ "outputs": [+ {+ "data": {+ "text/plain": [+ "<dsp.modules.sentence_vectorizer.NaiveGetFieldVectorizer at 0x7fc21559c130>"+ ]+ },+ "execution_count": 11,+ "metadata": {},+ "output_type": "execute_result"+ }+ ],+ "source": [+ "# still Naive, not SentenceTransformers - because context has ended its scope\n",+ "dsp.settings.vectorizer"+ ]+ },+ {+ "cell_type": "code",+ "execution_count": 12,+ "metadata": {},+ "outputs": [],+ "source": [+ "dsp.settings.configure(vectorizer=dsp.SentenceTransformersVectorizer())"+ ]+ },+ {+ "cell_type": "code",+ "execution_count": 13,+ "metadata": {},"outputs": [{"name": "stdout",