Skip to content

armgit / dspy

Public Imported from GitHub
0

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__.py
index 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.py
new file mode 100644
index 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 embeddings
diff --git a/dsp/primitives/demonstrate.py b/dsp/primitives/demonstrate.py
index 582c0fc23..7d42003eb 100644
--- a/dsp/primitives/demonstrate.py
+++ b/dsp/primitives/demonstrate.py
@@ -4,8 +4,8 @@ from typing import Callable, List
import numpy as np
import 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_sampled
diff --git a/knn_demonstrations_test.ipynb b/knn_demonstrations_test.ipynb
index 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",