Model: JacobLinCool/Qwen3-Embedding-0.6B-GIR-1
Author: JacobLinCool
Pipeline: sentence-similarity
Library: sentence-transformers
Tags: sentence-transformers, tensorboard, safetensors, qwen3, sentence-similarity, feature-extraction, dense, generated_from_trainer, dataset_size:400, loss:MultipleNegativesRankingLoss, arxiv:1908.10084, arxiv:1705.00652, base_model:Qwen/Qwen3-Embedding-0.6B, base_model:finetune:Qwen/Qwen3-Embedding-0.6B, model-index, endpoints_compatible, region:us
Base models (finetune): id: Qwen/Qwen3-Embedding-0.6B
Card metadata: tags: sentence-transformers, sentence-similarity, feature-extraction, dense, generated_from_trainer, dataset_size:400, loss:MultipleNegativesRankingLoss
base_model: Qwen/Qwen3-Embedding-0.6B
widget: source_sentence: Wrapper for calling the clean method of services attribute

        :return: None
sentences: def import_from_nhmmer_table(hmmout_path):
        
        
        
        
        res=HMMSearchResult()
        res.fields = [
                       SequenceSearchResult.QUERY_ID_FIELD,
                       SequenceSearchResult.HMM_NAME_FIELD,
                       SequenceSearchResult.ALIGNMENT_LENGTH_FIELD,
                       SequenceSearchResult.QUERY_FROM_FIELD,
                       SequenceSearchResult.QUERY_TO_FIELD,
                       SequenceSearchResult.HIT_FROM_FIELD,
                       SequenceSearchResult.HIT_TO_FIELD,
                       SequenceSearchResult.ALIGNMENT_BIT_SCORE,
                       SequenceSearchResult.ALIGNMENT_DIRECTION,
                       ]
        
        for row in [x.rstrip().split() for x in open(hmmout_path) if not x.startswith()]:
            alifrom    = int(row[6])
            alito      = int(row[7])
            aln_length = (alito-alifrom if alito-alifrom>0 else alifrom-alito)
            res.results.append([row[0],
                                row[2],
                                aln_length,
                                int(row[4]),
                                int(row[5]),
                                alifrom,
                                alito,
                                row[13],
                                alito > alifrom
                                ])
        return res, def clean(self):
        
        logger.debug("Cleaning configuration objects before configuration sending:")
        types_creations = self.__class__.types_creations
        for o_type in types_creations:
            (_, _, inner_property, _, _) = types_creations[o_type]
            logger.debug("  . for %s", inner_property, )
            inner_object = getattr(self, inner_property)
            inner_object.clean(), def index_modules(idx=None, path=None):
    
    suppress_output()
    modules = defaultdict(list)
    pkglist = pkgutil.walk_packages(onerror=lambda x: True)
    print(pkglist)
    if path:
        pkglist = pkgutil.walk_packages(path, onerror=lambda x: True)
    for modl, name, ispkg in pkglist:
        try:
            path = os.path.join(modl.path, name.split()[-1])
        except AttributeError:
            
            continue

        if os.path.isdir(path):
            path = os.path.join(path, )
        path += 

        objs = []

        if os.path.exists(path):
            try:
                objs = read_objs_from_path(path)
            except:
                continue
        elif not re.search(MODULE_BLACKLIST, name):
            try:
                mod = __import__(name)
                objs = [k for k in dir(mod) if not k.startswith()]
            except:
                continue
        else:
            continue

        for obj in objs:
            if name not in modules[obj]:
                modules[obj].append(name)
    suppress_output(True)
    return merge_dicts(idx, dict(modules)), source_sentence: Try to import the aeneas package and return ``True`` if that fails.
sentences: def check_import():
    
    try:
        import aeneas
        print_success(u"aeneas         OK")
        return False
    except ImportError:
        print_error(u"aeneas         ERROR")
        print_info(u"  Unable to load the aeneas Python package")
        print_info(u"  This error is probably caused by:")
        print_info(u"    A. you did not download/git-clone the aeneas package properly; or")
        print_info(u"    B. you did not install the required Python packages:")
        print_info(u"      1. BeautifulSoup4")
        print_info(u"      2. lxml")
        print_info(u"      3. numpy")
    except Exception as e:
        print_error(e)
    return True, def simplify(source, kink=20):
    
    source_coord = map(lambda o: {"lng": o.coordinates[0], "lat": o.coordinates[1]}, source)

    
    
    
    F = (math.pi / 180.0) * 0.5
    index = [] 
    sig_start = [] 
    sig_end = []

    
    count = len(source_coord)
    if count < 3:
        return source_coord 

    

    band_sqr = kink * 360.0 / (2.0 * math.pi * 6378137.0) 
    band_sqr *= band_sqr
    n_dest = 0
    sig_start[0] = 0
    sig_end[0] = count - 1
    n_stack = 1

    
    while n_stack > 0:
        
        start = sig_start[n_stack - 1]
        end = sig_end[n_stack - 1]
        n_stack -= 1

        if (end - start) > 1: 
            
            x12 = source[end]["lng"] - source[start]["lng"]
            y12 = source[end]["lat"] - source[start]["lat"]
            if math.fabs(x12) > 180.0:
                x12 = 360.0 - math.fabs(x12)
            x12 *= math.cos(F * (source[end]["lat"] + source[start]["lat"])) 
            d12 = (x12 * x12) + (y12 * y12)

            i = start + 1
            sig = start
            max_dev_sqr = -1.0
            while i < end:
                x13 = source[i]["lng"] - source[start]["lng"]
                y13 = source[i]["lat"] - source[start]["lat"]
                if math.fabs(x13) > 180.0:
                    x13 = 360.0 - math.fabs(x13)
                x13 *= math.cos(F * (source[i]["lat"] + source[start]["lat"]))
                d13 = (x13 * x13) + (y13 * y13)
                x23 = source[i]["lng"] - source[end]["lng"]
                y23 = source[i]["lat"] - source[end]["lat"]
                if math.fabs(x23) > 180.0:
                    x23 = 360.0 - math.fabs(x23)
                x23 *= math.cos(F * (source[i]["lat"] + source[end]["lat"]))
                d23 = (x23 * x23) + (y23 * y23)

                if d13 >= (d12 + d23):
                    dev_sqr = d23
                elif d23 >= (d12 + d13):
                    dev_sqr = d13
                else:
                    dev_sqr = (x13 * y12 - y13 * x12) * (x13 * y12 - y13 * x12) / d12 
                if dev_sqr > max_dev_sqr:
                    sig = i
                    max_dev_sqr = dev_sqr
                i += 1


            if max_dev_sqr < band_sqr: 
            
                index[n_dest] = start
                n_dest += 1
            else: 
                n_stack += 1
                sig_start[n_stack - 1] = sig
                sig_end[n_stack - 1] = end
                n_stack += 1
                sig_start[n_stack - 1] = start
                sig_end[n_stack - 1] = sig

        else:  
            index[n_dest] = start
            n_dest += 1

    
    index[n_dest] = count - 1
    n_dest += 1

    
    r = []
    for i in range(0, n_dest):
        r.append(source_coord[index[i]])

    return map(lambda o:  {"type": "Point","coordinates": [o.lng, o.lat]}, r), def smooth(data, fw):
    
    if fw == 0:
        fdata = data
    else:
        fdata = lfilter(np.ones(fw)/fw, 1, data)
    return fdata, source_sentence: Start response processing.
sentences: async def start(self, connection: ) -> :
        
        self._closed = False
        self._protocol = connection.protocol
        self._connection = connection

        with self._timer:
            while True:
                
                try:
                    message, payload = await self._protocol.read()  
                except http.HttpProcessingError as exc:
                    raise ClientResponseError(
                        self.request_info, self.history,
                        status=exc.code,
                        message=exc.message, headers=exc.headers) from exc

                if (message.code < 100 or
                        message.code > 199 or message.code == 101):
                    break

                if self._continue is not None:
                    set_result(self._continue, True)
                    self._continue = None

        
        payload.on_eof(self._response_eof)

        
        self.version = message.version
        self.status = message.code
        self.reason = message.reason

        
        self._headers = message.headers  
        self._raw_headers = message.raw_headers  

        
        self.content = payload

        
        for hdr in self.headers.getall(hdrs.SET_COOKIE, ()):
            try:
                self.cookies.load(hdr)
            except CookieError as exc:
                client_logger.warning(
                    , exc)
        return self, def solve(self, verbose=False, allow_brute_force=True):
        
        while not self.is_solved:
            
            self._update()

            
            singles_found = False or self._fill_naked_singles() or self._fill_hidden_singles()

            
            
            
            if not singles_found:
                if allow_brute_force:
                    solution = None
                    try:
                        dlxs = DancingLinksSolver(copy.deepcopy(self._matrix))
                        solutions = dlxs.solve()
                        solution = next(solutions)
                        more_solutions = next(solutions)
                    except StopIteration as e:
                        if solution is not None:
                            self._matrix = solution
                        else:
                            raise SudokuHasNoSolutionError("Dancing Links solver could not find any solution.")
                    except Exception as e:
                        raise SudokuHasNoSolutionError("Brute Force method failed.")
                    else:
                        
                        
                        raise SudokuHasMultipleSolutionsError("This Sudoku has multiple solutions!")
                    self.solution_steps.append("BRUTE FORCE - Dancing Links")
                    break
                else:
                    print(self)
                    raise SudokuTooDifficultError("This Sudoku requires more advanced methods!")
        if verbose:
            print("Sudoku solved in {0} iterations!\n{1}".format(len(self.solution_steps), self))
            for step in self.solution_steps:
                print(step), def get_peer_ips(self):
        
        presponse = [ord(i) for i in self.tracker_response[]]
        while presponse:
            peer_ip = ((.join(str(x) for x in presponse[0:4]),
                       256 * presponse[4] + presponse[5]))
            if peer_ip not in self.peer_ips:
                self.peer_ips.append(peer_ip)
            presponse = presponse[6:], source_sentence: Setter method for ipv6_phy_intf_cmds, mapped from YANG variable /interface/fortygigabitethernet/ipv6/ipv6_phy_intf_cmds (container)
    If this variable is read-only (config: false) in the
    source YANG file, then _set_ipv6_phy_intf_cmds is considered as a private
    method. Backends looking to populate this variable should
    do so via calling thisObj._set_ipv6_phy_intf_cmds() directly.
sentences: def _trim_xpath(self, xpath, prop):
        

        xroot = self._get_xroot_for(prop)

        if xroot is None and isinstance(xpath, string_types):
            xtags = xpath.split(XPATH_DELIM)

            if xtags[-1] in _iso_tag_primitives:
                xroot = XPATH_DELIM.join(xtags[:-1])

        return xroot, def _set_ipv6_phy_intf_cmds(self, v, load=False):
    
    if hasattr(v, "_utype"):
      v = v._utype(v)
    try:
      t = YANGDynClass(v,base=ipv6_phy_intf_cmds.ipv6_phy_intf_cmds, is_container=, presence=False, yang_name="ipv6-phy-intf-cmds", rest_name="", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u: {u: u, u: None, u: u}}, namespace=, defining_module=, yang_type=, is_config=True)
    except (TypeError, ValueError):
      raise ValueError({
          : ,
          : "container",
          : ,
        })

    self.__ipv6_phy_intf_cmds = t
    if hasattr(self, ):
      self._set(), def create_snapshot(self, xml_bytes):
        
        root = XML(xml_bytes)
        snapshot_id = root.findtext("snapshotId")
        volume_id = root.findtext("volumeId")
        status = root.findtext("status")
        start_time = root.findtext("startTime")
        start_time = datetime.strptime(
            start_time[:19], "%Y-%m-%dT%H:%M:%S")
        progress = root.findtext("progress")[:-1]
        progress = float(progress or "0") / 100.
        return model.Snapshot(
            snapshot_id, volume_id, status, start_time, progress), source_sentence: Generates samples of text from the provided vocabulary.

  Args:
    plain_vocab: vocabulary.
    distribution: distribution.
    train_samples: samples for training.
    length: length.

  Returns:
    train_indices (np.array of Integers): random integers for training.
      shape = [num_samples, length]
    test_indices (np.array of Integers): random integers for testing.
      shape = [num_samples, length]
    plain_vocab   (list of Integers): unique vocabularies.
sentences: def late_filling(target, pressure=,
                 Pc_star=,
                 Swp_star=0.2, eta=3):
    r
    element = pressure.split()[0]
    network = target.project.network
    phase = target.project.find_phase(target)
    pc_star = phase[Pc_star]
    Pc = phase[pressure]
    
        Ts = network.map_throats(throats=target.Ts, origin=target)
        values = values[Ts]
    else:
        Ps = network.map_pores(pores=target.Ps, origin=target)
        values = values[Ps]
    return values, def switch(self, name):
        
        try:
            switch = self.storage[self.__namespaced(name)]
        except KeyError:
            if not self.autocreate:
                raise ValueError("No switch named  registered in " % (name, self.namespace))

            switch = self.__create_and_register_disabled_switch(name)

        switch.manager = self
        return switch, def generate_plaintext_random(plain_vocab, distribution, train_samples,
                              length):
  
  if distribution is not None:
    assert len(distribution) == len(plain_vocab)

  train_indices = np.random.choice(
      range(len(plain_vocab)), (train_samples, length), p=distribution)

  return train_indices
pipeline_tag: sentence-similarity
library_name: sentence-transformers
metrics: cosine_accuracy@1, 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@1, cosine_ndcg@5, cosine_ndcg@10, cosine_mrr@1, cosine_mrr@5, cosine_mrr@10, cosine_map@100
model-index: name: SentenceTransformer based on Qwen/Qwen3-Embedding-0.6B
results: task: type: information-retrieval
name: Information Retrieval
dataset: name: Unknown
type: unknown
metrics: type: cosine_accuracy@1
value: 0.99
name: Cosine Accuracy@1
verified: no, type: cosine_accuracy@5
value: 1
name: Cosine Accuracy@5
verified: no, type: cosine_accuracy@10
value: 1
name: Cosine Accuracy@10
verified: no, type: cosine_precision@1
value: 0.99
name: Cosine Precision@1
verified: no, type: cosine_precision@3
value: 0.3333333333333334
name: Cosine Precision@3
verified: no, type: cosine_precision@5
value: 0.19999999999999996
name: Cosine Precision@5
verified: no, type: cosine_precision@10
value: 0.09999999999999998
name: Cosine Precision@10
verified: no, type: cosine_recall@1
value: 0.99
name: Cosine Recall@1
verified: no, type: cosine_recall@3
value: 1
name: Cosine Recall@3
verified: no, type: cosine_recall@5
value: 1
name: Cosine Recall@5
verified: no, type: cosine_recall@10
value: 1
name: Cosine Recall@10
verified: no, type: cosine_ndcg@1
value: 0.99
name: Cosine Ndcg@1
verified: no, type: cosine_ndcg@5
value: 0.9963092975357145
name: Cosine Ndcg@5
verified: no, type: cosine_ndcg@10
value: 0.9963092975357145
name: Cosine Ndcg@10
verified: no, type: cosine_mrr@1
value: 0.99
name: Cosine Mrr@1
verified: no, type: cosine_mrr@5
value: 0.995
name: Cosine Mrr@5
verified: no, type: cosine_mrr@10
value: 0.995
name: Cosine Mrr@10
verified: no, type: cosine_map@100
value: 0.995
name: Cosine Map@100
verified: no
Likes: 0 | All-time downloads: 61
Created: 2025-09-30 16:11:39