| --- |
| tags: |
| - sentence-transformers |
| - sentence-similarity |
| - feature-extraction |
| - dense |
| - generated_from_trainer |
| - dataset_size:283621 |
| - loss:CachedMultipleNegativesRankingLoss |
| base_model: answerdotai/ModernBERT-base |
| widget: |
| - source_sentence: '// Uint is a helper routine that allocates a new uint value to |
| store v and |
| |
| // returns a pointer to it. This is useful when assigning optional parameters.' |
| sentences: |
| - "func (c *Animation) GetCurrentTimeWithParams(v *AnimationGetCurrentTimeParams)\ |
| \ (float64, error) {\n\tresp, err := gcdmessage.SendCustomReturn(c.target, c.target.GetSendCh(),\ |
| \ &gcdmessage.ParamRequest{Id: c.target.GetId(), Method: \"Animation.getCurrentTime\"\ |
| , Params: v})\n\tif err != nil {\n\t\treturn 0, err\n\t}\n\n\tvar chromeData struct\ |
| \ {\n\t\tResult struct {\n\t\t\tCurrentTime float64\n\t\t}\n\t}\n\n\tif resp ==\ |
| \ nil {\n\t\treturn 0, &gcdmessage.ChromeEmptyResponseErr{}\n\t}\n\n\t// test\ |
| \ if error first\n\tcerr := &gcdmessage.ChromeErrorResponse{}\n\tjson.Unmarshal(resp.Data,\ |
| \ cerr)\n\tif cerr != nil && cerr.Error != nil {\n\t\treturn 0, &gcdmessage.ChromeRequestErr{Resp:\ |
| \ cerr}\n\t}\n\n\tif err := json.Unmarshal(resp.Data, &chromeData); err != nil\ |
| \ {\n\t\treturn 0, err\n\t}\n\n\treturn chromeData.Result.CurrentTime, nil\n}" |
| - "func Uint(v uint) *uint {\n\tp := new(uint)\n\t*p = v\n\treturn p\n}" |
| - "def after_init_app(self, app: FlaskUnchained):\n \"\"\"\n Configure\ |
| \ the JSON encoder for Flask to be able to serialize Enums,\n LocalProxy\ |
| \ objects, and SQLAlchemy models.\n \"\"\"\n self.set_json_encoder(app)\n\ |
| \ app.before_first_request(self.register_model_resources)" |
| - source_sentence: 'Returns a template for the parent of this template. |
| |
| |
| @throws ValidationException if the template has no parent.' |
| sentences: |
| - "func BodyContainsOr(values ...string) ResponseCondition {\n\treturn func(res\ |
| \ *http.Response) error {\n\t\tbody, err := ioutil.ReadAll(res.Body)\n\t\tif err\ |
| \ != nil {\n\t\t\treturn fmt.Errorf(\"failed to read response body: %s\", err)\n\ |
| \t\t}\n\n\t\tfor _, value := range values {\n\t\t\tif strings.Contains(string(body),\ |
| \ value) {\n\t\t\t\treturn nil\n\t\t\t}\n\t\t}\n\t\treturn fmt.Errorf(\"could\ |
| \ not find '%v' in body '%s'\", values, string(body))\n\t}\n}" |
| - "protected function after_update($result) {\n global $DB;\n\n if\ |
| \ (!$result) {\n $this->beforeupdate = null;\n return;\n\ |
| \ }\n\n // The parent ID has changed, we need to fix all the paths\ |
| \ of the children.\n if ($this->beforeupdate->get('parentid') != $this->get('parentid'))\ |
| \ {\n $beforepath = $this->beforeupdate->get('path') . $this->get('id')\ |
| \ . '/';\n\n $like = $DB->sql_like('path', '?');\n $likesearch\ |
| \ = $DB->sql_like_escape($beforepath) . '%';\n\n $table = '{' . self::TABLE\ |
| \ . '}';\n $sql = \"UPDATE $table SET path = REPLACE(path, ?, ?) WHERE\ |
| \ \" . $like;\n $DB->execute($sql, array(\n $beforepath,\n\ |
| \ $this->get('path') . $this->get('id') . '/',\n \ |
| \ $likesearch\n ));\n\n // Resolving sortorder holes left\ |
| \ after changing parent.\n $table = '{' . self::TABLE . '}';\n \ |
| \ $sql = \"UPDATE $table SET sortorder = sortorder -1 \"\n \ |
| \ . \" WHERE competencyframeworkid = ? AND parentid = ? AND sortorder\ |
| \ > ?\";\n $DB->execute($sql, array($this->get('competencyframeworkid'),\n\ |
| \ $this->beforeupdate->get('parentid'),\n\ |
| \ $this->beforeupdate->get('sortorder')\n\ |
| \ ));\n }\n\n $this->beforeupdate\ |
| \ = null;\n }" |
| - "public PathTemplate parentTemplate() {\n int i = segments.size();\n Segment\ |
| \ seg = segments.get(--i);\n if (seg.kind() == SegmentKind.END_BINDING) {\n\ |
| \ while (i > 0 && segments.get(--i).kind() != SegmentKind.BINDING) {}\n \ |
| \ }\n if (i == 0) {\n throw new ValidationException(\"template does\ |
| \ not have a parent\");\n }\n return new PathTemplate(segments.subList(0,\ |
| \ i), urlEncoding);\n }" |
| - source_sentence: 'Build a potentially nested fieldgroup |
| |
| |
| @param mixed $valueOrGroup Value of item, or title of group |
| |
| @param string|array $titleOrOptions Title of item, or options in grouip |
| |
| @return ArrayData Data for this item' |
| sentences: |
| - "protected function getFieldOption($valueOrGroup, $titleOrOptions)\n {\n \ |
| \ // Return flat option\n if (!is_array($titleOrOptions)) {\n \ |
| \ return parent::getFieldOption($valueOrGroup, $titleOrOptions);\n \ |
| \ }\n\n // Build children from options list\n $options = new\ |
| \ ArrayList();\n foreach ($titleOrOptions as $childValue => $childTitle)\ |
| \ {\n $options->push($this->getFieldOption($childValue, $childTitle));\n\ |
| \ }\n\n return new ArrayData(array(\n 'Title' => $valueOrGroup,\n\ |
| \ 'Options' => $options\n ));\n }" |
| - "public static function minify($content, array $options = [])\n {\n \ |
| \ $min = preg_replace(['/[\\n\\r]/', '/\\>[^\\S ]+/s', '/[^\\S ]+\\</s', '/(\\\ |
| s)+/s', ], ['', '>', '<', '\\\\1'], trim($content));\n $min = str_replace(['>\ |
| \ <'], ['><'], $min);\n \n if (ArrayHelper::getValue($options, 'comments',\ |
| \ false)) {\n $min = preg_replace('/<!--(.*)-->/Uis', '', $min);\n\ |
| \ }\n \n return $min;\n }" |
| - "private function loadXInclude(XInclude $xinclude, $filePath){\n //load\ |
| \ DOMDocument\n $xml = new DOMDocument();\n $loadSuccess = $xml->load($filePath);\n\ |
| \ $node = $xml->documentElement;\n if($loadSuccess && !is_null($node)){\n\ |
| \ //parse the href content\n $parser = new ParserFactory($xml);\n\ |
| \ $parser->loadContainerStatic($node, $xinclude->getBody());\n \ |
| \ }else{\n throw new XIncludeException('Cannot load the XInclude\ |
| \ DOM XML', $xinclude);\n }\n }" |
| - source_sentence: "Check for new unread messages and send them to the custom api\n\ |
| \n @param client_id: ID of client user" |
| sentences: |
| - "public function getLatMap()\n {\n if (null === $this->latMap) {\n \ |
| \ $this->latMap = $this->getTransliterationMap(Settings::ALPHABET_LAT);\n\ |
| \ }\n\n return $this->latMap;\n }" |
| - "def check_new_messages(client_id):\n \"\"\"Check for new unread messages and\ |
| \ send them to the custom api\n\n @param client_id: ID of client user\n \ |
| \ \"\"\"\n # Return if driver is not defined or if whatsapp is not logged in.\n\ |
| \ # Stop the timer as well\n if client_id not in drivers or not drivers[client_id]\ |
| \ or not drivers[client_id].is_logged_in():\n timers[client_id].stop()\n\ |
| \ return\n\n # Acquire a lock on thread\n if not acquire_semaphore(client_id,\ |
| \ True):\n return\n\n try:\n # Get all unread messages\n \ |
| \ res = drivers[client_id].get_unread()\n # Mark all of them as seen\n\ |
| \ for message_group in res:\n message_group.chat.send_seen()\n\ |
| \ # Release thread lock\n release_semaphore(client_id)\n \ |
| \ # If we have new messages, do something with it\n if res:\n \ |
| \ print(res)\n except:\n pass\n finally:\n # Release lock\ |
| \ anyway, safekeeping\n release_semaphore(client_id)" |
| - "def get_uppermost_library_root_state(self):\n \"\"\"Find state_copy of\ |
| \ uppermost LibraryState\n\n Method checks if there is a parent library\ |
| \ root state and assigns it to be the current library root state till\n \ |
| \ there is no further parent library root state.\n \"\"\"\n\n library_root_state\ |
| \ = self.get_next_upper_library_root_state()\n parent_library_root_state\ |
| \ = library_root_state\n # initial a library root state has to be found\ |
| \ and if there is no further parent root state\n # parent_library_root_state\ |
| \ and library_root_state are no more identical\n while parent_library_root_state\ |
| \ and library_root_state is parent_library_root_state:\n if library_root_state:\n\ |
| \ parent_library_root_state = library_root_state.parent.get_next_upper_library_root_state()\n\ |
| \n if parent_library_root_state:\n library_root_state\ |
| \ = parent_library_root_state\n\n return library_root_state" |
| - source_sentence: If MultiTenantMiddleware is used, filter queryset by request.site_id |
| sentences: |
| - "def reduce_ticks(ax, which, maxticks=3):\n \"\"\"Given a pyplot axis, resamples\ |
| \ its `which`-axis ticks such that are at most\n `maxticks` left.\n\n Parameters\n\ |
| \ ----------\n ax : axis\n The axis to adjust.\n which : {'x'\ |
| \ | 'y'}\n Which axis to adjust.\n maxticks : {3, int}\n Maximum\ |
| \ number of ticks to use.\n\n Returns\n -------\n array\n An array\ |
| \ of the selected ticks.\n \"\"\"\n ticks = getattr(ax, 'get_{}ticks'.format(which))()\n\ |
| \ if len(ticks) > maxticks:\n # make sure the left/right value is not\ |
| \ at the edge\n minax, maxax = getattr(ax, 'get_{}lim'.format(which))()\n\ |
| \ dw = abs(maxax-minax)/10.\n start_idx, end_idx = 0, len(ticks)\n\ |
| \ if ticks[0] < minax + dw:\n start_idx += 1\n if ticks[-1]\ |
| \ > maxax - dw:\n end_idx -= 1\n # get reduction factor\n \ |
| \ fac = int(len(ticks) / maxticks)\n ticks = ticks[start_idx:end_idx:fac]\n\ |
| \ return ticks" |
| - "function (isPublic, name, data, ttl, published_at, coreid) {\n var rawFn\ |
| \ = function (msg) {\n try {\n msg.setMaxAge(parseInt((ttl\ |
| \ && (ttl >= 0)) ? ttl : 60));\n if (published_at) {\n \ |
| \ msg.setTimestamp(moment(published_at).toDate());\n \ |
| \ }\n }\n catch (ex) {\n logger.error(\"\ |
| onCoreHeard - \" + ex);\n }\n return msg;\n };\n\n\ |
| \ var msgName = (isPublic) ? \"PublicEvent\" : \"PrivateEvent\";\n \ |
| \ var userID = (this.userID || \"\").toLowerCase() + \"/\";\n name =\ |
| \ (name) ? name.toString() : name;\n if (name && name.indexOf && (name.indexOf(userID)\ |
| \ == 0)) {\n name = name.substring(userID.length);\n }\n\n \ |
| \ data = (data) ? data.toString() : data;\n this.sendNONTypeMessage(msgName,\ |
| \ { event_name: name, _raw: rawFn }, data);\n }" |
| - "def get_queryset(self):\n '''\n If MultiTenantMiddleware is used,\ |
| \ filter queryset by request.site_id\n '''\n queryset = super(PageList,\ |
| \ self).get_queryset()\n if hasattr(self.request, 'site_id'):\n \ |
| \ queryset = queryset.filter(site_id=self.request.site_id)\n return\ |
| \ queryset" |
| datasets: |
| - benjamintli/code-retrieval-combined-v2 |
| pipeline_tag: sentence-similarity |
| library_name: sentence-transformers |
| metrics: |
| - cosine_accuracy@1 |
| - cosine_accuracy@3 |
| - cosine_accuracy@5 |
| - cosine_accuracy@10 |
| - cosine_precision@1 |
| - cosine_precision@3 |
| - cosine_precision@5 |
| - cosine_precision@10 |
| - cosine_recall@1 |
| - cosine_recall@3 |
| - cosine_recall@5 |
| - cosine_recall@10 |
| - cosine_ndcg@10 |
| - cosine_mrr@10 |
| - cosine_map@100 |
| model-index: |
| - name: SentenceTransformer based on answerdotai/ModernBERT-base |
| results: |
| - task: |
| type: information-retrieval |
| name: Information Retrieval |
| dataset: |
| name: eval |
| type: eval |
| metrics: |
| - type: cosine_accuracy@1 |
| value: 0.873 |
| name: Cosine Accuracy@1 |
| - type: cosine_accuracy@3 |
| value: 0.9366666666666666 |
| name: Cosine Accuracy@3 |
| - type: cosine_accuracy@5 |
| value: 0.9543333333333334 |
| name: Cosine Accuracy@5 |
| - type: cosine_accuracy@10 |
| value: 0.973 |
| name: Cosine Accuracy@10 |
| - type: cosine_precision@1 |
| value: 0.873 |
| name: Cosine Precision@1 |
| - type: cosine_precision@3 |
| value: 0.31222222222222223 |
| name: Cosine Precision@3 |
| - type: cosine_precision@5 |
| value: 0.19086666666666663 |
| name: Cosine Precision@5 |
| - type: cosine_precision@10 |
| value: 0.0973 |
| name: Cosine Precision@10 |
| - type: cosine_recall@1 |
| value: 0.873 |
| name: Cosine Recall@1 |
| - type: cosine_recall@3 |
| value: 0.9366666666666666 |
| name: Cosine Recall@3 |
| - type: cosine_recall@5 |
| value: 0.9543333333333334 |
| name: Cosine Recall@5 |
| - type: cosine_recall@10 |
| value: 0.973 |
| name: Cosine Recall@10 |
| - type: cosine_ndcg@10 |
| value: 0.9240732170821061 |
| name: Cosine Ndcg@10 |
| - type: cosine_mrr@10 |
| value: 0.9082900793650796 |
| name: Cosine Mrr@10 |
| - type: cosine_map@100 |
| value: 0.9093847853022148 |
| name: Cosine Map@100 |
| --- |
| |
| # SentenceTransformer based on answerdotai/ModernBERT-base |
|
|
| This is a [sentence-transformers](https://www.SBERT.net) model finetuned from [answerdotai/ModernBERT-base](https://huggingface.co/answerdotai/ModernBERT-base) on the [code-retrieval-combined-v2](https://huggingface.co/datasets/benjamintli/code-retrieval-combined-v2) dataset. 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:** [answerdotai/ModernBERT-base](https://huggingface.co/answerdotai/ModernBERT-base) <!-- at revision 8949b909ec900327062f0ebf497f51aef5e6f0c8 --> |
| - **Maximum Sequence Length:** 1024 tokens |
| - **Output Dimensionality:** 768 dimensions |
| - **Similarity Function:** Cosine Similarity |
| - **Training Dataset:** |
| - [code-retrieval-combined-v2](https://huggingface.co/datasets/benjamintli/code-retrieval-combined-v2) |
| <!-- - **Language:** Unknown --> |
| <!-- - **License:** Unknown --> |
|
|
| ### Model Sources |
|
|
| - **Documentation:** [Sentence Transformers Documentation](https://sbert.net) |
| - **Repository:** [Sentence Transformers on GitHub](https://github.com/huggingface/sentence-transformers) |
| - **Hugging Face:** [Sentence Transformers on Hugging Face](https://huggingface.co/models?library=sentence-transformers) |
|
|
| ### Full Model Architecture |
|
|
| ``` |
| SentenceTransformer( |
| (0): Transformer({'max_seq_length': 1024, 'do_lower_case': False, 'architecture': 'OptimizedModule'}) |
| (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}) |
| ) |
| ``` |
|
|
| ## 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 SentenceTransformer |
| |
| # Download from the 🤗 Hub |
| model = SentenceTransformer("modernbert-code-v2") |
| # Run inference |
| queries = [ |
| "If MultiTenantMiddleware is used, filter queryset by request.site_id", |
| ] |
| documents = [ |
| "def get_queryset(self):\n '''\n If MultiTenantMiddleware is used, filter queryset by request.site_id\n '''\n queryset = super(PageList, self).get_queryset()\n if hasattr(self.request, 'site_id'):\n queryset = queryset.filter(site_id=self.request.site_id)\n return queryset", |
| 'def reduce_ticks(ax, which, maxticks=3):\n """Given a pyplot axis, resamples its `which`-axis ticks such that are at most\n `maxticks` left.\n\n Parameters\n ----------\n ax : axis\n The axis to adjust.\n which : {\'x\' | \'y\'}\n Which axis to adjust.\n maxticks : {3, int}\n Maximum number of ticks to use.\n\n Returns\n -------\n array\n An array of the selected ticks.\n """\n ticks = getattr(ax, \'get_{}ticks\'.format(which))()\n if len(ticks) > maxticks:\n # make sure the left/right value is not at the edge\n minax, maxax = getattr(ax, \'get_{}lim\'.format(which))()\n dw = abs(maxax-minax)/10.\n start_idx, end_idx = 0, len(ticks)\n if ticks[0] < minax + dw:\n start_idx += 1\n if ticks[-1] > maxax - dw:\n end_idx -= 1\n # get reduction factor\n fac = int(len(ticks) / maxticks)\n ticks = ticks[start_idx:end_idx:fac]\n return ticks', |
| 'function (isPublic, name, data, ttl, published_at, coreid) {\n var rawFn = function (msg) {\n try {\n msg.setMaxAge(parseInt((ttl && (ttl >= 0)) ? ttl : 60));\n if (published_at) {\n msg.setTimestamp(moment(published_at).toDate());\n }\n }\n catch (ex) {\n logger.error("onCoreHeard - " + ex);\n }\n return msg;\n };\n\n var msgName = (isPublic) ? "PublicEvent" : "PrivateEvent";\n var userID = (this.userID || "").toLowerCase() + "/";\n name = (name) ? name.toString() : name;\n if (name && name.indexOf && (name.indexOf(userID) == 0)) {\n name = name.substring(userID.length);\n }\n\n data = (data) ? data.toString() : data;\n this.sendNONTypeMessage(msgName, { event_name: name, _raw: rawFn }, data);\n }', |
| ] |
| query_embeddings = model.encode_query(queries) |
| document_embeddings = model.encode_document(documents) |
| print(query_embeddings.shape, document_embeddings.shape) |
| # [1, 768] [3, 768] |
| |
| # Get the similarity scores for the embeddings |
| similarities = model.similarity(query_embeddings, document_embeddings) |
| print(similarities) |
| # tensor([[ 0.9183, -0.0231, -0.0561]]) |
| ``` |
|
|
| <!-- |
| ### 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 |
|
|
| #### Information Retrieval |
|
|
| * Dataset: `eval` |
| * Evaluated with [<code>InformationRetrievalEvaluator</code>](https://sbert.net/docs/package_reference/sentence_transformer/evaluation.html#sentence_transformers.evaluation.InformationRetrievalEvaluator) |
|
|
| | Metric | Value | |
| |:--------------------|:-----------| |
| | cosine_accuracy@1 | 0.873 | |
| | cosine_accuracy@3 | 0.9367 | |
| | cosine_accuracy@5 | 0.9543 | |
| | cosine_accuracy@10 | 0.973 | |
| | cosine_precision@1 | 0.873 | |
| | cosine_precision@3 | 0.3122 | |
| | cosine_precision@5 | 0.1909 | |
| | cosine_precision@10 | 0.0973 | |
| | cosine_recall@1 | 0.873 | |
| | cosine_recall@3 | 0.9367 | |
| | cosine_recall@5 | 0.9543 | |
| | cosine_recall@10 | 0.973 | |
| | **cosine_ndcg@10** | **0.9241** | |
| | cosine_mrr@10 | 0.9083 | |
| | cosine_map@100 | 0.9094 | |
| |
| <!-- |
| ## 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 Dataset |
| |
| #### code-retrieval-combined-v2 |
| |
| * Dataset: [code-retrieval-combined-v2](https://huggingface.co/datasets/benjamintli/code-retrieval-combined-v2) at [2b971a6](https://huggingface.co/datasets/benjamintli/code-retrieval-combined-v2/tree/2b971a6d597823ab7ff10b898ae6f3c0fdbbfa23) |
| * Size: 283,621 training samples |
| * Columns: <code>query</code> and <code>positive</code> |
| * Approximate statistics based on the first 1000 samples: |
| | | query | positive | |
| |:--------|:-----------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------| |
| | type | string | string | |
| | details | <ul><li>min: 5 tokens</li><li>mean: 44.94 tokens</li><li>max: 856 tokens</li></ul> | <ul><li>min: 30 tokens</li><li>mean: 181.2 tokens</li><li>max: 1024 tokens</li></ul> | |
| * Samples: |
| | query | positive | |
| |:---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|:---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------| |
| | <code>Start the asyncio event loop and runs the application.</code> | <code>def main():<br> """Start the asyncio event loop and runs the application."""<br> # Helper method so that the coroutine exits cleanly if an exception<br> # happens (which would leave resources dangling)<br> async def _run_application(loop):<br> try:<br> return await cli_handler(loop)<br><br> except KeyboardInterrupt:<br> pass # User pressed Ctrl+C, just ignore it<br><br> except SystemExit:<br> pass # sys.exit() was used - do nothing<br><br> except: # pylint: disable=bare-except # noqa<br> import traceback<br><br> traceback.print_exc(file=sys.stderr)<br> sys.stderr.writelines(<br> '\n>>> An error occurred, full stack trace above\n')<br><br> return 1<br><br> try:<br> loop = asyncio.get_event_loop()<br> return loop.run_until_complete(_run_application(loop))<br> except KeyboardInterrupt:<br> pass<br><br> return 1</code> | |
| | <code>Initialize the pool manager with the number of pools, the entry sizes for each<br>pool, and the maximum depth of the free pool.<br><br>@param bufferEntrySizes the memory sizes of each entry in the pools<br>@param bufferEntryDepths the maximum number of entries in the free pool</code> | <code>public void initialize(int[] bufferEntrySizes, int[] bufferEntryDepths) {<br> if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {<br> Tr.entry(tc, "initialize");<br> }<br><br> // order both lists from smallest to largest, based only on Entry Sizes<br> int len = bufferEntrySizes.length;<br> int[] bSizes = new int[len];<br> int[] bDepths = new int[len];<br> int sizeCompare;<br> int depth;<br> int sizeSort;<br> int j;<br><br> for (int i = 0; i < len; i++) {<br> sizeCompare = bufferEntrySizes[i];<br> depth = bufferEntryDepths[i];<br> // go backwards, for speed, since first Array List is<br> // probably already ordered small to large<br> for (j = i - 1; j >= 0; j--) {<br> sizeSort = bSizes[j];<br> if (sizeCompare > sizeSort) {<br> // add the bigger one after the smaller one<br> bSizes[j + 1] = sizeCompare;<br> bDepths[j ...</code> | |
| | <code>// List lists all of the documents in an index. The documents are returned in<br>// increasing ID order.</code> | <code>func (x *Index) List(c context.Context, opts *ListOptions) *Iterator {<br> t := &Iterator{<br> c: c,<br> index: x,<br> count: -1,<br> listInclusive: true,<br> more: moreList,<br> limit: -1,<br> }<br> if opts != nil {<br> t.listStartID = opts.StartID<br> if opts.Limit > 0 {<br> t.limit = opts.Limit<br> }<br> t.idsOnly = opts.IDsOnly<br> }<br> return t<br>}</code> | |
| * Loss: [<code>CachedMultipleNegativesRankingLoss</code>](https://sbert.net/docs/package_reference/sentence_transformer/losses.html#cachedmultiplenegativesrankingloss) with these parameters: |
| ```json |
| { |
| "scale": 20.0, |
| "similarity_fct": "cos_sim", |
| "mini_batch_size": 128, |
| "gather_across_devices": false, |
| "directions": [ |
| "query_to_doc" |
| ], |
| "partition_mode": "joint", |
| "hardness_mode": null, |
| "hardness_strength": 0.0 |
| } |
| ``` |
| |
| ### Evaluation Dataset |
| |
| #### code-retrieval-combined-v2 |
| |
| * Dataset: [code-retrieval-combined-v2](https://huggingface.co/datasets/benjamintli/code-retrieval-combined-v2) at [2b971a6](https://huggingface.co/datasets/benjamintli/code-retrieval-combined-v2/tree/2b971a6d597823ab7ff10b898ae6f3c0fdbbfa23) |
| * Size: 31,516 evaluation samples |
| * Columns: <code>query</code> and <code>positive</code> |
| * Approximate statistics based on the first 1000 samples: |
| | | query | positive | |
| |:--------|:-----------------------------------------------------------------------------------|:--------------------------------------------------------------------------------------| |
| | type | string | string | |
| | details | <ul><li>min: 5 tokens</li><li>mean: 42.73 tokens</li><li>max: 834 tokens</li></ul> | <ul><li>min: 30 tokens</li><li>mean: 180.42 tokens</li><li>max: 1024 tokens</li></ul> | |
| * Samples: |
| | query | positive | |
| |:---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|:---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------| |
| | <code>This gets the version of OpenALPR<br><br> :return: Version information</code> | <code>def get_version(self):<br> """<br> This gets the version of OpenALPR<br><br> :return: Version information<br> """<br><br> ptr = self._get_version_func(self.alpr_pointer)<br> version_number = ctypes.cast(ptr, ctypes.c_char_p).value<br> version_number = _convert_from_charp(version_number)<br> self._free_json_mem_func(ctypes.c_void_p(ptr))<br> return version_number</code> | |
| | <code>Remove all unnecessary comments from a lexer or parser file</code> | <code>public String stripUnnecessaryComments(String javaContent, AntlrOptions options) {<br> if (!options.isOptimizeCodeQuality()) {<br> return javaContent;<br> }<br> javaContent = stripMachineDependentPaths(javaContent);<br> if (options.isStripAllComments()) {<br> javaContent = stripAllComments(javaContent);<br> }<br> return javaContent;<br> }</code> | |
| | <code>Serialize reply to array or JSON.<br><br>@param {Object} packet<br>@param {String} packet.method "get", "search", "post", "put", "delete", "sub", "unsub".<br>@param {String} packet.resource<br>@param {String} packet.id<br>@param {*} packet.body<br>@param {Number} [packet.status]<br>@param {Number\|String} [packet.date]<br>@param {Object} [packet.headers]<br>@param {Boolean} [json] true to generate JSON instead of array.<br>@returns {Array\|String\|null}</code> | <code>function reply(packet, json) {<br> return _create(packet, packet.status \|\| 500, (METHODS[packet.method] \|\| '') + packet.resource, json);<br>}</code> | |
| * Loss: [<code>CachedMultipleNegativesRankingLoss</code>](https://sbert.net/docs/package_reference/sentence_transformer/losses.html#cachedmultiplenegativesrankingloss) with these parameters: |
| ```json |
| { |
| "scale": 20.0, |
| "similarity_fct": "cos_sim", |
| "mini_batch_size": 128, |
| "gather_across_devices": false, |
| "directions": [ |
| "query_to_doc" |
| ], |
| "partition_mode": "joint", |
| "hardness_mode": null, |
| "hardness_strength": 0.0 |
| } |
| ``` |
| |
| ### Training Hyperparameters |
| #### Non-Default Hyperparameters |
| |
| - `eval_strategy`: steps |
| - `per_device_train_batch_size`: 1024 |
| - `per_device_eval_batch_size`: 1024 |
| - `learning_rate`: 8e-05 |
| - `num_train_epochs`: 1 |
| - `warmup_steps`: 0.05 |
| - `bf16`: True |
| - `dataloader_num_workers`: 4 |
| - `load_best_model_at_end`: True |
| - `push_to_hub`: True |
| - `hub_model_id`: modernbert-code-v2 |
| - `batch_sampler`: no_duplicates |
| |
| #### All Hyperparameters |
| <details><summary>Click to expand</summary> |
| |
| - `do_predict`: False |
| - `eval_strategy`: steps |
| - `prediction_loss_only`: True |
| - `per_device_train_batch_size`: 1024 |
| - `per_device_eval_batch_size`: 1024 |
| - `gradient_accumulation_steps`: 1 |
| - `eval_accumulation_steps`: None |
| - `torch_empty_cache_steps`: None |
| - `learning_rate`: 8e-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`: 1 |
| - `max_steps`: -1 |
| - `lr_scheduler_type`: linear |
| - `lr_scheduler_kwargs`: None |
| - `warmup_ratio`: None |
| - `warmup_steps`: 0.05 |
| - `log_level`: passive |
| - `log_level_replica`: warning |
| - `log_on_each_node`: True |
| - `logging_nan_inf_filter`: True |
| - `enable_jit_checkpoint`: False |
| - `save_on_each_node`: False |
| - `save_only_model`: False |
| - `restore_callback_states_from_checkpoint`: False |
| - `use_cpu`: False |
| - `seed`: 42 |
| - `data_seed`: None |
| - `bf16`: True |
| - `fp16`: False |
| - `bf16_full_eval`: False |
| - `fp16_full_eval`: False |
| - `tf32`: None |
| - `local_rank`: -1 |
| - `ddp_backend`: None |
| - `debug`: [] |
| - `dataloader_drop_last`: False |
| - `dataloader_num_workers`: 4 |
| - `dataloader_prefetch_factor`: None |
| - `disable_tqdm`: False |
| - `remove_unused_columns`: True |
| - `label_names`: None |
| - `load_best_model_at_end`: True |
| - `ignore_data_skip`: False |
| - `fsdp`: [] |
| - `fsdp_config`: {'min_num_params': 0, 'xla': False, 'xla_fsdp_v2': False, 'xla_fsdp_grad_ckpt': False} |
| - `accelerator_config`: {'split_batches': False, 'dispatch_batches': None, 'even_batches': True, 'use_seedable_sampler': True, 'non_blocking': False, 'gradient_accumulation_kwargs': None} |
| - `parallelism_config`: None |
| - `deepspeed`: None |
| - `label_smoothing_factor`: 0.0 |
| - `optim`: adamw_torch_fused |
| - `optim_args`: None |
| - `group_by_length`: False |
| - `length_column_name`: length |
| - `project`: huggingface |
| - `trackio_space_id`: trackio |
| - `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 |
| - `push_to_hub`: True |
| - `resume_from_checkpoint`: None |
| - `hub_model_id`: modernbert-code-v2 |
| - `hub_strategy`: every_save |
| - `hub_private_repo`: None |
| - `hub_always_push`: False |
| - `hub_revision`: None |
| - `gradient_checkpointing`: False |
| - `gradient_checkpointing_kwargs`: None |
| - `include_for_metrics`: [] |
| - `eval_do_concat_batches`: True |
| - `auto_find_batch_size`: False |
| - `full_determinism`: False |
| - `ddp_timeout`: 1800 |
| - `torch_compile`: False |
| - `torch_compile_backend`: None |
| - `torch_compile_mode`: None |
| - `include_num_input_tokens_seen`: no |
| - `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`: True |
| - `use_cache`: 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 | eval_cosine_ndcg@10 | |
| |:----------:|:-------:|:-------------:|:---------------:|:-------------------:| |
| | 0.0722 | 20 | 3.9983 | 1.3745 | 0.7545 | |
| | 0.1444 | 40 | 1.0297 | 0.7864 | 0.8493 | |
| | 0.2166 | 60 | 0.6830 | 0.5917 | 0.8833 | |
| | 0.2888 | 80 | 0.5476 | 0.5128 | 0.8973 | |
| | 0.3610 | 100 | 0.4891 | 0.4641 | 0.9028 | |
| | 0.4332 | 120 | 0.4436 | 0.4370 | 0.9098 | |
| | 0.5054 | 140 | 0.4304 | 0.4151 | 0.9154 | |
| | 0.5776 | 160 | 0.4101 | 0.3948 | 0.9161 | |
| | 0.6498 | 180 | 0.3910 | 0.3829 | 0.9190 | |
| | 0.7220 | 200 | 0.3794 | 0.3729 | 0.9188 | |
| | 0.7942 | 220 | 0.3668 | 0.3650 | 0.9207 | |
| | 0.8664 | 240 | 0.3683 | 0.3573 | 0.9230 | |
| | **0.9386** | **260** | **0.359** | **0.3534** | **0.9241** | |
|
|
| * The bold row denotes the saved checkpoint. |
|
|
| ### Framework Versions |
| - Python: 3.12.12 |
| - Sentence Transformers: 5.3.0 |
| - Transformers: 5.0.0 |
| - PyTorch: 2.10.0+cu128 |
| - Accelerate: 1.13.0 |
| - Datasets: 4.0.0 |
| - Tokenizers: 0.22.2 |
|
|
| ## 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", |
| } |
| ``` |
|
|
| #### CachedMultipleNegativesRankingLoss |
| ```bibtex |
| @misc{gao2021scaling, |
| title={Scaling Deep Contrastive Learning Batch Size under Memory Limited Setup}, |
| author={Luyu Gao and Yunyi Zhang and Jiawei Han and Jamie Callan}, |
| year={2021}, |
| eprint={2101.06983}, |
| archivePrefix={arXiv}, |
| primaryClass={cs.LG} |
| } |
| ``` |
|
|
| <!-- |
| ## 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.* |
| --> |
