Get error <MilvusException: (code=1, message=Unexpected error, message=<required argument is not a float>)> When doing Milvus Hybird Search

[Kgg9]

I'm not sure why I get this error the Traceback isn't very helpful, and I followed everything from the tutorial docs, but I added my own local embedder model.

from pymilvus import (
    MilvusClient, DataType
)

client = MilvusClient(
    uri="http://localhost:19530",
    token="root:Milvus"
)

Create schema
schema = MilvusClient.create_schema(
    auto_id=False,
    enable_dynamic_field=True,
)
Add fields to schema
schema.add_field(field_name="id", datatype=DataType.INT64, is_primary=True)
schema.add_field(field_name="text", datatype=DataType.VARCHAR, max_length=2000)
schema.add_field(field_name="sparse", datatype=DataType.SPARSE_FLOAT_VECTOR)
schema.add_field(field_name="dense", datatype=DataType.FLOAT_VECTOR, dim=768)



# Setting up Milvus Databse - Setting up Index

Prepare index parameters
index_params = client.prepare_index_params()

Add indexes
index_params.add_index(
    field_name="dense",
    index_name="dense_index",
    index_type="IVF_FLAT",
    metric_type="IP",
    params={"nlist": 128},
)

index_params.add_index(
    field_name="sparse",
    index_name="sparse_index",
    index_type="SPARSE_INVERTED_INDEX",  # Index type for sparse vectors
    metric_type="IP",  # Currently, only IP (Inner Product) is supported for sparse vectors
    params={"drop_ratio_build": 0.2},  # The ratio of small vector values to be dropped during indexing
)



# Setting up Milvus Database - Creating Collection
client.create_collection(
    collection_name="SalesDoc",
    schema=schema,
    index_params=index_params
)



# Creating Data to be inserted into Milvus - Chunking the Documnet

from langchain_community.document_loaders import PyPDFLoader # Loading the Document

loader = PyPDFLoader("Sales_Doc.pdf")
pages = loader.load()

from langchain.text_splitter import RecursiveCharacterTextSplitter

text_splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=200)
chunks = text_splitter.split_documents(pages)

chunks = [chunk.page_content for chunk in chunks]



# Creating Data to be inserted into Milvus - Creating Dense Embeddings
from llama_cpp import Llama

embeddings = []

Load the model
model = Llama(model_path="nomic-embed-text-v1.5.Q4_K_M.gguf", embedding=True)

for chunk in chunks:
    embeddings.append(model.embed(chunk))



# Creating Data to be inserted into Milvus - Creating Sparse Embeddings

from pymilvus.model.sparse.bm25.tokenizers import build_default_analyzer
from pymilvus.model.sparse import BM25EmbeddingFunction

analyzer = build_default_analyzer(language="en")
Use the analyzer to instantiate the BM25EmbeddingFunction
bm25_ef = BM25EmbeddingFunction(analyzer)

Fit the model on the corpus to get the statistics of the corpus
bm25_ef.fit(chunks)

sparseEmbeddings = bm25_ef.encode_documents(chunks)

sparseEmbeddings = sparseEmbeddings.todense()

sparseEmbeds = []
for embedding in sparseEmbeddings:
    embed_dict = {}
    for index, val in enumerate(embedding):
        if val == 0:
            continue
        else:
            embed_dict[index] = val
    if len(embed_dict) == 0:
        continue
    sparseEmbeds.append(embed_dict)



# Creating Data to be inserted into Milvus - Creating Dataset to be inserted

data = []

for index, chunk in enumerate(chunks):
    data.append({"id": index, "text": chunk, "sparse": sparseEmbeds[index], "dense": embeddings[index]})



#Inserting Data into the Milvus Collection

res = client.insert(
    collection_name="SalesDoc",
    data=data
)

Get Sparse and Dense Vectors for Query

def get_Sparse_and_Dense(query):
    dense_embedding = model.embed(query)
    sparse_embedding = bm25_ef.encode_queries(query).todense()

    sparseEmbeds = []
    for embedding in sparse_embedding:
        embed_dict = {}
        for index, val in enumerate(embedding):
            if val == 0:
                continue
            else:
                embed_dict[index] = val
        if len(embed_dict) == 0:
            continue
        sparseEmbeds.append(embed_dict)

    return (sparseEmbeds, dense_embedding)


# Combining Vector and Bm25 search

from pymilvus import AnnSearchRequest

query = "What is the price of the White printer Model X3?"

query_sparse_vector,query_dense_vector = get_Sparse_and_Dense(query)
query_sparse_vector = tuple(query_sparse_vector)

search_param_1 = {
    "data": [query_dense_vector],
    "anns_field": "dense",
    "param": {
        "metric_type": "IP",
        "params":{"nlist": 128}
    },
    "limit": 2
}
request_1 = AnnSearchRequest(**search_param_1)

search_param_2 = {
    "data": [query_sparse_vector],
    "anns_field": "sparse",
    "param": {
        "metric_type": "IP",
        "params": {"drop_ratio_build": 0.2}
    },
    "limit": 2
}
request_2 = AnnSearchRequest(**search_param_2)

reqs = [request_1, request_2]


#Using Reranker - 60 is default value

from pymilvus import RRFRanker
ranker = RRFRanker(100)


# Hybird Search
res = client.hybrid_search(
    collection_name="SalesDoc",
    reqs=reqs,
    ranker=ranker,
    limit=2
)
for hits in res:
    print("TopK results:")
    for hit in hits:
        print(hit)

[yhmo]

The required sparse embedding should be a dict, not a tuple.

Change the method get_Sparse_and_Dense() to be:

def get_Sparse_and_Dense(query):
    # dense_embedding = model.embed(query)
    dense_embedding = [random.random() for _ in range(768)]
    sparse_embedding = bm25_ef.encode_queries(query).todense()

    sparseEmbeds = {}
    for embedding in sparse_embedding:
        for index, val in enumerate(embedding):
            if val == 0:
                continue
            else:
                sparseEmbeds[index] = val
        if len(embed_dict) == 0:
            continue

    return (sparseEmbeds, dense_embedding)

And remove this line:
# query_sparse_vector = tuple(query_sparse_vector)

If you got an empty result, set the consistency_level to "Strong":

res = client.hybrid_search(
    collection_name="SalesDoc",
    reqs=reqs,
    ranker=ranker,
    limit=2,
    consistency_level="Strong"
)