Shuu12121 / CodeSearch-ModernBERT-Owl-Atn

SentenceTransformer based on Shuu12121/CodeModernBERT-Owl

This is a sentence-transformers model finetuned from Shuu12121/CodeModernBERT-Owl . 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: Shuu12121/CodeModernBERT-Owl
• Maximum Sequence Length: 2048 tokens
• Output Dimensionality: 768 dimensions
• Similarity Function: Cosine Similarity

Model Sources

• Documentation: Sentence Transformers Documentation
• Repository: Sentence Transformers on GitHub
• Hugging Face: Sentence Transformers on Hugging Face

Full Model Architecture

SentenceTransformer(
  (0): Transformer({'max_seq_length': 2048, 'do_lower_case': False}) with Transformer model: ModernBertModel 
  (1): Pooling({'word_embedding_dimension': 768, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': False, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': True, 'pooling_mode_lasttoken': False, 'include_prompt': True})
)

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 = [
    'Copy entities from one workspace to another.',
    'def entity_copy(args):\n    \n    if not args.to_workspace:\n        args.to_workspace = args.workspace\n    if not args.to_project:\n        args.to_project = args.project\n    if (args.project == args.to_project\n        and args.workspace == args.to_workspace):\n        eprint("destination project and namespace must differ from"\n               " source workspace")\n        return 1\n\n    if not args.entities:\n        # get a list of entities from source workspace matching entity_type\n        ents = _entity_paginator(args.project, args.workspace, args.entity_type,\n                                 page_size=500, filter_terms=None,\n                                 sort_direction=\'asc\')\n        args.entities = [e[\'name\'] for e in ents]\n\n    prompt = "Copy {0} {1}(s) from {2}/{3} to {4}/{5}?\\n[Y\\\\n]: "\n    prompt = prompt.format(len(args.entities), args.entity_type, args.project,\n                           args.workspace, args.to_project, args.to_workspace)\n\n    if not args.yes and not _confirm_prompt("", prompt):\n        return\n\n    r = fapi.copy_entities(args.project, args.workspace, args.to_project,\n                           args.to_workspace, args.entity_type, args.entities,\n                           link_existing_entities=args.link)\n    fapi._check_response_code(r, 201)\n    return 0',
    'public Set<K> getUnavailableNodes() {\n        final Set<K> result = new HashSet<K>();\n        for ( final Map.Entry<K, ManagedItem<Boolean>> entry : _map.entrySet() ) {\n            if ( !entry.getValue()._value.booleanValue() && !isExpired( entry.getValue() ) ) {\n                result.add( entry.getKey() );\n            }\n        }\n        return result;\n    }',
]
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]

Evaluation

Metrics

Information Retrieval

• Datasets: code-docstring-retrieval-python , code-docstring-retrieval-java , code-docstring-retrieval-javascript , code-docstring-retrieval-php , code-docstring-retrieval-ruby , code-docstring-retrieval-go , code-docstring-retrieval-rust and code-docstring-retrieval-all
• Evaluated with InformationRetrievalEvaluator

Training Details

Training Dataset

Unnamed Dataset

• Size: 1,648,543 training samples
• Columns: sentence_0 , sentence_1 , and label
• Approximate statistics based on the first 1000 samples:

  	sentence_0	sentence_1	label
  type	string	string	float
  details	min: 5 tokens mean: 44.57 tokens max: 761 tokens	min: 18 tokens mean: 158.37 tokens max: 2048 tokens	min: 1.0 mean: 1.0 max: 1.0

• Samples:

  sentence_0	sentence_1	label
  Serves a cross-domain policy which can allow other policies to exist on the same domain. Note that this view, if used, must be the master policy for the domain, and so must be served from the URL /crossdomain.xml on the domain: setting metapolicy information in other policy files is forbidden by the cross-domain policy specification. Required arguments: permitted A string indicating the extent to which other policies are permitted. A set of constants is available in flashpolicies.policies , defining acceptable values for this argument. Optional arguments: domains A list of domains from which to allow access. Each value may be either a domain name (e.g., example.com ) or a wildcard (e.g., *.example.com ). Due to serious potential security issues, it is strongly recommended that you not use wildcard domain values.	def metapolicy(request, permitted, domains=None): if domains is None: domains = [] policy = policies.Policy(*domains) policy.metapolicy(permitted) return serve(request, policy)	1.0
  Puts a value from a VEX temporary register into a machine register. This is how the results of operations done to registers get committed to the machine's state. :param val: The VexValue to store (Want to store a constant? See Constant() first) :param reg: The integer register number to store into, or register name :return: None	def put(self, val, reg): offset = self.lookup_register(self.irsb_c.irsb.arch, reg) self.irsb_c.put(val.rdt, offset)	1.0
  Like get_token , but using an OAuth 2 authorization code. Use this method if you run a webserver that serves as an endpoint for the redirect URI. The webserver can retrieve the authorization code from the URL that is requested by ORCID. Parameters ---------- :param redirect_uri: string The redirect uri of the institution. :param authorization_code: string The authorization code. Returns ------- :returns: dict All data of the access token. The access token itself is in the "access_token" key.	def get_token_from_authorization_code(self, authorization_code, redirect_uri): token_dict = { "client_id": self._key, "client_secret": self._secret, "grant_type": "authorization_code", "code": authorization_code, "redirect_uri": redirect_uri, } response = requests.post(self._token_url, data=token_dict, headers={'Accept': 'application/json'}, timeout=self._timeout) response.raise_for_status() if self.do_store_raw_response: self.raw_response = response return json.loads(response.text)	1.0

• Loss: MultipleNegativesRankingLoss with these parameters:

  {
      "scale": 20.0,
      "similarity_fct": "cos_sim"
  }
  

Training Hyperparameters

Non-Default Hyperparameters

• eval_strategy : steps
• per_device_train_batch_size : 32
• per_device_eval_batch_size : 32
• num_train_epochs : 5
• fp16 : True
• multi_dataset_batch_sampler : round_robin

All Hyperparameters

Training Logs

Framework Versions

• Python: 3.11.11
• Sentence Transformers: 3.4.1
• Transformers: 4.50.3
• PyTorch: 2.6.0+cu124
• Accelerate: 1.5.2
• Datasets: 3.5.0
• Tokenizers: 0.21.1

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}
}