code_retriever_ru_en

SentenceTransformer

This is a sentence-transformers model trained on the cornstack_python, cornstack_python_pairs, codesearchnet, codesearchnet_pairs and solyanka_qa datasets. It maps sentences & paragraphs to a 768-dimensional dense vector space.

Model can be used for text-to-code, code-to-text retrieval tasks where text is in Russian/English and code is in Python/Java/Javascript/Go/Php/Ruby. Queries, documents also can be mix of natural language text and code. The quality of the model in code-to-code tasks wasn't measured.

Model Details

Model Description

• Model Type: Sentence Transformer
• Base model: RuModernBERT-base
• Maximum Sequence Length: 8192 tokens
• Output Dimensionality: 768 dimensions (can be trimmed to 512/256/128/64)
• Similarity Function: Cosine Similarity
• Training Datasets:
  • cornstack_python
  • cornstack_python_pairs
  • codesearchnet
  • codesearchnet_pairs
  • solyanka_qa

<!-- - **License:** Unknown -->

Full Model Architecture

SentenceTransformer(
  (0): Transformer({'max_seq_length': 8192, 'do_lower_case': False, 'architecture': 'ModernBertModel'})
  (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:

pip install -U sentence-transformers

Then you can load this model and run inference.

import torch
from sentence_transformers import SentenceTransformer, util

device = "cuda" if torch.cuda.is_available() else "cpu"
model = SentenceTransformer("fyaronskiy/code_retriever_ru_en").to(device)

queries_ru = [
    "Напиши функцию на Python, которая рекурсивно вычисляет факториал числа.",
    "Как проверить, является ли строка палиндромом?",
    "Объедини два отсортированных списка в один отсортированный список."
]

corpus_ru = [
    # Релевантный для Q1
    """def factorial(n):
    if n == 0:
        return 1
    return n * factorial(n - 1)""",

    # Hard negative для Q1
    """def sum_recursive(n):
    if n == 0:
        return 0
    return n + sum_recursive(n - 1)""",

    # Релевантный для Q2
    """def is_palindrome(s: str) -> bool:
    s = s.lower().replace(" ", "")
    return s == s[::-1]""",

    # Hard negative для Q2
    """def reverse_string(s: str) -> str:
    return s[::-1]""",

    # Релевантный для Q3
    """def merge_sorted_lists(a, b):
    result = []
    i = j = 0
    while i < len(a) and j < len(b):
        if a[i] < b[j]:
            result.append(a[i])
            i += 1
        else:
            result.append(b[j])
            j += 1
    result.extend(a[i:])
    result.extend(b[j:])
    return result""",

    # Hard negative для Q3
    """def add_lists(a, b):
    return [x + y for x, y in zip(a, b)]"""
]

doc_embeddings = model.encode(corpus_ru, convert_to_tensor=True, device=device)
query_embeddings = model.encode(queries_ru, convert_to_tensor=True, device=device)

# Выполняем поиск по каждому запросу
for i, query in enumerate(queries_ru):
    scores = util.cos_sim(query_embeddings[i], doc_embeddings)[0]
    best_idx = torch.argmax(scores).item()
    print(f"\nЗапрос {i+1}: {query}")
    print('Скоры всех документов в корпусе: ', scores)
    print(f"Наиболее подходящий документ (Скор={scores[best_idx]:.4f}):\n{corpus_ru[best_idx]}")

Model was trained with Matryoshka Loss with dims: 768, 512, 256, 128, 64. So for decreasing memory for your vector databaset and make inference faster you can truncate embeddings.

To do this you need to initialize model as follows:

matryoshka_dim = 128
model = SentenceTransformer("fyaronskiy/code_retriever_ru_en", truncate_dim=matryoshka_dim).to(device)

<!-- ### 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

Perfomance on code retrieval benchmark ruCoIR:

Metrics

Information Retrieval

• Evaluated with <code>InformationRetrievalEvaluator</code>

Information Retrieval

• Evaluated with <code>InformationRetrievalEvaluator</code>

<!-- ## 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>cornstack_python</summary>

cornstack_python

• Dataset: cornstack_python
• Size: 2,869,969 training samples
• Columns: <code>ru_query</code>, <code>document</code>, <code>negative_0</code>, <code>negative_1</code>, <code>negative_2</code>, <code>negative_3</code>, <code>negative_4</code>, <code>negative_5</code>, <code>negative_6</code>, <code>negative_7</code>, <code>negative_8</code>, <code>negative_9</code>, <code>negative_10</code>, <code>negative_11</code>, <code>negative_12</code>, <code>negative_13</code>, <code>negative_14</code>, and <code>negative_15</code>
• Approximate statistics based on the first 1000 samples:

  	ru_query	document	negative_0	negative_1	negative_2	negative_3	negative_4	negative_5	negative_6	negative_7	negative_8	negative_9	negative_10	negative_11	negative_12	negative_13	negative_14	negative_15
  type	string	string	string	string	string	string	string	string	string	string	string	string	string	string	string	string	string	string
  details	<ul><li>min: 7 tokens</li><li>mean: 27.46 tokens</li><li>max: 162 tokens</li></ul>	<ul><li>min: 6 tokens</li><li>mean: 304.38 tokens</li><li>max: 5574 tokens</li></ul>	<ul><li>min: 6 tokens</li><li>mean: 237.08 tokens</li><li>max: 3627 tokens</li></ul>	<ul><li>min: 6 tokens</li><li>mean: 229.94 tokens</li><li>max: 6691 tokens</li></ul>	<ul><li>min: 6 tokens</li><li>mean: 230.06 tokens</li><li>max: 6229 tokens</li></ul>	<ul><li>min: 7 tokens</li><li>mean: 230.7 tokens</li><li>max: 4876 tokens</li></ul>	<ul><li>min: 8 tokens</li><li>mean: 220.57 tokens</li><li>max: 4876 tokens</li></ul>	<ul><li>min: 7 tokens</li><li>mean: 236.08 tokens</li><li>max: 5880 tokens</li></ul>	<ul><li>min: 6 tokens</li><li>mean: 247.91 tokens</li><li>max: 6621 tokens</li></ul>	<ul><li>min: 6 tokens</li><li>mean: 207.62 tokens</li><li>max: 3350 tokens</li></ul>	<ul><li>min: 6 tokens</li><li>mean: 222.54 tokens</li><li>max: 6863 tokens</li></ul>	<ul><li>min: 6 tokens</li><li>mean: 221.53 tokens</li><li>max: 4976 tokens</li></ul>	<ul><li>min: 7 tokens</li><li>mean: 216.06 tokens</li><li>max: 4876 tokens</li></ul>	<ul><li>min: 7 tokens</li><li>mean: 197.03 tokens</li><li>max: 4763 tokens</li></ul>	<ul><li>min: 6 tokens</li><li>mean: 200.83 tokens</li><li>max: 8192 tokens</li></ul>	<ul><li>min: 6 tokens</li><li>mean: 204.94 tokens</li><li>max: 3210 tokens</li></ul>	<ul><li>min: 6 tokens</li><li>mean: 188.51 tokens</li><li>max: 2754 tokens</li></ul>	<ul><li>min: 6 tokens</li><li>mean: 188.27 tokens</li><li>max: 4876 tokens</li></ul>

• Samples:

  ru_query	document	negative_0	negative_1	negative_2	negative_3	negative_4	negative_5	negative_6	negative_7	negative_8	negative_9	negative_10	negative_11	negative_12	negative_13	negative_14	negative_15
  <code>установите значение business_id сообщения данных в конкретное значение</code>	<code>def step_impl_the_ru_is_set_to(context, business_id):<br> context.bdd_helper.message_data["business_id"] = business_id</code>	<code>def business_id(self, business_id):<br><br> self._business_id = business_id</code>	<code>def business_phone(self, business_phone):<br><br> self._business_phone = business_phone</code>	<code>def business_phone_number(self, business_phone_number):<br><br> self._business_phone_number = business_phone_number</code>	<code>def bus_ob_id(self, bus_ob_id):<br><br> self._bus_ob_id = bus_ob_id</code>	<code>def bus_ob_id(self, bus_ob_id):<br><br> self._bus_ob_id = bus_ob_id</code>	<code>def _set_id(self, value):<br> pass</code>	<code>def business_email(self, business_email):<br><br> self._business_email = business_email</code>	<code>def mailing_id(self, val: str):<br> self._mailing_id = val</code>	<code>def message_id(self, val: str):<br> self._message_id = val</code>	<code>def business_model(self, business_model):<br><br> self._business_model = business_model</code>	<code>def business_account(self, business_account):<br><br> self._business_account = business_account</code>	<code>def update_business(current_user, businessId):<br> business = Business.query.get(int(businessId))<br><br> if not business:<br> return make_json_reply('message', 'Business id does not exist'), 404<br><br> if business.user_id != current_user.id:<br> return make_json_reply('message', 'Cannot update business'), 400<br><br> data = request.get_json(force=True)<br> name = location = category = description = None<br><br> if 'name' in data.keys():<br> name = data['name']<br><br> if 'location' in data.keys():<br> location = data['location']<br><br> if 'category' in data.keys():<br> category = data['category']<br><br> if 'description' in data.keys():<br> description = data['description']<br><br> if check_validity_of_input(name=name):<br> business.name = name<br><br> if check_validity_of_input(location=location):<br> business.location = location<br><br> if check_validity_of_input(category=category):<br> business.category = category<br><br> if check_validity_of_input(description=description):<br> ...</code>	<code>def set_company_id_value(self, company_id_value):<br> self.company_id_value = company_id_value</code>	<code>def id(self, value):<br> self._id = value</code>	<code>def set_bribe(self, bribe_amount):
  <br> self.bribe = bribe_amount</code>	<code>def business_owner(self, business_owner):<br><br> self._business_owner = business_owner</code>
  <code>Установить состояние правил sid</code>	<code>def set_state_sid_request(ruleset_name, sid):<br> message = json.loads(request.stream.read().decode('utf-8'))<br> message['sid'] = sid<br> result = host.patch_state(ruleset_name, message)<br> return jsonify(result)</code>	<code>def sid(self, sid):<br> self._sid = sid</code>	<code>def set_state(self,s):<br> self.state = s</code>	<code>def set_state(self, state: int):</code>	<code>def setstate(self, state):<br><br> self.set(DER = state)</code>	<code>def set_rule(self, rule):<br> self.rule.load_state_dict(rule, strict=True)</code>	<code>def _set_state(self, state):<br> #print("** set state from %d to %d" % (self.state, state))<br> self.state = state</code>	<code>def set_state( self ):</code>	<code>def set_ident(self, new_ident: int):<br> if not isinstance(new_ident, int):<br> raise TypeError("Spectrum set identifiers may ONLY be positive integers")<br> self._set_ident = new_ident</code>	<code>def set_state(self, state):<br> #print("ComponentBase.set_state")<br> for k,v in state.items():<br> #print(" Set {:14s} to {:s}".format(k,str(v)))<br> if k == "connectors":<br> for con_state in v:<br> self.add_connector() <br> self.connectors[-1].set_state(con_state)<br> else:<br> setattr(self, k, v)</code>	<code>def setstate(self, state):<br><br> self.list = state</code>	<code>def setstate(self, state):<br><br> self.list = state</code>	<code>def state_id(self, state_id):<br><br> self._state_id = state_id</code>	<code>def set_state(self, state: int):<br> self.state = state</code>	<code>def set_domain_sid(self, sid):<br> dsdb._samdb_set_domain_sid(self, sid)</code>	<code>def set_state(self,state):<br> self.__state = state</code>	<code>def set_srid(self, srid: ir.IntegerValue) -> GeoSpatialValue:<br> return ops.GeoSetSRID(self, srid=srid).to_expr()</code>
  <code>Отправить события sid в ruleset</code>	<code>def post_sid_events(ruleset_name, sid):<br> message = json.loads(request.stream.read().decode('utf-8'))<br> message['sid'] = sid<br> result = host.post(ruleset_name, message)<br> return jsonify(result)</code>	<code>def post_events(ruleset_name):<br> message = json.loads(request.stream.read().decode('utf-8'))<br> result = host.post(ruleset_name, message)<br> return jsonify(result)</code>	<code>def set_state_sid_request(ruleset_name, sid):<br> message = json.loads(request.stream.read().decode('utf-8'))<br> message['sid'] = sid<br> result = host.patch_state(ruleset_name, message)<br> return jsonify(result)</code>	<code>def sid(self, sid):<br> self._sid = sid</code>	<code>def post(self, request, *args, **kwargs):<br> <br> id = args[0] if args else list(kwargs.values())[0]<br> try:<br> ssn = Subscription.objects.get(id=id)<br> except Subscription.DoesNotExist:<br> logger.error(<br> f'Received unwanted subscription {id} POST request! Sending status '<br> '410 back to hub.'<br> )<br> return Response('Unwanted subscription', status=410)<br> <br> ssn.update(time_last_event_received=now())<br> self.handler_task.delay(request.data)<br> return Response('') # TODO</code>	<code>def informed_consent_on_post_save(sender, instance, raw, created, **kwargs):<br> if not raw:<br> if created:<br> pass<br> # instance.registration_update_or_create()<br> # update_model_fields(instance=instance,<br> # model_cls=['subject_identifier', instance.subject_identifier])<br> try:<br> OnSchedule.objects.get(<br> subject_identifier=instance.subject_identifier, )<br> except OnSchedule.DoesNotExist:<br> onschedule_model = 'training_subject.onschedule'<br> put_on_schedule(schedule_name='training_subject_visit_schedule', instance=instance, onschedule_model=onschedule_model)</code>	<code>def post_event(self, event):
  <br> from evennia.scripts.models import ScriptDB

  <br> <br> if event.public_event: <br> event_manager = ScriptDB.objects.get(db_key="Event Manager") <br> event_manager.post_event(event, self.owner.player, event.display())</code> | <code>def post(self, event, *args, **kwargs):<br> self.inq.Signal((event, args, kwargs))</code> | <code>def post(self, request):<br> return self.serviceHandler.addEvent(request.data)</code> | <code>def register_to_event(request):<br> pass</code> | <code>def setFilterOnRule(request):<br> <br> logger = logging.getLogger(__name__)<br> <br> # Get some initial post values for processing.<br> ruleIds = request.POST.getlist('id')<br> sensors = request.POST.getlist('sensors')<br> commentString = request.POST['comment']<br> force = request.POST['force']<br> response = []<br> <br> # If the ruleIds list is empty, it means a SID has been entered manually.<br> if len(ruleIds) == 0:<br> # Grab the value from the POST.<br> ruleSID = request.POST['sid']<br> <br> # Match the GID:SID pattern, if its not there, throw exception.<br> try:<br> matchPattern = r"(\d+):(\d+)"<br> pattern = re.compile(matchPattern)<br> result = pattern.match(ruleSID)<br> <br> ruleGID = result.group(1)<br> ruleSID = result.group(2)<br> except:<br> response.append({'response': 'invalidGIDSIDFormat', 'text': 'Please format in the GID:SID syntax.'})<br> logger.warning("Invalid GID:SID syntax provided: "+str(ruleSID)+".")<br> return HttpResponse(json.dumps(response))<br> <br> # Try to find a generator object with the GID supplied, if it does...</code> | <code>def store_event(self, violations):<br> current_time = datetime.now().strftime("%Y/%m/%d %H:%M:%S")<br> insert_query = """INSERT INTO social_distancing (Location, Local_Time, Violations) VALUES ('{}', '{}', {})""".format(self.location, current_time, violations)<br> self.off_chain.insert(insert_query)<br><br> event_id = self.off_chain.select("""SELECT LAST_INSERT_ID() FROM social_distancing""")[0][0]<br> self.on_chain.store_hash(event_id, self.location, current_time, violations)</code> | <code>def test_post_event_on_schedule_page(self):<br> json_data = {<br> 'title': 'Test Event',<br> 'start': '2017-8-8T12:00:00',<br> 'end': '2017-8-8T12:00:00',<br> 'group': '3'<br> }<br><br> response = self.app.post("/saveEvent", data=json.dumps(json_data),<br> content_type='application/json')<br> self.assertTrue(response.status_code, 200)</code> | <code>def _push(self, server):<br> defns = [self.get_id(ident) for ident in list(self.ids)]<br> #for ident in list(self.ids):<br> # defn = self.get_id(ident)<br> if len(defns) == 0:<br> return<br> self.app.logger.info(f"Updating {server} with {len(defns)} records")<br> url = f"{server}/add_record"<br> try:<br> resp = requests.post(url, json=defns)<br> except Exception as e:<br> self.app.logger.error(str(e))<br> return<br> if not resp.ok:<br> self.app.logger.error(f"{resp.reason} {resp.content}")<br> return<br> self._server_updated[server] = True</code> | <code>def post(self, slug = None, eid = None):<br> uid = self.request.form.get("uid")<br> status = self.request.form.get("status") # can be join, maybe, notgoubg<br> event = self.barcamp.get_event(eid)<br> <br> user = self.app.module_map.userbase.get_user_by_id(uid)<br><br> reg = RegistrationService(self, user)<br> try:<br> status = reg.set_status(eid, status, force=True)<br> except RegistrationError, e:<br> print "a registration error occurred", e<br> raise ProcessingError(str(e))<br> return <br><br> return {'status' : 'success', 'reload' : True}</code> | <code>def events(self):</code> | <code>def post(self):<br><br> # we need a unique tx number so we can look these back up again<br> # as well as for logging<br> # FIXME: how can we guarantee uniqueness here?<br> tx = int(time.time() * 100000) + random.randrange(10000, 99999)<br><br> log.info("EVENTS [{}]: Creating events".format(tx))<br><br> try:<br> user = self.jbody["user"]<br> if not EMAIL_REGEX.match(user):<br> user += "@" + self.domain<br> event_type_id = self.jbody.get("eventTypeId", None)<br> category = self.jbody.get("category", None)<br> state = self.jbody.get("state", None)<br> note = self.jbody.get("note", None)<br> except KeyError as err:<br> raise exc.BadRequest(<br> "Missing Required Argument: {}".format(err.message)<br> )<br> except ValueError as err:<br> raise exc.BadRequest(err.message)<br><br> if not event_type_id and (not category and not state):<br> raise exc.BadRequest(<br> ...</code> |
• Loss: <code>MatryoshkaLoss</code> with these parameters:

  {
      "loss": "CachedMultipleNegativesRankingLoss",
      "matryoshka_dims": [
          768,
          512,
          256,
          128,
          64
      ],
      "matryoshka_weights": [
          1,
          1,
          1,
          1,
          1
      ],
      "n_dims_per_step": -1
  }
  

</details> <details><summary>cornstack_python_pairs</summary>

cornstack_python_pairs

• Dataset: cornstack_python_pairs
• Size: 1,434,984 training samples
• Columns: <code>en_query</code>, <code>ru_query</code>, and <code>label</code>
• Approximate statistics based on the first 1000 samples:

  	en_query	ru_query	label
  type	string	string	float
  details	<ul><li>min: 7 tokens</li><li>mean: 26.96 tokens</li><li>max: 150 tokens</li></ul>	<ul><li>min: 7 tokens</li><li>mean: 27.46 tokens</li><li>max: 162 tokens</li></ul>	<ul><li>min: 1.0</li><li>mean: 1.0</li><li>max: 1.0</li></ul>

• Samples:

  en_query	ru_query	label
  <code>set the message data business_id to a specific value</code>	<code>установите значение business_id сообщения данных в конкретное значение</code>	<code>1.0</code>
  <code>Set ruleset state sid</code>	<code>Установить состояние правил sid</code>	<code>1.0</code>
  <code>Post sid events to the ruleset</code>	<code>Отправить события sid в ruleset</code>	<code>1.0</code>

• Loss: <code>MatryoshkaLoss</code> with these parameters:

  {
      "loss": "CoSENTLoss",
      "matryoshka_dims": [
          768,
          512,
          256,
          128,
          64
      ],
      "matryoshka_weights": [
          1,
          1,
          1,
          1,
          1
      ],
      "n_dims_per_step": -1
  }
  

</details> <details><summary>codesearchnet</summary>

codesearchnet

• Dataset: codesearchnet at 3f90200
• Size: 1,880,853 training samples
• Columns: <code>ru_func_documentation_string</code> and <code>func_code_string</code>
• Approximate statistics based on the first 1000 samples:

  	ru_func_documentation_string	func_code_string
  type	string	string
  details	<ul><li>min: 5 tokens</li><li>mean: 95.0 tokens</li><li>max: 619 tokens</li></ul>	<ul><li>min: 62 tokens</li><li>mean: 522.56 tokens</li><li>max: 8192 tokens</li></ul>

• Samples:

  ru_func_documentation_string	func_code_string
  <code>Мультипроцессинг-целевой объект для устройства очереди zmq</code>	<code>def zmq_device(self):<br> '''<br> Multiprocessing target for the zmq queue device<br> '''<br> self.__setup_signals()<br> salt.utils.process.appendproctitle('MWorkerQueue')<br> self.context = zmq.Context(self.opts['worker_threads'])<br> # Prepare the zeromq sockets<br> self.uri = 'tcp://{interface}:{ret_port}'.format(**self.opts)<br> self.clients = self.context.socket(zmq.ROUTER)<br> if self.opts['ipv6'] is True and hasattr(zmq, 'IPV4ONLY'):<br> # IPv6 sockets work for both IPv6 and IPv4 addresses<br> self.clients.setsockopt(zmq.IPV4ONLY, 0)<br> self.clients.setsockopt(zmq.BACKLOG, self.opts.get('zmq_backlog', 1000))<br> self._start_zmq_monitor()<br> self.workers = self.context.socket(zmq.DEALER)<br><br> if self.opts.get('ipc_mode', '') == 'tcp':<br> self.w_uri = 'tcp://127.0.0.1:{0}'.format(<br> self.opts.get('tcp_master_workers', 4515)<br> )<br> else:<br> self.w_uri = 'ipc:...</code>
  <code>Чисто завершите работу сокета роутера</code>	<code>def close(self):<br> '''<br> Cleanly shutdown the router socket<br> '''<br> if self._closing:<br> return<br> log.info('MWorkerQueue under PID %s is closing', os.getpid())<br> self._closing = True<br> # pylint: disable=E0203<br> if getattr(self, '_monitor', None) is not None:<br> self._monitor.stop()<br> self._monitor = None<br> if getattr(self, '_w_monitor', None) is not None:<br> self._w_monitor.stop()<br> self._w_monitor = None<br> if hasattr(self, 'clients') and self.clients.closed is False:<br> self.clients.close()<br> if hasattr(self, 'workers') and self.workers.closed is False:<br> self.workers.close()<br> if hasattr(self, 'stream'):<br> self.stream.close()<br> if hasattr(self, '_socket') and self._socket.closed is False:<br> self._socket.close()<br> if hasattr(self, 'context') and self.context.closed is False:<br> self.context.term()</code>
  <code>До форка нам нужно создать устройство zmq роутера<br><br> :param func process_manager: Экземпляр класса salt.utils.process.ProcessManager</code>	<code>def pre_fork(self, process_manager):<br> '''<br> Pre-fork we need to create the zmq router device<br><br> :param func process_manager: An instance of salt.utils.process.ProcessManager<br> '''<br> salt.transport.mixins.auth.AESReqServerMixin.pre_fork(self, process_manager)<br> process_manager.add_process(self.zmq_device)</code>

• Loss: <code>MatryoshkaLoss</code> with these parameters:

  {
      "loss": "CachedMultipleNegativesRankingLoss",
      "matryoshka_dims": [
          768,
          512,
          256,
          128,
          64
      ],
      "matryoshka_weights": [
          1,
          1,
          1,
          1,
          1
      ],
      "n_dims_per_step": -1
  }
  

</details> <details><summary>codesearchnet_pairs</summary>

codesearchnet_pairs

• Dataset: codesearchnet_pairs at 3f90200
• Size: 940,426 training samples
• Columns: <code>en_func_documentation_string</code>, <code>ru_func_documentation_string</code>, and <code>label</code>
• Approximate statistics based on the first 1000 samples:

  	en_func_documentation_string	ru_func_documentation_string	label
  type	string	string	float
  details	<ul><li>min: 5 tokens</li><li>mean: 102.69 tokens</li><li>max: 1485 tokens</li></ul>	<ul><li>min: 5 tokens</li><li>mean: 95.0 tokens</li><li>max: 619 tokens</li></ul>	<ul><li>min: 1.0</li><li>mean: 1.0</li><li>max: 1.0</li></ul>

• Samples:

  en_func_documentation_string	ru_func_documentation_string	label
  <code>Multiprocessing target for the zmq queue device</code>	<code>Мультипроцессинг-целевой объект для устройства очереди zmq</code>	<code>1.0</code>
  <code>Cleanly shutdown the router socket</code>	<code>Чисто завершите работу сокета роутера</code>	<code>1.0</code>
  <code>Pre-fork we need to create the zmq router device<br><br> :param func process_manager: An instance of salt.utils.process.ProcessManager</code>	<code>До форка нам нужно создать устройство zmq роутера<br><br> :param func process_manager: Экземпляр класса salt.utils.process.ProcessManager</code>	<code>1.0</code>

• Loss: <code>MatryoshkaLoss</code> with these parameters:

  {
      "loss": "CoSENTLoss",
      "matryoshka_dims": [
          768,
          512,
          256,
          128,
          64
      ],
      "matryoshka_weights": [
          1,
          1,
          1,
          1,
          1
      ],
      "n_dims_per_step": -1
  }
  

</details> <details><summary>solyanka_qa</summary>

solyanka_qa

• Dataset: solyanka_qa at deeac62
• Size: 85,523 training samples
• Columns: <code>anchor</code> and <code>positive</code>
• Approximate statistics based on the first 1000 samples:

  	anchor	positive
  type	string	string
  details	<ul><li>min: 19 tokens</li><li>mean: 202.49 tokens</li><li>max: 518 tokens</li></ul>	<ul><li>min: 16 tokens</li><li>mean: 196.36 tokens</li><li>max: 524 tokens</li></ul>

• Samples:

  anchor	positive
  <code>Как происходит взаимодействие нескольких языков программирования? Понятно, что большинство (если не все) крупные энтерпрайз сервисы, приложения и тд. (не только веб) написаны с использованием не одного языка программирования, а нескольких. И эти составные части, написанные на разных языках, как-то взаимодействуют между собой (фронт, бизнес-логика, еще что-то).<br>Опыта разработки подобных систем у меня нет, поэтому не совсем могу представить, как это происходит. Подозреваю, что взаимодействие идет через независимые от языков средства. Например, нечто написанное на одном языке, шлет через TCP-IP пакет, который ловится и обрабатывается чем-то написанным на другом языке. Либо через HTTP запросы. Либо через запись/чтение из БД. Либо через файловый обмен, XML например.<br>Хотелось бы, чтобы знающие люди привели пару примеров, как это обычно происходит. Не просто в двух словах, мол "фронт на яваскрипте, бэк на яве", а с техническими нюансами. Заранее спасибо.</code>	<code>Несколько языков могут сосуществовать как в рамках одного процесса, так и в рамках нескольких.<br>Проще всего сосуществовать в рамках нескольких процессов: если процессы обмениваются данными, то совершенно всё равно (ну, в известных рамках), на каком языке эти данные были созданы, и какой язык их читает. Например, вы можете генерировать данные в виде HTML сервером на ASP.NET, а читать браузером, написанным на C++. (Да, пара из сервера и клиента — тоже взаимодействие языков.)<br>Теперь, если мы хотим взаимодействие в рамках одного процесса, нам нужно уметь вызывать друг друга. Для этого нужен общий стандарт вызова. Часто таким общим стандартом являются бинарные соглашения C (extern "C", экспорт из DLL в Windows).<br>Ещё пример общего стандарта — COM: COM-объекты можно писать на многих языках, так что если в языке есть часть, реализующая стандарт COM, он может вполне пользоваться им.<br>Отдельная возможность, популярная сейчас — языки, компилирующиеся в общий промежуточный код. Например, Java и Sc...</code>
  <code>Слэши и ковычки после использования stringify Есть подобный скрипт:<br>[code]<br> var output = {<br> lol: [<br> {name: "hahaha"}<br> ]<br> };<br> console.log(output);<br> output = JSON.stringify(output);<br> console.log(output);<br>[/code]<br>в итоге получаем<br>почему он вставил слэши и кавычки там, где не надо?</code>	<code>Может сразу сделать валидный JSON<br>[code]<br> var output = {<br> lol: {name: "hahaha"}<br> };<br> console.log(output);<br> output = JSON.stringify(output);<br> console.log(output);<br>[/code]<br>Правда я незнаю что за переменная name</code>
  <code>Оптимизация поиска числа в списке Есть функция. Она принимает число от 1 до 9 (мы ищем, есть ли оно в списке), и список, в котором мы его ищем)<br>[code]<br> def is_number_already_in(number, line):<br> equality = False<br> for i in line:<br> if i == number:<br> equality = True<br> if equality:<br> return True<br> else:<br> return False<br>[/code]<br>Как можно этот код оптимизировать и как называется способ (тема) оптимизации, чтобы я мог загуглить<br>Только не через лямбду, пожалуйста)</code>	<code>><br>[code]<br>> if equality:<br>> return True<br>> else:<br>> return False<br>><br>[/code]<br>[code]<br> return equality<br>[/code]<br>><br>[code]<br>> equality = False<br>> for i in line:<br>> if i == number:<br>> equality = True<br>><br>[/code]<br>[code]<br> equality = any(i == number for i in line)<br>[/code]<br>Всё целиком:<br>[code]<br> def is_number_already_in(number, line):<br> return any(i == number for i in line)<br>[/code]<br>Хотя на самом деле вроде бы можно гораздо проще<br>[code]<br> def is_number_already_in(number, line):<br> return number in line<br>[/code]<br>PS: Не проверял, но в любом случае идея должна быть понятна.</code>

• Loss: <code>MatryoshkaLoss</code> with these parameters:

  {
      "loss": "CachedMultipleNegativesRankingLoss",
      "matryoshka_dims": [
          768,
          512,
          256,
          128,
          64
      ],
      "matryoshka_weights": [
          1,
          1,
          1,
          1,
          1
      ],
      "n_dims_per_step": -1
  }
  

</details>

Evaluation Datasets

<details><summary>codesearchnet</summary>

codesearchnet

• Dataset: codesearchnet at 3f90200
• Size: 30,000 evaluation samples
• Columns: <code>ru_func_documentation_string</code> and <code>func_code_string</code>
• Approximate statistics based on the first 1000 samples:

  	ru_func_documentation_string	func_code_string
  type	string	string
  details	<ul><li>min: 6 tokens</li><li>mean: 194.76 tokens</li><li>max: 1278 tokens</li></ul>	<ul><li>min: 58 tokens</li><li>mean: 580.66 tokens</li><li>max: 8192 tokens</li></ul>

• Samples:

  ru_func_documentation_string	func_code_string
  <code>Обучить модель deepq.<br><br> Параметры<br> -------<br> env: gym.Env<br> среда для обучения<br> network: строка или функция<br> нейронная сеть, используемая в качестве аппроксиматора функции Q. Если строка, она должна быть одной из имен зарегистрированных моделей в baselines.common.models<br> (mlp, cnn, conv_only). Если функция, она должна принимать тензор наблюдения и возвращать тензор скрытой переменной, которая<br> будет отображена в головы функции Q (см. build_q_func в baselines.deepq.models для деталей по этому поводу)<br> seed: int или None<br> seed генератора случайных чисел. Запуски с одинаковым seed "должны" давать одинаковые результаты. Если None, используется отсутствие семени.<br> lr: float<br> скорость обучения для оптимизатора Adam<br> total_timesteps: int<br> количество шагов среды для оптимизации<br> buffer_size: int<br> размер буфера воспроизведения<br> exploration_fraction: float<br> доля всего периода обучения, в течение которого прои...</code>	<code>def learn(env,<br> network,<br> seed=None,<br> lr=5e-4,<br> total_timesteps=100000,<br> buffer_size=50000,<br> exploration_fraction=0.1,<br> exploration_final_eps=0.02,<br> train_freq=1,<br> batch_size=32,<br> print_freq=100,<br> checkpoint_freq=10000,<br> checkpoint_path=None,<br> learning_starts=1000,<br> gamma=1.0,<br> target_network_update_freq=500,<br> prioritized_replay=False,<br> prioritized_replay_alpha=0.6,<br> prioritized_replay_beta0=0.4,<br> prioritized_replay_beta_iters=None,<br> prioritized_replay_eps=1e-6,<br> param_noise=False,<br> callback=None,<br> load_path=None,<br> **network_kwargs<br> ):<br> """Train a deepq model.<br><br> Parameters<br> -------<br> env: gym.Env<br> environment to train on<br> network: string or a function<br> neural network to use as a q function approximator. If string, has to be one of the ...</code>
  <code>Сохранить модель в pickle, расположенный по пути path</code>	<code>def save_act(self, path=None):<br> """Save model to a pickle located at path"""<br> if path is None:<br> path = os.path.join(logger.get_dir(), "model.pkl")<br><br> with tempfile.TemporaryDirectory() as td:<br> save_variables(os.path.join(td, "model"))<br> arc_name = os.path.join(td, "packed.zip")<br> with zipfile.ZipFile(arc_name, 'w') as zipf:<br> for root, dirs, files in os.walk(td):<br> for fname in files:<br> file_path = os.path.join(root, fname)<br> if file_path != arc_name:<br> zipf.write(file_path, os.path.relpath(file_path, td))<br> with open(arc_name, "rb") as f:<br> model_data = f.read()<br> with open(path, "wb") as f:<br> cloudpickle.dump((model_data, self._act_params), f)</code>
  <code>CNN из статьи Nature.</code>	<code>def nature_cnn(unscaled_images, **conv_kwargs):<br> """<br> CNN from Nature paper.<br> """<br> scaled_images = tf.cast(unscaled_images, tf.float32) / 255.<br> activ = tf.nn.relu<br> h = activ(conv(scaled_images, 'c1', nf=32, rf=8, stride=4, init_scale=np.sqrt(2),<br> **conv_kwargs))<br> h2 = activ(conv(h, 'c2', nf=64, rf=4, stride=2, init_scale=np.sqrt(2), **conv_kwargs))<br> h3 = activ(conv(h2, 'c3', nf=64, rf=3, stride=1, init_scale=np.sqrt(2), **conv_kwargs))<br> h3 = conv_to_fc(h3)<br> return activ(fc(h3, 'fc1', nh=512, init_scale=np.sqrt(2)))</code>

• Loss: <code>MatryoshkaLoss</code> with these parameters:

  {
      "loss": "CachedMultipleNegativesRankingLoss",
      "matryoshka_dims": [
          768,
          512,
          256,
          128,
          64
      ],
      "matryoshka_weights": [
          1,
          1,
          1,
          1,
          1
      ],
      "n_dims_per_step": -1
  }
  

</details> <details><summary>codesearchnet_en</summary>

codesearchnet_en

• Dataset: codesearchnet_en at 3f90200
• Size: 30,000 evaluation samples
• Columns: <code>en_func_documentation_string</code> and <code>func_code_string</code>
• Approximate statistics based on the first 1000 samples: | | en_func_documentation_string | func_code_string |

The model card is truncated. Read the rest on Hugging Face.