From 61d9429c25bfb3238da13accf669213328fcb9a9 Mon Sep 17 00:00:00 2001 From: bogdankostic Date: Thu, 2 Jun 2022 15:05:29 +0200 Subject: [PATCH] Simplify loading of `EmbeddingRetriever` (#2619) * Infer model format for EmbeddingRetriever automatically * Update Documentation & Code Style * Adapt conftest to automatic inference of model_format * Update Documentation & Code Style * Fix tests * Update Documentation & Code Style * Fix tests * Adapt tutorials * Update Documentation & Code Style * Add test for similarity scores with sentence transformers * Adapt doc string and warning message * Update Documentation & Code Style Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com> --- docs/_src/api/api/retriever.md | 14 +++-- .../haystack-pipeline-master.schema.json | 1 - haystack/nodes/retriever/dense.py | 56 +++++++++++++++---- test/conftest.py | 5 +- test/document_stores/test_document_store.py | 24 +++++++- test/nodes/test_retriever.py | 6 +- tutorials/Tutorial11_Pipelines.ipynb | 4 +- tutorials/Tutorial11_Pipelines.py | 4 +- tutorials/Tutorial14_Query_Classifier.ipynb | 6 +- tutorials/Tutorial14_Query_Classifier.py | 4 +- tutorials/Tutorial15_TableQA.ipynb | 52 ++++++++--------- tutorials/Tutorial15_TableQA.py | 6 +- tutorials/Tutorial5_Evaluation.ipynb | 4 +- tutorials/Tutorial5_Evaluation.py | 2 +- 14 files changed, 115 insertions(+), 73 deletions(-) diff --git a/docs/_src/api/api/retriever.md b/docs/_src/api/api/retriever.md index 8cfe87ab81..3f7ec06596 100644 --- a/docs/_src/api/api/retriever.md +++ b/docs/_src/api/api/retriever.md @@ -1171,7 +1171,7 @@ class EmbeddingRetriever(BaseRetriever) #### EmbeddingRetriever.\_\_init\_\_ ```python -def __init__(document_store: BaseDocumentStore, embedding_model: str, model_version: Optional[str] = None, use_gpu: bool = True, batch_size: int = 32, max_seq_len: int = 512, model_format: str = "farm", pooling_strategy: str = "reduce_mean", emb_extraction_layer: int = -1, top_k: int = 10, progress_bar: bool = True, devices: Optional[List[Union[str, torch.device]]] = None, use_auth_token: Optional[Union[str, bool]] = None, scale_score: bool = True, embed_meta_fields: List[str] = []) +def __init__(document_store: BaseDocumentStore, embedding_model: str, model_version: Optional[str] = None, use_gpu: bool = True, batch_size: int = 32, max_seq_len: int = 512, model_format: Optional[str] = None, pooling_strategy: str = "reduce_mean", emb_extraction_layer: int = -1, top_k: int = 10, progress_bar: bool = True, devices: Optional[List[Union[str, torch.device]]] = None, use_auth_token: Optional[Union[str, bool]] = None, scale_score: bool = True, embed_meta_fields: List[str] = []) ``` **Arguments**: @@ -1182,10 +1182,14 @@ def __init__(document_store: BaseDocumentStore, embedding_model: str, model_vers - `use_gpu`: Whether to use all available GPUs or the CPU. Falls back on CPU if no GPU is available. - `batch_size`: Number of documents to encode at once. - `max_seq_len`: Longest length of each document sequence. Maximum number of tokens for the document text. Longer ones will be cut down. -- `model_format`: Name of framework that was used for saving the model. Options: -- ``'farm'`` -- ``'transformers'`` -- ``'sentence_transformers'`` +- `model_format`: Name of framework that was used for saving the model or model type. If no model_format is +provided, it will be inferred automatically from the model configuration files. +Options: + +- ``'farm'`` (will use `_DefaultEmbeddingEncoder` as embedding encoder) +- ``'transformers'`` (will use `_DefaultEmbeddingEncoder` as embedding encoder) +- ``'sentence_transformers'`` (will use `_SentenceTransformersEmbeddingEncoder` as embedding encoder) +- ``'retribert'`` (will use `_RetribertEmbeddingEncoder` as embedding encoder) - `pooling_strategy`: Strategy for combining the embeddings from the model (for farm / transformers models only). Options: diff --git a/haystack/json-schemas/haystack-pipeline-master.schema.json b/haystack/json-schemas/haystack-pipeline-master.schema.json index f61a907b56..fa117e876c 100644 --- a/haystack/json-schemas/haystack-pipeline-master.schema.json +++ b/haystack/json-schemas/haystack-pipeline-master.schema.json @@ -2265,7 +2265,6 @@ }, "model_format": { "title": "Model Format", - "default": "farm", "type": "string" }, "pooling_strategy": { diff --git a/haystack/nodes/retriever/dense.py b/haystack/nodes/retriever/dense.py index a4ebf7a1a7..ed568da4cf 100644 --- a/haystack/nodes/retriever/dense.py +++ b/haystack/nodes/retriever/dense.py @@ -3,6 +3,7 @@ import logging from pathlib import Path from copy import deepcopy +from requests.exceptions import HTTPError import numpy as np from tqdm.auto import tqdm @@ -11,6 +12,8 @@ from torch.nn import DataParallel from torch.utils.data.sampler import SequentialSampler import pandas as pd +from huggingface_hub import hf_hub_download +from transformers import AutoConfig from haystack.errors import HaystackError from haystack.schema import Document @@ -1452,7 +1455,7 @@ def __init__( use_gpu: bool = True, batch_size: int = 32, max_seq_len: int = 512, - model_format: str = "farm", + model_format: Optional[str] = None, pooling_strategy: str = "reduce_mean", emb_extraction_layer: int = -1, top_k: int = 10, @@ -1469,11 +1472,14 @@ def __init__( :param use_gpu: Whether to use all available GPUs or the CPU. Falls back on CPU if no GPU is available. :param batch_size: Number of documents to encode at once. :param max_seq_len: Longest length of each document sequence. Maximum number of tokens for the document text. Longer ones will be cut down. - :param model_format: Name of framework that was used for saving the model. Options: - - - ``'farm'`` - - ``'transformers'`` - - ``'sentence_transformers'`` + :param model_format: Name of framework that was used for saving the model or model type. If no model_format is + provided, it will be inferred automatically from the model configuration files. + Options: + + - ``'farm'`` (will use `_DefaultEmbeddingEncoder` as embedding encoder) + - ``'transformers'`` (will use `_DefaultEmbeddingEncoder` as embedding encoder) + - ``'sentence_transformers'`` (will use `_SentenceTransformersEmbeddingEncoder` as embedding encoder) + - ``'retribert'`` (will use `_RetribertEmbeddingEncoder` as embedding encoder) :param pooling_strategy: Strategy for combining the embeddings from the model (for farm / transformers models only). Options: @@ -1514,7 +1520,6 @@ def __init__( self.document_store = document_store self.embedding_model = embedding_model - self.model_format = model_format self.model_version = model_version self.use_gpu = use_gpu self.batch_size = batch_size @@ -1525,19 +1530,26 @@ def __init__( self.progress_bar = progress_bar self.use_auth_token = use_auth_token self.scale_score = scale_score + self.model_format = self._infer_model_format(embedding_model) if model_format is None else model_format logger.info(f"Init retriever using embeddings of model {embedding_model}") - if model_format not in _EMBEDDING_ENCODERS.keys(): + if self.model_format not in _EMBEDDING_ENCODERS.keys(): raise ValueError(f"Unknown retriever embedding model format {model_format}") - if self.embedding_model.startswith("sentence-transformers") and self.model_format != "sentence_transformers": + if ( + self.embedding_model.startswith("sentence-transformers") + and model_format + and model_format != "sentence_transformers" + ): logger.warning( f"You seem to be using a Sentence Transformer embedding model but 'model_format' is set to '{self.model_format}'." - f" You may need to set 'model_format='sentence_transformers' to ensure correct loading of model." + f" You may need to set model_format='sentence_transformers' to ensure correct loading of model." + f"As an alternative, you can let Haystack derive the format automatically by not setting the " + f"'model_format' parameter at all." ) - self.embedding_encoder = _EMBEDDING_ENCODERS[model_format](self) + self.embedding_encoder = _EMBEDDING_ENCODERS[self.model_format](self) self.embed_meta_fields = embed_meta_fields def retrieve( @@ -1817,3 +1829,25 @@ def _preprocess_documents(self, docs: List[Document]) -> List[Document]: doc.content = "\n".join(meta_data_fields + [doc.content]) linearized_docs.append(doc) return linearized_docs + + @staticmethod + def _infer_model_format(model_name_or_path: str) -> str: + # Check if model name is a local directory with sentence transformers config file in it + if Path(model_name_or_path).exists(): + if Path(f"{model_name_or_path}/config_sentence_transformers.json").exists(): + return "sentence_transformers" + # Check if sentence transformers config file in model hub + else: + try: + hf_hub_download(repo_id=model_name_or_path, filename="config_sentence_transformers.json") + return "sentence_transformers" + except HTTPError: + pass + + # Check if retribert model + config = AutoConfig.from_pretrained(model_name_or_path) + if config.model_type == "retribert": + return "retribert" + + # Model is neither sentence-transformers nor retribert model -> use _DefaultEmbeddingEncoder + return "farm" diff --git a/test/conftest.py b/test/conftest.py index 2f4f8902ad..ded06bb3e1 100644 --- a/test/conftest.py +++ b/test/conftest.py @@ -674,10 +674,7 @@ def get_retriever(retriever_type, document_store): ) elif retriever_type == "retribert": retriever = EmbeddingRetriever( - document_store=document_store, - embedding_model="yjernite/retribert-base-uncased", - model_format="retribert", - use_gpu=False, + document_store=document_store, embedding_model="yjernite/retribert-base-uncased", use_gpu=False ) elif retriever_type == "dpr_lfqa": retriever = DensePassageRetriever( diff --git a/test/document_stores/test_document_store.py b/test/document_stores/test_document_store.py index a892c79167..04442a7123 100644 --- a/test/document_stores/test_document_store.py +++ b/test/document_stores/test_document_store.py @@ -1387,7 +1387,7 @@ def test_elasticsearch_synonyms(): "document_store_with_docs", ["memory", "faiss", "milvus1", "weaviate", "elasticsearch"], indirect=True ) @pytest.mark.embedding_dim(384) -def test_similarity_score(document_store_with_docs): +def test_similarity_score_sentence_transformers(document_store_with_docs): retriever = EmbeddingRetriever( document_store=document_store_with_docs, embedding_model="sentence-transformers/paraphrase-MiniLM-L3-v2" ) @@ -1395,6 +1395,25 @@ def test_similarity_score(document_store_with_docs): pipeline = DocumentSearchPipeline(retriever) prediction = pipeline.run("Paul lives in New York") scores = [document.score for document in prediction["documents"]] + assert scores == pytest.approx( + [0.8497486114501953, 0.6622999012470245, 0.6077829301357269, 0.5928314849734306, 0.5614184625446796], abs=1e-3 + ) + + +@pytest.mark.parametrize( + "document_store_with_docs", ["memory", "faiss", "milvus1", "weaviate", "elasticsearch"], indirect=True +) +@pytest.mark.embedding_dim(384) +def test_similarity_score(document_store_with_docs): + retriever = EmbeddingRetriever( + document_store=document_store_with_docs, + embedding_model="sentence-transformers/paraphrase-MiniLM-L3-v2", + model_format="farm", + ) + document_store_with_docs.update_embeddings(retriever) + pipeline = DocumentSearchPipeline(retriever) + prediction = pipeline.run("Paul lives in New York") + scores = [document.score for document in prediction["documents"]] assert scores == pytest.approx( [0.9102507941407827, 0.6937791467877008, 0.6491682889305038, 0.6321622491318529, 0.5909129441370939], abs=1e-3 ) @@ -1409,6 +1428,7 @@ def test_similarity_score_without_scaling(document_store_with_docs): document_store=document_store_with_docs, embedding_model="sentence-transformers/paraphrase-MiniLM-L3-v2", scale_score=False, + model_format="farm", ) document_store_with_docs.update_embeddings(retriever) pipeline = DocumentSearchPipeline(retriever) @@ -1428,6 +1448,7 @@ def test_similarity_score_dot_product(document_store_dot_product_with_docs): retriever = EmbeddingRetriever( document_store=document_store_dot_product_with_docs, embedding_model="sentence-transformers/paraphrase-MiniLM-L3-v2", + model_format="farm", ) document_store_dot_product_with_docs.update_embeddings(retriever) pipeline = DocumentSearchPipeline(retriever) @@ -1447,6 +1468,7 @@ def test_similarity_score_dot_product_without_scaling(document_store_dot_product document_store=document_store_dot_product_with_docs, embedding_model="sentence-transformers/paraphrase-MiniLM-L3-v2", scale_score=False, + model_format="farm", ) document_store_dot_product_with_docs.update_embeddings(retriever) pipeline = DocumentSearchPipeline(retriever) diff --git a/test/nodes/test_retriever.py b/test/nodes/test_retriever.py index 5c817fb2ed..3661fdc3f9 100644 --- a/test/nodes/test_retriever.py +++ b/test/nodes/test_retriever.py @@ -591,11 +591,13 @@ def test_embeddings_encoder_of_embedding_retriever_should_warn_about_model_forma with caplog.at_level(logging.WARNING): EmbeddingRetriever( - document_store=document_store, embedding_model="sentence-transformers/paraphrase-multilingual-mpnet-base-v2" + document_store=document_store, + embedding_model="sentence-transformers/paraphrase-multilingual-mpnet-base-v2", + model_format="farm", ) assert ( - "You may need to set 'model_format='sentence_transformers' to ensure correct loading of model." + "You may need to set model_format='sentence_transformers' to ensure correct loading of model." in caplog.text ) diff --git a/tutorials/Tutorial11_Pipelines.ipynb b/tutorials/Tutorial11_Pipelines.ipynb index 042aa8a052..4c0a21e824 100644 --- a/tutorials/Tutorial11_Pipelines.ipynb +++ b/tutorials/Tutorial11_Pipelines.ipynb @@ -224,9 +224,7 @@ "\n", "# Initialize dense retriever\n", "embedding_retriever = EmbeddingRetriever(\n", - " document_store,\n", - " model_format=\"sentence_transformers\",\n", - " embedding_model=\"sentence-transformers/multi-qa-mpnet-base-dot-v1\",\n", + " document_store, embedding_model=\"sentence-transformers/multi-qa-mpnet-base-dot-v1\"\n", ")\n", "document_store.update_embeddings(embedding_retriever, update_existing_embeddings=False)\n", "\n", diff --git a/tutorials/Tutorial11_Pipelines.py b/tutorials/Tutorial11_Pipelines.py index 9e6455fcee..994f203cf9 100644 --- a/tutorials/Tutorial11_Pipelines.py +++ b/tutorials/Tutorial11_Pipelines.py @@ -33,9 +33,7 @@ def tutorial11_pipelines(): # Initialize dense retriever embedding_retriever = EmbeddingRetriever( - document_store, - model_format="sentence_transformers", - embedding_model="sentence-transformers/multi-qa-mpnet-base-dot-v1", + document_store, embedding_model="sentence-transformers/multi-qa-mpnet-base-dot-v1" ) document_store.update_embeddings(embedding_retriever, update_existing_embeddings=False) diff --git a/tutorials/Tutorial14_Query_Classifier.ipynb b/tutorials/Tutorial14_Query_Classifier.ipynb index d083e5f477..c672a879c0 100644 --- a/tutorials/Tutorial14_Query_Classifier.ipynb +++ b/tutorials/Tutorial14_Query_Classifier.ipynb @@ -408,9 +408,7 @@ "\n", "# Initialize dense retriever\n", "embedding_retriever = EmbeddingRetriever(\n", - " document_store=document_store,\n", - " model_format=\"sentence_transformers\",\n", - " embedding_model=\"sentence-transformers/multi-qa-mpnet-base-dot-v1\",\n", + " document_store=document_store, embedding_model=\"sentence-transformers/multi-qa-mpnet-base-dot-v1\"\n", ")\n", "document_store.update_embeddings(embedding_retriever, update_existing_embeddings=False)\n", "\n", @@ -6782,4 +6780,4 @@ }, "nbformat": 4, "nbformat_minor": 1 -} +} \ No newline at end of file diff --git a/tutorials/Tutorial14_Query_Classifier.py b/tutorials/Tutorial14_Query_Classifier.py index 2027fec39e..c17c98b4ff 100644 --- a/tutorials/Tutorial14_Query_Classifier.py +++ b/tutorials/Tutorial14_Query_Classifier.py @@ -38,9 +38,7 @@ def tutorial14_query_classifier(): # Initialize dense retriever embedding_retriever = EmbeddingRetriever( - document_store=document_store, - model_format="sentence_transformers", - embedding_model="sentence-transformers/multi-qa-mpnet-base-dot-v1", + document_store=document_store, embedding_model="sentence-transformers/multi-qa-mpnet-base-dot-v1" ) document_store.update_embeddings(embedding_retriever, update_existing_embeddings=False) diff --git a/tutorials/Tutorial15_TableQA.ipynb b/tutorials/Tutorial15_TableQA.ipynb index 999a396058..2782125a44 100644 --- a/tutorials/Tutorial15_TableQA.ipynb +++ b/tutorials/Tutorial15_TableQA.ipynb @@ -255,11 +255,7 @@ "source": [ "from haystack.nodes.retriever import EmbeddingRetriever\n", "\n", - "retriever = EmbeddingRetriever(\n", - " document_store=document_store,\n", - " embedding_model=\"deepset/all-mpnet-base-v2-table\",\n", - " model_format=\"sentence_transformers\",\n", - ")" + "retriever = EmbeddingRetriever(document_store=document_store, embedding_model=\"deepset/all-mpnet-base-v2-table\")" ] }, { @@ -1876,29 +1872,29 @@ ] }, { - "cell_type": "code", - "execution_count": 18, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 540 - }, - "id": "K4vH1ZEnniut", - "outputId": "85aa17a8-227d-40e4-c8c0-5d0532faa47a" + "cell_type": "code", + "execution_count": 18, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 540 }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "" - ] - }, - "execution_count": 18, - "metadata": {}, - "output_type": "execute_result" - } - ], + "id": "K4vH1ZEnniut", + "outputId": "85aa17a8-227d-40e4-c8c0-5d0532faa47a" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "# Let's have a look on the structure of the combined Table an Text QA pipeline.\n", "from IPython import display\n", @@ -3413,4 +3409,4 @@ }, "nbformat": 4, "nbformat_minor": 0 -} +} \ No newline at end of file diff --git a/tutorials/Tutorial15_TableQA.py b/tutorials/Tutorial15_TableQA.py index c96e799522..c22717f6a0 100644 --- a/tutorials/Tutorial15_TableQA.py +++ b/tutorials/Tutorial15_TableQA.py @@ -54,11 +54,7 @@ def read_tables(filename): # **Here:** We use the EmbeddingRetriever capable of retrieving relevant content among a database # of texts and tables using dense embeddings. - retriever = EmbeddingRetriever( - document_store=document_store, - embedding_model="deepset/all-mpnet-base-v2-table", - model_format="sentence_transformers", - ) + retriever = EmbeddingRetriever(document_store=document_store, embedding_model="deepset/all-mpnet-base-v2-table") # Add table embeddings to the tables in DocumentStore document_store.update_embeddings(retriever=retriever) diff --git a/tutorials/Tutorial5_Evaluation.ipynb b/tutorials/Tutorial5_Evaluation.ipynb index b5cc4340c1..c2f7ca9f79 100644 --- a/tutorials/Tutorial5_Evaluation.ipynb +++ b/tutorials/Tutorial5_Evaluation.ipynb @@ -263,7 +263,7 @@ "# For more information and suggestions on different models check out the documentation at: https://www.sbert.net/docs/pretrained_models.html\n", "\n", "# from haystack.retriever import EmbeddingRetriever, DensePassageRetriever\n", - "# retriever = EmbeddingRetriever(document_store=document_store, model_format=\"sentence_transformers\",\n", + "# retriever = EmbeddingRetriever(document_store=document_store,\n", "# embedding_model=\"sentence-transformers/multi-qa-mpnet-base-dot-v1\")\n", "# retriever = DensePassageRetriever(document_store=document_store,\n", "# query_embedding_model=\"facebook/dpr-question_encoder-single-nq-base\",\n", @@ -15737,4 +15737,4 @@ }, "nbformat": 4, "nbformat_minor": 2 -} +} \ No newline at end of file diff --git a/tutorials/Tutorial5_Evaluation.py b/tutorials/Tutorial5_Evaluation.py index abc745b5c9..6eed2caca0 100644 --- a/tutorials/Tutorial5_Evaluation.py +++ b/tutorials/Tutorial5_Evaluation.py @@ -77,7 +77,7 @@ def tutorial5_evaluation(): # For more information and suggestions on different models check out the documentation at: https://www.sbert.net/docs/pretrained_models.html # from haystack.retriever import EmbeddingRetriever, DensePassageRetriever - # retriever = EmbeddingRetriever(document_store=document_store, model_format="sentence_transformers", + # retriever = EmbeddingRetriever(document_store=document_store, # embedding_model="sentence-transformers/multi-qa-mpnet-base-dot-v1") # retriever = DensePassageRetriever(document_store=document_store, # query_embedding_model="facebook/dpr-question_encoder-single-nq-base",