Draft: Real vectors for tests

tests/congruence_tests/test_collections.py

@@ -101,7 +101,7 @@ def test_collection_exists():
 
 
 def test_init_from():
-    vector_size = 2
+    vector_size = 384
 
     remote_client = init_remote()
     local_client = init_local()

tests/congruence_tests/test_common.py

@@ -14,14 +14,14 @@
 COLLECTION_NAME = "congruence_test_collection"
 
 # dense vectors sizes
-text_vector_size = 50
-image_vector_size = 100
-code_vector_size = 80
+text_vector_size = 384
+image_vector_size = 384
+code_vector_size = 384
 
 # sparse vectors sizes
-sparse_text_vector_size = 100
-sparse_image_vector_size = 1_000
-sparse_code_vector_size = 10_000
+sparse_text_vector_size = 384
+sparse_image_vector_size = 384
+sparse_code_vector_size = 384
 
 # number of vectors to generate
 NUM_VECTORS = 1000

tests/congruence_tests/test_discovery.py

@@ -16,12 +16,13 @@
     init_remote,
 )
 from tests.fixtures.filters import one_random_filter_please
+from tests.fixtures.points import sample_queries
 
 secondary_collection_name = "congruence_secondary_collection"
 
 
 def random_vector(dims: int) -> list[float]:
-    return np.random.random(dims).round(3).tolist()
+    return sample_queries(1)[0]
 
 
 @pytest.fixture(scope="module")

tests/congruence_tests/test_group_search.py

@@ -18,6 +18,7 @@
     text_vector_size,
 )
 from tests.fixtures.filters import one_random_filter_please
+from tests.fixtures.points import sample_queries
 
 LOOKUP_COLLECTION_NAME = "lookup_collection"
 
@@ -26,9 +27,10 @@ class TestGroupSearcher:
     __test__ = False
 
     def __init__(self):
-        self.query_text = np.random.random(text_vector_size).tolist()
-        self.query_image = np.random.random(image_vector_size).tolist()
-        self.query_code = np.random.random(code_vector_size).tolist()
+        queries = sample_queries(3)
+        self.query_text = queries[0]
+        self.query_image = queries[1]
+        self.query_code = queries[2]
         self.group_by = "rand_digit"
         self.group_size = 1
         self.limit = 10
@@ -217,8 +219,8 @@ def group_by_keys():
 
 
 def test_group_search_types():
-    fixture_points = generate_fixtures(vectors_sizes=50)
-    vectors_config = models.VectorParams(size=50, distance=models.Distance.EUCLID)
+    fixture_points = generate_fixtures(vectors_sizes=text_vector_size)
+    vectors_config = models.VectorParams(size=text_vector_size, distance=models.Distance.EUCLID)
 
     searcher = TestGroupSearcher()
 
@@ -228,17 +230,16 @@ def test_group_search_types():
     remote_client = init_remote()
     init_client(remote_client, fixture_points, vectors_config=vectors_config)
 
-    query_vector_np = np.random.random(text_vector_size)
+    query_vector_np = sample_queries(1)[0]
     compare_client_results(
         local_client,
         remote_client,
         searcher.group_search,
-        query_vector=query_vector_np,
+        query_vector=np.array(query_vector_np),
     )
 
-    query_vector_list = query_vector_np.tolist()
     compare_client_results(
-        local_client, remote_client, searcher.group_search, query_vector=query_vector_list
+        local_client, remote_client, searcher.group_search, query_vector=query_vector_np
     )
 
     delete_fixture_collection(local_client)

tests/congruence_tests/test_query.py

@@ -33,6 +33,7 @@
     generate_random_multivector,
 )
 from tests.utils import read_version
+from tests.fixtures.points import sample_queries
 
 SECONDARY_COLLECTION_NAME = "congruence_secondary_collection"
 
@@ -46,12 +47,15 @@ def __init__(self):
         self.group_size = 3
         self.limit = 2  # number of groups
 
+        sampled_queries = sample_queries(4)
+        self.query_image = sampled_queries[0]
+
         # dense query vectors
-        self.dense_vector_query_text = np.random.random(text_vector_size).tolist()
-        self.dense_vector_query_text_bis = self.dense_vector_query_text
+        self.dense_vector_query_text = sampled_queries[1]
+        self.dense_vector_query_text_bis = sampled_queries[1]
         self.dense_vector_query_text_bis[0] += 42.0  # slightly different vector
-        self.dense_vector_query_image = np.random.random(image_vector_size).tolist()
-        self.dense_vector_query_code = np.random.random(code_vector_size).tolist()
+        self.dense_vector_query_image = sampled_queries[2]
+        self.dense_vector_query_code = sampled_queries[3]
 
         # sparse query vectors
         self.sparse_vector_query_text = generate_random_sparse_vector(
@@ -1458,9 +1462,11 @@ def test_original_input_persistence():
     # the reason was that we were replacing point id with a sparse vector, and then, when we needed a dense vector
     # from the same point id, we already had point id replaced with a sparse vector
     num_points = 50
-    vectors_config = {"text": models.VectorParams(size=50, distance=models.Distance.COSINE)}
+    vectors_config = {
+        "text": models.VectorParams(size=text_vector_size, distance=models.Distance.COSINE)
+    }
     sparse_vectors_config = {"sparse-text": models.SparseVectorParams()}
-    fixture_points = generate_fixtures(vectors_sizes={"text": 50}, num=num_points)
+    fixture_points = generate_fixtures(vectors_sizes={"text": text_vector_size}, num=num_points)
     sparse_fixture_points = generate_sparse_fixtures(num=num_points)
     points = [
         models.PointStruct(

tests/congruence_tests/test_query_batch.py

@@ -19,7 +19,11 @@
     generate_multivector_fixtures,
     multi_vector_config,
 )
-from tests.fixtures.points import generate_random_sparse_vector, generate_random_multivector
+from tests.fixtures.points import (
+    generate_random_sparse_vector,
+    generate_random_multivector,
+    sample_queries,
+)
 
 
 class TestQueryBatchSearcher:
@@ -39,28 +43,27 @@ def __init__(self):
         self.multivector_query_batch_code = []
 
         for _ in range(4):
+            vecs = sample_queries(4)
             self.dense_vector_query_batch_text.append(
                 models.QueryRequest(
-                    query=np.random.random(text_vector_size).tolist(),
-                    prefetch=models.Prefetch(
-                        query=np.random.random(text_vector_size).tolist(), limit=5, using="text"
-                    ),
+                    query=vecs[0],
+                    prefetch=models.Prefetch(query=vecs[1], limit=5, using="text"),
                     limit=5,
                     using="text",
                     with_payload=True,
                 )
             )
             self.dense_vector_query_batch_image.append(
                 models.QueryRequest(
-                    query=np.random.random(image_vector_size).tolist(),
+                    query=vecs[2],
                     limit=5,
                     using="image",
                     with_payload=True,
                 )
             )
             self.dense_vector_query_batch_code.append(
                 models.QueryRequest(
-                    query=np.random.random(code_vector_size).tolist(),
+                    query=vecs[3],
                     limit=5,
                     using="code",
                     with_payload=True,
@@ -101,16 +104,13 @@ def __init__(self):
                 )
             )
 
+        vecs = sample_queries(2)
         self.dense_vector_query_batch_text_dbsf = [
             models.QueryRequest(
                 query=models.FusionQuery(fusion=models.Fusion.DBSF),
                 prefetch=[
-                    models.Prefetch(
-                        query=np.random.random(text_vector_size).tolist(), using="text"
-                    ),
-                    models.Prefetch(
-                        query=np.random.random(text_vector_size).tolist(), using="text"
-                    ),
+                    models.Prefetch(query=vecs[0], using="text"),
+                    models.Prefetch(query=vecs[1], using="text"),
                 ],
                 with_payload=True,
             )

tests/congruence_tests/test_recommendation.py

@@ -16,6 +16,7 @@
     init_remote,
 )
 from tests.fixtures.filters import one_random_filter_please
+from tests.fixtures.points import sample_queries
 
 secondary_collection_name = "congruence_secondary_collection"
 
@@ -24,7 +25,7 @@ class TestSimpleRecommendation:
     __test__ = False
 
     def __init__(self):
-        self.query_image = np.random.random(image_vector_size).tolist()
+        self.query_image = sample_queries(1)[0]
 
     @classmethod
     def simple_recommend_image(cls, client: QdrantBase) -> list[models.ScoredPoint]:
@@ -291,7 +292,6 @@ def test_recommend_from_another_collection():
 
 def test_simple_recommend() -> None:
     fixture_points = generate_fixtures()
-
     secondary_collection_points = generate_fixtures(100)
 
     searcher = TestSimpleRecommendation()

tests/congruence_tests/test_search.py

@@ -22,9 +22,14 @@ class TestSimpleSearcher:
     __test__ = False
 
     def __init__(self):
-        self.query_text = np.random.random(text_vector_size).tolist()
-        self.query_image = np.random.random(image_vector_size).tolist()
-        self.query_code = np.random.random(code_vector_size).tolist()
+        _text_vectors = np.load("data/queries.npy", allow_pickle=True).astype(np.float32)
+        _text_vectors_unique = np.unique(_text_vectors, axis=0)
+        _text_vectors = _text_vectors_unique.tolist()
+        sampled_vectors = np.random.choice(len(_text_vectors), size=3, replace=False)
+
+        self.query_text = _text_vectors[sampled_vectors[0]]
+        self.query_image = _text_vectors[sampled_vectors[1]]
+        self.query_code = _text_vectors[sampled_vectors[2]]
 
     def simple_search_text(self, client: QdrantBase) -> list[models.ScoredPoint]:
         return client.search(

tests/fixtures/points.py

@@ -10,16 +10,32 @@
 from qdrant_client.local.sparse import validate_sparse_vector
 from tests.fixtures.payload import one_random_payload_please
 
+_text_vectors = np.load("data/text.npy", mmap_mode="r")
+_text_vectors_unique = np.unique(_text_vectors, axis=0)
+_text_vectors_clean = _text_vectors_unique[~np.isnan(_text_vectors_unique).any(axis=1)].tolist()
 
-def random_vectors(
-    vector_sizes: Union[dict[str, int], int],
-) -> models.VectorStruct:
+
+def sample_queries(n: int) -> list[np.array]:
+    _query_vectors = np.load("data/queries.npy", allow_pickle=True).astype(np.float32)
+    _query_vectors_unique = np.unique(_query_vectors, axis=0)
+    _query_vectors = _query_vectors_unique.tolist()
+    sampled_vectors = np.random.choice(len(_query_vectors), size=n, replace=False)
+    return [_query_vectors[i] for i in sampled_vectors]
+
+
+def random_vectors(vector_sizes: Union[dict[str, int], int], idx=None) -> models.VectorStruct:
     if isinstance(vector_sizes, int):
-        return np.random.random(vector_sizes).round(3).tolist()
+        if idx:
+            return _text_vectors_clean[idx]
+        else:
+            return np.random.random(vector_sizes).round(3).tolist()
     elif isinstance(vector_sizes, dict):
         vectors = {}
         for vector_name, vector_size in vector_sizes.items():
-            vectors[vector_name] = np.random.random(vector_size).round(3).tolist()
+            if idx:
+                vectors[vector_name] = _text_vectors_clean[idx]
+            else:
+                vectors[vector_name] = np.random.random(vector_size).round(3).tolist()
         return vectors
     else:
         raise ValueError("vector_sizes must be int or dict")
@@ -28,12 +44,12 @@ def random_vectors(
 def random_multivectors(vector_sizes: Union[dict[str, int], int]) -> models.VectorStruct:
     if isinstance(vector_sizes, int):
         vec_count = random.randint(1, 10)
-        return generate_random_multivector(vector_sizes, vec_count)
+        return sample_random_multivector(vector_sizes, vec_count)
     elif isinstance(vector_sizes, dict):
         vectors = {}
         for vector_name, vector_size in vector_sizes.items():
             vec_count = random.randint(1, 10)
-            vectors[vector_name] = generate_random_multivector(vector_size, vec_count)
+            vectors[vector_name] = sample_random_multivector(vector_size, vec_count)
         return vectors
     else:
         raise ValueError("vector_sizes must be int or dict")
@@ -46,6 +62,11 @@ def generate_random_multivector(vec_size: int, vec_count: int) -> list[list[floa
     return multivec
 
 
+def sample_random_multivector(vec_size: int, vec_count: int) -> list[list[float]]:
+    sampled_vectors = np.random.choice(len(_text_vectors_clean), size=vec_count, replace=False)
+    return [_text_vectors_clean[i] for i in sampled_vectors]
+
+
 # Generate random sparse vector with given size and density
 # The density is the probability of non-zero value over the whole vector
 def generate_random_sparse_vector(size: int, density: float) -> SparseVector:
@@ -100,7 +121,9 @@ def generate_points(
     if skip_vectors and isinstance(vector_sizes, int):
         raise ValueError("skip_vectors is not supported for single vector")
 
+    sampled_vectors = np.random.choice(len(_text_vectors_clean), size=num_points, replace=False)
     points = []
+
     for i in range(num_points):
         payload = None
         if with_payload:
@@ -115,7 +138,7 @@ def generate_points(
         elif multivector:
             vectors = random_multivectors(vector_sizes)
         else:
-            vectors = random_vectors(vector_sizes)
+            vectors = random_vectors(vector_sizes, sampled_vectors[i])
 
         if skip_vectors:
             if random.random() > 0.8: