uploading 1st place model

.gitattributes

@@ -33,3 +33,10 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+victord/sub19/models/bge-m3/tokenizer.json filter=lfs diff=lfs merge=lfs -text
+victord/sub19/models/bge-reranker-v2-m3_pseudo_tune_full/tokenizer.json filter=lfs diff=lfs merge=lfs -text
+victord/sub19/models/multilingual-e5-large_pseudo_full/tokenizer.json filter=lfs diff=lfs merge=lfs -text
+victord/sub19/models/multilingual-e5-large-instruct/tokenizer.json filter=lfs diff=lfs merge=lfs -text
+victord/sub19/models/snowflake-arctic-embed-l-v2.0/tokenizer.json filter=lfs diff=lfs merge=lfs -text
+victord/sub19/models/Solon-embeddings-large-0.1/tokenizer.json filter=lfs diff=lfs merge=lfs -text
+victord/sub19/models/Webiks_Hebrew_RAGbot_KolZchut_QA_Embedder_v1.0/tokenizer.json filter=lfs diff=lfs merge=lfs -text

victord/sub19/model.py

@@ -0,0 +1,1712 @@
+
+import os
+os.environ.setdefault("TOKENIZERS_PARALLELISM", "false")
+os.environ.setdefault("HF_HUB_OFFLINE", "1")          # never hit the Hub
+os.environ.setdefault("TRANSFORMERS_OFFLINE", "1")     # Transformers offline
+os.environ.setdefault("HF_DATASETS_OFFLINE", "1")      # Datasets offline
+os.environ.setdefault("HF_HUB_DISABLE_TELEMETRY", "1")
+os.environ.setdefault("DISABLE_TQDM", '1')
+os.environ.setdefault("TQDM_DISABLE", '1')
+os.environ["TQDM_DISABLE"] = "1"
+os.environ["DISABLE_TQDM"] = "1"
+import json
+import torch
+torch.backends.cuda.matmul.allow_tf32 = True
+torch.backends.cudnn.allow_tf32 = True
+import torch.nn.functional as F
+import numpy as np
+from transformers import AutoTokenizer, AutoModel
+from sklearn.metrics.pairwise import cosine_similarity
+import string
+from sklearn.feature_extraction import _stop_words
+
+import time
+
+import bm25s
+
+
+class BM25sRetriever:
+    def __init__(self, passages, ids):
+        self.corpus_tokens = bm25s.tokenize(passages, show_progress=False)
+        self.retriever = bm25s.BM25()
+        self.retriever.index(self.corpus_tokens, show_progress=False, leave_progress=False)
+        self.corpus_ids = ids
+        self.id2idx = {}
+        for i in range(len(self.corpus_ids)):
+            self.id2idx[self.corpus_ids[i]] = i
+            
+    def get_scores(self, query_text): 
+        query_tokens = bm25s.tokenize(query_text)
+        return self.retriever.retrieve(query_tokens, sorted=False, k=len(self.corpus_ids), show_progress=False, leave_progress=False)[1][0]
+
+
+
+
+class E5Retriever:
+    def __init__(self, model_name=None, device=None):
+        """
+        Initializes the E5 retriever using the multilingual E5 base model.
+        """
+        # Use local model
+        if model_name is None:
+            # local_model_path = os.path.join('sub/models', 'multilingual-e5-large') # 'multilingual-e5-large'
+            local_model_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'models', 'multilingual-e5-large_pseudo_full') # 'multilingual-e5-large'
+            if os.path.isdir(local_model_path):
+                model_name = local_model_path
+                print(f"Using local E5 model from: {model_name}")
+        
+        self.device = device or ("cuda" if torch.cuda.is_available() else "cpu")
+        
+        # Clear GPU cache before loading model
+        if torch.cuda.is_available():
+            torch.cuda.empty_cache()
+            
+        print(f"Loading E5 multilingual model on device: {self.device}")
+        self.tokenizer = AutoTokenizer.from_pretrained(model_name)
+        self.model = AutoModel.from_pretrained(model_name, torch_dtype=torch.bfloat16).to(self.device)
+        self.model.eval()
+
+        # Clear cache after model loading
+        if torch.cuda.is_available():
+            torch.cuda.empty_cache()
+            
+        self.corpus_ids = []
+        self.corpus_embeddings = None
+
+    def embed_texts(self, texts, is_query=False, batch_size=32): 
+        """
+        Generates embeddings for texts using E5 model with proper prefixes.
+        E5 requires specific prefixes for queries vs passages.
+        """
+        # E5 model requires specific prefixes
+        if is_query:
+            # Add query prefix for E5
+            prefixed_texts = [f"query: {text.strip()}" for text in texts]
+        else:
+            # Add passage prefix for E5
+            prefixed_texts = [f"passage: {text.strip()}" for text in texts]
+
+        all_embeddings = []
+        total_batches = (len(prefixed_texts) + batch_size - 1) // batch_size
+        
+        for i in range(0, len(prefixed_texts), batch_size):
+            batch_num = i // batch_size + 1
+            if not is_query and batch_num % 50 == 0:
+                print(f"Processing batch {batch_num}/{total_batches} ({(batch_num/total_batches)*100:.1f}%)")
+                if torch.cuda.is_available():
+                    torch.cuda.empty_cache()
+            
+            batch_texts = prefixed_texts[i:i + batch_size]
+            
+            try:
+                encoded = self.tokenizer(
+                    batch_texts, 
+                    padding=True, 
+                    truncation=True, 
+                    max_length=512,
+                    return_tensors='pt'
+                ).to(self.device)
+                
+                with torch.no_grad():
+                    model_output = self.model(**encoded)
+                    
+                    # E5 uses mean pooling with attention mask
+                    attention_mask = encoded['attention_mask']
+                    embeddings = model_output.last_hidden_state
+                    
+                    # Mean pooling
+                    mask_expanded = attention_mask.unsqueeze(-1).expand(embeddings.size()).float()
+                    sum_embeddings = torch.sum(embeddings * mask_expanded, 1)
+                    sum_mask = torch.clamp(mask_expanded.sum(1), min=1e-9)
+                    embeddings = sum_embeddings / sum_mask
+                    
+                    # L2 normalize embeddings (important for E5)
+                    embeddings = torch.nn.functional.normalize(embeddings, p=2, dim=1)
+                    
+                # Move to CPU immediately
+                all_embeddings.append(embeddings.cpu())
+                
+                # Clear GPU memory
+                del encoded, model_output, embeddings
+                if torch.cuda.is_available():
+                    torch.cuda.empty_cache()
+                    
+            except torch.cuda.OutOfMemoryError as e:
+                print(f"CUDA OOM at batch {batch_num}, reducing batch size...")
+                # Process one item at a time
+                for single_text in batch_texts:
+                    try:
+                        encoded = self.tokenizer(
+                            [single_text], 
+                            padding=True, 
+                            truncation=True, 
+                            max_length=512,
+                            return_tensors='pt'
+                        ).to(self.device)
+                        
+                        with torch.no_grad():
+                            model_output = self.model(**encoded)
+                            attention_mask = encoded['attention_mask']
+                            embeddings = model_output.last_hidden_state
+                            
+                            # Mean pooling
+                            mask_expanded = attention_mask.unsqueeze(-1).expand(embeddings.size()).float()
+                            sum_embeddings = torch.sum(embeddings * mask_expanded, 1)
+                            sum_mask = torch.clamp(mask_expanded.sum(1), min=1e-9)
+                            embeddings = sum_embeddings / sum_mask
+                            embeddings = torch.nn.functional.normalize(embeddings, p=2, dim=1)
+                            
+                        all_embeddings.append(embeddings.cpu())
+                        
+                        del encoded, model_output, embeddings
+                        if torch.cuda.is_available():
+                            torch.cuda.empty_cache()
+                            
+                    except Exception as e2:
+                        print(f"Failed to process single text: {e2}")
+                        # E5-base has 768 dimensions. Large 1024
+                        zero_embedding = torch.zeros(1, 1024).float()
+                        all_embeddings.append(zero_embedding)
+
+        return torch.cat(all_embeddings, dim=0).numpy()
+    
+    def prepare_corpus(self, texts, ids, batch_size=32): 
+
+        # Add passage prefix for E5
+        prefixed_texts = [f"passage: {text.strip()}" for text in texts]
+
+        all_embeddings = []
+        
+        all_tokens = []
+        all_ids = []
+        all_len = []
+
+        prefix_len = 3
+        suffix_len = 1
+        max_length = 512
+        max_passage = max_length - prefix_len - suffix_len
+        overlap = max_passage // 2
+
+        for i in range(len(prefixed_texts)): 
+            encoded = self.tokenizer(
+                    [prefixed_texts[i]], 
+                    padding=False, 
+                    truncation=False, 
+                    # max_length=512,
+                    # return_tensors='pt'
+                )
+            
+            if len(encoded['input_ids'][0]) > max_length:
+                _idxs = list(range(prefix_len, len(encoded['input_ids'][0])-suffix_len))
+
+                i0 = 0
+                while i0 < len(_idxs) - overlap:
+                    i1 = min(i0+max_passage, len(_idxs))
+                    all_ids.append((ids[i], (i0, i1, len(_idxs))))
+                    all_tokens.append({
+                        'input_ids': encoded['input_ids'][0][:prefix_len] + encoded['input_ids'][0][i0+prefix_len:i1+prefix_len] + encoded['input_ids'][0][-suffix_len:],
+                        'attention_mask': encoded['attention_mask'][0][:prefix_len] + encoded['attention_mask'][0][i0+prefix_len:i1+prefix_len] + encoded['attention_mask'][0][-suffix_len:]
+                    })
+                    all_len.append(i1-i0)
+                    i0 += max_passage - overlap
+            else:
+                all_ids.append((ids[i], None))
+                all_tokens.append({'input_ids': encoded['input_ids'][0], 'attention_mask': encoded['attention_mask'][0]})
+                all_len.append(len(encoded['input_ids'][0]) - prefix_len - suffix_len)
+
+
+        total_batches = (len(all_tokens) + batch_size - 1) // batch_size
+
+        all_len, all_tokens, all_ids = zip(*sorted(zip(all_len, all_tokens, all_ids), key=lambda x: x[0]))
+
+
+        for i in range(0, len(all_tokens), batch_size):
+            batch_num = i // batch_size + 1
+            if batch_num % 50 == 0:
+                print(f"Processing batch {batch_num}/{total_batches} ({(batch_num/total_batches)*100:.1f}%)")
+                if torch.cuda.is_available():
+                    torch.cuda.empty_cache()
+            
+            batch_tokens = all_tokens[i:i + batch_size]
+            
+            batch_max = max([len(ids['input_ids']) for ids in batch_tokens])
+            encoded = dict()
+            encoded["attention_mask"] = [s['attention_mask'] + (batch_max - len(s['attention_mask'])) * [0] for s in batch_tokens]
+            encoded["input_ids"] = [s['input_ids'] + (batch_max - len(s['attention_mask'])) * [0] for s in batch_tokens]
+            encoded["attention_mask"] = torch.tensor(encoded["attention_mask"], dtype=torch.long).to(self.device)
+            encoded["input_ids"] = torch.tensor(encoded["input_ids"], dtype=torch.long).to(self.device)
+
+
+
+            try:
+
+                with torch.no_grad():
+                    model_output = self.model(**encoded)
+                    
+                    # E5 uses mean pooling with attention mask
+                    attention_mask = encoded['attention_mask']
+                    embeddings = model_output.last_hidden_state
+                    
+                    # Mean pooling
+                    mask_expanded = attention_mask.unsqueeze(-1).expand(embeddings.size()).float()
+                    sum_embeddings = torch.sum(embeddings * mask_expanded, 1)
+                    sum_mask = torch.clamp(mask_expanded.sum(1), min=1e-9)
+                    embeddings = sum_embeddings / sum_mask
+                    
+                    # L2 normalize embeddings (important for E5)
+                    embeddings = torch.nn.functional.normalize(embeddings, p=2, dim=1)
+                    
+                # Move to CPU immediately
+                all_embeddings.append(embeddings.cpu())
+                
+                # Clear GPU memory
+                del encoded, model_output, embeddings
+                if torch.cuda.is_available():
+                    torch.cuda.empty_cache()
+                    
+            except torch.cuda.OutOfMemoryError as e:
+                print(f"CUDA OOM at batch {batch_num}, reducing batch size...")
+                # Process one item at a time
+                for j in range(len(encoded)):
+                    try:
+
+                        encoded0 = encoded[j:j+1]
+
+                        with torch.no_grad():
+                            model_output = self.model(**encoded0)
+                            attention_mask = encoded0['attention_mask']
+                            embeddings = model_output.last_hidden_state
+                            
+                            # Mean pooling
+                            mask_expanded = attention_mask.unsqueeze(-1).expand(embeddings.size()).float()
+                            sum_embeddings = torch.sum(embeddings * mask_expanded, 1)
+                            sum_mask = torch.clamp(mask_expanded.sum(1), min=1e-9)
+                            embeddings = sum_embeddings / sum_mask
+                            embeddings = torch.nn.functional.normalize(embeddings, p=2, dim=1)
+                            
+                        all_embeddings.append(embeddings.cpu())
+                        
+                        del encoded0, model_output, embeddings
+                        if torch.cuda.is_available():
+                            torch.cuda.empty_cache()
+                            
+                    except Exception as e2:
+                        print(f"Failed to process single text: {e2}")
+                        # E5-base has 768 dimensions. Large 1024
+                        zero_embedding = torch.zeros(1, 1024).float()
+                        all_embeddings.append(zero_embedding)
+
+        id2idx = {}
+        for i in range(len(all_ids)):
+            if all_ids[i][0] not in id2idx:
+                id2idx[all_ids[i][0]] = []
+            id2idx[all_ids[i][0]].append(i)
+
+        return torch.cat(all_embeddings, dim=0).to(self.model.device), all_ids, id2idx # numpy()
+
+
+
+class E5InstructRetriever:
+    def __init__(self, model_name=None, device=None):
+        """
+        Initializes the E5 Instruct retriever using the multilingual E5 Instruct large model.
+        """
+        # Use local model
+        if model_name is None:
+            # local_model_path = os.path.join('sub/models', 'multilingual-e5-large-instruct')
+            local_model_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'models', 'multilingual-e5-large-instruct') 
+            if os.path.isdir(local_model_path):
+                model_name = local_model_path
+                print(f"Using local E5 Instruct model from: {model_name}")
+        
+        self.device = device or ("cuda" if torch.cuda.is_available() else "cpu")
+        
+        # Clear GPU cache before loading model
+        if torch.cuda.is_available():
+            torch.cuda.empty_cache()
+            
+        print(f"Loading E5 Instruct multilingual model on device: {self.device}")
+        self.tokenizer = AutoTokenizer.from_pretrained(model_name)
+        self.model = AutoModel.from_pretrained(model_name, torch_dtype=torch.bfloat16).to(self.device) # torch.float16
+        self.model.eval()
+
+        # Clear cache after model loading
+        if torch.cuda.is_available():
+            torch.cuda.empty_cache()
+            
+        self.corpus_ids = []
+        self.corpus_embeddings = None
+
+    def embed_texts(self, texts, is_query=False, batch_size=32): 
+        """
+        Generates embeddings for texts using E5 Instruct model with proper prefixes.
+        E5 Instruct requires specific prefixes for queries vs passages.
+        """
+        task = 'Given a web search query, retrieve relevant passages that answer the query'
+        # E5 model requires specific prefixes
+        if is_query:
+            # Add query prefix for E5
+            prefixed_texts = [f"Instruct: {task}\nQuery: {text.strip()}" for text in texts]
+        else:
+            # Add passage prefix for E5
+            prefixed_texts = [f"{text.strip()}" for text in texts]
+
+        all_embeddings = []
+        total_batches = (len(prefixed_texts) + batch_size - 1) // batch_size
+        
+        for i in range(0, len(prefixed_texts), batch_size):
+            batch_num = i // batch_size + 1
+            if not is_query and batch_num % 50 == 0:
+                print(f"Processing batch {batch_num}/{total_batches} ({(batch_num/total_batches)*100:.1f}%)")
+                if torch.cuda.is_available():
+                    torch.cuda.empty_cache()
+            
+            batch_texts = prefixed_texts[i:i + batch_size]
+            
+            try:
+                encoded = self.tokenizer(
+                    batch_texts, 
+                    padding=True, 
+                    truncation=True, 
+                    max_length=512,
+                    return_tensors='pt'
+                ).to(self.device)
+                
+                with torch.no_grad():
+                    model_output = self.model(**encoded)
+                    
+                    # E5 uses mean pooling with attention mask
+                    attention_mask = encoded['attention_mask']
+                    embeddings = model_output.last_hidden_state
+                    
+                    # Mean pooling
+                    mask_expanded = attention_mask.unsqueeze(-1).expand(embeddings.size()).float()
+                    sum_embeddings = torch.sum(embeddings * mask_expanded, 1)
+                    sum_mask = torch.clamp(mask_expanded.sum(1), min=1e-9)
+                    embeddings = sum_embeddings / sum_mask
+                    
+                    # L2 normalize embeddings (important for E5)
+                    embeddings = torch.nn.functional.normalize(embeddings, p=2, dim=1)
+                    
+                # Move to CPU immediately
+                all_embeddings.append(embeddings.cpu())
+                
+                # Clear GPU memory
+                del encoded, model_output, embeddings
+                if torch.cuda.is_available():
+                    torch.cuda.empty_cache()
+                    
+            except torch.cuda.OutOfMemoryError as e:
+                print(f"CUDA OOM at batch {batch_num}, reducing batch size...")
+                # Process one item at a time
+                for single_text in batch_texts:
+                    try:
+                        encoded = self.tokenizer(
+                            [single_text], 
+                            padding=True, 
+                            truncation=True, 
+                            max_length=512,
+                            return_tensors='pt'
+                        ).to(self.device)
+                        
+                        with torch.no_grad():
+                            model_output = self.model(**encoded)
+                            attention_mask = encoded['attention_mask']
+                            embeddings = model_output.last_hidden_state
+                            
+                            # Mean pooling
+                            mask_expanded = attention_mask.unsqueeze(-1).expand(embeddings.size()).float()
+                            sum_embeddings = torch.sum(embeddings * mask_expanded, 1)
+                            sum_mask = torch.clamp(mask_expanded.sum(1), min=1e-9)
+                            embeddings = sum_embeddings / sum_mask
+                            embeddings = torch.nn.functional.normalize(embeddings, p=2, dim=1)
+                            
+                        all_embeddings.append(embeddings.cpu())
+                        
+                        del encoded, model_output, embeddings
+                        if torch.cuda.is_available():
+                            torch.cuda.empty_cache()
+                            
+                    except Exception as e2:
+                        print(f"Failed to process single text: {e2}")
+                        # E5-base has 768 dimensions. Large 1024
+                        zero_embedding = torch.zeros(1, 1024).float()
+                        all_embeddings.append(zero_embedding)
+
+        return torch.cat(all_embeddings, dim=0).numpy()
+    
+    def prepare_corpus(self, texts, ids, batch_size=32): 
+
+        # Add passage prefix for E5
+        prefixed_texts = [f"{text.strip()}" for text in texts]
+
+        all_embeddings = []
+        
+        all_tokens = []
+        all_ids = []
+        all_len = []
+
+        prefix_len = 1
+        suffix_len = 1
+        max_length = 512
+        max_passage = max_length - prefix_len - suffix_len
+        overlap = max_passage // 2
+
+        for i in range(len(prefixed_texts)): # tqdm(
+            encoded = self.tokenizer(
+                    [prefixed_texts[i]], 
+                    padding=False, 
+                    truncation=False, 
+                    # max_length=512,
+                    # return_tensors='pt'
+                )
+            
+            if len(encoded['input_ids'][0]) > max_length:
+                _idxs = list(range(prefix_len, len(encoded['input_ids'][0])-suffix_len))
+
+                i0 = 0
+                while i0 < len(_idxs) - overlap:
+                    i1 = min(i0+max_passage, len(_idxs))
+                    all_ids.append((ids[i], (i0, i1, len(_idxs))))
+                    all_tokens.append({
+                        'input_ids': encoded['input_ids'][0][:prefix_len] + encoded['input_ids'][0][i0+prefix_len:i1+prefix_len] + encoded['input_ids'][0][-suffix_len:],
+                        'attention_mask': encoded['attention_mask'][0][:prefix_len] + encoded['attention_mask'][0][i0+prefix_len:i1+prefix_len] + encoded['attention_mask'][0][-suffix_len:]
+                    })
+                    all_len.append(i1-i0)
+                    i0 += max_passage - overlap
+            else:
+                all_ids.append((ids[i], None))
+                all_tokens.append({'input_ids': encoded['input_ids'][0], 'attention_mask': encoded['attention_mask'][0]})
+                all_len.append(len(encoded['input_ids'][0]) - prefix_len - suffix_len)
+
+
+        total_batches = (len(all_tokens) + batch_size - 1) // batch_size
+
+        all_len, all_tokens, all_ids = zip(*sorted(zip(all_len, all_tokens, all_ids), key=lambda x: x[0]))
+
+
+        for i in range(0, len(all_tokens), batch_size):
+            batch_num = i // batch_size + 1
+            if batch_num % 50 == 0:
+                print(f"Processing batch {batch_num}/{total_batches} ({(batch_num/total_batches)*100:.1f}%)")
+                if torch.cuda.is_available():
+                    torch.cuda.empty_cache()
+            
+            batch_tokens = all_tokens[i:i + batch_size]
+            
+            batch_max = max([len(ids['input_ids']) for ids in batch_tokens])
+            encoded = dict()
+            encoded["attention_mask"] = [s['attention_mask'] + (batch_max - len(s['attention_mask'])) * [0] for s in batch_tokens]
+            encoded["input_ids"] = [s['input_ids'] + (batch_max - len(s['attention_mask'])) * [0] for s in batch_tokens]
+            encoded["attention_mask"] = torch.tensor(encoded["attention_mask"], dtype=torch.long).to(self.device)
+            encoded["input_ids"] = torch.tensor(encoded["input_ids"], dtype=torch.long).to(self.device)
+
+
+
+            try:
+
+                with torch.no_grad():
+                    model_output = self.model(**encoded)
+                    
+                    # E5 uses mean pooling with attention mask
+                    attention_mask = encoded['attention_mask']
+                    embeddings = model_output.last_hidden_state
+                    
+                    # Mean pooling
+                    mask_expanded = attention_mask.unsqueeze(-1).expand(embeddings.size()).float()
+                    sum_embeddings = torch.sum(embeddings * mask_expanded, 1)
+                    sum_mask = torch.clamp(mask_expanded.sum(1), min=1e-9)
+                    embeddings = sum_embeddings / sum_mask
+                    
+                    # L2 normalize embeddings (important for E5)
+                    embeddings = torch.nn.functional.normalize(embeddings, p=2, dim=1)
+                    
+                # Move to CPU immediately
+                all_embeddings.append(embeddings.cpu())
+                
+                # Clear GPU memory
+                del encoded, model_output, embeddings
+                if torch.cuda.is_available():
+                    torch.cuda.empty_cache()
+                    
+            except torch.cuda.OutOfMemoryError as e:
+                print(f"CUDA OOM at batch {batch_num}, reducing batch size...")
+                # Process one item at a time
+                for j in range(len(encoded)):
+                    try:
+
+                        encoded0 = encoded[j:j+1]
+
+                        with torch.no_grad():
+                            model_output = self.model(**encoded0)
+                            attention_mask = encoded0['attention_mask']
+                            embeddings = model_output.last_hidden_state
+                            
+                            # Mean pooling
+                            mask_expanded = attention_mask.unsqueeze(-1).expand(embeddings.size()).float()
+                            sum_embeddings = torch.sum(embeddings * mask_expanded, 1)
+                            sum_mask = torch.clamp(mask_expanded.sum(1), min=1e-9)
+                            embeddings = sum_embeddings / sum_mask
+                            embeddings = torch.nn.functional.normalize(embeddings, p=2, dim=1)
+                            
+                        all_embeddings.append(embeddings.cpu())
+                        
+                        del encoded0, model_output, embeddings
+                        if torch.cuda.is_available():
+                            torch.cuda.empty_cache()
+                            
+                    except Exception as e2:
+                        print(f"Failed to process single text: {e2}")
+                        # E5-base has 768 dimensions. Large 1024
+                        zero_embedding = torch.zeros(1, 1024).float()
+                        all_embeddings.append(zero_embedding)
+
+        id2idx = {}
+        for i in range(len(all_ids)):
+            if all_ids[i][0] not in id2idx:
+                id2idx[all_ids[i][0]] = []
+            id2idx[all_ids[i][0]].append(i)
+
+        return torch.cat(all_embeddings, dim=0).to(self.model.device), all_ids, id2idx # numpy()
+
+
+
+
+class SnowflakeInstructRetriever:
+    def __init__(self, model_name=None, device=None):
+        """
+        Initializes the retriever using the multilingual snowflake-arctic-embed-l-v2.0 model.
+        """
+        # Use local model
+        if model_name is None:
+            # local_model_path = os.path.join('sub/models', 'snowflake-arctic-embed-l-v2.0')
+            local_model_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'models', 'snowflake-arctic-embed-l-v2.0') 
+            if os.path.isdir(local_model_path):
+                model_name = local_model_path
+                print(f"Using local snowflake-arctic-embed-l-v2.0 model from: {model_name}")
+        
+        self.device = device or ("cuda" if torch.cuda.is_available() else "cpu")
+        
+        # Clear GPU cache before loading model
+        if torch.cuda.is_available():
+            torch.cuda.empty_cache()
+            
+        print(f"Loading snowflake-arctic-embed-l-v2.0 multilingual model on device: {self.device}")
+        self.tokenizer = AutoTokenizer.from_pretrained(model_name)
+        self.model = AutoModel.from_pretrained(model_name, torch_dtype=torch.bfloat16).to(self.device) 
+        self.model.eval()
+        
+        # Clear cache after model loading
+        if torch.cuda.is_available():
+            torch.cuda.empty_cache()
+            
+        self.corpus_ids = []
+        self.corpus_embeddings = None
+
+    def embed_texts(self, texts, is_query=False, batch_size=32): 
+        """
+        Generates embeddings for texts using snowflake-arctic-embed-l-v2.0 model with proper prefixes.
+        snowflake-arctic-embed-l-v2.0 requires specific prefixes for queries vs passages.
+        """
+
+        # E5 model requires specific prefixes
+        if is_query:
+            # Add query prefix for E5
+            prefixed_texts = [f"query: {text.strip()}" for text in texts]
+        else:
+            # Add passage prefix for E5
+            prefixed_texts = [f"{text.strip()}" for text in texts]
+
+        all_embeddings = []
+        total_batches = (len(prefixed_texts) + batch_size - 1) // batch_size
+        
+        for i in range(0, len(prefixed_texts), batch_size):
+            batch_num = i // batch_size + 1
+            if not is_query and batch_num % 50 == 0:
+                print(f"Processing batch {batch_num}/{total_batches} ({(batch_num/total_batches)*100:.1f}%)")
+                if torch.cuda.is_available():
+                    torch.cuda.empty_cache()
+            
+            batch_texts = prefixed_texts[i:i + batch_size]
+            
+            try:
+                encoded = self.tokenizer(
+                    batch_texts, 
+                    padding=True, 
+                    truncation=True, 
+                    max_length=1024, # 512
+                    return_tensors='pt'
+                ).to(self.device)
+                
+                with torch.no_grad():
+                    model_output = self.model(**encoded)
+                    
+                    embeddings = model_output[0][:, 0].float()
+                    # L2 normalize embeddings
+                    embeddings = torch.nn.functional.normalize(embeddings, p=2, dim=1)
+                    
+                # Move to CPU immediately
+                all_embeddings.append(embeddings.cpu())
+                
+                # Clear GPU memory
+                del encoded, model_output, embeddings
+                if torch.cuda.is_available():
+                    torch.cuda.empty_cache()
+                    
+            except torch.cuda.OutOfMemoryError as e:
+                print(f"CUDA OOM at batch {batch_num}, reducing batch size...")
+                # Process one item at a time
+                for single_text in batch_texts:
+                    try:
+                        encoded = self.tokenizer(
+                            [single_text], 
+                            padding=True, 
+                            truncation=True, 
+                            max_length=512,
+                            return_tensors='pt'
+                        ).to(self.device)
+                        
+                        with torch.no_grad():
+                            model_output = self.model(**encoded)
+
+                            embeddings = model_output[0][:, 0].float()
+                            embeddings = torch.nn.functional.normalize(embeddings, p=2, dim=1)
+                            
+                        all_embeddings.append(embeddings.cpu())
+                        
+                        del encoded, model_output, embeddings
+                        if torch.cuda.is_available():
+                            torch.cuda.empty_cache()
+                            
+                    except Exception as e2:
+                        print(f"Failed to process single text: {e2}")
+
+                        zero_embedding = torch.zeros(1, 1024).float()
+                        all_embeddings.append(zero_embedding)
+
+        return torch.cat(all_embeddings, dim=0).numpy()
+    
+    def prepare_corpus(self, texts, ids, batch_size=32): 
+        prefixed_texts = [f"{text.strip()}" for text in texts]
+
+        all_embeddings = []
+        
+        all_tokens = []
+        all_ids = []
+        all_len = []
+
+        prefix_len = 1
+        suffix_len = 1
+        max_length = 1024 # 512
+        max_passage = max_length - prefix_len - suffix_len
+        overlap = max_passage // 2
+
+        for i in range(len(prefixed_texts)): 
+            encoded = self.tokenizer(
+                    [prefixed_texts[i]], 
+                    padding=False, 
+                    truncation=False, 
+                    # max_length=512,
+                    # return_tensors='pt'
+                )
+            
+            if len(encoded['input_ids'][0]) > max_length:
+                _idxs = list(range(prefix_len, len(encoded['input_ids'][0])-suffix_len))
+
+                i0 = 0
+                while i0 < len(_idxs) - overlap:
+                    i1 = min(i0+max_passage, len(_idxs))
+                    all_ids.append((ids[i], (i0, i1, len(_idxs))))
+                    all_tokens.append({
+                        'input_ids': encoded['input_ids'][0][:prefix_len] + encoded['input_ids'][0][i0+prefix_len:i1+prefix_len] + encoded['input_ids'][0][-suffix_len:],
+                        'attention_mask': encoded['attention_mask'][0][:prefix_len] + encoded['attention_mask'][0][i0+prefix_len:i1+prefix_len] + encoded['attention_mask'][0][-suffix_len:]
+                    })
+                    all_len.append(i1-i0)
+                    i0 += max_passage - overlap
+            else:
+                all_ids.append((ids[i], None))
+                all_tokens.append({'input_ids': encoded['input_ids'][0], 'attention_mask': encoded['attention_mask'][0]})
+                all_len.append(len(encoded['input_ids'][0]) - prefix_len - suffix_len)
+
+
+        total_batches = (len(all_tokens) + batch_size - 1) // batch_size
+
+        all_len, all_tokens, all_ids = zip(*sorted(zip(all_len, all_tokens, all_ids), key=lambda x: x[0]))
+
+
+        for i in range(0, len(all_tokens), batch_size):
+            batch_num = i // batch_size + 1
+            if batch_num % 50 == 0:
+                print(f"Processing batch {batch_num}/{total_batches} ({(batch_num/total_batches)*100:.1f}%)")
+                if torch.cuda.is_available():
+                    torch.cuda.empty_cache()
+            
+            batch_tokens = all_tokens[i:i + batch_size]
+            
+            batch_max = max([len(ids['input_ids']) for ids in batch_tokens])
+            encoded = dict()
+            encoded["attention_mask"] = [s['attention_mask'] + (batch_max - len(s['attention_mask'])) * [0] for s in batch_tokens]
+            encoded["input_ids"] = [s['input_ids'] + (batch_max - len(s['attention_mask'])) * [0] for s in batch_tokens]
+            encoded["attention_mask"] = torch.tensor(encoded["attention_mask"], dtype=torch.long).to(self.device)
+            encoded["input_ids"] = torch.tensor(encoded["input_ids"], dtype=torch.long).to(self.device)
+
+
+
+            try:
+
+                with torch.no_grad():
+                    model_output = self.model(**encoded)
+                    
+                    embeddings = model_output[0][:, 0].float()
+                    # L2 normalize embeddings
+                    embeddings = torch.nn.functional.normalize(embeddings, p=2, dim=1)
+                    
+                # Move to CPU immediately
+                all_embeddings.append(embeddings.cpu())
+                
+                # Clear GPU memory
+                del encoded, model_output, embeddings
+                if torch.cuda.is_available():
+                    torch.cuda.empty_cache()
+                    
+            except torch.cuda.OutOfMemoryError as e:
+                print(f"CUDA OOM at batch {batch_num}, reducing batch size...")
+                # Process one item at a time
+                for j in range(len(encoded)):
+                    try:
+
+                        encoded0 = encoded[j:j+1]
+
+                        with torch.no_grad():
+                            model_output = self.model(**encoded0)
+
+                            embeddings = model_output[0][:, 0].float()
+                            embeddings = torch.nn.functional.normalize(embeddings, p=2, dim=1)
+                            
+                        all_embeddings.append(embeddings.cpu())
+                        
+                        del encoded0, model_output, embeddings
+                        if torch.cuda.is_available():
+                            torch.cuda.empty_cache()
+                            
+                    except Exception as e2:
+                        print(f"Failed to process single text: {e2}")
+                        zero_embedding = torch.zeros(1, 1024).float()
+                        all_embeddings.append(zero_embedding)
+
+        id2idx = {}
+        for i in range(len(all_ids)):
+            if all_ids[i][0] not in id2idx:
+                id2idx[all_ids[i][0]] = []
+            id2idx[all_ids[i][0]].append(i)
+
+        return torch.cat(all_embeddings, dim=0).to(self.model.device), all_ids, id2idx # numpy()
+
+
+
+class SolonRetriever:
+    def __init__(self, model_name=None, device=None):
+        """
+        Initializes the retriever using the multilingual Solon-embeddings-large-0.1 model.
+        """
+        # Use local model
+        if model_name is None:
+            # local_model_path = os.path.join('sub/models', 'Solon-embeddings-large-0.1')
+            local_model_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'models', 'Solon-embeddings-large-0.1') 
+            if os.path.isdir(local_model_path):
+                model_name = local_model_path
+                print(f"Using local Solon-embeddings-large-0.1 model from: {model_name}")
+        
+        self.device = device or ("cuda" if torch.cuda.is_available() else "cpu")
+        
+        # Clear GPU cache before loading model
+        if torch.cuda.is_available():
+            torch.cuda.empty_cache()
+            
+        print(f"Loading Solon-embeddings-large-0.1 multilingual model on device: {self.device}")
+        self.tokenizer = AutoTokenizer.from_pretrained(model_name)
+        self.model = AutoModel.from_pretrained(model_name, torch_dtype=torch.bfloat16).to(self.device) # torch.float16
+        self.model.eval()
+        
+        # Clear cache after model loading
+        if torch.cuda.is_available():
+            torch.cuda.empty_cache()
+            
+        self.corpus_ids = []
+        self.corpus_embeddings = None
+
+    def embed_texts(self, texts, is_query=False, batch_size=32): 
+        """
+        Generates embeddings for texts using Solon-embeddings-large-0.1 model with proper prefixes.
+        Solon-embeddings-large-0.1 requires specific prefixes for queries vs passages.
+        """
+
+        # E5 model requires specific prefixes
+        if is_query:
+            # Add query prefix
+            prefixed_texts = [f"query : {text.strip()}" for text in texts]
+        else:
+            prefixed_texts = [f"{text.strip()}" for text in texts]
+
+        all_embeddings = []
+        total_batches = (len(prefixed_texts) + batch_size - 1) // batch_size
+        
+        for i in range(0, len(prefixed_texts), batch_size):
+            batch_num = i // batch_size + 1
+            if not is_query and batch_num % 50 == 0:
+                print(f"Processing batch {batch_num}/{total_batches} ({(batch_num/total_batches)*100:.1f}%)")
+                if torch.cuda.is_available():
+                    torch.cuda.empty_cache()
+            
+            batch_texts = prefixed_texts[i:i + batch_size]
+            
+            try:
+                encoded = self.tokenizer(
+                    batch_texts, 
+                    padding=True, 
+                    truncation=True, 
+                    max_length=512, # 512
+                    return_tensors='pt'
+                ).to(self.device)
+                
+                with torch.no_grad():
+                    model_output = self.model(**encoded)
+                    
+                    # E5 uses mean pooling with attention mask
+                    attention_mask = encoded['attention_mask']
+                    embeddings = model_output.last_hidden_state
+                    
+                    # Mean pooling
+                    mask_expanded = attention_mask.unsqueeze(-1).expand(embeddings.size()).float()
+                    sum_embeddings = torch.sum(embeddings * mask_expanded, 1)
+                    sum_mask = torch.clamp(mask_expanded.sum(1), min=1e-9)
+                    embeddings = sum_embeddings / sum_mask
+                    
+                    # embeddings = model_output[0][:, 0].float()
+                    # L2 normalize embeddings (important for E5)
+                    embeddings = torch.nn.functional.normalize(embeddings, p=2, dim=1)
+                    
+                # Move to CPU immediately
+                all_embeddings.append(embeddings.cpu())
+                
+                # Clear GPU memory
+                del encoded, model_output, embeddings
+                if torch.cuda.is_available():
+                    torch.cuda.empty_cache()
+                    
+            except torch.cuda.OutOfMemoryError as e:
+                print(f"CUDA OOM at batch {batch_num}, reducing batch size...")
+                # Process one item at a time
+                for single_text in batch_texts:
+                    try:
+                        encoded = self.tokenizer(
+                            [single_text], 
+                            padding=True, 
+                            truncation=True, 
+                            max_length=512,
+                            return_tensors='pt'
+                        ).to(self.device)
+                        
+                        with torch.no_grad():
+                            model_output = self.model(**encoded)
+                            attention_mask = encoded['attention_mask']
+                            embeddings = model_output.last_hidden_state
+                            
+                            # Mean pooling
+                            mask_expanded = attention_mask.unsqueeze(-1).expand(embeddings.size()).float()
+                            sum_embeddings = torch.sum(embeddings * mask_expanded, 1)
+                            sum_mask = torch.clamp(mask_expanded.sum(1), min=1e-9)
+                            embeddings = sum_embeddings / sum_mask
+
+                            # embeddings = model_output[0][:, 0].float()
+                            embeddings = torch.nn.functional.normalize(embeddings, p=2, dim=1)
+                            
+                        all_embeddings.append(embeddings.cpu())
+                        
+                        del encoded, model_output, embeddings
+                        if torch.cuda.is_available():
+                            torch.cuda.empty_cache()
+                            
+                    except Exception as e2:
+                        print(f"Failed to process single text: {e2}")
+
+                        zero_embedding = torch.zeros(1, 1024).float()
+                        all_embeddings.append(zero_embedding)
+
+        return torch.cat(all_embeddings, dim=0).numpy()
+    
+    def prepare_corpus(self, texts, ids, batch_size=32): 
+        prefixed_texts = [f"{text.strip()}" for text in texts]
+
+        all_embeddings = []
+        
+        all_tokens = []
+        all_ids = []
+        all_len = []
+
+        prefix_len = 1
+        suffix_len = 1
+        max_length = 512 # 1024 # 512
+        max_passage = max_length - prefix_len - suffix_len
+        overlap = max_passage // 2
+
+        for i in range(len(prefixed_texts)): # tqdm(
+            encoded = self.tokenizer(
+                    [prefixed_texts[i]], 
+                    padding=False, 
+                    truncation=False, 
+                    # max_length=512,
+                    # return_tensors='pt'
+                )
+            
+            if len(encoded['input_ids'][0]) > max_length:
+                _idxs = list(range(prefix_len, len(encoded['input_ids'][0])-suffix_len))
+
+                i0 = 0
+                while i0 < len(_idxs) - overlap:
+                    i1 = min(i0+max_passage, len(_idxs))
+                    all_ids.append((ids[i], (i0, i1, len(_idxs))))
+                    all_tokens.append({
+                        'input_ids': encoded['input_ids'][0][:prefix_len] + encoded['input_ids'][0][i0+prefix_len:i1+prefix_len] + encoded['input_ids'][0][-suffix_len:],
+                        'attention_mask': encoded['attention_mask'][0][:prefix_len] + encoded['attention_mask'][0][i0+prefix_len:i1+prefix_len] + encoded['attention_mask'][0][-suffix_len:]
+                    })
+                    all_len.append(i1-i0)
+                    i0 += max_passage - overlap
+            else:
+                all_ids.append((ids[i], None))
+                all_tokens.append({'input_ids': encoded['input_ids'][0], 'attention_mask': encoded['attention_mask'][0]})
+                all_len.append(len(encoded['input_ids'][0]) - prefix_len - suffix_len)
+
+
+        total_batches = (len(all_tokens) + batch_size - 1) // batch_size
+
+        all_len, all_tokens, all_ids = zip(*sorted(zip(all_len, all_tokens, all_ids), key=lambda x: x[0]))
+
+
+        for i in range(0, len(all_tokens), batch_size):
+            batch_num = i // batch_size + 1
+            if batch_num % 50 == 0:
+                print(f"Processing batch {batch_num}/{total_batches} ({(batch_num/total_batches)*100:.1f}%)")
+                if torch.cuda.is_available():
+                    torch.cuda.empty_cache()
+            
+            batch_tokens = all_tokens[i:i + batch_size]
+            
+            batch_max = max([len(ids['input_ids']) for ids in batch_tokens])
+            encoded = dict()
+            encoded["attention_mask"] = [s['attention_mask'] + (batch_max - len(s['attention_mask'])) * [0] for s in batch_tokens]
+            encoded["input_ids"] = [s['input_ids'] + (batch_max - len(s['attention_mask'])) * [0] for s in batch_tokens]
+            encoded["attention_mask"] = torch.tensor(encoded["attention_mask"], dtype=torch.long).to(self.device)
+            encoded["input_ids"] = torch.tensor(encoded["input_ids"], dtype=torch.long).to(self.device)
+
+
+
+            try:
+
+                with torch.no_grad():
+                    model_output = self.model(**encoded)
+                    
+                    # E5 uses mean pooling with attention mask
+                    attention_mask = encoded['attention_mask']
+                    embeddings = model_output.last_hidden_state
+                    
+                    # Mean pooling
+                    mask_expanded = attention_mask.unsqueeze(-1).expand(embeddings.size()).float()
+                    sum_embeddings = torch.sum(embeddings * mask_expanded, 1)
+                    sum_mask = torch.clamp(mask_expanded.sum(1), min=1e-9)
+                    embeddings = sum_embeddings / sum_mask
+                    
+                    # L2 normalize embeddings
+                    embeddings = torch.nn.functional.normalize(embeddings, p=2, dim=1)
+                    
+                # Move to CPU immediately
+                all_embeddings.append(embeddings.cpu())
+                
+                # Clear GPU memory
+                del encoded, model_output, embeddings
+                if torch.cuda.is_available():
+                    torch.cuda.empty_cache()
+                    
+            except torch.cuda.OutOfMemoryError as e:
+                print(f"CUDA OOM at batch {batch_num}, reducing batch size...")
+                # Process one item at a time
+                for j in range(len(encoded)):
+                    try:
+
+                        encoded0 = encoded[j:j+1]
+
+                        with torch.no_grad():
+                            model_output = self.model(**encoded0)
+                            attention_mask = encoded0['attention_mask']
+                            embeddings = model_output.last_hidden_state
+                            
+                            # Mean pooling
+                            mask_expanded = attention_mask.unsqueeze(-1).expand(embeddings.size()).float()
+                            sum_embeddings = torch.sum(embeddings * mask_expanded, 1)
+                            sum_mask = torch.clamp(mask_expanded.sum(1), min=1e-9)
+                            embeddings = sum_embeddings / sum_mask
+
+                            embeddings = torch.nn.functional.normalize(embeddings, p=2, dim=1)
+                            
+                        all_embeddings.append(embeddings.cpu())
+                        
+                        del encoded0, model_output, embeddings
+                        if torch.cuda.is_available():
+                            torch.cuda.empty_cache()
+                            
+                    except Exception as e2:
+                        print(f"Failed to process single text: {e2}")
+                        zero_embedding = torch.zeros(1, 1024).float()
+                        all_embeddings.append(zero_embedding)
+
+        id2idx = {}
+        for i in range(len(all_ids)):
+            if all_ids[i][0] not in id2idx:
+                id2idx[all_ids[i][0]] = []
+            id2idx[all_ids[i][0]].append(i)
+
+        return torch.cat(all_embeddings, dim=0).to(self.model.device), all_ids, id2idx # numpy()
+
+
+class M3Retriever:
+    def __init__(self, model_name=None, device=None):
+        """
+        Initializes the bge-m3 retriever using the multilingual bge-m3 model.
+        """
+        # Use local model
+        if model_name is None:
+            # local_model_path = os.path.join('sub/models', 'bge-m3')
+            local_model_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'models', 'bge-m3') 
+            if os.path.isdir(local_model_path):
+                model_name = local_model_path
+                print(f"Using local bge-m3 model from: {model_name}")
+        
+        self.device = device or ("cuda" if torch.cuda.is_available() else "cpu")
+        
+        # Clear GPU cache before loading model
+        if torch.cuda.is_available():
+            torch.cuda.empty_cache()
+            
+        print(f"Loading bge-m3 multilingual model on device: {self.device}")
+        self.tokenizer = AutoTokenizer.from_pretrained(model_name)
+        self.model = AutoModel.from_pretrained(model_name, torch_dtype=torch.bfloat16).to(self.device) # torch.float16
+        self.model.eval()
+
+        # Clear cache after model loading
+        if torch.cuda.is_available():
+            torch.cuda.empty_cache()
+            
+        self.corpus_ids = []
+        self.corpus_embeddings = None
+
+    def embed_texts(self, texts, is_query=False, batch_size=32): 
+        """
+        Generates embeddings for texts using E5 Instruct model with proper prefixes.
+        bge-m3 requires specific prefixes for queries vs passages.
+        """
+
+        prefixed_texts = [f"{text.strip()}" for text in texts]
+
+        all_embeddings = []
+        total_batches = (len(prefixed_texts) + batch_size - 1) // batch_size
+        
+        for i in range(0, len(prefixed_texts), batch_size):
+            batch_num = i // batch_size + 1
+            if not is_query and batch_num % 50 == 0:
+                print(f"Processing batch {batch_num}/{total_batches} ({(batch_num/total_batches)*100:.1f}%)")
+                if torch.cuda.is_available():
+                    torch.cuda.empty_cache()
+            
+            batch_texts = prefixed_texts[i:i + batch_size]
+            
+            try:
+                encoded = self.tokenizer(
+                    batch_texts, 
+                    padding=True, 
+                    truncation=True, 
+                    max_length=512,
+                    return_tensors='pt'
+                ).to(self.device)
+                
+                with torch.no_grad():
+                    model_output = self.model(**encoded)
+                    
+                    embeddings = model_output[0][:, 0].float()
+
+                    # L2 normalize embeddings 
+                    embeddings = torch.nn.functional.normalize(embeddings, p=2, dim=1)
+                    
+                # Move to CPU immediately
+                all_embeddings.append(embeddings.cpu())
+                
+                # Clear GPU memory
+                del encoded, model_output, embeddings
+                if torch.cuda.is_available():
+                    torch.cuda.empty_cache()
+                    
+            except torch.cuda.OutOfMemoryError as e:
+                print(f"CUDA OOM at batch {batch_num}, reducing batch size...")
+                # Process one item at a time
+                for single_text in batch_texts:
+                    try:
+                        encoded = self.tokenizer(
+                            [single_text], 
+                            padding=True, 
+                            truncation=True, 
+                            max_length=512,
+                            return_tensors='pt'
+                        ).to(self.device)
+                        
+                        with torch.no_grad():
+                            model_output = self.model(**encoded)
+
+                            embeddings = model_output[0][:, 0].float()
+                            embeddings = torch.nn.functional.normalize(embeddings, p=2, dim=1)
+                            
+                        all_embeddings.append(embeddings.cpu())
+                        
+                        del encoded, model_output, embeddings
+                        if torch.cuda.is_available():
+                            torch.cuda.empty_cache()
+                            
+                    except Exception as e2:
+                        print(f"Failed to process single text: {e2}")
+                        zero_embedding = torch.zeros(1, 1024).float()
+                        all_embeddings.append(zero_embedding)
+
+        return torch.cat(all_embeddings, dim=0).numpy()
+    
+    def prepare_corpus(self, texts, ids, batch_size=32): 
+        prefixed_texts = [f"{text.strip()}" for text in texts]
+
+        all_embeddings = []
+        
+        all_tokens = []
+        all_ids = []
+        all_len = []
+
+        prefix_len = 1
+        suffix_len = 1
+        max_length = 512
+        max_passage = max_length - prefix_len - suffix_len
+        overlap = max_passage // 2
+
+        for i in range(len(prefixed_texts)): # tqdm(
+            encoded = self.tokenizer(
+                    [prefixed_texts[i]], 
+                    padding=False, 
+                    truncation=False, 
+                    # max_length=512,
+                    # return_tensors='pt'
+                )
+            
+            if len(encoded['input_ids'][0]) > max_length:
+                _idxs = list(range(prefix_len, len(encoded['input_ids'][0])-suffix_len))
+
+                i0 = 0
+                while i0 < len(_idxs) - overlap:
+                    i1 = min(i0+max_passage, len(_idxs))
+                    all_ids.append((ids[i], (i0, i1, len(_idxs))))
+                    all_tokens.append({
+                        'input_ids': encoded['input_ids'][0][:prefix_len] + encoded['input_ids'][0][i0+prefix_len:i1+prefix_len] + encoded['input_ids'][0][-suffix_len:],
+                        'attention_mask': encoded['attention_mask'][0][:prefix_len] + encoded['attention_mask'][0][i0+prefix_len:i1+prefix_len] + encoded['attention_mask'][0][-suffix_len:]
+                    })
+                    all_len.append(i1-i0)
+                    i0 += max_passage - overlap
+            else:
+                all_ids.append((ids[i], None))
+                all_tokens.append({'input_ids': encoded['input_ids'][0], 'attention_mask': encoded['attention_mask'][0]})
+                all_len.append(len(encoded['input_ids'][0]) - prefix_len - suffix_len)
+
+
+        total_batches = (len(all_tokens) + batch_size - 1) // batch_size
+
+        all_len, all_tokens, all_ids = zip(*sorted(zip(all_len, all_tokens, all_ids), key=lambda x: x[0]))
+
+
+        for i in range(0, len(all_tokens), batch_size):
+            batch_num = i // batch_size + 1
+            if batch_num % 50 == 0:
+                print(f"Processing batch {batch_num}/{total_batches} ({(batch_num/total_batches)*100:.1f}%)")
+                if torch.cuda.is_available():
+                    torch.cuda.empty_cache()
+            
+            batch_tokens = all_tokens[i:i + batch_size]
+            
+            batch_max = max([len(ids['input_ids']) for ids in batch_tokens])
+            encoded = dict()
+            encoded["attention_mask"] = [s['attention_mask'] + (batch_max - len(s['attention_mask'])) * [0] for s in batch_tokens]
+            encoded["input_ids"] = [s['input_ids'] + (batch_max - len(s['attention_mask'])) * [0] for s in batch_tokens]
+            encoded["attention_mask"] = torch.tensor(encoded["attention_mask"], dtype=torch.long).to(self.device)
+            encoded["input_ids"] = torch.tensor(encoded["input_ids"], dtype=torch.long).to(self.device)
+
+
+
+            try:
+
+                with torch.no_grad():
+                    model_output = self.model(**encoded)
+                    
+                    embeddings = model_output[0][:, 0].float()
+                    
+                    # L2 normalize embeddings (important for E5)
+                    embeddings = torch.nn.functional.normalize(embeddings, p=2, dim=1)
+                    
+                # Move to CPU immediately
+                all_embeddings.append(embeddings.cpu())
+                
+                # Clear GPU memory
+                del encoded, model_output, embeddings
+                if torch.cuda.is_available():
+                    torch.cuda.empty_cache()
+                    
+            except torch.cuda.OutOfMemoryError as e:
+                print(f"CUDA OOM at batch {batch_num}, reducing batch size...")
+                # Process one item at a time
+                for j in range(len(encoded)):
+                    try:
+
+                        encoded0 = encoded[j:j+1]
+
+                        with torch.no_grad():
+                            model_output = self.model(**encoded0)
+
+                            embeddings = model_output[0][:, 0].float()
+                            embeddings = torch.nn.functional.normalize(embeddings, p=2, dim=1)
+                            
+                        all_embeddings.append(embeddings.cpu())
+                        
+                        del encoded0, model_output, embeddings
+                        if torch.cuda.is_available():
+                            torch.cuda.empty_cache()
+                            
+                    except Exception as e2:
+                        print(f"Failed to process single text: {e2}")
+                        zero_embedding = torch.zeros(1, 1024).float()
+                        all_embeddings.append(zero_embedding)
+
+        id2idx = {}
+        for i in range(len(all_ids)):
+            if all_ids[i][0] not in id2idx:
+                id2idx[all_ids[i][0]] = []
+            id2idx[all_ids[i][0]].append(i)
+
+        return torch.cat(all_embeddings, dim=0).to(self.model.device), all_ids, id2idx # numpy()
+
+
+
+class BGEReranker:
+    def __init__(self, model_name=None, device=None):
+        """
+        Initializes the BGE reranker for fine-grained relevance scoring.
+        """
+        # Use local model 
+        if model_name is None:
+            # local_model_path = os.path.join('sub/models', 'bge-reranker-v2-m3') # 'bge-reranker-v2-m3'
+            local_model_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'models', 'bge-reranker-v2-m3_pseudo_tune_full')  # 'bge-reranker-v2-m3'
+            if os.path.isdir(local_model_path):
+                model_name = local_model_path
+                print(f"Using local BGE model from: {model_name}")
+        
+        self.device = device or ("cuda" if torch.cuda.is_available() else "cpu")
+        
+        print(f"Loading BGE reranker on device: {self.device}")
+        
+        # BGE reranker is actually a special model type
+        from transformers import AutoModelForSequenceClassification
+        
+        self.tokenizer = AutoTokenizer.from_pretrained(model_name)
+        self.model = AutoModelForSequenceClassification.from_pretrained(
+            model_name, 
+            torch_dtype=torch.bfloat16,
+            trust_remote_code=True
+        ).to(self.device)
+        self.model.eval()
+        
+        if torch.cuda.is_available():
+            torch.cuda.empty_cache()
+    
+    def prepare_corpus(self, texts, ids): 
+
+        self.corpus_tokens = {}
+        for i in range(len(texts)): # 
+            encoded = self.tokenizer(
+                    [texts[i].strip()], 
+                    padding=False, 
+                    truncation=False, 
+                    # max_length=512,
+                    # return_tensors='pt'
+                )
+            self.corpus_tokens[ids[i]] = {'input_ids': encoded['input_ids'][0], 'attention_mask': encoded['attention_mask'][0]}
+
+
+    def rerank(self, query_text, passages, passage_ids, max_time, top_k=20):
+        """
+        Rerank the passages using BGE reranker - CORRECTED VERSION.
+        """
+        if not passages:
+            return []
+        if time.time() > max_time-0.1:
+            print(f'No time for bge rerank!!')
+            return []
+
+        max_length = 2048
+
+        query_encoded = self.tokenizer(
+                    [query_text.strip()], 
+                    padding=False, 
+                    truncation=True,
+                    max_length = max_length - 1024,
+                    )
+        
+        all_tokens = []
+        all_ids = []
+        all_len = []
+
+        suffix_len = 1
+        prefix_len = 1
+
+        max_passage = max_length - len(query_encoded['input_ids'][0]) - suffix_len - prefix_len
+        overlap = max_passage // 2
+
+        for i in range(len(passage_ids)): # tqdm(
+            encoded = self.corpus_tokens[passage_ids[i]]
+            
+            if len(encoded['input_ids']) - suffix_len - prefix_len > max_passage:
+                _idxs = list(range(prefix_len, len(encoded['input_ids'])-suffix_len))
+
+                i0 = 0
+                while i0 < len(_idxs) - overlap:
+                    i1 = min(i0+max_passage, len(_idxs))
+                    all_ids.append((passage_ids[i], (i0, i1, len(_idxs))))
+                    all_tokens.append({
+                        'input_ids': query_encoded['input_ids'][0] + [2] + encoded['input_ids'][i0+prefix_len:i1+prefix_len] + [2],
+                        'attention_mask': query_encoded['attention_mask'][0] + [1] + encoded['attention_mask'][i0+prefix_len:i1+prefix_len] + [1]
+                    })
+                    all_len.append(i1-i0)
+                    i0 += max_passage - overlap
+            else:
+                all_ids.append((passage_ids[i], None))
+                all_tokens.append({'input_ids': query_encoded['input_ids'][0] + [2] + encoded['input_ids'][1:], 'attention_mask': query_encoded['attention_mask'][0] + [1] + encoded['attention_mask'][1:]})
+                all_len.append(len(encoded['input_ids']) - prefix_len - suffix_len)
+
+
+        # all_len, all_tokens, all_ids = zip(*sorted(zip(all_len, all_tokens, all_ids), key=lambda x: x[0]))
+
+
+        scores = []
+        batch_size = 4 # 4  # Conservative batch size
+        
+        for i in range(0, len(all_tokens), batch_size):
+            if time.time() > max_time:
+                print(f'bge rerank time limit! processed {len(scores)} of {len(all_tokens)}')
+                break
+
+            batch_tokens = all_tokens[i:i + batch_size]
+            
+            batch_max = max([len(ids['input_ids']) for ids in batch_tokens])
+            encoded = dict()
+            encoded["attention_mask"] = [s['attention_mask'] + (batch_max - len(s['attention_mask'])) * [0] for s in batch_tokens]
+            encoded["input_ids"] = [s['input_ids'] + (batch_max - len(s['attention_mask'])) * [0] for s in batch_tokens]
+            encoded["attention_mask"] = torch.tensor(encoded["attention_mask"], dtype=torch.long).to(self.device)
+            encoded["input_ids"] = torch.tensor(encoded["input_ids"], dtype=torch.long).to(self.device)
+
+
+            try:
+                # BGE reranker expects SEPARATE query and passage inputs
+                # NOT concatenated strings
+                # batch_queries = [query_text] * len(batch_passages)
+                
+                # Tokenize query-passage pairs properly
+                with torch.no_grad():
+
+                    # Get relevance scores from sequence classification model
+                    outputs = self.model(**encoded)
+                    
+                    # BGE reranker outputs logits for relevance classification
+                    logits = outputs.logits.float()
+                    
+                    # Handle different output shapes
+                    if len(logits.shape) == 1:
+                        # Single score per pair
+                        batch_scores = logits.cpu().numpy()
+                    elif logits.shape[1] == 1:
+                        # Single column output
+                        batch_scores = logits.squeeze(-1).cpu().numpy()
+                    else:
+                        # Binary classification - take positive class (index 1)
+                        batch_scores = logits[:, 1].cpu().numpy()
+                
+                scores.extend(batch_scores.tolist())
+                
+                # Cleanup
+                del encoded, outputs
+                if torch.cuda.is_available():
+                    torch.cuda.empty_cache()
+                    
+            except Exception as e:
+                print(f"Error in reranking batch {i//batch_size + 1}: {e}")
+                # Fallback: Use neutral scores for this batch
+                fallback_scores = [0.5] * len(batch_tokens)
+                scores.extend(fallback_scores)
+        
+        all_ids = all_ids[:len(scores)]
+
+        # Combine results and sort by reranking score
+        results = list(zip(all_ids, scores))
+        results.sort(key=lambda x: x[1], reverse=True)
+        
+        new_res = []
+        _used = set([])
+        for i in range(len(results)):
+            if results[i][0][0] not in _used:
+                _used.add(results[i][0][0])
+                new_res.append((results[i][0][0], results[i][1]))
+
+        return new_res[:min(top_k, len(new_res))]
+
+
+
+
+
+
+
+# Global instances
+retrievers = None
+reranker = None
+retrieverBM5 = None
+corpus_texts = {}  # Store original passage texts for reranking
+
+def preprocess(corpus_dict):
+    """
+    Preprocessing function using E5 multilingual model + BGE reranker.
+    
+    Input: corpus_dict - dict mapping document IDs to document objects with 'passage'/'text' field
+    Output: dict containing initialized models, embeddings, and corpus data
+    
+    Note: Uses global variables (retriever, reranker, corpus_texts) for efficiency,
+    but also returns all required data via preprocessed_data for function interface.
+    """
+    global retrievers, reranker, corpus_texts, retrieverBM5
+    
+    start_time = time.time()
+
+    print("=" * 60)
+    print("PREPROCESSING: Initializing E5 + BGE Reranker Pipeline...")
+    print("=" * 60)
+    
+    # Set GPU memory optimization
+    os.environ['PYTORCH_CUDA_ALLOC_CONF'] = 'expandable_segments:True'
+    torch.backends.cuda.matmul.allow_tf32 = True
+    torch.backends.cudnn.allow_tf32 = True
+
+    # Initialize E5 retriever
+    print("Loading retrievers...")
+    
+    retrieverE5 = E5Retriever()
+    
+    retrieverE5Ins = E5InstructRetriever()
+
+    retrieverM3 = M3Retriever()
+
+    retrieverSnowflake = SnowflakeInstructRetriever()
+
+    retrieverSolon = SolonRetriever()
+
+    retrieverRAGbot = E5Retriever(os.path.join(os.path.dirname(os.path.abspath(__file__)), 'models', 'Webiks_Hebrew_RAGbot_KolZchut_QA_Embedder_v1.0') )
+
+    retrievers = [retrieverE5, retrieverE5Ins, retrieverM3, retrieverSnowflake, retrieverSolon, retrieverRAGbot]
+
+
+    # Initialize BGE reranker
+    print("Loading rerankers...")
+    reranker = BGEReranker()
+
+    print(f"Preparing corpus with {len(corpus_dict)} documents...")
+    
+    # Store corpus IDs, passages, and original texts
+    corpus_ids = list(corpus_dict.keys())
+    passages = [doc.get('passage', doc.get('text', '')) for doc in corpus_dict.values()]
+    
+    for ret in retrievers:
+        ret.corpus_ids = list(corpus_dict.keys())
+        print("Computing embeddings...")
+        ret.corpus_embeddings, ret.corpus_ids, ret.id2idx = ret.prepare_corpus(passages,  ret.corpus_ids, batch_size=32)
+
+        print("✓ Corpus preprocessing complete!")
+        print(f"✓ Generated embeddings for {len(ret.corpus_ids)} documents")
+        print(f"✓ Embedding matrix shape: {ret.corpus_embeddings.shape}")
+
+    # Store original texts for reranking
+    corpus_texts = {doc_id: passages[i] for i, doc_id in enumerate(corpus_ids)}
+
+    reranker.corpus_ids = list(corpus_dict.keys())
+    reranker.prepare_corpus(passages,  reranker.corpus_ids)
+
+    retrieverBM5 = BM25sRetriever(passages,  corpus_ids)
+
+    if torch.cuda.is_available():
+        torch.cuda.empty_cache()
+
+    end_time = time.time()
+    elapsed_time = end_time - start_time
+    print(f"Elapsed time: {elapsed_time} seconds")
+
+    return {
+        'retrievers': retrievers,
+        'retrieverBM5': retrieverBM5,
+        'reranker': reranker,
+        'corpus_ids': corpus_ids,
+        'corpus_texts': corpus_texts,
+        'num_documents': len(corpus_dict)
+    }
+
+
+def predict(query, preprocessed_data):
+    """
+    Two-stage prediction: E5 retrieval + BGE reranking.
+    
+    Input: 
+    - query: dict with 'query' field containing query text
+    - preprocessed_data: dict from preprocess() containing models and corpus data
+    
+    Output: list of dicts with 'paragraph_uuid' and 'score' fields, ranked by relevance
+    
+    Note: Uses global variables for efficiency but can also extract required data
+    from preprocessed_data parameter for proper function interface.
+    """
+    global retrievers, reranker, corpus_texts, retrieverBM5
+    
+    start_time = time.time()
+    max_time = start_time + 1.85 #
+
+    # Extract query text
+    query_text = query.get('query', '')
+    if not query_text:
+        return []
+    
+    # Use global instances or get from preprocessed_data
+    if retrievers is None:
+        retrievers = preprocessed_data.get('retrievers')
+        reranker = preprocessed_data.get('reranker')
+        corpus_texts = preprocessed_data.get('corpus_texts', {})
+        retrieverBM5 = preprocessed_data.get('retrieverBM5')
+        
+        if retrievers is None or reranker is None:
+            print("Error: Missing retriever or reranker in preprocessed data")
+            return []
+    
+    TopNCandidates0 = 250
+    TopNCandidates = 250
+
+    retriever_mean_std = [(-1.4131863134104607, 1.055066495990117),
+                        (0.8814187049865723, 0.017973395064473152),
+                        (0.5294753313064575, 0.06463246047496796),
+                        (0.4171469509601593, 0.0699099600315094), 
+                        (0.49514809250831604, 0.06277099251747131),
+                        (0.530211865901947, 0.0704670324921608)]
+
+
+    retriever_w = np.array([1.1, 0.25, 0.2, 0.3, 0.3, 0.3])
+    retriever_w /= retriever_w.sum()
+
+    try:
+        # STAGE 1: Retrieval (get top 100 candidates)
+
+        candidate_ids = []
+        candidate_scores0 = []
+        candidate_passages = []
+        candidate_scores_bm5 = []
+
+        ret_scores = []
+        for retriever in retrievers:
+            query_embedding = retriever.embed_texts([query_text], is_query=True, batch_size=1)
+            query_embedding = torch.from_numpy(query_embedding).cuda()
+            # Compute cosine similarity with precomputed corpus embeddings
+            _scores = F.cosine_similarity(query_embedding, retriever.corpus_embeddings, 1, 1e-6)
+            _scores = _scores.cpu().numpy()
+            ret_scores.append(_scores)
+            _argsort = np.argsort(_scores)[::-1]
+
+            for idx in _argsort[:TopNCandidates0]:
+                if retriever.corpus_ids[idx][0] not in candidate_ids: 
+                    candidate_ids.append(retriever.corpus_ids[idx][0])
+            
+        _scores = retrieverBM5.get_scores(query_text)
+        _argsort = np.argsort(_scores)[::-1]
+        for idx in _argsort[:TopNCandidates0]:
+            if retrieverBM5.corpus_ids[idx] not in candidate_ids: 
+                candidate_ids.append(retrieverBM5.corpus_ids[idx])
+                
+        for i in range(len(candidate_ids)):
+            doc_id = candidate_ids[i]
+            _bm5_sc = (_scores[retrieverBM5.id2idx[doc_id]] - 5.919949) / 2.7885008
+            candidate_scores_bm5.append(_bm5_sc)
+            _sc = 0
+            for j in range(len(retrievers)):
+                _sc0 = np.max(ret_scores[j][retrievers[j].id2idx[doc_id]])
+                _sc0 = (_sc0 - retriever_mean_std[j][0]) / retriever_mean_std[j][1]
+                _sc += retriever_w[j] * _sc0
+            candidate_scores0.append(0.85 * _sc + 0.15 * _bm5_sc)
+            candidate_passages.append(corpus_texts.get(doc_id, ''))
+        
+        candidate_scores, candidate_ids, candidate_passages, candidate_scores_bm5 = zip(*sorted(zip(candidate_scores0, candidate_ids, candidate_passages, candidate_scores_bm5))[::-1][:min(len(candidate_ids), TopNCandidates)])
+
+        
+        # STAGE 2: Reranking (rerank top 100 -> top 20)
+
+        reranked_results = reranker.rerank(
+            query_text, 
+            candidate_passages, 
+            candidate_ids, 
+            max_time,
+            top_k=len(candidate_ids)
+        )
+
+        if len(reranked_results) >= 20:
+            reranked_scores0 = [rerank_score for (passage_id, rerank_score) in reranked_results]
+            reranked_results = [passage_id for (passage_id, rerank_score) in reranked_results]
+            scores = []
+            for _i, _p in enumerate(reranked_results):
+                scores.append(0.35 * (reranked_scores0[_i] + 1.8669906079283858) / 1.207719509974457 
+                                + 0.65 * candidate_scores[candidate_ids.index(_p)])
+ 
+            reranked_results = [(rerank_score, passage_id) for rerank_score, passage_id in sorted(zip(scores, reranked_results))][::-1] #[:TopNCandidates2]
+        else:
+            reranked_results = [(candidate_scores[i], candidate_ids[i]) for i in range(20)]
+
+
+        # Build final results with ACTUAL reranking scores
+        results = []
+        for rank, (rerank_score, passage_id) in enumerate(reranked_results[:20]):
+            results.append({
+                'paragraph_uuid': passage_id,
+                'score': float(rerank_score)  # Use actual BGE reranker score!
+            })
+
+        end_time = time.time()
+        elapsed_time = end_time - start_time
+        # print(f"✓ Returned {len(results)} results with reranker scores. Elapsed time: {elapsed_time} seconds")
+
+        return results
+        
+    except Exception as e:
+        print(f"Error in prediction: {e}")
+        # Fallback to E5-only retrieval with E5 scores
+        try:
+            query_embedding = retrievers[0].embed_texts([query_text], is_query=True, batch_size=1)
+            query_embedding = torch.from_numpy(query_embedding).cuda()
+            e5_scores = F.cosine_similarity(query_embedding, retrievers[0].corpus_embeddings, 1, 1e-6)
+            e5_scores = e5_scores.cpu().numpy()
+            top_indices = np.argsort(e5_scores)[::-1][:20]
+            
+            results = []
+            for idx in top_indices:
+                results.append({
+                    'paragraph_uuid': retriever.corpus_ids[idx],
+                    'score': float(e5_scores[idx])  # Use actual E5 cosine similarity score
+                })
+            
+            return results
+        except:
+            return []

victord/sub19/models/Solon-embeddings-large-0.1/1_Pooling/config.json

@@ -0,0 +1,10 @@
+{
+    "word_embedding_dimension": 1024,
+    "pooling_mode_cls_token": false,
+    "pooling_mode_mean_tokens": true,
+    "pooling_mode_max_tokens": false,
+    "pooling_mode_mean_sqrt_len_tokens": false,
+    "pooling_mode_weightedmean_tokens": false,
+    "pooling_mode_lasttoken": false,
+    "include_prompt": true
+}

victord/sub19/models/Solon-embeddings-large-0.1/README.md

@@ -0,0 +1,810 @@
+---
+tags:
+- mteb
+model-index:
+- name: Solon-embeddings-large-0.1
+  results:
+  - task:
+      type: sentence-similarity
+      name: Passage Retrieval
+    dataset:
+      type: unicamp-dl/mmarco
+      name: mMARCO-fr
+      config: french
+      split: validation
+    metrics:
+      - type: recall_at_500
+        name: Recall@500
+        value: 92.7
+      - type: recall_at_100
+        name: Recall@100
+        value: 82.7
+      - type: recall_at_10
+        name: Recall@10
+        value: 55.5
+      - type: map_at_10
+        name: MAP@10
+        value: 29.4
+      - type: ndcg_at_10
+        name: nDCG@10
+        value: 35.8
+      - type: mrr_at_10
+        name: MRR@10
+        value: 29.9
+  - task:
+      type: Clustering
+    dataset:
+      type: lyon-nlp/alloprof
+      name: MTEB AlloProfClusteringP2P
+      config: default
+      split: test
+      revision: 392ba3f5bcc8c51f578786c1fc3dae648662cb9b
+    metrics:
+    - type: v_measure
+      value: 64.16942168287153
+  - task:
+      type: Clustering
+    dataset:
+      type: lyon-nlp/alloprof
+      name: MTEB AlloProfClusteringS2S
+      config: default
+      split: test
+      revision: 392ba3f5bcc8c51f578786c1fc3dae648662cb9b
+    metrics:
+    - type: v_measure
+      value: 38.17076313383054
+  - task:
+      type: Reranking
+    dataset:
+      type: lyon-nlp/mteb-fr-reranking-alloprof-s2p
+      name: MTEB AlloprofReranking
+      config: default
+      split: test
+      revision: 666fdacebe0291776e86f29345663dfaf80a0db9
+    metrics:
+    - type: map
+      value: 64.8770878097632
+    - type: mrr
+      value: 66.39132423169396
+  - task:
+      type: Retrieval
+    dataset:
+      type: lyon-nlp/alloprof
+      name: MTEB AlloprofRetrieval
+      config: default
+      split: test
+      revision: 392ba3f5bcc8c51f578786c1fc3dae648662cb9b
+    metrics:
+    - type: map_at_1
+      value: 29.62
+    - type: map_at_10
+      value: 40.963
+    - type: map_at_100
+      value: 41.894
+    - type: map_at_1000
+      value: 41.939
+    - type: map_at_3
+      value: 37.708999999999996
+    - type: map_at_5
+      value: 39.696999999999996
+    - type: mrr_at_1
+      value: 29.62
+    - type: mrr_at_10
+      value: 40.963
+    - type: mrr_at_100
+      value: 41.894
+    - type: mrr_at_1000
+      value: 41.939
+    - type: mrr_at_3
+      value: 37.708999999999996
+    - type: mrr_at_5
+      value: 39.696999999999996
+    - type: ndcg_at_1
+      value: 29.62
+    - type: ndcg_at_10
+      value: 46.942
+    - type: ndcg_at_100
+      value: 51.629999999999995
+    - type: ndcg_at_1000
+      value: 52.927
+    - type: ndcg_at_3
+      value: 40.333999999999996
+    - type: ndcg_at_5
+      value: 43.922
+    - type: precision_at_1
+      value: 29.62
+    - type: precision_at_10
+      value: 6.589
+    - type: precision_at_100
+      value: 0.882
+    - type: precision_at_1000
+      value: 0.099
+    - type: precision_at_3
+      value: 15.976
+    - type: precision_at_5
+      value: 11.33
+    - type: recall_at_1
+      value: 29.62
+    - type: recall_at_10
+      value: 65.889
+    - type: recall_at_100
+      value: 88.212
+    - type: recall_at_1000
+      value: 98.575
+    - type: recall_at_3
+      value: 47.927
+    - type: recall_at_5
+      value: 56.64900000000001
+  - task:
+      type: Classification
+    dataset:
+      type: mteb/amazon_reviews_multi
+      name: MTEB AmazonReviewsClassification (fr)
+      config: fr
+      split: test
+      revision: 1399c76144fd37290681b995c656ef9b2e06e26d
+    metrics:
+    - type: accuracy
+      value: 42.077999999999996
+    - type: f1
+      value: 40.64511241732637
+  - task:
+      type: Retrieval
+    dataset:
+      type: maastrichtlawtech/bsard
+      name: MTEB BSARDRetrieval
+      config: default
+      split: test
+      revision: 5effa1b9b5fa3b0f9e12523e6e43e5f86a6e6d59
+    metrics:
+    - type: map_at_1
+      value: 0.901
+    - type: map_at_10
+      value: 1.524
+    - type: map_at_100
+      value: 1.833
+    - type: map_at_1000
+      value: 1.916
+    - type: map_at_3
+      value: 1.276
+    - type: map_at_5
+      value: 1.276
+    - type: mrr_at_1
+      value: 0.901
+    - type: mrr_at_10
+      value: 1.524
+    - type: mrr_at_100
+      value: 1.833
+    - type: mrr_at_1000
+      value: 1.916
+    - type: mrr_at_3
+      value: 1.276
+    - type: mrr_at_5
+      value: 1.276
+    - type: ndcg_at_1
+      value: 0.901
+    - type: ndcg_at_10
+      value: 2.085
+    - type: ndcg_at_100
+      value: 3.805
+    - type: ndcg_at_1000
+      value: 6.704000000000001
+    - type: ndcg_at_3
+      value: 1.41
+    - type: ndcg_at_5
+      value: 1.41
+    - type: precision_at_1
+      value: 0.901
+    - type: precision_at_10
+      value: 0.40499999999999997
+    - type: precision_at_100
+      value: 0.126
+    - type: precision_at_1000
+      value: 0.037
+    - type: precision_at_3
+      value: 0.601
+    - type: precision_at_5
+      value: 0.36
+    - type: recall_at_1
+      value: 0.901
+    - type: recall_at_10
+      value: 4.054
+    - type: recall_at_100
+      value: 12.613
+    - type: recall_at_1000
+      value: 36.937
+    - type: recall_at_3
+      value: 1.802
+    - type: recall_at_5
+      value: 1.802
+  - task:
+      type: BitextMining
+    dataset:
+      type: rbawden/DiaBLa
+      name: MTEB DiaBLaBitextMining (fr-en)
+      config: fr-en
+      split: test
+      revision: 5345895c56a601afe1a98519ce3199be60a27dba
+    metrics:
+    - type: accuracy
+      value: 88.90048712595686
+    - type: f1
+      value: 86.94952864886115
+    - type: precision
+      value: 86.20344379175826
+    - type: recall
+      value: 88.90048712595686
+  - task:
+      type: Clustering
+    dataset:
+      type: lyon-nlp/clustering-hal-s2s
+      name: MTEB HALClusteringS2S
+      config: default
+      split: test
+      revision: e06ebbbb123f8144bef1a5d18796f3dec9ae2915
+    metrics:
+    - type: v_measure
+      value: 24.087988843991155
+  - task:
+      type: Clustering
+    dataset:
+      type: mlsum
+      name: MTEB MLSUMClusteringP2P
+      config: default
+      split: test
+      revision: b5d54f8f3b61ae17845046286940f03c6bc79bc7
+    metrics:
+    - type: v_measure
+      value: 43.79603865728535
+  - task:
+      type: Clustering
+    dataset:
+      type: mlsum
+      name: MTEB MLSUMClusteringS2S
+      config: default
+      split: test
+      revision: b5d54f8f3b61ae17845046286940f03c6bc79bc7
+    metrics:
+    - type: v_measure
+      value: 37.746550373003
+  - task:
+      type: Classification
+    dataset:
+      type: mteb/mtop_domain
+      name: MTEB MTOPDomainClassification (fr)
+      config: fr
+      split: test
+      revision: d80d48c1eb48d3562165c59d59d0034df9fff0bf
+    metrics:
+    - type: accuracy
+      value: 89.26088318196052
+    - type: f1
+      value: 88.95811185929033
+  - task:
+      type: Classification
+    dataset:
+      type: mteb/mtop_intent
+      name: MTEB MTOPIntentClassification (fr)
+      config: fr
+      split: test
+      revision: ae001d0e6b1228650b7bd1c2c65fb50ad11a8aba
+    metrics:
+    - type: accuracy
+      value: 68.55308487316003
+    - type: f1
+      value: 48.2936682439785
+  - task:
+      type: Classification
+    dataset:
+      type: masakhane/masakhanews
+      name: MTEB MasakhaNEWSClassification (fra)
+      config: fra
+      split: test
+      revision: 8ccc72e69e65f40c70e117d8b3c08306bb788b60
+    metrics:
+    - type: accuracy
+      value: 81.51658767772511
+    - type: f1
+      value: 77.695234448912
+  - task:
+      type: Clustering
+    dataset:
+      type: masakhane/masakhanews
+      name: MTEB MasakhaNEWSClusteringP2P (fra)
+      config: fra
+      split: test
+      revision: 8ccc72e69e65f40c70e117d8b3c08306bb788b60
+    metrics:
+    - type: v_measure
+      value: 40.80377094681114
+  - task:
+      type: Clustering
+    dataset:
+      type: masakhane/masakhanews
+      name: MTEB MasakhaNEWSClusteringS2S (fra)
+      config: fra
+      split: test
+      revision: 8ccc72e69e65f40c70e117d8b3c08306bb788b60
+    metrics:
+    - type: v_measure
+      value: 28.79703837416241
+  - task:
+      type: Classification
+    dataset:
+      type: mteb/amazon_massive_intent
+      name: MTEB MassiveIntentClassification (fr)
+      config: fr
+      split: test
+      revision: 31efe3c427b0bae9c22cbb560b8f15491cc6bed7
+    metrics:
+    - type: accuracy
+      value: 67.40080699394755
+    - type: f1
+      value: 65.60793135686376
+  - task:
+      type: Classification
+    dataset:
+      type: mteb/amazon_massive_scenario
+      name: MTEB MassiveScenarioClassification (fr)
+      config: fr
+      split: test
+      revision: 7d571f92784cd94a019292a1f45445077d0ef634
+    metrics:
+    - type: accuracy
+      value: 71.29455279085406
+    - type: f1
+      value: 70.80876673828983
+  - task:
+      type: Retrieval
+    dataset:
+      type: jinaai/mintakaqa
+      name: MTEB MintakaRetrieval (fr)
+      config: fr
+      split: test
+      revision: efa78cc2f74bbcd21eff2261f9e13aebe40b814e
+    metrics:
+    - type: map_at_1
+      value: 16.625999999999998
+    - type: map_at_10
+      value: 25.224999999999998
+    - type: map_at_100
+      value: 26.291999999999998
+    - type: map_at_1000
+      value: 26.395000000000003
+    - type: map_at_3
+      value: 22.378999999999998
+    - type: map_at_5
+      value: 24.009
+    - type: mrr_at_1
+      value: 16.625999999999998
+    - type: mrr_at_10
+      value: 25.224999999999998
+    - type: mrr_at_100
+      value: 26.291999999999998
+    - type: mrr_at_1000
+      value: 26.395000000000003
+    - type: mrr_at_3
+      value: 22.378999999999998
+    - type: mrr_at_5
+      value: 24.009
+    - type: ndcg_at_1
+      value: 16.625999999999998
+    - type: ndcg_at_10
+      value: 30.074
+    - type: ndcg_at_100
+      value: 35.683
+    - type: ndcg_at_1000
+      value: 38.714999999999996
+    - type: ndcg_at_3
+      value: 24.188000000000002
+    - type: ndcg_at_5
+      value: 27.124
+    - type: precision_at_1
+      value: 16.625999999999998
+    - type: precision_at_10
+      value: 4.566
+    - type: precision_at_100
+      value: 0.729
+    - type: precision_at_1000
+      value: 0.097
+    - type: precision_at_3
+      value: 9.801
+    - type: precision_at_5
+      value: 7.305000000000001
+    - type: recall_at_1
+      value: 16.625999999999998
+    - type: recall_at_10
+      value: 45.659
+    - type: recall_at_100
+      value: 72.85000000000001
+    - type: recall_at_1000
+      value: 97.42
+    - type: recall_at_3
+      value: 29.402
+    - type: recall_at_5
+      value: 36.527
+  - task:
+      type: PairClassification
+    dataset:
+      type: GEM/opusparcus
+      name: MTEB OpusparcusPC (fr)
+      config: fr
+      split: test
+      revision: 9e9b1f8ef51616073f47f306f7f47dd91663f86a
+    metrics:
+    - type: cos_sim_accuracy
+      value: 83.58310626702998
+    - type: cos_sim_ap
+      value: 94.01979957812989
+    - type: cos_sim_f1
+      value: 88.70135958743555
+    - type: cos_sim_precision
+      value: 84.01420959147424
+    - type: cos_sim_recall
+      value: 93.94240317775571
+    - type: dot_accuracy
+      value: 83.58310626702998
+    - type: dot_ap
+      value: 94.01979957812989
+    - type: dot_f1
+      value: 88.70135958743555
+    - type: dot_precision
+      value: 84.01420959147424
+    - type: dot_recall
+      value: 93.94240317775571
+    - type: euclidean_accuracy
+      value: 83.58310626702998
+    - type: euclidean_ap
+      value: 94.01979957812989
+    - type: euclidean_f1
+      value: 88.70135958743555
+    - type: euclidean_precision
+      value: 84.01420959147424
+    - type: euclidean_recall
+      value: 93.94240317775571
+    - type: manhattan_accuracy
+      value: 83.58310626702998
+    - type: manhattan_ap
+      value: 93.99936024003892
+    - type: manhattan_f1
+      value: 88.6924150767799
+    - type: manhattan_precision
+      value: 83.45008756567425
+    - type: manhattan_recall
+      value: 94.63753723932473
+    - type: max_accuracy
+      value: 83.58310626702998
+    - type: max_ap
+      value: 94.01979957812989
+    - type: max_f1
+      value: 88.70135958743555
+  - task:
+      type: PairClassification
+    dataset:
+      type: paws-x
+      name: MTEB PawsX (fr)
+      config: fr
+      split: test
+      revision: 8a04d940a42cd40658986fdd8e3da561533a3646
+    metrics:
+    - type: cos_sim_accuracy
+      value: 60.6
+    - type: cos_sim_ap
+      value: 60.18915797975459
+    - type: cos_sim_f1
+      value: 62.491349480968864
+    - type: cos_sim_precision
+      value: 45.44539506794162
+    - type: cos_sim_recall
+      value: 100
+    - type: dot_accuracy
+      value: 60.6
+    - type: dot_ap
+      value: 60.091135216056024
+    - type: dot_f1
+      value: 62.491349480968864
+    - type: dot_precision
+      value: 45.44539506794162
+    - type: dot_recall
+      value: 100
+    - type: euclidean_accuracy
+      value: 60.6
+    - type: euclidean_ap
+      value: 60.18915797975459
+    - type: euclidean_f1
+      value: 62.491349480968864
+    - type: euclidean_precision
+      value: 45.44539506794162
+    - type: euclidean_recall
+      value: 100
+    - type: manhattan_accuracy
+      value: 60.650000000000006
+    - type: manhattan_ap
+      value: 60.2082343915352
+    - type: manhattan_f1
+      value: 62.491349480968864
+    - type: manhattan_precision
+      value: 45.44539506794162
+    - type: manhattan_recall
+      value: 100
+    - type: max_accuracy
+      value: 60.650000000000006
+    - type: max_ap
+      value: 60.2082343915352
+    - type: max_f1
+      value: 62.491349480968864
+  - task:
+      type: STS
+    dataset:
+      type: Lajavaness/SICK-fr
+      name: MTEB SICKFr
+      config: default
+      split: test
+      revision: e077ab4cf4774a1e36d86d593b150422fafd8e8a
+    metrics:
+    - type: cos_sim_pearson
+      value: 79.77067200230256
+    - type: cos_sim_spearman
+      value: 76.7445532523278
+    - type: euclidean_pearson
+      value: 76.34017074673956
+    - type: euclidean_spearman
+      value: 76.7453011027832
+    - type: manhattan_pearson
+      value: 76.19578084197778
+    - type: manhattan_spearman
+      value: 76.56293456459228
+  - task:
+      type: STS
+    dataset:
+      type: mteb/sts22-crosslingual-sts
+      name: MTEB STS22 (fr)
+      config: fr
+      split: test
+      revision: eea2b4fe26a775864c896887d910b76a8098ad3f
+    metrics:
+    - type: cos_sim_pearson
+      value: 81.2564160237984
+    - type: cos_sim_spearman
+      value: 83.30552085410882
+    - type: euclidean_pearson
+      value: 82.00494560507786
+    - type: euclidean_spearman
+      value: 83.30552085410882
+    - type: manhattan_pearson
+      value: 81.93132229157803
+    - type: manhattan_spearman
+      value: 83.04357992939353
+  - task:
+      type: STS
+    dataset:
+      type: stsb_multi_mt
+      name: MTEB STSBenchmarkMultilingualSTS (fr)
+      config: fr
+      split: test
+      revision: 93d57ef91790589e3ce9c365164337a8a78b7632
+    metrics:
+    - type: cos_sim_pearson
+      value: 80.34931905288978
+    - type: cos_sim_spearman
+      value: 79.99372771100049
+    - type: euclidean_pearson
+      value: 78.37976845123443
+    - type: euclidean_spearman
+      value: 79.99452356550658
+    - type: manhattan_pearson
+      value: 78.24434042082316
+    - type: manhattan_spearman
+      value: 79.87248340061164
+  - task:
+      type: Summarization
+    dataset:
+      type: lyon-nlp/summarization-summeval-fr-p2p
+      name: MTEB SummEvalFr
+      config: default
+      split: test
+      revision: b385812de6a9577b6f4d0f88c6a6e35395a94054
+    metrics:
+    - type: cos_sim_pearson
+      value: 30.476001473421586
+    - type: cos_sim_spearman
+      value: 29.687350195905456
+    - type: dot_pearson
+      value: 30.476000875190685
+    - type: dot_spearman
+      value: 29.662224660056562
+  - task:
+      type: Reranking
+    dataset:
+      type: lyon-nlp/mteb-fr-reranking-syntec-s2p
+      name: MTEB SyntecReranking
+      config: default
+      split: test
+      revision: b205c5084a0934ce8af14338bf03feb19499c84d
+    metrics:
+    - type: map
+      value: 88.28333333333333
+    - type: mrr
+      value: 88.28333333333333
+  - task:
+      type: Retrieval
+    dataset:
+      type: lyon-nlp/mteb-fr-retrieval-syntec-s2p
+      name: MTEB SyntecRetrieval
+      config: default
+      split: test
+      revision: 77f7e271bf4a92b24fce5119f3486b583ca016ff
+    metrics:
+    - type: map_at_1
+      value: 69
+    - type: map_at_10
+      value: 79.906
+    - type: map_at_100
+      value: 79.982
+    - type: map_at_1000
+      value: 79.982
+    - type: map_at_3
+      value: 77.667
+    - type: map_at_5
+      value: 79.51700000000001
+    - type: mrr_at_1
+      value: 69
+    - type: mrr_at_10
+      value: 79.906
+    - type: mrr_at_100
+      value: 79.982
+    - type: mrr_at_1000
+      value: 79.982
+    - type: mrr_at_3
+      value: 77.667
+    - type: mrr_at_5
+      value: 79.51700000000001
+    - type: ndcg_at_1
+      value: 69
+    - type: ndcg_at_10
+      value: 84.60499999999999
+    - type: ndcg_at_100
+      value: 84.868
+    - type: ndcg_at_1000
+      value: 84.868
+    - type: ndcg_at_3
+      value: 80.333
+    - type: ndcg_at_5
+      value: 83.647
+    - type: precision_at_1
+      value: 69
+    - type: precision_at_10
+      value: 9.9
+    - type: precision_at_100
+      value: 1
+    - type: precision_at_1000
+      value: 0.1
+    - type: precision_at_3
+      value: 29.333
+    - type: precision_at_5
+      value: 19.2
+    - type: recall_at_1
+      value: 69
+    - type: recall_at_10
+      value: 99
+    - type: recall_at_100
+      value: 100
+    - type: recall_at_1000
+      value: 100
+    - type: recall_at_3
+      value: 88
+    - type: recall_at_5
+      value: 96
+  - task:
+      type: Retrieval
+    dataset:
+      type: jinaai/xpqa
+      name: MTEB XPQARetrieval (fr)
+      config: fr
+      split: test
+      revision: c99d599f0a6ab9b85b065da6f9d94f9cf731679f
+    metrics:
+    - type: map_at_1
+      value: 42.027
+    - type: map_at_10
+      value: 64.331
+    - type: map_at_100
+      value: 65.657
+    - type: map_at_1000
+      value: 65.7
+    - type: map_at_3
+      value: 57.967999999999996
+    - type: map_at_5
+      value: 62.33800000000001
+    - type: mrr_at_1
+      value: 65.688
+    - type: mrr_at_10
+      value: 72.263
+    - type: mrr_at_100
+      value: 72.679
+    - type: mrr_at_1000
+      value: 72.69099999999999
+    - type: mrr_at_3
+      value: 70.405
+    - type: mrr_at_5
+      value: 71.587
+    - type: ndcg_at_1
+      value: 65.688
+    - type: ndcg_at_10
+      value: 70.221
+    - type: ndcg_at_100
+      value: 74.457
+    - type: ndcg_at_1000
+      value: 75.178
+    - type: ndcg_at_3
+      value: 65.423
+    - type: ndcg_at_5
+      value: 67.05499999999999
+    - type: precision_at_1
+      value: 65.688
+    - type: precision_at_10
+      value: 16.208
+    - type: precision_at_100
+      value: 1.975
+    - type: precision_at_1000
+      value: 0.207
+    - type: precision_at_3
+      value: 39.831
+    - type: precision_at_5
+      value: 28.652
+    - type: recall_at_1
+      value: 42.027
+    - type: recall_at_10
+      value: 78.803
+    - type: recall_at_100
+      value: 95.051
+    - type: recall_at_1000
+      value: 99.75500000000001
+    - type: recall_at_3
+      value: 62.62799999999999
+    - type: recall_at_5
+      value: 70.975
+license: mit
+language:
+- fr
+---
+
+# Solon Embeddings — large 0.1
+
+SOTA Open source french embedding model.
+
+**Instructions :**  
+Add "query : " before the *query* to retrieve to increase performance of retrieval.  
+No instructions needed for *passages*.
+
+
+| Model | Mean Score |
+| --- | --- |
+| **OrdalieTech/Solon-embeddings-large-0.1** | 0.7490 |
+| cohere/embed-multilingual-v3 | 0.7402 |
+| **OrdalieTech/Solon-embeddings-base-0.1** | 0.7306 |
+| openai/ada-002 | 0.7290 |
+| cohere/embed-multilingual-light-v3 | 0.6945 |
+| antoinelouis/biencoder-camembert-base-mmarcoFR | 0.6826 |
+| dangvantuan/sentence-camembert-large | 0.6756 |
+| voyage/voyage-01 | 0.6753 |
+| intfloat/multilingual-e5-large | 0.6660 |
+| intfloat/multilingual-e5-base | 0.6597 |
+| Sbert/paraphrase-multilingual-mpnet-base-v2 | 0.5975 |
+| dangvantuan/sentence-camembert-base | 0.5456 |
+| EuropeanParliament/eubert_embedding_v1 | 0.5063 |
+
+These results have been obtained through 9 french benchmarks on a variety of text similarity tasks (classification, reranking, STS) :
+- AmazonReviewsClassification (MTEB)
+- MassiveIntentClassification (MTEB)
+- MassiveScenarioClassification (MTEB)
+- MTOPDomainClassification (MTEB)
+- MTOPIntentClassification (MTEB)
+- STS22 (MTEB)
+- MiraclFRRerank (Miracl)
+- OrdalieFRSTS (Ordalie)
+- OrdalieFRReranking (Ordalie)
+
+We created OrdalieFRSTS and OrdalieFRReranking to enhance the benchmarking capabilities of French STS and reranking assessments.
+
+(evaluation script available here : github.com/OrdalieTech/mteb)

victord/sub19/models/Solon-embeddings-large-0.1/config.json

@@ -0,0 +1,27 @@
+{
+  "architectures": [
+    "XLMRobertaModel"
+  ],
+  "attention_probs_dropout_prob": 0.1,
+  "bos_token_id": 0,
+  "classifier_dropout": null,
+  "eos_token_id": 2,
+  "hidden_act": "gelu",
+  "hidden_dropout_prob": 0.1,
+  "hidden_size": 1024,
+  "initializer_range": 0.02,
+  "intermediate_size": 4096,
+  "layer_norm_eps": 1e-05,
+  "max_position_embeddings": 514,
+  "model_type": "xlm-roberta",
+  "num_attention_heads": 16,
+  "num_hidden_layers": 24,
+  "output_past": true,
+  "pad_token_id": 1,
+  "position_embedding_type": "absolute",
+  "torch_dtype": "bfloat16",
+  "transformers_version": "4.53.2",
+  "type_vocab_size": 1,
+  "use_cache": true,
+  "vocab_size": 250002
+}

victord/sub19/models/Solon-embeddings-large-0.1/config_sentence_transformers.json

@@ -0,0 +1,14 @@
+{
+  "__version__": {
+    "sentence_transformers": "5.1.1",
+    "transformers": "4.53.2",
+    "pytorch": "2.9.0+cu128"
+  },
+  "model_type": "SentenceTransformer",
+  "prompts": {
+    "query": "",
+    "document": ""
+  },
+  "default_prompt_name": null,
+  "similarity_fn_name": "cosine"
+}

victord/sub19/models/Solon-embeddings-large-0.1/model.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:93f3e71f01d33409b21e3c4ff37d249cb3c27c883b24a90afd352fb95cbd67fe
+size 1119826072

victord/sub19/models/Solon-embeddings-large-0.1/modules.json

@@ -0,0 +1,20 @@
+[
+  {
+    "idx": 0,
+    "name": "0",
+    "path": "",
+    "type": "sentence_transformers.models.Transformer"
+  },
+  {
+    "idx": 1,
+    "name": "1",
+    "path": "1_Pooling",
+    "type": "sentence_transformers.models.Pooling"
+  },
+  {
+    "idx": 2,
+    "name": "2",
+    "path": "2_Normalize",
+    "type": "sentence_transformers.models.Normalize"
+  }
+]

victord/sub19/models/Solon-embeddings-large-0.1/sentence_bert_config.json

@@ -0,0 +1,4 @@
+{
+    "max_seq_length": 512,
+    "do_lower_case": false
+}

victord/sub19/models/Solon-embeddings-large-0.1/sentencepiece.bpe.model

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cfc8146abe2a0488e9e2a0c56de7952f7c11ab059eca145a0a727afce0db2865
+size 5069051

victord/sub19/models/Solon-embeddings-large-0.1/special_tokens_map.json

@@ -0,0 +1,51 @@
+{
+  "bos_token": {
+    "content": "<s>",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  },
+  "cls_token": {
+    "content": "<s>",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  },
+  "eos_token": {
+    "content": "</s>",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  },
+  "mask_token": {
+    "content": "<mask>",
+    "lstrip": true,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  },
+  "pad_token": {
+    "content": "<pad>",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  },
+  "sep_token": {
+    "content": "</s>",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  },
+  "unk_token": {
+    "content": "<unk>",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  }
+}

victord/sub19/models/Solon-embeddings-large-0.1/tokenizer.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:249df0778f236f6ece390de0de746838ef25b9d6954b68c2ee71249e0a9d8fd4
+size 17082799

victord/sub19/models/Solon-embeddings-large-0.1/tokenizer_config.json

@@ -0,0 +1,56 @@
+{
+  "added_tokens_decoder": {
+    "0": {
+      "content": "<s>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "1": {
+      "content": "<pad>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "2": {
+      "content": "</s>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "3": {
+      "content": "<unk>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "250001": {
+      "content": "<mask>",
+      "lstrip": true,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    }
+  },
+  "bos_token": "<s>",
+  "clean_up_tokenization_spaces": true,
+  "cls_token": "<s>",
+  "eos_token": "</s>",
+  "extra_special_tokens": {},
+  "mask_token": "<mask>",
+  "model_max_length": 512,
+  "pad_token": "<pad>",
+  "sep_token": "</s>",
+  "sp_model_kwargs": {},
+  "tokenizer_class": "XLMRobertaTokenizer",
+  "unk_token": "<unk>"
+}

victord/sub19/models/Webiks_Hebrew_RAGbot_KolZchut_QA_Embedder_v1.0/1_Pooling/config.json

@@ -0,0 +1,10 @@
+{
+    "word_embedding_dimension": 1024,
+    "pooling_mode_cls_token": false,
+    "pooling_mode_mean_tokens": true,
+    "pooling_mode_max_tokens": false,
+    "pooling_mode_mean_sqrt_len_tokens": false,
+    "pooling_mode_weightedmean_tokens": false,
+    "pooling_mode_lasttoken": false,
+    "include_prompt": true
+}

victord/sub19/models/Webiks_Hebrew_RAGbot_KolZchut_QA_Embedder_v1.0/README.md

@@ -0,0 +1,93 @@
+---
+library_name: sentence-transformers
+pipeline_tag: sentence-similarity
+tags:
+- sentence-transformers
+- feature-extraction
+- sentence-similarity
+
+---
+
+# {MODEL_NAME}
+
+This is a [sentence-transformers](https://www.SBERT.net) model: It maps sentences & paragraphs to a 1024 dimensional dense vector space and can be used for tasks like clustering or semantic search.
+
+<!--- Describe your model here -->
+
+## 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
+sentences = ["This is an example sentence", "Each sentence is converted"]
+
+model = SentenceTransformer('{MODEL_NAME}')
+embeddings = model.encode(sentences)
+print(embeddings)
+```
+
+
+
+## Evaluation Results
+
+<!--- Describe how your model was evaluated -->
+
+For an automated evaluation of this model, see the *Sentence Embeddings Benchmark*: [https://seb.sbert.net](https://seb.sbert.net?model_name={MODEL_NAME})
+
+
+## Training
+The model was trained with the parameters:
+
+**DataLoader**:
+
+`torch.utils.data.dataloader.DataLoader` of length 874 with parameters:
+```
+{'batch_size': None, 'sampler': 'torch.utils.data.sampler.SequentialSampler', 'batch_sampler': 'utils.UniqueQuestionSampler'}
+```
+
+**Loss**:
+
+`sentence_transformers.losses.MultipleNegativesRankingLoss.MultipleNegativesRankingLoss` with parameters:
+  ```
+  {'scale': 100, 'similarity_fct': 'cos_sim'}
+  ```
+
+Parameters of the fit()-Method:
+```
+{
+    "epochs": 10,
+    "evaluation_steps": 0,
+    "evaluator": "utils.CustomInformationRetrievalEvaluator",
+    "max_grad_norm": 1,
+    "optimizer_class": "<class 'torch.optim.adamw.AdamW'>",
+    "optimizer_params": {
+        "lr": 1e-05,
+        "weight_decay": 0.01
+    },
+    "scheduler": "WarmupLinear",
+    "steps_per_epoch": null,
+    "warmup_steps": 243,
+    "weight_decay": 0.01
+}
+```
+
+
+## Full Model Architecture
+```
+SentenceTransformer(
+  (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: XLMRobertaModel 
+  (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
+  (2): Normalize()
+)
+```
+
+## Citing & Authors
+
+<!--- Describe where people can find more information -->

victord/sub19/models/Webiks_Hebrew_RAGbot_KolZchut_QA_Embedder_v1.0/config.json

@@ -0,0 +1,27 @@
+{
+  "architectures": [
+    "XLMRobertaModel"
+  ],
+  "attention_probs_dropout_prob": 0.1,
+  "bos_token_id": 0,
+  "classifier_dropout": null,
+  "eos_token_id": 2,
+  "hidden_act": "gelu",
+  "hidden_dropout_prob": 0.1,
+  "hidden_size": 1024,
+  "initializer_range": 0.02,
+  "intermediate_size": 4096,
+  "layer_norm_eps": 1e-05,
+  "max_position_embeddings": 514,
+  "model_type": "xlm-roberta",
+  "num_attention_heads": 16,
+  "num_hidden_layers": 24,
+  "output_past": true,
+  "pad_token_id": 1,
+  "position_embedding_type": "absolute",
+  "torch_dtype": "bfloat16",
+  "transformers_version": "4.53.2",
+  "type_vocab_size": 1,
+  "use_cache": true,
+  "vocab_size": 250002
+}

victord/sub19/models/Webiks_Hebrew_RAGbot_KolZchut_QA_Embedder_v1.0/config_sentence_transformers.json

@@ -0,0 +1,14 @@
+{
+  "__version__": {
+    "sentence_transformers": "5.1.2",
+    "transformers": "4.53.2",
+    "pytorch": "2.9.0+cu128"
+  },
+  "prompts": {
+    "query": "",
+    "document": ""
+  },
+  "default_prompt_name": null,
+  "model_type": "SentenceTransformer",
+  "similarity_fn_name": "cosine"
+}

victord/sub19/models/Webiks_Hebrew_RAGbot_KolZchut_QA_Embedder_v1.0/model.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1c5ecf0a1c5a72fb78c91dfd5b0c7f16145ca5fe2e5c4d3e0870b73fef7f6e99
+size 1119826072

victord/sub19/models/Webiks_Hebrew_RAGbot_KolZchut_QA_Embedder_v1.0/modules.json

@@ -0,0 +1,20 @@
+[
+  {
+    "idx": 0,
+    "name": "0",
+    "path": "",
+    "type": "sentence_transformers.models.Transformer"
+  },
+  {
+    "idx": 1,
+    "name": "1",
+    "path": "1_Pooling",
+    "type": "sentence_transformers.models.Pooling"
+  },
+  {
+    "idx": 2,
+    "name": "2",
+    "path": "2_Normalize",
+    "type": "sentence_transformers.models.Normalize"
+  }
+]

victord/sub19/models/Webiks_Hebrew_RAGbot_KolZchut_QA_Embedder_v1.0/sentence_bert_config.json

@@ -0,0 +1,4 @@
+{
+    "max_seq_length": 512,
+    "do_lower_case": false
+}

victord/sub19/models/Webiks_Hebrew_RAGbot_KolZchut_QA_Embedder_v1.0/special_tokens_map.json

@@ -0,0 +1,51 @@
+{
+  "bos_token": {
+    "content": "<s>",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  },
+  "cls_token": {
+    "content": "<s>",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  },
+  "eos_token": {
+    "content": "</s>",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  },
+  "mask_token": {
+    "content": "<mask>",
+    "lstrip": true,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  },
+  "pad_token": {
+    "content": "<pad>",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  },
+  "sep_token": {
+    "content": "</s>",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  },
+  "unk_token": {
+    "content": "<unk>",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  }
+}

victord/sub19/models/Webiks_Hebrew_RAGbot_KolZchut_QA_Embedder_v1.0/tokenizer.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:883b037111086fd4dfebbbc9b7cee11e1517b5e0c0514879478661440f137085
+size 17082987

victord/sub19/models/Webiks_Hebrew_RAGbot_KolZchut_QA_Embedder_v1.0/tokenizer_config.json

@@ -0,0 +1,62 @@
+{
+  "added_tokens_decoder": {
+    "0": {
+      "content": "<s>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "1": {
+      "content": "<pad>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "2": {
+      "content": "</s>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "3": {
+      "content": "<unk>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "250001": {
+      "content": "<mask>",
+      "lstrip": true,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    }
+  },
+  "bos_token": "<s>",
+  "clean_up_tokenization_spaces": true,
+  "cls_token": "<s>",
+  "eos_token": "</s>",
+  "extra_special_tokens": {},
+  "mask_token": "<mask>",
+  "max_length": 512,
+  "model_max_length": 512,
+  "pad_to_multiple_of": null,
+  "pad_token": "<pad>",
+  "pad_token_type_id": 0,
+  "padding_side": "right",
+  "sep_token": "</s>",
+  "stride": 0,
+  "tokenizer_class": "XLMRobertaTokenizerFast",
+  "truncation_side": "right",
+  "truncation_strategy": "longest_first",
+  "unk_token": "<unk>"
+}

victord/sub19/models/bge-m3/1_Pooling/config.json

@@ -0,0 +1,10 @@
+{
+    "word_embedding_dimension": 1024,
+    "pooling_mode_cls_token": true,
+    "pooling_mode_mean_tokens": false,
+    "pooling_mode_max_tokens": false,
+    "pooling_mode_mean_sqrt_len_tokens": false,
+    "pooling_mode_weightedmean_tokens": false,
+    "pooling_mode_lasttoken": false,
+    "include_prompt": true
+}

victord/sub19/models/bge-m3/README.md

@@ -0,0 +1,300 @@
+---
+pipeline_tag: sentence-similarity
+tags:
+- sentence-transformers
+- feature-extraction
+- sentence-similarity
+license: mit
+---
+
+For more details please refer to our github repo: https://github.com/FlagOpen/FlagEmbedding
+
+# BGE-M3 ([paper](https://arxiv.org/pdf/2402.03216.pdf), [code](https://github.com/FlagOpen/FlagEmbedding/tree/master/FlagEmbedding/BGE_M3))
+
+In this project, we introduce BGE-M3, which is distinguished for its versatility in Multi-Functionality, Multi-Linguality, and Multi-Granularity. 
+- Multi-Functionality: It can simultaneously perform the three common retrieval functionalities of embedding model: dense retrieval, multi-vector retrieval, and sparse retrieval. 
+- Multi-Linguality: It can support more than 100 working languages. 
+- Multi-Granularity: It is able to process inputs of different granularities, spanning from short sentences to long documents of up to 8192 tokens. 
+
+
+
+**Some suggestions for retrieval pipeline in RAG**
+
+We recommend to use the following pipeline: hybrid retrieval + re-ranking. 
+- Hybrid retrieval leverages the strengths of various methods, offering higher accuracy and stronger generalization capabilities. 
+A classic example: using both embedding retrieval and the BM25 algorithm. 
+Now, you can try to use BGE-M3, which supports both embedding and sparse retrieval. 
+This allows you to obtain token weights (similar to the BM25) without any additional cost when generate dense embeddings.
+To use hybrid retrieval, you can refer to [Vespa](https://github.com/vespa-engine/pyvespa/blob/master/docs/sphinx/source/examples/mother-of-all-embedding-models-cloud.ipynb
+) and [Milvus](https://github.com/milvus-io/pymilvus/blob/master/examples/hello_hybrid_sparse_dense.py).
+
+- As cross-encoder models, re-ranker demonstrates higher accuracy than bi-encoder embedding model. 
+Utilizing the re-ranking model (e.g., [bge-reranker](https://github.com/FlagOpen/FlagEmbedding/tree/master/FlagEmbedding/reranker), [bge-reranker-v2](https://github.com/FlagOpen/FlagEmbedding/tree/master/FlagEmbedding/llm_reranker)) after retrieval can further filter the selected text.
+
+
+## News:
+- 2024/7/1: **We update the MIRACL evaluation results of BGE-M3**. To reproduce the new results, you can refer to: [bge-m3_miracl_2cr](https://huggingface.co/datasets/hanhainebula/bge-m3_miracl_2cr). We have also updated our [paper](https://arxiv.org/pdf/2402.03216) on arXiv.
+  <details>
+  <summary> Details </summary>
+
+  The previous test results were lower because we mistakenly removed the passages that have the same id as the query from the search results. After correcting this mistake, the overall performance of BGE-M3 on MIRACL is higher than the previous results, but the experimental conclusion remains unchanged. The other results are not affected by this mistake. To reproduce the previous lower results, you need to add the `--remove-query` parameter when using `pyserini.search.faiss` or `pyserini.search.lucene` to search the passages.
+
+  </details>
+- 2024/3/20: **Thanks Milvus team!** Now you can use hybrid retrieval of bge-m3 in Milvus: [pymilvus/examples
+/hello_hybrid_sparse_dense.py](https://github.com/milvus-io/pymilvus/blob/master/examples/hello_hybrid_sparse_dense.py).
+- 2024/3/8: **Thanks for the [experimental results](https://towardsdatascience.com/openai-vs-open-source-multilingual-embedding-models-e5ccb7c90f05) from @[Yannael](https://huggingface.co/Yannael). In this benchmark, BGE-M3 achieves top performance in both English and other languages, surpassing models such as OpenAI.**
+- 2024/3/2: Release unified fine-tuning [example](https://github.com/FlagOpen/FlagEmbedding/tree/master/examples/unified_finetune) and [data](https://huggingface.co/datasets/Shitao/bge-m3-data) 
+- 2024/2/6: We release the [MLDR](https://huggingface.co/datasets/Shitao/MLDR) (a long document retrieval dataset covering 13 languages) and [evaluation pipeline](https://github.com/FlagOpen/FlagEmbedding/tree/master/C_MTEB/MLDR). 
+- 2024/2/1: **Thanks for the excellent tool from Vespa.** You can easily use multiple modes of BGE-M3 following this [notebook](https://github.com/vespa-engine/pyvespa/blob/master/docs/sphinx/source/examples/mother-of-all-embedding-models-cloud.ipynb)
+
+
+## Specs
+
+- Model  
+
+| Model Name |  Dimension | Sequence Length | Introduction |
+|:----:|:---:|:---:|:---:|
+| [BAAI/bge-m3](https://huggingface.co/BAAI/bge-m3) | 1024 | 8192 | multilingual; unified fine-tuning (dense, sparse, and colbert) from bge-m3-unsupervised|
+| [BAAI/bge-m3-unsupervised](https://huggingface.co/BAAI/bge-m3-unsupervised) | 1024 | 8192 | multilingual; contrastive learning from bge-m3-retromae |
+| [BAAI/bge-m3-retromae](https://huggingface.co/BAAI/bge-m3-retromae) | -- | 8192 | multilingual; extend the max_length of [xlm-roberta](https://huggingface.co/FacebookAI/xlm-roberta-large) to 8192 and further pretrained via [retromae](https://github.com/staoxiao/RetroMAE)| 
+| [BAAI/bge-large-en-v1.5](https://huggingface.co/BAAI/bge-large-en-v1.5) | 1024 | 512 | English model | 
+| [BAAI/bge-base-en-v1.5](https://huggingface.co/BAAI/bge-base-en-v1.5) |  768 | 512 | English model | 
+| [BAAI/bge-small-en-v1.5](https://huggingface.co/BAAI/bge-small-en-v1.5) |  384 | 512 | English model | 
+
+- Data
+
+|                          Dataset                           |                   Introduction                    |
+|:----------------------------------------------------------:|:-------------------------------------------------:|
+|    [MLDR](https://huggingface.co/datasets/Shitao/MLDR)     | Docuemtn Retrieval Dataset, covering 13 languages |
+| [bge-m3-data](https://huggingface.co/datasets/Shitao/bge-m3-data) |          Fine-tuning data used by bge-m3          |
+
+
+
+## FAQ
+
+**1. Introduction for different retrieval methods**
+
+- Dense retrieval: map the text into a single embedding, e.g., [DPR](https://arxiv.org/abs/2004.04906), [BGE-v1.5](https://github.com/FlagOpen/FlagEmbedding)
+- Sparse retrieval (lexical matching): a vector of size equal to the vocabulary, with the majority of positions set to zero, calculating a weight only for tokens present in the text. e.g., BM25, [unicoil](https://arxiv.org/pdf/2106.14807.pdf), and [splade](https://arxiv.org/abs/2107.05720)
+- Multi-vector retrieval: use multiple vectors to represent a text, e.g., [ColBERT](https://arxiv.org/abs/2004.12832).
+
+
+**2. How to use BGE-M3 in other projects?**
+
+For embedding retrieval, you can employ the BGE-M3 model using the same approach as BGE. 
+The only difference is that the BGE-M3 model no longer requires adding instructions to the queries. 
+
+For hybrid retrieval, you can use [Vespa](https://github.com/vespa-engine/pyvespa/blob/master/docs/sphinx/source/examples/mother-of-all-embedding-models-cloud.ipynb
+) and [Milvus](https://github.com/milvus-io/pymilvus/blob/master/examples/hello_hybrid_sparse_dense.py).
+
+
+**3. How to fine-tune bge-M3 model?**
+
+You can follow the common in this [example](https://github.com/FlagOpen/FlagEmbedding/tree/master/examples/finetune) 
+to fine-tune the dense embedding.
+
+If you want to fine-tune all embedding function of m3 (dense, sparse and colbert), you can refer to the [unified_fine-tuning example](https://github.com/FlagOpen/FlagEmbedding/tree/master/examples/unified_finetune)
+
+
+
+
+
+
+## Usage
+
+Install: 
+```
+git clone https://github.com/FlagOpen/FlagEmbedding.git
+cd FlagEmbedding
+pip install -e .
+```
+or: 
+```
+pip install -U FlagEmbedding
+```
+
+
+
+### Generate Embedding for text
+
+- Dense Embedding
+```python
+from FlagEmbedding import BGEM3FlagModel
+
+model = BGEM3FlagModel('BAAI/bge-m3',  
+                       use_fp16=True) # Setting use_fp16 to True speeds up computation with a slight performance degradation
+
+sentences_1 = ["What is BGE M3?", "Defination of BM25"]
+sentences_2 = ["BGE M3 is an embedding model supporting dense retrieval, lexical matching and multi-vector interaction.", 
+               "BM25 is a bag-of-words retrieval function that ranks a set of documents based on the query terms appearing in each document"]
+
+embeddings_1 = model.encode(sentences_1, 
+                            batch_size=12, 
+                            max_length=8192, # If you don't need such a long length, you can set a smaller value to speed up the encoding process.
+                            )['dense_vecs']
+embeddings_2 = model.encode(sentences_2)['dense_vecs']
+similarity = embeddings_1 @ embeddings_2.T
+print(similarity)
+# [[0.6265, 0.3477], [0.3499, 0.678 ]]
+```
+You also can use sentence-transformers and huggingface transformers to generate dense embeddings.
+Refer to [baai_general_embedding](https://github.com/FlagOpen/FlagEmbedding/tree/master/FlagEmbedding/baai_general_embedding#usage) for details.
+
+
+- Sparse Embedding (Lexical Weight)
+```python
+from FlagEmbedding import BGEM3FlagModel
+
+model = BGEM3FlagModel('BAAI/bge-m3',  use_fp16=True) # Setting use_fp16 to True speeds up computation with a slight performance degradation
+
+sentences_1 = ["What is BGE M3?", "Defination of BM25"]
+sentences_2 = ["BGE M3 is an embedding model supporting dense retrieval, lexical matching and multi-vector interaction.", 
+               "BM25 is a bag-of-words retrieval function that ranks a set of documents based on the query terms appearing in each document"]
+
+output_1 = model.encode(sentences_1, return_dense=True, return_sparse=True, return_colbert_vecs=False)
+output_2 = model.encode(sentences_2, return_dense=True, return_sparse=True, return_colbert_vecs=False)
+
+# you can see the weight for each token:
+print(model.convert_id_to_token(output_1['lexical_weights']))
+# [{'What': 0.08356, 'is': 0.0814, 'B': 0.1296, 'GE': 0.252, 'M': 0.1702, '3': 0.2695, '?': 0.04092}, 
+#  {'De': 0.05005, 'fin': 0.1368, 'ation': 0.04498, 'of': 0.0633, 'BM': 0.2515, '25': 0.3335}]
+
+
+# compute the scores via lexical mathcing
+lexical_scores = model.compute_lexical_matching_score(output_1['lexical_weights'][0], output_2['lexical_weights'][0])
+print(lexical_scores)
+# 0.19554901123046875
+
+print(model.compute_lexical_matching_score(output_1['lexical_weights'][0], output_1['lexical_weights'][1]))
+# 0.0
+```
+
+- Multi-Vector (ColBERT)
+```python
+from FlagEmbedding import BGEM3FlagModel
+
+model = BGEM3FlagModel('BAAI/bge-m3',  use_fp16=True) 
+
+sentences_1 = ["What is BGE M3?", "Defination of BM25"]
+sentences_2 = ["BGE M3 is an embedding model supporting dense retrieval, lexical matching and multi-vector interaction.", 
+               "BM25 is a bag-of-words retrieval function that ranks a set of documents based on the query terms appearing in each document"]
+
+output_1 = model.encode(sentences_1, return_dense=True, return_sparse=True, return_colbert_vecs=True)
+output_2 = model.encode(sentences_2, return_dense=True, return_sparse=True, return_colbert_vecs=True)
+
+print(model.colbert_score(output_1['colbert_vecs'][0], output_2['colbert_vecs'][0]))
+print(model.colbert_score(output_1['colbert_vecs'][0], output_2['colbert_vecs'][1]))
+# 0.7797
+# 0.4620
+```
+
+
+### Compute score for text pairs
+Input a list of text pairs, you can get the scores computed by different methods.
+```python
+from FlagEmbedding import BGEM3FlagModel
+
+model = BGEM3FlagModel('BAAI/bge-m3',  use_fp16=True) 
+
+sentences_1 = ["What is BGE M3?", "Defination of BM25"]
+sentences_2 = ["BGE M3 is an embedding model supporting dense retrieval, lexical matching and multi-vector interaction.", 
+               "BM25 is a bag-of-words retrieval function that ranks a set of documents based on the query terms appearing in each document"]
+
+sentence_pairs = [[i,j] for i in sentences_1 for j in sentences_2]
+
+print(model.compute_score(sentence_pairs, 
+                          max_passage_length=128, # a smaller max length leads to a lower latency
+                          weights_for_different_modes=[0.4, 0.2, 0.4])) # weights_for_different_modes(w) is used to do weighted sum: w[0]*dense_score + w[1]*sparse_score + w[2]*colbert_score
+
+# {
+#   'colbert': [0.7796499729156494, 0.4621465802192688, 0.4523794651031494, 0.7898575067520142], 
+#   'sparse': [0.195556640625, 0.00879669189453125, 0.0, 0.1802978515625], 
+#   'dense': [0.6259765625, 0.347412109375, 0.349853515625, 0.67822265625], 
+#   'sparse+dense': [0.482503205537796, 0.23454029858112335, 0.2332356721162796, 0.5122477412223816], 
+#   'colbert+sparse+dense': [0.6013619303703308, 0.3255828022956848, 0.32089319825172424, 0.6232916116714478]
+# }
+```
+
+
+
+
+## Evaluation  
+
+We provide the evaluation script for [MKQA](https://github.com/FlagOpen/FlagEmbedding/tree/master/C_MTEB/MKQA) and [MLDR](https://github.com/FlagOpen/FlagEmbedding/tree/master/C_MTEB/MLDR)
+
+### Benchmarks from the open-source community
+  ![avatar](./imgs/others.webp)
+ The BGE-M3 model emerged as the top performer on this benchmark (OAI is short for OpenAI). 
+  For more details, please refer to the [article](https://towardsdatascience.com/openai-vs-open-source-multilingual-embedding-models-e5ccb7c90f05) and [Github Repo](https://github.com/Yannael/multilingual-embeddings)
+
+
+### Our results
+- Multilingual (Miracl dataset) 
+
+![avatar](./imgs/miracl.jpg)
+
+- Cross-lingual (MKQA dataset)
+
+![avatar](./imgs/mkqa.jpg)
+
+- Long Document Retrieval
+  - MLDR:   
+  ![avatar](./imgs/long.jpg)
+  Please note that [MLDR](https://huggingface.co/datasets/Shitao/MLDR) is a document retrieval dataset we constructed via LLM, 
+  covering 13 languages, including test set, validation set, and training set. 
+  We utilized the training set from MLDR to enhance the model's long document retrieval capabilities. 
+  Therefore, comparing baselines with `Dense w.o.long`(fine-tuning without long document dataset) is more equitable. 
+  Additionally, this long document retrieval dataset will be open-sourced to address the current lack of open-source multilingual long text retrieval datasets.
+  We believe that this data will be helpful for the open-source community in training document retrieval models.
+
+  - NarritiveQA:  
+  ![avatar](./imgs/nqa.jpg)
+
+- Comparison with BM25  
+
+We utilized Pyserini to implement BM25, and the test results can be reproduced by this [script](https://github.com/FlagOpen/FlagEmbedding/tree/master/C_MTEB/MLDR#bm25-baseline).
+We tested BM25 using two different tokenizers: 
+one using Lucene Analyzer and the other using the same tokenizer as M3 (i.e., the tokenizer of xlm-roberta). 
+The results indicate that BM25 remains a competitive baseline, 
+especially in long document retrieval.
+
+![avatar](./imgs/bm25.jpg)
+
+
+
+## Training
+- Self-knowledge Distillation: combining multiple outputs from different 
+retrieval modes as reward signal to enhance the performance of single mode(especially for sparse retrieval and multi-vec(colbert) retrival)
+- Efficient Batching: Improve the efficiency when fine-tuning on long text. 
+The small-batch strategy is simple but effective, which also can used to fine-tune large embedding model.
+- MCLS: A simple method to improve the performance on long text without fine-tuning. 
+If you have no enough resource to fine-tuning model with long text, the method is useful.
+
+Refer to our [report](https://arxiv.org/pdf/2402.03216.pdf) for more details. 
+
+
+
+
+
+
+## Acknowledgement
+
+Thanks to the authors of open-sourced datasets, including Miracl, MKQA, NarritiveQA, etc. 
+Thanks to the open-sourced libraries like [Tevatron](https://github.com/texttron/tevatron), [Pyserini](https://github.com/castorini/pyserini).
+
+
+
+## Citation
+
+If you find this repository useful, please consider giving a star :star: and citation
+
+```
+@misc{bge-m3,
+      title={BGE M3-Embedding: Multi-Lingual, Multi-Functionality, Multi-Granularity Text Embeddings Through Self-Knowledge Distillation}, 
+      author={Jianlv Chen and Shitao Xiao and Peitian Zhang and Kun Luo and Defu Lian and Zheng Liu},
+      year={2024},
+      eprint={2402.03216},
+      archivePrefix={arXiv},
+      primaryClass={cs.CL}
+}
+```

victord/sub19/models/bge-m3/config.json

@@ -0,0 +1,27 @@
+{
+  "architectures": [
+    "XLMRobertaModel"
+  ],
+  "attention_probs_dropout_prob": 0.1,
+  "bos_token_id": 0,
+  "classifier_dropout": null,
+  "eos_token_id": 2,
+  "hidden_act": "gelu",
+  "hidden_dropout_prob": 0.1,
+  "hidden_size": 1024,
+  "initializer_range": 0.02,
+  "intermediate_size": 4096,
+  "layer_norm_eps": 1e-05,
+  "max_position_embeddings": 8194,
+  "model_type": "xlm-roberta",
+  "num_attention_heads": 16,
+  "num_hidden_layers": 24,
+  "output_past": true,
+  "pad_token_id": 1,
+  "position_embedding_type": "absolute",
+  "torch_dtype": "bfloat16",
+  "transformers_version": "4.53.2",
+  "type_vocab_size": 1,
+  "use_cache": true,
+  "vocab_size": 250002
+}

victord/sub19/models/bge-m3/config_sentence_transformers.json

@@ -0,0 +1,14 @@
+{
+  "__version__": {
+    "sentence_transformers": "5.1.1",
+    "transformers": "4.53.2",
+    "pytorch": "2.9.0+cu128"
+  },
+  "model_type": "SentenceTransformer",
+  "prompts": {
+    "query": "",
+    "document": ""
+  },
+  "default_prompt_name": null,
+  "similarity_fn_name": "cosine"
+}

victord/sub19/models/bge-m3/model.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ebd7cf4fcc1a794f73ea3213266a7bd44e995eac0751b6e98ec9bb91cfc57202
+size 1135554736

victord/sub19/models/bge-m3/modules.json

@@ -0,0 +1,20 @@
+[
+  {
+    "idx": 0,
+    "name": "0",
+    "path": "",
+    "type": "sentence_transformers.models.Transformer"
+  },
+  {
+    "idx": 1,
+    "name": "1",
+    "path": "1_Pooling",
+    "type": "sentence_transformers.models.Pooling"
+  },
+  {
+    "idx": 2,
+    "name": "2",
+    "path": "2_Normalize",
+    "type": "sentence_transformers.models.Normalize"
+  }
+]

victord/sub19/models/bge-m3/sentence_bert_config.json

@@ -0,0 +1,4 @@
+{
+    "max_seq_length": 8192,
+    "do_lower_case": false
+}

victord/sub19/models/bge-m3/sentencepiece.bpe.model

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cfc8146abe2a0488e9e2a0c56de7952f7c11ab059eca145a0a727afce0db2865
+size 5069051

victord/sub19/models/bge-m3/special_tokens_map.json

@@ -0,0 +1,51 @@
+{
+  "bos_token": {
+    "content": "<s>",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  },
+  "cls_token": {
+    "content": "<s>",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  },
+  "eos_token": {
+    "content": "</s>",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  },
+  "mask_token": {
+    "content": "<mask>",
+    "lstrip": true,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  },
+  "pad_token": {
+    "content": "<pad>",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  },
+  "sep_token": {
+    "content": "</s>",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  },
+  "unk_token": {
+    "content": "<unk>",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  }
+}

victord/sub19/models/bge-m3/tokenizer.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:249df0778f236f6ece390de0de746838ef25b9d6954b68c2ee71249e0a9d8fd4
+size 17082799

victord/sub19/models/bge-m3/tokenizer_config.json

@@ -0,0 +1,56 @@
+{
+  "added_tokens_decoder": {
+    "0": {
+      "content": "<s>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "1": {
+      "content": "<pad>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "2": {
+      "content": "</s>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "3": {
+      "content": "<unk>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "250001": {
+      "content": "<mask>",
+      "lstrip": true,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    }
+  },
+  "bos_token": "<s>",
+  "clean_up_tokenization_spaces": true,
+  "cls_token": "<s>",
+  "eos_token": "</s>",
+  "extra_special_tokens": {},
+  "mask_token": "<mask>",
+  "model_max_length": 8192,
+  "pad_token": "<pad>",
+  "sep_token": "</s>",
+  "sp_model_kwargs": {},
+  "tokenizer_class": "XLMRobertaTokenizer",
+  "unk_token": "<unk>"
+}

victord/sub19/models/bge-reranker-v2-m3_pseudo_tune_full/README.md

@@ -0,0 +1,503 @@
+---
+tags:
+- sentence-transformers
+- cross-encoder
+- reranker
+- generated_from_trainer
+- dataset_size:175622
+- loss:BinaryCrossEntropyLoss
+base_model: BAAI/bge-reranker-v2-m3
+pipeline_tag: text-ranking
+library_name: sentence-transformers
+metrics:
+- pearson
+- spearman
+model-index:
+- name: CrossEncoder based on BAAI/bge-reranker-v2-m3
+  results:
+  - task:
+      type: cross-encoder-correlation
+      name: Cross Encoder Correlation
+    dataset:
+      name: sts dev
+      type: sts_dev
+    metrics:
+    - type: pearson
+      value: 0.5543320589612747
+      name: Pearson
+    - type: spearman
+      value: 0.5369237805280626
+      name: Spearman
+---
+
+# CrossEncoder based on BAAI/bge-reranker-v2-m3
+
+This is a [Cross Encoder](https://www.sbert.net/docs/cross_encoder/usage/usage.html) model finetuned from [BAAI/bge-reranker-v2-m3](https://huggingface.co/BAAI/bge-reranker-v2-m3) on the train_dataset, HebNLI, HebQA, RAGbot and ParaShoot datasets using the [sentence-transformers](https://www.SBERT.net) library. It computes scores for pairs of texts, which can be used for text reranking and semantic search.
+
+## Model Details
+
+### Model Description
+- **Model Type:** Cross Encoder
+- **Base model:** [BAAI/bge-reranker-v2-m3](https://huggingface.co/BAAI/bge-reranker-v2-m3) <!-- at revision 953dc6f6f85a1b2dbfca4c34a2796e7dde08d41e -->
+- **Maximum Sequence Length:** 2048 tokens
+- **Number of Output Labels:** 1 label
+- **Training Datasets:**
+    - train_dataset
+    - HebNLI
+    - HebQA
+    - RAGbot
+    - ParaShoot
+<!-- - **Language:** Unknown -->
+<!-- - **License:** Unknown -->
+
+### Model Sources
+
+- **Documentation:** [Sentence Transformers Documentation](https://sbert.net)
+- **Documentation:** [Cross Encoder Documentation](https://www.sbert.net/docs/cross_encoder/usage/usage.html)
+- **Repository:** [Sentence Transformers on GitHub](https://github.com/huggingface/sentence-transformers)
+- **Hugging Face:** [Cross Encoders on Hugging Face](https://huggingface.co/models?library=sentence-transformers&other=cross-encoder)
+
+## Usage
+
+### Direct Usage (Sentence Transformers)
+
+First install the Sentence Transformers library:
+
+```bash
+pip install -U sentence-transformers
+```
+
+Then you can load this model and run inference.
+```python
+from sentence_transformers import CrossEncoder
+
+# Download from the 🤗 Hub
+model = CrossEncoder("cross_encoder_model_id")
+# Get scores for pairs of texts
+pairs = [
+    ['מה התשלום עבור דרגה X במעון או משפחתון?\n מה הזכאות עבור ילד נוסף במסגרת מעון או משפחתון?', 'דרגות השתתפות במימון מעונות יום ומשפחתונים\n \nגובה שכר הלימוד\nסכומי השתתפות המדינה והסכומים אותם משלימים ההורים עבור כל אחת מהדרגות, מפורטים בטבלאות שכר לימוד.\nהטבלאות מחולקות לפי תעריפים לילדים ותעריפים לתינוקות:\n\nגובה שכר הלימוד בהתאם לדרגות השונות מפורטת בטבלאות שכר לימוד במסגרות ילדים באתר משרד העבודה.\nהדרגות המופיעות בטבלאות מותאמות לגובה ההכנסה לנפש במשפחה.\nככל שדרגת הזכאות (בטווח 12-3) נמוכה יותר, כך גדלה השתתפות המדינה בתשלום.\nעבור רמות ההשתתפות המותאמות לגובה ההכנסות, יש להוסיף או להפחית דרגות, על-פי מספר מספר הילדים השוהים במעון או במשפחתון - למשפחה עם כמה ילדים השוהים במעון או במשפחתון, תוגדל רמת השתתפות המדינה עבור כל אחד מהילדים (תיקבע דרגה נמוכה יותר בין הדרגות 12-3).\nתינוקות הם מי שגילם היה עד 15 חודשים ב-1 בספטמבר של שנת הלימודים אליה נרשמו.\nילדים הם מי שב-1 בספטמבר של שנת הלימודים אליה נרשמו, גילם היה בין 15 חודשים ויום ל-33 חודשים (או עד לגיל 46 חודשים, למי שיש להם אישור מהיחידה להתפתחות הילד כי הם מעוכבי התפתחות).\n\nהשפעת מספר הילדים השוהים במעון/משפחתון על דרגת ההשתתפות\nדרגה בהתאם לרמת הכנסה\n: 3\nמספר הילדים\nהזכאים במשפחה \n\n: 2\nהדרגה הסופית\nהמותאמת \n\n: 14\n\nהשפעת מספר הילדים השוהים במעון/משפחתון על דרגת ההשתתפות\nדרגה בהתאם לרמת הכנסה\n: 3\nמספר הילדים\nהזכאים במשפחה \n\n: 3 ומעלה\nהדרגה הסופית\nהמותאמת \n\n: 15\nהשפעת מספר הילדים השוהים במעון/משפחתון על דרגת ההשתתפות\n\n\nדרגה בהתאם לרמת הכנסה\n\nמספר הילדים\nהזכאים במשפחה \n\n\nהדרגה הס��פית\nהמותאמת \n\n\n\n3\n2\n14\n\n\n3\n3 ומעלה\n15'],
+    ['מה התשלום עבור דרגה X במעון או משפחתון?\n מה הזכאות עבור ילד נוסף במסגרת מעון או משפחתון?', 'סיוע להורים עצמאיים (הורים יחידים) במימון מעונות יום ומשפחתונים\n \nהורים עצמאיים (הורים יחידים) (/he/הורה_עצמאי_(הורה_יחיד)) עשויים להיות זכאים לסיוע במימון מעונות יום ומשפחתונים לפי דרגות השתתפות (/he/דרגות_השתתפות_במימון_מעונות_יום_ומשפחתונים) שנקבעות בהתאם לרמת ההכנסה שלהם (/he/רמת_ההכנסה_לנפש_לצורך_סיוע_במימון_מעונות_יום)\n\n\n \nהורים עצמאיים שעונים על הגדרת מגבירי עבודה (.D7.96.D7.9B.D7.90.D7.95.D7.AA_.D7.A9.D7.9C_.D7.94.D7.95.D7.A8.D7.99.D7.9D_.D7.9E.D7.92.D7.91.D7.99.D7.A8.D7.99_.D7.A2.D7.91.D7.95.D7.93.D7.94) זכאים לסיוע מוגדל וישלמו 250 בחודש לילד אחד ו-375 בחודש לשני ילדים\nכדי להקל על שילובם של הורים בשוק העבודה, המדינה מסייעת להם במימון מעונות יום ומשפחתונים מוכרים.\n\nגובה התמיכה בזכאות הכללית של ההורים (זוגות הורים או הורים עצמאיים) נקבע על-פי מספר דרגות השתתפות המתבססות על רמת ההכנסה לנפש במשפחה.\nהורים עצמאיים (הורים יחידים) שעונים על הגדרת "מגבירי עבודה" (בהתאם למפורט בהמשך), זכאים לסיוע מוגדל וישלמו רק 250 ₪ בחודש עבור ילד אחד ו-375 ₪ בחודש עבור שני ילדים.\nלפרטים ומידע כללי על הזכות, ראו השתתפות במימון מעונות יום ומשפחתונים.'],
+    ['מה התשלום עבור דרגה X במעון או משפחתון?\n מה הזכאות עבור ילד נוסף במסגרת מעון או משפחתון?', 'השתתפות במימון מעונות יום ומשפחתונים\n תהליך מימוש הזכות\nאיתור מסגרת מוכרת\nמערכת אינטרנטית (מקוונת) מאפשרת לאתר משפחתונים, מעונות וצהרונים הנמצאים בפיקוח ממשלתי.\nניתן לבצע חיפוש לפי ישוב, סוג המסגרת או שם המסגרת. לכניסה למערכת לחצו כאן.\n\nהתשלום למעון/משפחתון\nעבור חודש אוגוסט יחושב תשלום באופן יחסי בהתאם לתקופת שהות הילד במעון (העלות המלאה לחודש כפול מספר החודשים שהילד שהה במעון חלקי 12 חודשים).\nהחזר כספי בהתאם לדרגת ההשתתפות, יינתן להורים עבור החודש שבו התקבל שאלון ההרשמה במוקד, ועבור החודש שקדם לו.\nהשתתפות בחודש הראשון לכניסת הילד למסגרת (מעון או משפחתון):\n\nהוריו של ילד שנכנס למסגרת עד ל-15 בחודש (כולל ה-15 לחודש), יהיו זכאים להשתתפות המדינה עבור אותו חודש (על-פי הדרגה שנקבעה להם).\nהוריו של ילד שנכנס למסגרת לאחר ה-15 לחודש, לא יהיו זכאים להשתתפות בחודש זה. במקרה זה יחויבו ההורים לשלם דמי החזקה באופן יחסי לימים בהם שהה הילד במסגרת.\n\nהיעדרות של הילד\nהיעדרות מהמעון לתקופה של יותר מ-21 ימים תיחשב כעזיבה, אלא אם כן הוצגו במהלך תקופה זו אישורים רפואיים על מחלה או אשפוז של הילד.\nהיעדרות של 45 ימים ומעלה בשל אשפוז או מחלה, תיחשב כעזיבה החל מהיום ה-45. חזרה של ילד למעון לאחר מכן, תחייב את ההורה להגיש בקשה חדשה לקביעת דרגת ההשתתפות בצירוף מסמכים עדכניים.\n\nשינוי בתנאי הזכאות\nהזכאות נמשכת כל עוד מתקיימים התנאים המזכים.\nבמקרה שחל שינוי בתנאים - ההורים חייבים למסור על כך הודעה בכתב לאגף מעונות יום ומשפחתונים, לא יאוחר מ-30 יום ממועד השינוי.\n\nבמהלך שנת לימודים, יתכן שיידרשו מההורים נתוני הכנסה מעודכנים כתנאי להמשך תשלום התמיכה.\nגובה התמיכה יעודכן, כלפי מעלה או מטה, על בסיס הנתונים החדשים.\nאת העדכון יש לבצע באמצעות מערכת עדכונט באתר משרד העבודה. ניתן גם להיעזר במוקד מעונות יום, משפחתונים וצהרונים, בטלפון *2969.'],
+    ['מה התשלום עבור דרגה X במעון או משפחתון?\n מה הזכאות עבור ילד נוסף במסגרת מעון או משפחתון?', 'מדריך למי שפונו או התפנו מבתיהם עקב מלחמת חרבות ברזל\n Metadata\nמענק למעונות יום ומשפחתונים שלא גבו כסף מההורים או החזירו חלק מהתשלום להורים\nמעונות יום ומשפחתונים בעלי סמל, שבהתאם להנחיות פיקוד העורף, לא פעלו במהלך חודש אוקטובר או שפעלו באופן חלקי בלבד, זכאים למענק סיוע חד-פעמי בגין הימים שבהם לא פעלו.\nהמענק יינתן בתנאי שלא גבו מההורים תשלום עבור הימים שבהם לא היתה פעילות, ואם היתה פעילות חלקית - הם השיבו להורים את החלק היחסי מהתשלום.\nגובה המענק הוא 889 ₪ עבור כל ילד במעון.\nלא ניתן לקבל גם מענק ממשרד העבודה וגם פיצוי מרשות המסים. מעון או משפחתון שקיבל מענק ממשרד העבודה והגיש תביעה לפיצוי מרשות המסים, סכום המענק יופחת מגובה הפיצוי שיקבל מרשות המסים.\nלמידע נוסף ראו מענק למעונות ומשפחתונים מוכרים בתקופת מלחמת חרבות ברזל'],
+    ['מה התשלום עבור דרגה X במעון או משפחתון?\n מה הזכאות עבור ילד נוסף במסגרת מעון או משפחתון?', 'מדריך הורות משותפת\n מענקים וקצבאות\n\n\nמיקום הילד/ה במשפחה\nסכום הקצבה עבור הילד/ה (נכון ל-2024)\n\n\nילד ראשון\n169 ₪\n\n\nילד שני\n214 ₪\n\n\nילד שלישי\n214 ₪ (+ 111 ₪ להורים שמקבלים קצבאות קיום)\n\n\nילד רביעי\n214 ₪  (+ 111 ₪ להורים שמקבלים קצבאות קיום)\n\n\nילד חמישי ואילך\n169 ₪\n\nלשיעורי הקצבה בשנים הקודמות ראו באתר המוסד לביטוח לאומי.\nלמידע נוסף ראו קצבת ילדים.\n\nמעונות יום\nקדימות בקבלה\nהורים העונים על קריטריונים שונים, עשויים להיות זכאים לקדימות בקבלה למעונות היום שנמצאים באחריות משרד הרווחה.\nבין הקריטריונים נמצאים "הורים עצמאים", הכוללים הורה לא נשוי ושאין לו ידוע בציבור, למשל, אישה בהורות משותפת.\nמעונות יום\nהשתתפות במימון\nכדי לעודד את שילובם של הורים בשוק העבודה, המדינה מסייעת במימון מעונות יום ומשפחתונים מוכרים. גובה הסיוע ניתן בהתאם לרמת ההכנסה.\nלמידע נוסף ראו השתתפות במימון מעונות יום ומשפחתונים.'],
+]
+scores = model.predict(pairs)
+print(scores.shape)
+# (5,)
+
+# Or rank different texts based on similarity to a single text
+ranks = model.rank(
+    'מה התשלום עבור דרגה X במעון או משפחתון?\n מה הזכאות עבור ילד נוסף במסגרת מעון או משפחתון?',
+    [
+        'דרגות השתתפות במימון מעונות יום ומשפחתונים\n \nגובה שכר הלימוד\nסכומי השתתפות המדינה והסכומים אותם משלימים ההורים עבור כל אחת מהדרגות, מפורטים בטבלאות שכר לימוד.\nהטבלאות מחולקות לפי תעריפים לילדים ותעריפים לתינוקות:\n\nגובה שכר הלימוד בהתאם לדרגות השונות מפורטת בטבלאות שכר לימוד במסגרות ילדים באתר משרד העבודה.\nהדרגות המופיעות בטבלאות מותאמות לגובה ההכנסה לנפש במשפחה.\nככל שדרגת הזכאות (בטווח 12-3) נמוכה יותר, כך גדלה השתתפות המדינה בתשלום.\nעבור רמות ההשתתפות המותאמות לגובה ההכנסות, יש להוסיף או להפחית דרגות, על-פי מספר מספר הילדים השוהים במעון או במשפחתון - למשפחה עם כמה ילדים השוהים במעון או במשפחתון, תוגדל רמת השתתפות המדינה עבור כל אחד מהילדים (תיקבע דרגה נמוכה יותר בין הדרגות 12-3).\nתינוקות הם מי שגילם היה עד 15 חודשים ב-1 בספטמבר של שנת הלימודים אליה נרשמו.\nילדים הם מי שב-1 בספטמבר של שנת הלימודים אליה נרשמו, גילם היה בין 15 חודשים ויום ל-33 חודשים (או עד לגיל 46 חודשים, למי שיש להם אישור מהיחידה להתפתחות הילד כי הם מעוכבי התפתחות).\n\nהשפעת מספר הילדים השוהים במעון/משפחתון על דרגת ההשתתפות\nדרגה בהתאם לרמת הכנסה\n: 3\nמספר הילדים\nהזכאים במשפחה \n\n: 2\nהדרגה הסופית\nהמותאמת \n\n: 14\n\nהשפעת מספר הילדים השוהים במעון/משפחתון על דרגת ההשתתפות\nדרגה בהתאם לרמת הכנסה\n: 3\nמספר הילדים\nהזכאים במשפחה \n\n: 3 ומעלה\nהדרגה הסופית\nהמותאמת \n\n: 15\nהשפעת מספר הילדים השוהים במעון/משפחתון על דרגת ההשתתפות\n\n\nדרגה בהתאם לרמת הכנסה\n\nמספר הילדים\nהזכאים במשפחה \n\n\nהדרגה הסופית\nהמותאמת \n\n\n\n3\n2\n14\n\n\n3\n3 ומעלה\n15',
+        'סיוע להורים עצמאיים (הורים יחידים) במימון מעונות יום ומשפחתונים\n \nהורים עצמאיים (הורים יחידים) (/he/הורה_עצמאי_(הורה_יחיד)) עשויים להיות זכאים לסיוע במימון מעונות יום ומשפחתונים לפי דרגות השתתפות (/he/דרגות_השתתפות_במימון_מעונות_יום_ומשפחתונים) שנקבעות בהתאם לרמת ההכנסה שלהם (/he/רמת_ההכנסה_לנפש_לצורך_סיוע_במימון_מעונות_יום)\n\n\n \nהורים עצמאיים שעונים על הגדרת מגבירי עבודה (.D7.96.D7.9B.D7.90.D7.95.D7.AA_.D7.A9.D7.9C_.D7.94.D7.95.D7.A8.D7.99.D7.9D_.D7.9E.D7.92.D7.91.D7.99.D7.A8.D7.99_.D7.A2.D7.91.D7.95.D7.93.D7.94) זכאים לסיוע מוגדל וישלמו 250 בחודש לילד אחד ו-375 בחודש לשני ילדים\nכדי להקל על שילובם של הורים בשוק העבודה, המדינה מסייעת להם במימון מעונות יום ומשפחתונים מוכרים.\n\nגובה התמיכה בזכאות הכללית של ההורים (זוגות הורים או הורים עצמאיים) נקבע על-פי מספר דרגות השתתפות המתבססות על רמת ההכנסה לנפש במשפחה.\nהורים עצמאיים (הורים יחידים) שעונים על הגדרת "מגבירי עבודה" (בהתאם למפורט בהמשך), זכאים לסיוע מוגדל וישלמו רק 250 ₪ בחודש עבור ילד אחד ו-375 ₪ בחודש עבור שני ילדים.\nלפרטים ומידע כללי על הזכות, ראו השתתפות במימון מעונות יום ומשפחתונים.',
+        'השתתפות במימון מעונות יום ומשפחתונים\n תהליך מימוש הזכות\nאיתור מסגרת מוכרת\nמערכת אינטרנטית (מקוונת) מאפשרת לאתר משפחתונים, מעונות וצהרונים הנמצאים בפיקוח ממשלתי.\nניתן לבצע חיפוש לפי ישוב, סוג המסגרת או שם המסגרת. לכניסה למערכת לחצו כאן.\n\nהתשלום למעון/משפחתון\nעבור חודש אוגוסט יחושב תשלום באופן יחסי בהתאם לתקופת שהות הילד במעון (העלות המלאה לחודש כפול מספר החודשים שהילד שהה במעון חלקי 12 חודשים).\nהחזר כספי בהתאם לדרגת ההשתתפות, יינתן להורים עבור החודש שבו התקבל שאלון ההרשמה במוקד, ועבור החודש שקדם לו.\nהשתתפות בחודש הראשון לכניסת הילד למסגרת (מעון או משפחתון):\n\nהוריו של ילד שנכנס למסגרת עד ל-15 בחודש (כולל ה-15 לחודש), יהיו זכאים להשתתפות המדינה עבור אותו חודש (על-פי הדרגה שנקבעה להם).\nהוריו של ילד שנכנס למסגרת לאחר ה-15 לחודש, לא יהיו זכאים להשתתפות בחודש זה. במקרה זה יחויבו ההורים לשלם דמי החזקה באופן יחסי לימים בהם שהה הילד במסגרת.\n\nהיעדרות של הילד\nהיעדרות מהמעון לתקופה של יותר מ-21 ימים תיחשב כעזיבה, אלא אם כן הוצגו במהלך תקופה זו אישורים רפואיים על מחלה או אשפוז של הילד.\nהיעדרות של 45 ימים ומעלה בשל אשפוז או מחלה, תיחשב כעזיבה החל מהיום ה-45. חזרה של ילד למעון לאחר מכן, תחייב את ההורה להגיש בקשה חדשה לקביעת דרגת ההשתתפות בצירוף מסמכים עדכניים.\n\nשינוי בתנאי הזכאות\nהזכאות נמשכת כל עוד מתקיימים התנאים המזכים.\nבמקרה שחל שינוי בתנאים - ההורים חייבים למסור על כך הודעה בכתב לאגף מעונות יום ומשפחתונים, לא יאוחר מ-30 יום ממועד השינוי.\n\nבמהלך שנת לימודים, יתכן שיידרשו מההורים נתוני הכנסה מעודכנים כתנאי להמשך תשלום התמיכה.\nגובה התמיכה יעודכן, כלפי מעלה או מטה, על בסיס הנתונים החדשים.\nאת העדכון יש לבצע באמצעות מערכת עדכונט באתר משרד העבודה. ניתן גם להיעזר במוקד מעונות יום, משפחתונים וצהרונים, בטלפון *2969.',
+        'מדריך למי שפונו או התפנו מבתיהם עקב מלחמת חרבות ברזל\n Metadata\nמענק למעונות יום ומשפחתונים שלא גבו כסף מההורים או החזירו חלק מהתשלום להורים\nמעונות יום ומשפחתונים בעלי סמל, שבהתאם להנחיות פיקוד העורף, לא פעלו במהלך חודש אוקטובר או שפעלו באופן חלקי בלבד, זכאים למענק סיוע חד-פעמי בגין הימים שבהם לא פעלו.\nהמענק יינתן בתנאי שלא גבו מההורים תשלום עבור הימים שבהם לא היתה פעילות, ואם היתה פעילות חלקית - הם השיבו להורים את החלק היחסי מהתשלום.\nגובה המענק הוא 889 ₪ עבור כל ילד במעון.\nלא ניתן לקבל גם מענק ממשרד העבודה וגם פיצוי מרשות המסים. מעון או משפחתון שקיבל מענק ממשרד העבודה והגיש תביעה לפיצוי מרשות המסים, סכום המענק יופחת מגובה הפיצוי שיקבל מרשות המסים.\nלמידע נוסף ראו מענק למעונות ומשפחתונים מוכרים בתקופת מלחמת חרבות ברזל',
+        'מדריך הורות משותפת\n מענקים וקצבאות\n\n\nמיקום הילד/ה במשפחה\nסכום הקצבה עבור הילד/ה (נכון ל-2024)\n\n\nילד ראשון\n169 ₪\n\n\nילד שני\n214 ₪\n\n\nילד שלישי\n214 ₪ (+ 111 ₪ להורים שמקבלים קצבאות קיום)\n\n\nילד רביעי\n214 ₪  (+ 111 ₪ להורים שמקבלים קצבאות קיום)\n\n\nילד חמישי ואילך\n169 ₪\n\nלשיעורי הקצבה בשנים הקודמות ראו באתר המוסד לביטוח לאומי.\nלמידע נוסף ראו קצבת ילדים.\n\nמעונות יום\nקדימות בקבלה\nהורים העונים על קריטריונים שונים, עשויים להיות זכאים לקדימות בקבלה למעונות היום שנמצאים באחריות משרד הרווחה.\nבין הקריטריונים נמצאים "הורים עצמאים", הכוללים הורה לא נשוי ושאין לו ידוע בציבור, למשל, אישה בהורות משותפת.\nמעונות יום\nהשתתפות במימון\nכדי לעודד את שילובם של הורים בשוק העבודה, המדינה מסייעת במימון מעונות יום ומשפחתונים מוכרים. גובה הסיוע ניתן בהתאם לרמת ההכנסה.\nלמידע נוסף ראו השתתפות במימון מעונות יום ומשפחתונים.',
+    ]
+)
+# [{'corpus_id': ..., 'score': ...}, {'corpus_id': ..., 'score': ...}, ...]
+```
+
+<!--
+### Direct Usage (Transformers)
+
+<details><summary>Click to see the direct usage in Transformers</summary>
+
+</details>
+-->
+
+<!--
+### Downstream Usage (Sentence Transformers)
+
+You can finetune this model on your own dataset.
+
+<details><summary>Click to expand</summary>
+
+</details>
+-->
+
+<!--
+### Out-of-Scope Use
+
+*List how the model may foreseeably be misused and address what users ought not to do with the model.*
+-->
+
+## Evaluation
+
+### Metrics
+
+#### Cross Encoder Correlation
+
+* Dataset: `sts_dev`
+* Evaluated with [<code>CrossEncoderCorrelationEvaluator</code>](https://sbert.net/docs/package_reference/cross_encoder/evaluation.html#sentence_transformers.cross_encoder.evaluation.CrossEncoderCorrelationEvaluator)
+
+| Metric       | Value      |
+|:-------------|:-----------|
+| pearson      | 0.5543     |
+| **spearman** | **0.5369** |
+
+<!--
+## Bias, Risks and Limitations
+
+*What are the known or foreseeable issues stemming from this model? You could also flag here known failure cases or weaknesses of the model.*
+-->
+
+<!--
+### Recommendations
+
+*What are recommendations with respect to the foreseeable issues? For example, filtering explicit content.*
+-->
+
+## Training Details
+
+### Training Datasets
+<details><summary>train_dataset</summary>
+
+#### train_dataset
+
+* Dataset: train_dataset
+* Size: 40,680 training samples
+* Columns: <code>sentence1</code>, <code>sentence2</code>, and <code>score</code>
+* Approximate statistics based on the first 1000 samples:
+  |         | sentence1                                                                                       | sentence2                                                                                          | score                                                          |
+  |:--------|:------------------------------------------------------------------------------------------------|:---------------------------------------------------------------------------------------------------|:---------------------------------------------------------------|
+  | type    | string                                                                                          | string                                                                                             | float                                                          |
+  | details | <ul><li>min: 14 characters</li><li>mean: 46.84 characters</li><li>max: 134 characters</li></ul> | <ul><li>min: 86 characters</li><li>mean: 1021.29 characters</li><li>max: 9471 characters</li></ul> | <ul><li>min: 0.0</li><li>mean: 0.31</li><li>max: 1.0</li></ul> |
+* Samples:
+  | sentence1                                                                                                | sentence2                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | score            |
+  |:---------------------------------------------------------------------------------------------------------|:---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|:-----------------|
+  | <code>מה התשלום עבור דרגה X במעון או משפחתון?<br> מה הזכאות עבור ילד נוסף במסגרת מעון או משפחתון?</code> | <code>דרגות השתתפות במימון מעונות יום ומשפחתונים<br> <br>גובה שכר הלימוד<br>סכומי השתתפות המדינה והסכומים אותם משלימים ההורים עבור כל אחת מהדרגות, מפורטים בטבלאות שכר לימוד.<br>הטבלאות מחולקות לפי תעריפים לילדים ותעריפים לתינוקות:<br><br>גובה שכר הלימוד בהתאם לדרגות השונות מפורטת בטבלאות שכר לימוד במסגרות ילדים באתר משרד העבודה.<br>הדרגות המופיעות בטבלאות מותאמות לגובה ההכנסה לנפש במשפחה.<br>ככל שדרגת הזכאות (בטווח 12-3) נמוכה יותר, כך גדלה השתתפות המדינה בתשלום.<br>עבור רמות ההשתתפות המותאמות לגובה ההכנסות, יש להוסיף או להפחית דרגות, על-פי מספר מספר הילדים השוהים במעון או במשפחתון - למשפחה עם כמה ילדים השוהים במעון או במשפחתון, תוגדל רמת השתתפות המדינה עבור כל אחד מהילדים (תיקבע דרגה נמוכה יותר בין הדרגות 12-3).<br>תינוקות הם מי שגילם היה עד 15 חודשים ב-1 בספטמבר של שנת הלימודים אליה נרשמו.<br>ילדים הם מי שב-1 בספטמבר של שנת הלימודים אליה נרשמו, גילם היה בין 15 חודשים ויום ל-33 חודשים (או עד לגיל 46 חודשים, למי שיש להם אישור מהיחידה להתפתחות הילד כי הם מעוכבי התפתחות).<br><br>השפעת מספר הילדים השוהים במעון/משפחתון על דרגת ההשתתפ...</code>          | <code>0.8</code> |
+  | <code>מה התשלום עבור דרגה X במעון או משפחתון?<br> מה הזכאות עבור ילד נוסף במסגרת מעון או משפחתון?</code> | <code>סיוע להורים עצמאיים (הורים יחידים) במימון מעונות יום ומשפחתונים<br> <br>הורים עצמאיים (הורים יחידים) (/he/הורה_עצמאי_(הורה_יחיד)) עשויים להיות זכאים לסיוע במימון מעונות יום ומשפחתונים לפי דרגות השתתפות (/he/דרגות_השתתפות_במימון_מעונות_יום_ומשפחתונים) שנקבעות בהתאם לרמת ההכנסה שלהם (/he/רמת_ההכנסה_לנפש_לצורך_סיוע_במימון_מעונות_יום)<br><br><br> <br>הורים עצמאיים שעונים על הגדרת מגבירי עבודה (.D7.96.D7.9B.D7.90.D7.95.D7.AA_.D7.A9.D7.9C_.D7.94.D7.95.D7.A8.D7.99.D7.9D_.D7.9E.D7.92.D7.91.D7.99.D7.A8.D7.99_.D7.A2.D7.91.D7.95.D7.93.D7.94) זכאים לסיוע מוגדל וישלמו 250 בחודש לילד אחד ו-375 בחודש לשני ילדים<br>כדי להקל על שילובם של הורים בשוק העבודה, המדינה מסייעת להם במימון מעונות יום ומשפחתונים מוכרים.<br><br>גובה התמיכה בזכאות הכללית של ההורים (זוגות הורים או הורים עצמאיים) נקבע על-פי מספר דרגות השתתפות המתבססות על רמת ההכנסה לנפש במשפחה.<br>הורים עצמאיים (הורים יחידים) שעונים על הגדרת "מגבירי עבודה" (בהתאם למפורט בהמשך), זכאים לסיוע מוגדל וישלמו רק 250 ₪ בחודש עבור ילד אחד ו-375 ₪ בחודש עבור שני ילדים.<br>לפרטים ומידע כללי ע...</code>                | <code>0.7</code> |
+  | <code>מה התשלום עבור דרגה X במעון או משפחתון?<br> מה הזכאות עבור ילד נוסף במסגרת מעון או משפחתון?</code> | <code>השתתפות במימון מעונות יום ומשפחתונים<br> תהליך מימוש הזכות<br>איתור מסגרת מוכרת<br>מערכת אינטרנטית (מקוונת) מאפשרת לאתר משפחתונים, מעונות וצהרונים הנמצאים בפיקוח ממשלתי.<br>ניתן לבצע חיפוש לפי ישוב, סוג המסגרת או שם המסגרת. לכניסה למערכת לחצו כאן.<br><br>התשלום למעון/משפחתון<br>עבור חודש אוגוסט יחושב תשלום באופן יחסי בהתאם לתקופת שהות הילד במעון (העלות המלאה לחודש כפול מספר החודשים שהילד שהה במעון חלקי 12 חודשים).<br>החזר כספי בהתאם לדרגת ההשתתפות, יינתן להורים עבור החודש שבו התקבל שאלון ההרשמה במוקד, ועבור החודש שקדם לו.<br>השתתפות בחודש הראשון לכניסת הילד למסגרת (מעון או משפחתון):<br><br>הוריו של ילד שנכנס למסגרת עד ל-15 בחודש (כולל ה-15 לחודש), יהיו זכאים להשתתפות המדינה עבור אותו חודש (על-פי הדרגה שנקבעה להם).<br>הוריו של ילד שנכנס למסגרת לאחר ה-15 לחודש, לא יהיו זכאים להשתתפות בחודש זה. במקרה זה יחויבו ההורים לשלם דמי החזקה באופן יחסי לימים בהם שהה הילד במסגרת.<br><br>היעדרות של הילד<br>היעדרות מהמעון לתקופה של יותר מ-21 ימים תיחשב כעזיבה, אלא אם כן הוצגו במהלך תקופה זו אישורים רפואיים על מחלה או אשפוז של הילד.<br>היעדרות של 45...</code> | <code>0.8</code> |
+* Loss: [<code>BinaryCrossEntropyLoss</code>](https://sbert.net/docs/package_reference/cross_encoder/losses.html#binarycrossentropyloss) with these parameters:
+  ```json
+  {
+      "activation_fn": "torch.nn.modules.linear.Identity",
+      "pos_weight": null
+  }
+  ```
+</details>
+<details><summary>HebNLI</summary>
+
+#### HebNLI
+
+* Dataset: HebNLI
+* Size: 60,792 training samples
+* Columns: <code>sentence1</code>, <code>sentence2</code>, and <code>score</code>
+* Approximate statistics based on the first 1000 samples:
+  |         | sentence1                                                                                      | sentence2                                                                                      | score                                                            |
+  |:--------|:-----------------------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------------------|:-----------------------------------------------------------------|
+  | type    | string                                                                                         | string                                                                                         | float                                                            |
+  | details | <ul><li>min: 4 characters</li><li>mean: 86.89 characters</li><li>max: 400 characters</li></ul> | <ul><li>min: 8 characters</li><li>mean: 43.86 characters</li><li>max: 153 characters</li></ul> | <ul><li>min: 0.01</li><li>mean: 0.41</li><li>max: 0.99</li></ul> |
+* Samples:
+  | sentence1                                                                        | sentence2                                                                        | score             |
+  |:---------------------------------------------------------------------------------|:---------------------------------------------------------------------------------|:------------------|
+  | <code>הצלחנו, אמרה טופנס.</code>                                                 | <code>טופנס אמרה שהם ניצחו.</code>                                               | <code>0.99</code> |
+  | <code>אחרי שלושה ימים של אימונים אינטנסיביים הם סיימו את הקורס בהצטיינות.</code> | <code>הם השלימו את המסלול עם שעות לאחר שלושה ימים של אימונים אינטנסיביים.</code> | <code>0.99</code> |
+  | <code>הייתי מציע לך לנסוע לרוסיה מיד.</code>                                     | <code>הייתי מציע לך להכין את הדרך לרוסיה באופן מיידי.</code>                     | <code>0.99</code> |
+* Loss: [<code>BinaryCrossEntropyLoss</code>](https://sbert.net/docs/package_reference/cross_encoder/losses.html#binarycrossentropyloss) with these parameters:
+  ```json
+  {
+      "activation_fn": "torch.nn.modules.linear.Identity",
+      "pos_weight": null
+  }
+  ```
+</details>
+<details><summary>HebQA</summary>
+
+#### HebQA
+
+* Dataset: HebQA
+* Size: 60,294 training samples
+* Columns: <code>sentence1</code>, <code>sentence2</code>, and <code>score</code>
+* Approximate statistics based on the first 1000 samples:
+  |         | sentence1                                                                                     | sentence2                                                                                          | score                                                            |
+  |:--------|:----------------------------------------------------------------------------------------------|:---------------------------------------------------------------------------------------------------|:-----------------------------------------------------------------|
+  | type    | string                                                                                        | string                                                                                             | float                                                            |
+  | details | <ul><li>min: 13 characters</li><li>mean: 37.7 characters</li><li>max: 91 characters</li></ul> | <ul><li>min: 504 characters</li><li>mean: 695.62 characters</li><li>max: 1311 characters</li></ul> | <ul><li>min: 0.01</li><li>mean: 0.75</li><li>max: 0.99</li></ul> |
+* Samples:
+  | sentence1                                                   | sentence2                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | score                            |
+  |:------------------------------------------------------------|:--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|:---------------------------------|
+  | <code>כמה אנשים היו בוועדה שניסחה את הטיוטה הרביעית?</code> | <code>לאחר שהטיוטות הראשוניות הובאו למנהלת העם וספגו ביקורת חריפה, הוקמה ועדת חמישה בראשות משה שרת שניסחה טיוטה רביעית. ב-13 במאי לפנות ערב הוגשה הצעתה למנהלת העם. ש��ת עשה את רוב המלאכה, תוך התייעצות עם משפטנים מומחים. נוסח ההכרזה הושאל מכתב המנדט וממסמכים משפטיים רבים אחרים, וכל סעיף שלו התחיל במילים "הואיל ו...". בהצעה זו הוזכרה גם תוכנית החלוקה של האו"ם. מזכיר מנהלת העם כתב כי "בן-גוריון התנגד ל'הואיל' כי אינו עברי" וכן "התנגד למילים 'ישוב רב־איל', 'עוז וגבורה' וכיוצא באלה". כמו כן, התנגד להזכרה מפורשת של תוכנית החלוקה.</code> | <code>0.8592790964302004</code>  |
+  | <code>כמה אנשים היו בוועדה שניסחה את הטיוטה הרביעית?</code> | <code>לאחר שהטיוטות הראשוניות הובאו למנהלת העם וספגו ביקורת חריפה, הוקמה ועדת חמישה בראשות משה שרת שניסחה טיוטה רביעית. ב-13 במאי לפנות ערב הוגשה הצעתה למנהלת העם. שרת עשה את רוב המלאכה, תוך התייעצות עם משפטנים מומחים. נוסח ההכרזה הושאל מכתב המנדט וממסמכים משפטיים רבים אחרים, וכל סעיף שלו התחיל במילים "הואיל ו...". בהצעה זו הוזכרה גם תוכנית החלוקה של האו"ם. מזכיר מנהלת העם כתב כי "בן-גוריון התנגד ל'הואיל' כי אינו עברי" וכן "התנגד למילים 'ישוב רב־איל', 'עוז וגבורה' וכיוצא באלה". כמו כן, התנגד להזכרה מפורשת של תוכנית החלוקה.</code> | <code>0.99</code>                |
+  | <code>באילו מילים התחילו כל סעיפי הטויוטה?</code>           | <code>לאחר שהטיוטות הראשוניות הובאו למנהלת העם וספגו ביקורת חריפה, הוקמה ועדת חמישה בראשות משה שרת שניסחה טיוטה רביעית. ב-13 במאי לפנות ערב הוגשה הצעתה למנהלת העם. שרת עשה את רוב המלאכה, תוך התייעצות עם משפטנים מומחים. נוסח ההכרזה הושאל מכתב המנדט וממסמכים משפטיים רבים אחרים, וכל סעיף שלו התחיל במילים "הואיל ו...". בהצעה זו הוזכרה גם תוכנית החלוקה של האו"ם. מזכיר מנהלת העם כתב כי "בן-גוריון התנגד ל'הואיל' כי אינו עברי" וכן "התנגד למילים 'ישוב רב־איל', 'עוז וגבורה' וכיוצא באלה". כמו כן, התנגד להזכרה מפורשת של תוכנית החלוקה.</code> | <code>0.25883327354329505</code> |
+* Loss: [<code>BinaryCrossEntropyLoss</code>](https://sbert.net/docs/package_reference/cross_encoder/losses.html#binarycrossentropyloss) with these parameters:
+  ```json
+  {
+      "activation_fn": "torch.nn.modules.linear.Identity",
+      "pos_weight": null
+  }
+  ```
+</details>
+<details><summary>RAGbot</summary>
+
+#### RAGbot
+
+* Dataset: RAGbot
+* Size: 7,780 training samples
+* Columns: <code>sentence1</code>, <code>sentence2</code>, and <code>score</code>
+* Approximate statistics based on the first 1000 samples:
+  |         | sentence1                                                                                       | sentence2                                                                                           | score                                                            |
+  |:--------|:------------------------------------------------------------------------------------------------|:----------------------------------------------------------------------------------------------------|:-----------------------------------------------------------------|
+  | type    | string                                                                                          | string                                                                                              | float                                                            |
+  | details | <ul><li>min: 10 characters</li><li>mean: 60.23 characters</li><li>max: 424 characters</li></ul> | <ul><li>min: 211 characters</li><li>mean: 1312.64 characters</li><li>max: 4772 characters</li></ul> | <ul><li>min: 0.01</li><li>mean: 0.71</li><li>max: 0.99</li></ul> |
+* Samples:
+  | sentence1                                                                                                     | sentence2                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | score                            |
+  |:--------------------------------------------------------------------------------------------------------------|:---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|:---------------------------------|
+  | <code>לא ברור באתר <br>אם על חברות ביטוח פרטיות <br>חל חוק חופש המידע <br>אני מציע שזה יהיה כתוב מפורש</code> | <code>חוק חופש המידע, התשנ"ח-1998 מאפשר לכל אזרח או תושב ישראל (/he/תושב_ישראל) לפנות בבקשה לרשות ציבורית לקבל מידע אותו היא מחזיקה. מטרתו הראשית של החוק היא להטמיע תפיסת יסוד של שיתוף במידע הציבורי.<br>פרטים<br><br>שם החוק:חוק חופש המידע, התשנ"ח-1998<br>קישור:החוק באתר נבו<br>שר אחראי:שר המשפטים<br>החוק ב"ספר החוקים הפתוח"<br>נושאים וזכויות<br>חופש המידע<br>הזכות לפרטיות</code>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | <code>0.02321811595881069</code> |
+  | <code>לא ברור באתר <br>אם על חברות ביטוח פרטיות <br>חל חוק חופש המידע <br>אני מציע שזה יהיה כתוב מפורש</code> | <code>חוק חופש המידע, התשנ"ח-1998 מאפשר לכל אזרח או תושב ישראל (/he/תושב_ישראל) לפנות בבקשה לרשות ציבורית לקבל מידע אותו היא מחזיקה. מטרתו הראשית של החוק היא להטמיע תפיסת יסוד של שיתוף במידע הציבורי.<br>פרטים<br><br>שם החוק:חוק חופש המידע, התשנ"ח-1998<br>קישור:החוק באתר נבו<br>שר אחראי:שר המשפטים<br>החוק ב"ספר החוקים הפתוח"<br>נושאים וזכויות<br>חופש המידע<br>הזכות לפרטיות</code>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | <code>0.99</code>                |
+  | <code>לא ברור באתר <br>אם על חברות ביטוח פרטיות <br>חל חוק חופש המידע <br>אני מציע שזה יהיה כתוב מפורש</code> | <code>כל אזרח או תושב ישראל זכאי לקבלת מידע מרשות ציבורית (https://www.gov.il/he/departments/general/list_of_authorities)<br><br><br> <br>לצורך קבלת המידע יש לפנות לממונה על יישום חוק חופש המידע ברשות הציבורית<br><br><br> <br>לפני הגשת בקשה לקבלת מידע, מומלץ לברר אם המידע כבר קיים במאגר התשובות (https://www.gov.il/he/departments/general/answer_reservoir) של היחידה הממשלתית לחופש המידע במשרד המשפטים<br><br><br> <br>הגשת הבקשה כרוכה בתשלום אגרה, אך במקרים מסוימים ניתן פטור מתשלום האגרה<br><br><br> <br>למידע נוסף ראו הגשת בקשת חופש המידע (https://www.gov.il/he/service/freedom_of_information_submission) באתר היחידה הממשלתית לחופש המידע במשרד המשפטים<br>חוק חופש המידע קובע כי כל אזרח או תושב ישראל זכאי לקבל מידע מרשות ציבורית.<br><br>לרשימה המלאה של הרשויות הציבוריות שעליהן חל החוק ראו כאן.<br><br>אוכלוסיית יעד ותנאים מקדימים<br>כל אזרח או תושב ישראל.<br><br>למי ואיך פונים<br>יש לבדוק איזו רשות אחראית על הנושא שלגביו מבוקש המידע.<br>יש לפנות לממונה על יישום חוק חופש המידע ברשות האחראית:<br><br>לרשימת הממונים על יישום חוק חופש המידע ברשויות השונות באתר היחידה הממשלתית לחופש המידע...</code> | <code>0.01</code>                |
+* Loss: [<code>BinaryCrossEntropyLoss</code>](https://sbert.net/docs/package_reference/cross_encoder/losses.html#binarycrossentropyloss) with these parameters:
+  ```json
+  {
+      "activation_fn": "torch.nn.modules.linear.Identity",
+      "pos_weight": null
+  }
+  ```
+</details>
+<details><summary>ParaShoot</summary>
+
+#### ParaShoot
+
+* Dataset: ParaShoot
+* Size: 6,076 training samples
+* Columns: <code>sentence1</code>, <code>sentence2</code>, and <code>score</code>
+* Approximate statistics based on the first 1000 samples:
+  |         | sentence1                                                                                      | sentence2                                                                                          | score                                                            |
+  |:--------|:-----------------------------------------------------------------------------------------------|:---------------------------------------------------------------------------------------------------|:-----------------------------------------------------------------|
+  | type    | string                                                                                         | string                                                                                             | float                                                            |
+  | details | <ul><li>min: 9 characters</li><li>mean: 37.13 characters</li><li>max: 119 characters</li></ul> | <ul><li>min: 500 characters</li><li>mean: 746.67 characters</li><li>max: 2042 characters</li></ul> | <ul><li>min: 0.01</li><li>mean: 0.91</li><li>max: 0.99</li></ul> |
+* Samples:
+  | sentence1                                                 | sentence2                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | score                           |
+  |:----------------------------------------------------------|:-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|:--------------------------------|
+  | <code>במה בתחילת דרכה עסקה חברתו של אהרון רוזנפלד?</code> | <code>בתחילה עסקה חברתו מכל הבא ליד אך עם הגברת הבנייה בשנות ה-20 יצר רוזנפלד קשרים בבלגיה, ייבא משם חומרי בניין (בעיקר זכוכית) וייצג את חברת הספנות הבלגית שהביאה את החומרים הללו. כך עגנה ב-1923 בחיפה האונייה הבלגית הראשונה. רוזנפלד היה גם סוכנן של חברות ספנות ואוניות אמריקאיות. בשל פיתוח יחסי העסקים עם בלגיה התמנה ב-1929 לסגן-קונסול וב-1934 לקונסול בלגיה וליבריה בחיפה. ב-1932 קיבל מאלברט הראשון מלך בלגיה את אות הכבוד של אביר מסדר הכתר הבלגי . רוזנפלד השתתף בהקמתם של המרכז המסחרי הישן והחדש בעיר התחתית, והיה ממקימי "בנק בעלי הבתים בע"מ" ב-15 ביולי 1931. רוזנפלד היה חבר בארגונים חברתיים ועסקיים שונים, ובין השאר היה נשיא הבונים החופשיים, חבר ועדת הנמל בלשכת המסחר והתעשייה העברית ולשכת הספנות החיפאית (מ"מ נשיא לשכת הספנות באמצע שנות ה-60) ואזרח כבוד של חיפה.</code> | <code>0.9341320672743826</code> |
+  | <code>במה בתחילת דרכה עסקה חברתו של אהרון רוזנפלד?</code> | <code>בתחילה עסקה חברתו מכל הבא ליד אך עם הגברת הבנייה בשנות ה-20 יצר רוזנפלד קשרים בבלגיה, ייבא משם חומרי בניין (בעיקר זכוכית) וייצג את חברת הספנות הבלגית שהביאה את החומרים הללו. כך עגנה ב-1923 בחיפה האונייה הבלגית הראשונה. רוזנפלד היה גם סוכנן של חברות ספנות ואוניות אמריקאיות. בשל פיתוח יחסי העסקים עם בלגיה התמנה ב-1929 לסגן-קונסול וב-1934 לקונסול בלגיה וליבריה בחיפה. ב-1932 קיבל מאלברט הראשון מלך בלגיה את אות הכבוד של אביר מסדר הכתר הבלגי . רוזנפלד השתתף בהקמתם של המרכז המסחרי הישן והחדש בעיר התחתית, והיה ממקימי "בנק בעלי הבתים בע"מ" ב-15 ביולי 1931. רוזנפלד היה חבר בארגונים חברתיים ועסקיים שונים, ובין השאר היה נשיא הבונים החופשיים, חבר ועדת הנמל בלשכת המסחר והתעשייה העברית ולשכת הספנות החיפאית (מ"מ נשיא לשכת הספנות באמצע שנות ה-60) ואזרח כבוד של חיפה.</code> | <code>0.99</code>               |
+  | <code>מה אירע בחיפה לראשונה בשנת 1923?</code>             | <code>בתחילה עסקה חברתו מכל הבא ליד אך עם הגברת הבנייה בשנות ה-20 יצר רוזנפלד קשרים בבלגיה, ייבא משם חומרי בניין (בעיקר זכוכית) וייצג את חברת הספנות הבלגית שהביאה את החומרים הללו. כך עגנה ב-1923 בחיפה האונייה הבלגית הראשונה. רוזנפלד היה גם סוכנן של חברות ספנות ואוניות אמריקאיות. בשל פיתוח יחסי העסקים עם בלגיה התמנה ב-1929 לסגן-קונסול וב-1934 לקונסול בלגיה וליבריה בחיפה. ב-1932 קיבל מאלברט הראשון מלך בלגיה את אות הכבוד של אביר מסדר הכתר הבלגי . רוזנפלד השתתף בהקמתם של המרכז המסחרי הישן והחדש בעיר התחתית, והיה ממקימי "בנק בעלי הבתים בע"מ" ב-15 ביולי 1931. רוזנפלד היה חבר בארגונים חברתיים ועסקיים שונים, ובין השאר היה נשיא הבונים החופשיים, חבר ועדת הנמל בלשכת המסחר והתעשייה העברית ולשכת הספנות החיפאית (מ"מ נשיא לשכת הספנות באמצע שנות ה-60) ואזרח כבוד של חיפה.</code> | <code>0.4503647439465404</code> |
+* Loss: [<code>BinaryCrossEntropyLoss</code>](https://sbert.net/docs/package_reference/cross_encoder/losses.html#binarycrossentropyloss) with these parameters:
+  ```json
+  {
+      "activation_fn": "torch.nn.modules.linear.Identity",
+      "pos_weight": null
+  }
+  ```
+</details>
+
+### Evaluation Dataset
+
+#### Unnamed Dataset
+
+* Size: 40,680 evaluation samples
+* Columns: <code>sentence1</code>, <code>sentence2</code>, and <code>score</code>
+* Approximate statistics based on the first 1000 samples:
+  |         | sentence1                                                                                       | sentence2                                                                                          | score                                                          |
+  |:--------|:------------------------------------------------------------------------------------------------|:---------------------------------------------------------------------------------------------------|:---------------------------------------------------------------|
+  | type    | string                                                                                          | string                                                                                             | float                                                          |
+  | details | <ul><li>min: 14 characters</li><li>mean: 46.84 characters</li><li>max: 134 characters</li></ul> | <ul><li>min: 86 characters</li><li>mean: 1021.29 characters</li><li>max: 9471 characters</li></ul> | <ul><li>min: 0.0</li><li>mean: 0.31</li><li>max: 1.0</li></ul> |
+* Samples:
+  | sentence1                                                                                                | sentence2                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | score            |
+  |:---------------------------------------------------------------------------------------------------------|:---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|:-----------------|
+  | <code>מה התשלום עבור דרגה X במעון או משפחתון?<br> מה הזכאות עבור ילד נוסף במסגרת מעון או משפחתון?</code> | <code>דרגות השתתפות במימון מעונות יום ומשפחתונים<br> <br>גובה שכר הלימוד<br>סכומי השתתפות המדינה והסכומים אותם משלימים ההורים עבור כל אחת מהדרגות, מפורטים בטבלאות שכר לימוד.<br>הטבלאות מחולקות לפי תעריפים לילדים ותעריפים לתינוקות:<br><br>גובה שכר הלימוד בהתאם לדרגות השונות מפורטת בטבלאות שכר לימוד במסגרות ילדים באתר משרד העבודה.<br>הדרגות המופיעות בטבלאות מותאמות לגובה ההכנסה לנפש במשפחה.<br>ככל שדרגת הזכאות (בטווח 12-3) נמוכה יותר, כך גדלה השתתפות המדינה בתשלום.<br>עבור רמות ההשתתפות המותאמות לגובה ההכנסות, יש להוסיף או להפחית דרגות, על-פי מספר מספר הילדים השוהים במעון או במשפחתון - למשפחה עם כמה ילדים השוהים במעון או במשפחתון, תוגדל רמת השתתפות המדינה עבור כל אחד מהילדים (תיקבע דרגה נמוכה יותר בין הדרגות 12-3).<br>תינוקות הם מי שגילם היה עד 15 חודשים ב-1 בספטמב�� של שנת הלימודים אליה נרשמו.<br>ילדים הם מי שב-1 בספטמבר של שנת הלימודים אליה נרשמו, גילם היה בין 15 חודשים ויום ל-33 חודשים (או עד לגיל 46 חודשים, למי שיש להם אישור מהיחידה להתפתחות הילד כי הם מעוכבי התפתחות).<br><br>השפעת מספר הילדים השוהים במעון/משפחתון על דרגת ההשתתפ...</code>          | <code>0.8</code> |
+  | <code>מה התשלום עבור דרגה X במעון או משפחתון?<br> מה הזכאות עבור ילד נוסף במסגרת מעון או משפחתון?</code> | <code>סיוע להורים עצמאיים (הורים יחידים) במימון מעונות יום ומשפחתונים<br> <br>הורים עצמאיים (הורים יחידים) (/he/הורה_עצמאי_(הורה_יחיד)) עשויים להיות זכאים לסיוע במימון מעונות יום ומשפחתונים לפי דרגות השתתפות (/he/דרגות_השתתפות_במימון_מעונות_יום_ומשפחתונים) שנקבעות בהתאם לרמת ההכנסה שלהם (/he/רמת_ההכנסה_לנפש_לצורך_סיוע_במימון_מעונות_יום)<br><br><br> <br>הורים עצמאיים שעונים על הגדרת מגבירי עבודה (.D7.96.D7.9B.D7.90.D7.95.D7.AA_.D7.A9.D7.9C_.D7.94.D7.95.D7.A8.D7.99.D7.9D_.D7.9E.D7.92.D7.91.D7.99.D7.A8.D7.99_.D7.A2.D7.91.D7.95.D7.93.D7.94) זכאים לסיוע מוגדל וישלמו 250 בחודש לילד אחד ו-375 בחודש לשני ילדים<br>כדי להקל על שילובם של הורים בשוק העבודה, המדינה מסייעת להם במימון מעונות יום ומשפחתונים מוכרים.<br><br>גובה התמיכה בזכאות הכללית של ההורים (זוגות הורים או הורים עצמאיים) נקבע על-פי מספר דרגות השתתפות המתבססות על רמת ההכנסה לנפש במשפחה.<br>הורים עצמאיים (הורים יחידים) שעונים על הגדרת "מגבירי עבודה" (בהתאם למפורט בהמשך), זכאים לסיוע מוגדל וישלמו רק 250 ₪ בחודש עבור ילד אחד ו-375 ₪ בחודש עבור שני ילדים.<br>לפרטים ומידע כללי ע...</code>                | <code>0.7</code> |
+  | <code>מה התשלום עבור דרגה X במעון או משפחתון?<br> מה הזכאות עבור ילד נוסף במסגרת מעון או משפחתון?</code> | <code>השתתפות במימון מעונות יום ומשפחתונים<br> תהליך מימוש הזכות<br>איתור מסגרת מוכרת<br>מערכת אינטרנטית (מקוונת) מאפשרת לאתר משפחתונים, מעונות וצהרונים הנמצאים בפיקוח ממשלתי.<br>ניתן לבצע חיפוש לפי ישוב, סוג המסגרת או שם המסגרת. לכניסה למערכת לחצו כאן.<br><br>התשלום למעון/משפחתון<br>עבור חודש אוגוסט יחושב תשלום באופן יחסי בהתאם לתקופת שהות הילד במעון (העלות המלאה לחודש כפול מספר החודשים שהילד שהה במעון חלקי 12 חודשים).<br>החזר כספי בהתאם לדרגת ההשתתפות, יינתן להורים עבור החודש שבו התקבל שאלון ההרשמה במוקד, ועבור החודש שקדם לו.<br>השתתפות בחודש הראשון לכניסת הילד למסגרת (מעון או משפחתון):<br><br>הוריו של ילד שנכנס למסגרת עד ל-15 בחודש (כולל ה-15 לחודש), יהיו זכאים להשתתפות המדינה עבור אותו חודש (על-פי הדרגה שנקבעה להם).<br>הוריו של ילד שנכנס למסגרת לאחר ה-15 לחודש, לא יהיו זכאים להשתתפות בחודש זה. במקרה זה יחויבו ההורים לשלם דמי החזקה באופן יחסי לימים בהם שהה הילד במסגרת.<br><br>היעדרות של הילד<br>היעדרות מהמעון לתקופה של יותר מ-21 ימים תיחשב כעזיבה, אלא אם כן הוצגו במהלך תקופה זו אישורים רפואיים על מחלה או אשפוז של הילד.<br>היעדרות של 45...</code> | <code>0.8</code> |
+* Loss: [<code>BinaryCrossEntropyLoss</code>](https://sbert.net/docs/package_reference/cross_encoder/losses.html#binarycrossentropyloss) with these parameters:
+  ```json
+  {
+      "activation_fn": "torch.nn.modules.linear.Identity",
+      "pos_weight": null
+  }
+  ```
+
+### Training Hyperparameters
+#### Non-Default Hyperparameters
+
+- `eval_strategy`: steps
+- `per_device_train_batch_size`: 16
+- `per_device_eval_batch_size`: 16
+- `gradient_accumulation_steps`: 8
+- `learning_rate`: 4e-05
+- `weight_decay`: 0.01
+- `max_grad_norm`: 2.0
+- `num_train_epochs`: 2
+- `max_steps`: 300
+- `warmup_steps`: 300
+- `bf16`: True
+- `tf32`: True
+- `torch_compile`: True
+- `torch_compile_backend`: inductor
+- `batch_sampler`: no_duplicates
+
+#### All Hyperparameters
+<details><summary>Click to expand</summary>
+
+- `overwrite_output_dir`: False
+- `do_predict`: False
+- `eval_strategy`: steps
+- `prediction_loss_only`: True
+- `per_device_train_batch_size`: 16
+- `per_device_eval_batch_size`: 16
+- `per_gpu_train_batch_size`: None
+- `per_gpu_eval_batch_size`: None
+- `gradient_accumulation_steps`: 8
+- `eval_accumulation_steps`: None
+- `torch_empty_cache_steps`: None
+- `learning_rate`: 4e-05
+- `weight_decay`: 0.01
+- `adam_beta1`: 0.9
+- `adam_beta2`: 0.999
+- `adam_epsilon`: 1e-08
+- `max_grad_norm`: 2.0
+- `num_train_epochs`: 2
+- `max_steps`: 300
+- `lr_scheduler_type`: linear
+- `lr_scheduler_kwargs`: {}
+- `warmup_ratio`: 0.0
+- `warmup_steps`: 300
+- `log_level`: passive
+- `log_level_replica`: warning
+- `log_on_each_node`: True
+- `logging_nan_inf_filter`: True
+- `save_safetensors`: True
+- `save_on_each_node`: False
+- `save_only_model`: False
+- `restore_callback_states_from_checkpoint`: False
+- `no_cuda`: False
+- `use_cpu`: False
+- `use_mps_device`: False
+- `seed`: 42
+- `data_seed`: None
+- `jit_mode_eval`: False
+- `use_ipex`: False
+- `bf16`: True
+- `fp16`: False
+- `fp16_opt_level`: O1
+- `half_precision_backend`: auto
+- `bf16_full_eval`: False
+- `fp16_full_eval`: False
+- `tf32`: True
+- `local_rank`: 0
+- `ddp_backend`: None
+- `tpu_num_cores`: None
+- `tpu_metrics_debug`: False
+- `debug`: []
+- `dataloader_drop_last`: False
+- `dataloader_num_workers`: 0
+- `dataloader_prefetch_factor`: None
+- `past_index`: -1
+- `disable_tqdm`: False
+- `remove_unused_columns`: True
+- `label_names`: None
+- `load_best_model_at_end`: False
+- `ignore_data_skip`: False
+- `fsdp`: []
+- `fsdp_min_num_params`: 0
+- `fsdp_config`: {'min_num_params': 0, 'xla': False, 'xla_fsdp_v2': False, 'xla_fsdp_grad_ckpt': False}
+- `fsdp_transformer_layer_cls_to_wrap`: None
+- `accelerator_config`: {'split_batches': False, 'dispatch_batches': None, 'even_batches': True, 'use_seedable_sampler': True, 'non_blocking': False, 'gradient_accumulation_kwargs': None}
+- `deepspeed`: None
+- `label_smoothing_factor`: 0.0
+- `optim`: adamw_torch
+- `optim_args`: None
+- `adafactor`: False
+- `group_by_length`: False
+- `length_column_name`: length
+- `ddp_find_unused_parameters`: None
+- `ddp_bucket_cap_mb`: None
+- `ddp_broadcast_buffers`: False
+- `dataloader_pin_memory`: True
+- `dataloader_persistent_workers`: False
+- `skip_memory_metrics`: True
+- `use_legacy_prediction_loop`: False
+- `push_to_hub`: False
+- `resume_from_checkpoint`: None
+- `hub_model_id`: None
+- `hub_strategy`: every_save
+- `hub_private_repo`: None
+- `hub_always_push`: False
+- `hub_revision`: None
+- `gradient_checkpointing`: False
+- `gradient_checkpointing_kwargs`: None
+- `include_inputs_for_metrics`: False
+- `include_for_metrics`: []
+- `eval_do_concat_batches`: True
+- `fp16_backend`: auto
+- `push_to_hub_model_id`: None
+- `push_to_hub_organization`: None
+- `mp_parameters`: 
+- `auto_find_batch_size`: False
+- `full_determinism`: False
+- `torchdynamo`: None
+- `ray_scope`: last
+- `ddp_timeout`: 1800
+- `torch_compile`: True
+- `torch_compile_backend`: inductor
+- `torch_compile_mode`: None
+- `include_tokens_per_second`: False
+- `include_num_input_tokens_seen`: False
+- `neftune_noise_alpha`: None
+- `optim_target_modules`: None
+- `batch_eval_metrics`: False
+- `eval_on_start`: False
+- `use_liger_kernel`: False
+- `liger_kernel_config`: None
+- `eval_use_gather_object`: False
+- `average_tokens_across_devices`: False
+- `prompts`: None
+- `batch_sampler`: no_duplicates
+- `multi_dataset_batch_sampler`: proportional
+- `router_mapping`: {}
+- `learning_rate_mapping`: {}
+
+</details>
+
+### Training Logs
+| Epoch  | Step | Training Loss | Validation Loss | sts_dev_spearman |
+|:------:|:----:|:-------------:|:---------------:|:----------------:|
+| -1     | -1   | -             | -               | 0.4608           |
+| 0.2186 | 300  | 0.4926        | 0.4868          | 0.5369           |
+| -1     | -1   | -             | -               | 0.5369           |
+
+
+### Framework Versions
+- Python: 3.10.16
+- Sentence Transformers: 5.1.2
+- Transformers: 4.53.2
+- PyTorch: 2.9.0+cu128
+- Accelerate: 1.10.1
+- Datasets: 4.2.0
+- Tokenizers: 0.21.4
+
+## Citation
+
+### BibTeX
+
+#### Sentence Transformers
+```bibtex
+@inproceedings{reimers-2019-sentence-bert,
+    title = "Sentence-BERT: Sentence Embeddings using Siamese BERT-Networks",
+    author = "Reimers, Nils and Gurevych, Iryna",
+    booktitle = "Proceedings of the 2019 Conference on Empirical Methods in Natural Language Processing",
+    month = "11",
+    year = "2019",
+    publisher = "Association for Computational Linguistics",
+    url = "https://arxiv.org/abs/1908.10084",
+}
+```
+
+<!--
+## Glossary
+
+*Clearly define terms in order to be accessible across audiences.*
+-->
+
+<!--
+## Model Card Authors
+
+*Lists the people who create the model card, providing recognition and accountability for the detailed work that goes into its construction.*
+-->
+
+<!--
+## Model Card Contact
+
+*Provides a way for people who have updates to the Model Card, suggestions, or questions, to contact the Model Card authors.*
+-->

victord/sub19/models/bge-reranker-v2-m3_pseudo_tune_full/config.json

@@ -0,0 +1,37 @@
+{
+  "architectures": [
+    "XLMRobertaForSequenceClassification"
+  ],
+  "attention_probs_dropout_prob": 0.1,
+  "bos_token_id": 0,
+  "classifier_dropout": null,
+  "eos_token_id": 2,
+  "hidden_act": "gelu",
+  "hidden_dropout_prob": 0.1,
+  "hidden_size": 1024,
+  "id2label": {
+    "0": "LABEL_0"
+  },
+  "initializer_range": 0.02,
+  "intermediate_size": 4096,
+  "label2id": {
+    "LABEL_0": 0
+  },
+  "layer_norm_eps": 1e-05,
+  "max_position_embeddings": 8194,
+  "model_type": "xlm-roberta",
+  "num_attention_heads": 16,
+  "num_hidden_layers": 24,
+  "output_past": true,
+  "pad_token_id": 1,
+  "position_embedding_type": "absolute",
+  "sentence_transformers": {
+    "activation_fn": "torch.nn.modules.activation.Sigmoid",
+    "version": "5.1.2"
+  },
+  "torch_dtype": "bfloat16",
+  "transformers_version": "4.53.2",
+  "type_vocab_size": 1,
+  "use_cache": true,
+  "vocab_size": 250002
+}

victord/sub19/models/bge-reranker-v2-m3_pseudo_tune_full/model.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0c4e2582945a051835252f00c9967c0083f87e9b56af3fbc482c5eeeb31e8b68
+size 1135560090

victord/sub19/models/bge-reranker-v2-m3_pseudo_tune_full/sentencepiece.bpe.model

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cfc8146abe2a0488e9e2a0c56de7952f7c11ab059eca145a0a727afce0db2865
+size 5069051

victord/sub19/models/bge-reranker-v2-m3_pseudo_tune_full/special_tokens_map.json

@@ -0,0 +1,51 @@
+{
+  "bos_token": {
+    "content": "<s>",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  },
+  "cls_token": {
+    "content": "<s>",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  },
+  "eos_token": {
+    "content": "</s>",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  },
+  "mask_token": {
+    "content": "<mask>",
+    "lstrip": true,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  },
+  "pad_token": {
+    "content": "<pad>",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  },
+  "sep_token": {
+    "content": "</s>",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  },
+  "unk_token": {
+    "content": "<unk>",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  }
+}

victord/sub19/models/bge-reranker-v2-m3_pseudo_tune_full/tokenizer.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f346050eed4b822e076c8958539a82bd05b7828c9110f81e7ed7a6d1b853710b
+size 17083154

victord/sub19/models/bge-reranker-v2-m3_pseudo_tune_full/tokenizer_config.json

@@ -0,0 +1,57 @@
+{
+  "added_tokens_decoder": {
+    "0": {
+      "content": "<s>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "1": {
+      "content": "<pad>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "2": {
+      "content": "</s>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "3": {
+      "content": "<unk>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "250001": {
+      "content": "<mask>",
+      "lstrip": true,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    }
+  },
+  "bos_token": "<s>",
+  "clean_up_tokenization_spaces": true,
+  "cls_token": "<s>",
+  "eos_token": "</s>",
+  "extra_special_tokens": {},
+  "mask_token": "<mask>",
+  "max_length": 2048,
+  "model_max_length": 2048,
+  "pad_token": "<pad>",
+  "sep_token": "</s>",
+  "sp_model_kwargs": {},
+  "tokenizer_class": "XLMRobertaTokenizer",
+  "unk_token": "<unk>"
+}

victord/sub19/models/multilingual-e5-large-instruct/1_Pooling/config.json

@@ -0,0 +1,10 @@
+{
+    "word_embedding_dimension": 1024,
+    "pooling_mode_cls_token": false,
+    "pooling_mode_mean_tokens": true,
+    "pooling_mode_max_tokens": false,
+    "pooling_mode_mean_sqrt_len_tokens": false,
+    "pooling_mode_weightedmean_tokens": false,
+    "pooling_mode_lasttoken": false,
+    "include_prompt": true
+}

victord/sub19/models/multilingual-e5-large-instruct/config.json

@@ -0,0 +1,27 @@
+{
+  "architectures": [
+    "XLMRobertaModel"
+  ],
+  "attention_probs_dropout_prob": 0.1,
+  "bos_token_id": 0,
+  "classifier_dropout": null,
+  "eos_token_id": 2,
+  "hidden_act": "gelu",
+  "hidden_dropout_prob": 0.1,
+  "hidden_size": 1024,
+  "initializer_range": 0.02,
+  "intermediate_size": 4096,
+  "layer_norm_eps": 1e-05,
+  "max_position_embeddings": 514,
+  "model_type": "xlm-roberta",
+  "num_attention_heads": 16,
+  "num_hidden_layers": 24,
+  "output_past": true,
+  "pad_token_id": 1,
+  "position_embedding_type": "absolute",
+  "torch_dtype": "bfloat16",
+  "transformers_version": "4.53.2",
+  "type_vocab_size": 1,
+  "use_cache": true,
+  "vocab_size": 250002
+}

victord/sub19/models/multilingual-e5-large-instruct/config_sentence_transformers.json

@@ -0,0 +1,14 @@
+{
+  "__version__": {
+    "sentence_transformers": "5.1.1",
+    "transformers": "4.53.2",
+    "pytorch": "2.9.0+cu128"
+  },
+  "model_type": "SentenceTransformer",
+  "prompts": {
+    "query": "",
+    "document": ""
+  },
+  "default_prompt_name": null,
+  "similarity_fn_name": "cosine"
+}

victord/sub19/models/multilingual-e5-large-instruct/model.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:23e75f34a6a87a71c6a6a4a9244c0520599b3593a9cb13275fa4a92a970fb85a
+size 1119826072

victord/sub19/models/multilingual-e5-large-instruct/modules.json

@@ -0,0 +1,20 @@
+[
+  {
+    "idx": 0,
+    "name": "0",
+    "path": "",
+    "type": "sentence_transformers.models.Transformer"
+  },
+  {
+    "idx": 1,
+    "name": "1",
+    "path": "1_Pooling",
+    "type": "sentence_transformers.models.Pooling"
+  },
+  {
+    "idx": 2,
+    "name": "2",
+    "path": "2_Normalize",
+    "type": "sentence_transformers.models.Normalize"
+  }
+]

victord/sub19/models/multilingual-e5-large-instruct/sentence_bert_config.json

@@ -0,0 +1,4 @@
+{
+    "max_seq_length": 512,
+    "do_lower_case": false
+}

victord/sub19/models/multilingual-e5-large-instruct/sentencepiece.bpe.model

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cfc8146abe2a0488e9e2a0c56de7952f7c11ab059eca145a0a727afce0db2865
+size 5069051

victord/sub19/models/multilingual-e5-large-instruct/special_tokens_map.json

@@ -0,0 +1,51 @@
+{
+  "bos_token": {
+    "content": "<s>",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  },
+  "cls_token": {
+    "content": "<s>",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  },
+  "eos_token": {
+    "content": "</s>",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  },
+  "mask_token": {
+    "content": "<mask>",
+    "lstrip": true,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  },
+  "pad_token": {
+    "content": "<pad>",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  },
+  "sep_token": {
+    "content": "</s>",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  },
+  "unk_token": {
+    "content": "<unk>",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  }
+}