Upload folder using huggingface_hub

README.md

@@ -71,57 +71,6 @@ cd FlagEmbedding
 pip install -e .
 ```
 
-#### For normal reranker (bge-reranker-base / bge-reranker-large / bge-reranker-v2-m3 )
-
-Get relevance scores (higher scores indicate more relevance):
-
-```python
-from FlagEmbedding import FlagReranker
-reranker = FlagReranker('BAAI/bge-reranker-v2-m3', use_fp16=True) # Setting use_fp16 to True speeds up computation with a slight performance degradation
-
-score = reranker.compute_score(['query', 'passage'])
-print(score) # -5.65234375
-
-# You can map the scores into 0-1 by set "normalize=True", which will apply sigmoid function to the score
-score = reranker.compute_score(['query', 'passage'], normalize=True)
-print(score) # 0.003497010252573502
-
-scores = reranker.compute_score([['what is panda?', 'hi'], ['what is panda?', 'The giant panda (Ailuropoda melanoleuca), sometimes called a panda bear or simply panda, is a bear species endemic to China.']])
-print(scores) # [-8.1875, 5.26171875]
-
-# You can map the scores into 0-1 by set "normalize=True", which will apply sigmoid function to the score
-scores = reranker.compute_score([['what is panda?', 'hi'], ['what is panda?', 'The giant panda (Ailuropoda melanoleuca), sometimes called a panda bear or simply panda, is a bear species endemic to China.']], normalize=True)
-print(scores) # [0.00027803096387751553, 0.9948403768236574]
-```
-
-#### For LLM-based reranker
-
-```python
-from FlagEmbedding import FlagLLMReranker
-reranker = FlagLLMReranker('BAAI/bge-reranker-v2-gemma', use_fp16=True) # Setting use_fp16 to True speeds up computation with a slight performance degradation
-# reranker = FlagLLMReranker('BAAI/bge-reranker-v2-gemma', use_bf16=True) # You can also set use_bf16=True to speed up computation with a slight performance degradation
-
-score = reranker.compute_score(['query', 'passage'])
-print(score)
-
-scores = reranker.compute_score([['what is panda?', 'hi'], ['what is panda?', 'The giant panda (Ailuropoda melanoleuca), sometimes called a panda bear or simply panda, is a bear species endemic to China.']])
-print(scores)
-```
-
-#### For LLM-based layerwise reranker
-
-```python
-from FlagEmbedding import LayerWiseFlagLLMReranker
-reranker = LayerWiseFlagLLMReranker('BAAI/bge-reranker-v2-minicpm-layerwise', use_fp16=True) # Setting use_fp16 to True speeds up computation with a slight performance degradation
-# reranker = LayerWiseFlagLLMReranker('BAAI/bge-reranker-v2-minicpm-layerwise', use_bf16=True) # You can also set use_bf16=True to speed up computation with a slight performance degradation
-
-score = reranker.compute_score(['query', 'passage'], cutoff_layers=[28]) # Adjusting 'cutoff_layers' to pick which layers are used for computing the score.
-print(score)
-
-scores = reranker.compute_score([['what is panda?', 'hi'], ['what is panda?', 'The giant panda (Ailuropoda melanoleuca), sometimes called a panda bear or simply panda, is a bear species endemic to China.']], cutoff_layers=[28])
-print(scores)
-```
-
 #### For LLM-based lightweight reranker
 
 ```python
@@ -137,150 +86,6 @@ print(scores)
 
 ### Using Huggingface transformers
 
-#### For normal reranker (bge-reranker-base / bge-reranker-large / bge-reranker-v2-m3 )
-
-Get relevance scores (higher scores indicate more relevance):
-
-```python
-import torch
-from transformers import AutoModelForSequenceClassification, AutoTokenizer
-
-tokenizer = AutoTokenizer.from_pretrained('BAAI/bge-reranker-v2-m3')
-model = AutoModelForSequenceClassification.from_pretrained('BAAI/bge-reranker-v2-m3')
-model.eval()
-
-pairs = [['what is panda?', 'hi'], ['what is panda?', 'The giant panda (Ailuropoda melanoleuca), sometimes called a panda bear or simply panda, is a bear species endemic to China.']]
-with torch.no_grad():
-    inputs = tokenizer(pairs, padding=True, truncation=True, return_tensors='pt', max_length=512)
-    scores = model(**inputs, return_dict=True).logits.view(-1, ).float()
-    print(scores)
-```
-
-#### For LLM-based reranker
-
-```python
-import torch
-from transformers import AutoModelForCausalLM, AutoTokenizer
-
-def get_inputs(pairs, tokenizer, prompt=None, max_length=1024):
-    if prompt is None:
-        prompt = "Given a query A and a passage B, determine whether the passage contains an answer to the query by providing a prediction of either 'Yes' or 'No'."
-    sep = "\n"
-    prompt_inputs = tokenizer(prompt,
-                              return_tensors=None,
-                              add_special_tokens=False)['input_ids']
-    sep_inputs = tokenizer(sep,
-                           return_tensors=None,
-                           add_special_tokens=False)['input_ids']
-    inputs = []
-    for query, passage in pairs:
-        query_inputs = tokenizer(f'A: {query}',
-                                 return_tensors=None,
-                                 add_special_tokens=False,
-                                 max_length=max_length * 3 // 4,
-                                 truncation=True)
-        passage_inputs = tokenizer(f'B: {passage}',
-                                   return_tensors=None,
-                                   add_special_tokens=False,
-                                   max_length=max_length,
-                                   truncation=True)
-        item = tokenizer.prepare_for_model(
-            [tokenizer.bos_token_id] + query_inputs['input_ids'],
-            sep_inputs + passage_inputs['input_ids'],
-            truncation='only_second',
-            max_length=max_length,
-            padding=False,
-            return_attention_mask=False,
-            return_token_type_ids=False,
-            add_special_tokens=False
-        )
-        item['input_ids'] = item['input_ids'] + sep_inputs + prompt_inputs
-        item['attention_mask'] = [1] * len(item['input_ids'])
-        inputs.append(item)
-    return tokenizer.pad(
-            inputs,
-            padding=True,
-            max_length=max_length + len(sep_inputs) + len(prompt_inputs),
-            pad_to_multiple_of=8,
-            return_tensors='pt',
-    )
-
-tokenizer = AutoTokenizer.from_pretrained('BAAI/bge-reranker-v2-gemma')
-model = AutoModelForCausalLM.from_pretrained('BAAI/bge-reranker-v2-gemma')
-yes_loc = tokenizer('Yes', add_special_tokens=False)['input_ids'][0]
-model.eval()
-
-pairs = [['what is panda?', 'hi'], ['what is panda?', 'The giant panda (Ailuropoda melanoleuca), sometimes called a panda bear or simply panda, is a bear species endemic to China.']]
-with torch.no_grad():
-    inputs = get_inputs(pairs, tokenizer)
-    scores = model(**inputs, return_dict=True).logits[:, -1, yes_loc].view(-1, ).float()
-    print(scores)
-```
-
-#### For LLM-based layerwise reranker
-
-```python
-import torch
-from transformers import AutoModelForCausalLM, AutoTokenizer
-
-def get_inputs(pairs, tokenizer, prompt=None, max_length=1024):
-    if prompt is None:
-        prompt = "Given a query A and a passage B, determine whether the passage contains an answer to the query by providing a prediction of either 'Yes' or 'No'."
-    sep = "\n"
-    prompt_inputs = tokenizer(prompt,
-                              return_tensors=None,
-                              add_special_tokens=False)['input_ids']
-    sep_inputs = tokenizer(sep,
-                           return_tensors=None,
-                           add_special_tokens=False)['input_ids']
-    inputs = []
-    for query, passage in pairs:
-        query_inputs = tokenizer(f'A: {query}',
-                                 return_tensors=None,
-                                 add_special_tokens=False,
-                                 max_length=max_length * 3 // 4,
-                                 truncation=True)
-        passage_inputs = tokenizer(f'B: {passage}',
-                                   return_tensors=None,
-                                   add_special_tokens=False,
-                                   max_length=max_length,
-                                   truncation=True)
-        item = tokenizer.prepare_for_model(
-            [tokenizer.bos_token_id] + query_inputs['input_ids'],
-            sep_inputs + passage_inputs['input_ids'],
-            truncation='only_second',
-            max_length=max_length,
-            padding=False,
-            return_attention_mask=False,
-            return_token_type_ids=False,
-            add_special_tokens=False
-        )
-        item['input_ids'] = item['input_ids'] + sep_inputs + prompt_inputs
-        item['attention_mask'] = [1] * len(item['input_ids'])
-        inputs.append(item)
-    return tokenizer.pad(
-            inputs,
-            padding=True,
-            max_length=max_length + len(sep_inputs) + len(prompt_inputs),
-            pad_to_multiple_of=8,
-            return_tensors='pt',
-    )
-
-tokenizer = AutoTokenizer.from_pretrained('BAAI/bge-reranker-v2-minicpm-layerwise', trust_remote_code=True)
-model = AutoModelForCausalLM.from_pretrained('BAAI/bge-reranker-v2-minicpm-layerwise', trust_remote_code=True, torch_dtype=torch.bfloat16)
-model = model.to('cuda')
-model.eval()
-
-pairs = [['what is panda?', 'hi'], ['what is panda?', 'The giant panda (Ailuropoda melanoleuca), sometimes called a panda bear or simply panda, is a bear species endemic to China.']]
-with torch.no_grad():
-    inputs = get_inputs(pairs, tokenizer).to(model.device)
-    all_scores = model(**inputs, return_dict=True, cutoff_layers=[28])
-    all_scores = [scores[:, -1].view(-1, ).float() for scores in all_scores[0]]
-    print(all_scores)
-```
-
-#### For LLM-based lightweight reranker
-
 ```python
 import torch
 from transformers import AutoModelForCausalLM, AutoTokenizer