Hugging Face's logo

Nosorozhek
/
e5-linker-tuned

Sentence Similarity
sentence-transformers
Safetensors
xlm-roberta
feature-extraction
Generated from Trainer
dataset_size:1877
loss:MultipleNegativesRankingLoss
text-embeddings-inference
Model card Files
xet
 Community

SentenceTransformer based on intfloat/multilingual-e5-base

This is a sentence-transformers model finetuned from intfloat/multilingual-e5-base. It maps sentences & paragraphs to a 768-dimensional dense vector space and can be used for semantic textual similarity, semantic search, paraphrase mining, text classification, clustering, and more.

Model Details

Model Description

  • Model Type: Sentence Transformer
  • Base model: intfloat/multilingual-e5-base
  • Maximum Sequence Length: 512 tokens
  • Output Dimensionality: 768 dimensions
  • Similarity Function: Cosine Similarity

Model Sources

Full Model Architecture 

SentenceTransformer(
  (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: XLMRobertaModel 
  (1): Pooling({'word_embedding_dimension': 768, '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()
)

Usage

Direct Usage (Sentence Transformers)

First install the Sentence Transformers library:

pip install -U sentence-transformers

Then you can load this model and run inference.

from sentence_transformers import SentenceTransformer

# Download from the 🤗 Hub
model = SentenceTransformer("sentence_transformers_model_id")
# Run inference
sentences = [
    'query: Класс HP_holder реализует RAII-механизм для работы с hazard pointer в lock-free стеке. Его задача — захватить один из указателей из массива hazard_pointers, который используется для защиты данных от небезопасного удаления другими потоками. Конструктор класса перебирает все элементы массива, пытаясь атомарно обновить идентификатор потока в поле id каждого указателя. Если обновление успешно, указатель hp сохраняет адрес этого элемента, и цикл прерывается. В противном случае, если все указатели заняты, выбрасывается исключение. Такой подход гарантирует потоку эксклюзивный доступ к hazard pointer на всё время его использования, что необходимо для корректной работы lock-free алгоритмов.',
    'passage: Lock-free stack: reclamation with HP\n34\n// RAII\nclass HP_holder {\n HP* hp {nullptr};\npublic:\n HP_holder() {\n for (auto &p: hazard_pointers) {\n std::thread::id old_id;\n if (p.id.compare_exchange_strong(old_id, std::this_thread::get_id())) {\n hp = &p;\n break;\n }\n }\n if (!hp)\n throw std::runtime_error("No hazard pointers available");\n }\n};',
    'passage: int main() {\n    constexpr const size_t M = 4096;\n    constexpr const size_t P = 4096;\n    constexpr const size_t N = 4096;\n\n    std::cout << "Generating inputs...";\n    std::cout.flush();\n    const std::vector<float> aHost = GenerateData(M * P, 31337);\n    const std::vector<float> bHost = GenerateData((P) * N, 31338);\n    std::cout << "    done" << std::endl;\n\n    std::cout << "Calculating reference...";\n    std::cout.flush();\n    std::vector<float> cHost(M * N);\n    // GemmHost(M, N, P, aHost.data(), P, bHost.data(), N, cHost.data(), N);\n    std::cout << "    done" << std::endl;\n\n    float* aDevice = GenerateDevicePtr(aHost);\n    float* bDevice = GenerateDevicePtr(bHost);\n\n    float* cDevice = nullptr;\n    CudaCheck(cudaMalloc(&cDevice, M * N * sizeof(float)));\n\n    cudaDeviceProp deviceProp{};\n    CudaCheck(cudaGetDeviceProperties(&deviceProp, /* device = */ 0));\n\n    std::cout << "One SM has:"\n              << "\\n\\t" << deviceProp.regsPerMultiprocessor << " registers"\n              << "\\n\\t" << deviceProp.sharedMemPerMultiprocessor << " bytes of shared memory"\n              << "\\n\\t" << deviceProp.maxThreadsPerMultiProcessor << " threads";',
]
embeddings = model.encode(sentences)
print(embeddings.shape)
# [3, 768]

# Get the similarity scores for the embeddings
similarities = model.similarity(embeddings, embeddings)
print(similarities.shape)
# [3, 3]

Training Details

Training Dataset

Unnamed Dataset

  • Size: 1,877 training samples
  • Columns: anchor and positive
  • Approximate statistics based on the first 1000 samples:
    anchor positive
    type string string
    details
    • min: 16 tokens
    • mean: 144.93 tokens
    • max: 453 tokens
    • min: 7 tokens
    • mean: 297.74 tokens
    • max: 512 tokens
  • Samples:
    anchor positive
    query: Control divergence — это ключевая проблема в параллельных вычислениях, особенно при работе с графическими процессорами, где все нити в warp должны выполнять одни и те же инструкции синхронно.

    Она возникает, когда ветвление кода приводит к тому, что разные нити выполняют разные пути, что нарушает параллелизм и снижает эффективность.

    В таких случаях часть нитей простаивает, пока другие выполняют свои инструкции, что приводит к значительным потерям производительности.

    Это особенно критично в архитектурах CUDA, где warp объединяет 32 нити, и любое расхождение в потоке управления требует дополнительных тактов для синхронизации.

    Таким образом, минимизация control divergence позволяет максимально загрузить вычислительные ресурсы и ускорить выполнение программ.    		 passage: **Control divergence
    19 / 25
    query: Функция reclaim_later создает новый объект ReclaimData, содержащий указатель на переданные данные, и добавляет его в список узлов, предназначенных для отложенного освобождения. Это позволяет безопасно управлять памятью, избегая преждевременного удаления данных, на которые могут существовать опасные указатели. Функция delete_nodes_with_no_hazards начинает с атомарного извлечения текущего списка узлов, требующих проверки, и затем итеративно проходит по каждому узлу. Для каждого узла проверяется, существуют ли опасные указатели на его данные, и если нет, узел удаляется. В противном случае узел возвращается в список для последующей обработки. passage: },
    {
    "id": "hazard_ptr.cpp_block3",
    "source_file": "hazard_ptr.cpp",
    "content": "void reclaim_later(T* data) {\n add_to_reclaim_list(new ReclaimData(data));\n}\n\nvoid delete_nodes_with_no_hazards() {\n ReclaimData* current = nodes_to_reclaim.exchange(nullptr);\n while (current) {\n ReclaimData* const next = current->next;\n if (!outstanding_hazard_pointers_for(current->data))\n delete current;\n else\n add_to_reclaim_list(current);\n current = next;\n }\n}\n\ntemplate "
    },
    {
    "id": "hazard_ptr.cpp_block4",
    "source_file": "hazard_ptr.cpp",
    query: Lock-free алгоритмы позволяют добиться более эффективных программ за счёт отсутствия блокировок, что исключает возможность возникновения дедлоков. Однако реализация таких структур требует высокой квалификации и сопровождается значительными трудностями. При этом ключевое преимущество заключается в возможности параллельной работы нескольких потоков с одной структурой данных. Важно, что даже при снятии одного потока с исполнения остальные должны сохранять работоспособность. В противном случае система может терять производительность или становиться нестабильной. passage: Slide 14,lockfree.pdf,Зачем писать Lock-free? + возможно более эффективные программы + отсутствие дедлоков - это очень не просто 14...
    Slide 15,lockfree.pdf,Lock-free структуры >1 потока должно иметь возможность параллельно работать со структурой; при этом необязательно в рамках одной операции при снятии любого потока с исполнения остальные должны иметь в...
    Slide 16,lockfree.pdf,Lock-free stack template head class Stack { private: struct Node { std::shared_ptr data; Node* next; A B C }; std::atomic head; public: Stack() = default; Stack(const Stack&) = d...
    Slide 17,lockfree.pdf,Lock-free stack: destructor template class Stack { public: ~Stack() { auto first = head.load(); while (first) { auto unlinked = first; first = first->next; delete unlinked; } } }; 17...
    Slide 18,lockfree.pdf,"Lock-free stack: push template class Stack { public: void push (T const &data) { Node* new_node = new Node{std::make_shared(data), nullptr}; new_n...
  • Loss: MultipleNegativesRankingLoss with these parameters:
    {
    "scale": 20.0,
    "similarity_fct": "cos_sim"
}

Evaluation Dataset

Unnamed Dataset

  • Size: 209 evaluation samples
  • Columns: anchor and positive
  • Approximate statistics based on the first 209 samples:
    anchor positive
    type string string
    details
    • min: 17 tokens
    • mean: 140.93 tokens
    • max: 434 tokens
    • min: 7 tokens
    • mean: 340.64 tokens
    • max: 512 tokens
  • Samples:
    anchor positive
    query: Вот три варианта описания кода с слайда: passage: #include
    #include
    #include

    #include
    query: Похоже, текст слайда слишком краткий и не содержит конкретного материала для развернутого описания. Однако, если предположить, что под "Live coding (II)" подразумевается продолжение темы живого программирования или демонстрации кода в реальном времени, то можно предложить варианты, покрывающие возможные аспекты такого занятия. passage: Live coding (II)
    15 / 25
    query: Мы возвращаемся к теме асинхронного копирования, которая пришла к нам из третьей лекции, где мы обсуждали, как важно начинать загрузку данных как можно раньше, чтобы максимально перекрывать операции памяти и вычислений.
    На новых GPU-архитектурах появились специализированные примитивы асинхронного копирования, которые позволяют перемещать данные из глобальной памяти напрямую в разделяемую без участия ядра.
    Для базовой части курса вам достаточно освоить концепции пайплайнинга и двойной буферизации, которые позволяют скрыть латентность памяти за счёт перекрытия операций.
    Однако асинхронное копирование — это уже следующий уровень детализации, который сильно привязан к конкретной архитектуре и используется в первую очередь в высокопроизводительных GEMM-подобных ядрах.
    Таким образом, сегодня мы лишь касаемся этой темы, чтобы у вас сформировалась общая картина, но полное погружение в async copy оставляем для продвинутых курсов.    		 passage: Advanced topic: Async Copy
    ▶Это развитие идеи из лекции 03:
    ▶начинать загрузку как можно раньше
    ▶лучше перекрывать память и вычисления
    ▶На новых архитектурах есть специальные async copy primitive’ы global →
    shared
    ▶Но для базовой линии курса достаточно понимать идею pipeline и double
    buffering
    ▶Async copy — уже следующий уровень детализации:
    ▶architecture-specific
    ▶полезно для очень горячих GEMM-like kernels
    17 / 24
  • Loss: MultipleNegativesRankingLoss with these parameters:
    {
    "scale": 20.0,
    "similarity_fct": "cos_sim"
}

Training Hyperparameters

Non-Default Hyperparameters

  • eval_strategy: epoch
  • per_device_train_batch_size: 16
  • num_train_epochs: 10
  • warmup_steps: 100
  • fp16: True

All Hyperparameters

Click to expand
  • overwrite_output_dir: False
  • do_predict: False
  • eval_strategy: epoch
  • prediction_loss_only: True
  • per_device_train_batch_size: 16
  • per_device_eval_batch_size: 8
  • per_gpu_train_batch_size: None
  • per_gpu_eval_batch_size: None
  • gradient_accumulation_steps: 1
  • eval_accumulation_steps: None
  • torch_empty_cache_steps: None
  • learning_rate: 5e-05
  • weight_decay: 0.0
  • adam_beta1: 0.9
  • adam_beta2: 0.999
  • adam_epsilon: 1e-08
  • max_grad_norm: 1.0
  • num_train_epochs: 10
  • max_steps: -1
  • lr_scheduler_type: linear
  • lr_scheduler_kwargs: {}
  • warmup_ratio: 0.0
  • warmup_steps: 100
  • 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: False
  • fp16: True
  • fp16_opt_level: O1
  • half_precision_backend: auto
  • bf16_full_eval: False
  • fp16_full_eval: False
  • tf32: None
  • 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
  • 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: False
  • torch_compile_backend: None
  • torch_compile_mode: None
  • dispatch_batches: None
  • split_batches: 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
  • eval_use_gather_object: False
  • average_tokens_across_devices: False
  • prompts: None
  • batch_sampler: batch_sampler
  • multi_dataset_batch_sampler: proportional

Training Logs

Click to expand
Epoch Step Training Loss Validation Loss
0.1695 10 2.6821 -
0.3390 20 2.2156 -
0.5085 30 1.2204 -
0.6780 40 0.8138 -
0.8475 50 0.6464 -
1.0 59 - 0.1863
1.0169 60 0.4889 -
1.1864 70 0.3661 -
1.3559 80 0.3095 -
1.5254 90 0.4092 -
1.6949 100 0.4396 -
1.8644 110 0.4766 -
2.0 118 - 0.1436
2.0339 120 0.34 -
2.2034 130 0.2795 -
2.3729 140 0.2194 -
2.5424 150 0.2563 -
2.7119 160 0.2141 -
2.8814 170 0.2561 -
3.0 177 - 0.1478
0.1695 10 0.2167 -
0.3390 20 0.2049 -
0.5085 30 0.1237 -
0.6780 40 0.1516 -
0.8475 50 0.1561 -
1.0 59 - 0.1628
1.0169 60 0.0984 -
1.1864 70 0.089 -
1.3559 80 0.0817 -
1.5254 90 0.0758 -
1.6949 100 0.0711 -
1.8644 110 0.0913 -
2.0 118 - 0.1587
2.0339 120 0.0775 -
2.2034 130 0.0608 -
2.3729 140 0.042 -
2.5424 150 0.0612 -
2.7119 160 0.0609 -
2.8814 170 0.0807 -
3.0 177 - 0.1487
0.0847 10 0.0621 -
0.1695 20 0.1254 -
0.2542 30 0.1065 -
0.3390 40 0.0964 -
0.4237 50 0.0739 -
0.5085 60 0.0169 -
0.5932 70 0.0787 -
0.6780 80 0.074 -
0.7627 90 0.0918 -
0.8475 100 0.0918 -
0.9322 110 0.0937 -
1.0 118 - 0.1804
1.0169 120 0.0727 -
1.1017 130 0.0468 -
1.1864 140 0.0871 -
1.2712 150 0.0486 -
1.3559 160 0.0428 -
1.4407 170 0.0772 -
1.5254 180 0.0802 -
1.6102 190 0.0699 -
1.6949 200 0.1164 -
1.7797 210 0.1267 -
1.8644 220 0.052 -
1.9492 230 0.1224 -
2.0 236 - 0.1788
2.0339 240 0.083 -
2.1186 250 0.0684 -
2.2034 260 0.0402 -
2.2881 270 0.0537 -
2.3729 280 0.0456 -
2.4576 290 0.076 -
2.5424 300 0.0652 -
2.6271 310 0.0799 -
2.7119 320 0.0706 -
2.7966 330 0.053 -
2.8814 340 0.0747 -
2.9661 350 0.0221 -
3.0 354 - 0.1520
3.0508 360 0.0643 -
3.1356 370 0.0695 -
3.2203 380 0.1086 -
3.3051 390 0.088 -
3.3898 400 0.0723 -
3.4746 410 0.1114 -
3.5593 420 0.0817 -
3.6441 430 0.0857 -
3.7288 440 0.0854 -
3.8136 450 0.0797 -
3.8983 460 0.0484 -
3.9831 470 0.1414 -
4.0 472 - 0.1747
4.0678 480 0.0925 -
4.1525 490 0.0579 -
4.2373 500 0.0801 -
4.3220 510 0.0747 -
4.4068 520 0.0731 -
4.4915 530 0.1312 -
4.5763 540 0.0721 -
4.6610 550 0.0788 -
4.7458 560 0.0615 -
4.8305 570 0.0476 -
4.9153 580 0.0928 -
5.0 590 0.0615 0.1977
5.0847 600 0.0159 -
5.1695 610 0.0518 -
5.2542 620 0.0781 -
5.3390 630 0.0634 -
5.4237 640 0.0261 -
5.5085 650 0.0691 -
5.5932 660 0.0571 -
5.6780 670 0.0946 -
5.7627 680 0.0674 -
5.8475 690 0.0942 -
5.9322 700 0.0596 -
6.0 708 - 0.1725
6.0169 710 0.0336 -
6.1017 720 0.0461 -
6.1864 730 0.0714 -
6.2712 740 0.0575 -
6.3559 750 0.064 -
6.4407 760 0.052 -
6.5254 770 0.0353 -
6.6102 780 0.0557 -
6.6949 790 0.0283 -
6.7797 800 0.0445 -
6.8644 810 0.0473 -
6.9492 820 0.0794 -
7.0 826 - 0.1923
7.0339 830 0.0506 -
7.1186 840 0.0292 -
7.2034 850 0.0572 -
7.2881 860 0.1032 -
7.3729 870 0.0334 -
7.4576 880 0.0513 -
7.5424 890 0.0838 -
7.6271 900 0.0344 -
7.7119 910 0.0886 -
7.7966 920 0.0354 -
7.8814 930 0.0494 -
7.9661 940 0.0384 -
8.0 944 - 0.1892
8.0508 950 0.017 -
8.1356 960 0.0404 -
8.2203 970 0.0558 -
8.3051 980 0.0198 -
8.3898 990 0.0885 -
8.4746 1000 0.0381 -
8.5593 1010 0.0343 -
8.6441 1020 0.0609 -
8.7288 1030 0.04 -
8.8136 1040 0.0448 -
8.8983 1050 0.0425 -
8.9831 1060 0.0502 -
9.0 1062 - 0.1743
9.0678 1070 0.1041 -
9.1525 1080 0.0838 -
9.2373 1090 0.0419 -
9.3220 1100 0.0756 -
9.4068 1110 0.0339 -
9.4915 1120 0.0554 -
9.5763 1130 0.0381 -
9.6610 1140 0.0335 -
9.7458 1150 0.0153 -
9.8305 1160 0.0486 -
9.9153 1170 0.0556 -
10.0 1180 0.0428 0.1782

Framework Versions

  • Python: 3.11.10
  • Sentence Transformers: 3.3.1
  • Transformers: 4.47.0
  • PyTorch: 2.11.0+cu130
  • Accelerate: 1.2.1
  • Datasets: 4.8.4
  • Tokenizers: 0.21.4

Citation

BibTeX

Sentence Transformers 

@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",
}

MultipleNegativesRankingLoss 

@misc{henderson2017efficient,
    title={Efficient Natural Language Response Suggestion for Smart Reply},
    author={Matthew Henderson and Rami Al-Rfou and Brian Strope and Yun-hsuan Sung and Laszlo Lukacs and Ruiqi Guo and Sanjiv Kumar and Balint Miklos and Ray Kurzweil},
    year={2017},
    eprint={1705.00652},
    archivePrefix={arXiv},
    primaryClass={cs.CL}
}
Downloads last month
7
Safetensors
Model size
0.3B params
Tensor type
F32
·
Inference Providers NEW
Sentence Similarity
This model isn't deployed by any Inference Provider. 🙋 Ask for provider support

Model tree for Nosorozhek/e5-linker-tuned

Base model

intfloat/multilingual-e5-base
Finetuned
(186)
this model

Papers for Nosorozhek/e5-linker-tuned