Model Card with TensorFlow example

This PRs adds a TensorFlow example that mimics the PT example, that uses the newly added TF weights.

PT example outputs:
```
0.9156370162963867 Around 9 Million people live in London
0.49475783109664917 London is known for its financial district
```

TF example outputs:
```
0.9156371355056763 Around 9 Million people live in London
0.49475765228271484 London is known for its financial district
```

README.md

@@ -46,7 +46,7 @@ for doc, score in doc_score_pairs:
 ```
 
 
-## Usage (HuggingFace Transformers)
+## 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
@@ -56,7 +56,7 @@ 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 #First element of model_output contains all token embeddings
+    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)
 
@@ -105,6 +105,63 @@ 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_output, encoded_input['attention_mask'])
+
+    # Normalize embeddings
+    embeddings = tf.math.l2_normalize(embeddings, axis=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 = TFAutoModel.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 = (query_emb @ tf.transpose(doc_emb))[0].numpy().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)
+```
+
 ## Technical Details
 
 In the following some technical details how this model must be used: