readme: ---
  pipeline_tag: sentence-similarity
  tags:
  - sentence-transformers
  - feature-extraction
  - sentence-similarity
  datasets:
  - flax-sentence-embeddings/stackexchange_xml
  - ms_marco
  - gooaq
  - yahoo_answers_topics
  - search_qa
  - eli5
  - natural_questions
  - trivia_qa
  - embedding-data/QQP
  - embedding-data/PAQ_pairs
  - embedding-data/Amazon-QA
  - embedding-data/WikiAnswers
  ---
  
  # multi-qa-MiniLM-L6-cos-v1
  This is a [sentence-transformers](https://www.SBERT.net) model: It maps sentences & paragraphs to a 384 dimensional dense vector space and was designed for **semantic search**. It has been trained on 215M (question, answer) pairs from diverse sources. For an introduction to semantic search, have a look at: [SBERT.net - Semantic Search](https://www.sbert.net/examples/applications/semantic-search/README.html)
  
  
  ## Usage (Sentence-Transformers)
  Using this model becomes easy when you have [sentence-transformers](https://www.SBERT.net) installed:
  
  ```
  pip install -U sentence-transformers
  ```
  
  Then you can use the model like this:
  ```python
  from sentence_transformers import SentenceTransformer, util
  
  query = "How many people live in London?"
  docs = ["Around 9 Million people live in London", "London is known for its financial district"]
  
  #Load the model
  model = SentenceTransformer('sentence-transformers/multi-qa-MiniLM-L6-cos-v1')
  
  #Encode query and documents
  query_emb = model.encode(query)
  doc_emb = model.encode(docs)
  
  #Compute dot score between query and all document embeddings
  scores = util.dot_score(query_emb, doc_emb)[0].cpu().tolist()
  
  #Combine docs & scores
  doc_score_pairs = list(zip(docs, scores))
  
  #Sort by decreasing score
  doc_score_pairs = sorted(doc_score_pairs, key=lambda x: x[1], reverse=True)
  
  #Output passages & scores
  for doc, score in doc_score_pairs:
      print(score, doc)
  ```
  
  
  ## PyTorch Usage (HuggingFace Transformers)
  Without [sentence-transformers](https://www.SBERT.net), you can use the model like this: First, you pass your input through the transformer model, then you have to apply the correct pooling-operation on-top of the contextualized word embeddings.
  
  ```python
  from transformers import AutoTokenizer, AutoModel
  import torch
  import torch.nn.functional as F
  
  #Mean Pooling - Take average of all tokens
  def mean_pooling(model_output, attention_mask):
      token_embeddings = model_output.last_hidden_state
      input_mask_expanded = attention_mask.unsqueeze(-1).expand(token_embeddings.size()).float()
      return torch.sum(token_embeddings * input_mask_expanded, 1) / torch.clamp(input_mask_expanded.sum(1), min=1e-9)
  
  
  #Encode text
  def encode(texts):
      # Tokenize sentences
      encoded_input = tokenizer(texts, padding=True, truncation=True, return_tensors='pt')
  
      # Compute token embeddings
      with torch.no_grad():
          model_output = model(**encoded_input, return_dict=True)
  
      # Perform pooling
      embeddings = mean_pooling(model_output, encoded_input['attention_mask'])
  
      # Normalize embeddings
      embeddings = F.normalize(embeddings, p=2, dim=1)
  	
      return embeddings
  
  
  # Sentences we want sentence embeddings for
  query = "How many people live in London?"
  docs = ["Around 9 Million people live in London", "London is known for its financial district"]
  
  # Load model from HuggingFace Hub
  tokenizer = AutoTokenizer.from_pretrained("sentence-transformers/multi-qa-MiniLM-L6-cos-v1")
  model = AutoModel.from_pretrained("sentence-transformers/multi-qa-MiniLM-L6-cos-v1")
  
  #Encode query and docs
  query_emb = encode(query)
  doc_emb = encode(docs)
  
  #Compute dot score between query and all document embeddings
  scores = torch.mm(query_emb, doc_emb.transpose(0, 1))[0].cpu().tolist()
  
  #Combine docs & scores
  doc_score_pairs = list(zip(docs, scores))
  
  #Sort by decreasing score
  doc_score_pairs = sorted(doc_score_pairs, key=lambda x: x[1], reverse=True)
  
  #Output passages & scores
  for doc, score in doc_score_pairs:
      print(score, doc)
  ```
  
  ## TensorFlow Usage (HuggingFace Transformers)
  Similarly to the PyTorch example above, to use the model with TensorFlow you pass your input through the transformer model, then you have to apply the correct pooling-operation on-top of the contextualized word embeddings.
  
  ```python
  from transformers import AutoTokenizer, TFAutoModel
  import tensorflow as tf
  
  #Mean Pooling - Take attention mask into account for correct averaging
  def mean_pooling(model_output, attention_mask):
      token_embeddings = model_output.last_hidden_state
      input_mask_expanded = tf.cast(tf.tile(tf.expand_dims(attention_mask, -1), [1, 1, token_embeddings.shape[-1]]), tf.float32)
      return tf.math.reduce_sum(token_embeddings * input_mask_expanded, 1) / tf.math.maximum(tf.math.reduce_sum(input_mask_expanded, 1), 1e-9)
  
  
  #Encode text
  def encode(texts):
      # Tokenize sentences
      encoded_input = tokenizer(texts, padding=True, truncation=True, return_tensors='tf')
  
      # Compute token embeddings
      model_output = model(**encoded_input, return_dict=True)
  
      # Perform pooling
      embeddings = mean_pooling(model_outpu