
    Ch                        S SK Jr  S SKJr  S SKJr  S SKJr  S SKJ	s  J
r  S SKJrJ	r	  S SKJr  S SKJrJrJr   " S	 S
\5      r " S S\	R*                  5      rg)    )annotations)Iterable)Enum)AnyN)Tensornn)SentenceTransformer)pairwise_cos_simpairwise_euclidean_simpairwise_manhattan_simc                  *    \ rS rSrSrS rS rS rSrg)TripletDistanceMetric   zThe metric for the triplet lossc                    S[        X5      -
  $ )N   )r
   xys     `/var/www/html/shao/venv/lib/python3.13/site-packages/sentence_transformers/losses/TripletLoss.py<lambda>TripletDistanceMetric.<lambda>   s    !.q44    c                    [        X5      $ N)r   r   s     r   r   r      
    3A9r   c                    [        X5      $ r   )r   r   s     r   r   r      r   r    N)	__name__
__module____qualname____firstlineno____doc__COSINE	EUCLIDEAN	MANHATTAN__static_attributes__r   r   r   r   r      s    )4F9I9Ir   r   c                     ^  \ rS rSr\R
                  S4     S	U 4S jjjrS
S jrSS jrSS jr	\
SS j5       rSrU =r$ )TripletLoss      c                F   > [         TU ]  5         Xl        X l        X0l        g)ad  
This class implements triplet loss. Given a triplet of (anchor, positive, negative),
the loss minimizes the distance between anchor and positive while it maximizes the distance
between anchor and negative. It compute the following loss function:

``loss = max(||anchor - positive|| - ||anchor - negative|| + margin, 0)``.

Margin is an important hyperparameter and needs to be tuned respectively.

Args:
    model: SentenceTransformerModel
    distance_metric: Function to compute distance between two
        embeddings. The class TripletDistanceMetric contains
        common distance metrices that can be used.
    triplet_margin: The negative should be at least this much
        further away from the anchor than the positive.

References:
    - For further details, see: https://en.wikipedia.org/wiki/Triplet_loss

Requirements:
    1. (anchor, positive, negative) triplets

Inputs:
    +---------------------------------------+--------+
    | Texts                                 | Labels |
    +=======================================+========+
    | (anchor, positive, negative) triplets | none   |
    +---------------------------------------+--------+

Example:
    ::

        from sentence_transformers import SentenceTransformer, SentenceTransformerTrainer, losses
        from datasets import Dataset

        model = SentenceTransformer("microsoft/mpnet-base")
        train_dataset = Dataset.from_dict({
            "anchor": ["It's nice weather outside today.", "He drove to work."],
            "positive": ["It's so sunny.", "He took the car to the office."],
            "negative": ["It's quite rainy, sadly.", "She walked to the store."],
        })
        loss = losses.TripletLoss(model=model)

        trainer = SentenceTransformerTrainer(
            model=model,
            train_dataset=train_dataset,
            loss=loss,
        )
        trainer.train()
N)super__init__modeldistance_metrictriplet_margin)selfr.   r/   r0   	__class__s       r   r-   TripletLoss.__init__   s"    l 	
.,r   c                r    U Vs/ sH  o0R                  U5      S   PM     nnU R                  XB5      $ s  snf )Nsentence_embedding)r.   compute_loss_from_embeddings)r1   sentence_featureslabelssentence_feature
embeddingss        r   forwardTripletLoss.forwardR   s>    arsarM]jj!123GHar
s00DD ts   4c                    Uu  p4nU R                  X45      nU R                  X55      n[        R                  " Xg-
  U R                  -   5      nUR	                  5       $ )zm
Compute the CoSENT loss from embeddings.

Args:
    embeddings: List of embeddings

Returns:
    Loss value
)r/   Frelur0   mean)	r1   r:   r8   
rep_anchorrep_posrep_negdistance_posdistance_neglossess	            r   r6   (TripletLoss.compute_loss_from_embeddingsW   sV     (2$
W++J@++J@3d6I6IIJ{{}r   c                    U R                   R                  n[        [        5      R	                  5        H  u  p#X0R                   :X  d  M  SU 3n  O   XR
                  S.$ )NzTripletDistanceMetric.)r/   r0   )r/   r   varsr   itemsr0   )r1   distance_metric_namenamevalues       r   get_config_dictTripletLoss.get_config_dicth   s\    #33<< 56<<>KD,,,)?v'F$ ?
 $8K^K^__r   c                    g)Na  
@misc{hermans2017defense,
    title={In Defense of the Triplet Loss for Person Re-Identification},
    author={Alexander Hermans and Lucas Beyer and Bastian Leibe},
    year={2017},
    eprint={1703.07737},
    archivePrefix={arXiv},
    primaryClass={cs.CV}
}
r   )r1   s    r   citationTripletLoss.citationq   s    	r   )r/   r.   r0   )r.   r	   r0   floatreturnNone)r7   zIterable[dict[str, Tensor]]r8   r   rT   r   )r:   zlist[Tensor]r8   r   rT   r   )rT   zdict[str, Any])rT   str)r   r   r    r!   r   r$   r-   r;   r6   rN   propertyrQ   r&   __classcell__)r2   s   @r   r(   r(      sW    :O:Y:Yst9-(9-kp9-	9- 9-vE
"` 
 
r   r(   )
__future__r   collections.abcr   enumr   typingr   torch.nn.functionalr   
functionalr>   torchr   )sentence_transformers.SentenceTransformerr	   sentence_transformers.utilr
   r   r   r   Moduler(   r   r   r   <module>rc      sA    " $      I g g:D :f")) fr   